itkNarrowBandImageFilterBase.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkNarrowBandImageFilterBase_h
#define itkNarrowBandImageFilterBase_h
 
#include "itkFiniteDifferenceImageFilter.h"
#include "itkMultiThreaderBase.h"
#include "itkNarrowBand.h"
#include "itkObjectStore.h"
#include "itkPlatformMultiThreader.h"
 
 
namespace itk
{
template <typename TInputImage, typename TOutputImage>
class ITK_TEMPLATE_EXPORT NarrowBandImageFilterBase : public FiniteDifferenceImageFilter<TInputImage, TOutputImage>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(NarrowBandImageFilterBase);
 
  using Self = NarrowBandImageFilterBase;
  using Superclass = FiniteDifferenceImageFilter<TInputImage, TOutputImage>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkTypeMacro(NarrowBandImageFilterBase, ImageToImageFilter);
 
  using InputImageType = typename Superclass::InputImageType;
  using OutputImageType = typename Superclass::OutputImageType;
  using FiniteDifferenceFunctionType = typename Superclass::FiniteDifferenceFunctionType;
 
  static constexpr unsigned int ImageDimension = Superclass::ImageDimension;
 
  using PixelType = typename Superclass::PixelType;
 
  using TimeStepType = typename Superclass::TimeStepType;
 
  using IndexType = typename OutputImageType::IndexType;
 
  using ValueType = typename OutputImageType::ValueType;
 
  using BandNodeType = BandNode<IndexType, PixelType>;
 
  using NarrowBandType = NarrowBand<BandNodeType>;
  using NarrowBandPointer = typename NarrowBandType::Pointer;
  using RegionType = typename NarrowBandType::RegionType;
  using NarrowBandIterator = typename NarrowBandType::Iterator;
 
  itkSetMacro(IsoSurfaceValue, ValueType);
  itkGetConstMacro(IsoSurfaceValue, ValueType);
 
  //  itkGetConstMacro( RMSChange, ValueType);
 
  void
  InsertNarrowBandNode(const BandNodeType & node)
  {
    m_NarrowBand->PushBack(node); // add new node
    this->Modified();
  }
 
  void
  InsertNarrowBandNode(const IndexType & index)
  {
    BandNodeType tmpnode;
 
    tmpnode.m_Index = index;
    m_NarrowBand->PushBack(tmpnode);
    this->Modified();
  }
 
  void
  InsertNarrowBandNode(const IndexType & index, const PixelType & value, const signed char & nodestate)
  {
    BandNodeType tmpnode;
 
    tmpnode.m_Data = value;
    tmpnode.m_Index = index;
    tmpnode.m_NodeState = nodestate;
 
    m_NarrowBand->PushBack(tmpnode);
    this->Modified();
  }
 
  void
  SetNarrowBandTotalRadius(const float & val)
  {
    if (m_NarrowBand->GetTotalRadius() != val)
    {
      m_NarrowBand->SetTotalRadius(val);
      this->Modified();
    }
  }
 
  float
  GetNarrowBandTotalRadius() const
  {
    return m_NarrowBand->GetTotalRadius();
  }
 
  void
  SetNarrowBandInnerRadius(const float & val)
  {
    if (m_NarrowBand->GetInnerRadius() != val)
    {
      m_NarrowBand->SetInnerRadius(val);
      this->Modified();
    }
  }
 
  float
  GetNarrowBandInnerRadius() const
  {
    return m_NarrowBand->GetInnerRadius();
  }
 
  virtual void
  CreateNarrowBand()
  {}
 
  virtual void
  SetNarrowBand(NarrowBandType * ptr)
  {
    if (m_NarrowBand != ptr)
    {
      m_NarrowBand = ptr;
      this->Modified();
    }
  }
 
  void
  CopyInputToOutput() override;
 
protected:
  NarrowBandImageFilterBase()
  {
    m_NarrowBand = NarrowBandType::New();
    m_NarrowBand->SetTotalRadius(4);
    m_NarrowBand->SetInnerRadius(2);
    m_ReinitializationFrequency = 6;
    m_IsoSurfaceValue = 0.0;
    m_Step = 0;
    m_Touched = false;
  }
 
  ~NarrowBandImageFilterBase() override = default;
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  NarrowBandPointer m_NarrowBand;
 
  struct ThreadRegionType
  {
 
    NarrowBandIterator first;
 
    NarrowBandIterator last;
  };
 
  std::vector<RegionType> m_RegionList;
 
  void
  GetSplitRegion(const size_t & i, ThreadRegionType & splitRegion);
 
  void
  Initialize() override;
 
  void
  InitializeIteration() override;
 
  void
  PostProcessOutput() override;
 
  /* This function clears all pixels from the narrow band */
  void
  ClearNarrowBand();
 
  void
  GenerateData() override;
 
  /* Variables to control reinitialization */
  IdentifierType m_ReinitializationFrequency;
  IdentifierType m_Step;
 
  bool m_Touched;
 
  std::vector<bool> m_TouchedForThread;
 
  ValueType m_IsoSurfaceValue;
 
private:
  /* This class does not use AllocateUpdateBuffer to allocate memory for its
   * narrow band. This is taken care of in SetNarrowBand, and InsertNarrowBandNode
   * functions. This function is here for compatibility with the
   * FiniteDifferenceSolver framework.
   */
  void
  AllocateUpdateBuffer() override
  {}
 
  virtual void
  ThreadedApplyUpdate(const TimeStepType & dt, const ThreadRegionType & regionToProcess, ThreadIdType threadId);
 
  void
  ApplyUpdate(const TimeStepType &) override
  {}
 
  virtual TimeStepType
  ThreadedCalculateChange(const ThreadRegionType & regionToProcess);
 
  TimeStepType
  CalculateChange() override
  {
    return 0;
  }
};
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkNarrowBandImageFilterBase.hxx"
#endif
 
#endif