Changeset 13204

Timestamp:

05/24/13 19:16:57 (12 hours ago)

Author:

robert

Message:

Resrtuctured the use of static's in the Uniform::getNameID() method to avoid problems under Android.

Location:

OpenSceneGraph/trunk

Files:

• examples/osgvolume/osgvolume.cpp (modified) (5 diffs)
• include/osg/Image (modified) (2 diffs)
• include/osg/ImageUtils (modified) (1 diff)
• include/osgPresentation/SlideShowConstructor (modified) (3 diffs)
• src/osg/Image.cpp (modified) (1 diff)
• src/osg/ImageUtils.cpp (modified) (1 diff)
• src/osgPlugins/p3d/ReaderWriterP3D.cpp (modified) (1 diff)
• src/osgPresentation/SlideShowConstructor.cpp (modified) (1 diff)

OpenSceneGraph/trunk/examples/osgvolume/osgvolume.cpp

@@ -116 +116 @@
 }
 
-struct ModulateAlphaByLuminanceOperator
-{
-    ModulateAlphaByLuminanceOperator() {}
-
-    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;}
-};
-
-
 struct ScaleOperator
 {
@@ -309 +297 @@
 
 
-}
-
-enum ColourSpaceOperation
-{
-    NO_COLOUR_SPACE_OPERATION,
-    MODULATE_ALPHA_BY_LUMINANCE,
-    MODULATE_ALPHA_BY_COLOUR,
-    REPLACE_ALPHA_WITH_LUMINANCE,
-    REPLACE_RGB_WITH_LUMINANCE
-};
-
-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* doColourSpaceConversion(ColourSpaceOperation op, osg::Image* image, osg::Vec4& colour)
-{
-    switch(op)
-    {
-        case (MODULATE_ALPHA_BY_LUMINANCE):
-        {
-            std::cout<<"doing conversion MODULATE_ALPHA_BY_LUMINANCE"<<std::endl;
-            osg::modifyImage(image,ModulateAlphaByLuminanceOperator());
-            return image;
-        }
-        case (MODULATE_ALPHA_BY_COLOUR):
-        {
-            std::cout<<"doing conversion MODULATE_ALPHA_BY_COLOUR"<<std::endl;
-            osg::modifyImage(image,ModulateAlphaByColourOperator(colour));
-            return image;
-        }
-        case (REPLACE_ALPHA_WITH_LUMINANCE):
-        {
-            std::cout<<"doing conversion REPLACE_ALPHA_WITH_LUMINANCE"<<std::endl;
-            osg::modifyImage(image,ReplaceAlphaWithLuminanceOperator());
-            return image;
-        }
-        case (REPLACE_RGB_WITH_LUMINANCE):
-        {
-            std::cout<<"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;
-    }
 }
 
@@ -672 +590 @@
 
     // set up colour space operation.
-    ColourSpaceOperation colourSpaceOperation = NO_COLOUR_SPACE_OPERATION;
+    osg::ColorSpaceOperation colourSpaceOperation = osg::NO_COLOUR_SPACE_OPERATION;
     osg::Vec4 colourModulate(0.25f,0.25f,0.25f,0.25f);
-    while(arguments.read("--modulate-alpha-by-luminance")) { colourSpaceOperation = MODULATE_ALPHA_BY_LUMINANCE; }
-    while(arguments.read("--modulate-alpha-by-colour", colourModulate.x(),colourModulate.y(),colourModulate.z(),colourModulate.w() )) { colourSpaceOperation = MODULATE_ALPHA_BY_COLOUR; }
-    while(arguments.read("--replace-alpha-with-luminance")) { colourSpaceOperation = REPLACE_ALPHA_WITH_LUMINANCE; }
-    while(arguments.read("--replace-rgb-with-luminance")) { colourSpaceOperation = REPLACE_RGB_WITH_LUMINANCE; }
+    while(arguments.read("--modulate-alpha-by-luminance")) { colourSpaceOperation = osg::MODULATE_ALPHA_BY_LUMINANCE; }
+    while(arguments.read("--modulate-alpha-by-colour", colourModulate.x(),colourModulate.y(),colourModulate.z(),colourModulate.w() )) { colourSpaceOperation = osg::MODULATE_ALPHA_BY_COLOUR; }
+    while(arguments.read("--replace-alpha-with-luminance")) { colourSpaceOperation = osg::REPLACE_ALPHA_WITH_LUMINANCE; }
+    while(arguments.read("--replace-rgb-with-luminance")) { colourSpaceOperation = osg::REPLACE_RGB_WITH_LUMINANCE; }
 
 
@@ -1019 +937 @@
 
 
-    if (colourSpaceOperation!=NO_COLOUR_SPACE_OPERATION)
+    if (colourSpaceOperation!=osg::NO_COLOUR_SPACE_OPERATION)
     {
         for(Images::iterator itr = images.begin();
@@ -1025 +943 @@
             ++itr)
         {
-            (*itr) = doColourSpaceConversion(colourSpaceOperation, itr->get(), colourModulate);
+            (*itr) = osg::colorSpaceConversion(colourSpaceOperation, itr->get(), colourModulate);
         }
     }

OpenSceneGraph/trunk/include/osg/Image

@@ -180 +180 @@
         virtual void readImageFromCurrentTexture(unsigned int contextID, bool copyMipMapsIfAvailable, GLenum type = GL_UNSIGNED_BYTE, unsigned int face = 0);
 
+        /** swap the data and settings between two image objects.*/
+        void swap(osg::Image& rhs);
 
         /** Scale image to specified size. */
@@ -472 +474 @@
         WriteHint   _writeHint;
 
-
         Origin _origin;
 

OpenSceneGraph/trunk/include/osg/ImageUtils

@@ -154 +154 @@
             bool resizeToPowerOfTwo = false);
 
+
+
+
 /** create a 2D osg::Image that provides a point at the center of the image.
  *  The colour across th image is computed from a balance between the center color and the background color controlled by the power of the radius from the center.*/
 extern OSG_EXPORT osg::Image* createSpotLightImage(const osg::Vec4& centerColour, const osg::Vec4& backgroudColour, unsigned int size, float power);
+
+
+enum ColorSpaceOperation
+{
+    NO_COLOUR_SPACE_OPERATION,
+    MODULATE_ALPHA_BY_LUMINANCE,
+    MODULATE_ALPHA_BY_COLOUR,
+    REPLACE_ALPHA_WITH_LUMINANCE,
+    REPLACE_RGB_WITH_LUMINANCE
+};
+
+/** Convert the RGBA values in a Image based on a ColorSpaceOperation defined scheme.*/
+extern osg::Image* colorSpaceConversion(ColorSpaceOperation op, osg::Image* image, const osg::Vec4& colour);
+
 
 }

OpenSceneGraph/trunk/include/osgPresentation/SlideShowConstructor

@@ -16 +16 @@
 #include <osg/Vec3>
 #include <osg/Vec4>
+#include <osg/ImageUtils>
 #include <osg/Group>
 #include <osg/ClearNode>
@@ -292 +293 @@
             cutoffValue(0.1),
             sampleDensityValue(0.005),
-            sampleDensityWhenMovingValue(0.0)
+            sampleDensityWhenMovingValue(0.0),
+            colorSpaceOperation(osg::NO_COLOUR_SPACE_OPERATION),
+            colorModulate(1.0f,1.0f,1.0f,1.0f)
         {
             region[0] = region[1] = region[2] = 0.0f;
@@ -309 +312 @@
         float                                   sampleDensityValue;
         float                                   sampleDensityWhenMovingValue;
+
+        osg::ColorSpaceOperation                colorSpaceOperation;
+        osg::Vec4                               colorModulate;
     };
 

OpenSceneGraph/trunk/src/osg/Image.cpp

@@ -1184 +1184 @@
 }
 
+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)
 {

OpenSceneGraph/trunk/src/osg/ImageUtils.cpp

@@ -616 +616 @@
 
 
-}
-
+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;
+    }
+}
+
+
+
+}
+

OpenSceneGraph/trunk/src/osgPlugins/p3d/ReaderWriterP3D.cpp

@@ -1098 +1098 @@
     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

OpenSceneGraph/trunk/src/osgPresentation/SlideShowConstructor.cpp

@@ -2082 +2082 @@
     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)
     {