itkAzimuthElevationToCartesianTransform.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 __itkAzimuthElevationToCartesianTransform_h
#define __itkAzimuthElevationToCartesianTransform_h

#include "itkAffineTransform.h"
#include "vnl/vnl_math.h"

namespace itk
{
template< class TScalarType = float,  // Data type for scalars
          unsigned int NDimensions = 3 >
// (e.g. float or double)
class ITK_EXPORT AzimuthElevationToCartesianTransform:
  public AffineTransform< TScalarType, NDimensions >
{
public:
  typedef AzimuthElevationToCartesianTransform         Self;
  typedef AffineTransform<  TScalarType, NDimensions > Superclass;
  typedef SmartPointer< Self >                         Pointer;
  typedef SmartPointer< const Self >                   ConstPointer;

  itkStaticConstMacro(SpaceDimension, unsigned int, NDimensions);
  itkStaticConstMacro( ParametersDimension, unsigned int,
                       NDimensions * ( NDimensions + 1 ) );

  itkTypeMacro(AzimuthElevationToCartesianTransform, AffineTransform);

  itkNewMacro(Self);

  typedef typename Superclass::ParametersType ParametersType;

  typedef typename Superclass::JacobianType JacobianType;

  typedef typename Superclass::ScalarType ScalarType;

  typedef  typename Superclass::InputPointType  InputPointType;
  typedef  typename Superclass::OutputPointType OutputPointType;

  typedef Matrix< TScalarType, itkGetStaticConstMacro(SpaceDimension),
                  itkGetStaticConstMacro(SpaceDimension) > MatrixType;

  void SetAzimuthElevationToCartesianParameters(
    const double sampleSize,
    const double blanking,
    const long maxAzimuth,
    const long maxElevation,
    const double azimuthAngleSeparation,
    const double elevationAngleSeparation);

  void SetAzimuthElevationToCartesianParameters(const double sampleSize,
                                                const double blanking,
                                                const long maxAzimuth,
                                                const long maxElevation);

  OutputPointType     TransformPoint(const InputPointType  & point) const;

  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);
  }

  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();

  virtual ~AzimuthElevationToCartesianTransform();

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

private:
  AzimuthElevationToCartesianTransform(const Self &); // purposely not
                                                      // implemented
  void operator=(const Self &);                       //purposely not

  // implemented

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