added colormap transparency support to glyphs

Author: Haydelj

src/Core/Datatypes/ColorMap.cc

@@ -213,19 +213,19 @@ double ColorMap::alpha(double transformedValue) const
   for(i = 0; (i < alphaLookup_.size()) && (alphaLookup_[i] < transformedValue); i += 2);
 
   double startx = 0.0;
-  double starty = 40.0;
+  double starty = 41.0;
   double endx = 364.0;
-  double endy = 40.0;
+  double endy = starty;
 
   if(i == 0)
   {
     endx = alphaLookup_[0];
-    endy = alphaLookup_[1];
+    starty = endy = alphaLookup_[1];
   }
   else if(i == alphaLookup_.size())
   {
     startx = alphaLookup_[i - 2];
-    starty = alphaLookup_[i - 1];
+    endy = starty = alphaLookup_[i - 1];
   }
   else
   {
@@ -236,7 +236,7 @@ double ColorMap::alpha(double transformedValue) const
   }
 
   double interp = (transformedValue - startx) / (endx - startx);
-  double value = ((1.0f - interp) * starty + (interp) * endy) / 80.0;
+  double value = 1.0f - ((1.0f - interp) * starty + (interp) * endy) / 82.0f;
   return value;
 }
 

src/Modules/Visualization/CreateStandardColorMap.cc

@@ -66,6 +66,7 @@ void CreateStandardColorMap::execute()
 
     //TODO cbright: pass computed alpha function from transient state to factory
     auto alphaPoints = state->getValue(Parameters::AlphaUserPointsVector).toVector();
+    std::cout << alphaPoints << "\n";
     std::vector<double> points;
     for(auto point : alphaPoints)
     {

src/Modules/Visualization/ShowFieldGlyphs.cc

@@ -587,7 +587,7 @@ void GlyphBuilder::renderVectors(
 
   glyphs.buildObject(*geom, uniqueNodeID, renState.get(RenderState::USE_TRANSPARENT_EDGES),
                      state->getValue(ShowFieldGlyphs::VectorsUniformTransparencyValue).toDouble(),
-                     colorScheme, renState, primIn, mesh->get_bounding_box());
+                     colorScheme, renState, primIn, mesh->get_bounding_box(), true, portHandler.getTextureMap());
 }
 
 void GlyphBuilder::renderScalars(
@@ -682,7 +682,9 @@ void GlyphBuilder::renderScalars(
   std::string uniqueNodeID = id + "scalar_glyphs" + ss.str();
 
   glyphs.buildObject(*geom, uniqueNodeID, renState.get(RenderState::USE_TRANSPARENT_NODES),
-                     state->getValue(ShowFieldGlyphs::ScalarsUniformTransparencyValue).toDouble(), colorScheme, renState, primIn, mesh->get_bounding_box());
+                     state->getValue(ShowFieldGlyphs::ScalarsUniformTransparencyValue).toDouble(),
+                     colorScheme, renState, primIn, mesh->get_bounding_box(), true,
+                     portHandler.getTextureMap());
 }
 
 double map_emphasis(double old)
@@ -870,16 +872,23 @@ void GlyphBuilder::renderTensors(
   }
 
   glyphs.buildObject(*geom, uniqueNodeID, renState.get(RenderState::USE_TRANSPARENCY),
-                     state->getValue(ShowFieldGlyphs::TensorsUniformTransparencyValue).toDouble(), colorScheme, renState, primIn, mesh->get_bounding_box());
+                     state->getValue(ShowFieldGlyphs::TensorsUniformTransparencyValue).toDouble(),
+                     colorScheme, renState, primIn, mesh->get_bounding_box(), true,
+                     portHandler.getTextureMap());
 
   // Render lines(2 eigenvalues equalling 0)
   RenderState lineRenState = getVectorsRenderState(state);
   tensor_line_glyphs.buildObject(*geom, uniqueLineID, lineRenState.get(RenderState::USE_TRANSPARENT_EDGES),
-                                 state->getValue(ShowFieldGlyphs::TensorsUniformTransparencyValue).toDouble(), colorScheme, lineRenState, SpireIBO::PRIMITIVE::LINES, mesh->get_bounding_box());
+                                 state->getValue(ShowFieldGlyphs::TensorsUniformTransparencyValue).toDouble(),
+                                 colorScheme, lineRenState, SpireIBO::PRIMITIVE::LINES, mesh->get_bounding_box(),
+                                 true, portHandler.getTextureMap());
+
   // Render scalars(3 eigenvalues equalling 0)
   RenderState pointRenState = getScalarsRenderState(state);
   point_glyphs.buildObject(*geom, uniquePointID, pointRenState.get(RenderState::USE_TRANSPARENT_NODES),
-                           state->getValue(ShowFieldGlyphs::TensorsUniformTransparencyValue).toDouble(), colorScheme, pointRenState, SpireIBO::PRIMITIVE::POINTS, mesh->get_bounding_box());
+                           state->getValue(ShowFieldGlyphs::TensorsUniformTransparencyValue).toDouble(),
+                           colorScheme, pointRenState, SpireIBO::PRIMITIVE::POINTS, mesh->get_bounding_box(),
+                           true, portHandler.getTextureMap());
 }
 
 void ShowFieldGlyphs::setSuperquadricEmphasis(int emphasis)

src/Modules/Visualization/ShowFieldGlyphsPortHandler.cc

@@ -51,8 +51,7 @@ namespace SCIRun{
           boost::optional<ColorMapHandle> pcolorMap,
           boost::optional<ColorMapHandle> scolorMap,
           boost::optional<ColorMapHandle> tcolorMap)
-        : module_(mod),
-        pf_handle(pf), pf_info(pf)
+        : module_(mod), pf_handle(pf), pf_info(pf)
       {
         // Save field info
         p_vfld = (pf)->vfield();
@@ -134,48 +133,50 @@ namespace SCIRun{
 
         // If color map was picked, set the chosen color map
         if(colorScheme == ColorScheme::COLOR_MAP)
+        {
+          switch(renState.mColorInput)
           {
-            switch(renState.mColorInput)
+            case RenderState::InputPort::PRIMARY_PORT:
+              if(pcolorMap)
               {
-              case RenderState::InputPort::PRIMARY_PORT:
-                if(pcolorMap)
-                  {
-                    colorMap = pcolorMap;
-                    colorMapGiven = true;
-                  }
-                else
-                  {
-                    colorMapGiven = false;
-                  }
-                break;
-              case RenderState::InputPort::SECONDARY_PORT:
-                if(scolorMap)
-                  {
-                    colorMap = scolorMap;
-                    colorMapGiven = true;
-                  }
-                else
-                  {
-                    colorMapGiven = false;
-                  }
-                break;
-              case RenderState::InputPort::TERTIARY_PORT:
-                if(tcolorMap)
-                  {
-                    colorMap = tcolorMap;
-                    colorMapGiven = true;
-                  }
-                else
-                  {
-                    colorMapGiven = false;
-                  }
-                break;
-              default:
-                throw std::invalid_argument("Selected port was not primary, secondary, or tertiary.");
-                break;
+                colorMap = pcolorMap;
+                colorMapGiven = true;
               }
+              else
+              {
+                colorMapGiven = false;
+              }
+              break;
+            case RenderState::InputPort::SECONDARY_PORT:
+              if(scolorMap)
+              {
+                colorMap = scolorMap;
+                colorMapGiven = true;
+              }
+              else
+              {
+                colorMapGiven = false;
+              }
+              break;
+            case RenderState::InputPort::TERTIARY_PORT:
+              if(tcolorMap)
+              {
+                colorMap = tcolorMap;
+                colorMapGiven = true;
+              }
+              else
+              {
+                colorMapGiven = false;
+              }
+              break;
+            default:
+              throw std::invalid_argument("Selected port was not primary, secondary, or tertiary.");
+              break;
           }
 
+          spiltColorMapToTextureAndCoordinates();
+        }
+
         // Get color input type from render state
         colorInput = renState.mColorInput;
 
@@ -267,10 +268,10 @@ namespace SCIRun{
 
         ColorRGB colorMapVal;
         switch(colorInput)
-          {
+        {
           case RenderState::InputPort::PRIMARY_PORT:
             switch(pf_data_type)
-              {
+            {
               case FieldDataType::Scalar:
                 colorMapVal = colorMap.get()->valueToColor(pinputScalar.get());
                 break;
@@ -283,11 +284,11 @@ namespace SCIRun{
               default:
                 throw std::invalid_argument("Primary color map did not find scalar, vector, or tensor data.");
                 break;
-              }
+            }
             break;
           case RenderState::InputPort::SECONDARY_PORT:
             switch(sf_data_type)
-              {
+            {
               case FieldDataType::Scalar:
                 colorMapVal = colorMap.get()->valueToColor(sinputScalar.get());
                 break;
@@ -300,11 +301,11 @@ namespace SCIRun{
               default:
                 throw std::invalid_argument("Secondary color map did not find scalar, vector, or tensor data.");
                 break;
-              }
+            }
             break;
           case RenderState::InputPort::TERTIARY_PORT:
             switch(tf_data_type)
-              {
+            {
               case FieldDataType::Scalar:
                 colorMapVal = colorMap.get()->valueToColor(tinputScalar.get());
                 break;
@@ -317,12 +318,12 @@ namespace SCIRun{
               default:
                 throw std::invalid_argument("Tertiary color map did not find scalar, vector, or tensor data.");
                 break;
-              }
+            }
             break;
           default:
             throw std::invalid_argument("Color map selection was not given a primary, secondary, or tertiary port.");
             break;
-          }
+        }
         return colorMapVal;
       }
 
@@ -331,40 +332,40 @@ namespace SCIRun{
       {
         // Make sure color map port and correpsonding field data is given for chosen color map
         if(colorScheme == ColorScheme::COLOR_MAP)
+        {
+          switch(colorInput)
           {
-            switch(colorInput)
+            case RenderState::InputPort::PRIMARY_PORT:
+              if(!colorMap)
               {
-              case RenderState::InputPort::PRIMARY_PORT:
-                if(!colorMap)
-                  {
-                    throw std::invalid_argument("Primary Color Map input is required.");
-                  }
-                break;
-              case RenderState::InputPort::SECONDARY_PORT:
-                if(!(secondaryFieldGiven && colorMap))
-                  {
-                    throw std::invalid_argument("Secondary Field and Color Map input is required.");
-                  }
-                if(s_vfld->num_values() < p_vfld->num_values())
-                  {
-                    throw std::invalid_argument("Secondary Field input cannot have a smaller size than the Primary Field input.");
-                  }
-                break;
-              case RenderState::InputPort::TERTIARY_PORT:
-                if(!(tertiaryFieldGiven && colorMap))
-                  {
-                    throw std::invalid_argument("Tertiary Field and Color Map input is required.");
-                  }
-                if(t_vfld->num_values() < p_vfld->num_values())
-                  {
-                    throw std::invalid_argument("Tertiary Field input cannot have a smaller size than the Primary Field input.");
-                  }
-                break;
-              default:
-                throw std::invalid_argument("Must select a primary, secondary, or tertiary port for color map input.");
-                break;
+                throw std::invalid_argument("Primary Color Map input is required.");
+              }
+              break;
+            case RenderState::InputPort::SECONDARY_PORT:
+              if(!(secondaryFieldGiven && colorMap))
+              {
+                throw std::invalid_argument("Secondary Field and Color Map input is required.");
               }
+              if(s_vfld->num_values() < p_vfld->num_values())
+              {
+                throw std::invalid_argument("Secondary Field input cannot have a smaller size than the Primary Field input.");
+              }
+              break;
+            case RenderState::InputPort::TERTIARY_PORT:
+              if(!(tertiaryFieldGiven && colorMap))
+              {
+                throw std::invalid_argument("Tertiary Field and Color Map input is required.");
+              }
+              if(t_vfld->num_values() < p_vfld->num_values())
+              {
+                throw std::invalid_argument("Tertiary Field input cannot have a smaller size than the Primary Field input.");
+              }
+              break;
+            default:
+              throw std::invalid_argument("Must select a primary, secondary, or tertiary port for color map input.");
+              break;
           }
+        }
         // Make sure scalar is not given for rgb conversion
         else if(colorScheme == ColorScheme::COLOR_IN_SITU)
           {
@@ -647,6 +648,24 @@ namespace SCIRun{
       {
        return pf_handle->mesh()->getFacade();
       }
+
+      void ShowFieldGlyphsPortHandler::spiltColorMapToTextureAndCoordinates()
+      {
+        ColorMapHandle realColorMap = nullptr;
+
+        if(colorMap) realColorMap = colorMap.get();
+        else realColorMap = StandardColorMapFactory::create();
+
+        textureMap = StandardColorMapFactory::create(realColorMap->getColorMapName(),
+          realColorMap->getColorMapResolution(), realColorMap->getColorMapShift(),
+          realColorMap->getColorMapInvert(), 0.5, 1.0, realColorMap->getAlphaLookup());
+
+        coordinateMap = StandardColorMapFactory::create("Grayscale", 256, 0, false,
+          realColorMap->getColorMapRescaleScale(), realColorMap->getColorMapRescaleShift());
+
+        colorMap = coordinateMap;
+      }
+
     }
   }
 }

src/Modules/Visualization/ShowFieldGlyphsPortHandler.h

@@ -69,6 +69,7 @@ namespace SCIRun{
         RenderState::InputPort colorInput;
         Core::Datatypes::ColorRGB defaultColor;
         boost::optional<Core::Datatypes::ColorMapHandle> colorMap;
+        Core::Datatypes::ColorMapHandle coordinateMap {nullptr}, textureMap {nullptr};
         boost::optional<Core::Geometry::Tensor> pinputTensor, sinputTensor, tinputTensor;
         boost::optional<Core::Geometry::Vector> pinputVector, sinputVector, tinputVector;
         boost::optional<double> pinputScalar, sinputScalar, tinputScalar;
@@ -100,6 +101,10 @@ namespace SCIRun{
         // Verifies that data is valid. Run this after initialization
         void checkForErrors();
 
+        void spiltColorMapToTextureAndCoordinates();
+
+        Core::Datatypes::ColorMapHandle getTextureMap() {return textureMap;}
+
         // Returns color scheme that was set in render state
         Graphics::Datatypes::ColorScheme getColorScheme();