MeVisLab/Standard/Sources/ML/MLKernel/mlKernelBaseModule.h

Go to the documentation of this file.

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

//-------------------------------------------------------------------------
// Prevent multiple including of this file.
#if !defined (__mlKernelBaseModule_H)
#define __mlKernelBaseModule_H

// ML-includes
#ifndef __mlInitSystemKernel_H
#include "mlInitSystemKernel.h"
#endif
#ifndef __mlKernel_H
#include "mlKernel.h"
#endif
#ifndef __mlKernelTools_H
#include "mlKernelTools.h"
#endif
#ifndef __mlKernelMacros_H
#include "mlKernelMacros.h"
#endif

ML_START_NAMESPACE

  //---------------------------------------------------------
  //---------------------------------------------------------
  class MLKERNELEXPORT KernelBaseModule : public Module{

    friend class KernelBaseOpCalculateOutputImageHandler;

  protected:
    KernelBaseModule(int inputNum=1, int outputNum=1);

  public:


    inline Kernel       &getKernel()                       { return _kernel;             }

    inline const Kernel &getConstKernel() const            { return _kernel;             }






    inline EnumField    *getBorderHandlingFld() const      { return _borderHandlingFld;  }

    inline DoubleField  *getFillValueFld() const           { return _fillValueFld;       }

    // The field value describes the number of filtering iterations to be applied 
    // each page of the output image; the default is 1. Values < 1 are handled as 1.
    // Still untested.
    //inline IntField     *getNumIterationsFld() const       { return _numIterationsFld;  }

    enum InputImageRefExtent { 
      Overlap = 0,     

      Input0_ExtWithoutFill,     

      Input0_ExtWithFill,     

      MaxExtentsWithoutFill,

      MaxExtentsWithFill,

      NumImageRefExtents
    };

    inline EnumField    &getReferenceExtentModeFld() const { return *_referenceExtentFld; }

  protected:

    virtual void _setCorrectCorrelationMinMax(bool imageIntervalUsed=false,
                                              MLdouble intervalMin=0,
                                              MLdouble intervalMax=0,
                                              MLint inIdx=0,
                                              MLint outIdx=0);

    virtual ImageVector _getCalculatedReferenceInputExt() const;





    virtual void calculateOutputImageProperties(int outIndex);

    virtual SubImageBox calculateInputSubImageBox(int inIndex, const SubImageBox& outSubImgBox, int outIndex);

    virtual void calcInSubImagePreparation(int outIndex, SubImage *inSubImgs);

    virtual void calcOutSubImagePostProcessing(SubImage *outSubImg, int outIndex, SubImage *inSubImgs);

    virtual void _connectToAllOutputs(Field *field);


  protected:
    virtual void _calcKernelPage(SubImage                    *outSubImg,       
                                 int                          outIndex,        
                                 SubImage                    *inSubImgs,       
                                 int                          numInSubImgs,    
                                 MLsoffset                   *indexTab,        
                                 size_t                       indexTabSize,    
                                 MLsoffset                    srcVoxelOffset,  
                                 size_t                       loopIdx,         
                                 size_t                       iteration,       
                                 const ImageVector           &ov1,             
                                 const ImageVector           &ov2,             
                                 const ImageVector           &pOf,             
                                 size_t                       numVox)=0;       
  
  private:
    virtual void calculateOutputSubImage(SubImage *realOutSubImg, int outIndex, SubImage *inSubImgs, UserThreadData* userThreadData);

    virtual CalculateOutputImageHandler* createCalculateOutputImageHandler(PagedImage* outImg);

    virtual UserThreadData* createUserThreadData(PagedImage* outImg);

    static SubImageBox expandBox(const SubImageBox& inBox, const ImageVector &negFilterExt,
      const ImageVector &posFilterExt,
      bool          isSeparable,
      MLint         numIterations);

  private:



    EnumField   *_borderHandlingFld;

    DoubleField *_fillValueFld;

    // Specifies the number of iterations of the algorithm 
    // onto the page; default is 1.
    // Still not tested.
    //IntField    *_numIterationsFld;

    EnumField   *_referenceExtentFld;

    Kernel       _kernel;

    ImageVector  _calculatedReferenceInputExt;

    ImageVector  _calcReferenceInputExt() const;

    ML_ABSTRACT_MODULE_CLASS_HEADER(KernelBaseModule);
 };


#ifdef ML_DEPRECATED

 // disable deprecation warnings
#ifdef WIN32
#pragma warning(push)
#pragma warning(disable : 4996 )
#endif

 class MLKERNELEXPORT ML_DEPRECATED KernelBaseOp : public KernelBaseModule
 {
 public:
   KernelBaseOp(int inputNum=1, int outputNum=1):KernelBaseModule(inputNum,outputNum)
   {};

   ML_ABSTRACT_MODULE_CLASS_HEADER(KernelBaseOp)
 };

 // re-enable deprecation warnings
#ifdef WIN32
#pragma warning(pop)
#endif

#endif // ML_DEPRECATED

ML_END_NAMESPACE

#endif //of __mlKernelBaseModule_H