MeVisLab/Standard/Sources/ML/MLBase/mlRasterFunction.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------

// This class handles two types of implicit functions which can be rastered
// into a subimage with the methods \c draw().
//
// The first function type tests a voxel coordinate which shall be drawn or not.
// The second function type tests a world coordinate which shall be rastered or not.
// These functions can be set alternatively as static static function or can be
// implemented as overloaded virtual method.
//
// For the implicit functions in world coordinates a pretransformation and
// a voxel to world matrix can be defined so that transformations to the rastered
// objects can be applied simply.
// Note that transformations are only applied in 3d.
//--------------------------------------------------------------------------------
#ifndef __mlRasterFunction_H
#define __mlRasterFunction_H

#ifndef __mlModuleIncludes_H
#include <mlModuleIncludes.h>
#endif
#ifndef __mlBaseInit_H
#include "mlBaseInit.h"
#endif
#ifndef __mlSubImageBoxd_H
#include "mlSubImageBoxd.h"
#endif

ML_START_NAMESPACE

enum TestFuncMode {
  StaticVoxelTest,
  VirtualVoxelTest,
  StaticWorldVoxelTest,
  VirtualWorldVoxelTest
};

typedef bool (*VoxelTestFunction)(const ImageVector &p, void *userData);

typedef bool (*WorldVoxelTestFunction)(const Vector6 &p,  void *userData);

typedef void (*ModifierFunction)(SubImage *tSubImg, const ImageVector &p, void *userData);


//===============================================================================
//===============================================================================
class MLBASEEXPORT RasterFunction : public Base
{
public:
    RasterFunction() : Base()                                          { _init();              }
    
    RasterFunction(const RasterFunction &f) : Base()                   { _init(); *this = f;   };
    
    virtual ~RasterFunction()                                          {};
    
    virtual const RasterFunction &operator=(const RasterFunction &f);
    

    inline void          setFunctionMode(TestFuncMode mode)            { _testFuncMode = mode; }
    inline TestFuncMode  getFunctionMode() const                       { return _testFuncMode; }
    
    virtual bool         isVoxelInside(const ImageVector &) const           { return false;                                 }
    
    virtual bool         isWorldVoxelInside(const Vector6 &) const        { return false;                                 }
    

    inline void          setVoxelTestFunction(VoxelTestFunction  f, void  *data)
    { _voxelTestFunction = f; _voxelTestFunctionData = data; };
    inline void          getVoxelTestFunction(VoxelTestFunction &f, void *&data) const
    { f = _voxelTestFunction; data = _voxelTestFunctionData; };
    

    inline void          setWorldVoxelTestFunction(WorldVoxelTestFunction  f, void  *data)
    { _worldVoxelTestFunction = f; _worldVoxelTestFunctionData = data; };
    inline void          getWorldVoxelTestFunction(WorldVoxelTestFunction &f, void *&data) const
    { f = _worldVoxelTestFunction; data = _worldVoxelTestFunctionData; };
    

    inline void          setModifierFunction(ModifierFunction  f, void  *data)
    { _modifierFunction = f; _modifierFunctionData = data; };
    inline void          getModifierFunction(ModifierFunction &f, void *&data) const
    { f = _modifierFunction; data = _modifierFunctionData; };
    inline void          enableModifierFunction(bool flag)    { _useModifierFunction = flag; };
    inline bool          isModifierFunctionOn() const         { return _useModifierFunction; };
    

    inline void          setFillValue(long double val)                    { _fillValue=val;                               }
    inline long double   getFillValue() const                             { return _fillValue;                            }
    

    inline void          setBGFillValue(long double val)                  { _bgFillValue=val;                             }
    inline long double   getBGFillValue() const                           { return _bgFillValue;                          }
    

    inline void          enableBGFilling(bool val)                        { _isBGFill=val;                                }
    inline bool          isBGFilling() const                              { return _isBGFill;                             }
    

    inline const SubImageBox &getVoxBoundingBox () const                    { return _voxSubImgBox;                         }
    inline void          setVoxBoundingBox(const SubImageBox &box)          { _voxSubImgBox = box;                          }
    inline const SubImageBoxd &getWorldBoundingBox() const                  { return _worldSubImgBox;                       }
    inline void          setWorldBoundingBox(const SubImageBoxd &box)       { _worldSubImgBox = box;                        }
    

    inline void          setPreTransform(const Matrix4 &pre)                 { _preTrans = pre; _composeMatrices();          }
    inline const Matrix4 &  getPretransform() const                          { return _preTrans;                             }
    

    inline void          setVoxToWorld(const Matrix4 &v2w)                   { _voxToWorld = v2w; _composeMatrices();        }
    inline const Matrix4 &  getVoxToWorld() const                            { return _voxToWorld;                           }
    
    virtual void         draw(SubImage *sImg) const;
    

    virtual char*        getPersistentState() const                       { return 0; };
    virtual void         setPersistentState(const char* /*state*/)        {};
    virtual void         clearPersistentState(char* /*state*/) const      {};
    
    virtual RasterFunction* clone() const { return new RasterFunction(*this); };

protected:
    virtual SubImageBox  _transformSubImgBox(const SubImageBoxd &box) const;
    
    virtual SubImageBox  _getClipBox(const SubImageBox &box) const;
    
    virtual void         _getTransformBase(const ImageVector &p, Vector3 tBase[4]) const;
    
    template <typename DATATYPE>
        void                 _fillRaster(const SubImageBox &box, TSubImage<DATATYPE> *pSubImg, Vector3 tBase[4]) const
    {
        // Fill subimage if background filling is enabled.
        if (_isBGFill) { pSubImg->fill(static_cast<DATATYPE>(_bgFillValue)); }
        
        // Cast fill value to right data type to avoid expensive float to long casts on voxel writes.
        const DATATYPE fillVal = static_cast<DATATYPE>(_fillValue);
        
        // Iterate over all voxels of the box to be tested.
        ImageVector p=box.v1;
        for (p.u=box.v1.u;  p.u<=box.v2.u;  p.u++){
            for (p.t=box.v1.t;  p.t<=box.v2.t;  p.t++){
                for (p.c=box.v1.c;  p.c<=box.v2.c;  p.c++){
                    // Get origin of plane in world coordinates (origin). Note that c, t and u coordinates remain untransformed.
                    Vector6 moveZ(tBase[0],0,0,0);
                    
                    for (p.z=box.v1.z;  p.z<=box.v2.z;  p.z++){
                        // Test all voxel coordinates of the box whether they are within the sphere or not.
                        // If yes then set voxel value to the value of fillVal.
                        // If not leave other voxels unchanged.
                        // Note that we use the method setImageValue which permits accesses of the
                        // page in global image coordinates even if only a fraction of the
                        // input subimage is currently accessable. Here the important thing is not
                        // to access the region outside box.
                        switch (_testFuncMode){
                            
                            //-----------------------------------------------------------------------------------------
                            // If a function pointer shall be used for voxel testing
                            // and the function pointer is valid then test/modify all voxels in plane.
                        case StaticVoxelTest:{
                            if (_voxelTestFunction){
                                for (p.y=box.v1.y;  p.y<=box.v2.y;  p.y++){
                                    
                                    if (_useModifierFunction && _modifierFunction){
                                        // Use userdefined functions to modify the image.
                                        for (p.x=box.v1.x;  p.x<=box.v2.x;  p.x++){
                                            if (_voxelTestFunction(p, _voxelTestFunctionData)){
                                                _modifierFunction(pSubImg, p, _modifierFunctionData);
                                            }
                                        }
                                    }
                                    else{
                                        for (p.x=box.v1.x;  p.x<=box.v2.x;  p.x++){
                                            if (_voxelTestFunction(p, _voxelTestFunctionData)){
                                                pSubImg->setImageValue(p, fillVal);
                                            }
                                        }
                                    }
                                }
                            }
                                             }
                            break;
                            
                            //-----------------------------------------------------------------------------------------
                        case VirtualVoxelTest:{
                            // If the virtual voxel test function shall be used then test/modify all voxels in plane.
                            for (p.y=box.v1.y;  p.y<=box.v2.y;  p.y++){
                                
                                if (_useModifierFunction && _modifierFunction){
                                    // Use userdefined functions to modify the image.
                                    for (p.x=box.v1.x;  p.x<=box.v2.x;  p.x++){
                                        if (isVoxelInside(p)) _modifierFunction(pSubImg, p, _modifierFunctionData);
                                    }
                                }
                                else{
                                    for (p.x=box.v1.x;  p.x<=box.v2.x;  p.x++){
                                        if (isVoxelInside(p)) pSubImg->setImageValue(p, fillVal);
                                    }
                                }
                            }
                                              }
                            break;
                            
                            //-----------------------------------------------------------------------------------------
                            // If a function pointer shall be used for voxel testing
                            // the the function pointer is valid then test/modify all voxels in plane.
                        case StaticWorldVoxelTest:{
                            if (_worldVoxelTestFunction){
                                
                                // Set world position of plane start.
                                Vector6 moveY = moveZ;
                                for (p.y=box.v1.y;  p.y<=box.v2.y;  p.y++){
                                    
                                    // Set coordinate to the start of the row.
                                    Vector6 moveX = moveY;
                                    
                                    // Modify voxels in a row.
                                    if (_useModifierFunction && _modifierFunction){
                                        // Use userdefined functions to modify the image.
                                        for (p.x=box.v1.x;  p.x<=box.v2.x;  p.x++){
                                            if (_worldVoxelTestFunction(moveX, _worldVoxelTestFunctionData)){
                                                _modifierFunction(pSubImg, p, _modifierFunctionData);
                                            }
                                            // Go to next voxel in row world space.
                                            moveX += tBase[1];
                                        } // for (p.x...)
                                    }
                                    else{
                                        for (p.x=box.v1.x;  p.x<=box.v2.x;  p.x++){
                                            if (_worldVoxelTestFunction(moveX, _worldVoxelTestFunctionData)){
                                                pSubImg->setImageValue(p, fillVal);
                                            }
                                            // Go to next voxel in row world space.
                                            moveX += tBase[1];
                                        } // for (p.x...)
                                    }
                                    
                                    // Move row start coordinate to next row in world space.
                                    moveY += tBase[2];
                                } // for (p.y...)
                            }
                                                  }
                            break;
                            
                            //-----------------------------------------------------------------------------------------
                        case VirtualWorldVoxelTest:{
                            // Transform origin and voxels in x and y direction to have movement vectors.
                            // Move world position of plane start of voxel to be testetd
                            Vector6 moveY = moveZ;
                            for (p.y=box.v1.y;  p.y<=box.v2.y;  p.y++){
                                
                                // Set world position of plane start.
                                Vector6 moveX = moveY;
                                
                                // Modify voxels in a row.
                                if (_useModifierFunction && _modifierFunction){
                                    // Use userdefined functions to modify the image.
                                    for (p.x=box.v1.x;  p.x<=box.v2.x;  p.x++){
                                        if (isWorldVoxelInside(moveX)){
                                            _modifierFunction(pSubImg, p, _modifierFunctionData);
                                        }
                                        // Go to next voxel in row in world space.
                                        moveX += tBase[1];
                                    } // for (p.x...)
                                }
                                else{
                                    for (p.x=box.v1.x;  p.x<=box.v2.x;  p.x++){
                                        if (isWorldVoxelInside(moveX)){
                                            pSubImg->setImageValue(p, fillVal);
                                        }
                                        // Go to next voxel in row in world space.
                                        moveX += tBase[1];
                                    } // for (p.x...)
                                }
                                // Move row start coordinate to next row in world space.
                                moveY += tBase[2];
                            } // for (p.y...)
                                                   }
                            break;
                        default: {
                            ML_PRINT_WARNING("void RasterFunction::_fillRaster(const SubImageBox &box, TSubImage<DATATYPE> *pSubImg, Vector3 tBase[4]) const", ML_BAD_PARAMETER, "Not rastering!");
                                 }
                            return;
          }  // switch
          
          // Move plane origin to the next z coordinate in world coordinates.
          moveZ += tBase[3];
        }  // for (p.z...
      }
    }
  }
} // void fillRaster(...)


private:
    void              _init();
    
    void              _composeMatrices();
    
    long double       _fillValue;
    
    long double       _bgFillValue;
    
    bool              _isBGFill;
    
    Matrix4           _preTrans;
    
    Matrix4           _voxToWorld;
    
    Matrix4           _v2w;
    
    Matrix4           _w2v;
    
    SubImageBox       _voxSubImgBox;
    
    SubImageBoxd      _worldSubImgBox;
    
    TestFuncMode      _testFuncMode;
    

    VoxelTestFunction _voxelTestFunction;
    void *            _voxelTestFunctionData;
    

    WorldVoxelTestFunction _worldVoxelTestFunction;
    void *            _worldVoxelTestFunctionData;
    

    bool              _useModifierFunction;
    ModifierFunction  _modifierFunction;
    void *            _modifierFunctionData;
    
    ML_CLASS_HEADER(RasterFunction);
    
};

ML_END_NAMESPACE

#endif // __mlRasterFunction_H