mlRasterFunction.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_RASTER_FUNCTION_H
#define ML_RASTER_FUNCTION_H
 

 
// 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.
 
#include <mlModuleIncludes.h>
#include "mlBaseInit.h"
#include "mlSubImageBoxd.h"
 
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;   };

    ~RasterFunction() override                                          {};

    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(double val)                    { _fillValue=val;                               }
    inline double   getFillValue() const                             { return _fillValue;                            }

    inline void          setBGFillValue(double val)                  { _bgFillValue=val;                             }
    inline 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;

    std::string persistentState() const override { return {}; }
 
    void setPersistentState(const std::string& /*state*/) override {}


    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(ml_cast_from_scalar<DATATYPE>(_bgFillValue)); }
 
        // Cast fill value to right data type to avoid expensive float to long casts on voxel writes.
        const DATATYPE fillVal = ml_cast_from_scalar<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();

    double       _fillValue;

    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