Merge branch 'master' into qt4-tag

Author: dcwhite

src/Core/Datatypes/ColorMap.cc

@@ -42,9 +42,10 @@ using namespace SCIRun::Core::Geometry;
 using namespace SCIRun::Core::Logging;
 
 ColorMap::ColorMap(ColorMapStrategyHandle color, const std::string& name, const size_t resolution, const double shift,
-  const bool invert, const double rescale_scale, const double rescale_shift)
+  const bool invert, const double rescale_scale, const double rescale_shift, const std::vector<double>& alphaPoints)
   : color_(color), nameInfo_(name), resolution_(resolution), shift_(shift),
-  invert_(invert), rescale_scale_(rescale_scale), rescale_shift_(rescale_shift)
+  invert_(invert), rescale_scale_(rescale_scale), rescale_shift_(rescale_shift),
+  alphaLookup_(alphaPoints)
 {
 
 }
@@ -116,7 +117,7 @@ namespace detail
 
 ColorMapHandle StandardColorMapFactory::create(const std::string& name, const size_t &res,
   const double &shift, const bool &invert,
-  const double &rescale_scale, const double &rescale_shift)
+  const double &rescale_scale, const double &rescale_shift, const std::vector<double>& alphaPoints)
 {
   using namespace detail;
   ColorMapStrategyHandle color;
@@ -129,7 +130,7 @@ ColorMapHandle StandardColorMapFactory::create(const std::string& name, const si
     color.reset(new Rainbow);
   }
 
-  return boost::make_shared<ColorMap>(color, name, res, shift, invert, rescale_scale, rescale_shift);
+  return boost::make_shared<ColorMap>(color, name, res, shift, invert, rescale_scale, rescale_shift, alphaPoints);
 }
 
 StandardColorMapFactory::NameList StandardColorMapFactory::getList()
@@ -148,16 +149,6 @@ StandardColorMapFactory::NameList StandardColorMapFactory::getList()
  */
 double ColorMap::getTransformedValue(double f) const
 {
-  /////////////////////////////////////////////////
-  //TODO: this seemingly useless code fixes a nasty crash bug on Windows. Don't delete it until a proper fix is implemented!
-  static bool x = true;
-  if (x)
-  {
-    std::cout << "";// this;// << " " << name_ << " " << resolution_ << " " << shift_ << " " << invert_ << std::endl;
-    x = false;
-  }
-  /////////////////////////////////////////////////
-
   const double rescaled01 = static_cast<double>((f + rescale_shift_) * rescale_scale_);
 
   double v = std::min(std::max(0., rescaled01), 1.);
@@ -191,57 +182,83 @@ double ColorMap::getTransformedValue(double f) const
 ColorRGB ColorMap::getColorMapVal(double v) const
 {
   double f = getTransformedValue(v);
-  //now grab the RGB
   auto colorWithoutAlpha = color_->getColorMapVal(f);
-  //TODO:
-  //return applyAlpha(f, colorWithoutAlpha);
-  return colorWithoutAlpha;
+  return applyAlpha(f, colorWithoutAlpha);
 }
-/*
-ColorRGB applyAlpha(double transformed, colorWithoutAlpha)
-...easy
 
+ColorRGB ColorMap::applyAlpha(double transformed, ColorRGB colorWithoutAlpha) const
+{
+  double a = alpha(transformed);
+  return ColorRGB(colorWithoutAlpha.r(), colorWithoutAlpha.g(), colorWithoutAlpha.b(), a);
+}
 
-double alpha(double transformedValue)
+double ColorMap::alpha(double transformedValue) const
 {
-  // interpolate in alphaLookup_
+  if(alphaLookup_.size() == 0) return 0.5;
+  int i;
+  for(i = 0; (i < alphaLookup_.size()) && (alphaLookup_[i] < transformedValue); i += 2);
+
+  double startx = 0.0f, starty, endx = 1.0f, endy;
+  if(i == 0)
+  {
+    endx = alphaLookup_[0];
+    starty = endy = alphaLookup_[1];
+  }
+  else if(i == alphaLookup_.size())
+  {
+    startx = alphaLookup_[i - 2];
+    endy = starty = alphaLookup_[i - 1];
+  }
+  else
+  {
+    startx = alphaLookup_[i - 2];
+    starty = alphaLookup_[i - 1];
+    endx = alphaLookup_[i + 0];
+    endy = alphaLookup_[i + 1];
+  }
+
+  double interp = (transformedValue - startx) / (endx - startx);
+  double value = ((1.0f - interp) * starty + (interp) * endy);
+  return value;
 }
-*/
+
 
 /**
  * @name valueToColor
  * @brief Takes a scalar value and directly passes into getColorMap.
  * @param The raw data value as a scalar double.
  * @return The RGB value mapped from the scalar.
  */
-ColorRGB ColorMap::valueToColor(double scalar) const {
-  ColorRGB color = getColorMapVal(scalar);
-  return color;
+ColorRGB ColorMap::valueToColor(double scalar) const
+{
+  return getColorMapVal(scalar);
 }
+
 /**
  * @name valueToColor
  * @brief Takes a tensor value and creates an RGB value based on the magnitude of the eigenvalues.
  * @param The raw data value as a tensor.
  * @return The RGB value mapped from the tensor.
  */
-ColorRGB ColorMap::valueToColor(Tensor &tensor) const {
+ColorRGB ColorMap::valueToColor(Tensor &tensor) const
+{
   double eigen1, eigen2, eigen3;
   tensor.get_eigenvalues(eigen1, eigen2, eigen3);
   double magnitude = Vector(eigen1, eigen2, eigen3).length();
-  ColorRGB color = getColorMapVal(magnitude);
-  return color;
+  return getColorMapVal(magnitude);
 }
+
 /**
  * @name valueToColor
  * @brief Takes a vector value and creates an RGB value.
  * @param The raw data value as a vector.
  * @return The RGB value mapped from the vector.
  */
-ColorRGB ColorMap::valueToColor(const Vector &vector) const {
+ColorRGB ColorMap::valueToColor(const Vector &vector) const
+{
     //TODO this is probably not implemented correctly.
    // return ColorRGB(getTransformedColor(fabs(vector.x())),getTransformedColor(fabs(vector.y())), getTransformedColor(fabs(vector.z())));
-  ColorRGB color = getColorMapVal(vector.length());
-  return color;
+  return getColorMapVal(vector.length());
 }
 
 // This Rainbow takes into account scientific visualization recommendations.

src/Core/Datatypes/ColorMap.h

@@ -51,7 +51,8 @@ namespace Datatypes {
     explicit ColorMap(ColorMapStrategyHandle color,
       const std::string& name = "Rainbow", const size_t resolution = 256,
                         const double shift = 0.0, const bool invert = false,
-                        const double rescale_scale = .5, const double rescale_shift = 1.);
+                        const double rescale_scale = .5, const double rescale_shift = 1.0,
+                        const std::vector<double>& alphaPoints = {});
                         //TODO cbright: pass in alpha vector
     virtual ColorMap* clone() const override;
 
@@ -62,6 +63,7 @@ namespace Datatypes {
     bool getColorMapInvert() const;
     double getColorMapRescaleScale() const;
     double getColorMapRescaleShift() const;
+    std::vector<double> getAlphaLookup() const {return alphaLookup_;}
 
     ColorRGB valueToColor(double scalar) const;
     ColorRGB valueToColor(Core::Geometry::Tensor &tensor) const;
@@ -73,6 +75,8 @@ namespace Datatypes {
     ///<< Internal functions.
     Core::Datatypes::ColorRGB getColorMapVal(double v) const;
     double getTransformedValue(double v) const;
+    ColorRGB applyAlpha(double transformed, ColorRGB colorWithoutAlpha) const;
+    double alpha(double transformedValue) const;
 
     ColorMapStrategyHandle color_;
     ///<< The colormap's name.
@@ -112,7 +116,8 @@ namespace Datatypes {
    // See explanation for defaults above in ColorMap Constructor
     static ColorMapHandle create(const std::string& name = "Rainbow", const size_t &resolution = 256,
                                     const double &shift = 0.0, const bool &invert = false,
-                                    const double &rescale_scale = .5, const double &rescale_shift = 1.);
+                                    const double &rescale_scale = .5, const double &rescale_shift = 1.0,
+                                    const std::vector<double>& alphaPoints = {});
     typedef std::vector<std::string> NameList;
     static NameList getList();
   private:

src/Interface/Modules/Render/ES/shaders/Flat_ColorMap.fs

@@ -119,7 +119,7 @@ void main()
   else               colorMapValue = texture2D(uTX0, vec2(vTexCoords.x, 0.0));
 
   vec3 diffuseColor = colorMapValue.rgb;
-  float transparency = uTransparency;
+  float transparency = colorMapValue.a;
 
   gl_FragColor = vec4(diffuseColor, transparency);
 

src/Interface/Modules/Render/ES/shaders/Phong_ColorMap.fs

@@ -137,7 +137,7 @@ void main()
   vec3 diffuseColor = pow(colorMapValue.rgb, vec3(2.2));
   vec3 specularColor = uSpecularColor.rgb;
   vec3 ambientColor = uAmbientColor.rgb;
-  float transparency = uTransparency;
+  float transparency = colorMapValue.a;
 
   vec3 normal = normalize(vNormal);
   if(gl_FrontFacing) normal = -normal;

src/Interface/Modules/Visualization/CreateStandardColorMapDialog.cc

@@ -38,6 +38,12 @@ using namespace SCIRun::Core::Datatypes;
 
 typedef SCIRun::Modules::Visualization::CreateStandardColorMap CreateStandardColorMapModule;
 
+namespace
+{
+  const double colormapPreviewHeight = 83;
+  const double colormapPreviewWidth = 365;
+  const QRectF colorMapPreviewRect(0, 0, colormapPreviewWidth, colormapPreviewHeight);
+}
 
 CreateStandardColorMapDialog::CreateStandardColorMapDialog(const std::string& name, ModuleStateHandle state,
   QWidget* parent /* = 0 */)
@@ -94,11 +100,10 @@ void CreateStandardColorMapDialog::pullSpecial()
   }
   else
   {
-    previewColorMap_->addEndpoints();
     for (const auto& p : pointsVec)
     {
       auto pVec = p.toVector();
-      previewColorMap_->addPoint(QPointF(pVec[0].toDouble(), pVec[1].toDouble()));
+      previewColorMap_->addPoint(QPointF(pVec[0].toDouble() * colormapPreviewWidth, (1.0f - pVec[1].toDouble()) * colormapPreviewHeight));
     }
   }
 }
@@ -155,18 +160,10 @@ void CreateStandardColorMapDialog::onInvertCheck(bool b)
 AlphaFunctionManager::AlphaFunctionManager(const QPointF& start, const QPointF& end, ModuleStateHandle state, const boost::atomic<bool>& pulling) :
   state_(state),
   defaultStart_(start), defaultEnd_(end),
-  alphaFunction_(ALPHA_VECTOR_LENGTH, DEFAULT_ALPHA),
   dialogPulling_(pulling)
 {
 }
 
-namespace
-{
-  const double colormapPreviewHeight = 83;
-  const double colormapPreviewWidth = 365;
-  const QRectF colorMapPreviewRect(0, 0, colormapPreviewWidth, colormapPreviewHeight);
-}
-
 ColormapPreview::ColormapPreview(QGraphicsScene* scene, ModuleStateHandle state,
   const boost::atomic<bool>& pulling,
   QWidget* parent)
@@ -189,7 +186,6 @@ void ColormapPreview::mousePressEvent(QMouseEvent* event)
   }
 
   //TODO: remove point if event & RightMouseButton
-
   //TODO: points are movable!
 }
 
@@ -201,13 +197,6 @@ void ColormapPreview::addDefaultLine()
   alphaPath_ = scene()->addLine(defaultStart_.x(), defaultStart_.y(),
     defaultEnd_.x(), defaultEnd_.y(),
     alphaLinePen);
-  alphaManager_.insertEndpoints();
-}
-
-void AlphaFunctionManager::insertEndpoints()
-{
-  alphaPoints_.insert(defaultStart_);
-  insert(defaultEnd_); // only update function and state after both endpoints are added
 }
 
 void ColormapPreview::removeDefaultLine()
@@ -218,18 +207,13 @@ void ColormapPreview::removeDefaultLine()
 
 void ColormapPreview::addPoint(const QPointF& point)
 {
-  if (alphaManager_.alreadyExists(point))
-    return;
+  if (alphaManager_.alreadyExists(point)) return;
 
   removeDefaultLine();
 
   static QPen pointPen(Qt::white, 1);
   auto item = scene()->addEllipse(point.x() - 4, point.y() - 4, 8, 8, pointPen, QBrush(Qt::black));
   item->setZValue(1);
-  // QString toolTip;
-  // QDebug tt(&toolTip);
-  // tt << "Alpha point " << point.x() << ", " << point.y() << " y% " << (1 - point.y() / sceneRect().height());
-  // item->setToolTip(toolTip);
   alphaManager_.insert(point);
 
   drawAlphaPolyline();
@@ -244,14 +228,12 @@ bool AlphaFunctionManager::alreadyExists(const QPointF& point) const
 void AlphaFunctionManager::insert(const QPointF& p)
 {
   alphaPoints_.insert(p);
-  updateAlphaFunction();
   pushToState();
 }
 
 void AlphaFunctionManager::clear()
 {
   alphaPoints_.clear();
-  alphaFunction_.assign(ALPHA_VECTOR_LENGTH, DEFAULT_ALPHA);
   pushToState();
 }
 
@@ -262,19 +244,15 @@ void AlphaFunctionManager::pushToState()
     if (!alphaPoints_.empty())
     {
       Variable::List alphaPointsVec;
-      //strip endpoints before saving user-added points
       auto begin = alphaPoints_.begin(), end = alphaPoints_.end();
-      std::advance(begin, 1);
-      std::advance(end, -1);
-      std::for_each(begin, end, [&](const QPointF& p) { alphaPointsVec.emplace_back(Name("alphaPoint"), makeAnonymousVariableList(p.x(), p.y())); });
+      std::for_each(begin, end, [&](const QPointF& p) { alphaPointsVec.emplace_back(Name("alphaPoint"),
+        makeAnonymousVariableList(p.x()/colormapPreviewWidth, 1.0f - p.y()/colormapPreviewHeight)); });
       state_->setValue(Parameters::AlphaUserPointsVector, alphaPointsVec);
     }
     else
     {
       state_->setValue(Parameters::AlphaUserPointsVector, Variable::List());
     }
-
-    state_->setTransientValue(Parameters::AlphaFunctionVector, alphaFunction_);
   }
 }
 
@@ -284,15 +262,16 @@ void ColormapPreview::drawAlphaPolyline()
   auto pathItem = new QGraphicsPathItem();
   alphaPath_ = pathItem;
   pathItem->setPen(alphaLinePen);
+
   QPainterPath path;
-  QPointF from = defaultStart_;
-  path.moveTo(from);
+  auto start = alphaManager_.begin();
+  auto end = alphaManager_.end(); std::advance(end, -1);
+  QPointF from = QPointF(defaultStart_.x(), start->y());
+  QPointF to = QPointF(defaultEnd_.x(), end->y());
 
-  for (const auto& point : alphaManager_)
-  {
-    path.lineTo(point);
-    path.moveTo(point);
-  }
+  path.moveTo(from);
+  for (const auto& point : alphaManager_) path.lineTo(point);
+  path.lineTo(to);
 
   pathItem->setPath(path);
   pathItem->setZValue(0);
@@ -310,27 +289,6 @@ void ColormapPreview::clearAlphaPointGraphics()
   addDefaultLine();
 }
 
-void AlphaFunctionManager::updateAlphaFunction()
-{
-  //from v4, color endpoints (0 and 1) are fixed at alpha = 0.5.
-  // alphaFunction_ will sample from in between these endpoints, evenly spaced throughout open interval (0,1)
-
-  for (int i = 0; i < static_cast<int>(alphaFunction_.size()); ++i)
-  {
-    if (i > 0 && i < alphaFunction_.size() - 1)
-    {
-      double color = i / static_cast<double>(ALPHA_SAMPLES + 1);
-      auto between = alphaLineEndpointsAtColor(color);
-      alphaFunction_[i] = interpolateAlphaLineValue(between.first, between.second, color);
-      // qDebug() << "Color: " << color << "Alpha: " << alphaFunction_[i] << "between points" << between.first << between.second;
-    }
-    else
-    {
-      alphaFunction_[i] = DEFAULT_ALPHA;
-    }
-  }
-}
-
 std::pair<QPointF,QPointF> AlphaFunctionManager::alphaLineEndpointsAtColor(double color) const
 {
   auto rightIter = alphaPoints_.upper_bound(colorToPoint(color));
@@ -353,7 +311,7 @@ double AlphaFunctionManager::interpolateAlphaLineValue(const QPointF& leftEndpoi
 
 double AlphaFunctionManager::pointYToAlpha(double y) const
 {
-  return 1 - y / colorMapPreviewRect.height();
+  return 1.0f - y / colorMapPreviewRect.height();
 }
 
 QPointF AlphaFunctionManager::colorToPoint(double color) const