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