X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fvectorscope.cpp;h=f81066335457ba1742d9e54e958ee3ffa0ee1e08;hb=5c90404b275f932110db0942d00233180deae0a1;hp=841e76d2bf92a5d5916deffcae4afc4f9d250715;hpb=2ce698b921225589844447f223963614d4b74158;p=kdenlive

diff --git a/src/vectorscope.cpp b/src/vectorscope.cpp
index 841e76d2..f8106633 100644
--- a/src/vectorscope.cpp
+++ b/src/vectorscope.cpp
@@ -34,22 +34,21 @@ const QPointF YUV_Cy(.147, -.615);
 const QPointF YUV_Mg(.289,  .515);
 const QPointF YUV_Yl(-.437,  .100);
 
-const QPen penThick(QBrush(QColor(250,250,250)), 2, Qt::SolidLine);
-const QPen penThin(QBrush(QColor(250,250,250)), 1, Qt::SolidLine);
-const QPen penLight(QBrush(QColor(200,200,250,150)), 1, Qt::SolidLine);
-const QPen penDark(QBrush(QColor(0,0,20,250)), 1, Qt::SolidLine);
+const QPointF YPbPr_R(-.169, .5);
+const QPointF YPbPr_G(-.331, -.419);
+const QPointF YPbPr_B(.5, -.081);
+const QPointF YPbPr_Cy(.169, -.5);
+const QPointF YPbPr_Mg(.331, .419);
+const QPointF YPbPr_Yl(-.5, .081);
 
 
 Vectorscope::Vectorscope(Monitor *projMonitor, Monitor *clipMonitor, QWidget *parent) :
-    AbstractScopeWidget(projMonitor, clipMonitor, parent),
-    m_gain(1),
-    m_circleEnabled(false)
+    AbstractScopeWidget(projMonitor, clipMonitor, true, parent),
+    m_gain(1)
 {
     ui = new Ui::Vectorscope_UI();
     ui->setupUi(this);
 
-    //TODO don't draw circle when mouseLeaved
-
     m_colorTools = new ColorTools();
     m_colorPlaneExport = new ColorPlaneExport(this);
     m_vectorscopeGenerator = new VectorscopeGenerator();
@@ -64,6 +63,7 @@ Vectorscope::Vectorscope(Monitor *projMonitor, Monitor *clipMonitor, QWidget *pa
     ui->backgroundMode->addItem(i18n("None"), QVariant(BG_NONE));
     ui->backgroundMode->addItem(i18n("YUV"), QVariant(BG_YUV));
     ui->backgroundMode->addItem(i18n("Modified YUV (Chroma)"), QVariant(BG_CHROMA));
+    ui->backgroundMode->addItem(i18n("YPbPr"), QVariant(BG_YPbPr));
 
     ui->sliderGain->setMinimum(0);
     ui->sliderGain->setMaximum(40);
@@ -72,6 +72,7 @@ Vectorscope::Vectorscope(Monitor *projMonitor, Monitor *clipMonitor, QWidget *pa
     b &= connect(ui->backgroundMode, SIGNAL(currentIndexChanged(int)), this, SLOT(slotBackgroundChanged()));
     b &= connect(ui->sliderGain, SIGNAL(valueChanged(int)), this, SLOT(slotGainChanged(int)));
     b &= connect(ui->paintMode, SIGNAL(currentIndexChanged(int)), this, SLOT(forceUpdateScope()));
+    b &= connect(this, SIGNAL(signalMousePositionChanged()), this, SLOT(forceUpdateHUD()));
     ui->sliderGain->setValue(0);
 
 
@@ -85,54 +86,97 @@ Vectorscope::Vectorscope(Monitor *projMonitor, Monitor *clipMonitor, QWidget *pa
 
     m_a75PBox = new QAction(i18n("75% box"), this);
     m_a75PBox->setCheckable(true);
-    m_a75PBox->setChecked(false);
     m_menu->addAction(m_a75PBox);
     b &= connect(m_a75PBox, SIGNAL(changed()), this, SLOT(forceUpdateBackground()));
 
     m_aAxisEnabled = new QAction(i18n("Draw axis"), this);
     m_aAxisEnabled->setCheckable(true);
-    m_aAxisEnabled->setChecked(false);
     m_menu->addAction(m_aAxisEnabled);
     b &= connect(m_aAxisEnabled, SIGNAL(changed()), this, SLOT(forceUpdateBackground()));
 
-    Q_ASSERT(b);
+    m_menu->addSeparator()->setText(i18n("Color Space"));
+    m_aColorSpace_YPbPr = new QAction(i18n("YPbPr"), this);
+    m_aColorSpace_YPbPr->setCheckable(true);
+    m_aColorSpace_YUV = new QAction(i18n("YUV"), this);
+    m_aColorSpace_YUV->setCheckable(true);
+    m_agColorSpace = new QActionGroup(this);
+    m_agColorSpace->addAction(m_aColorSpace_YPbPr);
+    m_agColorSpace->addAction(m_aColorSpace_YUV);
+    m_menu->addAction(m_aColorSpace_YPbPr);
+    m_menu->addAction(m_aColorSpace_YUV);
+    b &= connect(m_aColorSpace_YPbPr, SIGNAL(toggled(bool)), this, SLOT(slotColorSpaceChanged()));
+    b &= connect(m_aColorSpace_YUV, SIGNAL(toggled(bool)), this, SLOT(slotColorSpaceChanged()));
 
+    Q_ASSERT(b);
 
-    this->setMouseTracking(true);
+    // To make the 1.0x text show
     slotGainChanged(ui->sliderGain->value());
+
+    init();
 }
 
 Vectorscope::~Vectorscope()
 {
+    writeConfig();
+
     delete m_colorTools;
     delete m_colorPlaneExport;
     delete m_vectorscopeGenerator;
 
+    delete m_aColorSpace_YPbPr;
+    delete m_aColorSpace_YUV;
     delete m_aExportBackground;
     delete m_aAxisEnabled;
     delete m_a75PBox;
+    delete m_agColorSpace;
 }
 
 QString Vectorscope::widgetName() const { return QString("Vectorscope"); }
 
-QRect Vectorscope::scopeRect()
+void Vectorscope::readConfig()
+{
+    AbstractScopeWidget::readConfig();
+
+    KSharedConfigPtr config = KGlobal::config();
+    KConfigGroup scopeConfig(config, configName());
+    m_a75PBox->setChecked(scopeConfig.readEntry("75PBox", false));
+    m_aAxisEnabled->setChecked(scopeConfig.readEntry("axis", false));
+    ui->backgroundMode->setCurrentIndex(scopeConfig.readEntry("backgroundmode").toInt());
+    ui->paintMode->setCurrentIndex(scopeConfig.readEntry("paintmode").toInt());
+    ui->sliderGain->setValue(scopeConfig.readEntry("gain", 1));
+    m_aColorSpace_YPbPr->setChecked(scopeConfig.readEntry("colorspace_ypbpr", false));
+    m_aColorSpace_YUV->setChecked(!m_aColorSpace_YPbPr->isChecked());
+}
+
+void Vectorscope::writeConfig()
 {
-    // Widget width/height
-    int ww = this->size().width();
-    int wh = this->size().height();
+    KSharedConfigPtr config = KGlobal::config();
+    KConfigGroup scopeConfig(config, configName());
+    scopeConfig.writeEntry("75PBox", m_a75PBox->isChecked());
+    scopeConfig.writeEntry("axis", m_aAxisEnabled->isChecked());
+    scopeConfig.writeEntry("backgroundmode", ui->backgroundMode->currentIndex());
+    scopeConfig.writeEntry("paintmode", ui->paintMode->currentIndex());
+    scopeConfig.writeEntry("gain", ui->sliderGain->value());
+    scopeConfig.writeEntry("colorspace_ypbpr", m_aColorSpace_YPbPr->isChecked());
+    scopeConfig.sync();
+}
 
+QRect Vectorscope::scopeRect()
+{
     // Distance from top/left/right
     int offset = 6;
 
     // We want to paint below the controls area. The line is the lowest element.
-    QPoint topleft(offset, ui->line->y()+offset);
+    QPoint topleft(offset, ui->verticalSpacer->geometry().y()+offset);
+    QPoint bottomright(ui->horizontalSpacer->geometry().right()-offset, this->size().height()-offset);
+
+    QRect scopeRect(topleft, bottomright);
 
     // Circle Width: min of width and height
-    cw = wh - topleft.y();
-    if (ww < cw) { cw = ww; }
-    cw -= 2*offset;
+    cw = (scopeRect.height() < scopeRect.width()) ? scopeRect.height() : scopeRect.width();
+    scopeRect.setWidth(cw);
+    scopeRect.setHeight(cw);
 
-    QRect scopeRect(topleft, QPoint(cw, cw) + topleft);
 
     m_centerPoint = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), QPointF(0,0));
     pR75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_R);
@@ -141,6 +185,12 @@ QRect Vectorscope::scopeRect()
     pCy75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_Cy);
     pMg75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_Mg);
     pYl75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YUV_Yl);
+    qR75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YPbPr_R);
+    qG75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YPbPr_G);
+    qB75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YPbPr_B);
+    qCy75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YPbPr_Cy);
+    qMg75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YPbPr_Mg);
+    qYl75 = m_vectorscopeGenerator->mapToCircle(scopeRect.size(), P75*VectorscopeGenerator::scaling*YPbPr_Yl);
 
     return scopeRect;
 }
@@ -154,7 +204,7 @@ QImage Vectorscope::renderHUD(uint)
 
     QImage hud;
 
-    if (m_circleEnabled) {
+    if (m_mouseWithinWidget) {
         // Mouse moved: Draw a circle over the scope
 
         hud = QImage(m_scopeRect.size(), QImage::Format_ARGB32);
@@ -176,7 +226,11 @@ QImage Vectorscope::renderHUD(uint)
             davinci.setPen(penLight);
             break;
         default:
-            davinci.setPen(penDark);
+            if (r > cw/2) {
+                davinci.setPen(penLight);
+            } else {
+                davinci.setPen(penDark);
+            }
             break;
         }
         davinci.drawEllipse(m_centerPoint, (int)r, (int)r);
@@ -186,7 +240,7 @@ QImage Vectorscope::renderHUD(uint)
         float angle = copysign(acos(dx/r)*180/M_PI, dy);
         davinci.drawText(QPoint(10, m_scopeRect.height()), i18n("%1°", QString::number(angle, 'f', 1)));
 
-        m_circleEnabled = false;
+//        m_circleEnabled = false;
     } else {
         hud = QImage(0, 0, QImage::Format_ARGB32);
     }
@@ -194,7 +248,7 @@ QImage Vectorscope::renderHUD(uint)
     return hud;
 }
 
-QImage Vectorscope::renderScope(uint accelerationFactor)
+QImage Vectorscope::renderScope(uint accelerationFactor, const QImage qimage)
 {
     QTime start = QTime::currentTime();
     QImage scope;
@@ -203,18 +257,18 @@ QImage Vectorscope::renderScope(uint accelerationFactor)
         qDebug() << "Scope size not known yet. Aborting.";
     } else {
 
+        VectorscopeGenerator::ColorSpace colorSpace = m_aColorSpace_YPbPr->isChecked() ?
+                                                      VectorscopeGenerator::ColorSpace_YPbPr : VectorscopeGenerator::ColorSpace_YUV;
+        VectorscopeGenerator::PaintMode paintMode = (VectorscopeGenerator::PaintMode) ui->paintMode->itemData(ui->paintMode->currentIndex()).toInt();
         scope = m_vectorscopeGenerator->calculateVectorscope(m_scopeRect.size(),
-                                                             m_activeRender->extractFrame(m_activeRender->seekFramePosition()),
-                                                             m_gain, (VectorscopeGenerator::PaintMode) ui->paintMode->itemData(ui->paintMode->currentIndex()).toInt(),
+                                                             qimage,
+                                                             m_gain, paintMode, colorSpace,
                                                              m_aAxisEnabled->isChecked(), accelerationFactor);
 
     }
 
     unsigned int mseconds = start.msecsTo(QTime::currentTime());
-//    qDebug() << "Scope rendered in " << mseconds << " ms. Sending finished signal.";
-//    emit signalScopeCalculationFinished(mseconds, skipPixels);
     emit signalScopeRenderingFinished(mseconds, accelerationFactor);
-//    qDebug() << "xxScope: Signal finished sent.";
     return scope;
 }
 
@@ -232,6 +286,9 @@ QImage Vectorscope::renderBackground(uint)
     case BG_CHROMA:
         bg = m_colorTools->yuvColorWheel(m_scopeRect.size(), (unsigned char) 255, 1/VectorscopeGenerator::scaling, true, true);
         break;
+    case BG_YPbPr:
+        bg = m_colorTools->yPbPrColorWheel(m_scopeRect.size(), (unsigned char) 128, 1/VectorscopeGenerator::scaling, true);
+        break;
     default:
         qDebug() << "No background.";
         bg = QImage(cw, cw, QImage::Format_ARGB32);
@@ -251,29 +308,55 @@ QImage Vectorscope::renderBackground(uint)
     davinci.drawEllipse(0, 0, cw, cw);
 
     // Draw RGB/CMY points with 100% chroma
-    vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_R);
-    davinci.drawEllipse(vinciPoint, 4,4);
-    davinci.drawText(vinciPoint-QPoint(20, -10), "R");
+    if (m_aColorSpace_YUV->isChecked()) {
+        vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_R);
+        davinci.drawEllipse(vinciPoint, 4,4);
+        davinci.drawText(vinciPoint-QPoint(20, -10), "R");
+
+        vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_G);
+        davinci.drawEllipse(vinciPoint, 4,4);
+        davinci.drawText(vinciPoint-QPoint(20, 0), "G");
+
+        vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_B);
+        davinci.drawEllipse(vinciPoint, 4,4);
+        davinci.drawText(vinciPoint+QPoint(15, 10), "B");
+
+        vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_Cy);
+        davinci.drawEllipse(vinciPoint, 4,4);
+        davinci.drawText(vinciPoint+QPoint(15, -5), "Cy");
+
+        vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_Mg);
+        davinci.drawEllipse(vinciPoint, 4,4);
+        davinci.drawText(vinciPoint+QPoint(15, 10), "Mg");
+
+        vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_Yl);
+        davinci.drawEllipse(vinciPoint, 4,4);
+        davinci.drawText(vinciPoint-QPoint(25, 0), "Yl");
+    } else {
+        vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YPbPr_R);
+        davinci.drawEllipse(vinciPoint, 4,4);
+        davinci.drawText(vinciPoint-QPoint(20, -10), "R");
 
-    vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_G);
-    davinci.drawEllipse(vinciPoint, 4,4);
-    davinci.drawText(vinciPoint-QPoint(20, 0), "G");
+        vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YPbPr_G);
+        davinci.drawEllipse(vinciPoint, 4,4);
+        davinci.drawText(vinciPoint-QPoint(20, 0), "G");
 
-    vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_B);
-    davinci.drawEllipse(vinciPoint, 4,4);
-    davinci.drawText(vinciPoint+QPoint(15, 10), "B");
+        vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YPbPr_B);
+        davinci.drawEllipse(vinciPoint, 4,4);
+        davinci.drawText(vinciPoint+QPoint(15, 10), "B");
 
-    vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_Cy);
-    davinci.drawEllipse(vinciPoint, 4,4);
-    davinci.drawText(vinciPoint+QPoint(15, -5), "Cy");
+        vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YPbPr_Cy);
+        davinci.drawEllipse(vinciPoint, 4,4);
+        davinci.drawText(vinciPoint+QPoint(15, -5), "Cy");
 
-    vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_Mg);
-    davinci.drawEllipse(vinciPoint, 4,4);
-    davinci.drawText(vinciPoint+QPoint(15, 10), "Mg");
+        vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YPbPr_Mg);
+        davinci.drawEllipse(vinciPoint, 4,4);
+        davinci.drawText(vinciPoint+QPoint(15, 10), "Mg");
 
-    vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YUV_Yl);
-    davinci.drawEllipse(vinciPoint, 4,4);
-    davinci.drawText(vinciPoint-QPoint(25, 0), "Yl");
+        vinciPoint = m_vectorscopeGenerator->mapToCircle(m_scopeRect.size(), VectorscopeGenerator::scaling*YPbPr_Yl);
+        davinci.drawEllipse(vinciPoint, 4,4);
+        davinci.drawText(vinciPoint-QPoint(25, 0), "Yl");
+    }
 
     switch (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt()) {
     case BG_NONE:
@@ -304,22 +387,40 @@ QImage Vectorscope::renderBackground(uint)
 
     // Draw 75% box
     if (m_a75PBox->isChecked()) {
-        davinci.drawLine(pR75, pYl75);
-        davinci.drawLine(pYl75, pG75);
-        davinci.drawLine(pG75, pCy75);
-        davinci.drawLine(pCy75, pB75);
-        davinci.drawLine(pB75, pMg75);
-        davinci.drawLine(pMg75, pR75);
+        if (m_aColorSpace_YUV->isChecked()) {
+            davinci.drawLine(pR75, pYl75);
+            davinci.drawLine(pYl75, pG75);
+            davinci.drawLine(pG75, pCy75);
+            davinci.drawLine(pCy75, pB75);
+            davinci.drawLine(pB75, pMg75);
+            davinci.drawLine(pMg75, pR75);
+        } else {
+            davinci.drawLine(qR75, qYl75);
+            davinci.drawLine(qYl75, qG75);
+            davinci.drawLine(qG75, qCy75);
+            davinci.drawLine(qCy75, qB75);
+            davinci.drawLine(qB75, qMg75);
+            davinci.drawLine(qMg75, qR75);
+        }
     }
 
     // Draw RGB/CMY points with 75% chroma (for NTSC)
     davinci.setPen(penThin);
-    davinci.drawEllipse(pR75, 3,3);
-    davinci.drawEllipse(pG75, 3,3);
-    davinci.drawEllipse(pB75, 3,3);
-    davinci.drawEllipse(pCy75, 3,3);
-    davinci.drawEllipse(pMg75, 3,3);
-    davinci.drawEllipse(pYl75, 3,3);
+    if (m_aColorSpace_YUV->isChecked()) {
+        davinci.drawEllipse(pR75, 3,3);
+        davinci.drawEllipse(pG75, 3,3);
+        davinci.drawEllipse(pB75, 3,3);
+        davinci.drawEllipse(pCy75, 3,3);
+        davinci.drawEllipse(pMg75, 3,3);
+        davinci.drawEllipse(pYl75, 3,3);
+    } else {
+        davinci.drawEllipse(qR75, 3,3);
+        davinci.drawEllipse(qG75, 3,3);
+        davinci.drawEllipse(qB75, 3,3);
+        davinci.drawEllipse(qCy75, 3,3);
+        davinci.drawEllipse(qMg75, 3,3);
+        davinci.drawEllipse(qYl75, 3,3);
+    }
 
     // Draw realtime factor (number of skipped pixels)
     if (m_aRealtime->isChecked()) {
@@ -372,25 +473,23 @@ void Vectorscope::slotBackgroundChanged()
     forceUpdateBackground();
 }
 
-
-
-///// Events /////
-
-void Vectorscope::mouseMoveEvent(QMouseEvent *event)
-{
-    // Draw a circle around the center,
-    // showing percentage number of the radius length
-
-    m_circleEnabled = true;
-    m_mousePos = event->pos();
-    forceUpdateHUD();
-}
-
-void Vectorscope::leaveEvent(QEvent *event)
+void Vectorscope::slotColorSpaceChanged()
 {
-    // Repaint the HUD without the circle
-
-    m_circleEnabled = false;
-    QWidget::leaveEvent(event);
-    forceUpdateHUD();
+    int index;
+    if (m_aColorSpace_YPbPr->isChecked()) {
+        if (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt() == BG_YUV) {
+            index = ui->backgroundMode->findData(QVariant(BG_YPbPr));
+            if (index >= 0) {
+                ui->backgroundMode->setCurrentIndex(index);
+            }
+        }
+    } else {
+        if (ui->backgroundMode->itemData(ui->backgroundMode->currentIndex()).toInt() == BG_YPbPr) {
+            index = ui->backgroundMode->findData(QVariant(BG_YUV));
+            if (index >= 0) {
+                ui->backgroundMode->setCurrentIndex(index);
+            }
+        }
+    }
+    forceUpdate();
 }