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
 *
 *         https://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 VDimension = 3>
class ITK_TEMPLATE_EXPORT AzimuthElevationToCartesianTransform
  : public AffineTransform<TParametersValueType, VDimension>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(AzimuthElevationToCartesianTransform);

  using Self = AzimuthElevationToCartesianTransform;
  using Superclass = AffineTransform<TParametersValueType, VDimension>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  static constexpr unsigned int SpaceDimension = VDimension;
  static constexpr unsigned int ParametersDimension = VDimension * (VDimension + 1);

  itkOverrideGetNameOfClassMacro(AzimuthElevationToCartesianTransform);

  itkNewMacro(Self);

  using typename Superclass::ParametersType;
  using typename Superclass::FixedParametersType;
  using typename Superclass::TransformCategoryEnum;

  using typename Superclass::JacobianType;
  using typename Superclass::JacobianPositionType;
  using typename Superclass::InverseJacobianPositionType;

  using typename Superclass::ScalarType;

  using typename Superclass::InputPointType;
  using 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;
  }

  bool
  IsLinear() const override
  {
    return false;
  }

  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 */