git.sesse.net Git - kdenlive/blob - src/vectorscope.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
  12 #include <QAction>
  13 #include <QColor>
  14 #include <QDebug>
  15 #include <QMouseEvent>
  16 #include <QMenu>
  17 #include <QPainter>
  18
  19 #include <QTime>
  20
  21 #include "colorplaneexport.h"
  22 #include "colortools.h"
  23 #include "renderer.h"
  24 #include "vectorscope.h"
  25 #include "vectorscopegenerator.h"
  26
  27 const float P75 = .75;
  28 const unsigned char DEFAULT_Y = 255;
  29 //const unsigned int REALTIME_FPS = 15; // in fps.
  30
  31 const QPointF YUV_R(-.147,  .615);
  32 const QPointF YUV_G(-.289, -.515);
  33 const QPointF YUV_B(.437, -.100);
  34 const QPointF YUV_Cy(.147, -.615);
  35 const QPointF YUV_Mg(.289,  .515);
  36 const QPointF YUV_Yl(-.437,  .100);
  37
  38 const QPen penThick(QBrush(QColor(250,250,250)), 2, Qt::SolidLine);
  39 const QPen penThin(QBrush(QColor(250,250,250)), 1, Qt::SolidLine);
  40 const QPen penLight(QBrush(QColor(200,200,250,150)), 1, Qt::SolidLine);
  41 const QPen penDark(QBrush(QColor(0,0,20,250)), 1, Qt::SolidLine);
  42
  43
  44 Vectorscope::Vectorscope(Monitor *projMonitor, Monitor *clipMonitor, QWidget *parent) :
  45     AbstractScopeWidget(projMonitor, clipMonitor, parent),
  46     m_gain(1),
  47     m_circleEnabled(false)
  48 {
  49     ui = new Ui::Vectorscope_UI();
  50     ui->setupUi(this);
  51
  52     //TODO don't draw circle when mouseLeaved
  53
  54     m_colorTools = new ColorTools();
  55     m_colorPlaneExport = new ColorPlaneExport(this);
  56     m_vectorscopeGenerator = new VectorscopeGenerator();
  57
  58     ui->paintMode->addItem(i18n("Green 2"), QVariant(VectorscopeGenerator::PaintMode_Green2));
  59     ui->paintMode->addItem(i18n("Green"), QVariant(VectorscopeGenerator::PaintMode_Green));
  60     ui->paintMode->addItem(i18n("Black"), QVariant(VectorscopeGenerator::PaintMode_Black));
  61     ui->paintMode->addItem(i18n("Modified YUV (Chroma)"), QVariant(VectorscopeGenerator::PaintMode_Chroma));
  62     ui->paintMode->addItem(i18n("YUV"), QVariant(VectorscopeGenerator::PaintMode_YUV));
  63     ui->paintMode->addItem(i18n("Original Color"), QVariant(VectorscopeGenerator::PaintMode_Original));
  64
  65     ui->backgroundMode->addItem(i18n("None"), QVariant(BG_NONE));
  66     ui->backgroundMode->addItem(i18n("YUV"), QVariant(BG_YUV));
  67     ui->backgroundMode->addItem(i18n("Modified YUV (Chroma)"), QVariant(BG_CHROMA));
  68
  69     ui->sliderGain->setMinimum(0);
  70     ui->sliderGain->setMaximum(40);
  71
  72     bool b = true;
  73     b &= connect(ui->backgroundMode, SIGNAL(currentIndexChanged(int)), this, SLOT(slotBackgroundChanged()));
  74     b &= connect(ui->sliderGain, SIGNAL(valueChanged(int)), this, SLOT(slotGainChanged(int)));
  75     b &= connect(ui->paintMode, SIGNAL(currentIndexChanged(int)), this, SLOT(forceUpdateScope()));
  76     ui->sliderGain->setValue(0);
  77
  78
  79     ///// Build context menu /////
  80
  81     m_menu->addSeparator();
  82
  83     m_aExportBackground = new QAction(i18n("Export background"), this);
  84     m_menu->addAction(m_aExportBackground);
  85     b &= connect(m_aExportBackground, SIGNAL(triggered()), this, SLOT(slotExportBackground()));
  86
  87     m_a75PBox = new QAction(i18n("75% box"), this);
  88     m_a75PBox->setCheckable(true);
  89     m_a75PBox->setChecked(false);
  90     m_menu->addAction(m_a75PBox);
  91     b &= connect(m_a75PBox, SIGNAL(changed()), this, SLOT(forceUpdateBackground()));
  92
  93     m_aAxisEnabled = new QAction(i18n("Draw axis"), this);
  94     m_aAxisEnabled->setCheckable(true);
  95     m_aAxisEnabled->setChecked(false);
  96     m_menu->addAction(m_aAxisEnabled);
  97     b &= connect(m_aAxisEnabled, SIGNAL(changed()), this, SLOT(forceUpdateBackground()));
  98
  99     Q_ASSERT(b);
 100
 101
 102     this->setMouseTracking(true);
 103     slotGainChanged(ui->sliderGain->value());
 104 }
 105
 106 Vectorscope::~Vectorscope()
 107 {
 108     delete m_colorTools;
 109     delete m_colorPlaneExport;
 110     delete m_vectorscopeGenerator;
 111
 112     delete m_aExportBackground;
 113     delete m_aAxisEnabled;
 114     delete m_a75PBox;
 115 }
 116
 117 QString Vectorscope::widgetName() const {
 118     return QString("Vectorscope");
 119 }
 120
 121 QRect Vectorscope::scopeRect()
 122 {
 123     // Widget width/height
 124     int ww = this->size().width();
 125     int wh = this->size().height();
 126
 127     // Distance from top/left/right
 128     int offset = 6;
 129
 130     // We want to paint below the controls area. The line is the lowest element.
 131     QPoint topleft(offset, ui->line->y()+offset);
 132
 133     // Circle Width: min of width and height
 134     cw = wh - topleft.y();
 135     if (ww < cw) { cw = ww; }
 136     cw -= 2*offset;
 137
 138     QRect scopeRect(topleft, QPoint(cw, cw) + topleft);
 139
 140     m_centerPoint = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), QPointF(0,0));
 141     pR75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_R);
 142     pG75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_G);
 143     pB75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_B);
 144     pCy75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_Cy);
 145     pMg75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_Mg);
 146     pYl75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_Yl);
 147
 148     return scopeRect;
 149 }
 150
 151 bool Vectorscope::isHUDDependingOnInput() const { return false; }
 152 bool Vectorscope::isScopeDependingOnInput() const { return true; }
 153 bool Vectorscope::isBackgroundDependingOnInput() const { return false; }
 154
 155 QImage Vectorscope::renderHUD(uint)
 156 {
 157
 158     QImage hud;
 159
 160     if (m_circleEnabled) {
 161         // Mouse moved: Draw a circle over the scope
 162
 163         hud = QImage(m_scopeRect.size(), QImage::Format_ARGB32);
 164         hud.fill(qRgba(0, 0, 0, 0));
 165
 166         QPainter davinci(&hud);
 167         QPoint widgetCenterPoint = m_scopeRect.topLeft() + m_centerPoint;
 168
 169         int dx = -widgetCenterPoint.x()+m_mousePos.x();
 170         int dy =  widgetCenterPoint.y()-m_mousePos.y();
 171
 172         QPoint reference = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(1,0));
 173
 174         float r = sqrt(dx*dx + dy*dy);
 175         float percent = (float) 100*r/VectorscopeGenerator::scaling/m_gain/(reference.x() - widgetCenterPoint.x());
 176
 177         switch (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt()) {
 178         case BG_NONE:
 179             davinci.setPen(penLight);
 180             break;
 181         default:
 182             davinci.setPen(penDark);
 183             break;
 184         }
 185         davinci.drawEllipse(m_centerPoint, (int)r, (int)r);
 186         davinci.setPen(penThin);
 187         davinci.drawText(QPoint(m_scopeRect.width()-40, m_scopeRect.height()), i18n("%1 \%", QString::number(percent, 'f', 0)));
 188
 189         float angle = copysign(acos(dx/r)*180/M_PI, dy);
 190         davinci.drawText(QPoint(10, m_scopeRect.height()), i18n("%1°", QString::number(angle, 'f', 1)));
 191
 192         m_circleEnabled = false;
 193     } else {
 194         hud = QImage(0, 0, QImage::Format_ARGB32);
 195     }
 196     emit signalHUDRenderingFinished(0, 1);
 197     return hud;
 198 }
 199
 200 QImage Vectorscope::renderScope(uint accelerationFactor)
 201 {
 202     QTime start = QTime::currentTime();
 203     QImage scope;
 204
 205     if (cw <= 0) {
 206         qDebug() << "Scope size not known yet. Aborting.";
 207     } else {
 208
 209         scope = m_vectorscopeGenerator->calculateVectorscope(m_scopeRect.size(),
 210                                                              m_activeRender->extractFrame(m_activeRender->seekFramePosition()),
 211                                                              m_gain, (VectorscopeGenerator::PaintMode) ui->paintMode->itemData(ui->paintMode->currentIndex()).toInt(),
 212                                                              m_aAxisEnabled->isChecked(), accelerationFactor);
 213
 214     }
 215
 216     unsigned int mseconds = start.msecsTo(QTime::currentTime());
 217 //    qDebug() << "Scope rendered in " << mseconds << " ms. Sending finished signal.";
 218 //    emit signalScopeCalculationFinished(mseconds, skipPixels);
 219     emit signalScopeRenderingFinished(mseconds, accelerationFactor);
 220 //    qDebug() << "xxScope: Signal finished sent.";
 221     return scope;
 222 }
 223
 224 QImage Vectorscope::renderBackground(uint)
 225 {
 226     QTime start = QTime::currentTime();
 227     start.start();
 228
 229     QImage bg;
 230     switch (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt()) {
 231     case BG_YUV:
 232         qDebug() << "YUV background.";
 233         bg = m_colorTools->yuvColorWheel(m_scopeRect.size(), (unsigned char) 128, 1/VectorscopeGenerator::scaling, false, true);
 234         break;
 235     case BG_CHROMA:
 236         bg = m_colorTools->yuvColorWheel(m_scopeRect.size(), (unsigned char) 255, 1/VectorscopeGenerator::scaling, true, true);
 237         break;
 238     default:
 239         qDebug() << "No background.";
 240         bg = QImage(cw, cw, QImage::Format_ARGB32);
 241         bg.fill(qRgba(0,0,0,0));
 242         break;
 243     }
 244
 245
 246     // Draw the vectorscope circle
 247     QPainter davinci(&bg);
 248     QPoint vinciPoint;
 249
 250
 251     davinci.setRenderHint(QPainter::Antialiasing, true);
 252
 253     davinci.setPen(penThick);
 254     davinci.drawEllipse(0, 0, cw, cw);
 255
 256     // Draw RGB/CMY points with 100% chroma
 257     vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_R);
 258     davinci.drawEllipse(vinciPoint, 4,4);
 259     davinci.drawText(vinciPoint-QPoint(20, -10), "R");
 260
 261     vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_G);
 262     davinci.drawEllipse(vinciPoint, 4,4);
 263     davinci.drawText(vinciPoint-QPoint(20, 0), "G");
 264
 265     vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_B);
 266     davinci.drawEllipse(vinciPoint, 4,4);
 267     davinci.drawText(vinciPoint+QPoint(15, 10), "B");
 268
 269     vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_Cy);
 270     davinci.drawEllipse(vinciPoint, 4,4);
 271     davinci.drawText(vinciPoint+QPoint(15, -5), "Cy");
 272
 273     vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_Mg);
 274     davinci.drawEllipse(vinciPoint, 4,4);
 275     davinci.drawText(vinciPoint+QPoint(15, 10), "Mg");
 276
 277     vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_Yl);
 278     davinci.drawEllipse(vinciPoint, 4,4);
 279     davinci.drawText(vinciPoint-QPoint(25, 0), "Yl");
 280
 281     switch (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt()) {
 282     case BG_NONE:
 283         davinci.setPen(penLight);
 284         break;
 285     default:
 286         davinci.setPen(penDark);
 287         break;
 288     }
 289
 290     // Draw axis
 291     if (m_aAxisEnabled->isChecked()) {
 292         davinci.drawLine(m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(0,-.9)), m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(0,.9)));
 293         davinci.drawLine(m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(-.9,0)), m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(.9,0)));
 294     }
 295
 296     // Draw center point
 297     switch (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt()) {
 298     case BG_CHROMA:
 299         davinci.setPen(penDark);
 300         break;
 301     default:
 302         davinci.setPen(penThin);
 303         break;
 304     }
 305     davinci.drawEllipse(m_centerPoint, 5,5);
 306
 307
 308     // Draw 75% box
 309     if (m_a75PBox->isChecked()) {
 310         davinci.drawLine(pR75, pYl75);
 311         davinci.drawLine(pYl75, pG75);
 312         davinci.drawLine(pG75, pCy75);
 313         davinci.drawLine(pCy75, pB75);
 314         davinci.drawLine(pB75, pMg75);
 315         davinci.drawLine(pMg75, pR75);
 316     }
 317
 318     // Draw RGB/CMY points with 75% chroma (for NTSC)
 319     davinci.setPen(penThin);
 320     davinci.drawEllipse(pR75, 3,3);
 321     davinci.drawEllipse(pG75, 3,3);
 322     davinci.drawEllipse(pB75, 3,3);
 323     davinci.drawEllipse(pCy75, 3,3);
 324     davinci.drawEllipse(pMg75, 3,3);
 325     davinci.drawEllipse(pYl75, 3,3);
 326
 327     // Draw realtime factor (number of skipped pixels)
 328     if (m_aRealtime->isChecked()) {
 329         davinci.setPen(penThin);
 330         davinci.drawText(QPoint(m_scopeRect.width()-40, m_scopeRect.height()-15), QVariant(m_accelFactorScope).toString().append("x"));
 331     }
 332
 333     emit signalBackgroundRenderingFinished(start.elapsed(), 1);
 334     return bg;
 335 }
 336
 337
 338
 339
 340 ///// Slots /////
 341
 342 void Vectorscope::slotGainChanged(int newval)
 343 {
 344     m_gain = 1 + (float)newval/10;
 345     ui->lblGain->setText(QString::number(m_gain, 'f', 1) + "x");
 346     forceUpdateScope();
 347 }
 348
 349 void Vectorscope::slotExportBackground()
 350 {
 351     qDebug() << "Exporting background";
 352     m_colorPlaneExport->show();
 353
 354 }
 355
 356 void Vectorscope::slotBackgroundChanged()
 357 {
 358     // Background changed, switch to a suitable color mode now
 359     int index;
 360     switch (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt()) {
 361     case BG_YUV:
 362         index = ui->paintMode->findData(QVariant(VectorscopeGenerator::PaintMode_Black));
 363         if (index >= 0) {
 364             ui->paintMode->setCurrentIndex(index);
 365         }
 366         break;
 367
 368     case BG_NONE:
 369         if (ui->paintMode->itemData(ui->paintMode->currentIndex()).toInt() == VectorscopeGenerator::PaintMode_Black) {
 370             index = ui->paintMode->findData(QVariant(VectorscopeGenerator::PaintMode_Green2));
 371             ui->paintMode->setCurrentIndex(index);
 372         }
 373         break;
 374     }
 375     forceUpdateBackground();
 376 }
 377
 378
 379
 380 ///// Events /////
 381
 382 void Vectorscope::mouseMoveEvent(QMouseEvent *event)
 383 {
 384     // Draw a circle around the center,
 385     // showing percentage number of the radius length
 386
 387     m_circleEnabled = true;
 388     m_mousePos = event->pos();
 389     forceUpdateHUD();
 390 }
 391
 392 void Vectorscope::leaveEvent(QEvent *event)
 393 {
 394     // Repaint the HUD without the circle
 395
 396     m_circleEnabled = false;
 397     QWidget::leaveEvent(event);
 398     forceUpdateHUD();
 399 }