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
 *
 *         https://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 "itkBooleanStdVector.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>;

  itkOverrideGetNameOfClassMacro(NarrowBandImageFilterBase);

  using typename Superclass::InputImageType;
  using typename Superclass::OutputImageType;
  using typename Superclass::FiniteDifferenceFunctionType;

  static constexpr unsigned int ImageDimension = Superclass::ImageDimension;

  using typename Superclass::PixelType;

  using 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();
    }
  }

  [[nodiscard]] float
  GetNarrowBandTotalRadius() const
  {
    return m_NarrowBand->GetTotalRadius();
  }

  void
  SetNarrowBandInnerRadius(const float val)
  {
    if (m_NarrowBand->GetInnerRadius() != val)
    {
      m_NarrowBand->SetInnerRadius(val);
      this->Modified();
    }
  }

  [[nodiscard]] 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_ReinitializationFrequency(6)
    , m_IsoSurfaceValue(0.0)
  {
    m_NarrowBand->SetTotalRadius(4);
    m_NarrowBand->SetInnerRadius(2);
  }
 
  ~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{};
 
  BooleanStdVectorType 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