BUG: restore mouse interaction with ctkTransferFunctionWidget

Libs/Widgets/ctkTransferFunctionControlPointsItem.cpp

@@ -30,6 +30,7 @@
 /// CTK includes
 #include "ctkTransferFunctionControlPointsItem.h"
 #include "ctkTransferFunctionScene.h"
+#include "ctkTransferFunctionWidget.h"
 
 //-----------------------------------------------------------------------------
 class ctkTransferFunctionControlPointsItemPrivate: 
@@ -39,14 +40,14 @@ public:
   ctkTransferFunctionControlPointsItemPrivate();
   void init();
   QList<QPointF> ControlPoints;
-  QSizeF         PointSize;
+  QSize          PointSize;
   int            SelectedPoint;
 };
 
 //-----------------------------------------------------------------------------
 ctkTransferFunctionControlPointsItemPrivate::ctkTransferFunctionControlPointsItemPrivate()
 {
-  this->PointSize = QSizeF(12,12);
+  this->PointSize = QSize(12,12);
   this->SelectedPoint = -1;
 }
 
@@ -120,31 +121,35 @@ void ctkTransferFunctionControlPointsItem::mousePressEvent(QGraphicsSceneMouseEv
 {
   qDebug() << "mouse press caught";
   CTK_D(ctkTransferFunctionControlPointsItem);
-  QRectF pointArea(QPointF(0,0), d->PointSize*2.);
+  QWidget* w = e->widget();
+  ctkTransferFunctionWidget* view = qobject_cast<ctkTransferFunctionWidget*>(e->widget()->parentWidget());
+  Q_ASSERT(view);
+  // e->pos() is ok, pointArea should be in the world coordiate
+  QRect pointViewArea(QPoint(-d->PointSize.width() / 2, -d->PointSize.height() / 2), d->PointSize);
+  QPolygonF pointItemArea = this->mapFromScene(view->mapToScene(pointViewArea));
   d->SelectedPoint = -1;
   for(int i = 0; i < d->ControlPoints.count(); ++i)
     {
-    pointArea.moveCenter(d->ControlPoints[i]);
-    if (pointArea.contains(e->pos()))
+    if (pointItemArea.translated(d->ControlPoints[i]).containsPoint(e->pos(), Qt::OddEvenFill))
       {
       d->SelectedPoint = i;
       break;
       }
     }
-  if (d->SelectedPoint < 0)
+  if (d->SelectedPoint >= 0)
     {
-    //QPointF currentPoint( e->pos() );
-  //  e->pos()->x();
-    //this->transferFunction()->insertControlPoint( e->pos().x() );
-
+    return;
+    }
+  ctkTransferFunctionScene* tfScene = dynamic_cast<ctkTransferFunctionScene*>(this->scene());
+  Q_ASSERT(tfScene);
+  
   // convert coordinates
-  QPointF functionCoordinates = screen2TransferFunctionCoordinates( e->pos().x(), e->pos().y());
+  QPointF tfPos = tfScene->mapPointFromScene(e->pos());
   // add point to transfer function
   // returns index
-  int index = this->transferFunction()->insertControlPoint( functionCoordinates.x());
+  int index = this->transferFunction()->insertControlPoint( tfPos.x());
   // update value of the point
-  this->transferFunction()->setControlPointValue( index, functionCoordinates.y());
-    }
+  this->transferFunction()->setControlPointValue( index, tfPos.y());
 }
 
 //-----------------------------------------------------------------------------
@@ -157,12 +162,15 @@ void ctkTransferFunctionControlPointsItem::mouseMoveEvent(QGraphicsSceneMouseEve
     e->ignore();
     return;
     }
-  qreal range[2];
-  this->transferFunction()->range(range);
-  qreal newPos = range[0] + e->pos().x() / (this->rect().width() / (range[1] - range[0]));
-  newPos = qBound(range[0], newPos, range[1]);
-  this->transferFunction()->setControlPointPos(d->SelectedPoint, newPos);
-  //this->transferFunction()->setControlPointValue(d->SelectedPoint, e->y());
+  //qreal range[2];
+  //this->transferFunction()->range(range);
+  //qreal newPos = range[0] + e->pos().x() / (this->rect().width() / (range[1] - range[0]));
+  //newPos = qBound(range[0], newPos, range[1]);
+  ctkTransferFunctionScene* tfScene = dynamic_cast<ctkTransferFunctionScene*>(this->scene());
+  Q_ASSERT(tfScene);
+  QPointF newPos = tfScene->mapPointFromScene(e->pos());
+  this->transferFunction()->setControlPointPos(d->SelectedPoint, newPos.x());
+  this->transferFunction()->setControlPointValue(d->SelectedPoint, newPos.y());
 }
 
 //-----------------------------------------------------------------------------

Libs/Widgets/ctkTransferFunctionScene.cpp

@@ -164,7 +164,7 @@ void ctkTransferFunctionScene::computeCurve()
   ctkControlPoint* startCP = d->TransferFunction->controlPoint(0);
   ctkControlPoint* nextCP = 0;
 
-  QPointF startPos = this->mapPointToScreen(startCP);
+  QPointF startPos = this->mapPointToScene(startCP);
   
   d->Points.clear();
   d->Points << startPos;
@@ -180,10 +180,10 @@ void ctkTransferFunctionScene::computeCurve()
       int j;
       for (j = 1; j < points.count(); ++j)
         {
-        d->Path.lineTo(this->mapPointToScreen(points[j]));
+        d->Path.lineTo(this->mapPointToScene(points[j]));
         }
       j = points.count() - 1;
-      d->Points << this->mapPointToScreen(points[j]);
+      d->Points << this->mapPointToScene(points[j]);
       }
     else //dynamic_cast<ctkBezierControlPoint*>(startCP))
       {
@@ -192,7 +192,7 @@ void ctkTransferFunctionScene::computeCurve()
       QList<QPointF> bezierPoints;
       foreach(const ctkPoint& p, points)
         {
-        bezierPoints << this->mapPointToScreen(p);
+        bezierPoints << this->mapPointToScene(p);
         }
       d->Path.cubicTo(bezierPoints[1], bezierPoints[2], bezierPoints[3]);
       d->Points << bezierPoints[3];
@@ -231,7 +231,7 @@ void ctkTransferFunctionScene::computeGradient()
   ctkControlPoint* startCP = d->TransferFunction->controlPoint(0);
   ctkControlPoint* nextCP = 0;
 
-  qreal startPos = this->mapXToScreen(this->posX(startCP->x()));
+  qreal startPos = this->mapXToScene(this->posX(startCP->x()));
   qreal nextPos;
   
   d->Gradient = QLinearGradient(0., 0., 1., 0.);
@@ -240,7 +240,7 @@ void ctkTransferFunctionScene::computeGradient()
   for(int i = 1; i < count; ++i)
     {
     nextCP = d->TransferFunction->controlPoint(i);
-    nextPos = this->mapXToScreen(this->posX(nextCP));
+    nextPos = this->mapXToScene(this->posX(nextCP));
     if (this->transferFunction()->isDiscrete())
       {
       qreal midPoint = (startPos + nextPos)  / 2;
@@ -252,7 +252,7 @@ void ctkTransferFunctionScene::computeGradient()
       QList<ctkPoint> points = this->nonLinearPoints(startCP, nextCP);
       foreach(const ctkPoint& p, points)
         {
-        d->Gradient.setColorAt(this->mapXToScreen(this->posX(p)), this->color(p));
+        d->Gradient.setColorAt(this->mapXToScene(this->posX(p)), this->color(p));
         }
       //no need, d->Gradient.setColorAt(nextPos, this->color(nextCP));
       }
@@ -263,9 +263,9 @@ void ctkTransferFunctionScene::computeGradient()
       QList<QPointF> bezierPoints;
       foreach(const ctkPoint& p, points)
         {
-        d->Gradient.setColorAt(this->mapXToScreen(this->posX(p)), this->color(p));
+        d->Gradient.setColorAt(this->mapXToScene(this->posX(p)), this->color(p));
         }
-      nextPos = this->mapXToScreen(this->posX(points[points.size() - 1])); 
+      nextPos = this->mapXToScene(this->posX(points[points.size() - 1])); 
       }
     //qDebug() << i << points[0] << points[1] << points[2] << points[3];
     delete startCP;
@@ -399,43 +399,43 @@ qreal ctkTransferFunctionScene::posY(const QVariant& value)const
 }
 
 //-----------------------------------------------------------------------------
-QPointF ctkTransferFunctionScene::mapPointToScreen(const ctkControlPoint* cp)const
+QPointF ctkTransferFunctionScene::mapPointToScene(const ctkControlPoint* cp)const
 {
-  return QPointF(this->mapXToScreen(this->posX(cp->x())),
-                 this->mapYToScreen(this->posY(cp->value())));
+  return QPointF(this->mapXToScene(this->posX(cp->x())),
+                 this->mapYToScene(this->posY(cp->value())));
 }
 
 //-----------------------------------------------------------------------------
-QPointF ctkTransferFunctionScene::mapPointToScreen(const ctkPoint& point)const
+QPointF ctkTransferFunctionScene::mapPointToScene(const ctkPoint& point)const
 {
-  return QPointF( this->mapXToScreen(this->posX(point.X)),
-                  this->mapYToScreen(this->posY(point.Value)));
+  return QPointF( this->mapXToScene(this->posX(point.X)),
+                  this->mapYToScene(this->posY(point.Value)));
 }
 
 //-----------------------------------------------------------------------------
-qreal ctkTransferFunctionScene::mapXToScreen(qreal xPos)const
+qreal ctkTransferFunctionScene::mapXToScene(qreal xPos)const
 {
   CTK_D(const ctkTransferFunctionScene);
   return (xPos - d->RangeXOffSet) * d->RangeXDiff;
 }
 
 //-----------------------------------------------------------------------------
-qreal ctkTransferFunctionScene::mapYToScreen(qreal yPos)const
+qreal ctkTransferFunctionScene::mapYToScene(qreal yPos)const
 {
   CTK_D(const ctkTransferFunctionScene);
   return this->height() - (yPos - d->RangeYOffSet) * d->RangeYDiff;
 }
 
 //-----------------------------------------------------------------------------
-qreal ctkTransferFunctionScene::mapXFromScreen(qreal screenPosX)const
+qreal ctkTransferFunctionScene::mapXFromScene(qreal scenePosX)const
 {
   CTK_D(const ctkTransferFunctionScene);
-  return (screenPosX / d->RangeXDiff) + d->RangeXOffSet;
+  return (scenePosX / d->RangeXDiff) + d->RangeXOffSet;
 }
 
 //-----------------------------------------------------------------------------
-qreal ctkTransferFunctionScene::mapYFromScreen(qreal screenPosY)const
+qreal ctkTransferFunctionScene::mapYFromScene(qreal scenePosY)const
 {
   CTK_D(const ctkTransferFunctionScene);
-  return ((this->height() - screenPosY) / d->RangeYDiff) + d->RangeYOffSet ;
+  return ((this->height() - scenePosY) / d->RangeYDiff) + d->RangeYOffSet ;
 }

Libs/Widgets/ctkTransferFunctionScene.h

@@ -58,13 +58,15 @@ public:
   qreal posY(const QVariant& tfV)const;
   QColor color(const QVariant& tfV) const;
   
-  QPointF mapPointToScreen(const ctkControlPoint* cp)const;
-  QPointF mapPointToScreen(const ctkPoint& point)const;
+  QPointF mapPointToScene(const ctkControlPoint* cp)const;
+  QPointF mapPointToScene(const ctkPoint& point)const;
+  
  
-  qreal mapXToScreen(qreal posX)const;
-  qreal mapYToScreen(qreal posY)const;
-  qreal mapXFromScreen(qreal screenPosX)const;
-  qreal mapYFromScreen(qreal screenPosY)const;
+  qreal mapXToScene(qreal posX)const;
+  qreal mapYToScene(qreal posY)const;
+  qreal mapXFromScene(qreal ScenePosX)const;
+  qreal mapYFromScene(qreal ScenePosY)const;
+  inline QPointF mapPointFromScene(const QPointF& point)const;
 
   QList<ctkPoint> bezierParams(ctkControlPoint* start, ctkControlPoint* end) const;
   QList<ctkPoint> nonLinearPoints(ctkControlPoint* start, ctkControlPoint* end) const;
@@ -114,4 +116,10 @@ QColor ctkTransferFunctionScene::color(const ctkPoint& point) const
   return this->color(point.Value);
 }
 
+QPointF ctkTransferFunctionScene::mapPointFromScene(const QPointF& point)const
+{
+  return QPointF(this->mapXFromScene(point.x()),
+                 this->mapYFromScene(point.y()));
+}
+
 #endif