mlKernelBaseModule.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
**
**************************************************************************************/
 
 
 
#if !defined (__mlKernelBaseModule_H)
#define __mlKernelBaseModule_H
 
// ML-includes
#include "mlInitSystemKernel.h"
#include "mlKernel.h"
#include "mlKernelTools.h"
#include "mlKernelMacros.h"
 
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;
 
    void calculateOutputImageProperties(int outputIndex, PagedImage* outputImage) override;
 
    SubImageBox calculateInputSubImageBox(int inIndex, const SubImageBox& outSubImgBox, int outIndex) override;
 
    virtual void calcInSubImagePreparation(int outIndex, SubImage *inSubImgs);
 
    virtual void calcOutSubImagePostProcessing(SubImage *outSubImg, int outIndex, SubImage *inSubImgs);
 
    virtual SubImageBox calculateAreaToBeCalculated(const SubImageBox& areaToBeCalculated, const SubImageBox& outSubImageBox);
    virtual ImageVector calculateOutInCoordShift(const ImageVector shift, const SubImageBox& outSubImageBox);
    virtual SubImageBox calculateValidDestArea(const SubImageBox& validDestArea, const SubImageBox& outSubImageBox);
 
    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);
 
    using Module::calculateOutputSubImage;
 
    CalculateOutputImageHandler* createCalculateOutputImageHandler(PagedImage* outImg) override;
 
    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);
 };
 
ML_END_NAMESPACE
 
#endif //of __mlKernelBaseModule_H