sitkCannySegmentationLevelSetImageFilter.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 sitkCannySegmentationLevelSetImageFilter_h
#define sitkCannySegmentationLevelSetImageFilter_h
 
/*
 * WARNING: DO NOT EDIT THIS FILE!
 * THIS FILE IS AUTOMATICALLY GENERATED BY THE SIMPLEITK BUILD PROCESS.
 * Please look at sitkImageFilterTemplate.h.in to make changes.
 */
 
#include <memory>
 
#include "sitkBasicFilters.h"
#include "sitkImageFilter.h"
 
namespace itk::simple {

    class SITKBasicFilters_EXPORT CannySegmentationLevelSetImageFilter : public ImageFilter {
    public:
      using Self = CannySegmentationLevelSetImageFilter;

      virtual ~CannySegmentationLevelSetImageFilter();

      CannySegmentationLevelSetImageFilter();

      using PixelIDTypeList = RealPixelIDTypeList;
\

      SITK_RETURN_SELF_TYPE_HEADER SetThreshold ( double Threshold ) { this->m_Threshold = Threshold; return *this; }

      double GetThreshold() const { return this->m_Threshold; }\

      SITK_RETURN_SELF_TYPE_HEADER SetVariance ( double Variance ) { this->m_Variance = Variance; return *this; }

      double GetVariance() const { return this->m_Variance; }\

      SITK_RETURN_SELF_TYPE_HEADER SetMaximumRMSError ( double MaximumRMSError ) { this->m_MaximumRMSError = MaximumRMSError; return *this; }

      double GetMaximumRMSError() const { return this->m_MaximumRMSError; }\

      SITK_RETURN_SELF_TYPE_HEADER SetPropagationScaling ( double PropagationScaling ) { this->m_PropagationScaling = PropagationScaling; return *this; }

      double GetPropagationScaling() const { return this->m_PropagationScaling; }\

      SITK_RETURN_SELF_TYPE_HEADER SetCurvatureScaling ( double CurvatureScaling ) { this->m_CurvatureScaling = CurvatureScaling; return *this; }

      double GetCurvatureScaling() const { return this->m_CurvatureScaling; }\

      SITK_RETURN_SELF_TYPE_HEADER SetAdvectionScaling ( double AdvectionScaling ) { this->m_AdvectionScaling = AdvectionScaling; return *this; }

      double GetAdvectionScaling() const { return this->m_AdvectionScaling; }\

      SITK_RETURN_SELF_TYPE_HEADER SetNumberOfIterations ( uint32_t NumberOfIterations ) { this->m_NumberOfIterations = NumberOfIterations; return *this; }

      uint32_t GetNumberOfIterations() const { return this->m_NumberOfIterations; }\

      SITK_RETURN_SELF_TYPE_HEADER SetReverseExpansionDirection ( bool ReverseExpansionDirection ) { this->m_ReverseExpansionDirection = ReverseExpansionDirection; return *this; }

      SITK_RETURN_SELF_TYPE_HEADER ReverseExpansionDirectionOn() { return this->SetReverseExpansionDirection(true); }
      SITK_RETURN_SELF_TYPE_HEADER ReverseExpansionDirectionOff() { return this->SetReverseExpansionDirection(false); }

      bool GetReverseExpansionDirection() const { return this->m_ReverseExpansionDirection; }\

      SITK_RETURN_SELF_TYPE_HEADER SetIsoSurfaceValue ( double IsoSurfaceValue ) { this->m_IsoSurfaceValue = IsoSurfaceValue; return *this; }

      double GetIsoSurfaceValue() const { return this->m_IsoSurfaceValue; }
     uint32_t GetElapsedIterations() const { return this->m_ElapsedIterations; };

     double GetRMSChange() const { return this->m_RMSChange; };

     Image GetCannyImage() const { return this->m_CannyImage; };
 

      std::string GetName() const { return std::string ("CannySegmentationLevelSetImageFilter"); }

      std::string ToString() const;
 

#ifndef SWIG
      Image Execute ( Image && initialImage, const Image & featureImage );
#endif
      Image Execute ( const Image & initialImage, const Image & featureImage );
 
    private:

 
      using MemberFunctionType = Image (Self::*)( const Image * initialImage, const Image * featureImage );
      template <class TImageType> Image ExecuteInternal ( const Image * initialImage, const Image * featureImage );
 
 
      friend struct detail::MemberFunctionAddressor<MemberFunctionType>;
 
      std::unique_ptr<detail::MemberFunctionFactory<MemberFunctionType> > m_MemberFactory;
 
 
      double  m_Threshold{0.0};
 
      double  m_Variance{0.0};
 
      /* Value of RMS change below which the filter should stop. This is a convergence criterion. */
      double  m_MaximumRMSError{0.02};
 
      /* Weight of direct propagation contribution to the speed term */
      double  m_PropagationScaling{1.0};
 
      /* Weight of the curvature contribution to the speed term */
      double  m_CurvatureScaling{1.0};
 
      /* Weight of the advection contribution to the speed term */
      double  m_AdvectionScaling{1.0};
 
      /* Number of iterations to run */
      uint32_t  m_NumberOfIterations{1000u};
 
      /* Turn On/Off the flag which determines whether Positive or Negative speed terms will cause surface expansion.  If set to TRUE then negative speed terms will cause the surface to expand and positive speed terms will cause the surface to contract.  If set to FALSE (default) then positive speed terms will cause the surface to expand and negative speed terms will cause the surface to contract.  This method can be safely used to reverse the expansion/contraction as appropriate to a particular application or data set. */
      bool  m_ReverseExpansionDirection{false};
 
      /*  */
      double  m_IsoSurfaceValue{0.0};
 
 
      uint32_t m_ElapsedIterations{0};
 
      double m_RMSChange{0.0};
 
      Image m_CannyImage{Image()};
 
 
      bool m_InPlace{false};
    };

#ifndef SWIG
     SITKBasicFilters_EXPORT Image CannySegmentationLevelSet ( Image && initialImage, const Image & featureImage, double threshold = 0.0, double variance = 0.0, double maximumRMSError = 0.02, double propagationScaling = 1.0, double curvatureScaling = 1.0, double advectionScaling = 1.0, uint32_t numberOfIterations = 1000u, bool reverseExpansionDirection = false, double isoSurfaceValue = 0.0 );
#endif
     SITKBasicFilters_EXPORT Image CannySegmentationLevelSet ( const Image & initialImage, const Image & featureImage, double threshold = 0.0, double variance = 0.0, double maximumRMSError = 0.02, double propagationScaling = 1.0, double curvatureScaling = 1.0, double advectionScaling = 1.0, uint32_t numberOfIterations = 1000u, bool reverseExpansionDirection = false, double isoSurfaceValue = 0.0 );

}
#endif