itkTubeSpatialObjectPoint.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 itkTubeSpatialObjectPoint_h
#define itkTubeSpatialObjectPoint_h

#include "itkSpatialObjectPoint.h"
#include "itkCovariantVector.h"
#include "vnl/vnl_vector_fixed.h"

namespace itk
{
template< unsigned int TPointDimension = 3>
class ITK_TEMPLATE_EXPORT TubeSpatialObjectPoint:
  public SpatialObjectPoint< TPointDimension >
{
public:

  using Self = TubeSpatialObjectPoint;
  using Superclass = SpatialObjectPoint< TPointDimension >;
  using PointType = Point< double, TPointDimension >;
  using VectorType = Vector< double, TPointDimension >;
  using CovariantVectorType = CovariantVector< double, TPointDimension >;

  TubeSpatialObjectPoint();

  ~TubeSpatialObjectPoint() override = default;

  double GetRadiusInObjectSpace() const
  { return m_RadiusInObjectSpace; }

  double GetRadiusInWorldSpace() const;

  void SetRadiusInObjectSpace(double newR)
  { m_RadiusInObjectSpace = newR; }

  void SetRadiusInWorldSpace(double newR);

  const VectorType & GetTangentInObjectSpace() const
  { return m_TangentInObjectSpace; }

  const VectorType GetTangentInWorldSpace() const;

  void SetTangentInObjectSpace(const VectorType & newT)
  { m_TangentInObjectSpace = newT; }

  void SetTangentInWorldSpace(const VectorType & newT);

  const CovariantVectorType & GetNormal1InObjectSpace() const
  { return m_Normal1InObjectSpace; }

  const CovariantVectorType GetNormal1InWorldSpace() const;

  void SetNormal1InObjectSpace(const CovariantVectorType & newV1)
  { m_Normal1InObjectSpace = newV1; }

  void SetNormal1InWorldSpace(const CovariantVectorType & newV1);

  const CovariantVectorType & GetNormal2InObjectSpace() const
  { return m_Normal2InObjectSpace; }

  const CovariantVectorType GetNormal2InWorldSpace() const;

  void SetNormal2InObjectSpace(const CovariantVectorType & newV2)
  { m_Normal2InObjectSpace = newV2; }

  void SetNormal2InWorldSpace(const CovariantVectorType & newV2);

  void SetRidgeness( double ridgeness )
  { m_Ridgeness = ridgeness; }

  double GetRidgeness() const
  { return m_Ridgeness; }

  void SetMedialness( double medialness )
  { m_Medialness = medialness; }

  double GetMedialness() const
  { return m_Medialness; }

  void SetBranchness( double branchness )
  { m_Branchness = branchness; }

  double GetBranchness() const
  { return m_Branchness; }

  void SetAlpha1( double alpha1 )
  { m_Alpha1 = alpha1; }

  double GetAlpha1() const
  { return m_Alpha1; }

  void SetAlpha2( double alpha2 )
  { m_Alpha2 = alpha2; }

  double GetAlpha2() const
  { return m_Alpha2; }

  void SetAlpha3( double alpha3 )
  { m_Alpha3 = alpha3; }

  double GetAlpha3() const
  { return m_Alpha3; }

  Self & operator=(const TubeSpatialObjectPoint & rhs);

protected:

  VectorType          m_TangentInObjectSpace;
  CovariantVectorType m_Normal1InObjectSpace;
  CovariantVectorType m_Normal2InObjectSpace;

  double m_Branchness;
  double m_Medialness;
  double m_Ridgeness;
  double m_Alpha1;
  double m_Alpha2;
  double m_Alpha3;

  double m_RadiusInObjectSpace;

  void PrintSelf(std::ostream & os, Indent indent) const override;

};

} // end of namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkTubeSpatialObjectPoint.hxx"
#endif

#endif // itkTubeSpatialObjectPoint_h