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 QPointF YPbPr_R(-.169, .5);
  38 const QPointF YPbPr_G(-.331, -.419);
  39 const QPointF YPbPr_B(.5, -.081);
  40 const QPointF YPbPr_Cy(.169, -.5);
  41 const QPointF YPbPr_Mg(.331, .419);
  42 const QPointF YPbPr_Yl(-.5, .081);
  43
  44
  45 Vectorscope::Vectorscope(Monitor *projMonitor, Monitor *clipMonitor, QWidget *parent) :
  46     AbstractScopeWidget(projMonitor, clipMonitor, parent),
  47     m_gain(1)
  48 {
  49     ui = new Ui::Vectorscope_UI();
  50     ui->setupUi(this);
  51
  52     m_colorTools = new ColorTools();
  53     m_colorPlaneExport = new ColorPlaneExport(this);
  54     m_vectorscopeGenerator = new VectorscopeGenerator();
  55
  56     ui->paintMode->addItem(i18n("Green 2"), QVariant(VectorscopeGenerator::PaintMode_Green2));
  57     ui->paintMode->addItem(i18n("Green"), QVariant(VectorscopeGenerator::PaintMode_Green));
  58     ui->paintMode->addItem(i18n("Black"), QVariant(VectorscopeGenerator::PaintMode_Black));
  59     ui->paintMode->addItem(i18n("Modified YUV (Chroma)"), QVariant(VectorscopeGenerator::PaintMode_Chroma));
  60     ui->paintMode->addItem(i18n("YUV"), QVariant(VectorscopeGenerator::PaintMode_YUV));
  61     ui->paintMode->addItem(i18n("Original Color"), QVariant(VectorscopeGenerator::PaintMode_Original));
  62
  63     ui->backgroundMode->addItem(i18n("None"), QVariant(BG_NONE));
  64     ui->backgroundMode->addItem(i18n("YUV"), QVariant(BG_YUV));
  65     ui->backgroundMode->addItem(i18n("Modified YUV (Chroma)"), QVariant(BG_CHROMA));
  66     ui->backgroundMode->addItem("YPbPr", QVariant(BG_YPbPr)); // TODO translate after 0.7.8 release
  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     b &= connect(this, SIGNAL(signalMousePositionChanged()), this, SLOT(forceUpdateHUD()));
  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_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_menu->addAction(m_aAxisEnabled);
  95     b &= connect(m_aAxisEnabled, SIGNAL(changed()), this, SLOT(forceUpdateBackground()));
  96
  97     // TODO use i18n after the 0.7.8 release
  98     m_menu->addSeparator()->setText("Color Space");
  99     m_aColorSpace_YPbPr = new QAction("YPbPr", this);
 100     m_aColorSpace_YPbPr->setCheckable(true);
 101     m_aColorSpace_YUV = new QAction("YUV", this);
 102     m_aColorSpace_YUV->setCheckable(true);
 103     m_agColorSpace = new QActionGroup(this);
 104     m_agColorSpace->addAction(m_aColorSpace_YPbPr);
 105     m_agColorSpace->addAction(m_aColorSpace_YUV);
 106     m_menu->addAction(m_aColorSpace_YPbPr);
 107     m_menu->addAction(m_aColorSpace_YUV);
 108     b &= connect(m_aColorSpace_YPbPr, SIGNAL(toggled(bool)), this, SLOT(slotColorSpaceChanged()));
 109     b &= connect(m_aColorSpace_YUV, SIGNAL(toggled(bool)), this, SLOT(slotColorSpaceChanged()));
 110
 111     Q_ASSERT(b);
 112
 113     // To make the 1.0x text show
 114     slotGainChanged(ui->sliderGain->value());
 115
 116     init();
 117 }
 118
 119 Vectorscope::~Vectorscope()
 120 {
 121     writeConfig();
 122
 123     delete m_colorTools;
 124     delete m_colorPlaneExport;
 125     delete m_vectorscopeGenerator;
 126
 127     delete m_aColorSpace_YPbPr;
 128     delete m_aColorSpace_YUV;
 129     delete m_aExportBackground;
 130     delete m_aAxisEnabled;
 131     delete m_a75PBox;
 132     delete m_agColorSpace;
 133 }
 134
 135 QString Vectorscope::widgetName() const { return QString("Vectorscope"); }
 136
 137 void Vectorscope::readConfig()
 138 {
 139     AbstractScopeWidget::readConfig();
 140
 141     KSharedConfigPtr config = KGlobal::config();
 142     KConfigGroup scopeConfig(config, configName());
 143     m_a75PBox->setChecked(scopeConfig.readEntry("75PBox", false));
 144     m_aAxisEnabled->setChecked(scopeConfig.readEntry("axis", false));
 145     ui->backgroundMode->setCurrentIndex(scopeConfig.readEntry("backgroundmode").toInt());
 146     ui->paintMode->setCurrentIndex(scopeConfig.readEntry("paintmode").toInt());
 147     ui->sliderGain->setValue(scopeConfig.readEntry("gain", 1));
 148     m_aColorSpace_YPbPr->setChecked(scopeConfig.readEntry("colorspace_ypbpr", false));
 149     m_aColorSpace_YUV->setChecked(!m_aColorSpace_YPbPr->isChecked());
 150 }
 151
 152 void Vectorscope::writeConfig()
 153 {
 154     KSharedConfigPtr config = KGlobal::config();
 155     KConfigGroup scopeConfig(config, configName());
 156     scopeConfig.writeEntry("75PBox", m_a75PBox->isChecked());
 157     scopeConfig.writeEntry("axis", m_aAxisEnabled->isChecked());
 158     scopeConfig.writeEntry("backgroundmode", ui->backgroundMode->currentIndex());
 159     scopeConfig.writeEntry("paintmode", ui->paintMode->currentIndex());
 160     scopeConfig.writeEntry("gain", ui->sliderGain->value());
 161     scopeConfig.writeEntry("colorspace_ypbpr", m_aColorSpace_YPbPr->isChecked());
 162     scopeConfig.sync();
 163 }
 164
 165 QRect Vectorscope::scopeRect()
 166 {
 167     // Distance from top/left/right
 168     int offset = 6;
 169
 170     // We want to paint below the controls area. The line is the lowest element.
 171     QPoint topleft(offset, ui->verticalSpacer->geometry().y()+offset);
 172     QPoint bottomright(ui->horizontalSpacer->geometry().right()-offset, this->size().height()-offset);
 173
 174     QRect scopeRect(topleft, bottomright);
 175
 176     // Circle Width: min of width and height
 177     cw = (scopeRect.height() < scopeRect.width()) ? scopeRect.height() : scopeRect.width();
 178     scopeRect.setWidth(cw);
 179     scopeRect.setHeight(cw);
 180
 181
 182     m_centerPoint = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), QPointF(0,0));
 183     pR75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_R);
 184     pG75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_G);
 185     pB75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_B);
 186     pCy75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_Cy);
 187     pMg75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_Mg);
 188     pYl75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_Yl);
 189     qR75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YPbPr_R);
 190     qG75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YPbPr_G);
 191     qB75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YPbPr_B);
 192     qCy75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YPbPr_Cy);
 193     qMg75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YPbPr_Mg);
 194     qYl75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YPbPr_Yl);
 195
 196     return scopeRect;
 197 }
 198
 199 bool Vectorscope::isHUDDependingOnInput() const { return false; }
 200 bool Vectorscope::isScopeDependingOnInput() const { return true; }
 201 bool Vectorscope::isBackgroundDependingOnInput() const { return false; }
 202
 203 QImage Vectorscope::renderHUD(uint)
 204 {
 205
 206     QImage hud;
 207
 208     if (m_mouseWithinWidget) {
 209         // Mouse moved: Draw a circle over the scope
 210
 211         hud = QImage(m_scopeRect.size(), QImage::Format_ARGB32);
 212         hud.fill(qRgba(0, 0, 0, 0));
 213
 214         QPainter davinci(&hud);
 215         QPoint widgetCenterPoint = m_scopeRect.topLeft() + m_centerPoint;
 216
 217         int dx = -widgetCenterPoint.x()+m_mousePos.x();
 218         int dy =  widgetCenterPoint.y()-m_mousePos.y();
 219
 220         QPoint reference = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(1,0));
 221
 222         float r = sqrt(dx*dx + dy*dy);
 223         float percent = (float) 100*r/VectorscopeGenerator::scaling/m_gain/(reference.x() - widgetCenterPoint.x());
 224
 225         switch (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt()) {
 226         case BG_NONE:
 227             davinci.setPen(penLight);
 228             break;
 229         default:
 230             if (r > cw/2) {
 231                 davinci.setPen(penLight);
 232             } else {
 233                 davinci.setPen(penDark);
 234             }
 235             break;
 236         }
 237         davinci.drawEllipse(m_centerPoint, (int)r, (int)r);
 238         davinci.setPen(penThin);
 239         davinci.drawText(QPoint(m_scopeRect.width()-40, m_scopeRect.height()), i18n("%1 \%", QString::number(percent, 'f', 0)));
 240
 241         float angle = copysign(acos(dx/r)*180/M_PI, dy);
 242         davinci.drawText(QPoint(10, m_scopeRect.height()), i18n("%1°", QString::number(angle, 'f', 1)));
 243
 244 //        m_circleEnabled = false;
 245     } else {
 246         hud = QImage(0, 0, QImage::Format_ARGB32);
 247     }
 248     emit signalHUDRenderingFinished(0, 1);
 249     return hud;
 250 }
 251
 252 QImage Vectorscope::renderScope(uint accelerationFactor, const QImage qimage)
 253 {
 254     QTime start = QTime::currentTime();
 255     QImage scope;
 256
 257     if (cw <= 0) {
 258         qDebug() << "Scope size not known yet. Aborting.";
 259     } else {
 260
 261         VectorscopeGenerator::ColorSpace colorSpace = m_aColorSpace_YPbPr->isChecked() ?
 262                                                       VectorscopeGenerator::ColorSpace_YPbPr : VectorscopeGenerator::ColorSpace_YUV;
 263         VectorscopeGenerator::PaintMode paintMode = (VectorscopeGenerator::PaintMode) ui->paintMode->itemData(ui->paintMode->currentIndex()).toInt();
 264         scope = m_vectorscopeGenerator->calculateVectorscope(m_scopeRect.size(),
 265                                                              qimage,
 266                                                              m_gain, paintMode, colorSpace,
 267                                                              m_aAxisEnabled->isChecked(), accelerationFactor);
 268
 269     }
 270
 271     unsigned int mseconds = start.msecsTo(QTime::currentTime());
 272     emit signalScopeRenderingFinished(mseconds, accelerationFactor);
 273     return scope;
 274 }
 275
 276 QImage Vectorscope::renderBackground(uint)
 277 {
 278     QTime start = QTime::currentTime();
 279     start.start();
 280
 281     QImage bg;
 282     switch (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt()) {
 283     case BG_YUV:
 284         qDebug() << "YUV background.";
 285         bg = m_colorTools->yuvColorWheel(m_scopeRect.size(), (unsigned char) 128, 1/VectorscopeGenerator::scaling, false, true);
 286         break;
 287     case BG_CHROMA:
 288         bg = m_colorTools->yuvColorWheel(m_scopeRect.size(), (unsigned char) 255, 1/VectorscopeGenerator::scaling, true, true);
 289         break;
 290     case BG_YPbPr:
 291         bg = m_colorTools->yPbPrColorWheel(m_scopeRect.size(), (unsigned char) 128, 1/VectorscopeGenerator::scaling, true);
 292         break;
 293     default:
 294         qDebug() << "No background.";
 295         bg = QImage(cw, cw, QImage::Format_ARGB32);
 296         bg.fill(qRgba(0,0,0,0));
 297         break;
 298     }
 299
 300
 301     // Draw the vectorscope circle
 302     QPainter davinci(&bg);
 303     QPoint vinciPoint;
 304
 305
 306     davinci.setRenderHint(QPainter::Antialiasing, true);
 307
 308     davinci.setPen(penThick);
 309     davinci.drawEllipse(0, 0, cw, cw);
 310
 311     // Draw RGB/CMY points with 100% chroma
 312     if (m_aColorSpace_YUV->isChecked()) {
 313         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_R);
 314         davinci.drawEllipse(vinciPoint, 4,4);
 315         davinci.drawText(vinciPoint-QPoint(20, -10), "R");
 316
 317         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_G);
 318         davinci.drawEllipse(vinciPoint, 4,4);
 319         davinci.drawText(vinciPoint-QPoint(20, 0), "G");
 320
 321         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_B);
 322         davinci.drawEllipse(vinciPoint, 4,4);
 323         davinci.drawText(vinciPoint+QPoint(15, 10), "B");
 324
 325         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_Cy);
 326         davinci.drawEllipse(vinciPoint, 4,4);
 327         davinci.drawText(vinciPoint+QPoint(15, -5), "Cy");
 328
 329         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_Mg);
 330         davinci.drawEllipse(vinciPoint, 4,4);
 331         davinci.drawText(vinciPoint+QPoint(15, 10), "Mg");
 332
 333         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_Yl);
 334         davinci.drawEllipse(vinciPoint, 4,4);
 335         davinci.drawText(vinciPoint-QPoint(25, 0), "Yl");
 336     } else {
 337         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YPbPr_R);
 338         davinci.drawEllipse(vinciPoint, 4,4);
 339         davinci.drawText(vinciPoint-QPoint(20, -10), "R");
 340
 341         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YPbPr_G);
 342         davinci.drawEllipse(vinciPoint, 4,4);
 343         davinci.drawText(vinciPoint-QPoint(20, 0), "G");
 344
 345         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YPbPr_B);
 346         davinci.drawEllipse(vinciPoint, 4,4);
 347         davinci.drawText(vinciPoint+QPoint(15, 10), "B");
 348
 349         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YPbPr_Cy);
 350         davinci.drawEllipse(vinciPoint, 4,4);
 351         davinci.drawText(vinciPoint+QPoint(15, -5), "Cy");
 352
 353         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YPbPr_Mg);
 354         davinci.drawEllipse(vinciPoint, 4,4);
 355         davinci.drawText(vinciPoint+QPoint(15, 10), "Mg");
 356
 357         vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YPbPr_Yl);
 358         davinci.drawEllipse(vinciPoint, 4,4);
 359         davinci.drawText(vinciPoint-QPoint(25, 0), "Yl");
 360     }
 361
 362     switch (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt()) {
 363     case BG_NONE:
 364         davinci.setPen(penLight);
 365         break;
 366     default:
 367         davinci.setPen(penDark);
 368         break;
 369     }
 370
 371     // Draw axis
 372     if (m_aAxisEnabled->isChecked()) {
 373         davinci.drawLine(m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(0,-.9)), m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(0,.9)));
 374         davinci.drawLine(m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(-.9,0)), m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), QPointF(.9,0)));
 375     }
 376
 377     // Draw center point
 378     switch (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt()) {
 379     case BG_CHROMA:
 380         davinci.setPen(penDark);
 381         break;
 382     default:
 383         davinci.setPen(penThin);
 384         break;
 385     }
 386     davinci.drawEllipse(m_centerPoint, 5,5);
 387
 388
 389     // Draw 75% box
 390     if (m_a75PBox->isChecked()) {
 391         if (m_aColorSpace_YUV->isChecked()) {
 392             davinci.drawLine(pR75, pYl75);
 393             davinci.drawLine(pYl75, pG75);
 394             davinci.drawLine(pG75, pCy75);
 395             davinci.drawLine(pCy75, pB75);
 396             davinci.drawLine(pB75, pMg75);
 397             davinci.drawLine(pMg75, pR75);
 398         } else {
 399             davinci.drawLine(qR75, qYl75);
 400             davinci.drawLine(qYl75, qG75);
 401             davinci.drawLine(qG75, qCy75);
 402             davinci.drawLine(qCy75, qB75);
 403             davinci.drawLine(qB75, qMg75);
 404             davinci.drawLine(qMg75, qR75);
 405         }
 406     }
 407
 408     // Draw RGB/CMY points with 75% chroma (for NTSC)
 409     davinci.setPen(penThin);
 410     if (m_aColorSpace_YUV->isChecked()) {
 411         davinci.drawEllipse(pR75, 3,3);
 412         davinci.drawEllipse(pG75, 3,3);
 413         davinci.drawEllipse(pB75, 3,3);
 414         davinci.drawEllipse(pCy75, 3,3);
 415         davinci.drawEllipse(pMg75, 3,3);
 416         davinci.drawEllipse(pYl75, 3,3);
 417     } else {
 418         davinci.drawEllipse(qR75, 3,3);
 419         davinci.drawEllipse(qG75, 3,3);
 420         davinci.drawEllipse(qB75, 3,3);
 421         davinci.drawEllipse(qCy75, 3,3);
 422         davinci.drawEllipse(qMg75, 3,3);
 423         davinci.drawEllipse(qYl75, 3,3);
 424     }
 425
 426     // Draw realtime factor (number of skipped pixels)
 427     if (m_aRealtime->isChecked()) {
 428         davinci.setPen(penThin);
 429         davinci.drawText(QPoint(m_scopeRect.width()-40, m_scopeRect.height()-15), QVariant(m_accelFactorScope).toString().append("x"));
 430     }
 431
 432     emit signalBackgroundRenderingFinished(start.elapsed(), 1);
 433     return bg;
 434 }
 435
 436
 437
 438
 439 ///// Slots /////
 440
 441 void Vectorscope::slotGainChanged(int newval)
 442 {
 443     m_gain = 1 + (float)newval/10;
 444     ui->lblGain->setText(QString::number(m_gain, 'f', 1) + "x");
 445     forceUpdateScope();
 446 }
 447
 448 void Vectorscope::slotExportBackground()
 449 {
 450     qDebug() << "Exporting background";
 451     m_colorPlaneExport->show();
 452
 453 }
 454
 455 void Vectorscope::slotBackgroundChanged()
 456 {
 457     // Background changed, switch to a suitable color mode now
 458     int index;
 459     switch (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt()) {
 460     case BG_YUV:
 461         index = ui->paintMode->findData(QVariant(VectorscopeGenerator::PaintMode_Black));
 462         if (index >= 0) {
 463             ui->paintMode->setCurrentIndex(index);
 464         }
 465         break;
 466
 467     case BG_NONE:
 468         if (ui->paintMode->itemData(ui->paintMode->currentIndex()).toInt() == VectorscopeGenerator::PaintMode_Black) {
 469             index = ui->paintMode->findData(QVariant(VectorscopeGenerator::PaintMode_Green2));
 470             ui->paintMode->setCurrentIndex(index);
 471         }
 472         break;
 473     }
 474     forceUpdateBackground();
 475 }
 476
 477 void Vectorscope::slotColorSpaceChanged()
 478 {
 479     int index;
 480     if (m_aColorSpace_YPbPr->isChecked()) {
 481         if (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt() == BG_YUV) {
 482             index = ui->backgroundMode->findData(QVariant(BG_YPbPr));
 483             if (index >= 0) {
 484                 ui->backgroundMode->setCurrentIndex(index);
 485             }
 486         }
 487     } else {
 488         if (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt() == BG_YPbPr) {
 489             index = ui->backgroundMode->findData(QVariant(BG_YUV));
 490             if (index >= 0) {
 491                 ui->backgroundMode->setCurrentIndex(index);
 492             }
 493         }
 494     }
 495     forceUpdate();
 496 }