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

Go to the documentation of this file.

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

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

// ML-includes
#ifndef __mlInitSystemKernel_H
#include "mlInitSystemKernel.h"
#endif
#ifndef __mlKernel_H
#include "mlKernel.h"
#endif
#ifndef __mlLineApplicator_H
#include "mlLineApplicator.h"
#endif
#ifndef __mlKernelTools_H
#include "mlKernelTools.h"
#endif
#ifndef __mlKernelLineApplicatorBase_H
#include "mlKernelLineApplicatorBase.h"
#endif

ML_START_NAMESPACE


#define ML_DEBUG_ENV_NAME "ML_KERNELLINEAPPLICATOR"

  //---------------------------------------------------------------------------------------------  
  //---------------------------------------------------------------------------------------------
  template <typename DATATYPE, typename KDATATYPE> 
    class MLKERNELEXPORT KernelLineApplicator : public KernelLineApplicatorBase<DATATYPE, KDATATYPE> {

    //-------------------------------------------------------------------------------------------  
    //----------------------- CONSTRUCTORS AND DESTRUCTOR ---------------------------------------  
    //-------------------------------------------------------------------------------------------  

public:
    //--------------------------------------------------------------------------------------------------------
    //--------------------------------------------------------------------------------------------------------
    enum ApplyMode {
      APPLY_COPY                            = 0,
      APPLY_NORMALLY                        ,
      APPLY_USER_FILTER                     ,
      APPLY_IMAGE_INTERVAL_FILTER           ,
      APPLY_KERNEL_INTERVAL_FILTER          ,
      APPLY_IMAGE_AND_KERNEL_INTERVAL_FILTER,
      
      NUM_APPLY_MODES                    
    };

    //-------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------
    static const char* const ApplyModeNames[];

    //-------------------------------------------------------------------------------------------  
    //-------------------------------------------------------------------------------------------  
    KernelLineApplicator() : KernelLineApplicatorBase<DATATYPE, KDATATYPE>()
    {
      _init();
    }

    //-------------------------------------------------------------------------------------------  
    //-------------------------------------------------------------------------------------------  
    KernelLineApplicator(const KernelLineApplicator &kernLineApp): 
      KernelLineApplicatorBase<DATATYPE, KDATATYPE>(kernLineApp)
    {
      _init();
      *this=kernLineApp;
    }

    //-------------------------------------------------------------------------------------------  
    //-------------------------------------------------------------------------------------------  
    KernelLineApplicator(const TKernel<KDATATYPE> &kernel,
                         ApplyMode applyMode,
                         MLdouble iIntMin=-DBL_MIN, MLdouble iIntMax=DBL_MAX, 
                         MLdouble kIntMin=-DBL_MIN, MLdouble kIntMax=DBL_MAX) :
      KernelLineApplicatorBase<DATATYPE, KDATATYPE>(kernel)
    {
      // Initialize this instance.
      _init();
  
      // Specify the kernel.
      setKernel(kernel);

      // Set the mode how the kernel is applied to the image.
      setApplyMode(applyMode);

      // Initialize image and kernel interval.
      setImageInterval (iIntMin, iIntMax);
      setKernelInterval(kIntMin, kIntMax);
    }

    //-------------------------------------------------------------------------------------------  
    //-------------------------------------------------------------------------------------------  
    virtual ~KernelLineApplicator()
    {
      KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_clearIndices();
    }

    //-------------------------------------------------------------------------------------------  
    //-------------------------------------------------------------------------------------------  
    const KernelLineApplicator &operator=(const KernelLineApplicator &kernLineApp)
    {
      // Execute superclass functionality.
      KernelLineApplicatorBase<DATATYPE, KDATATYPE>::operator=(kernLineApp);

      // Assign only if objects differ.
      if (this != &kernLineApp){
        // Copy member settings.
        setApplyMode     (kernLineApp._applyMode);
        setImageInterval (kernLineApp._origIMin, kernLineApp._origIMax);
        setKernelInterval(kernLineApp._kernIMin, kernLineApp._kernIMax);
      }

      return *this;
    }


    //-------------------------------------------------------------------------------------------  
    //------------------------- PARAMETER CONTROL -----------------------------------------------  
    //-------------------------------------------------------------------------------------------  

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

    //-------------------------------------------------------------------------------------------  
    inline void setApplyMode(ApplyMode mode)      { _applyMode = mode; }
    inline ApplyMode getApplyMode()  const        { return _applyMode; }


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

    //-------------------------------------------------------------------------------------------  
    inline DATATYPE getImageIntervalMin()  const  { return _origIMinDT;  }
    inline DATATYPE getImageIntervalMax()  const  { return _origIMaxDT;  }
    inline DATATYPE getKernelIntervalMin() const  { return _kernIMinDT;  }
    inline DATATYPE getKernelIntervalMax() const  { return _kernIMaxDT;  }

    //-------------------------------------------------------------------------------------------  
    //-------------------------------------------------------------------------------------------  
    void setImageInterval(MLdouble min=-DBL_MAX, MLdouble   max=DBL_MAX)
    {
      // Store MLdouble and casted values to DATATYPE. So we don't need to cast so much later.
      _origIMin   = min;
      _origIMax   = max;
      _origIMinDT = static_cast<DATATYPE>(min);
      _origIMaxDT = static_cast<DATATYPE>(max);
      _normOrigI  = _origIMin <= _origIMax;
    }

    //-------------------------------------------------------------------------------------------  
    //-------------------------------------------------------------------------------------------  
    void setKernelInterval(MLdouble min=-DBL_MAX, MLdouble max=DBL_MAX)
    {
      // Store MLdouble and casted values to DATATYPE. So we don't need to cast so much later.
      _kernIMin   = min;
      _kernIMax   = max;
      _kernIMinDT = static_cast<DATATYPE>(min);
      _kernIMaxDT = static_cast<DATATYPE>(max);
      _normKernI  = _kernIMin <= _kernIMax;
    }

    //-------------------------------------------------------------------------------------------  
    //-------------------------------------------------------------------------------------------  
    bool isInImageInterval(DATATYPE v) const
    {
      // Look whether v is in current interval. Normally v is implicitly converted to
      // _origMin/_origMax type for comparison, i.e. 3 <= 3.5 results to false.
      // For user defined data types (internally implemented as carrier types), however,
      // we want to use the user defined comparison. So we must look for the data type and
      // use different casts.
      return (MLIsStandardTypePtr((DATATYPE*)NULL) ?

               // Use MLdouble for comparison
               (( _normOrigI && ((static_cast<MLdouble>(v) >=_origIMin) && (static_cast<MLdouble>(v) <= _origIMax))) ||
                (!_normOrigI && ((static_cast<MLdouble>(v) < _origIMax) || (static_cast<MLdouble>(v) >  _origIMin)))    ) :

               // Use DATATYPE for comparison.
               (( _normOrigI && ((v >=_origIMinDT) && (v <= _origIMaxDT))) ||
                (!_normOrigI && ((v < _origIMaxDT) || (v >  _origIMinDT)))    )
             );
    }

    //-------------------------------------------------------------------------------------------  
    //-------------------------------------------------------------------------------------------  
    bool isInKernelInterval(DATATYPE v) const
    {
      // See \c isInImageInterval for documentation.
      return (MLIsStandardTypePtr((DATATYPE*)NULL) ?

               // Use MLdouble for comparison
               (( _normKernI && ((static_cast<MLdouble>(v) >=_kernIMin) && (static_cast<MLdouble>(v) <= _kernIMax))) ||
                (!_normKernI && ((static_cast<MLdouble>(v) < _kernIMax) || (static_cast<MLdouble>(v) >  _kernIMin)))    ) :

               // Use DATATYPE for comparison.
               (( _normKernI && ((v >=_kernIMinDT) && (v <= _kernIMaxDT))) ||
                (!_normKernI && ((v < _kernIMaxDT) || (v >  _kernIMinDT)))    )
             );
    }


    //-------------------------------------------------------------------------------------------  
    //-------------------------------------------------------------------------------------------  
    void applyToLine(TSubImageWithCursor<DATATYPE> *inSubImg,
                     TSubImageWithCursor<DATATYPE> *outSubImg,
                     size_t numVox)
    {
      // Update the index table for this page. It contains an offset to get from the kernel origin
      // to any other kernel voxel. It's needed for fast access to values covered by kernel elements.
      _defineIndices(*inSubImg);

      // Kernel empty or invalid kernel?
      if ((NULL == KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_kernel) || 
          (   0 == KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_indexTabSize)){
        KernelTools::copyLine(inSubImg->getCursorPos(),
                              outSubImg->getCursorPos(), 
                              numVox,
                              KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_srcVoxOffset);
      }
      else{
        switch (_applyMode){

        default:
        case APPLY_COPY:
          KernelTools::copyLine(inSubImg->getCursorPos(), 
                                outSubImg->getCursorPos(),
                                numVox, 
                                KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_srcVoxOffset);
          break;

        case APPLY_USER_FILTER:
          applyUserFilterToLine(inSubImg, outSubImg, numVox);
          break;

        case APPLY_NORMALLY:
          KernelTools::correlateLine
             (inSubImg->getCursorPos(), outSubImg->getCursorPos(), numVox, 
              KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_kernel->getValueTab(), 
              KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_indexTab, 
              KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_indexTabSize);
          break;

        case APPLY_IMAGE_INTERVAL_FILTER:
          KernelTools::correlateLineWithImageInterval
             (inSubImg->getCursorPos(), outSubImg->getCursorPos(), numVox, 
              KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_kernel->getValueTab(), 
              KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_indexTab, 
              KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_indexTabSize, 
              KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_srcVoxOffset, 
              _origIMin, 
              _origIMax);
          break;

        case APPLY_KERNEL_INTERVAL_FILTER:
          KernelTools::correlateLineWithKernelInterval
             (inSubImg->getCursorPos(), outSubImg->getCursorPos(), numVox,
              KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_kernel->getValueTab(), 
              KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_indexTab, 
              KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_indexTabSize, 
              KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_srcVoxOffset, 
              _kernIMin, 
              _kernIMax);
          break;

        case APPLY_IMAGE_AND_KERNEL_INTERVAL_FILTER: 
          KernelTools::correlateLineWithImageAndKernelInterval
             (inSubImg->getCursorPos(), outSubImg->getCursorPos(), numVox, 
              KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_kernel->getValueTab(), 
              KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_indexTab, 
              KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_indexTabSize, 
              KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_srcVoxOffset,
              _origIMin, 
              _origIMax, 
              _kernIMin, 
              _kernIMax);
          break;
        }
      }
    }

    //-------------------------------------------------------------------------------------------  
    //-------------------------------------------------------------------------------------------  
    virtual void applyUserFilterToLine(TSubImageWithCursor<DATATYPE> *inSubImg,
                                       TSubImageWithCursor<DATATYPE> *outSubImg,
                                       long numVox) const
    {
       // Use convenience routine from helper class when not overloaded.
       KernelTools::copyLine(inSubImg->getCursorPos(), 
                             outSubImg->getCursorPos(), 
                             numVox, 
                             KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_srcVoxOffset);
    }

  protected:

    //-------------------------------------------------------------------------------------------  
    //-------------------------------------------------------------------------------------------  
    void _init()
    {
      // Execute superclass functionality.
      KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_init();

      // mode how the kernel is applied to the image.
      _applyMode = APPLY_NORMALLY;

      // Intervals to exclude input image voxels from filtering or from usage in kernels.
      setImageInterval (-DBL_MAX, DBL_MAX);
      setKernelInterval(-DBL_MAX, DBL_MAX);
    }



    //-------------------------------------------------------------------------------------------  
    //                     Protected members.
    //-------------------------------------------------------------------------------------------  

    //-------------------------------------------------------------------------------------------  
    //-------------------------------------------------------------------------------------------  
    ApplyMode       _applyMode;

    //-------------------------------------------------------------------------------------------  
    // ---------------------- KERNEL INTERVALS AND THEIR PROPERTIES -----------------------------
    //-------------------------------------------------------------------------------------------  

    MLdouble        _origIMin;
    MLdouble        _origIMax;
    DATATYPE        _origIMinDT;
    DATATYPE        _origIMaxDT;

    bool            _normOrigI;




    MLdouble        _kernIMin;
    MLdouble        _kernIMax;
    DATATYPE        _kernIMinDT;
    DATATYPE        _kernIMaxDT;

    bool            _normKernI;
  };

//-------------------------------------------------------------------
//-------------------------------------------------------------------
template <typename DATATYPE, typename KDATATYPE> const char * const 
 KernelLineApplicator<DATATYPE, KDATATYPE>::ApplyModeNames[] = {
    "ApplyCopy",
    "ApplyNormally",
    "ApplyUserFilter",
    "ApplyImageIntervalFilter",
    "ApplyKernelIntervalFilter",
    "ApplyImageAndKernelInterval"
  };



// Forget ML_DEBUG_ENV_NAME, because it probably will be used by other operators, too.
#undef ML_DEBUG_ENV_NAME

ML_END_NAMESPACE

#endif // __mlKernelLineApplicator_H