mlKernelLineApplicator.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(__mlKernelLineApplicator_H)
#define __mlKernelLineApplicator_H
 
// ML-includes
#include "mlInitSystemKernel.h"
#include "mlKernel.h"
#include "mlLineApplicator.h"
#include "mlKernelTools.h"
#include "mlKernelLineApplicatorBase.h"
 
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, however,
      // we want to use the user defined comparison. So we must look for the data type and
      // use different casts.
      return (TypeTraits<DATATYPE>::isScalarType ?
 
               // 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 (TypeTraits<DATATYPE>::isScalarType ?
 
               // 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