itkSymmetricSecondRankTensor.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 __itkSymmetricSecondRankTensor_h
#define __itkSymmetricSecondRankTensor_h

// Undefine an eventual SymmetricSecondRankTensor macro
#ifdef SymmetricSecondRankTensor
#undef SymmetricSecondRankTensor
#endif

#include "itkIndent.h"
#include "itkFixedArray.h"
#include "itkMatrix.h"
#include "itkSymmetricEigenAnalysis.h"

namespace itk
{
template< typename TComponent, unsigned int NDimension = 3 >
class SymmetricSecondRankTensor:public
  FixedArray< TComponent, NDimension *( NDimension + 1 ) / 2 >
{
public:
  typedef SymmetricSecondRankTensor                                    Self;
  typedef FixedArray< TComponent, NDimension *( NDimension + 1 ) / 2 > Superclass;

  itkStaticConstMacro(Dimension, unsigned int, NDimension);
  itkStaticConstMacro( InternalDimension, unsigned int, ( NDimension * ( NDimension + 1 ) / 2 ) );

  typedef FixedArray< TComponent,
                      itkGetStaticConstMacro(InternalDimension) > BaseArray;

  typedef FixedArray< TComponent, NDimension > EigenValuesArrayType;

  typedef Matrix< TComponent, NDimension, NDimension > MatrixType;
  typedef Matrix< TComponent, NDimension, NDimension > EigenVectorsMatrixType;

  typedef TComponent                                    ComponentType;
  typedef typename Superclass::ValueType                ValueType;
  typedef typename NumericTraits< ValueType >::RealType AccumulateValueType;
  typedef typename NumericTraits< ValueType >::RealType RealValueType;

  typedef SymmetricEigenAnalysis< MatrixType,
                                  EigenValuesArrayType, EigenVectorsMatrixType >  SymmetricEigenAnalysisType;

  SymmetricSecondRankTensor() { this->Fill(0); }

  SymmetricSecondRankTensor (const ComponentType & r) { this->Fill(r); }

  template< typename TCoordRepB >
  SymmetricSecondRankTensor(const SymmetricSecondRankTensor< TCoordRepB, NDimension > & pa):
    BaseArray(pa) {}

  typedef ComponentType ComponentArrayType[itkGetStaticConstMacro(InternalDimension)];

  SymmetricSecondRankTensor(const ComponentArrayType r):BaseArray(r) {}

  template< typename TCoordRepB >
  Self & operator=(const SymmetricSecondRankTensor< TCoordRepB, NDimension > & pa)
  {
    BaseArray::operator=(pa);
    return *this;
  }

  Self & operator=(const ComponentType & r);

  Self & operator=(const ComponentArrayType r);

  Self operator+(const Self & vec) const;

  Self operator-(const Self & vec) const;

  const Self & operator+=(const Self & vec);

  const Self & operator-=(const Self & vec);

  Self operator *(const RealValueType & scalar) const;

  Self operator/(const RealValueType & scalar) const;

  const Self & operator*=(const RealValueType & scalar);

  const Self & operator/=(const RealValueType & scalar);

  static unsigned int GetNumberOfComponents()
  {
    return itkGetStaticConstMacro(InternalDimension);
  }

  ComponentType GetNthComponent(int c) const { return this->operator[](c); }

  void SetNthComponent(int c, const ComponentType & v) {  this->operator[](c) = v; }

  ValueType & operator()(unsigned int row, unsigned int col);

  const ValueType & operator()(unsigned int row, unsigned int col) const;

  void SetIdentity();

  AccumulateValueType GetTrace() const;

  void ComputeEigenValues(EigenValuesArrayType & eigenValues) const;

  void ComputeEigenAnalysis(EigenValuesArrayType & eigenValues,
                            EigenVectorsMatrixType & eigenVectors) const;

  template<typename TMatrixValueType>
  Self Rotate( const Matrix<TMatrixValueType, NDimension, NDimension> & m) const;
  template<typename TMatrixValueType>
  Self Rotate( const vnl_matrix_fixed<TMatrixValueType, NDimension, NDimension> & m) const
  {
    return this->Rotate( static_cast<Matrix<TMatrixValueType, NDimension, NDimension> >(m) );
  }
  template<typename TMatrixValueType>
  Self Rotate( const vnl_matrix<TMatrixValueType> & m) const
  {
    return this->Rotate( static_cast<Matrix<TMatrixValueType> >(m) );
  }

  MatrixType PreMultiply(const MatrixType & m) const;

  MatrixType PostMultiply(const MatrixType & m) const;

private:
};

typedef std::ostream OutputStreamType;
typedef std::istream InputStreamType;

template< typename TComponent, unsigned int NDimension  >
OutputStreamType & operator<<(OutputStreamType & os,
                                         const SymmetricSecondRankTensor< TComponent, NDimension > & c);

template< typename TComponent, unsigned int NDimension  >
InputStreamType & operator>>(InputStreamType & is,
                                        SymmetricSecondRankTensor< TComponent, NDimension > & c);
} // end namespace itk

#include "itkNumericTraitsTensorPixel.h"

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

#endif