Histogram: Fixed random value of 256th index. Missed one int with std::fill.

[kdenlive] / src / colorcorrection / rgbparadegenerator.cpp

diff --git a/src/colorcorrection/rgbparadegenerator.cpp b/src/colorcorrection/rgbparadegenerator.cpp
index fe494e8399f1f62ca718a96f8abfa754af22682f..222749c3333cb86d32f8e6d2cc20f1c49e3061c1 100644 (file)
--- a/src/colorcorrection/rgbparadegenerator.cpp
+++ b/src/colorcorrection/rgbparadegenerator.cpp
@@ -11,7 +11,6 @@
 #include "rgbparadegenerator.h"
 
 #include <QColor>
-#include <QDebug>
 #include <QPainter>
 #include <QPoint>
 #include <QTime>
@@ -26,20 +25,17 @@ RGBParadeGenerator::RGBParadeGenerator()
 {
 }
 
-QImage RGBParadeGenerator::calculateRGBParade(const QSize &paradeSize, const QImage &image, const bool &drawAxis, const uint &accelFactor)
+QImage RGBParadeGenerator::calculateRGBParade(const QSize &paradeSize, const QImage &image,
+                                              const RGBParadeGenerator::PaintMode paintMode, const bool &drawAxis, 
+                                              const bool &drawGradientRef, const uint &accelFactor)
 {
     Q_ASSERT(accelFactor >= 1);
 
-    QImage parade(paradeSize, QImage::Format_ARGB32);
-
-    if (paradeSize.width() <= 0 || paradeSize.height() <= 0) {
-        qCritical("Wave size should not be 0.");
+    if (paradeSize.width() <= 0 || paradeSize.height() <= 0 || image.width() <= 0 || image.height() <= 0) {
+        return QImage();
 
     } else {
-
-        qDebug() << "Wave calculation started.";
-
-        // Fill with transparent color
+        QImage parade(paradeSize, QImage::Format_ARGB32);
         parade.fill(qRgba(0,0,0,0));
 
         QRgb *col;
@@ -69,9 +65,12 @@ QImage RGBParadeGenerator::calculateRGBParade(const QSize &paradeSize, const QIm
         const int vm = weaken*18;
         const int vl = weaken*9;
 
+        // Divide by 3 because of the 3 components
+        const float brightnessAdjustment = accelFactor * ((float) ww*wh/(byteCount>>3)) / 3;
+
         uchar minR = 255, minG = 255, minB = 255, maxR = 0, maxG = 0, maxB = 0, r, g, b;
-        qDebug() << "Expecting about " << avgPxPerPx << " pixels per pixel in the RGB parade. Weakening by " << weaken
-                << " with an acceleration factor of " << accelFactor;
+//        qDebug() << "Expecting about " << avgPxPerPx << " pixels per pixel in the RGB parade. Weakening by " << weaken
+//                << " with an acceleration factor of " << accelFactor;
 
 
         QImage unscaled(ww-right, 256, QImage::Format_ARGB32);
@@ -93,18 +92,39 @@ QImage RGBParadeGenerator::calculateRGBParade(const QSize &paradeSize, const QIm
 
             paradePoint = QPoint((int)dx, r);
             paradeCol = QRgb(unscaled.pixel(paradePoint));
-            unscaled.setPixel(paradePoint, qRgba(CHOP255(vh + qRed(paradeCol)), CHOP255(vm + qGreen(paradeCol)),
-                                           CHOP255(vl + qBlue(paradeCol)), 255));
+            switch(paintMode) {
+            case PaintMode_RGB2:
+                unscaled.setPixel(paradePoint, qRgba(CHOP255(vh + qRed(paradeCol)), CHOP255(vm + qGreen(paradeCol)),
+                                                     CHOP255(vl + qBlue(paradeCol)), 255));
+                break;
+            default:
+                unscaled.setPixel(paradePoint, qRgba(255,0,0, CHOP255(brightnessAdjustment*16 + qAlpha(paradeCol))));
+                break;
+            }
 
             paradePoint = QPoint((int) (dx + partW + offset), g);
             paradeCol = QRgb(unscaled.pixel(paradePoint));
-            unscaled.setPixel(paradePoint, qRgba(CHOP255(vl + qRed(paradeCol)), CHOP255(vh + qGreen(paradeCol)),
-                                           CHOP255(vm + qBlue(paradeCol)), 255));
+            switch(paintMode) {
+            case PaintMode_RGB2:
+                unscaled.setPixel(paradePoint, qRgba(CHOP255(vl + qRed(paradeCol)), CHOP255(vh + qGreen(paradeCol)),
+                                               CHOP255(vm + qBlue(paradeCol)), 255));
+                break;
+            default:
+                unscaled.setPixel(paradePoint, qRgba(0,255,0, CHOP255(brightnessAdjustment*16 + qAlpha(paradeCol))));
+                break;
+            }
 
             paradePoint = QPoint((int) (dx + 2*partW + 2*offset), b);
             paradeCol = QRgb(unscaled.pixel(paradePoint));
-            unscaled.setPixel(paradePoint, qRgba(CHOP255(vm + qRed(paradeCol)), CHOP255(vl + qGreen(paradeCol)),
-                                           CHOP255(vh + qBlue(paradeCol)), 255));
+            switch(paintMode) {
+            case PaintMode_RGB2:
+                unscaled.setPixel(paradePoint, qRgba(CHOP255(vm + qRed(paradeCol)), CHOP255(vl + qGreen(paradeCol)),
+                                               CHOP255(vh + qBlue(paradeCol)), 255));
+                break;
+            default:
+                unscaled.setPixel(paradePoint, qRgba(0,0,255, CHOP255(brightnessAdjustment*16 + qAlpha(paradeCol))));
+                break;
+            }
 
 
             if (r < minR) { minR = r; }
@@ -134,6 +154,13 @@ QImage RGBParadeGenerator::calculateRGBParade(const QSize &paradeSize, const QIm
                 }
             }
         }
+        
+        if (drawGradientRef) {
+            davinci.setPen(colLight);
+            davinci.drawLine(0                 ,partH,   partW,           0);
+            davinci.drawLine(  partW +   offset,partH, 2*partW +   offset,0);
+            davinci.drawLine(2*partW + 2*offset,partH, 3*partW + 2*offset,0);
+        }
 
 
         const int d = 50;
@@ -168,10 +195,8 @@ QImage RGBParadeGenerator::calculateRGBParade(const QSize &paradeSize, const QIm
 
 
 
-
+        return parade;
     }
-
-    return parade;
 }
 
 #undef CHOP255