itkNarrowBandImageFilterBase.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  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 "itkBarrier.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_ASSIGN(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