itkAzimuthElevationToCartesianTransform.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 itkAzimuthElevationToCartesianTransform_h
#define itkAzimuthElevationToCartesianTransform_h
 
#include "itkAffineTransform.h"
#include "itkMath.h"
 
namespace itk
{
template <typename TParametersValueType = double, unsigned int NDimensions = 3>
class ITK_TEMPLATE_EXPORT AzimuthElevationToCartesianTransform
  : public AffineTransform<TParametersValueType, NDimensions>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(AzimuthElevationToCartesianTransform);
 
  using Self = AzimuthElevationToCartesianTransform;
  using Superclass = AffineTransform<TParametersValueType, NDimensions>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  static constexpr unsigned int SpaceDimension = NDimensions;
  static constexpr unsigned int ParametersDimension = NDimensions * (NDimensions + 1);
 
  itkTypeMacro(AzimuthElevationToCartesianTransform, AffineTransform);
 
  itkNewMacro(Self);
 
  using ParametersType = typename Superclass::ParametersType;
  using FixedParametersType = typename Superclass::FixedParametersType;
  using TransformCategoryEnum = typename Superclass::TransformCategoryEnum;
 
  using JacobianType = typename Superclass::JacobianType;
  using JacobianPositionType = typename Superclass::JacobianPositionType;
  using InverseJacobianPositionType = typename Superclass::InverseJacobianPositionType;
 
  using ScalarType = typename Superclass::ScalarType;
 
  using InputPointType = typename Superclass::InputPointType;
  using OutputPointType = typename Superclass::OutputPointType;
 
  using MatrixType = Matrix<TParametersValueType, Self::SpaceDimension, Self::SpaceDimension>;
 
  void
  SetAzimuthElevationToCartesianParameters(const double sampleSize,
                                           const double firstSampleDistance,
                                           const long   maxAzimuth,
                                           const long   maxElevation,
                                           const double azimuthAngleSeparation,
                                           const double elevationAngleSeparation);
 
  void
  SetAzimuthElevationToCartesianParameters(const double sampleSize,
                                           const double firstSampleDistance,
                                           const long   maxAzimuth,
                                           const long   maxElevation);
 
  OutputPointType
  TransformPoint(const InputPointType & point) const override;
 
  inline InputPointType
  BackTransform(const OutputPointType & point) const
  {
    InputPointType result;
 
    if (m_ForwardAzimuthElevationToPhysical)
    {
      result = static_cast<InputPointType>(TransformCartesianToAzEl(point));
    }
    else
    {
      result = static_cast<InputPointType>(TransformAzElToCartesian(point));
    }
    return result;
  }
 
  inline InputPointType
  BackTransformPoint(const OutputPointType & point) const
  {
    return BackTransform(point);
  }
 
 
  TransformCategoryEnum
  GetTransformCategory() const override
  {
    return Self::TransformCategoryEnum::UnknownTransformCategory;
  }
 
  void
  SetForwardAzimuthElevationToCartesian();
 
  void
  SetForwardCartesianToAzimuthElevation();
 
  OutputPointType
  TransformAzElToCartesian(const InputPointType & point) const;
 
  OutputPointType
  TransformCartesianToAzEl(const OutputPointType & point) const;
 
  itkSetMacro(MaxAzimuth, long);
  itkGetConstMacro(MaxAzimuth, long);
 
  itkSetMacro(MaxElevation, long);
  itkGetConstMacro(MaxElevation, long);
 
  itkSetMacro(RadiusSampleSize, double);
  itkGetConstMacro(RadiusSampleSize, double);
 
  itkSetMacro(AzimuthAngularSeparation, double);
  itkGetConstMacro(AzimuthAngularSeparation, double);
 
  itkSetMacro(ElevationAngularSeparation, double);
  itkGetConstMacro(ElevationAngularSeparation, double);
 
  itkSetMacro(FirstSampleDistance, double);
  itkGetConstMacro(FirstSampleDistance, double);
 
protected:
  AzimuthElevationToCartesianTransform();
 
  ~AzimuthElevationToCartesianTransform() override = default;
 
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
private:
  long   m_MaxAzimuth;
  long   m_MaxElevation;
  double m_RadiusSampleSize;
  double m_AzimuthAngularSeparation;
  double m_ElevationAngularSeparation;
  double m_FirstSampleDistance;
  bool   m_ForwardAzimuthElevationToPhysical;
}; // class AzimuthElevationToCartesianTransform
} // namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkAzimuthElevationToCartesianTransform.hxx"
#endif
 
#endif /* itkAzimuthElevationToCartesianTransform_h */