otbStreamingInnerProductVectorImageFilter.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.

  Some parts of this code are derived from ITK. See ITKCopyright.txt
  for details.


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

=========================================================================*/
#ifndef __otbStreamingInnerProductVectorImageFilter_h
#define __otbStreamingInnerProductVectorImageFilter_h

#include "otbPersistentImageFilter.h"
#include "otbPersistentFilterStreamingDecorator.h"
#include "itkNumericTraits.h"
#include "itkArray.h"
#include "itkSimpleDataObjectDecorator.h"
#include "itkImageRegionSplitter.h"
#include "itkVariableSizeMatrix.h"
#include "itkVariableLengthVector.h"
#include "vnl/vnl_matrix.h"

namespace otb
{

template<class TInputImage>
class ITK_EXPORT PersistentInnerProductVectorImageFilter :
  public PersistentImageFilter<TInputImage, TInputImage>
{
public:
  typedef PersistentInnerProductVectorImageFilter         Self;
  typedef PersistentImageFilter<TInputImage, TInputImage> Superclass;
  typedef itk::SmartPointer<Self>                         Pointer;
  typedef itk::SmartPointer<const Self>                   ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(PersistentInnerProductVectorImageFilter, PersistentImageFilter);

  typedef TInputImage                      ImageType;
  typedef typename TInputImage::Pointer    InputImagePointer;
  typedef typename TInputImage::RegionType RegionType;
  typedef typename TInputImage::PixelType  PixelType;

  itkStaticConstMacro(InputImageDimension, unsigned int, TInputImage::ImageDimension);

  itkStaticConstMacro(ImageDimension, unsigned int, TInputImage::ImageDimension);

  typedef typename itk::DataObject::Pointer DataObjectPointer;

  typedef vnl_matrix<double>               MatrixType;
  typedef typename std::vector<MatrixType> ArrayMatrixType;

  typedef itk::SimpleDataObjectDecorator<MatrixType> MatrixObjectType;

  MatrixType GetInnerProduct() const
  {
    return this->GetInnerProductOutput()->Get();
  }
  MatrixObjectType* GetInnerProductOutput();
  const MatrixObjectType* GetInnerProductOutput() const;

  virtual DataObjectPointer MakeOutput(unsigned int idx);

  virtual void AllocateOutputs();
  virtual void GenerateOutputInformation();
  virtual void Synthetize(void);
  virtual void Reset(void);

  itkSetMacro(CenterData, bool);
  itkGetMacro(CenterData, bool);
  itkBooleanMacro(CenterData);

protected:
  PersistentInnerProductVectorImageFilter();
  virtual ~PersistentInnerProductVectorImageFilter() {}
  virtual void PrintSelf(std::ostream& os, itk::Indent indent) const;
  void  ThreadedGenerateData(const RegionType& outputRegionForThread, int threadId);

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

  ArrayMatrixType m_ThreadInnerProduct;

  bool m_CenterData;

}; // end of class PersistentStatisticsVectorImageFilter

template<class TInputImage>
class ITK_EXPORT StreamingInnerProductVectorImageFilter :
  public PersistentFilterStreamingDecorator<PersistentInnerProductVectorImageFilter<TInputImage> >
{
public:
  typedef StreamingInnerProductVectorImageFilter Self;
  typedef PersistentFilterStreamingDecorator
  <PersistentInnerProductVectorImageFilter<TInputImage> > Superclass;
  typedef itk::SmartPointer<Self>       Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(StreamingInnerProductVectorImageFilter, PersistentFilterStreamingDecorator);

  typedef TInputImage                         InputImageType;
  typedef typename Superclass::FilterType     StatFilterType;
  typedef typename StatFilterType::MatrixType MatrixType;

  typedef typename StatFilterType::MatrixObjectType MatrixObjectType;

  void SetInput(TInputImage * input)
  {
    this->GetFilter()->SetInput(input);
  }
  TInputImage * GetInput()
  {
    return this->GetFilter()->GetInput();
  }

  MatrixType GetInnerProduct() const
  {
    return this->GetFilter()->GetInnerProductOutput()->Get();
  }
  MatrixObjectType* GetInnerProductOutput()
  {
    return this->GetFilter()->GetInnerProductOutput();
  }
  const MatrixObjectType* GetInnerProductOutput() const
  {
    return this->GetFilter()->GetInnerProductOutput();
  }

  void SetCenterData(bool centerdata)
  {
    this->GetFilter()->SetCenterData(centerdata);
  }

protected:
  StreamingInnerProductVectorImageFilter() {};
  virtual ~StreamingInnerProductVectorImageFilter() {}

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

};

} // end namespace otb

#ifndef OTB_MANUAL_INSTANTIATION
#include "otbStreamingInnerProductVectorImageFilter.txx"
#endif

#endif