Merge branch 'master' into pythonSetData

Author: dcwhite

src/Core/Datatypes/Color.h

@@ -48,6 +48,8 @@ namespace Datatypes {
     explicit ColorRGB(const std::string& rgb);
     ColorRGB(double r, double g, double b);
     ColorRGB(double r, double g, double b, double a);
+    //adjust alpha while copying
+    ColorRGB(const ColorRGB& color, double a);
 
     // These equality operations should use floating point comparisons.
     inline bool operator==(const ColorRGB& c) const {

src/Core/Datatypes/ColorMap.cc

@@ -31,12 +31,13 @@
 #include <Core/Datatypes/ColorMap.h>
 #include <iostream>
 
+using namespace SCIRun;
 using namespace SCIRun::Core::Datatypes;
 using namespace SCIRun::Core::Geometry;
 
-ColorMap::ColorMap(const std::string& name, const size_t resolution, const double shift,
+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)
-  : name_(name), resolution_(resolution), shift_(shift),
+  : color_(color), nameInfo_(name), resolution_(resolution), shift_(shift),
   invert_(invert), rescale_scale_(rescale_scale), rescale_shift_(rescale_shift)
 {
 
@@ -47,19 +48,73 @@ ColorMap* ColorMap::clone() const
   return new ColorMap(*this);
 }
 
+namespace detail
+{
+class Rainbow : public ColorMapStrategy
+{
+public:
+  virtual ColorRGB getColorMapVal(double v) const override;
+};
+
+class OldRainbow : public ColorMapStrategy
+{
+public:
+  virtual ColorRGB getColorMapVal(double v) const override;
+};
+
+class Blackbody : public ColorMapStrategy
+{
+public:
+  virtual ColorRGB getColorMapVal(double v) const override;
+};
+
+class Grayscale : public ColorMapStrategy
+{
+public:
+  virtual ColorRGB getColorMapVal(double v) const override;
+};
+
+class OrangeBlackLime : public ColorMapStrategy
+{
+public:
+  virtual ColorRGB getColorMapVal(double v) const override;
+};
+
+class Darkhue : public ColorMapStrategy
+{
+public:
+  virtual Core::Datatypes::ColorRGB getColorMapVal(double v) const override;
+};
+}
+
 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)
 {
-  if (!(name == "Rainbow" ||
-    name == "Old Rainbow" ||
-    name == "Blackbody" ||
-    name == "Grayscale" ||
-    name == "Orange,Black,Lime" ||
-    name == "Darkhue"))
-    THROW_INVALID_ARGUMENT("Color map name not implemented/recognized.");
-
-  return boost::make_shared<ColorMap>(name, res, shift, invert, rescale_scale, rescale_shift);
+    ColorMapStrategyHandle color;
+    if (name == "Rainbow") {
+      color.reset(new detail::Rainbow);
+    }
+    else if (name == "Old Rainbow") {
+      color.reset(new detail::OldRainbow);
+    }
+    else if (name == "Blackbody") {
+      color.reset(new detail::Blackbody);
+    }
+    else if (name == "Grayscale") {
+      color.reset(new detail::Grayscale);
+    }
+    else if (name == "Orange,Black,Lime") {
+      color.reset(new detail::OrangeBlackLime);
+    }
+    else if (name == "Darkhue") {
+      color.reset(new detail::Darkhue);
+    }
+    else
+      THROW_INVALID_ARGUMENT("Color map name not implemented/recognized.");
+
+
+  return boost::make_shared<ColorMap>(color, name, res, shift, invert, rescale_scale, rescale_shift);
 }
 /**
  * @name getTransformedColor
@@ -68,7 +123,7 @@ ColorMapHandle StandardColorMapFactory::create(const std::string& name, const si
  * @param v The input value from raw data that will be transformed (usually into [0,1] space).
  * @return The scalar double value transformed into ColorMap space from raw data.
  */
-double ColorMap::getTransformedColor(double f) const 
+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!
@@ -104,39 +159,32 @@ double ColorMap::getTransformedColor(double f) const
  * @name getColorMapVal
  * @brief This method returns the RGB value for the current colormap parameters.
  * The input comes from raw data values. To scale to data, ColorMap
- *           must be created with those parameters. The input is transformed, then 
- *           used to select a color from a set of color maps (currently defined by 
+ *           must be created with those parameters. The input is transformed, then
+ *           used to select a color from a set of color maps (currently defined by
  *           strings.
  * @param v The input value from raw data that will be mapped to a color.
  * @return The RGB value mapped from the transformed input into the ColorMap's named map.
  */
-ColorRGB ColorMap::getColorMapVal(double v) const 
+ColorRGB ColorMap::getColorMapVal(double v) const
 {
-  double f = getTransformedColor(v);
+  double f = getTransformedValue(v);
   //now grab the RGB
-  ColorRGB col;
+  auto colorWithoutAlpha = color_->getColorMapVal(f);
+  //TODO:
+  //return applyAlpha(f, colorWithoutAlpha);
+  return colorWithoutAlpha;
+}
+/*
+ColorRGB applyAlpha(double transformed, colorWithoutAlpha)
+...easy
 
-  if (name_ == "Rainbow") {
-    col = getRainbowColorMapVal(f);
-  }
-  else if (name_ == "Old Rainbow") {
-    col = getOldRainbowColorMapVal(f);
-  }
-  else if (name_ == "Blackbody") {
-    col = getBlackbodyColorMapVal(f);
-  }
-  else if (name_ == "Grayscale") {
-    col = getGrayscaleColorMapVal(f);
-  }
-  else if (name_ == "Orange,Black,Lime") {
-    col = getOrangeBlackLimeColorMapVal(f);
-  }
-  else if (name_ == "Darkhue") {
-    col = getDarkhueColorMapVal(f);
-  }
 
-  return col;
+double alpha(double transformedValue)
+{
+  // interpolate in alphaLookup_
 }
+*/
+
 /**
  * @name valueToColor
  * @brief Takes a scalar value and directly passes into getColorMap.
@@ -178,7 +226,7 @@ ColorRGB ColorMap::valueToColor(const Vector &vector) const {
 // be "brighter" than the other colors. All colors "appear" to be the
 // same brightness.
 // Blue -> Dark Cyan -> Green -> Orange -> Red
-ColorRGB ColorMap::getRainbowColorMapVal(double f) const
+ColorRGB detail::Rainbow::getColorMapVal(double f) const
 {
   ColorRGB col;
   if (f < 0.25)
@@ -194,7 +242,7 @@ ColorRGB ColorMap::getRainbowColorMapVal(double f) const
 
 //The Old Rainbow that simply transitions from blue to red 1 color at a time.
 // Blue -> Cyan -> Green -> Yellow -> Red
-ColorRGB ColorMap::getOldRainbowColorMapVal(double f) const
+ColorRGB detail::OldRainbow::getColorMapVal(double f) const
 {
   ColorRGB col;
   if (f < 0.25)
@@ -211,7 +259,7 @@ ColorRGB ColorMap::getOldRainbowColorMapVal(double f) const
 // This map is designed to appear like a heat-map, where "cooler" (lower) values
 // are darker and approach black, and "hotter" (higher) values are lighter
 // and approach white. In between, you have the red, orange, and yellow transitions.
-ColorRGB ColorMap::getBlackbodyColorMapVal(double f) const
+ColorRGB detail::Blackbody::getColorMapVal(double f) const
 {
   ColorRGB col;
   if (f < 0.333333)
@@ -224,7 +272,7 @@ ColorRGB ColorMap::getBlackbodyColorMapVal(double f) const
 }
 
 // A very simple black to white map with grays in between.
-ColorRGB ColorMap::getGrayscaleColorMapVal(double f) const
+ColorRGB detail::Grayscale::getColorMapVal(double f) const
 {
   ColorRGB col;
   col = ColorRGB(f, f, f);
@@ -233,7 +281,7 @@ ColorRGB ColorMap::getGrayscaleColorMapVal(double f) const
 
 // This color scheme sets a transition of color that goes
 // Orange -> Black -> Lime
-ColorRGB ColorMap::getOrangeBlackLimeColorMapVal(double f) const
+ColorRGB detail::OrangeBlackLime::getColorMapVal(double f) const
 {
   ColorRGB col;
   if (f < 0.5)
@@ -243,7 +291,7 @@ ColorRGB ColorMap::getOrangeBlackLimeColorMapVal(double f) const
   return col;
 }
 
-ColorRGB ColorMap::getDarkhueColorMapVal(double f) const
+ColorRGB detail::Darkhue::getColorMapVal(double f) const
 {
   ColorRGB col;
   if (f < 0.25)
@@ -257,7 +305,7 @@ ColorRGB ColorMap::getDarkhueColorMapVal(double f) const
   return col;
 }
 
-std::string ColorMap::getColorMapName() const { return name_; }
+std::string ColorMap::getColorMapName() const { return nameInfo_; }
 size_t ColorMap::getColorMapResolution() const { return resolution_; }
 double ColorMap::getColorMapShift() const { return shift_; }
 bool ColorMap::getColorMapInvert() const { return invert_; }

src/Core/Datatypes/ColorMap.h

@@ -6,7 +6,7 @@
    Copyright (c) 2015 Scientific Computing and Imaging Institute,
    University of Utah.
 
-   
+
    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
@@ -27,7 +27,7 @@
 */
 /// @todo Documentation Core/Datatypes/ColorMap.h
 #ifndef CORE_DATATYPES_COLORMAP_H
-#define CORE_DATATYPES_COLORMAP_H 
+#define CORE_DATATYPES_COLORMAP_H
 
 #include <Core/Datatypes/Datatype.h>
 #include <boost/noncopyable.hpp>
@@ -40,44 +40,43 @@ namespace SCIRun {
 namespace Core {
 namespace Datatypes {
 
+  class ColorMapStrategy;
+  typedef boost::shared_ptr<ColorMapStrategy> ColorMapStrategyHandle;
+
   class SCISHARE ColorMap : public Datatype
   {
   public:
     // Because colors need to be in the range [0,1], and SCIRun4 used [-1,1] for it's
     // default input range, we need to transform by default the data into [0,1] range.
-    explicit ColorMap(const std::string& name = "Rainbow", const size_t resolution = 256,
+    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.);
-      
+                        //TODO: pass in alpha vector
     virtual ColorMap* clone() const;
 
+    ColorMapStrategyHandle getColorStrategy() const { return color_; }
     std::string getColorMapName() const;
     size_t getColorMapResolution() const;
     double getColorMapShift() const;
     bool getColorMapInvert() const;
     double getColorMapRescaleScale() const;
     double getColorMapRescaleShift() const;
-    
+
     Core::Datatypes::ColorRGB valueToColor(double scalar) const;
     Core::Datatypes::ColorRGB valueToColor(const Core::Geometry::Tensor &tensor) const;
     Core::Datatypes::ColorRGB valueToColor(const Core::Geometry::Vector &vector) const;
 
     virtual std::string dynamic_type_name() const override { return "ColorMap"; }
-    
+
   private:
     ///<< Internal functions.
     Core::Datatypes::ColorRGB getColorMapVal(double v) const;
-    double getTransformedColor(double v) const;
-
-    Core::Datatypes::ColorRGB getRainbowColorMapVal(double f) const;
-    Core::Datatypes::ColorRGB getOldRainbowColorMapVal(double f) const;
-    Core::Datatypes::ColorRGB getBlackbodyColorMapVal(double f) const;
-    Core::Datatypes::ColorRGB getGrayscaleColorMapVal(double f) const;
-    Core::Datatypes::ColorRGB getOrangeBlackLimeColorMapVal(double f) const;
-    Core::Datatypes::ColorRGB getDarkhueColorMapVal(double f) const;
-    
+    double getTransformedValue(double v) const;
+
+    ColorMapStrategyHandle color_;
     ///<< The colormap's name.
-    std::string name_;
+    std::string nameInfo_;
     ///<< The resolution of the map [2,256].
     size_t resolution_;
     ///<< The gamma shift.
@@ -88,6 +87,23 @@ namespace Datatypes {
     double rescale_scale_;
     ///<< Rescaling shift (usually -data_min). Shift happens before scale.
     double rescale_shift_;
+
+    std::vector<double> alphaLookup_;
+  };
+
+  class SCISHARE ColorMapStrategy
+  {
+  public:
+    virtual ~ColorMapStrategy() {}
+    virtual Core::Datatypes::ColorRGB getColorMapVal(double v) const = 0;
+  };
+
+  //TODO: not sure this needs to be abstract
+  class SCISHARE AlphaMapping
+  {
+  public:
+    virtual ~AlphaMapping() {}
+    virtual double alpha(double transformedValue) const = 0;
   };
 
   class SCISHARE StandardColorMapFactory : boost::noncopyable