Added ValidDataOperator base class and NoDataValue and ValidRange subclasses, and

support for it in osgTerrain::Layer and GeometryTechniqnue.

include/osgTerrain/Layer

@@ -19,6 +19,7 @@
 #include <osg/Array>
 
 #include <osgTerrain/Locator>
+#include <osgTerrain/ValidDataOperator>
 
 namespace osgTerrain {
 
@@ -38,6 +39,11 @@ class OSGTERRAIN_EXPORT Layer : public osg::Object
         Locator* getLocator() { return _locator.get(); }
         const Locator* getLocator() const { return _locator.get(); }
 
+        void setValidDataOperator(ValidDataOperator* validDataOp) { _validDataOperator = validDataOp; }
+        ValidDataOperator* getValidDataOperator() { return _validDataOperator.get(); }
+        const ValidDataOperator* getValidDataOperator() const { return _validDataOperator.get(); }
+
+
         virtual unsigned int getNumColumns() const { return 0; }
         virtual unsigned int getNumRows() const { return 0; }
 
@@ -46,11 +52,37 @@ class OSGTERRAIN_EXPORT Layer : public osg::Object
         
         virtual bool transform(float offset, float scale) { return false; }
 
+
         virtual bool getValue(unsigned int /*i*/, unsigned int /*j*/, float& /*value*/) const { return false; }
         virtual bool getValue(unsigned int /*i*/, unsigned int /*j*/, osg::Vec2& /*value*/) const { return false; }
         virtual bool getValue(unsigned int /*i*/, unsigned int /*j*/, osg::Vec3& /*value*/) const { return false; }
         virtual bool getValue(unsigned int /*i*/, unsigned int /*j*/, osg::Vec4& /*value*/) const { return false; }
 
+        inline bool getValidValue(unsigned int i, unsigned int j, float& value) const
+        {
+            if (getValue(i,j,value)) return _validDataOperator.valid() ? (*_validDataOperator)(value) : true;
+            return false;
+        }
+
+        inline bool getValidValue(unsigned int i, unsigned int j, osg::Vec2& value) const
+        {
+            if (getValue(i,j,value)) return _validDataOperator.valid() ? (*_validDataOperator)(value) : true;
+            return false;
+        }
+
+        inline bool getValidValue(unsigned int i, unsigned int j, osg::Vec3& value) const
+        {
+            if (getValue(i,j,value)) return _validDataOperator.valid() ? (*_validDataOperator)(value) : true;
+            return false;
+        }
+
+        inline bool getValidValue(unsigned int i, unsigned int j, osg::Vec4& value) const
+        {
+            if (getValue(i,j,value)) return _validDataOperator.valid() ? (*_validDataOperator)(value) : true;
+            return false;
+        }
+
+
         inline void computeIndices(double ndc_x, double ndc_y, unsigned int& i, unsigned int& j, double& ir, double& jr)
         {
             ndc_x *= double(getNumColumns()-1);
@@ -115,8 +147,9 @@ class OSGTERRAIN_EXPORT Layer : public osg::Object
 
         virtual ~Layer();
 
-        osg::ref_ptr<Locator>   _locator;
-        osg::Vec4               _defaultValue;
+        osg::ref_ptr<Locator>           _locator;
+        osg::ref_ptr<ValidDataOperator> _validDataOperator;
+        osg::Vec4                       _defaultValue;
 
 };
 

include/osgTerrain/ValidDataOperator

@@ -0,0 +1,70 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
+ *
+ * This library is open source and may be redistributed and/or modified under  
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
+ * OpenSceneGraph Public License for more details.
+*/
+
+#ifndef OSGTERRAIN_VALIDDATAOPERATOR
+#define OSGTERRAIN_VALIDDATAOPERATOR 1
+
+#include <osgTerrain/Export>
+
+namespace osgTerrain {
+
+struct ValidDataOperator : public osg::Referenced
+{
+    virtual bool operator() (float value) const { return true; }
+    virtual bool operator() (const osg::Vec2& value) const { return operator()(value.x()) && operator()(value.y()) ; }
+    virtual bool operator() (const osg::Vec3& value) const { return operator()(value.x()) && operator()(value.y()) && operator()(value.z());  }
+    virtual bool operator() (const osg::Vec4& value) const { return operator()(value.x()) && operator()(value.y()) && operator()(value.z()) && operator()(value.w()); }
+};
+
+struct ValidRange : public ValidDataOperator
+{
+    ValidRange(float minValue, float maxValue):
+        _minValue(minValue),
+        _maxValue(maxValue) {}
+        
+    void setRange(float minValue, float maxValue)
+    {
+        _minValue = minValue;
+        _maxValue = maxValue;
+    }
+
+    void setMinValue(float minValue) { _minValue = minValue; }
+    float getMinValue() const { return _minValue; }
+
+    void setMaxValue(float maxValue) { _maxValue = maxValue; }
+    float getMaxValue() const { return _maxValue; }
+
+    virtual bool operator() (float value) const { return value>=_minValue && value<=_maxValue; }
+
+    float _minValue, _maxValue;
+};
+
+
+struct NoDataValue : public ValidDataOperator
+{
+    NoDataValue(float value):
+        _value(value) {}
+        
+    void setNoDataValue(float value) { _value = value; }
+    float getValue() const { return _value; }
+
+    virtual bool operator() (float value) const { return value!=_value; }
+    
+    float _value;
+};
+
+}
+
+#endif
+
+