git.sesse.net Git - kdenlive/blob - src/scopes/colorscopes/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 "vectorscope.h"
  24 #include "colorcorrection/vectorscopegenerator.h"
  25
  26 const float P75 = .75;
  27 const unsigned char DEFAULT_Y = 255;
  28
  29 const QPointF YUV_R(-.147,  .615);
  30 const QPointF YUV_G(-.289, -.515);
  31 const QPointF YUV_B(.437, -.100);
  32 const QPointF YUV_Cy(.147, -.615);
  33 const QPointF YUV_Mg(.289,  .515);
  34 const QPointF YUV_Yl(-.437,  .100);
  35
  36 const QPointF YPbPr_R(-.169, .5);
  37 const QPointF YPbPr_G(-.331, -.419);
  38 const QPointF YPbPr_B(.5, -.081);
  39 const QPointF YPbPr_Cy(.169, -.5);
  40 const QPointF YPbPr_Mg(.331, .419);
  41 const QPointF YPbPr_Yl(-.5, .081);
  42
  43
  44 Vectorscope::Vectorscope(QWidget *parent) :
  45     AbstractGfxScopeWidget(true, parent),
  46     m_gain(1)
  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     ui->backgroundMode->addItem(i18n("YPbPr"), QVariant(BG_YPbPr));
  66
  67     ui->sliderGain->setMinimum(0);
  68     ui->sliderGain->setMaximum(40);
  69
  70     bool b = true;
  71     b &= connect(ui->backgroundMode, SIGNAL(currentIndexChanged(int)), this, SLOT(slotBackgroundChanged()));
  72     b &= connect(ui->sliderGain, SIGNAL(valueChanged(int)), this, SLOT(slotGainChanged(int)));
  73     b &= connect(ui->paintMode, SIGNAL(currentIndexChanged(int)), this, SLOT(forceUpdateScope()));
  74     b &= connect(this, SIGNAL(signalMousePositionChanged()), this, SLOT(forceUpdateHUD()));
  75     ui->sliderGain->setValue(0);
  76
  77
  78     ///// Build context menu /////
  79
  80     m_menu->addSeparator()->setText(i18n("Tools"));;
  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_menu->addSeparator()->setText(i18n("Drawing options"));
  87
  88     m_a75PBox = new QAction(i18n("75% box"), this);
  89     m_a75PBox->setCheckable(true);
  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_menu->addAction(m_aAxisEnabled);
  96     b &= connect(m_aAxisEnabled, SIGNAL(changed()), this, SLOT(forceUpdateBackground()));
  97
  98     m_aIQLines = new QAction(i18n("Draw I/Q lines"), this);
  99     m_aIQLines->setCheckable(true);
 100     m_menu->addAction(m_aIQLines);
 101     b &= connect(m_aIQLines, SIGNAL(changed()), this, SLOT(forceUpdateBackground()));
 102
 103     m_menu->addSeparator()->setText(i18n("Color Space"));
 104     m_aColorSpace_YPbPr = new QAction(i18n("YPbPr"), this);
 105     m_aColorSpace_YPbPr->setCheckable(true);
 106     m_aColorSpace_YUV = new QAction(i18n("YUV"), this);
 107     m_aColorSpace_YUV->setCheckable(true);
 108     m_agColorSpace = new QActionGroup(this);
 109     m_agColorSpace->addAction(m_aColorSpace_YPbPr);
 110     m_agColorSpace->addAction(m_aColorSpace_YUV);
 111     m_menu->addAction(m_aColorSpace_YPbPr);
 112     m_menu->addAction(m_aColorSpace_YUV);
 113     b &= connect(m_aColorSpace_YPbPr, SIGNAL(toggled(bool)), this, SLOT(slotColorSpaceChanged()));
 114     b &= connect(m_aColorSpace_YUV, SIGNAL(toggled(bool)), this, SLOT(slotColorSpaceChanged()));
 115
 116     Q_ASSERT(b);
 117
 118     // To make the 1.0x text show
 119     slotGainChanged(ui->sliderGain->value());
 120
 121     init();
 122 }
 123
 124 Vectorscope::~Vectorscope()
 125 {
 126     writeConfig();
 127
 128     delete m_colorTools;
 129     delete m_colorPlaneExport;
 130     delete m_vectorscopeGenerator;
 131
 132     delete m_aColorSpace_YPbPr;
 133     delete m_aColorSpace_YUV;
 134     delete m_aExportBackground;
 135     delete m_aAxisEnabled;
 136     delete m_a75PBox;
 137     delete m_agColorSpace;
 138     delete ui;
 139 }
 140
 141 QString Vectorscope::widgetName() const
 142 {
 143     return QLatin1String("Vectorscope");
 144 }
 145
 146 void Vectorscope::readConfig()
 147 {
 148     AbstractGfxScopeWidget::readConfig();
 149
 150     KSharedConfigPtr config = KGlobal::config();
 151     KConfigGroup scopeConfig(config, configName());
 152     m_a75PBox->setChecked(scopeConfig.readEntry("75PBox", false));
 153     m_aAxisEnabled->setChecked(scopeConfig.readEntry("axis", false));
 154     m_aIQLines->setChecked(scopeConfig.readEntry("iqlines", false));
 155     ui->backgroundMode->setCurrentIndex(scopeConfig.readEntry("backgroundmode").toInt());
 156     ui->paintMode->setCurrentIndex(scopeConfig.readEntry("paintmode").toInt());
 157     ui->sliderGain->setValue(scopeConfig.readEntry("gain", 1));
 158     m_aColorSpace_YPbPr->setChecked(scopeConfig.readEntry("colorspace_ypbpr", false));
 159     m_aColorSpace_YUV->setChecked(!m_aColorSpace_YPbPr->isChecked());
 160 }
 161
 162 void Vectorscope::writeConfig()
 163 {
 164     KSharedConfigPtr config = KGlobal::config();
 165     KConfigGroup scopeConfig(config, configName());
 166     scopeConfig.writeEntry("75PBox", m_a75PBox->isChecked());
 167     scopeConfig.writeEntry("axis", m_aAxisEnabled->isChecked());
 168     scopeConfig.writeEntry("iqlines", m_aIQLines->isChecked());
 169     scopeConfig.writeEntry("backgroundmode", ui->backgroundMode->currentIndex());
 170     scopeConfig.writeEntry("paintmode", ui->paintMode->currentIndex());
 171     scopeConfig.writeEntry("gain", ui->sliderGain->value());
 172     scopeConfig.writeEntry("colorspace_ypbpr", m_aColorSpace_YPbPr->isChecked());
 173     scopeConfig.sync();
 174 }
 175
 176 QRect Vectorscope::scopeRect()
 177 {
 178     // Distance from top/left/right
 179     int offset = 6;
 180
 181     // We want to paint below the controls area. The line is the lowest element.
 182     QPoint topleft(offset, ui->verticalSpacer->geometry().y()+offset);
 183     QPoint bottomright(ui->horizontalSpacer->geometry().right()-offset, this->size().height()-offset);
 184
 185     m_visibleRect = QRect(topleft, bottomright);
 186
 187     QRect scopeRect(topleft, bottomright);
 188
 189     // Circle Width: min of width and height
 190     cw = (scopeRect.height() < scopeRect.width()) ? scopeRect.height() : scopeRect.width();
 191     scopeRect.setWidth(cw);
 192     scopeRect.setHeight(cw);
 193
 194
 195     m_centerPoint = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), QPointF(0,0));
 196     pR75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_R);
 197     pG75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_G);
 198     pB75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_B);
 199     pCy75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_Cy);
 200     pMg75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_Mg);
 201     pYl75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_Yl);
 202     qR75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YPbPr_R);
 203     qG75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YPbPr_G);
 204     qB75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YPbPr_B);
 205     qCy75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YPbPr_Cy);
 206     qMg75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YPbPr_Mg);
 207     qYl75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YPbPr_Yl);
 208
 209     return scopeRect;
 210 }
 211
 212 bool Vectorscope::isHUDDependingOnInput() const { return false; }
 213 bool Vectorscope::isScopeDependingOnInput() const { return true; }
 214 bool Vectorscope::isBackgroundDependingOnInput() const { return false; }
 215
 216 QImage Vectorscope::renderHUD(uint)
 217 {
 218
 219     QImage hud;
 220     QLocale locale;
 221     if (m_mouseWithinWidget) {
 222         // Mouse moved: Draw a circle over the scope
 223
 224         hud = QImage(m_visibleRect.size(), QImage::Format_ARGB32);
 225         hud.fill(qRgba(0, 0, 0, 0));
 226
 227         QPainter davinci(&hud);
 228         QPoint widgetCenterPoint = m_scopeRect.topLeft() + m_centerPoint;
 229
 230         int dx = -widgetCenterPoint.x()+m_mousePos.x();
 231         int dy =  widgetCenterPoint.y()-m_mousePos.y();
 232
 233         QPoint reference = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(1,0));
 234
 235         float r = sqrt(dx*dx + dy*dy);
 236         float percent = (float) 100*r/VectorscopeGenerator::scaling/m_gain/(reference.x() - widgetCenterPoint.x());
 237
 238         switch (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt()) {
 239         case BG_NONE:
 240             davinci.setPen(penLight);
 241             break;
 242         default:
 243             if (r > cw/2) {
 244                 davinci.setPen(penLight);
 245             } else {
 246                 davinci.setPen(penDark);
 247             }
 248             break;
 249         }
 250         davinci.drawEllipse(m_centerPoint, (int)r, (int)r);
 251         davinci.setPen(penThin);
 252         davinci.drawText(QPoint(m_scopeRect.width()-40, m_scopeRect.height()), i18n("%1 \%", locale.toString(percent, 'f', 0)));
 253
 254         float angle = copysign(acos(dx/r)*180/M_PI, dy);
 255         davinci.drawText(QPoint(10, m_scopeRect.height()), i18n("%1°", locale.toString(angle, 'f', 1)));
 256
 257 //        m_circleEnabled = false;
 258     } else {
 259         hud = QImage(0, 0, QImage::Format_ARGB32);
 260     }
 261     emit signalHUDRenderingFinished(0, 1);
 262     return hud;
 263 }
 264
 265 QImage Vectorscope::renderGfxScope(uint accelerationFactor, const QImage &qimage)
 266 {
 267     QTime start = QTime::currentTime();
 268     QImage scope;
 269
 270     if (cw <= 0) {
 271         qDebug() << "Scope size not known yet. Aborting.";
 272     } else {
 273
 274         VectorscopeGenerator::ColorSpace colorSpace = m_aColorSpace_YPbPr->isChecked() ?
 275                                                       VectorscopeGenerator::ColorSpace_YPbPr : VectorscopeGenerator::ColorSpace_YUV;
 276         VectorscopeGenerator::PaintMode paintMode = (VectorscopeGenerator::PaintMode) ui->paintMode->itemData(ui->paintMode->currentIndex()).toInt();
 277         scope = m_vectorscopeGenerator->calculateVectorscope(m_scopeRect.size(),
 278                                                              qimage,
 279                                                              m_gain, paintMode, colorSpace,
 280                                                              m_aAxisEnabled->isChecked(), accelerationFactor);
 281
 282     }
 283
 284     unsigned int mseconds = start.msecsTo(QTime::currentTime());
 285     emit signalScopeRenderingFinished(mseconds, accelerationFactor);
 286     return scope;
 287 }
 288
 289 QImage Vectorscope::renderBackground(uint)
 290 {
 291     QTime start = QTime::currentTime();
 292     start.start();
 293
 294     QImage bg(m_visibleRect.size(), QImage::Format_ARGB32);
 295     bg.fill(qRgba(0,0,0,0));
 296
 297     // Set up tools
 298     QPainter davinci(&bg);
 299     davinci.setRenderHint(QPainter::Antialiasing, true);
 300
 301     QPoint vinciPoint;
 302     QPoint vinciPoint2;
 303
 304     // Draw the color plane (if selected)
 305     QImage colorPlane;
 306     switch (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt()) {
 307     case BG_YUV:
 308         colorPlane = m_colorTools->yuvColorWheel(m_scopeRect.size(), (unsigned char) 128, 1/VectorscopeGenerator::scaling, false, true);
 309         davinci.drawImage(0, 0, colorPlane);
 310         break;
 311     case BG_CHROMA:
 312         colorPlane = m_colorTools->yuvColorWheel(m_scopeRect.size(), (unsigned char) 255, 1/VectorscopeGenerator::scaling, true, true);
 313         davinci.drawImage(0, 0, colorPlane);
 314         break;
 315     case BG_YPbPr:
 316         colorPlane = m_colorTools->yPbPrColorWheel(m_scopeRect.size(), (unsigned char) 128, 1/VectorscopeGenerator::scaling, true);
 317         davinci.drawImage(0, 0, colorPlane);
 318         break;
 319     }
 320
 321
 322
 323     // Draw I/Q lines (from the YIQ color space; Skin tones lie on the I line)
 324     // Positions are calculated by transforming YIQ:[0 1 0] or YIQ:[0 0 1] to YUV/YPbPr.
 325     if (m_aIQLines->isChecked()) {
 326
 327         switch (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt()) {
 328         case BG_NONE:
 329             davinci.setPen(penLightDots);
 330             break;
 331         default:
 332             davinci.setPen(penDarkDots);
 333             break;
 334         }
 335
 336         if (m_aColorSpace_YUV->isChecked()) {
 337             vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(-.544,.838));
 338             vinciPoint2 = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(.544,-.838));
 339         } else {
 340             vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(-.675,.737));
 341             vinciPoint2 = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(.675,-.737));
 342         }
 343
 344         davinci.drawLine(vinciPoint, vinciPoint2);
 345         davinci.setPen(penThick);
 346         davinci.drawText(vinciPoint - QPoint(11, 5), "I");
 347
 348
 349         switch (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt()) {
 350         case BG_NONE:
 351             davinci.setPen(penLightDots);
 352             break;
 353         default:
 354             davinci.setPen(penDarkDots);
 355             break;
 356         }
 357
 358         if (m_aColorSpace_YUV->isChecked()) {
 359             vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(.838, .544));
 360             vinciPoint2 = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(-.838,-.544));
 361         } else {
 362             vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(.908, .443));
 363             vinciPoint2 = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(-.908,-.443));
 364         }
 365
 366         davinci.drawLine(vinciPoint, vinciPoint2);
 367         davinci.setPen(penThick);
 368         davinci.drawText(vinciPoint - QPoint(-7, 2), "Q");
 369
 370
 371
 372     }
 373
 374     // Draw the vectorscope circle
 375     davinci.setPen(penThick);
 376     davinci.drawEllipse(0, 0, cw, cw);
 377
 378     // Draw RGB/CMY points with 100% chroma
 379     if (m_aColorSpace_YUV->isChecked()) {
 380         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_R);
 381         davinci.drawEllipse(vinciPoint, 4,4);
 382         davinci.drawText(vinciPoint-QPoint(20, -10), "R");
 383
 384         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_G);
 385         davinci.drawEllipse(vinciPoint, 4,4);
 386         davinci.drawText(vinciPoint-QPoint(20, 0), "G");
 387
 388         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_B);
 389         davinci.drawEllipse(vinciPoint, 4,4);
 390         davinci.drawText(vinciPoint+QPoint(15, 10), "B");
 391
 392         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_Cy);
 393         davinci.drawEllipse(vinciPoint, 4,4);
 394         davinci.drawText(vinciPoint+QPoint(15, -5), "Cy");
 395
 396         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_Mg);
 397         davinci.drawEllipse(vinciPoint, 4,4);
 398         davinci.drawText(vinciPoint+QPoint(15, 10), "Mg");
 399
 400         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_Yl);
 401         davinci.drawEllipse(vinciPoint, 4,4);
 402         davinci.drawText(vinciPoint-QPoint(25, 0), "Yl");
 403     } else {
 404         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YPbPr_R);
 405         davinci.drawEllipse(vinciPoint, 4,4);
 406         davinci.drawText(vinciPoint-QPoint(20, -10), "R");
 407
 408         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YPbPr_G);
 409         davinci.drawEllipse(vinciPoint, 4,4);
 410         davinci.drawText(vinciPoint-QPoint(20, 0), "G");
 411
 412         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YPbPr_B);
 413         davinci.drawEllipse(vinciPoint, 4,4);
 414         davinci.drawText(vinciPoint+QPoint(15, 10), "B");
 415
 416         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YPbPr_Cy);
 417         davinci.drawEllipse(vinciPoint, 4,4);
 418         davinci.drawText(vinciPoint+QPoint(15, -5), "Cy");
 419
 420         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YPbPr_Mg);
 421         davinci.drawEllipse(vinciPoint, 4,4);
 422         davinci.drawText(vinciPoint+QPoint(15, 10), "Mg");
 423
 424         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YPbPr_Yl);
 425         davinci.drawEllipse(vinciPoint, 4,4);
 426         davinci.drawText(vinciPoint-QPoint(25, 0), "Yl");
 427     }
 428
 429     switch (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt()) {
 430     case BG_NONE:
 431         davinci.setPen(penLight);
 432         break;
 433     default:
 434         davinci.setPen(penDark);
 435         break;
 436     }
 437
 438     // Draw axis
 439     if (m_aAxisEnabled->isChecked()) {
 440         davinci.drawLine(m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(0,-.9)), m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(0,.9)));
 441         davinci.drawLine(m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(-.9,0)), m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(.9,0)));
 442     }
 443
 444     // Draw center point
 445     switch (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt()) {
 446     case BG_CHROMA:
 447         davinci.setPen(penDark);
 448         break;
 449     default:
 450         davinci.setPen(penThin);
 451         break;
 452     }
 453     davinci.drawEllipse(m_centerPoint, 5,5);
 454
 455
 456     // Draw 75% box
 457     if (m_a75PBox->isChecked()) {
 458         if (m_aColorSpace_YUV->isChecked()) {
 459             davinci.drawLine(pR75, pYl75);
 460             davinci.drawLine(pYl75, pG75);
 461             davinci.drawLine(pG75, pCy75);
 462             davinci.drawLine(pCy75, pB75);
 463             davinci.drawLine(pB75, pMg75);
 464             davinci.drawLine(pMg75, pR75);
 465         } else {
 466             davinci.drawLine(qR75, qYl75);
 467             davinci.drawLine(qYl75, qG75);
 468             davinci.drawLine(qG75, qCy75);
 469             davinci.drawLine(qCy75, qB75);
 470             davinci.drawLine(qB75, qMg75);
 471             davinci.drawLine(qMg75, qR75);
 472         }
 473     }
 474
 475     // Draw RGB/CMY points with 75% chroma (for NTSC)
 476     davinci.setPen(penThin);
 477     if (m_aColorSpace_YUV->isChecked()) {
 478         davinci.drawEllipse(pR75, 3,3);
 479         davinci.drawEllipse(pG75, 3,3);
 480         davinci.drawEllipse(pB75, 3,3);
 481         davinci.drawEllipse(pCy75, 3,3);
 482         davinci.drawEllipse(pMg75, 3,3);
 483         davinci.drawEllipse(pYl75, 3,3);
 484     } else {
 485         davinci.drawEllipse(qR75, 3,3);
 486         davinci.drawEllipse(qG75, 3,3);
 487         davinci.drawEllipse(qB75, 3,3);
 488         davinci.drawEllipse(qCy75, 3,3);
 489         davinci.drawEllipse(qMg75, 3,3);
 490         davinci.drawEllipse(qYl75, 3,3);
 491     }
 492
 493     // Draw realtime factor (number of skipped pixels)
 494     if (m_aRealtime->isChecked()) {
 495         davinci.setPen(penThin);
 496         davinci.drawText(QPoint(m_scopeRect.width()-40, m_scopeRect.height()-15), QVariant(m_accelFactorScope).toString().append("x"));
 497     }
 498
 499     emit signalBackgroundRenderingFinished(start.elapsed(), 1);
 500     return bg;
 501 }
 502
 503
 504
 505
 506 ///// Slots /////
 507
 508 void Vectorscope::slotGainChanged(int newval)
 509 {
 510     QLocale locale;
 511     m_gain = 1 + (float)newval/10;
 512     ui->lblGain->setText(locale.toString(m_gain, 'f', 1) + 'x');
 513     forceUpdateScope();
 514 }
 515
 516 void Vectorscope::slotExportBackground()
 517 {
 518     qDebug() << "Exporting background";
 519     m_colorPlaneExport->show();
 520
 521 }
 522
 523 void Vectorscope::slotBackgroundChanged()
 524 {
 525     // Background changed, switch to a suitable color mode now
 526     int index;
 527     switch (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt()) {
 528     case BG_YUV:
 529         index = ui->paintMode->findData(QVariant(VectorscopeGenerator::PaintMode_Black));
 530         if (index >= 0) {
 531             ui->paintMode->setCurrentIndex(index);
 532         }
 533         break;
 534
 535     case BG_NONE:
 536         if (ui->paintMode->itemData(ui->paintMode->currentIndex()).toInt() == VectorscopeGenerator::PaintMode_Black) {
 537             index = ui->paintMode->findData(QVariant(VectorscopeGenerator::PaintMode_Green2));
 538             ui->paintMode->setCurrentIndex(index);
 539         }
 540         break;
 541     }
 542     forceUpdateBackground();
 543 }
 544
 545 void Vectorscope::slotColorSpaceChanged()
 546 {
 547     int index;
 548     if (m_aColorSpace_YPbPr->isChecked()) {
 549         if (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt() == BG_YUV) {
 550             index = ui->backgroundMode->findData(QVariant(BG_YPbPr));
 551             if (index >= 0) {
 552                 ui->backgroundMode->setCurrentIndex(index);
 553             }
 554         }
 555     } else {
 556         if (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt() == BG_YPbPr) {
 557             index = ui->backgroundMode->findData(QVariant(BG_YUV));
 558             if (index >= 0) {
 559                 ui->backgroundMode->setCurrentIndex(index);
 560             }
 561         }
 562     }
 563     forceUpdate();
 564 }
 565
 566 #include "vectorscope.moc"