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

Go to the documentation of this file.

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

//-------------------------------------------------------------------------
// Prevent multiple including of this file.
#if !defined(__mlKernelLineApplicatorBase_H)
#define __mlKernelLineApplicatorBase_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

ML_START_NAMESPACE


#define ML_DEBUG_ENV_NAME "ML_KERNELLINEAPPLICATORBASE"

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

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

public:
    //-------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------
    KernelLineApplicatorBase(){ _init(); }

    //-------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------
    KernelLineApplicatorBase(const KernelLineApplicatorBase<DATATYPE, KDATATYPE> &kernLineAppBase);

    //-------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------
    KernelLineApplicatorBase(const TKernel<KDATATYPE> &kernel);

    //-------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------
    virtual ~KernelLineApplicatorBase(){ _clearIndices(); }

    //-------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------
    const KernelLineApplicatorBase<DATATYPE, KDATATYPE> &operator=(const KernelLineApplicatorBase<DATATYPE, KDATATYPE> &kernLineAppBase);

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

    //-------------------------------------------------------------------------------------------
    virtual ImageVector getNegativeExtent() const { return _kernel ? _kernel->getNegativeExtent() : ImageVector(0); }
    virtual ImageVector getPositiveExtent() const { return _kernel ? _kernel->getPositiveExtent() : ImageVector(0); }


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

    //-------------------------------------------------------------------------------------------
    inline void setKernel(const TKernel<KDATATYPE> &kernel) { _kernel = &kernel; }
    inline const TKernel<KDATATYPE> &getKernel()  const     { return *_kernel;   }

    //-------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------
    virtual void applyToLine(TSubImageWithCursor<DATATYPE> *inSubImg,
                             TSubImageWithCursor<DATATYPE> * /*outSubImg*/,
                             size_t /*numVox*/)                { _defineIndices(*inSubImg); };

  protected:

    //-------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------
    void _init();


    //-------------------------------------------------------------------------------------------
    // --------------------- CREATE/CLEAR OF THE KERNEL INDEX TABLE -----------------------------
    //-------------------------------------------------------------------------------------------

    //-------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------
    virtual void _defineIndices(const SubImage &inSubImg);

    //-------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------
    virtual void _clearIndices();


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

    //-------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------
    const TKernel<KDATATYPE> *_kernel;

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

    //-------------------------------------------------------------------------------------------
    MLsoffset      *_indexTab;

    size_t          _indexTabSize;

    MLsoffset       _srcVoxOffset;
  };








  //-------------------------------------------------------------------------------------------
  // --------------------- IMPLEMENTATION PART ------------------------------------------------
  //-------------------------------------------------------------------------------------------


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


  //-------------------------------------------------------------------------------------------
  //-------------------------------------------------------------------------------------------
  template <typename DATATYPE, typename KDATATYPE>
    KernelLineApplicatorBase<DATATYPE, KDATATYPE>::KernelLineApplicatorBase(const TKernel<KDATATYPE> &kernel)
  {
    //mlDebugPrint("Entering constructor...");

    // Initialize this instance.
    _init();

    // Specify the kernel.
    setKernel(kernel);

    //mlDebugPrint("Leaving constructor.");
  }

  //-------------------------------------------------------------------------------------------
  //-------------------------------------------------------------------------------------------
  template <typename DATATYPE, typename KDATATYPE>
    void KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_init()
  {
    // Initialize pointer to the kernel used for filtering.
    _kernel = NULL;

    // Table of offsets from the voxel covered by the kernel origin to other image voxels
    // covered by the kernel.
    _indexTab     = NULL;
    _indexTabSize = 0;
    _srcVoxOffset = 0;
  }

  //-------------------------------------------------------------------------------------------
  //-------------------------------------------------------------------------------------------
  template <typename DATATYPE, typename KDATATYPE>
    const KernelLineApplicatorBase<DATATYPE, KDATATYPE>
      &KernelLineApplicatorBase<DATATYPE, KDATATYPE>::
        operator=(const KernelLineApplicatorBase<DATATYPE, KDATATYPE> &kernLineAppBase)
  {
    //mlDebugPrint("Entering operator=...");

    // Assign only if objects differ.
    if (this != &kernLineAppBase){
      // Copy member settings.
      _kernel       = kernLineAppBase._kernel;
      _srcVoxOffset = kernLineAppBase._srcVoxOffset;

      // Create new index table for filtering.
      _clearIndices();
      _indexTabSize = kernLineAppBase._indexTabSize;
      _indexTab     = new MLsoffset[_indexTabSize];
      if (!_indexTab){
        ML_PRINT_FATAL_ERROR("KernelLineApplicatorBase.h: KernelLineApplicatorBase::operator=(...):",
                             ML_NO_MEMORY, "Not enough memory. Cannot complete assignment operator correctly!");
      }

      // Copy contents of table.
      if (_indexTab){ memcpy(_indexTab, kernLineAppBase._indexTab, sizeof(MLsoffset)*_indexTabSize); }

      // Copy the offset from kernel origin to replaced voxel.
      _srcVoxOffset = kernLineAppBase._srcVoxOffset;
    }

    //mlDebugPrint("Leaving operator=.");

    return *this;
  }

  //-------------------------------------------------------------------------------------------
  //-------------------------------------------------------------------------------------------
  template <typename DATATYPE, typename KDATATYPE>
    void KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_defineIndices(const SubImage &inSubImg)
  {
    // Destroy previous index table.
    _clearIndices();

    // Create new index table.
    _indexTab = KernelTools::createIndexTab(inSubImg.getStride(), *_kernel);

    // Calculate the offset to the source voxel to be copied if input is copied normally to output.
    _srcVoxOffset = KernelTools::calcSrcVoxelOffset(inSubImg.getStride(), _kernel->getNegativeExtent());

    // Store the number of elements _indexTabSize.
    _indexTabSize = _kernel->getTabSize();

  }

  //-------------------------------------------------------------------------------------------
  //-------------------------------------------------------------------------------------------
  template <typename DATATYPE, typename KDATATYPE>
    void KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_clearIndices()
  {
    //mlDebugPrint("Entering _clearIndexTab...");

    // Compute offset index from voxel in output image to voxel in input image which can be
    // returned as original voxel, e.g. if filter operation fails or if it does nothing.
    _srcVoxOffset = 0;

    // Remove previous indexTab.
    if (_indexTab){
      delete []_indexTab;
      _indexTab = NULL;
      _indexTabSize = 0;
    }

    //mlDebugPrint("Leaving _clearIndexTab.");
  }


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

ML_END_NAMESPACE

#endif // __mlKernelLineApplicatorBase_H