otbSinclairToCoherencyMatrixFunctor.h

Go to the documentation of this file.

/*=========================================================================

  Program:   ORFEO Toolbox
  Language:  C++
  Date:      $Date$
  Version:   $Revision$


  Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
  See OTBCopyright.txt for details.


     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __otbSinclairToCoherencyMatrixFunctor_h
#define __otbSinclairToCoherencyMatrixFunctor_h

#include "vcl_complex.h"

namespace otb
{
namespace Functor
{
template <class TInput1, class TInput2, class TInput3,
          class TInput4, class TOutput>
class SinclairToCoherencyMatrixFunctor
{
public:
  typedef double                                   RealType;
  typedef std::complex <RealType>                  ComplexType;
  typedef typename TOutput::ValueType              OutputValueType;
  inline TOutput operator ()(const TInput1& Shh, const TInput2& Shv,
                             const TInput3& Svh, const TInput4& Svv)
  {
    TOutput result;

    result.SetSize(m_NumberOfComponentsPerPixel);

    const ComplexType S_hh = static_cast<ComplexType>(Shh);
    const ComplexType S_hv = static_cast<ComplexType>(Shv);
    const ComplexType S_vh = static_cast<ComplexType>(Svh);
    const ComplexType S_vv = static_cast<ComplexType>(Svv);

    const ComplexType HHPlusVV   = S_hh + S_vv;
    const ComplexType HHMinusVV  = S_hh - S_vv;
    const ComplexType HVPlusVH   =  S_hv + S_vh;
    const ComplexType jHVMinusVH = (S_hv - S_vh) * ComplexType(0., 1.);

    result[0] = static_cast<OutputValueType>( std::norm(HHPlusVV) );
    result[1] = static_cast<OutputValueType>( HHPlusVV * vcl_conj(HHMinusVV) );
    result[2] = static_cast<OutputValueType>( HHPlusVV * vcl_conj(HVPlusVH) );
    result[3] = static_cast<OutputValueType>( HHPlusVV * vcl_conj(jHVMinusVH) );
    result[4] = static_cast<OutputValueType>( std::norm(HHMinusVV) );
    result[5] = static_cast<OutputValueType>( HHMinusVV * vcl_conj(HVPlusVH) );
    result[6] = static_cast<OutputValueType>( HHMinusVV * vcl_conj(jHVMinusVH) );
    result[7] = static_cast<OutputValueType>( std::norm(HVPlusVH) );
    result[8] = static_cast<OutputValueType>( HVPlusVH * vcl_conj(jHVMinusVH) );
    result[9] = static_cast<OutputValueType>( std::norm(jHVMinusVH) );

    result /= 2.0;

    return (result);
  }

  unsigned int GetNumberOfComponentsPerPixel()
  {
    return m_NumberOfComponentsPerPixel;
  }

  SinclairToCoherencyMatrixFunctor() {}

  virtual ~SinclairToCoherencyMatrixFunctor() {}

protected:


private:
  //itkStaticConstMacro(NumberOfComponentsPerPixel, unsigned int, 10);
  static const  unsigned int m_NumberOfComponentsPerPixel = 10;
};

} // namespace Functor
} // namespace otb

#endif