git.sesse.net Git - kdenlive/blob - src/colorcorrection/histogramgenerator.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2010 by Simon Andreas Eugster (simon.eu@gmail.com)      *
   3  *   This file is part of kdenlive. See www.kdenlive.org.                  *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  ***************************************************************************/
  10
  11 #include <algorithm>
  12 #include <math.h>
  13 #include <QImage>
  14 #include <QPainter>
  15 #include <KLocale>
  16 #include "histogramgenerator.h"
  17
  18 HistogramGenerator::HistogramGenerator()
  19 {
  20 }
  21
  22 QImage HistogramGenerator::calculateHistogram(const QSize &paradeSize, const QImage &image, const int &components,
  23                                               HistogramGenerator::Rec rec, bool unscaled, uint accelFactor) const
  24 {
  25     if (paradeSize.height() <= 0 || paradeSize.width() <= 0 || image.width() <= 0 || image.height() <= 0) {
  26         return QImage();
  27     }
  28
  29     bool drawY = (components & HistogramGenerator::ComponentY) != 0;
  30     bool drawR = (components & HistogramGenerator::ComponentR) != 0;
  31     bool drawG = (components & HistogramGenerator::ComponentG) != 0;
  32     bool drawB = (components & HistogramGenerator::ComponentB) != 0;
  33     bool drawSum = (components & HistogramGenerator::ComponentSum) != 0;
  34
  35     int r[256], g[256], b[256], y[256], s[766];
  36     // Initialize the values to zero
  37     std::fill(r, r+256, 0);
  38     std::fill(g, g+256, 0);
  39     std::fill(b, b+256, 0);
  40     std::fill(y, y+256, 0);
  41     std::fill(s, s+766, 0);
  42
  43     const uint iw = image.bytesPerLine();
  44     const uint ih = image.height();
  45     const uint ww = paradeSize.width();
  46     const uint wh = paradeSize.height();
  47     const uint byteCount = iw*ih;
  48     const uint stepsize = image.depth() / 8 *accelFactor;
  49
  50     const uchar *bits = image.bits();
  51     QRgb *col;
  52
  53
  54     // Read the stats from the input image
  55     for (uint i = 0; i < byteCount; i += stepsize) {
  56         col = (QRgb *)bits;
  57
  58         r[qRed(*col)]++;
  59         g[qGreen(*col)]++;
  60         b[qBlue(*col)]++;
  61         if (drawY) {
  62             // Use if branch to avoid expensive multiplication if Y disabled
  63             if (rec == HistogramGenerator::Rec_601) {
  64                 y[(int)floor(.299*qRed(*col) + .587*qGreen(*col) + .114*qBlue(*col))]++;
  65             } else {
  66                 y[(int)floor(.2125*qRed(*col) + .7154*qGreen(*col) + .0721*qBlue(*col))]++;
  67             }
  68         }
  69         if (drawSum) {
  70             // Use an if branch here because the sum takes more operations than rgb
  71             s[qRed(*col)]++;
  72             s[qGreen(*col)]++;
  73             s[qBlue(*col)]++;
  74         }
  75
  76         bits += stepsize;
  77     }
  78
  79
  80     const int nParts = (drawY ? 1 : 0) + (drawR ? 1 : 0) + (drawG ? 1 : 0) + (drawB ? 1 : 0) + (drawSum ? 1 : 0);
  81     if (nParts == 0) {
  82         // Nothing to draw
  83         return QImage();
  84     }
  85
  86     const int d = 20; // Distance for text
  87     const int partH = (wh-nParts*d)/nParts;
  88     float scaling = 0;
  89     int div = byteCount >> 7;
  90     if ( div > 0 )
  91         scaling = (float)partH/(byteCount >> 7);
  92     const int dist = 40;
  93
  94     int wy = 0; // Drawing position
  95
  96     QImage histogram(paradeSize, QImage::Format_ARGB32);
  97     QPainter davinci(&histogram);
  98     davinci.setPen(QColor(220, 220, 220, 255));
  99     histogram.fill(qRgba(0, 0, 0, 0));
 100
 101     if (drawY) {
 102         drawComponentFull(&davinci, y, scaling, QRect(0, wy, ww, partH + dist), QColor(220, 220, 210, 255), dist, unscaled, 256);
 103
 104         wy += partH + d;
 105     }
 106
 107     if (drawSum) {
 108         drawComponentFull(&davinci, s, scaling/3, QRect(0, wy, ww, partH + dist), QColor(220, 220, 210, 255), dist, unscaled, 256);
 109
 110         wy += partH + d;
 111     }
 112
 113     if (drawR) {
 114         drawComponentFull(&davinci, r, scaling, QRect(0, wy, ww, partH + dist), QColor(255, 128, 0, 255), dist, unscaled, 256);
 115
 116         wy += partH + d;
 117     }
 118
 119     if (drawG) {
 120         drawComponentFull(&davinci, g, scaling, QRect(0, wy, ww, partH + dist), QColor(128, 255, 0, 255), dist, unscaled, 256);
 121         wy += partH + d;
 122     }
 123
 124     if (drawB) {
 125         drawComponentFull(&davinci, b, scaling, QRect(0, wy, ww, partH + dist), QColor(0, 128, 255, 255), dist, unscaled, 256);
 126
 127         wy += partH + d;
 128     }
 129
 130     return histogram;
 131 }
 132
 133 QImage HistogramGenerator::drawComponent(const int *y, const QSize &size, const float &scaling, const QColor &color,
 134                                          bool unscaled, uint max) const
 135 {
 136     QImage component(max, size.height(), QImage::Format_ARGB32);
 137     component.fill(qRgba(0, 0, 0, 0));
 138     Q_ASSERT(scaling != INFINITY);
 139
 140     const int partH = size.height();
 141     int partY;
 142
 143     for (uint x = 0; x < max; x++) {
 144         // Calculate the height of the curve at position x
 145         partY = scaling*y[x];
 146
 147         // Invert the y axis
 148         if (partY > partH-1) { partY = partH-1; }
 149         partY = partH-1 - partY;
 150
 151         for (int k = partH-1; k >= partY; k--) {
 152             component.setPixel(x, k, color.rgba());
 153         }
 154     }
 155     if (unscaled && size.width() >= component.width()) {
 156         return component;
 157     } else {
 158         return component.scaled(size, Qt::IgnoreAspectRatio, Qt::FastTransformation);
 159     }
 160 }
 161
 162 void HistogramGenerator::drawComponentFull(QPainter *davinci, const int *y, const float &scaling, const QRect &rect,
 163                                         const QColor &color, int textSpace, bool unscaled, uint max) const
 164 {
 165     QImage component = drawComponent(y, rect.size() - QSize(0, textSpace), scaling, color, unscaled, max);
 166     davinci->drawImage(rect.topLeft(), component);
 167
 168     int min = 0;
 169     for (uint x = 0; x < max; x++) {
 170         min = x;
 171         if (y[x] > 0) {
 172             break;
 173         }
 174     }
 175     int maxVal = max-1;
 176     for (int x = max-1; x >= 0; x--) {
 177         maxVal = x;
 178         if (y[x] > 0) {
 179             break;
 180         }
 181     }
 182
 183     const int textY = rect.bottom()-textSpace+15;
 184     const int dist = 40;
 185     const int cw = component.width();
 186
 187     davinci->drawText(0,            textY, i18n("min"));
 188     davinci->drawText(dist,         textY, QString::number(min, 'f', 0));
 189
 190     davinci->drawText(cw-dist-30,   textY, i18n("max"));
 191     davinci->drawText(cw-30,        textY, QString::number(maxVal, 'f', 0));
 192 }