itkMultiplyByConstantMatrixVectorImageFilter.h

Go to the documentation of this file.

#ifndef __itkMultiplyByConstantMatrixVectorImageFilter_h
#define __itkMultiplyByConstantMatrixVectorImageFilter_h

#include "itkUnaryFunctorImageFilter.h"
#include "utlNDArray.h"

namespace itk
{
namespace Functor
{
template <class TInput, class TMatrix, class TOutput=TInput>
class MultiplyByConstantMatrix
{
public:
  typedef typename TInput::ValueType   InputValueType;
  typedef typename TOutput::ValueType  OutputValueType;
  typedef utl::NDArray<double, 1>      VectorType;

  MultiplyByConstantMatrix()
  {
  }

  ~MultiplyByConstantMatrix()
  {
  }

  bool operator!=(const MultiplyByConstantMatrix & other) const
  {
    return !( *this == other );
  }

  bool operator==(const MultiplyByConstantMatrix & other) const
  {
    return other.m_ConstantMatrix == m_ConstantMatrix;
  }

  inline TOutput operator()(const TInput & A)
  {
    // Because the user has to specify the constant we don't
    // check if the cte is not 0;
  VectorType  vectorInput(A.GetSize());
  VectorType  vectorOutput(m_ConstantMatrix.Rows());
  TOutput out;
  out.SetSize( m_ConstantMatrix.Rows() );

  utl::VectorToVector<TInput, VectorType>(A, vectorInput, A.Size());
  utl::ProductUtlMv(m_ConstantMatrix, vectorInput, vectorOutput );
  utl::VectorToVector<VectorType, TOutput>(vectorOutput, out, vectorOutput.Size());

  return out;
  }

  void SetConstantMatrix(const TMatrix& ct)
  {
    this->m_ConstantMatrix = ct;
  }

  const TMatrix & GetConstantMatrix() const
  {
    return m_ConstantMatrix;
  }

  const unsigned GetNumberOfComponentsPerPixelInOutput() const
    {
    return m_ConstantMatrix.Rows();
    }

  TMatrix m_ConstantMatrix;
};
}

template <class TInputImage, class TConstantMatrix, class TOutputImage=TInputImage>
class ITK_EXPORT MultiplyByConstantMatrixVectorImageFilter :
  public
  UnaryFunctorImageFilter<TInputImage, TOutputImage,
                          Functor::MultiplyByConstantMatrix<
                            typename TInputImage::PixelType, TConstantMatrix,
                            typename TOutputImage::PixelType> >
{
public:
  typedef MultiplyByConstantMatrixVectorImageFilter Self;
  typedef UnaryFunctorImageFilter<
      TInputImage, TOutputImage,
      Functor::MultiplyByConstantMatrix<
        typename TInputImage::PixelType, TConstantMatrix,
        typename TOutputImage::PixelType> >             Superclass;

  typedef SmartPointer<Self>       Pointer;
  typedef SmartPointer<const Self> ConstPointer;

  itkNewMacro( Self );

  itkTypeMacro( MultiplyByConstantMatrixVectorImageFilter, UnaryFunctorImageFilter );

  void SetConstantMatrix(const TConstantMatrix& ct )
  {
    if( ct != this->GetFunctor().GetConstantMatrix() )
      {
      this->GetFunctor().SetConstantMatrix( ct );
      this->Modified();
      }
  }

  const TConstantMatrix & GetConstantMatrix() const
  {
    return this->GetFunctor().GetConstantMatrix();
  }

protected:
  MultiplyByConstantMatrixVectorImageFilter()
  {
  }

  virtual ~MultiplyByConstantMatrixVectorImageFilter()
  {
  }

  virtual void GenerateOutputInformation() ITK_OVERRIDE
    {
    Superclass::GenerateOutputInformation();
    typename Superclass::OutputImagePointer outputPtr = this->GetOutput();
    unsigned dim = this->GetFunctor().GetNumberOfComponentsPerPixelInOutput();
    outputPtr->SetNumberOfComponentsPerPixel(dim);
    }

  void PrintSelf(std::ostream & os, Indent indent ) const ITK_OVERRIDE
  {
    Superclass::PrintSelf( os, indent );
    os << indent << "Constant Matrix : " << this->GetConstantMatrix() << std::endl;
  }

private:
  MultiplyByConstantMatrixVectorImageFilter(const Self &); // purposely not implemented
  void operator=(const Self &);                      // purposely not implemented
};
} // end namespace itk


#endif