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