mlKernelLineApplicatorBase.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(__mlKernelLineApplicatorBase_H)
#define __mlKernelLineApplicatorBase_H
 
// ML-includes
#include "mlInitSystemKernel.h"
#include "mlKernel.h"
#include "mlLineApplicator.h"
#include "mlKernelTools.h"
 
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);
 
    //-------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------
    ~KernelLineApplicatorBase() override{ _clearIndices(); }
 
    //-------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------
    const KernelLineApplicatorBase<DATATYPE, KDATATYPE> &operator=(const KernelLineApplicatorBase<DATATYPE, KDATATYPE> &kernLineAppBase);
 
    //-------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------
    ImageVector getNegativeExtent() const override { return _kernel ? _kernel->getNegativeExtent() : ImageVector(0); }
    ImageVector getPositiveExtent() const override { return _kernel ? _kernel->getPositiveExtent() : ImageVector(0); }
 
 
    //-------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------
    inline void setKernel(const TKernel<KDATATYPE> &kernel) { _kernel = &kernel; }
    inline const TKernel<KDATATYPE> &getKernel()  const     { return *_kernel;   }
 
    //-------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------
    void applyToLine(TSubImageWithCursor<DATATYPE> *inSubImg,
                             TSubImageWithCursor<DATATYPE> * /*outSubImg*/,
                             size_t /*numVox*/) override                { _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)
  {
    // Initialize this instance.
    _init();
 
    // Specify the kernel.
    setKernel(kernel);
  }
 
  //-------------------------------------------------------------------------------------------
  //-------------------------------------------------------------------------------------------
  template <typename DATATYPE, typename KDATATYPE>
    void KernelLineApplicatorBase<DATATYPE, KDATATYPE>::_init()
  {
    // Initialize pointer to the kernel used for filtering.
    _kernel = nullptr;
 
    // Table of offsets from the voxel covered by the kernel origin to other image voxels
    // covered by the kernel.
    _indexTab     = nullptr;
    _indexTabSize = 0;
    _srcVoxOffset = 0;
  }
 
  //-------------------------------------------------------------------------------------------
  //-------------------------------------------------------------------------------------------
  template <typename DATATYPE, typename KDATATYPE>
    const KernelLineApplicatorBase<DATATYPE, KDATATYPE>
      &KernelLineApplicatorBase<DATATYPE, KDATATYPE>::
        operator=(const KernelLineApplicatorBase<DATATYPE, KDATATYPE> &kernLineAppBase)
  {
    // 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;
    }
    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()
  {
    // 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 = nullptr;
      _indexTabSize = 0;
    }
  }
 
 
// 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