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