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