sitkCompositeTransform.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 sitkCompositeTransform_h
#define sitkCompositeTransform_h
 
#include "sitkCommon.h"
#include "sitkTransform.h"
 
namespace itk
{
 
 
template <typename TParametersValueType, unsigned int NInputDimensions, unsigned int NOutputDimensions>
class Transform;
 
namespace simple
{
 
class SITKCommon_EXPORT CompositeTransform
    : public Transform {
public:
  using Self = CompositeTransform;
  using Superclass = Transform;
 
  explicit CompositeTransform(unsigned int dimensions);
 
  CompositeTransform( const Transform & );
 
  CompositeTransform( const CompositeTransform & );
 
  explicit CompositeTransform(const std::vector<itk::simple::Transform> &);
 
  ~CompositeTransform() override;
 
  CompositeTransform &operator=( const CompositeTransform &);
 
  std::string GetName( ) const override  { return std::string("CompositeTransform");}
 
 
  SITK_RETURN_SELF_TYPE_HEADER FlattenTransform();
 
  SITK_RETURN_SELF_TYPE_HEADER AddTransform( Transform t );
 
  unsigned int GetNumberOfTransforms() const;
 
  void ClearTransforms();
 
  void RemoveTransform();
 
  Transform GetBackTransform();
 
  Transform GetNthTransform(unsigned int n);
 
protected:
 
  void SetPimpleTransform( PimpleTransformBase * ) override;
 
private:
 
 
  struct MyVisitor
  {
    itk::TransformBase *transform;
    CompositeTransform *that;
    template< typename TransformType >
    void operator() ( )
    {
      TransformType *t = dynamic_cast<TransformType*>(transform);
      if (t)
      {
        that->InternalInitialization(t);
        // set to null to stop trying dynamic_cast
        transform = nullptr;
      }
    }
  };
 
  void InternalInitialization(itk::TransformBase *transform);
 
  template<unsigned int NDimension>
  void InternalInitialization(itk::CompositeTransform< double, NDimension > *);
 
  template <unsigned int NDimensions>
  void InternalInitialization(itk::Transform<double, NDimensions, NDimensions> *);
 
  std::function<void ()> m_pfFlattenTransform;
  std::function<void ( Transform & )> m_pfAddTransform;
  std::function<void ()> m_pfRemoveTransform;
  std::function<Transform ()> m_pfBackTransform;
  std::function<Transform (unsigned int)> m_pfGetNthTransform;
  std::function<unsigned int ()> m_pfGetNumberOfTransforms;
  std::function<void ()> m_pfClearTransformQueue;
};
 
}
}
 
#endif // sitkCompositeTransform_h