Moved colour space conversion of volumes from the osgvolume example into osg/ImageUtils and added support for colorSpaceConversion="MODULATE_ALPHA_BY_LUMINANCE","MODULATE_ALPHA_BY_COLOUR","REPLACE_ALPHA_WITH_LUMINANCE" and "REPLACE_RGB_WITH_LUMINANCE" to .p3d <volume> tag

src/osg/Image.cpp

@@ -1183,6 +1183,32 @@ void Image::readImageFromCurrentTexture(unsigned int contextID, bool copyMipMaps
 #endif
 }
 
+void Image::swap(osg::Image& rhs)
+{
+    std::swap(_fileName, rhs._fileName);
+    std::swap(_writeHint, rhs._writeHint);
+
+    std::swap(_origin, rhs._origin);
+
+    std::swap(_s, rhs._s); std::swap(_t, rhs._t); std::swap(_r, rhs._r);
+    std::swap(_rowLength, rhs._rowLength);
+    std::swap(_internalTextureFormat, rhs._internalTextureFormat);
+    std::swap(_pixelFormat, rhs._pixelFormat);
+    std::swap(_dataType, rhs._dataType);
+    std::swap(_packing, rhs._packing);
+    std::swap(_pixelAspectRatio, rhs._pixelAspectRatio);
+
+    std::swap(_allocationMode, rhs._allocationMode);
+    std::swap(_data, rhs._data);
+
+    std::swap(_mipmapData, rhs._mipmapData);
+
+    std::swap(_bufferObject, rhs._bufferObject);
+
+    std::swap(_dimensionsChangedCallbacks, rhs._dimensionsChangedCallbacks);
+}
+
+
 void Image::scaleImage(int s,int t,int r, GLenum newDataType)
 {
     if (_s==s && _t==t && _r==r) return;

src/osg/ImageUtils.cpp

@@ -615,5 +615,68 @@ osg::Image* createSpotLightImage(const osg::Vec4& centerColour, const osg::Vec4&
 }
 
 
+struct ModulateAlphaByColourOperator
+{
+    ModulateAlphaByColourOperator(const osg::Vec4& colour):_colour(colour) { _lum = _colour.length(); }
+
+    osg::Vec4 _colour;
+    float _lum;
+
+    inline void luminance(float&) const {}
+    inline void alpha(float&) const {}
+    inline void luminance_alpha(float& l,float& a) const { a*= l*_lum; }
+    inline void rgb(float&,float&,float&) const {}
+    inline void rgba(float& r,float& g,float& b,float& a) const { a = (r*_colour.r()+g*_colour.g()+b*_colour.b()+a*_colour.a()); }
+};
+
+struct ReplaceAlphaWithLuminanceOperator
+{
+    ReplaceAlphaWithLuminanceOperator() {}
+
+    inline void luminance(float&) const {}
+    inline void alpha(float&) const {}
+    inline void luminance_alpha(float& l,float& a) const { a= l; }
+    inline void rgb(float&,float&,float&) const { }
+    inline void rgba(float& r,float& g,float& b,float& a) const { float l = (r+g+b)*0.3333333; a = l; }
+};
+
+osg::Image* colorSpaceConversion(ColorSpaceOperation op, osg::Image* image, const osg::Vec4& colour)
+{
+    switch(op)
+    {
+        case (MODULATE_ALPHA_BY_LUMINANCE):
+        {
+            OSG_NOTICE<<"doing conversion MODULATE_ALPHA_BY_LUMINANCE"<<std::endl;
+            osg::modifyImage(image, ModulateAlphaByLuminanceOperator());
+            return image;
+        }
+        case (MODULATE_ALPHA_BY_COLOUR):
+        {
+            OSG_NOTICE<<"doing conversion MODULATE_ALPHA_BY_COLOUR"<<std::endl;
+            osg::modifyImage(image, ModulateAlphaByColourOperator(colour));
+            return image;
+        }
+        case (REPLACE_ALPHA_WITH_LUMINANCE):
+        {
+            OSG_NOTICE<<"doing conversion REPLACE_ALPHA_WITH_LUMINANCE"<<std::endl;
+            osg::modifyImage(image, ReplaceAlphaWithLuminanceOperator());
+            return image;
+        }
+        case (REPLACE_RGB_WITH_LUMINANCE):
+        {
+            OSG_NOTICE<<"doing conversion REPLACE_ALPHA_WITH_LUMINANCE"<<std::endl;
+            osg::Image* newImage = new osg::Image;
+            newImage->allocateImage(image->s(), image->t(), image->r(), GL_LUMINANCE, image->getDataType());
+            osg::copyImage(image, 0, 0, 0, image->s(), image->t(), image->r(),
+                        newImage, 0, 0, 0, false);
+            return newImage;
+        }
+        default:
+            return image;
+    }
+}
+
+
+
 }
 

src/osgPlugins/p3d/ReaderWriterP3D.cpp

@@ -1098,6 +1098,23 @@ void ReaderWriterP3DXML::parseVolume(osgPresentation::SlideShowConstructor& cons
     if (getProperty(cur, "sampleDensity", volumeData.sampleDensityValue)) {}
     if (getProperty(cur, "sampleDensityWhenMoving", volumeData.sampleDensityWhenMovingValue)) {}
 
+
+    if (getProperty(cur, "colourModulate", volumeData.colorModulate)) {}
+    if (getProperty(cur, "colorModulate", volumeData.colorModulate)) {}
+
+    std::string operation;
+    if (getProperty(cur, "colorSpaceOperation", operation) || getProperty(cur, "colourSpaceOperation", operation))
+    {
+        osg::ColorSpaceOperation colorOp = osg::NO_COLOUR_SPACE_OPERATION;
+        if (operation=="NO_COLOUR_SPACE_OPERATION") volumeData.colorSpaceOperation = osg::NO_COLOUR_SPACE_OPERATION;
+        else if (operation=="MODULATE_ALPHA_BY_LUMINANCE") volumeData.colorSpaceOperation = osg::MODULATE_ALPHA_BY_LUMINANCE;
+        else if (operation=="MODULATE_ALPHA_BY_COLOUR") volumeData.colorSpaceOperation = osg::MODULATE_ALPHA_BY_COLOUR;
+        else if (operation=="REPLACE_ALPHA_WITH_LUMINANCE") volumeData.colorSpaceOperation = osg::REPLACE_ALPHA_WITH_LUMINANCE;
+        else if (operation=="REPLACE_RGB_WITH_LUMINANCE") volumeData.colorSpaceOperation = osg::REPLACE_RGB_WITH_LUMINANCE;
+    }
+    
+    
+
     // check for any transfer function required
     std::string transferFunctionFile;
     if (getTrimmedProperty(cur, "tf", transferFunctionFile))

src/osgPresentation/SlideShowConstructor.cpp

@@ -2081,6 +2081,17 @@ void SlideShowConstructor::addVolume(const std::string& filename, const Position
 
     if (!image && !volume) return;
 
+
+    if (volumeData.colorSpaceOperation!=osg::NO_COLOUR_SPACE_OPERATION)
+    {
+        OSG_NOTICE<<"Doing colour space conversion"<<std::endl;
+        osg::ref_ptr<osg::Image> converted_image = osg::colorSpaceConversion(volumeData.colorSpaceOperation, image.get(), volumeData.colorModulate);
+        if (converted_image!=image)
+        {
+            image->swap(*converted_image);
+        }
+    }
+    
     if (positionData.scale.x()<0.0)
     {
         image->flipHorizontal();