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

Go to the documentation of this file.

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

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

// ML-includes
#ifndef __mlInitSystemKernel_H
#include "mlInitSystemKernel.h"
#endif
#ifndef __mlKernelBaseModule_H
#include "mlKernelBaseModule.h"
#endif

ML_START_NAMESPACE

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

  public:

    KernelModule(int inputNum=1, int outputNum=1);




    inline IntField    *getKernelXFld() const          { return _kernelXFld; }
    inline IntField    *getKernelYFld() const          { return _kernelYFld; }
    inline IntField    *getKernelZFld() const          { return _kernelZFld; }
    inline IntField    *getKernelCFld() const          { return _kernelCFld; }
    inline IntField    *getKernelTFld() const          { return _kernelTFld; }
    inline IntField    *getKernelUFld() const          { return _kernelUFld; }

    inline BoolField   *getMakeSphericalFld() const     { return _makeSphericalFld; }








    inline BoolField   *getNormalizeFld() const         { return _normalizeFld; }









    inline StringField *getExternalKernelFld() const   { return _externalKernelFld; }

    inline BoolField *getUseExternalKernelFld() const  { return _useExternalKernelFld; }

    inline StringField *getKernelOutputFld() const     { return _kernelOutputFld; }






    inline StringField *getKernelInfoFld() const       { return _kernelInfoFld; }

    inline DoubleField *getKernelElementsSumFld() const { return _kernelElementsSumFld; }

    inline IntField   *getNumKernelElementsFld() const  { return _numKernelElementsFld;    }









    inline DoubleField *getImageIntervalMinFld() const { return _imageIntervalMinFld; }

    inline DoubleField *getImageIntervalMaxFld() const { return _imageIntervalMaxFld; }

    inline BoolField *getUseImageIntervalFld() const   { return _useImageIntervalFld; }









    inline DoubleField *getKernelIntervalMinFld() const { return _kernelIntervalMinFld; }

    inline DoubleField *getKernelIntervalMaxFld() const { return _kernelIntervalMaxFld; }

    inline BoolField *getUseKernelIntervalFld() const   { return _useKernelIntervalFld; }















    inline BoolField *getAutoCalcMinMaxFld() const      { return _autoCalcMinMaxFld;    }

    inline NotifyField *getSetAutoMinMaxFld() const     { return _setAutoMinMaxFld;     }







    inline DoubleField *getOutputMinFld() const         { return _outputMinFld;         }

    inline DoubleField *getOutputMaxFld() const         { return _outputMaxFld;         }

    inline BoolField   *getUseMinMaxFld() const         { return _useMinMaxFld;         }

  protected:

    //-------------------------------------------------------------------------------------------
    // Stuff often overloaded in derived classes.
    //-------------------------------------------------------------------------------------------

    //-------------------------------------------------------------------------------------------

    //-------------------------------------------------------------------------------------------
    virtual void _userKernelPreUpdate() { };

    virtual void _userKernelPostUpdate() { };



    //-------------------------------------------------------------------------------------------
    // Stuff often called - but usually not overloaded - by derived classes.
    //-------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------

    //-------------------------------------------------------------------------------------------

    virtual void _createKernelExtentFields(int numDim=6,
                                           const ImageVector &defaultExt=ImageVector(3,3,1,1,1,1));

    virtual void _validateKernelExtents();

    virtual void _createMakeSphericalField(bool defaultVal=false);

    virtual void _createNormalizeField(bool defaultVal=false);

    virtual void _createMinMaxCalcFields(bool defaultValue=false, bool createSetOutputMinMax=false);

    virtual void _createMinMaxFields(MLdouble minVal=0, MLdouble maxVal=0, bool defaultValue=false);

    virtual void _createExternalKernelFields(bool createUseToggle=false, bool defaultVal=false);

    virtual void _createKernelOutputField();

    virtual void _createImageIntervalFields(MLdouble min=0, MLdouble max=1024,
                                            bool createToggle=false, bool useIt=false);

    virtual void _createKernelIntervalFields(MLdouble min=0, MLdouble max=1024,
                                             bool createToggle=false, bool useIt=false);



    virtual void _createKernelInfoField();

    virtual void _createNumKernelElementsField();

    virtual void _createKernelElementsSumField();




    //-------------------------------------------------------------------------------------------

    //-------------------------------------------------------------------------------------------

    virtual void _updateKernel(){ _updateKernel(true); };

    virtual void _updateKernel(bool permitExtentChanges);

    virtual void _updateKernelOutputField();

    virtual std::string _composeKernelInfo(bool valid=true) const;


    //-------------------------------------------------------------------------------------------

    //-------------------------------------------------------------------------------------------

    void _setImageInterval(MLdouble minVal=-DBL_MAX, MLdouble maxVal=DBL_MAX);

    void _setKernelInterval(MLdouble minVal=-DBL_MAX, MLdouble maxVal=DBL_MAX);

    bool _isInImageInterval(MLdouble v) const;

    bool _isInKernelInterval(MLdouble v) const;




    //-------------------------------------------------------------------------------------------

    //-------------------------------------------------------------------------------------------

    virtual void handleNotification(Field* field);

    virtual void activateAttachments();

    virtual void calculateOutputImageProperties(int outIndex);

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

  private:

    //-------------------------------------------------------------------------------------------

    //-------------------------------------------------------------------------------------------

    IntField    *_kernelXFld;
    IntField    *_kernelYFld;
    IntField    *_kernelZFld;
    IntField    *_kernelCFld;
    IntField    *_kernelTFld;
    IntField    *_kernelUFld;

    BoolField   *_makeSphericalFld;



    //-------------------------------------------------------------------------------------------

    //-------------------------------------------------------------------------------------------
    BoolField   *_normalizeFld;



    //-------------------------------------------------------------------------------------------

    //-------------------------------------------------------------------------------------------
    StringField *_externalKernelFld;

    BoolField *_useExternalKernelFld;

    StringField *_kernelOutputFld;



    //-------------------------------------------------------------------------------------------

    //-------------------------------------------------------------------------------------------
    DoubleField *_imageIntervalMinFld;

    DoubleField *_imageIntervalMaxFld;

    BoolField *_useImageIntervalFld;



    //-------------------------------------------------------------------------------------------

    //-------------------------------------------------------------------------------------------
    DoubleField *_kernelIntervalMinFld;

    DoubleField *_kernelIntervalMaxFld;

    BoolField *_useKernelIntervalFld;


    //-------------------------------------------------------------------------------------------

    //-------------------------------------------------------------------------------------------
    StringField *_kernelInfoFld;

    IntField *_numKernelElementsFld;

    DoubleField *_kernelElementsSumFld;


    //-------------------------------------------------------------------------------------------

    //-------------------------------------------------------------------------------------------
    BoolField *_autoCalcMinMaxFld;

    NotifyField *_setAutoMinMaxFld;



    //-------------------------------------------------------------------------------------------

    //-------------------------------------------------------------------------------------------
    DoubleField *_outputMinFld;

    DoubleField *_outputMaxFld;

    BoolField   *_useMinMaxFld;



    //-------------------------------------------------------------------------------------------

    //-------------------------------------------------------------------------------------------

    MLdouble _autoMin;

    MLdouble _autoMax;

    bool      _autoMinMaxValid;



    bool      _normImageInterval;

    bool      _normKernelInterval;

    MLdouble _imageIntervalMin;

    MLdouble _imageIntervalMax;

    MLdouble _kernelIntervalMin;

    MLdouble _kernelIntervalMax;



    ML_ABSTRACT_MODULE_CLASS_HEADER(KernelModule);
 };

#ifdef ML_DEPRECATED

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

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

   ML_ABSTRACT_MODULE_CLASS_HEADER(KernelOp)
 };

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

#endif // ML_DEPRECATED



ML_END_NAMESPACE

#endif //of __mlKernelModule_H