Show progress while loading project

[kdenlive] / src / colortools.cpp

diff --git a/src/colortools.cpp b/src/colortools.cpp
index cc49e9ef451bbd6dbcb27e63d2a1f73a0a8b784b..6e44a33473f9a5f02759aab215671e2c86debf3a 100644 (file)
--- a/src/colortools.cpp
+++ b/src/colortools.cpp
@@ -17,14 +17,16 @@ ColorTools::ColorTools()
 
 
 
-QImage ColorTools::yuvColorWheel(const QSize &size, unsigned char Y, float scaling, bool modifiedVersion, bool circleOnly)
+QImage ColorTools::yuvColorWheel(const QSize &size, const unsigned char &Y, const float &scaling, const bool &modifiedVersion, const bool &circleOnly)
 {
     QImage wheel(size, QImage::Format_ARGB32);
     if (size.width() == 0 || size.height() == 0) {
         qCritical("ERROR: Size of the color wheel must not be 0!");
         return wheel;
     }
-    wheel.fill(qRgba(0,0,0,0));
+    if (circleOnly) {
+        wheel.fill(qRgba(0,0,0,0));
+    }
 
     double dr, dg, db, du, dv, dmax;
     double ru, rv, rr;
@@ -86,6 +88,161 @@ QImage ColorTools::yuvColorWheel(const QSize &size, unsigned char Y, float scali
         }
     }
 
-    emit signalWheelCalculationFinished();
+    emit signalYuvWheelCalculationFinished();
     return wheel;
 }
+
+QImage ColorTools::yuvVerticalPlane(const QSize &size, const float &angle, const float &scaling)
+{
+    QImage plane(size, QImage::Format_ARGB32);
+    if (size.width() == 0 || size.height() == 0) {
+        qCritical("ERROR: Size of the color plane must not be 0!");
+        return plane;
+    }
+
+    double dr, dg, db, du, dv, Y;
+    const int w = size.width();
+    const int h = size.height();
+    const double uscaling = scaling*cos(M_PI*angle/180);
+    const double vscaling = scaling*sin(M_PI*angle/180);
+
+    for (int uv = 0; uv < w; uv++) {
+        du = uscaling*((double)2*uv/w - 1);//(double)?
+        dv = vscaling*((double)2*uv/w - 1);
+
+        for (int y = 0; y < h; y++) {
+            Y = (double)255*y/h;
+
+            // See yuv2rgb, yuvColorWheel
+            dr = Y + 290.8*dv;
+            dg = Y - 100.6*du - 148*dv;
+            db = Y + 517.2*du;
+            if (dr < 0) dr = 0;
+            if (dg < 0) dg = 0;
+            if (db < 0) db = 0;
+            if (dr > 255) dr = 255;
+            if (dg > 255) dg = 255;
+            if (db > 255) db = 255;
+
+            plane.setPixel(uv, (h-y-1), qRgba(dr, dg, db, 255));
+
+        }
+    }
+
+
+    return plane;
+
+}
+
+QImage ColorTools::rgbCurvePlane(const QSize &size, const ColorTools::ColorsRGB &color, float scaling)
+{
+    Q_ASSERT(scaling > 0 && scaling <= 1);
+
+    QImage plane(size, QImage::Format_ARGB32);
+    if (size.width() == 0 || size.height() == 0) {
+        qCritical("ERROR: Size of the color plane must not be 0!");
+        return plane;
+    }
+
+    const int w = size.width();
+    const int h = size.height();
+
+    double dcol, dval;
+    double dx, dy;
+
+    for (int x = 0; x < w; x++) {
+        dval = (double)255*x/(w-1);
+
+        for (int y = 0; y < h; y++) {
+            dy = (double)y/(h-1);
+            dx = (double)x/(w-1);
+
+            if (1-scaling < 0.0001) {
+                dcol = (double)255*dy;
+            } else {
+                dcol = (double)255 * (dy - (dy-dx)*(1-scaling));
+            }
+
+            if (color == ColorTools::COL_R) {
+                plane.setPixel(x, (h-y-1), qRgb(dcol, dval, dval));
+            } else if (color == ColorTools::COL_G) {
+                plane.setPixel(x, (h-y-1), qRgb(dval, dcol, dval));
+            } else if (color == ColorTools::COL_B){
+                plane.setPixel(x, (h-y-1), qRgb(dval, dval, dcol));
+            } else {
+                plane.setPixel(x, (h-y-1), qRgb(dcol, dcol, dcol));
+            }
+
+        }
+    }
+    return plane;
+}
+
+QImage ColorTools::yPbPrColorWheel(const QSize &size, const unsigned char &Y, const float &scaling, const bool &circleOnly)
+{
+
+    QImage wheel(size, QImage::Format_ARGB32);
+    if (size.width() == 0 || size.height() == 0) {
+        qCritical("ERROR: Size of the color wheel must not be 0!");
+        return wheel;
+    }
+    if (circleOnly) {
+        wheel.fill(qRgba(0,0,0,0));
+    }
+
+    double dr, dg, db, dpB, dpR;
+    double rB, rR, rr;
+    const int w = size.width();
+    const int h = size.height();
+    const float w2 = (float)w/2;
+    const float h2 = (float)h/2;
+
+    for (int b = 0; b < w; b++) {
+        // Transform pB from {0,...,w} to [-0.5,0.5]
+        dpB = (double) b/(w-1) - .5;
+        dpB = scaling*dpB;
+
+        for (int r = 0; r < h; r++) {
+            dpR = (double) r/(h-1) - .5;
+            dpR = scaling*dpR;
+
+            if (circleOnly) {
+                // see yuvColorWheel
+                rB = b - w2;
+                rR = r - h2;
+                rr = rB*rB/(w2*w2) + rR*rR/(h2*h2);
+                if (rr > 1) {
+                    continue;
+                }
+            }
+
+            // Calculate the RGB values from YPbPr
+            dr = Y + 357.5*dpR;
+            dg = Y - 87.75*dpB - 182.1*dpR;
+            db = Y + 451.86*dpB;
+
+            // Avoid overflows (which would generate intersting patterns).
+            // Note that not all possible (y,u,v) values with u,v \in [-1,1]
+            // have a correct RGB representation, therefore some RGB values
+            // may exceed {0,...,255}.
+            if (dr < 0) dr = 0;
+            if (dg < 0) dg = 0;
+            if (db < 0) db = 0;
+            if (dr > 255) dr = 255;
+            if (dg > 255) dg = 255;
+            if (db > 255) db = 255;
+
+            wheel.setPixel(b, (h-r-1), qRgba(dr, dg, db, 255));
+        }
+    }
+
+    return wheel;
+}
+
+
+
+
+
+
+
+