Merge branch 'jcfr/master'

CMake/ctkFunctionCheckCompilerFlags.cmake

@@ -24,30 +24,19 @@
 #    2-myflags: -fprofile-arcs
 #    3-myflags: -fprofile-arcs -Wall
 
-FUNCTION(ctkFunctionCheckCompilerFlags CXX_FLAGS_TO_TEST RESULT_VAR)
+INCLUDE(TestCXXAcceptsFlag)
+
+FUNCTION(ctkFunctionCheckCompilerFlags CXX_FLAG_TO_TEST RESULT_VAR)
   
-  IF(CXX_FLAGS_TO_TEST STREQUAL "")
-    MESSAGE(FATAL_ERROR "CXX_FLAGS_TO_TEST shouldn't be empty")
+  IF(CXX_FLAG_TO_TEST STREQUAL "")
+    MESSAGE(FATAL_ERROR "CXX_FLAG_TO_TEST shouldn't be empty")
   ENDIF()
   
-  SET(bindir ${CMAKE_BINARY_DIR})
-  SET(srcfile ${bindir}/ctkFunctionCheckCompilerFlags.cpp)
-  
-  FILE(WRITE ${srcfile} "
-#include <iostream>
-int main(int, char**) { std::cout << \"Rock climbing is awesome\" << std::endl;}
-")
-  
-  SET(is_valid 0)
-  TRY_COMPILE(
-    is_valid ${bindir} ${srcfile}
-    CMAKE_FLAGS "-DCMAKE_CXX_FLAGS:STRING=${CXX_FLAGS_TO_TEST}"
-    )
-  
-  IF(is_valid)
-    SET(${RESULT_VAR} "${${RESULT_VAR}} ${CXX_FLAGS_TO_TEST}" PARENT_SCOPE)
+  CHECK_CXX_ACCEPTS_FLAG(${CXX_FLAG_TO_TEST} HAS_FLAG)
+
+  IF(HAS_FLAG)
+    SET(${RESULT_VAR} "${${RESULT_VAR}} ${CXX_FLAG_TO_TEST}" PARENT_SCOPE)
   ENDIF()
-  
-  MESSAGE(STATUS "Compiler Flags [${CXX_FLAGS_TO_TEST}] supported")
+
 ENDFUNCTION()
 

CMake/ctkFunctionExecuteProcess.cmake

@@ -19,6 +19,10 @@
 ###########################################################################
 
 #
+# Same as EXECUTE_PROCESS command except it can accept the extra parameter: PATH_LIST
+#
+# According to the platform, either PATH, LD_LIBRARY_PATH or DYLD_LIBRARY_PATH
+# will be updated using the paths specified using PATH_LIST
 #
 #
 
@@ -96,4 +100,4 @@ FUNCTION(ctkFunctionExecuteProcess)
 
   INCLUDE(${output_file})
   
-ENDFUNCTION()
+ENDFUNCTION()

CMakeLists.txt

@@ -150,6 +150,7 @@ INCLUDE(CMake/ctkFunctionGenerateDGraphInput.cmake)
 INCLUDE(CMake/ctkFunctionGenerateProjectXml.cmake)
 INCLUDE(CMake/ctkMacroGeneratePluginManifest.cmake)
 INCLUDE(CMake/ctkMacroGeneratePluginResourceFile.cmake)
+INCLUDE(CMake/ctkFunctionCheckCompilerFlags.cmake)
 
 # Used by CTKGenerateCTKConfig.cmake
 SET(CTK_CMAKE_DIR ${CTK_SOURCE_DIR}/CMake)
@@ -218,7 +219,7 @@ MARK_AS_ADVANCED(ADDITIONAL_CXX_FLAGS)
 #
 IF(CMAKE_CXX_COMPILER_ID)
   # Set the default symbol visibility to hidden for gcc
-  IF(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
+  IF("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
     SET(VISIBILITY_CXX_FLAGS "-fvisibility=hidden -fvisibility-inlines-hidden")
   ENDIF()
 ENDIF()
@@ -227,8 +228,8 @@ ENDIF()
 # Set coverage Flags
 #
 IF(WITH_COVERAGE)
-  IF(CMAKE_CXX_COMPILER_ID AND ${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
-    SET(coverage_flags "-g -fdiagnostics-show-option -fprofile-arcs -ftest-coverage -O3 -DNDEBUG")
+  IF("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    SET(coverage_flags "-g -fprofile-arcs -ftest-coverage -O3 -DNDEBUG")
     SET(COVERAGE_CXX_FLAGS ${coverage_flags})
     SET(COVERAGE_C_FLAGS ${coverage_flags})
   ENDIF()
@@ -240,8 +241,10 @@ ENDIF()
 SET(CTK_C_FLAGS "${COVERAGE_C_FLAGS} ${ADDITIONAL_C_FLAGS}")
 SET(CTK_CXX_FLAGS "${VISIBILITY_CXX_FLAGS} ${COVERAGE_CXX_FLAGS} ${ADDITIONAL_CXX_FLAGS}")
 
-IF(CMAKE_CXX_COMPILER_ID AND ${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
-  SET(cflags "-fdiagnostics-show-option -Wall -Wextra -Wpointer-arith -Winvalid-pch -Wcast-align -Wwrite-strings -fstack-protector-all -D_FORTIFY_SOURCE=2")
+IF("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+  SET(cflags "-Wall -Wextra -Wpointer-arith -Winvalid-pch -Wcast-align -Wwrite-strings -D_FORTIFY_SOURCE=2")
+  ctkFunctionCheckCompilerFlags("-fdiagnostics-show-option" cflags)
+  ctkFunctionCheckCompilerFlags("-fstack-protector-all" cflags)
   SET(CTK_C_FLAGS "${cflags} ${CTK_C_FLAGS}")
   SET(CTK_CXX_FLAGS "${cflags} -Woverloaded-virtual -Wold-style-cast -Wstrict-null-sentinel -Wsign-promo ${CTK_CXX_FLAGS}")
 ENDIF()

Libs/Core/CMakeLists.txt

@@ -47,6 +47,8 @@ SET(KIT_SRCS
   ctkSingleton.h
   ctkTransferFunction.cpp
   ctkTransferFunction.h
+  ctkTransferFunctionRepresentation.cpp
+  ctkTransferFunctionRepresentation.h
   ctkUtils.cpp
   ctkUtils.h
   )
@@ -64,6 +66,7 @@ SET(KIT_MOC_SRCS
   ctkHistogram.h
   ctkModelTester.h
   ctkTransferFunction.h
+  ctkTransferFunctionRepresentation.h
   )
 
 # UI files

Libs/Core/ctkCommandLineParser.cpp

@@ -23,6 +23,7 @@ public:
     this->IgnoreRest = ignoreRest;
     this->NumberOfParametersToProcess = 0;
     }
+  virtual ~CommandLineParserArgumentDescriptionBase(){}
   virtual bool addParameter(const QString& value) = 0;
   QString helpText(int fieldWidth, const char charPad);
   QString LongArg;
@@ -89,6 +90,7 @@ QString CommandLineParserArgumentDescriptionBase::helpText(int fieldWidth, const
       this->RegularExpression = _REGEXP;                                                \
       this->ArgumentType = #_TYPE;                                                      \
       }                                                                                 \
+    virtual ~ CommandLineParser##_NAME##ArgumentDescription(){}                         \
      virtual bool addParameter(const QString& value);                                   \
     _TYPE* Variable;                                                                    \
     _TYPE DefaultValue;                                                                 \

Libs/Core/ctkDependencyGraph.h

@@ -36,7 +36,7 @@ class CTK_CORE_EXPORT ctkDependencyGraph
 {
 public:
   ctkDependencyGraph(int nvertices);
-  ~ctkDependencyGraph();
+  virtual ~ctkDependencyGraph();
   
   void printAdditionalInfo();
   void printGraph();

Libs/Core/ctkLogger.cpp

@@ -22,124 +22,161 @@
 #include <QDebug>
 #include <QSqlDatabase>
 
-#include "ctkLogger.h"
+// CTK includes
+#include <ctkLogger.h>
 
-// log4cpp
-#include "log4qt/log4qt.h"
-#include "log4qt/logger.h"
-#include "log4qt/basicconfigurator.h"
+// Log4Qt includes
+#include <log4qt/log4qt.h>
+#include <log4qt/logger.h>
+#include <log4qt/basicconfigurator.h>
 
 class ctkLoggerPrivate: public ctkPrivate<ctkLogger>
 {
 public:
-  ctkLoggerPrivate() {};
-  ~ctkLoggerPrivate() {};
+  ctkLoggerPrivate(){};
+  ~ctkLoggerPrivate(){};
   Log4Qt::Logger *Logger;
 };
 
+//-----------------------------------------------------------------------------
 ctkLogger::ctkLogger(QString name, QObject* _parent): Superclass(_parent)
 {
   CTK_D(ctkLogger);
-  d->Logger = Log4Qt::Logger::logger( name.toStdString().c_str() );
+  d->Logger = Log4Qt::Logger::logger( name.toStdString().c_str());
 }
 
+//-----------------------------------------------------------------------------
 ctkLogger::~ctkLogger()
 {
 }
 
+//-----------------------------------------------------------------------------
 void ctkLogger::configure()
 {
   Log4Qt::BasicConfigurator::configure();
 }
 
-void ctkLogger::debug ( QString s ) 
+//-----------------------------------------------------------------------------
+void ctkLogger::debug(const QString& s)
 { 
   CTK_D(ctkLogger);
-  d->Logger->debug ( s );
+  d->Logger->debug(s);
 }
-void ctkLogger::info ( QString s ) 
+
+//-----------------------------------------------------------------------------
+void ctkLogger::info(const QString& s)
 { 
   CTK_D(ctkLogger);
-  d->Logger->info ( s );
+  d->Logger->info(s);
 }
-void ctkLogger::trace ( QString s ) 
+
+//-----------------------------------------------------------------------------
+void ctkLogger::trace(const QString& s)
 { 
   CTK_D(ctkLogger);
-  d->Logger->trace ( s );
+  d->Logger->trace(s);
 }
-void ctkLogger::warn ( QString s ) 
+
+//-----------------------------------------------------------------------------
+void ctkLogger::warn(const QString& s)
 { 
   CTK_D(ctkLogger);
-  d->Logger->warn ( s );
+  d->Logger->warn(s);
 }
-void ctkLogger::error ( QString s ) 
+
+//-----------------------------------------------------------------------------
+void ctkLogger::error(const QString& s)
 { 
   CTK_D(ctkLogger);
-  d->Logger->error ( s );
+  d->Logger->error(s);
 }
-void ctkLogger::fatal ( QString s ) 
+
+//-----------------------------------------------------------------------------
+void ctkLogger::fatal(const QString& s)
 { 
   CTK_D(ctkLogger);
-  d->Logger->fatal ( s );
+  d->Logger->fatal(s);
 }
 
-void ctkLogger::setDebug() 
+//-----------------------------------------------------------------------------
+void ctkLogger::setDebug()
 {
   CTK_D(ctkLogger);
-  d->Logger->setLevel ( Log4Qt::Level ( Log4Qt::Level::DEBUG_INT ) ); 
+  d->Logger->setLevel(Log4Qt::Level(Log4Qt::Level::DEBUG_INT));
 }
-void ctkLogger::setInfo() 
+
+//-----------------------------------------------------------------------------
+void ctkLogger::setInfo()
 { 
   CTK_D(ctkLogger);
-  d->Logger->setLevel ( Log4Qt::Level ( Log4Qt::Level::INFO_INT ) ); 
+  d->Logger->setLevel(Log4Qt::Level(Log4Qt::Level::INFO_INT));
 }
-void ctkLogger::setTrace() 
+
+//-----------------------------------------------------------------------------
+void ctkLogger::setTrace()
 { 
   CTK_D(ctkLogger);
-  d->Logger->setLevel ( Log4Qt::Level ( Log4Qt::Level::TRACE_INT ) ); 
+  d->Logger->setLevel(Log4Qt::Level(Log4Qt::Level::TRACE_INT));
 }
-void ctkLogger::setWarn() 
+
+//-----------------------------------------------------------------------------
+void ctkLogger::setWarn()
 { 
   CTK_D(ctkLogger);
-  d->Logger->setLevel ( Log4Qt::Level ( Log4Qt::Level::WARN_INT ) ); 
+  d->Logger->setLevel(Log4Qt::Level(Log4Qt::Level::WARN_INT));
 }
-void ctkLogger::setError() 
+
+//-----------------------------------------------------------------------------
+void ctkLogger::setError()
 { 
   CTK_D(ctkLogger);
-  d->Logger->setLevel ( Log4Qt::Level ( Log4Qt::Level::ERROR_INT ) ); 
+  d->Logger->setLevel(Log4Qt::Level(Log4Qt::Level::ERROR_INT));
 }
-void ctkLogger::setFatal() 
+
+//-----------------------------------------------------------------------------
+void ctkLogger::setFatal()
 { 
   CTK_D(ctkLogger);
-  d->Logger->setLevel ( Log4Qt::Level ( Log4Qt::Level::FATAL_INT ) ); 
+  d->Logger->setLevel(Log4Qt::Level(Log4Qt::Level::FATAL_INT));
 }
 
-bool ctkLogger::isDebugEnabled() 
+//-----------------------------------------------------------------------------
+bool ctkLogger::isDebugEnabled()
 { 
   CTK_D(ctkLogger);
   return d->Logger->isDebugEnabled(); 
 }
-bool ctkLogger::isInfoEnabled() 
+
+//-----------------------------------------------------------------------------
+bool ctkLogger::isInfoEnabled()
 { 
   CTK_D(ctkLogger);
   return d->Logger->isInfoEnabled(); 
 }
-bool ctkLogger::isTraceEnabled() 
+
+//-----------------------------------------------------------------------------
+bool ctkLogger::isTraceEnabled()
 { 
   CTK_D(ctkLogger);
   return d->Logger->isTraceEnabled(); 
 }
-bool ctkLogger::isWarnEnabled() 
+
+//-----------------------------------------------------------------------------
+bool ctkLogger::isWarnEnabled()
 { 
   CTK_D(ctkLogger);
   return d->Logger->isWarnEnabled(); 
 }
-bool ctkLogger::isErrorEnabled() 
+
+//-----------------------------------------------------------------------------
+bool ctkLogger::isErrorEnabled()
 { 
   CTK_D(ctkLogger);
   return d->Logger->isErrorEnabled(); 
 }
-bool ctkLogger::isFatalEnabled() 
+
+//-----------------------------------------------------------------------------
+bool ctkLogger::isFatalEnabled()
 { 
   CTK_D(ctkLogger);
   return d->Logger->isFatalEnabled(); 

Libs/Core/ctkLogger.h

@@ -34,17 +34,17 @@ class CTK_CORE_EXPORT ctkLogger : public QObject
   Q_OBJECT
 public:
   typedef QObject Superclass;
-  explicit ctkLogger ( QString name, QObject* parent = 0 );
+  explicit ctkLogger(QString name, QObject* parent = 0);
   virtual ~ctkLogger ();
 
   static void configure();
   
-  void debug ( QString s );
-  void info ( QString s );
-  void trace ( QString s );
-  void warn ( QString s );
-  void error ( QString s );
-  void fatal ( QString s );
+  void debug(const QString& s);
+  void info(const QString& s);
+  void trace(const QString& s);
+  void warn(const QString& s);
+  void error(const QString& s);
+  void fatal(const QString& s);
 
   void setDebug();
   void setInfo();

Libs/Core/ctkTransferFunction.cpp

@@ -19,6 +19,7 @@
 =========================================================================*/
 /// CTK includes
 #include "ctkTransferFunction.h"
+#include "ctkTransferFunctionRepresentation.h"
 
 //-----------------------------------------------------------------------------
 ctkControlPoint::~ctkControlPoint()
@@ -36,9 +37,26 @@ ctkNonLinearControlPoint::~ctkNonLinearControlPoint()
 }
 
 //-----------------------------------------------------------------------------
+class ctkTransferFunctionPrivate:public ctkPrivate<ctkTransferFunction>
+{
+public:
+  ctkTransferFunctionPrivate();
+  ctkTransferFunctionRepresentation* Representation;
+};
+
+//-----------------------------------------------------------------------------
+ctkTransferFunctionPrivate::ctkTransferFunctionPrivate()
+{
+  this->Representation = 0;
+}
+
+//-----------------------------------------------------------------------------
 ctkTransferFunction::ctkTransferFunction(QObject* parentObject)
   :QObject(parentObject)
 {
+  CTK_INIT_PRIVATE(ctkTransferFunction);
+  CTK_D(ctkTransferFunction);
+  d->Representation = new ctkTransferFunctionRepresentation(this);
 }
 
 //-----------------------------------------------------------------------------
@@ -51,3 +69,10 @@ ctkTransferFunction::~ctkTransferFunction()
   // this->ControlPoints->clear();
   // emit changed();
 }
+
+//-----------------------------------------------------------------------------
+ctkTransferFunctionRepresentation* ctkTransferFunction::representation()const
+{
+  CTK_D(const ctkTransferFunction);
+  return d->Representation;
+}

Libs/Core/ctkTransferFunction.h

@@ -28,8 +28,12 @@
 #include <QVariant>
 
 /// CTK includes
+#include "ctkPimpl.h"
 #include "CTKCoreExport.h"
 
+class ctkTransferFunctionPrivate;
+class ctkTransferFunctionRepresentation;
+
 //-----------------------------------------------------------------------------
 struct CTK_CORE_EXPORT ctkPoint
 {
@@ -104,8 +108,12 @@ public:
   /// be careful with it, as changing the value might require
   /// more changes to ctkControlPoint.
   virtual void setControlPointValue(int index, const QVariant& value)=0;
+
+  ctkTransferFunctionRepresentation* representation()const;
 signals:
   void changed();
+private:
+  CTK_DECLARE_PRIVATE(ctkTransferFunction);
 };
 
 //-----------------------------------------------------------------------------

Libs/Core/ctkTransferFunctionRepresentation.cpp

@@ -0,0 +1,510 @@
+/*=========================================================================
+
+  Library:   CTK
+
+  Copyright (c) 2010  Kitware Inc.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.commontk.org/LICENSE
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+=========================================================================*/
+/// Qt includes
+#include <QGraphicsScene>
+#include <QLinearGradient>
+#include <QResizeEvent>
+#include <QDebug>
+
+/// CTK includes
+#include "ctkTransferFunction.h"
+#include "ctkTransferFunctionRepresentation.h"
+
+/// STL includes
+#include <limits>
+
+//-----------------------------------------------------------------------------
+class ctkTransferFunctionRepresentationPrivate: public ctkPrivate<ctkTransferFunctionRepresentation>
+{
+  CTK_DECLARE_PUBLIC(ctkTransferFunctionRepresentation);
+public:
+  ctkTransferFunctionRepresentationPrivate();
+
+  ctkTransferFunction* TransferFunction;
+  QColor               VerticalGradientColor;
+
+  QPainterPath         Path;
+  QLinearGradient      Gradient;
+  QList<QPointF>       Points;
+
+  QRectF       rect()const;
+  qreal        width()const;
+  qreal        height()const;
+
+  qreal        WorldRangeX[2];
+  QVariant     WorldRangeY[2];
+  qreal        RangeXDiff;
+  qreal        RangeXOffSet;
+  qreal        RangeYDiff;
+  qreal        RangeYOffSet;
+};
+
+//-----------------------------------------------------------------------------
+ctkTransferFunctionRepresentationPrivate::ctkTransferFunctionRepresentationPrivate()
+{
+  this->TransferFunction = 0;
+  this->VerticalGradientColor = QColor::fromRgbF(1., 0., 0., 1. );
+}
+
+//-----------------------------------------------------------------------------
+QRectF ctkTransferFunctionRepresentationPrivate::rect()const
+{
+  return QRectF(0.,0.,1.,1.);
+}
+
+//-----------------------------------------------------------------------------
+qreal ctkTransferFunctionRepresentationPrivate::width()const
+{
+  return 1.;
+}
+
+//-----------------------------------------------------------------------------
+qreal ctkTransferFunctionRepresentationPrivate::height()const
+{
+  return 1.;
+}
+
+//-----------------------------------------------------------------------------
+ctkTransferFunctionRepresentation::ctkTransferFunctionRepresentation(QObject* parentObject)
+  :QObject(parentObject)
+{
+  CTK_INIT_PRIVATE(ctkTransferFunctionRepresentation);
+}
+
+//-----------------------------------------------------------------------------
+ctkTransferFunctionRepresentation::ctkTransferFunctionRepresentation(
+  ctkTransferFunction* transferFunction, QObject* parentObject)
+  :QObject(parentObject)
+{
+  CTK_INIT_PRIVATE(ctkTransferFunctionRepresentation);
+  this->setTransferFunction(transferFunction);
+}
+
+//-----------------------------------------------------------------------------
+ctkTransferFunctionRepresentation::~ctkTransferFunctionRepresentation()
+{
+}
+
+//-----------------------------------------------------------------------------
+QColor ctkTransferFunctionRepresentation::verticalGradientColor() const
+{
+  CTK_D( const ctkTransferFunctionRepresentation );
+  return d->VerticalGradientColor;
+}
+//-----------------------------------------------------------------------------
+void ctkTransferFunctionRepresentation::setVerticalGradientColor( QColor verticalGradientColor )
+{
+  CTK_D( ctkTransferFunctionRepresentation );
+  d->VerticalGradientColor = verticalGradientColor;
+}
+
+//-----------------------------------------------------------------------------
+void ctkTransferFunctionRepresentation::setTransferFunction(ctkTransferFunction* transferFunction)
+{
+  CTK_D(ctkTransferFunctionRepresentation);
+  if (d->TransferFunction == transferFunction)
+    {
+    return;
+    }
+  d->TransferFunction = transferFunction;
+  connect( d->TransferFunction, SIGNAL(changed()),
+           this, SLOT(onTransferFunctionChanged()),
+           Qt::UniqueConnection);
+  this->onTransferFunctionChanged();
+}
+
+//-----------------------------------------------------------------------------
+ctkTransferFunction* ctkTransferFunctionRepresentation::transferFunction()const
+{
+  return ctk_d()->TransferFunction;
+}
+
+//-----------------------------------------------------------------------------
+void ctkTransferFunctionRepresentation::onTransferFunctionChanged()
+{
+  CTK_D(ctkTransferFunctionRepresentation);
+  // delete cache here
+  d->Path = QPainterPath();
+  d->Points.clear();
+}
+
+//-----------------------------------------------------------------------------
+const QPainterPath& ctkTransferFunctionRepresentation::curve()const
+{
+  CTK_D(const ctkTransferFunctionRepresentation);
+  if (d->Path.isEmpty())
+    {
+    const_cast<ctkTransferFunctionRepresentation*>(this)->computeCurve();
+    const_cast<ctkTransferFunctionRepresentation*>(this)->computeGradient();
+    }
+  return d->Path;
+}
+
+//-----------------------------------------------------------------------------
+const QList<QPointF>& ctkTransferFunctionRepresentation::points()const
+{
+  CTK_D(const ctkTransferFunctionRepresentation);
+  if (d->Path.isEmpty())
+    {
+    const_cast<ctkTransferFunctionRepresentation*>(this)->computeCurve();
+    const_cast<ctkTransferFunctionRepresentation*>(this)->computeGradient();
+    }
+  return d->Points;
+}
+
+//-----------------------------------------------------------------------------
+const QGradient& ctkTransferFunctionRepresentation::gradient()const
+{
+  CTK_D(const ctkTransferFunctionRepresentation);
+  if (d->Path.isEmpty())
+    {
+    const_cast<ctkTransferFunctionRepresentation*>(this)->computeCurve();
+    const_cast<ctkTransferFunctionRepresentation*>(this)->computeGradient();
+    }
+  return d->Gradient;
+}
+
+//-----------------------------------------------------------------------------
+void ctkTransferFunctionRepresentation::computeCurve()
+{
+  CTK_D(ctkTransferFunctionRepresentation);
+
+  int count = d->TransferFunction ? d->TransferFunction->count() : 0;
+  if (count <= 0)
+    {
+    return;
+    }
+  qDebug() << "computeCurve" << d->rect();
+  d->TransferFunction->range(d->WorldRangeX[0], d->WorldRangeX[1]);
+  d->WorldRangeY[0] = this->posY(d->TransferFunction->minValue());
+  d->WorldRangeY[1] = this->posY(d->TransferFunction->maxValue());
+
+  d->RangeXDiff   = this->computeRangeXDiff(d->rect(), d->WorldRangeX);
+  d->RangeXOffSet = this->computeRangeXOffset(d->WorldRangeX);
+
+  d->RangeYDiff   = this->computeRangeYDiff(d->rect(), d->WorldRangeY);
+  d->RangeYOffSet = this->computeRangeYOffset(d->WorldRangeY);
+
+  ctkControlPoint* startCP = d->TransferFunction->controlPoint(0);
+  ctkControlPoint* nextCP = 0;
+
+  QPointF startPos = this->mapPointToScene(startCP);
+
+  d->Points.clear();
+  d->Points << startPos;
+
+  d->Path = QPainterPath();
+  d->Path.moveTo(startPos);
+  for(int i = 1; i < count; ++i)
+    {
+    nextCP = d->TransferFunction->controlPoint(i);
+    if (this->transferFunction()->isDiscrete())
+      {
+      QPointF nextPos = this->mapPointToScene(nextCP);
+      qreal midPosX = (startPos.x() + nextPos.x()) / 2.;
+
+      d->Path.lineTo(QPointF(midPosX, startPos.y()));
+      d->Path.lineTo(QPointF(midPosX, nextPos.y()));
+
+      d->Points << nextPos;
+      startPos = nextPos;
+      if (i == count -1)
+        {
+        d->Path.lineTo(nextPos);
+        }
+      }
+    else if (dynamic_cast<ctkNonLinearControlPoint*>(startCP))
+      {
+      QList<ctkPoint> points = this->nonLinearPoints(startCP, nextCP);
+      int j;
+      for (j = 1; j < points.count(); ++j)
+        {
+        d->Path.lineTo(this->mapPointToScene(points[j]));
+        }
+      j = points.count() - 1;
+      d->Points << this->mapPointToScene(points[j]);
+      }
+    else //dynamic_cast<ctkBezierControlPoint*>(startCP))
+      {
+      QList<ctkPoint> points = this->bezierParams(startCP, nextCP);
+      QList<ctkPoint>::iterator it = points.begin();
+      QList<QPointF> bezierPoints;
+      foreach(const ctkPoint& p, points)
+        {
+        bezierPoints << this->mapPointToScene(p);
+        }
+      d->Path.cubicTo(bezierPoints[1], bezierPoints[2], bezierPoints[3]);
+      d->Points << bezierPoints[3];
+      }
+    //qDebug() << i << points[0] << points[1] << points[2] << points[3];
+    delete startCP;
+    startCP = nextCP;
+    }
+  if (startCP)
+    {
+    delete startCP;
+    }
+}
+
+//-----------------------------------------------------------------------------
+void ctkTransferFunctionRepresentation::computeGradient()
+{
+  CTK_D(ctkTransferFunctionRepresentation);
+
+  int count = d->TransferFunction ? d->TransferFunction->count() : 0;
+  if (count <= 0)
+    {
+    return;
+    }
+  qDebug() << "computeCurve" << d->rect();
+  d->TransferFunction->range(d->WorldRangeX[0], d->WorldRangeX[1]);
+  d->WorldRangeY[0] = this->posY(d->TransferFunction->minValue());
+  d->WorldRangeY[1] = this->posY(d->TransferFunction->maxValue());
+
+  d->RangeXDiff   = this->computeRangeXDiff(QRectF(0.,0.,1.,1.), d->WorldRangeX);
+  d->RangeXOffSet = this->computeRangeXOffset(d->WorldRangeX);
+
+  d->RangeYDiff   = this->computeRangeYDiff(QRectF(0.,0.,1.,1.), d->WorldRangeY);
+  d->RangeYOffSet = this->computeRangeYOffset(d->WorldRangeY);
+
+  ctkControlPoint* startCP = d->TransferFunction->controlPoint(0);
+  ctkControlPoint* nextCP = 0;
+
+  qreal startPos = this->mapXToScene(this->posX(startCP->x()));
+  qreal nextPos;
+
+  //
+  //if we have no colors in value (i.e. can't convert value to color)
+  if (! d->TransferFunction->value(0).canConvert<QColor>())
+    {
+    // create vertical gradient
+    d->Gradient = QLinearGradient(0., 0., 0., 1.);
+    // red
+    d->Gradient.setColorAt(0, d->VerticalGradientColor );
+    // to black
+    d->Gradient.setColorAt(1, QColor::fromRgbF(0., 0., 0., 1. ));
+    return;
+    }
+
+  // classic gradient if we have colors in value
+  d->Gradient = QLinearGradient(0., 0., 1., 0.);
+  d->Gradient.setColorAt(startPos, this->color(startCP));
+  for(int i = 1; i < count; ++i)
+    {
+    nextCP = d->TransferFunction->controlPoint(i);
+    nextPos = this->mapXToScene(this->posX(nextCP));
+    if (this->transferFunction()->isDiscrete())
+      {
+      qreal midPoint = (startPos + nextPos)  / 2;
+      d->Gradient.setColorAt(midPoint, this->color(startCP));
+      d->Gradient.setColorAt(midPoint + std::numeric_limits<qreal>::epsilon(), this->color(nextCP));
+      }
+    else if (dynamic_cast<ctkNonLinearControlPoint*>(startCP))
+      {
+      QList<ctkPoint> points = this->nonLinearPoints(startCP, nextCP);
+      foreach(const ctkPoint& p, points)
+        {
+        d->Gradient.setColorAt(this->mapXToScene(this->posX(p)), this->color(p));
+        }
+      //no need, d->Gradient.setColorAt(nextPos, this->color(nextCP));
+      }
+    else //dynamic_cast<ctkBezierControlPoint*>(startCP))
+      { // TODO handle bezier points with color
+      QList<ctkPoint> points = this->bezierParams(startCP, nextCP);
+      QList<ctkPoint>::iterator it = points.begin();
+      QList<QPointF> bezierPoints;
+      foreach(const ctkPoint& p, points)
+        {
+        d->Gradient.setColorAt(this->mapXToScene(this->posX(p)), this->color(p));
+        }
+      nextPos = this->mapXToScene(this->posX(points[points.size() - 1]));
+      }
+    //qDebug() << i << points[0] << points[1] << points[2] << points[3];
+    delete startCP;
+    startCP = nextCP;
+    startPos = nextPos;
+    }
+  d->Gradient.setColorAt(startPos, this->color(startCP));
+  if (startCP)
+    {
+    delete startCP;
+    }
+}
+
+//-----------------------------------------------------------------------------
+QList<ctkPoint> ctkTransferFunctionRepresentation::bezierParams(
+  ctkControlPoint* start, ctkControlPoint* end) const
+{
+  Q_ASSERT(start);
+  Q_ASSERT(end);
+  QList<ctkPoint> points;
+
+  ctkBezierControlPoint* bezierCP = dynamic_cast<ctkBezierControlPoint*>(start);
+  if (!bezierCP)
+    {// just duplicate start and end into p1 and p2
+    points << start->P;
+    points << start->P;
+    points << end->P;
+    points << end->P;
+    return points;
+    }
+
+  points << start->P;
+  points << bezierCP->P1;
+  points << bezierCP->P2;
+  points << end->P;
+  return points;
+}
+
+//-----------------------------------------------------------------------------
+QList<ctkPoint> ctkTransferFunctionRepresentation::nonLinearPoints(
+  ctkControlPoint* start, ctkControlPoint* end) const
+{
+  Q_ASSERT(start);
+
+  ctkNonLinearControlPoint* nonLinearCP =
+    dynamic_cast<ctkNonLinearControlPoint*>(start);
+  if (!nonLinearCP)
+    {
+    QList<ctkPoint> points;
+    points << start->P;
+    points << end->P;
+    return points;
+    }
+  return nonLinearCP->SubPoints;
+}
+
+//-----------------------------------------------------------------------------
+QColor ctkTransferFunctionRepresentation::color(const QVariant& v) const
+{
+  //Q_ASSERT(v.canConvert<QColor>());
+  if (v.canConvert<QColor>())
+    {
+    return v.value<QColor>();
+    }
+  else
+    {
+    //black background
+    QColor defaultColor(0., 0., 0.);
+    return defaultColor;
+    }
+  return QColor();
+}
+
+//-----------------------------------------------------------------------------
+qreal ctkTransferFunctionRepresentation::computeRangeXDiff(const QRectF& rect, qreal rangeX[2])
+{
+  return rect.width() / (rangeX[1] - rangeX[0]);
+}
+
+//-----------------------------------------------------------------------------
+qreal ctkTransferFunctionRepresentation::computeRangeXOffset(qreal rangeX[2])
+{
+  return rangeX[0];
+}
+
+//-----------------------------------------------------------------------------
+qreal ctkTransferFunctionRepresentation::computeRangeYDiff(const QRectF& rect, const QVariant rangeY[2])
+{
+  qreal rangeYDiff = rect.height();
+  qreal rangePosY[2];
+  rangePosY[0] = this->posY(rangeY[0]);
+  rangePosY[1] = this->posY(rangeY[1]);
+  if (rangePosY[1] == rangePosY[0])
+    {
+    rangeYDiff /= rangePosY[0];
+    return rangeYDiff;
+    }
+  rangeYDiff /= rangePosY[1] - rangePosY[0];
+  return rangeYDiff;
+}
+
+//-----------------------------------------------------------------------------
+qreal ctkTransferFunctionRepresentation::computeRangeYOffset(const QVariant rangeY[2])
+{
+  qreal rangePosY[2];
+  rangePosY[0] = this->posY(rangeY[0]);
+  rangePosY[1] = this->posY(rangeY[1]);
+
+  if (rangePosY[1] == rangePosY[0])
+    {
+    return 0.;
+    }
+  return rangePosY[0];
+}
+
+//-----------------------------------------------------------------------------
+qreal ctkTransferFunctionRepresentation::posX(const qreal& x)const
+{
+  return x;
+}
+
+//-----------------------------------------------------------------------------
+qreal ctkTransferFunctionRepresentation::posY(const QVariant& value)const
+{
+  Q_ASSERT(value.canConvert<qreal>() || value.canConvert<QColor>());
+  if (value.canConvert<QColor>())
+    {
+    return value.value<QColor>().alphaF();
+    }
+  return value.toReal();
+}
+
+//-----------------------------------------------------------------------------
+QPointF ctkTransferFunctionRepresentation::mapPointToScene(const ctkControlPoint* cp)const
+{
+  return QPointF(this->mapXToScene(this->posX(cp->x())),
+                 this->mapYToScene(this->posY(cp->value())));
+}
+
+//-----------------------------------------------------------------------------
+QPointF ctkTransferFunctionRepresentation::mapPointToScene(const ctkPoint& point)const
+{
+  return QPointF( this->mapXToScene(this->posX(point.X)),
+                  this->mapYToScene(this->posY(point.Value)));
+}
+
+//-----------------------------------------------------------------------------
+qreal ctkTransferFunctionRepresentation::mapXToScene(qreal xPos)const
+{
+  CTK_D(const ctkTransferFunctionRepresentation);
+  return (xPos - d->RangeXOffSet) * d->RangeXDiff;
+}
+
+//-----------------------------------------------------------------------------
+qreal ctkTransferFunctionRepresentation::mapYToScene(qreal yPos)const
+{
+  CTK_D(const ctkTransferFunctionRepresentation);
+  return d->height() - (yPos - d->RangeYOffSet) * d->RangeYDiff;
+}
+
+//-----------------------------------------------------------------------------
+qreal ctkTransferFunctionRepresentation::mapXFromScene(qreal scenePosX)const
+{
+  CTK_D(const ctkTransferFunctionRepresentation);
+  return (scenePosX / d->RangeXDiff) + d->RangeXOffSet;
+}
+
+//-----------------------------------------------------------------------------
+qreal ctkTransferFunctionRepresentation::mapYFromScene(qreal scenePosY)const
+{
+  CTK_D(const ctkTransferFunctionRepresentation);
+  return ((d->height() - scenePosY) / d->RangeYDiff) + d->RangeYOffSet ;
+}

Libs/Core/ctkTransferFunctionRepresentation.h

@@ -0,0 +1,130 @@
+/*=========================================================================
+
+  Library:   CTK
+ 
+  Copyright (c) 2010  Kitware Inc.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.commontk.org/LICENSE
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ 
+=========================================================================*/
+
+#ifndef __ctkTransferFunctionRepresentation_h
+#define __ctkTransferFunctionRepresentation_h
+
+/// Qt includes
+#include <QColor>
+#include <QGradient>
+#include <QObject>
+#include <QPainterPath>
+
+/// CTK includes
+#include "ctkPimpl.h"
+#include "ctkTransferFunction.h"
+#include "CTKCoreExport.h"
+
+class ctkTransferFunction;
+class ctkTransferFunctionRepresentationPrivate;
+
+//-----------------------------------------------------------------------------
+class CTK_CORE_EXPORT ctkTransferFunctionRepresentation: public QObject
+{
+  Q_OBJECT
+  Q_PROPERTY(QColor VerticalGradientColor READ verticalGradientColor WRITE setVerticalGradientColor)
+
+public:
+  ctkTransferFunctionRepresentation(QObject* parent = 0);
+  ctkTransferFunctionRepresentation(ctkTransferFunction* transferFunction, QObject* parent = 0);
+  virtual ~ctkTransferFunctionRepresentation();
+
+  void setTransferFunction(ctkTransferFunction* transferFunction);
+  ctkTransferFunction* transferFunction()const;
+
+  inline qreal posX(const ctkControlPoint* cp)const;
+  inline qreal posY(const ctkControlPoint* cp)const;
+  inline QColor color(const ctkControlPoint* cp) const;
+
+  inline qreal posX(const ctkPoint& point)const;
+  inline qreal posY(const ctkPoint& point)const;
+  inline QColor color(const ctkPoint& point) const;
+
+  qreal posX(const qreal& tfX)const;
+  qreal posY(const QVariant& tfV)const;
+  QColor color(const QVariant& tfV) const;
+
+  QPointF mapPointToScene(const ctkControlPoint* cp)const;
+  QPointF mapPointToScene(const ctkPoint& point)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;
+
+  const QPainterPath& curve()const;
+  const QList<QPointF>& points()const;
+  const QGradient& gradient()const;
+
+  void computeCurve();
+  void computeGradient();
+
+  QColor verticalGradientColor()const;
+  void setVerticalGradientColor(QColor verticalGradientColor);
+
+protected slots:
+  virtual void onTransferFunctionChanged();
+
+protected:
+  qreal computeRangeXDiff(const QRectF& rect, qreal rangeX[2]);
+  qreal computeRangeXOffset(qreal rangeX[2]);
+  qreal computeRangeYDiff(const QRectF& rect, const QVariant rangeY[2]);
+  qreal computeRangeYOffset(const QVariant rangeY[2]);
+private:
+  CTK_DECLARE_PRIVATE(ctkTransferFunctionRepresentation);
+};
+
+qreal ctkTransferFunctionRepresentation::posX(const ctkControlPoint* cp)const
+{
+  return this->posX(cp->x());
+}
+qreal ctkTransferFunctionRepresentation::posY(const ctkControlPoint* cp)const
+{
+  return this->posY(cp->value());
+}
+QColor ctkTransferFunctionRepresentation::color(const ctkControlPoint* cp) const
+{
+  return this->color(cp->value());
+}
+
+qreal ctkTransferFunctionRepresentation::posX(const ctkPoint& point)const
+{
+  return this->posX(point.X);
+}
+qreal ctkTransferFunctionRepresentation::posY(const ctkPoint& point)const
+{
+  return this->posY(point.Value);
+}
+QColor ctkTransferFunctionRepresentation::color(const ctkPoint& point) const
+{
+  return this->color(point.Value);
+}
+
+QPointF ctkTransferFunctionRepresentation::mapPointFromScene(const QPointF& point)const
+{
+  return QPointF(this->mapXFromScene(point.x()),
+                 this->mapYFromScene(point.y()));
+}
+
+#endif

Libs/Scripting/Python/Widgets/ctkPythonShell.cpp

@@ -68,6 +68,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <ctkAbstractPythonManager.h>
 #include "ctkPythonShell.h"
 
+#ifdef __GNUC__
+// Disable warnings related to Python macros and functions
+// See http://gcc.gnu.org/onlinedocs/gcc/Diagnostic-Pragmas.html
+// Note: Ideally the incriminated functions and macros should be fixed upstream ...
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#endif
+
 //----------------------------------------------------------------------------
 class ctkPythonShellCompleter : public ctkConsoleWidgetCompleter
 {

Libs/Visualization/VTK/Core/ctkVTKColorTransferFunction.cpp

@@ -63,7 +63,6 @@ int ctkVTKColorTransferFunction::count()const
   CTK_D(const ctkVTKColorTransferFunction);
   if (d->ColorTransferFunction.GetPointer() == 0)
     {
-    Q_ASSERT(d->ColorTransferFunction.GetPointer());
     return -1;
     }
   return d->ColorTransferFunction->GetSize();

Libs/Visualization/VTK/Core/ctkVTKCompositeFunction.cpp

@@ -156,9 +156,10 @@ ctkControlPoint* ctkVTKCompositeFunction::controlPoint(int index)const
 
   double valuesPWF[4];
   double valuesCTF[6];
+#ifndef QT_NO_DEBUG
   double* rangePWF = d->PiecewiseFunction->GetRange();
   double* rangeCTF = d->ColorTransferFunction->GetRange();
-
+#endif
   d->PiecewiseFunction->GetNodeValue(index, valuesPWF);
   d->ColorTransferFunction->GetNodeValue(index, valuesCTF);
 
@@ -317,7 +318,9 @@ int ctkVTKCompositeFunction::insertControlPoint(qreal pos)
       d->ColorTransferFunction->AddRGBPoint( pos, color[0], color[1], color[2] );
 
   // Add point to piecewise
+#ifndef QT_NO_DEBUG
   int indexPiecewise =
+#endif
       d->PiecewiseFunction->AddPoint( pos, 0);
 
   // check index
@@ -399,5 +402,6 @@ vtkColorTransferFunction* ctkVTKCompositeFunction::colorTransferFunction()const
 //-----------------------------------------------------------------------------
 void ctkVTKCompositeFunction::removeControlPoint( qreal pos )
 {
+  Q_UNUSED(pos);
   // TO BE IMPLEMENTED
 }

Libs/Visualization/VTK/Core/ctkVTKHistogram.cpp

@@ -303,12 +303,21 @@ void populateIrregularBins(vtkIntArray* bins, const ctkVTKHistogram* histogram)
 void ctkVTKHistogram::build()
 {
   CTK_D(ctkVTKHistogram);
-  
+
+  if (d->DataArray.GetPointer() == 0)
+    {
+    d->MinBin = 0;
+    d->MaxBin = 0;
+    d->Bins->SetNumberOfTuples(0);
+    return;
+    }
+
   const int binCount = d->computeNumberOfBins();
 
   d->Bins->SetNumberOfComponents(1);
   d->Bins->SetNumberOfTuples(binCount);
 
+
   if (static_cast<double>(binCount) != (d->Range[1] - d->Range[2]))
     {
     switch(d->DataArray->GetDataType())
@@ -339,5 +348,6 @@ void ctkVTKHistogram::build()
 //-----------------------------------------------------------------------------
 void ctkVTKHistogram::removeControlPoint( qreal pos )
 {
+  Q_UNUSED(pos);
   // TO BE IMPLEMENTED
 }

Libs/Visualization/VTK/Core/ctkVTKLookupTable.cpp

@@ -227,5 +227,6 @@ vtkLookupTable* ctkVTKLookupTable::lookupTable()const
 //-----------------------------------------------------------------------------
 void ctkVTKLookupTable::removeControlPoint( qreal pos )
 {
+  Q_UNUSED(pos);
   // TO BE IMPLEMENTED
 }

Libs/Visualization/VTK/Core/ctkVTKPiecewiseFunction.cpp

@@ -139,7 +139,9 @@ ctkControlPoint* ctkVTKPiecewiseFunction::controlPoint(int index)const
   Q_ASSERT(index >= 0 && index < this->count());
 
   double values[4];
+#ifndef QT_NO_DEBUG
   double* range = d->PiecewiseFunction->GetRange();
+#endif
   d->PiecewiseFunction->GetNodeValue(index, values);
 
   QVariant rangeY[2];
@@ -289,10 +291,9 @@ vtkPiecewiseFunction* ctkVTKPiecewiseFunction::piecewiseFunction()const
 void ctkVTKPiecewiseFunction::removeControlPoint( qreal pos )
 {
   CTK_D(ctkVTKPiecewiseFunction);
-  int index = -1;
   if (d->PiecewiseFunction.GetPointer() == 0)
-  {
-  return;
-  }
+    {
+    return;
+    }
   d->PiecewiseFunction->RemovePoint( pos );
 }

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

@@ -59,7 +59,7 @@ int ctkTransferFunctionWidgetTest5(int argc, char * argv [] )
   transferFunctionWidget.show();
   ctkTransferFunctionBarsItem * histogramItem = new ctkTransferFunctionBarsItem;
   histogramItem->setTransferFunction(histogram.data());
-  qobject_cast<ctkTransferFunctionScene*>(transferFunctionWidget.scene())->setTransferFunction(histogram.data());
+  //qobject_cast<ctkTransferFunctionScene*>(transferFunctionWidget.scene())->setTransferFunction(histogram.data());
   transferFunctionWidget.scene()->addItem(histogramItem);
 
   QTimer autoExit;

Libs/Visualization/VTK/Widgets/ctkVTKRenderView.h

@@ -51,9 +51,11 @@ public:
   /// If a render has already been scheduled, this called is a no-op
   void scheduleRender();
 
+public slots:
   /// Force a render even if a render is already ocurring
   void forceRender();
 
+public:
   /// Get underlying RenderWindow
   vtkRenderWindow* renderWindow()const;
   

Libs/Visualization/VTK/Widgets/ctkVTKSliceView.cpp

@@ -26,6 +26,7 @@
 // CTK includes
 #include "ctkVTKSliceView.h"
 #include "ctkVTKSliceView_p.h"
+#include "ctkLogger.h"
 
 // VTK includes
 #include <vtkRendererCollection.h>
@@ -43,6 +44,10 @@
 #define VTK_CREATE(type, name) \
   vtkSmartPointer<type> name = vtkSmartPointer<type>::New()
 
+//--------------------------------------------------------------------------
+static ctkLogger logger("org.commontk.visualization.vtk.widgets.ctkVTKSliceView");
+//--------------------------------------------------------------------------
+
 // --------------------------------------------------------------------------
 // RenderWindowItem methods
 
@@ -277,6 +282,7 @@ void ctkVTKSliceView::scheduleRender()
 {
   CTK_D(ctkVTKSliceView);
 
+  logger.trace("scheduleRender");
   if (!d->RenderEnabled)
     {
     return;
@@ -296,6 +302,7 @@ void ctkVTKSliceView::forceRender()
     {
     return;
     }
+  logger.trace("forceRender");
   d->RenderWindow->Render();
   d->RenderPending = false;
 }
@@ -550,20 +557,20 @@ CTK_GET_CXX(ctkVTKSliceView, double, colorWindow, ColorWindow);
 CTK_GET_CXX(ctkVTKSliceView, double, colorLevel, ColorLevel);
 
 //----------------------------------------------------------------------------
-void ctkVTKSliceView::setImageData(vtkImageData* imageDataToSet)
+void ctkVTKSliceView::setImageData(vtkImageData* newImageData)
 {
   CTK_D(ctkVTKSliceView);
 
   foreach(const QSharedPointer<RenderWindowItem>& item, d->RenderWindowItemList)
     {
-    item->ImageMapper->SetInput(imageDataToSet);
+    item->ImageMapper->SetInput(newImageData);
     }
 
-  if (imageDataToSet)
+  if (newImageData)
     {
     d->updateRenderWindowItemsZIndex(d->RenderWindowLayoutType);
     }
 
-  d->ImageData = imageDataToSet;
+  d->ImageData = newImageData;
 }
 

Libs/Visualization/VTK/Widgets/ctkVTKSliceView.h

@@ -58,9 +58,13 @@ public:
   /// If a render has already been scheduled, this called is a no-op
   void scheduleRender();
 
+public slots:
+
   /// Force a render even if a render is already ocurring
   void forceRender();
 
+public:
+
   /// Get underlying RenderWindow
   vtkRenderWindow* renderWindow() const;
   

Libs/Widgets/ctkTransferFunctionBarsItem.cpp

@@ -1,7 +1,7 @@
 /*=========================================================================
 
   Library:   CTK
- 
+
   Copyright (c) 2010  Kitware Inc.
 
   Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,7 +15,7 @@
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
- 
+
 =========================================================================*/
 
 /// Qt includes
@@ -29,6 +29,7 @@
 /// CTK includes
 #include "ctkTransferFunction.h"
 #include "ctkTransferFunctionBarsItem.h"
+#include "ctkTransferFunctionRepresentation.h"
 #include "ctkTransferFunctionScene.h"
 
 // std includes
@@ -39,14 +40,17 @@ class ctkTransferFunctionBarsItemPrivate: public ctkPrivate<ctkTransferFunctionB
 {
 public:
   ctkTransferFunctionBarsItemPrivate();
-  qreal BarWidth;
-  bool  Log;
+  qreal  BarWidth;
+  QColor BarColor;
+  ctkTransferFunctionBarsItem::LogMode   LogMode;
 };
 
+//-----------------------------------------------------------------------------
 ctkTransferFunctionBarsItemPrivate::ctkTransferFunctionBarsItemPrivate()
 {
   this->BarWidth = 0.6180; // golden ratio... why not.
-  this->Log = true;
+  this->BarColor = QColor(191, 191, 191, 127);
+  this->LogMode = ctkTransferFunctionBarsItem::AutoLog;
 }
 
 //-----------------------------------------------------------------------------
@@ -66,13 +70,14 @@ ctkTransferFunctionBarsItem::ctkTransferFunctionBarsItem(
 
 //-----------------------------------------------------------------------------
 ctkTransferFunctionBarsItem::~ctkTransferFunctionBarsItem()
-{  
+{
 }
 
 //-----------------------------------------------------------------------------
 void ctkTransferFunctionBarsItem::setBarWidth(qreal newBarWidth)
 {
   CTK_D(ctkTransferFunctionBarsItem);
+  newBarWidth = qBound(0., newBarWidth, 1.);
   if (d->BarWidth == newBarWidth)
     {
     return;
@@ -89,6 +94,20 @@ qreal ctkTransferFunctionBarsItem::barWidth()const
 }
 
 //-----------------------------------------------------------------------------
+void ctkTransferFunctionBarsItem::setBarColor(const QColor& color)
+{
+  CTK_D(ctkTransferFunctionBarsItem);
+  d->BarColor = color;
+}
+
+//-----------------------------------------------------------------------------
+QColor ctkTransferFunctionBarsItem::barColor()const
+{
+  CTK_D(const ctkTransferFunctionBarsItem);
+  return d->BarColor;
+}
+
+//-----------------------------------------------------------------------------
 void ctkTransferFunctionBarsItem::paint(
   QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget)
 {
@@ -101,23 +120,43 @@ void ctkTransferFunctionBarsItem::paint(
     return;
     }
 
-  ctkTransferFunctionScene* tfScene = dynamic_cast<ctkTransferFunctionScene*>(this->scene());
-  Q_ASSERT(tfScene);
-  const QList<QPointF>& points = tfScene->points();
+  ctkTransferFunctionRepresentation* tfRep = this->transferFunction()->representation();
+  //ctkTransferFunctionScene* tfScene = dynamic_cast<ctkTransferFunctionScene*>(this->scene());
+  //Q_ASSERT(tfScene);
+  //const QList<QPointF>& points = tfScene->points();
+  const QList<QPointF>& points = tfRep->points();
 
   QPainterPath bars;
-  QPen pen(QColor(255, 255, 255, 191), 1);
+  QPen pen( QColor(255, 255, 255, 191), 1);
   pen.setCosmetic(true);
+  if (qFuzzyCompare(d->BarWidth, 1.))
+    {
+    pen = QPen(QBrush(), 0, Qt::NoPen);
+    }
   painter->setPen(pen);
-  painter->setBrush(QBrush(QColor(191, 191, 191, 127)));
+  painter->setBrush(QBrush(d->BarColor));
 
-  qreal barWidth = d->BarWidth * (this->rect().width() / (points.size() - 1)); 
+  qreal barWidth = d->BarWidth * (this->rect().width() / (points.size() - 1));
+  bool useLog = false;
+  switch (d->LogMode)
+    {
+    case ctkTransferFunctionBarsItem::AutoLog:
+      useLog = this->transferFunction()->maxValue().toReal() - this->transferFunction()->minValue().toReal() > 1000.;
+      break;
+    case ctkTransferFunctionBarsItem::UseLog:
+      useLog = true;
+      break;
+    default:
+    case ctkTransferFunctionBarsItem::NoLog:
+      useLog = false;
+    }
   foreach(const QPointF& point, points)
     {
     qreal barHeight = point.y();
-    if (d->Log && barHeight != 1.)
+    if (useLog && barHeight != 1.)
       {
-      barHeight = this->rect().height() - log( tfScene->mapYFromScene(barHeight) )/log(this->transferFunction()->maxValue().toReal());// 1. - (-log(barHeight)/100.);
+      //barHeight = this->rect().height() - log( tfScene->mapYFromScene(barHeight) )/log(this->transferFunction()->maxValue().toReal());// 1. - (-log(barHeight)/100.);
+      barHeight = this->rect().height() - log( tfRep->mapYFromScene(barHeight) )/log(this->transferFunction()->maxValue().toReal());// 1. - (-log(barHeight)/100.);
       }
     bars.addRect(point.x() - barWidth/2, this->rect().height(),
                  barWidth, barHeight - this->rect().height() );

Libs/Widgets/ctkTransferFunctionBarsItem.h

@@ -37,15 +37,25 @@ class CTK_WIDGETS_EXPORT ctkTransferFunctionBarsItem: public ctkTransferFunction
 {
   Q_OBJECT
   Q_PROPERTY(qreal barWidth READ barWidth WRITE setBarWidth)
+  Q_PROPERTY(QColor barColor READ barColor WRITE setBarColor)
 public:
   ctkTransferFunctionBarsItem(QGraphicsItem* parent = 0);
-  ctkTransferFunctionBarsItem(ctkTransferFunction* transferFunc, 
+  ctkTransferFunctionBarsItem(ctkTransferFunction* transferFunc,
                               QGraphicsItem* parent = 0);
   virtual ~ctkTransferFunctionBarsItem();
-  
-  void setBarWidth(qreal newBarWidth);  
+
+  void setBarWidth(qreal newBarWidth);
   qreal barWidth()const;
 
+  void setBarColor(const QColor& newBarColor);
+  QColor barColor()const;
+  
+  enum LogMode
+  {
+    NoLog = 0,
+    UseLog = 1,
+    AutoLog =2
+  };
   virtual void paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget = 0);
 private:
   CTK_DECLARE_PRIVATE(ctkTransferFunctionBarsItem);

Libs/Widgets/ctkTransferFunctionControlPointsItem.cpp

@@ -30,6 +30,7 @@
 
 /// CTK includes
 #include "ctkTransferFunctionControlPointsItem.h"
+#include "ctkTransferFunctionRepresentation.h"
 #include "ctkTransferFunctionScene.h"
 #include "ctkTransferFunctionWidget.h"
 
@@ -94,16 +95,17 @@ void ctkTransferFunctionControlPointsItem::paint(
     return;
     }
 
-  ctkTransferFunctionScene* tfScene = dynamic_cast<ctkTransferFunctionScene*>(this->scene());
-  Q_ASSERT(tfScene);
+  //ctkTransferFunctionScene* tfScene = dynamic_cast<ctkTransferFunctionScene*>(this->scene());
+  //Q_ASSERT(tfScene);
+  ctkTransferFunctionRepresentation* tfRep = this->transferFunction()->representation();
   
-  const QPainterPath& curve = tfScene->curve();
+  const QPainterPath& curve = tfRep->curve();
   QPen pen(QColor(255, 255, 255, 191), 1);
   pen.setCosmetic(true);
   painter->setPen(pen);
   painter->drawPath(curve);
 
-  d->ControlPoints = tfScene->points();
+  d->ControlPoints = tfRep->points();
   painter->setBrush(QBrush(QColor(191, 191, 191, 127)));
   painter->save();
   QTransform transform = painter->transform();
@@ -141,11 +143,12 @@ void ctkTransferFunctionControlPointsItem::mousePressEvent(QGraphicsSceneMouseEv
     {
     return;
     }
-  ctkTransferFunctionScene* tfScene = dynamic_cast<ctkTransferFunctionScene*>(this->scene());
-  Q_ASSERT(tfScene);
+  //ctkTransferFunctionScene* tfScene = dynamic_cast<ctkTransferFunctionScene*>(this->scene());
+  //Q_ASSERT(tfScene);
+  ctkTransferFunctionRepresentation* tfRep = this->transferFunction()->representation();
   
   // convert coordinates
-  QPointF tfPos = tfScene->mapPointFromScene(e->pos());
+  QPointF tfPos = tfRep->mapPointFromScene(e->pos());
   // add point to transfer function
   // returns index
   int index = this->transferFunction()->insertControlPoint( tfPos.x());
@@ -168,9 +171,11 @@ void ctkTransferFunctionControlPointsItem::mouseMoveEvent(QGraphicsSceneMouseEve
     return;
     }
 
-  ctkTransferFunctionScene* tfScene = dynamic_cast<ctkTransferFunctionScene*>(this->scene());
-  Q_ASSERT(tfScene);
-  QPointF newPos = tfScene->mapPointFromScene(e->pos());
+  //ctkTransferFunctionScene* tfScene = dynamic_cast<ctkTransferFunctionScene*>(this->scene());
+  //Q_ASSERT(tfScene);
+  ctkTransferFunctionRepresentation* tfRep = this->transferFunction()->representation();
+
+  QPointF newPos = tfRep->mapPointFromScene(e->pos());
 
   // Deal with borders
   if(d->SelectedPoint == 0 || d->SelectedPoint == this->transferFunction()->count() )
@@ -270,6 +275,7 @@ void ctkTransferFunctionControlPointsItem::drawPoints( QPointF iPointF )
 //-----------------------------------------------------------------------------
 void ctkTransferFunctionControlPointsItem::fusionPoints( QPointF iPointF )
 {
+  Q_UNUSED(iPointF);
   // TO BE IMPLEMENTED
   // if 2 points are to close: delete one..?
 }

Libs/Widgets/ctkTransferFunctionGradientItem.cpp

@@ -30,8 +30,10 @@
 /// CTK includes
 #include "ctkTransferFunction.h"
 #include "ctkTransferFunctionGradientItem.h"
+#include "ctkTransferFunctionRepresentation.h"
 #include "ctkTransferFunctionScene.h"
 
+//-----------------------------------------------------------------------------
 class ctkTransferFunctionGradientItemPrivate:public ctkPrivate<ctkTransferFunctionGradientItem>
 {
 public:
@@ -39,6 +41,7 @@ public:
   bool Mask;
 };
 
+//-----------------------------------------------------------------------------
 ctkTransferFunctionGradientItemPrivate::ctkTransferFunctionGradientItemPrivate()
 {
   this->Mask = true;
@@ -68,15 +71,20 @@ void ctkTransferFunctionGradientItem::paint(
 {
   Q_UNUSED(option);
   Q_UNUSED(widget);
-  ctkTransferFunctionScene* tfScene = dynamic_cast<ctkTransferFunctionScene*>(this->scene());
-  Q_ASSERT(tfScene);
 
-  const QGradient& gradient = tfScene->gradient();
+  if (this->transferFunction()->count() <= 0)
+    {
+    return;
+    }
+  //ctkTransferFunctionScene* tfScene = dynamic_cast<ctkTransferFunctionScene*>(this->scene());
+  //Q_ASSERT(tfScene);
+  ctkTransferFunctionRepresentation* tfRep = this->transferFunction()->representation();
+
+  const QGradient& gradient = tfRep->gradient();
 
   if ( this->mask() )
     {
-    const QPainterPath& curve = tfScene->curve();
-    QPainterPath closedPath = curve;
+    QPainterPath closedPath = tfRep->curve();
     QRectF position = this->rect();
     // link to last point
     closedPath.lineTo(position.x() + position.width(), position.y() + position.height());

Libs/Widgets/ctkTransferFunctionItem.cpp

@@ -30,6 +30,7 @@
 /// CTK includes
 #include "ctkTransferFunction.h"
 #include "ctkTransferFunctionItem.h"
+#include "ctkTransferFunctionScene.h"
 
 //-----------------------------------------------------------------------------
 class ctkTransferFunctionItemPrivate : 
@@ -84,6 +85,11 @@ void ctkTransferFunctionItem::setTransferFunction(ctkTransferFunction* transferF
 {
   CTK_D(ctkTransferFunctionItem);
   d->TransferFunction = transferFunction;
+  if (this->scene())
+    {
+    connect(d->TransferFunction,SIGNAL(changed()),
+            this->scene(), SLOT(update()),Qt::UniqueConnection);
+    }
 }
 
 //-----------------------------------------------------------------------------
@@ -118,7 +124,7 @@ QRectF ctkTransferFunctionItem::boundingRect()const
   CTK_D(const ctkTransferFunctionItem);
   return d->Rect;
 }
-
+/*
 //-----------------------------------------------------------------------------
 QList<ctkPoint> ctkTransferFunctionItem::bezierParams(
   ctkControlPoint* start, ctkControlPoint* end) const
@@ -310,3 +316,16 @@ QPointF ctkTransferFunctionItem::screen2TransferFunctionCoordinates( qreal x, qr
 
   return transferFunctionCoordinates;
 }
+*/
+
+//-----------------------------------------------------------------------------
+QVariant ctkTransferFunctionItem::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant& value)
+{
+  QVariant res = this->QGraphicsObject::itemChange(change, value);
+  if (change == QGraphicsItem::ItemSceneChange && this->scene())
+    {
+    connect(this->transferFunction(),SIGNAL(changed()),
+            this->scene(), SLOT(update()),Qt::UniqueConnection);
+    }
+  return res;
+}

Libs/Widgets/ctkTransferFunctionItem.h

@@ -49,7 +49,7 @@ public:
   inline void setRect(qreal x, qreal y, qreal width, qreal height);
   void setRect(const QRectF& rectangle);
   QRectF rect()const;
-
+/*
   qreal rangeXDiff();
   qreal rangeXOffSet();
 
@@ -58,18 +58,18 @@ public:
 
   QPointF transferFunction2ScreenCoordinates( qreal x, qreal y);
   QPointF screen2TransferFunctionCoordinates( qreal x, qreal y);
-
+*/
   virtual QRectF boundingRect()const;
 protected:
-  qreal y(const QVariant& value)const;
-  inline qreal y(const ctkPoint& point)const;
+  //qreal y(const QVariant& value)const;
+  //inline qreal y(const ctkPoint& point)const;
 
   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;
-
+  //QList<ctkPoint> bezierParams(ctkControlPoint* start, ctkControlPoint* end)const;
+  //QList<ctkPoint> nonLinearPoints(ctkControlPoint* start, ctkControlPoint* end)const;
+  virtual QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant& value);
 private:
   CTK_DECLARE_PRIVATE(ctkTransferFunctionItem);
 };
@@ -79,7 +79,7 @@ void ctkTransferFunctionItem::setRect(qreal x, qreal y, qreal width, qreal heigh
 {
   this->setRect(QRectF(x,y,width,height));
 }
-
+/*
 //-----------------------------------------------------------------------------
 qreal ctkTransferFunctionItem::y(const ctkPoint& p)const
 {
@@ -91,5 +91,5 @@ QColor ctkTransferFunctionItem::color(const ctkPoint& p)const
 {
   return this->color(p.Value);
 }
-
+*/
 #endif

Libs/Widgets/ctkTransferFunctionScene.cpp

@@ -36,24 +36,11 @@ class ctkTransferFunctionScenePrivate: public ctkPrivate<ctkTransferFunctionScen
   CTK_DECLARE_PUBLIC(ctkTransferFunctionScene);
 public:
   ctkTransferFunctionScenePrivate();
-  QRectF               OldRect;
-  ctkTransferFunction* TransferFunction;
-  QPainterPath   Path;
-  QLinearGradient Gradient;
-  QList<QPointF> Points;
-  qreal        WorldRangeX[2];
-  QVariant     WorldRangeY[2];
-  qreal        RangeXDiff;
-  qreal        RangeXOffSet;
-  qreal        RangeYDiff;
-  qreal        RangeYOffSet;
-  QColor       VerticalGradientColor;
 };
 
+//-----------------------------------------------------------------------------
 ctkTransferFunctionScenePrivate::ctkTransferFunctionScenePrivate()
 {
-  this->TransferFunction = 0;
-  this->VerticalGradientColor = QColor::fromRgbF(1., 0., 0., 1. );
 }
 
 //-----------------------------------------------------------------------------
@@ -63,421 +50,7 @@ ctkTransferFunctionScene::ctkTransferFunctionScene(QObject* parentObject)
   CTK_INIT_PRIVATE(ctkTransferFunctionScene);
 }
 
-//-----------------------------------------------------------------------------
-ctkTransferFunctionScene::ctkTransferFunctionScene(
-  ctkTransferFunction* transferFunction, QObject* parentObject)
-  :QGraphicsScene(parentObject)
-{
-  CTK_INIT_PRIVATE(ctkTransferFunctionScene);
-  this->setTransferFunction(transferFunction);
-}
-//-----------------------------------------------------------------------------
 ctkTransferFunctionScene::~ctkTransferFunctionScene()
 {
 }
 
-//-----------------------------------------------------------------------------
-void ctkTransferFunctionScene::setTransferFunction(ctkTransferFunction* transferFunction)
-{
-  CTK_D(ctkTransferFunctionScene);
-  if (d->TransferFunction == transferFunction)
-    {
-    return;
-    }
-  d->TransferFunction = transferFunction;
-  connect( d->TransferFunction, SIGNAL(changed()),
-           this, SLOT(onTransferFunctionChanged()),
-           Qt::UniqueConnection);
-  this->update();
-}
-
-//-----------------------------------------------------------------------------
-ctkTransferFunction* ctkTransferFunctionScene::transferFunction()const
-{
-  return ctk_d()->TransferFunction;
-}
-
-//-----------------------------------------------------------------------------
-void ctkTransferFunctionScene::onTransferFunctionChanged()
-{
-  CTK_D(ctkTransferFunctionScene);
-  // TODO delete cache here
-  d->Path = QPainterPath();
-  this->update();  
-}
-
-//-----------------------------------------------------------------------------
-const QPainterPath& ctkTransferFunctionScene::curve()const
-{
-  CTK_D(const ctkTransferFunctionScene);
-  if (d->Path.isEmpty())// || this->sceneRect() != d->OldRect)
-    {
-    const_cast<ctkTransferFunctionScene*>(this)->computeCurve();
-    const_cast<ctkTransferFunctionScene*>(this)->computeGradient();
-    }
-  return d->Path;
-}
-
-//-----------------------------------------------------------------------------
-const QList<QPointF>& ctkTransferFunctionScene::points()const
-{
-  CTK_D(const ctkTransferFunctionScene);
-  if (d->Path.isEmpty())// || this->sceneRect() != d->OldRect)
-    {
-    const_cast<ctkTransferFunctionScene*>(this)->computeCurve();
-    const_cast<ctkTransferFunctionScene*>(this)->computeGradient();
-    }
-  return d->Points;
-}
-
-//-----------------------------------------------------------------------------
-const QGradient& ctkTransferFunctionScene::gradient()const
-{
-  CTK_D(const ctkTransferFunctionScene);
-  if (d->Path.isEmpty())// || this->sceneRect() != d->OldRect)
-    {
-    const_cast<ctkTransferFunctionScene*>(this)->computeCurve();
-    const_cast<ctkTransferFunctionScene*>(this)->computeGradient();
-    }
-  return d->Gradient;
-}
-
-//-----------------------------------------------------------------------------
-void ctkTransferFunctionScene::computeCurve()
-{
-  CTK_D(ctkTransferFunctionScene);
-
-  int count = d->TransferFunction ? d->TransferFunction->count() : 0;
-  if (count <= 0)
-    {
-    return;
-    }
-  qDebug() << "computeCurve" << this->sceneRect();
-  d->TransferFunction->range(d->WorldRangeX[0], d->WorldRangeX[1]);
-  d->WorldRangeY[0] = this->posY(d->TransferFunction->minValue());
-  d->WorldRangeY[1] = this->posY(d->TransferFunction->maxValue());
-
-  d->RangeXDiff   = this->computeRangeXDiff(this->sceneRect(), d->WorldRangeX);
-  d->RangeXOffSet = this->computeRangeXOffset(d->WorldRangeX);
-
-  d->RangeYDiff   = this->computeRangeYDiff(this->sceneRect(), d->WorldRangeY);
-  d->RangeYOffSet = this->computeRangeYOffset(d->WorldRangeY);
-
-  ctkControlPoint* startCP = d->TransferFunction->controlPoint(0);
-  ctkControlPoint* nextCP = 0;
-
-  QPointF startPos = this->mapPointToScene(startCP);
-  
-  d->Points.clear();
-  d->Points << startPos;
-
-  d->Path = QPainterPath();
-  d->Path.moveTo(startPos);
-  for(int i = 1; i < count; ++i)
-    {
-    nextCP = d->TransferFunction->controlPoint(i);
-    if (this->transferFunction()->isDiscrete())
-      {
-      QPointF nextPos = this->mapPointToScene(nextCP);
-      qreal midPosX = (startPos.x() + nextPos.x()) / 2.;
-      
-      d->Path.lineTo(QPointF(midPosX, startPos.y()));
-      d->Path.lineTo(QPointF(midPosX, nextPos.y()));
-      
-      d->Points << nextPos;
-      startPos = nextPos;
-      if (i == count -1)
-        {
-        d->Path.lineTo(nextPos);
-        }
-      }
-    else if (dynamic_cast<ctkNonLinearControlPoint*>(startCP))
-      {
-      QList<ctkPoint> points = this->nonLinearPoints(startCP, nextCP);
-      int j;
-      for (j = 1; j < points.count(); ++j)
-        {
-        d->Path.lineTo(this->mapPointToScene(points[j]));
-        }
-      j = points.count() - 1;
-      d->Points << this->mapPointToScene(points[j]);
-      }
-    else //dynamic_cast<ctkBezierControlPoint*>(startCP))
-      {
-      QList<ctkPoint> points = this->bezierParams(startCP, nextCP);
-      QList<ctkPoint>::iterator it = points.begin();
-      QList<QPointF> bezierPoints;
-      foreach(const ctkPoint& p, points)
-        {
-        bezierPoints << this->mapPointToScene(p);
-        }
-      d->Path.cubicTo(bezierPoints[1], bezierPoints[2], bezierPoints[3]);
-      d->Points << bezierPoints[3];
-      }
-    //qDebug() << i << points[0] << points[1] << points[2] << points[3];
-    delete startCP;
-    startCP = nextCP;
-    }
-  if (startCP)
-    {
-    delete startCP;
-    }
-}
-
-//-----------------------------------------------------------------------------
-void ctkTransferFunctionScene::computeGradient()
-{
-  CTK_D(ctkTransferFunctionScene);
-
-  int count = d->TransferFunction ? d->TransferFunction->count() : 0;
-  if (count <= 0)
-    {
-    return;
-    }
-  qDebug() << "computeCurve" << this->sceneRect();
-  d->TransferFunction->range(d->WorldRangeX[0], d->WorldRangeX[1]);
-  d->WorldRangeY[0] = this->posY(d->TransferFunction->minValue());
-  d->WorldRangeY[1] = this->posY(d->TransferFunction->maxValue());
-
-  d->RangeXDiff   = this->computeRangeXDiff(QRectF(0.,0.,1.,1.), d->WorldRangeX);
-  d->RangeXOffSet = this->computeRangeXOffset(d->WorldRangeX);
-
-  d->RangeYDiff   = this->computeRangeYDiff(QRectF(0.,0.,1.,1.), d->WorldRangeY);
-  d->RangeYOffSet = this->computeRangeYOffset(d->WorldRangeY);
-
-  ctkControlPoint* startCP = d->TransferFunction->controlPoint(0);
-  ctkControlPoint* nextCP = 0;
-
-  qreal startPos = this->mapXToScene(this->posX(startCP->x()));
-  qreal nextPos;
-  
-  //
-  //if we have no colors in value (i.e. can't convert value to color)
-  if (! d->TransferFunction->value(0).canConvert<QColor>())
-    {
-    // create vertical gradient
-    d->Gradient = QLinearGradient(0., 0., 0., 1.);
-    // red
-    d->Gradient.setColorAt(0, d->VerticalGradientColor );
-    // to black
-    d->Gradient.setColorAt(1, QColor::fromRgbF(0., 0., 0., 1. ));
-    return;
-    }
-
-  // classic gradient if we have colors in value
-  d->Gradient = QLinearGradient(0., 0., 1., 0.);
-  d->Gradient.setColorAt(startPos, this->color(startCP));
-  for(int i = 1; i < count; ++i)
-    {
-    nextCP = d->TransferFunction->controlPoint(i);
-    nextPos = this->mapXToScene(this->posX(nextCP));
-    if (this->transferFunction()->isDiscrete())
-      {
-      qreal midPoint = (startPos + nextPos)  / 2;
-      d->Gradient.setColorAt(midPoint, this->color(startCP));
-      d->Gradient.setColorAt(midPoint + std::numeric_limits<qreal>::epsilon(), this->color(nextCP));
-      }
-    else if (dynamic_cast<ctkNonLinearControlPoint*>(startCP))
-      {
-      QList<ctkPoint> points = this->nonLinearPoints(startCP, nextCP);
-      foreach(const ctkPoint& p, points)
-        {
-        d->Gradient.setColorAt(this->mapXToScene(this->posX(p)), this->color(p));
-        }
-      //no need, d->Gradient.setColorAt(nextPos, this->color(nextCP));
-      }
-    else //dynamic_cast<ctkBezierControlPoint*>(startCP))
-      { // TODO handle bezier points with color
-      QList<ctkPoint> points = this->bezierParams(startCP, nextCP);
-      QList<ctkPoint>::iterator it = points.begin();
-      QList<QPointF> bezierPoints;
-      foreach(const ctkPoint& p, points)
-        {
-        d->Gradient.setColorAt(this->mapXToScene(this->posX(p)), this->color(p));
-        }
-      nextPos = this->mapXToScene(this->posX(points[points.size() - 1]));
-      }
-    //qDebug() << i << points[0] << points[1] << points[2] << points[3];
-    delete startCP;
-    startCP = nextCP;
-    startPos = nextPos;
-    }
-  d->Gradient.setColorAt(startPos, this->color(startCP));
-  if (startCP)
-    {
-    delete startCP;
-    }
-}
-
-//-----------------------------------------------------------------------------
-QList<ctkPoint> ctkTransferFunctionScene::bezierParams(
-  ctkControlPoint* start, ctkControlPoint* end) const
-{
-  Q_ASSERT(start);
-  Q_ASSERT(end);
-  QList<ctkPoint> points; 
-  
-  ctkBezierControlPoint* bezierCP = dynamic_cast<ctkBezierControlPoint*>(start);
-  if (!bezierCP)
-    {// just duplicate start and end into p1 and p2
-    points << start->P;
-    points << start->P;
-    points << end->P;
-    points << end->P;
-    return points;
-    }
-  
-  points << start->P;
-  points << bezierCP->P1;
-  points << bezierCP->P2;
-  points << end->P;
-  return points;
-}
-
-//-----------------------------------------------------------------------------
-QList<ctkPoint> ctkTransferFunctionScene::nonLinearPoints(
-  ctkControlPoint* start, ctkControlPoint* end) const
-{
-  Q_ASSERT(start);
-    
-  ctkNonLinearControlPoint* nonLinearCP = 
-    dynamic_cast<ctkNonLinearControlPoint*>(start);
-  if (!nonLinearCP)
-    {
-    QList<ctkPoint> points; 
-    points << start->P;
-    points << end->P;
-    return points;
-    }
-  return nonLinearCP->SubPoints;
-}
-
-//-----------------------------------------------------------------------------
-QColor ctkTransferFunctionScene::color(const QVariant& v) const
-{ 
-  //Q_ASSERT(v.canConvert<QColor>());
-  if (v.canConvert<QColor>())
-    {
-    return v.value<QColor>();
-    }
-  else
-    {
-    //black background
-    QColor defaultColor(0., 0., 0.);
-    return defaultColor;
-    }
-  return QColor();
-}
-
-//-----------------------------------------------------------------------------
-qreal ctkTransferFunctionScene::computeRangeXDiff(const QRectF& rect, qreal rangeX[2])
-{
-  return rect.width() / (rangeX[1] - rangeX[0]);
-}
-
-//-----------------------------------------------------------------------------
-qreal ctkTransferFunctionScene::computeRangeXOffset(qreal rangeX[2])
-{
-  return rangeX[0];
-}
-
-//-----------------------------------------------------------------------------
-qreal ctkTransferFunctionScene::computeRangeYDiff(const QRectF& rect, const QVariant rangeY[2])
-{
-  qreal rangeYDiff = rect.height();
-  qreal rangePosY[2];
-  rangePosY[0] = this->posY(rangeY[0]);
-  rangePosY[1] = this->posY(rangeY[1]);
-  if (rangePosY[1] == rangePosY[0])
-    {
-    rangeYDiff /= rangePosY[0];
-    return rangeYDiff;
-    }
-  rangeYDiff /= rangePosY[1] - rangePosY[0];
-  return rangeYDiff;
-}
-
-//-----------------------------------------------------------------------------
-qreal ctkTransferFunctionScene::computeRangeYOffset(const QVariant rangeY[2])
-{
-  qreal rangePosY[2];
-  rangePosY[0] = this->posY(rangeY[0]);
-  rangePosY[1] = this->posY(rangeY[1]);
-
-  if (rangePosY[1] == rangePosY[0])
-    {
-    return 0.;
-    }
-  return rangePosY[0];
-}
-
-//-----------------------------------------------------------------------------
-qreal ctkTransferFunctionScene::posX(const qreal& x)const
-{
-  return x;
-}
-
-//-----------------------------------------------------------------------------
-qreal ctkTransferFunctionScene::posY(const QVariant& value)const
-{
-  Q_ASSERT(value.canConvert<qreal>() || value.canConvert<QColor>());
-  if (value.canConvert<QColor>())
-    {
-    return value.value<QColor>().alphaF();
-    }
-  return value.toReal();
-}
-
-//-----------------------------------------------------------------------------
-QPointF ctkTransferFunctionScene::mapPointToScene(const ctkControlPoint* cp)const
-{
-  return QPointF(this->mapXToScene(this->posX(cp->x())),
-                 this->mapYToScene(this->posY(cp->value())));
-}
-
-//-----------------------------------------------------------------------------
-QPointF ctkTransferFunctionScene::mapPointToScene(const ctkPoint& point)const
-{
-  return QPointF( this->mapXToScene(this->posX(point.X)),
-                  this->mapYToScene(this->posY(point.Value)));
-}
-
-//-----------------------------------------------------------------------------
-qreal ctkTransferFunctionScene::mapXToScene(qreal xPos)const
-{
-  CTK_D(const ctkTransferFunctionScene);
-  return (xPos - d->RangeXOffSet) * d->RangeXDiff;
-}
-
-//-----------------------------------------------------------------------------
-qreal ctkTransferFunctionScene::mapYToScene(qreal yPos)const
-{
-  CTK_D(const ctkTransferFunctionScene);
-  return this->height() - (yPos - d->RangeYOffSet) * d->RangeYDiff;
-}
-
-//-----------------------------------------------------------------------------
-qreal ctkTransferFunctionScene::mapXFromScene(qreal scenePosX)const
-{
-  CTK_D(const ctkTransferFunctionScene);
-  return (scenePosX / d->RangeXDiff) + d->RangeXOffSet;
-}
-
-//-----------------------------------------------------------------------------
-qreal ctkTransferFunctionScene::mapYFromScene(qreal scenePosY)const
-{
-  CTK_D(const ctkTransferFunctionScene);
-  return ((this->height() - scenePosY) / d->RangeYDiff) + d->RangeYOffSet ;
-}
-//-----------------------------------------------------------------------------
-QColor ctkTransferFunctionScene::verticalGradientColor() const
-{
-  CTK_D( const ctkTransferFunctionScene );
-  return d->VerticalGradientColor;
-}
-//-----------------------------------------------------------------------------
-void ctkTransferFunctionScene::setVerticalGradientColor( QColor verticalGradientColor )
-{
-  CTK_D( ctkTransferFunctionScene );
-  d->VerticalGradientColor = verticalGradientColor;
-}

Libs/Widgets/ctkTransferFunctionScene.h

@@ -38,93 +38,13 @@ class ctkTransferFunctionScenePrivate;
 class CTK_WIDGETS_EXPORT ctkTransferFunctionScene: public QGraphicsScene
 {
   Q_OBJECT
-  Q_PROPERTY(QColor VerticalGradientColor READ verticalGradientColor WRITE setVerticalGradientColor)
 
 public:
   ctkTransferFunctionScene(QObject* parent = 0);
-  ctkTransferFunctionScene(ctkTransferFunction* transferFunction, QObject* parent = 0);
   virtual ~ctkTransferFunctionScene();
 
-  void setTransferFunction(ctkTransferFunction* transferFunction);
-  ctkTransferFunction* transferFunction()const;
-
-  inline qreal posX(const ctkControlPoint* cp)const;
-  inline qreal posY(const ctkControlPoint* cp)const;
-  inline QColor color(const ctkControlPoint* cp) const;
-
-  inline qreal posX(const ctkPoint& point)const;
-  inline qreal posY(const ctkPoint& point)const;
-  inline QColor color(const ctkPoint& point) const;
-
-  qreal posX(const qreal& tfX)const;
-  qreal posY(const QVariant& tfV)const;
-  QColor color(const QVariant& tfV) const;
-  
-  QPointF mapPointToScene(const ctkControlPoint* cp)const;
-  QPointF mapPointToScene(const ctkPoint& point)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;
-
-  const QPainterPath& curve()const;
-  const QList<QPointF>& points()const;
-  const QGradient& gradient()const;
-
-  void computeCurve();
-  void computeGradient();
-
-  QColor verticalGradientColor()const;
-  void setVerticalGradientColor(QColor verticalGradientColor);
-
-protected slots:
-  virtual void onTransferFunctionChanged();
-
-protected:
-  qreal computeRangeXDiff(const QRectF& rect, qreal rangeX[2]);
-  qreal computeRangeXOffset(qreal rangeX[2]);
-  qreal computeRangeYDiff(const QRectF& rect, const QVariant rangeY[2]);
-  qreal computeRangeYOffset(const QVariant rangeY[2]);
 private:
   CTK_DECLARE_PRIVATE(ctkTransferFunctionScene);
 };
 
-qreal ctkTransferFunctionScene::posX(const ctkControlPoint* cp)const
-{
-  return this->posX(cp->x());
-}
-qreal ctkTransferFunctionScene::posY(const ctkControlPoint* cp)const
-{
-  return this->posY(cp->value());
-}
-QColor ctkTransferFunctionScene::color(const ctkControlPoint* cp) const
-{
-  return this->color(cp->value());
-}
-
-qreal ctkTransferFunctionScene::posX(const ctkPoint& point)const
-{
-  return this->posX(point.X);
-}
-qreal ctkTransferFunctionScene::posY(const ctkPoint& point)const
-{
-  return this->posY(point.Value);
-}
-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

Libs/Widgets/ctkTransferFunctionWidget.cpp

@@ -89,7 +89,7 @@ void ctkTransferFunctionWidget::setTransferFunction(ctkTransferFunction* transfe
   ctkTransferFunctionScene* tfScene = dynamic_cast<ctkTransferFunctionScene*>(this->scene());
   Q_ASSERT(tfScene);
   tfScene->clear();
-  tfScene->setTransferFunction(transferFunction);
+  //tfScene->setTransferFunction(transferFunction);
 
   ctkTransferFunctionGradientItem* gradient = 
     new ctkTransferFunctionGradientItem(transferFunction);

UseCTK.cmake.in

@@ -31,6 +31,6 @@ IF(NOT CTK_USE_FILE_INCLUDED)
   INCLUDE_DIRECTORIES(${CTK_INCLUDE_DIRS})
  
   # Add link directories needed to use CTK.
-  LINK_DIRECTORIES(${CTK_LIBRARY_DIRS})
+  LINK_DIRECTORIES(${CTK_LIBRARY_DIRS} ${CTK_EXTERNAL_LIBRARY_DIRS})
  
 ENDIF()