ENH: Libs/Core-Visualization-Widget: Transfer function: cleaning, possibility to add point with click

Libs/Core/ctkTransferFunction.h

@@ -90,6 +90,7 @@ public:
   virtual QVariant maxValue()const = 0;
   ///
   virtual int insertControlPoint(const ctkControlPoint& cp) = 0;
+  virtual int insertControlPoint(qreal pos) = 0;
 
   /// 
   /// be careful with it, as changing the value might require

Libs/Visualization/VTK/Core/ctkVTKColorTransferFunction.cpp

@@ -227,7 +227,15 @@ int ctkVTKColorTransferFunction::insertControlPoint(const ctkControlPoint& cp)
     }
   return index;
 }
+//-----------------------------------------------------------------------------
+// insert point with value = 0
+int ctkVTKColorTransferFunction::insertControlPoint(qreal pos)
+{
+  // nothing
+  int index = 0;
 
+  return index;
+}
 //-----------------------------------------------------------------------------
 void ctkVTKColorTransferFunction::setControlPointPos(int index, qreal pos)
 {

Libs/Visualization/VTK/Core/ctkVTKColorTransferFunction.h

@@ -53,6 +53,8 @@ public:
   virtual QVariant maxValue()const;
 
   virtual int insertControlPoint(const ctkControlPoint& cp);
+  virtual int insertControlPoint(qreal pos);
+
   virtual void setControlPointPos(int index, qreal pos);
   virtual void setControlPointValue(int index, const QVariant& value);
   

Libs/Visualization/VTK/Core/ctkVTKLookupTable.cpp

@@ -155,7 +155,15 @@ int ctkVTKLookupTable::insertControlPoint(const ctkControlPoint& cp)
   qDebug() << "ctkVTKLookupTable doesn't support insertControlPoint";
   return -1;
 }
+//-----------------------------------------------------------------------------
+// insert point with value = 0
+int ctkVTKLookupTable::insertControlPoint(qreal pos)
+{
+  // nothing
+  int index = 0;
 
+  return index;
+}
 //-----------------------------------------------------------------------------
 void ctkVTKLookupTable::setControlPointPos(int index, qreal pos)
 {

Libs/Visualization/VTK/Core/ctkVTKLookupTable.h

@@ -52,6 +52,8 @@ public:
   virtual QVariant maxValue()const;
 
   virtual int insertControlPoint(const ctkControlPoint& cp);
+  virtual int insertControlPoint(qreal pos);
+
   virtual void setControlPointPos(int index, qreal pos);
   virtual void setControlPointValue(int index, const QVariant& value);
 

Libs/Visualization/VTK/Core/ctkVTKPiecewiseFunction.cpp

@@ -171,12 +171,12 @@ ctkControlPoint* ctkVTKPiecewiseFunction::controlPoint(int index)const
            values[2] >= 0. && values[2] <= 1. &&                // Midpoint
            values[3] >= 0. && values[3] <= 1. );                // Sharpness
 
-  double subPoints[30];
-  d->PiecewiseFunction->GetTable(cp->x(), values[0], 10, subPoints);
-  qreal interval = (values[0] - cp->x()) / 9.;
+  double subPoints[100];
+  d->PiecewiseFunction->GetTable(cp->x(), values[0], 100, subPoints);
+  qreal interval = (values[0] - cp->x()) / 99.;
 
   // subPoints[i] since value varies (not like in color transfer function widget)
-  for(int i = 0; i < 10; ++i)
+  for(int i = 0; i < 100; ++i)
     {
     cp->SubPoints << ctkPoint(cp->x() + interval*i, subPoints[i]);
     }
@@ -218,6 +218,20 @@ int ctkVTKPiecewiseFunction::insertControlPoint(const ctkControlPoint& cp)
     }
   return index;
 }
+//-----------------------------------------------------------------------------
+// insert point with value = 0
+int ctkVTKPiecewiseFunction::insertControlPoint(qreal pos)
+{
+  CTK_D(ctkVTKPiecewiseFunction);
+  int index = -1;
+  if (d->PiecewiseFunction.GetPointer() == 0)
+    {
+    return index;
+    }
+  index = d->PiecewiseFunction->AddPoint( pos, 0);
+  qDebug() << "index of new point: " << index;
+  return index;
+}
 
 //-----------------------------------------------------------------------------
 void ctkVTKPiecewiseFunction::setControlPointPos(int index, qreal pos)
@@ -235,10 +249,11 @@ void ctkVTKPiecewiseFunction::setControlPointPos(int index, qreal pos)
 void ctkVTKPiecewiseFunction::setControlPointValue(int index, const QVariant& value)
 {
   CTK_D(ctkVTKPiecewiseFunction);
-  Q_ASSERT(value.value<QColor>().isValid());
-  QColor rgb = value.value<QColor>();
   double values[4];
   d->PiecewiseFunction->GetNodeValue(index, values);
+  qDebug() << "old value: " << values[1];
+  values[1] = value.toDouble();
+  qDebug() << "new value: " << values[1];
   // setNodeValue should eventually fired the signal changed()
   d->PiecewiseFunction->SetNodeValue(index, values);
 }

Libs/Visualization/VTK/Core/ctkVTKPiecewiseFunction.h

@@ -52,6 +52,8 @@ public:
   virtual QVariant maxValue()const;
 
   virtual int insertControlPoint(const ctkControlPoint& cp);
+  virtual int insertControlPoint(qreal pos);
+
   virtual void setControlPointPos(int index, qreal pos);
   virtual void setControlPointValue(int index, const QVariant& value);
 

Libs/Visualization/VTK/Widgets/Testing/Cpp/ctkTransferFunctionWidgetTest3.cpp

@@ -43,8 +43,11 @@ int ctkTransferFunctionWidgetTest3(int argc, char * argv [] )
   vtkSmartPointer<vtkPiecewiseFunction> pwf =
     vtkSmartPointer<vtkPiecewiseFunction>::New();
   //
-  pwf->AddPoint(0.2, 1.);
-  pwf->AddPoint(0.8, 2.);
+  pwf->AddPoint(0., 1.);
+  pwf->AddPoint(0.2, 1.2);
+  pwf->AddPoint(0.3, 1.5);
+  pwf->AddPoint(0.4, 2., 0.5, 0.5);
+  pwf->AddPoint(0.9, 1.5);
 
   QSharedPointer<ctkTransferFunction> transferFunction =
     QSharedPointer<ctkTransferFunction>(new ctkVTKPiecewiseFunction(pwf));
@@ -52,8 +55,8 @@ int ctkTransferFunctionWidgetTest3(int argc, char * argv [] )
   // the widget is not really shown here, only when app.exec() is called
   transferFunctionWidget.show();
 
-  QTimer autoExit;
-  QObject::connect(&autoExit, SIGNAL(timeout()), &app, SLOT(quit()));
-  autoExit.start(1000);
+//  QTimer autoExit;
+//  QObject::connect(&autoExit, SIGNAL(timeout()), &app, SLOT(quit()));
+//  autoExit.start(1000);
   return app.exec();
 }

Libs/Widgets/ctkTransferFunctionControlPointsItem.cpp

@@ -89,54 +89,20 @@ void ctkTransferFunctionControlPointsItem::paint(
     {
     return;
     }
-  qreal rangeX[2];
-  this->transferFunction()->range(rangeX);
-  qreal rangeXDiff = this->rect().width() / (rangeX[1] - rangeX[0]);
-  qreal rangeXOffSet = rangeX[0];
-
-  QVariant rangeY[2];
-  rangeY[0] = this->transferFunction()->minValue();
-  rangeY[1] = this->transferFunction()->maxValue();
-  qreal rangeYDiff = this->rect().height();
-  qreal rangeYOffSet; 
-  if (rangeY[0].canConvert<qreal>())
-    {
-    if (rangeY[1].toReal() == rangeY[0].toReal())
-      {
-      rangeYDiff /= rangeY[0].toReal();
-      rangeYOffSet = 0.;
-      }
-    else
-      {
-      rangeYDiff /= rangeY[1].toReal() - rangeY[0].toReal();
-      rangeYOffSet = rangeY[0].toReal();
-      }
-    }
-  else if (rangeY[0].canConvert<QColor>())
-    {
-    if ( rangeY[1].value<QColor>().alphaF() == rangeY[0].value<QColor>().alphaF())
-      {
-      rangeYDiff /= rangeY[0].value<QColor>().alphaF();
-      rangeYOffSet = 0.;
-      }
-    else
-      {
-      rangeYDiff /= rangeY[1].value<QColor>().alphaF() - rangeY[0].value<QColor>().alphaF();
-      rangeYOffSet = rangeY[0].value<QColor>().alphaF();
-      }
-    }
-  else
-    {
-    Q_ASSERT(rangeY[0].canConvert<qreal>() ||
-             rangeY[0].canConvert<QColor>());
-    }
+
+  qreal rangeXDiff = this->rangeXDiff();
+  qreal rangeXOffSet = this->rangeXOffSet();
+
+  qreal rangeYDiff = this->rangeYDiff();
+  qreal rangeYOffSet = this->rangeYDiff();
+
   ctkControlPoint* startCP = this->transferFunction()->controlPoint(0);
   ctkControlPoint* endCP = 0;
   qreal start = 0;
   qreal end = 0;
 
   QPainterPath path;
-
+ // this->x(controlpoint)
   QPointF startPos(startCP->x() - rangeXOffSet, this->y(startCP->value()) - rangeYOffSet);
   startPos.rx() *= rangeXDiff;
   startPos.setY(this->rect().height() 
@@ -156,12 +122,14 @@ void ctkTransferFunctionControlPointsItem::paint(
       for (j = 1; j < points.count(); ++j)
         {
         path.lineTo(
-          QPointF((points[j].X - rangeXOffSet) * rangeXDiff, this->rect().height() - 
-                  (this->y(points[j].Value) - rangeYOffSet) * rangeYDiff));
+          QPointF(
+            this->transferFunction2ScreenCoordinates(points[j].X,
+                                                     this->y(points[j].Value))));
         }
       j = points.count() - 1;
-      d->ControlPoints << QPointF((points[j].X - rangeXOffSet) * rangeXDiff, this->rect().height() - 
-                  (this->y(points[j].Value)- rangeYOffSet) * rangeYDiff );
+      d->ControlPoints << QPointF( this->transferFunction2ScreenCoordinates(
+        points[j].X,
+        this->y(points[j].Value)));
       }
     else //dynamic_cast<ctkBezierControlPoint*>(startCP))
       {
@@ -201,6 +169,7 @@ void ctkTransferFunctionControlPointsItem::paint(
 //-----------------------------------------------------------------------------
 void ctkTransferFunctionControlPointsItem::mousePressEvent(QGraphicsSceneMouseEvent* e)
 {
+  qDebug() << "mouse press caught";
   CTK_D(ctkTransferFunctionControlPointsItem);
   QRectF pointArea(QPointF(0,0), d->PointSize*2.);
   d->SelectedPoint = -1;
@@ -215,13 +184,24 @@ void ctkTransferFunctionControlPointsItem::mousePressEvent(QGraphicsSceneMouseEv
     }
   if (d->SelectedPoint < 0)
     {
-    e->ignore();
+    //QPointF currentPoint( e->pos() );
+  //  e->pos()->x();
+    //this->transferFunction()->insertControlPoint( e->pos().x() );
+
+  // convert coordinates
+  QPointF functionCoordinates = screen2TransferFunctionCoordinates( e->pos().x(), e->pos().y());
+  // add point to transfer function
+  // returns index
+  int index = this->transferFunction()->insertControlPoint( functionCoordinates.x());
+  // update value of the point
+  this->transferFunction()->setControlPointValue( index, functionCoordinates.y());
     }
 }
 
 //-----------------------------------------------------------------------------
 void ctkTransferFunctionControlPointsItem::mouseMoveEvent(QGraphicsSceneMouseEvent* e)
 {
+  qDebug() << "mouse caught";
   CTK_D(ctkTransferFunctionControlPointsItem);
   if (d->SelectedPoint < 0)
     {
@@ -239,6 +219,7 @@ void ctkTransferFunctionControlPointsItem::mouseMoveEvent(QGraphicsSceneMouseEve
 //-----------------------------------------------------------------------------
 void ctkTransferFunctionControlPointsItem::mouseReleaseEvent(QGraphicsSceneMouseEvent* e)
 {
+  qDebug() << "mouse release caught";
   CTK_D(ctkTransferFunctionControlPointsItem);
   if (d->SelectedPoint < 0)
     {

Libs/Widgets/ctkTransferFunctionControlPointsItem.h

@@ -42,6 +42,7 @@ public:
   virtual ~ctkTransferFunctionControlPointsItem();
 
   virtual void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget = 0);
+
 protected:
   virtual void mousePressEvent(QGraphicsSceneMouseEvent* e);
   virtual void mouseMoveEvent(QGraphicsSceneMouseEvent* e);

Libs/Widgets/ctkTransferFunctionItem.cpp

@@ -193,3 +193,125 @@ QColor ctkTransferFunctionItem::color(const QVariant& v) const
     }
   return QColor();
 }
+//-----------------------------------------------------------------------------
+qreal ctkTransferFunctionItem::rangeXDiff()
+{
+  // pointer to private class
+  CTK_D(ctkTransferFunctionItem);
+
+  qreal rangeX[2];
+  d->TransferFunction->range(rangeX);
+  return this->rect().width() / (rangeX[1] - rangeX[0]);
+}
+
+//-----------------------------------------------------------------------------
+qreal ctkTransferFunctionItem::rangeXOffSet()
+{
+  // pointer to private class
+  CTK_D(ctkTransferFunctionItem);
+
+  qreal rangeX[2];
+  d->TransferFunction->range(rangeX);
+  return rangeX[0];
+}
+
+//-----------------------------------------------------------------------------
+qreal ctkTransferFunctionItem::rangeYDiff()
+{
+  // pointer to private class
+  CTK_D(ctkTransferFunctionItem);
+
+  QVariant rangeY[2];
+  rangeY[0] = d->TransferFunction->minValue();
+  rangeY[1] = d->TransferFunction->maxValue();
+  qreal rangeYDiff = this->rect().height();
+  if (rangeY[0].canConvert<qreal>())
+    {
+    if (rangeY[1].toReal() == rangeY[0].toReal())
+      {
+      rangeYDiff /= rangeY[0].toReal();
+      return rangeYDiff;
+      }
+    else
+      {
+      rangeYDiff /= rangeY[1].toReal() - rangeY[0].toReal();
+      return rangeYDiff;
+      }
+    }
+    else if (rangeY[0].canConvert<QColor>())
+      {
+      if ( rangeY[1].value<QColor>().alphaF() == rangeY[0].value<QColor>().alphaF())
+        {
+        rangeYDiff /= rangeY[0].value<QColor>().alphaF();
+        return rangeYDiff;
+        }
+      else
+        {
+        rangeYDiff /= rangeY[1].value<QColor>().alphaF() - rangeY[0].value<QColor>().alphaF();
+        return rangeYDiff;
+        }
+      }
+    else
+      {
+      Q_ASSERT(rangeY[0].canConvert<qreal>() ||
+      rangeY[0].canConvert<QColor>());
+      }
+  return rangeYDiff;
+}
+
+//-----------------------------------------------------------------------------
+qreal ctkTransferFunctionItem::rangeYOffSet()
+{
+  // pointer to private class
+  CTK_D(ctkTransferFunctionItem);
+
+  QVariant rangeY[2];
+  rangeY[0] = d->TransferFunction->minValue();
+  rangeY[1] = d->TransferFunction->maxValue();
+  qreal rangeYOffSet;
+  if (rangeY[0].canConvert<qreal>())
+    {
+    if (rangeY[1].toReal() == rangeY[0].toReal())
+      {
+      return 0.;
+      }
+    else
+      {
+      return rangeY[0].toReal();
+      }
+    }
+  else if (rangeY[0].canConvert<QColor>())
+    {
+    if ( rangeY[1].value<QColor>().alphaF() == rangeY[0].value<QColor>().alphaF())
+      {
+      return 0.;
+      }
+    else
+      {
+      return rangeY[0].value<QColor>().alphaF();
+      }
+    }
+  else
+    {
+    Q_ASSERT(rangeY[0].canConvert<qreal>() ||
+        rangeY[0].canConvert<QColor>());
+    }
+  return 0;
+}
+
+//-----------------------------------------------------------------------------
+QPointF ctkTransferFunctionItem::transferFunction2ScreenCoordinates( qreal x, qreal y)
+{
+  QPointF screenCoordinates((x - this->rangeXOffSet() ) * this->rangeXDiff(),
+      this->rect().height() - (y - this->rangeYOffSet() ) * this->rangeYDiff() );
+  return screenCoordinates;
+}
+
+//-----------------------------------------------------------------------------
+QPointF ctkTransferFunctionItem::screen2TransferFunctionCoordinates( qreal x, qreal y)
+{
+  QPointF transferFunctionCoordinates((x / this->rangeXDiff() ) + this->rangeXOffSet(),
+      ( - y + this->rect().height() )/this->rangeYDiff() + this->rangeYOffSet());
+
+  return transferFunctionCoordinates;
+}

Libs/Widgets/ctkTransferFunctionItem.h

@@ -49,6 +49,16 @@ public:
   inline void setRect(qreal x, qreal y, qreal width, qreal height);
   void setRect(const QRectF& rectangle);
   QRectF rect()const;
+
+  qreal rangeXDiff();
+  qreal rangeXOffSet();
+
+  qreal rangeYDiff();
+  qreal rangeYOffSet();
+
+  QPointF transferFunction2ScreenCoordinates( qreal x, qreal y);
+  QPointF screen2TransferFunctionCoordinates( qreal x, qreal y);
+
   virtual QRectF boundingRect()const;
 protected:
   qreal y(const QVariant& value)const;
@@ -57,8 +67,6 @@ protected:
   QColor color(const QVariant& value)const;
   inline QColor color(const ctkPoint& point)const;
 
-
-
   QList<ctkPoint> bezierParams(ctkControlPoint* start, ctkControlPoint* end)const;
   QList<ctkPoint> nonLinearPoints(ctkControlPoint* start, ctkControlPoint* end)const;
 protected slots:

Libs/Widgets/ctkTransferFunctionWidget.cpp

@@ -20,6 +20,7 @@
 /// Qt includes
 #include <QGraphicsScene>
 #include <QResizeEvent>
+#include <QDebug>
 
 /// CTK includes
 #include "ctkTransferFunction.h"
@@ -63,7 +64,6 @@ ctkTransferFunctionWidget::ctkTransferFunctionWidget(
   ctk_d()->init();
   this->setTransferFunction(transferFunction);
 }
-
 //-----------------------------------------------------------------------------
 ctkTransferFunctionWidget::~ctkTransferFunctionWidget()
 {
@@ -111,4 +111,39 @@ void ctkTransferFunctionWidget::resizeEvent(QResizeEvent * event)
   // Control points are resized by the view transform, we want
   // fixed size control points, lines...
   //this->fitInView(this->scene()->sceneRect());
+  qDebug() << "resize event caught";
+}
+/*
+//-----------------------------------------------------------------------------
+void ctkTransferFunctionWidget::dragEnterEvent ( QDragEnterEvent * event )
+{
+  qDebug() << "drag event caught";
+
+  this->QGraphicsView::dragEnterEvent(event);
+
+}
+
+//-----------------------------------------------------------------------------
+void ctkTransferFunctionWidget::mousePressEvent ( QMouseEvent * event )
+{
+  qDebug() << "press event caught";
+  //One control point is added to the scene
+  // 1 - get position of the mouse
+  qDebug() << "x position " << event->x();
+  qDebug() << "y position " << event->y();
+
+  this->scene()->items()[1]->;
+
+  // 2nd item are the control points
+
+  this->QGraphicsView::mousePressEvent(event);
+}
+
+//-----------------------------------------------------------------------------
+void ctkTransferFunctionWidget::mouseReleaseEvent ( QMouseEvent * event )
+{
+  qDebug() << "release event caught";
+
+  this->QGraphicsView::mouseReleaseEvent(event);
 }
+*/

Libs/Widgets/ctkTransferFunctionWidget.h

@@ -44,6 +44,11 @@ public:
   ctkTransferFunction* transferFunction()const;
 protected:
   virtual void resizeEvent(QResizeEvent * event);
+  /*
+  virtual void dragEnterEvent ( QDragEnterEvent * event );
+  virtual void mousePressEvent ( QMouseEvent * event );
+  virtual void mouseReleaseEvent ( QMouseEvent * event );*/
+
 private:
   CTK_DECLARE_PRIVATE(ctkTransferFunctionWidget);
 };