diff --git a/Code/BasicFilters/otbShiftScaleVectorImageFilter.h b/Code/BasicFilters/otbShiftScaleVectorImageFilter.h
new file mode 100644
index 0000000000000000000000000000000000000000..4387177dae64692fcd487e63682edd8c3a369f4f
--- /dev/null
+++ b/Code/BasicFilters/otbShiftScaleVectorImageFilter.h
@@ -0,0 +1,211 @@
+/*=========================================================================
+
+ 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 __otbShiftScaleImageFilter_h
+#define __otbShiftScaleImageFilter_h
+
+#include "itkUnaryFunctorImageFilter.h"
+#include "itkVariableLengthVector.h"
+
+namespace otb
+{
+namespace Functor
+{
+/** \class VectorShiftScale
+ * \brief This functor performs a per band linear transform of its input.
+ *
+ * For each band, the following formula is applied :
+ *
+ * \f[ output = \frac{input - shift}{scale} \f]
+ *
+ * Standard casting is applied between input and output type.
+ *
+ * Shifts and scales can be set via the SetShiftValues() and SetScaleValues() methods.
+ *
+ * TInput and TOutput type are supposed to be of type itk::VariableLengthVector.
+ *
+ */
+template<class TInput, class TOutput>
+class VectorShiftScale
+{
+public:
+public:
+ /// Real type typedef
+ typedef typename itk::NumericTraits<typename TInput::ValueType>::RealType RealType;
+
+ /// Constructor
+ VectorShiftScale() {}
+
+ /// Constructor
+ virtual ~VectorShiftScale() {}
+
+ /// Accessors
+ void SetShiftValues(TInput value)
+ {
+ m_Shift = value;
+ }
+ void SetScaleValues(TInput value)
+ {
+ m_Scale = value;
+ }
+ TInput GetShiftValues()
+ {
+ return m_Shift;
+ }
+ TInput GetScaleValues()
+ {
+ return m_Scale;
+ }
+
+ bool operator !=(const VectorShiftScale& other) const
+ {
+ if (m_Shift.Size() == other.GetShiftValues().Size())
+ {
+ for (unsigned int i = 0; i < m_Shift.Size(); ++i)
+ {
+ if (m_Shift[i] != other.GetShiftValues()[i])
+ {
+ return true;
+ }
+ }
+ }
+ if (m_Scale.Size() == other.GetScaleValues().Size())
+ {
+ for (unsigned int i = 0; i < m_Scale.Size(); ++i)
+ {
+ if (m_Scale[i] != other.GetScaleValues()[i])
+ {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ bool operator==(const VectorShiftScale & other) const
+ {
+ return !(*this != other);
+ }
+
+ // main computation method
+ inline TOutput operator()(const TInput & x) const
+ {
+ // output instantiation
+ TOutput result;
+ result.SetSize(x.GetSize());
+
+ // consistency checking
+ if (result.GetSize() != m_Scale.GetSize()
+ || result.GetSize() != m_Shift.GetSize())
+ {
+ itkGenericExceptionMacro(<< "Pixel size different from scale or shift size !");
+ }
+
+ // transformation
+ for (unsigned int i = 0; i < x.GetSize(); ++i)
+ {
+ if ( m_Scale[i] > 1e-10)
+ {
+ const RealType invertedScale = 1 / m_Scale[i];
+ result[i] = static_cast<typename TOutput::ValueType> (invertedScale * (x[i] - m_Shift[i]) );
+ }
+ else
+ {
+ result[i] = static_cast<typename TOutput::ValueType> (x[i] - m_Shift[i]);
+ }
+ }
+ return result;
+ }
+
+private:
+ TInput m_Shift;
+ TOutput m_Scale;
+};
+} // End namespace Functor
+
+/** \class ShiftScaleVectorImageFilter
+ * \brief This filter performs a shift and scaling of a vector image on a per band basis.
+ *
+ * \ingroup IntensityImageFilters
+ * \ingroup MultiThreaded
+ */
+template <class TInputImage, class TOutputImage = TInputImage>
+class ITK_EXPORT ShiftScaleVectorImageFilter :
+ public itk::UnaryFunctorImageFilter<TInputImage, TOutputImage,
+ Functor::VectorShiftScale<ITK_TYPENAME TInputImage::PixelType,
+ ITK_TYPENAME TOutputImage::PixelType> >
+{
+public:
+ /** Standard class typedefs. */
+ typedef ShiftScaleVectorImageFilter Self;
+ typedef Functor::VectorShiftScale< ITK_TYPENAME TInputImage::PixelType,
+ ITK_TYPENAME TOutputImage::PixelType>
+ FunctorType;
+ typedef itk::UnaryFunctorImageFilter<TInputImage, TOutputImage,
+ FunctorType > Superclass;
+ typedef itk::SmartPointer<Self> Pointer;
+ typedef itk::SmartPointer<const Self> ConstPointer;
+
+ typedef typename TOutputImage::PixelType OutputPixelType;
+ typedef typename TInputImage::PixelType InputPixelType;
+ typedef typename InputPixelType::ValueType InputValueType;
+ typedef typename OutputPixelType::ValueType OutputValueType;
+ typedef typename itk::NumericTraits<InputValueType>::RealType InputRealType;
+ typedef typename itk::NumericTraits<OutputValueType>::RealType OutputRealType;
+
+ /** Method for creation through the object factory. */
+ itkNewMacro(Self);
+
+ /** Runtime information support. */
+ itkTypeMacro(ShiftScaleImageFilter,
+ itk::UnaryFunctorImageFilter);
+
+ itkGetMacro(Scale, InputPixelType);
+ itkSetMacro(Scale, InputPixelType);
+
+ itkGetMacro(Shift, InputPixelType);
+ itkSetMacro(Shift, InputPixelType);
+
+ /** Process to execute before entering the multithreaded section */
+ void BeforeThreadedGenerateData(void);
+
+ /** Generate output information */
+ void GenerateOutputInformation(void);
+
+ /** Generate input requested region */
+ void GenerateInputRequestedRegion(void);
+
+protected:
+ ShiftScaleVectorImageFilter() {}
+ virtual ~ShiftScaleVectorImageFilter() {}
+
+private:
+ ShiftScaleVectorImageFilter(const Self&); //purposely not implemented
+ void operator=(const Self&); //purposely not implemented
+
+ InputPixelType m_Scale;
+ InputPixelType m_Shift;
+
+};
+
+} // end namespace otb
+
+#ifndef OTB_MANUAL_INSTANTIATION
+#include "otbShiftScaleVectorImageFilter.txx"
+#endif
+
+#endif
diff --git a/Code/BasicFilters/otbShiftScaleVectorImageFilter.txx b/Code/BasicFilters/otbShiftScaleVectorImageFilter.txx
new file mode 100644
index 0000000000000000000000000000000000000000..826a99b669fd9ded2d619c3ef5b080733eb59629
--- /dev/null
+++ b/Code/BasicFilters/otbShiftScaleVectorImageFilter.txx
@@ -0,0 +1,71 @@
+/*=========================================================================
+
+ 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 MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. See the above copyright notices for more information.
+
+=========================================================================*/
+#ifndef __otbVectorRescaleIntensityImageFilter_txx
+#define __otbVectorRescaleIntensityImageFilter_txx
+
+#include "otbShiftScaleVectorImageFilter.h"
+
+namespace otb
+{
+/**
+ * Generate output information.
+ */
+template <class TInputImage, class TOutputImage>
+void
+ShiftScaleVectorImageFilter<TInputImage, TOutputImage>
+::GenerateOutputInformation(void)
+{
+ this->Superclass::GenerateOutputInformation();
+ this->GetOutput()->SetNumberOfComponentsPerPixel(
+ this->GetInput()->GetNumberOfComponentsPerPixel()
+ );
+}
+/**
+ * Generate input requested region.
+ */
+template <class TInputImage, class TOutputImage>
+void
+ShiftScaleVectorImageFilter<TInputImage, TOutputImage>
+::GenerateInputRequestedRegion(void)
+{
+ if (this->GetInput())
+ {
+ typename TInputImage::Pointer input = const_cast<TInputImage *>(this->GetInput());
+ typename TInputImage::RegionType inputRegion;
+ this->CallCopyOutputRegionToInputRegion(inputRegion, this->GetOutput()->GetRequestedRegion());
+ input->SetRequestedRegion(inputRegion);
+ }
+}
+/**
+ * Process to execute before entering the multithreaded section.
+ */
+template <class TInputImage, class TOutputImage>
+void
+ShiftScaleVectorImageFilter<TInputImage, TOutputImage>
+::BeforeThreadedGenerateData()
+{
+ // set up the functor values
+ this->GetFunctor().SetScaleValues(m_Scale);
+ this->GetFunctor().SetShiftValues(m_Shift);
+}
+
+} // end namespace otb
+#endif
diff --git a/Code/BasicFilters/otbVectorRescaleIntensityImageFilter.h b/Code/BasicFilters/otbVectorRescaleIntensityImageFilter.h
index 49f9dadf9728639e4b711b417360ec582dcda0fa..c513765e9afa305784188dda38c2ce754b4804e1 100644
--- a/Code/BasicFilters/otbVectorRescaleIntensityImageFilter.h
+++ b/Code/BasicFilters/otbVectorRescaleIntensityImageFilter.h
@@ -85,7 +85,7 @@ public:
bool operator !=(const VectorAffineTransform& other) const
{
- if (m_OutputMaximum.Size() == other.GetOutputMinimum().Size())
+ if (m_OutputMinimum.Size() == other.GetOutputMinimum().Size())
{
for (unsigned int i = 0; i < m_OutputMinimum.Size(); ++i)
{
diff --git a/Code/Common/otbRemoteSensingRegion.h b/Code/Common/otbRemoteSensingRegion.h
index befd72d3d98a103d183e7ed997a467a175763a42..c6612fdca4f0b852e2ccfd9eb0623c1bf60cd159 100644
--- a/Code/Common/otbRemoteSensingRegion.h
+++ b/Code/Common/otbRemoteSensingRegion.h
@@ -372,6 +372,7 @@ template<class ImageType, class RemoteSensingRegionType>
typename ImageType::RegionType
TransformPhysicalRegionToIndexRegion(const RemoteSensingRegionType& region, const ImageType* image)
{
+ std::cout << "TransformPhysicalRegionToIndexRegion" <<std::endl;
typename ImageType::RegionType outputRegion;
typename ImageType::RegionType::IndexType index;
typename ImageType::RegionType::IndexType index2;
@@ -397,6 +398,43 @@ TransformPhysicalRegionToIndexRegion(const RemoteSensingRegionType& region, cons
return outputRegion;
}
+template<class ImageType, class RemoteSensingRegionType>
+typename ImageType::RegionType
+TransformContinousRegionToIndexRegion(const RemoteSensingRegionType& region, const ImageType* image)
+{
+ std::cout << "TransformContinousRegionToIndexRegion" <<std::endl;
+ typename ImageType::RegionType outputRegion;
+ typename ImageType::RegionType::IndexType index;
+ typename ImageType::RegionType::IndexType index2;
+
+ typedef typename ImageType::RegionType::IndexType ImageIndexType;
+ typedef typename ImageIndexType::IndexValueType ImageIndexValueType;
+
+ typename ImageType::PointType point;
+ point[0] = region.GetIndex()[0];
+ point[1] = region.GetIndex()[1];
+
+ index[0] = static_cast<ImageIndexValueType>(point[0]);
+ index[1] = static_cast<ImageIndexValueType>(point[1]);
+
+ point[0] = region.GetIndex()[0] + region.GetSize()[0];
+ point[1] = region.GetIndex()[1] + region.GetSize()[1];
+
+ index2[0] = static_cast<ImageIndexValueType>(point[0]);
+ index2[1] = static_cast<ImageIndexValueType>(point[1]);
+
+ typename ImageType::RegionType::SizeType size;
+ size[0] = std::abs(index2[0] - index[0]);
+ size[1] = std::abs(index2[1] - index[1]);
+
+ index[0] = std::min(index2[0], index[0]);
+ index[1] = std::min(index2[1], index[1]);
+
+ outputRegion.SetIndex(index);
+ outputRegion.SetSize(size);
+ return outputRegion;
+}
+
} // end namespace otb
#endif
diff --git a/Code/Learning/otbListSampleGenerator.h b/Code/Learning/otbListSampleGenerator.h
index cbb5190a8aaa372e9646ee19279a73515dcd2810..444ccae5227ad4139b96531e3d39aa77b7276cda 100644
--- a/Code/Learning/otbListSampleGenerator.h
+++ b/Code/Learning/otbListSampleGenerator.h
@@ -24,6 +24,10 @@
#include "itkPreOrderTreeIterator.h"
#include "itkMersenneTwisterRandomVariateGenerator.h"
+#include "otbVectorDataProjectionFilter.h"
+#include "otbVectorDataExtractROI.h"
+
+
namespace otb
{
/** \class ListSampleGenerator
@@ -61,6 +65,9 @@ public:
itkNewMacro(Self);
typedef TImage ImageType;
+ typedef typename ImageType::Pointer ImagePointerType;
+ typedef typename ImageType::IndexType ImageIndexType;
+ typedef typename ImageType::RegionType ImageRegionType;
typedef TVectorData VectorDataType;
typedef typename VectorDataType::Pointer VectorDataPointerType;
@@ -77,6 +84,12 @@ public:
typedef itk::Statistics::ListSample<LabelType> ListLabelType;
typedef typename ListLabelType::Pointer ListLabelPointerType;
+ // Reprojection filter
+ typedef VectorDataProjectionFilter<VectorDataType,VectorDataType>
+ VectorDataProjectionFilterType;
+ typedef VectorDataExtractROI<VectorDataType> VectorDataExtractROIType;
+ typedef typename VectorDataExtractROIType::RegionType RemoteSensingRegionType;
+
/** Connects the input image for which the sample list is going to be extracted */
void SetInput(const ImageType *);
const ImageType * GetInput() const;
@@ -131,6 +144,8 @@ public:
void GenerateClassStatistics();
+ void ReprojectVectorData(const ImagePointerType image, VectorDataPointerType vectorDataInput);
+
protected:
ListSampleGenerator();
virtual ~ListSampleGenerator() {}
diff --git a/Code/Learning/otbListSampleGenerator.txx b/Code/Learning/otbListSampleGenerator.txx
index 74a62fdcf4b1c74523de911e85989f6260eb8eef..e3f665490a7cec165768f74607b05e19befeac99 100644
--- a/Code/Learning/otbListSampleGenerator.txx
+++ b/Code/Learning/otbListSampleGenerator.txx
@@ -73,7 +73,30 @@ void
ListSampleGenerator<TImage, TVectorData>
::SetInputVectorData(const VectorDataType * vectorData)
{
+ std::cout << "ListSampleGenerator::SetInputVectorData BEGIN ..." << std::endl;
+
this->ProcessObject::SetNthInput(1, const_cast<VectorDataType *>(vectorData));
+
+ TreeIteratorType itVector(vectorData->GetDataTree());
+ itVector.GoToBegin();
+
+ int idPolygon=1;
+ while (!itVector.IsAtEnd())
+ {
+ if (itVector.Get()->IsPolygonFeature())
+ {
+ std::cout << "POLYGON " << idPolygon << ": " <<std::endl;
+ for (unsigned int itPoints = 0; itPoints < itVector.Get()->GetPolygonExteriorRing()->GetVertexList()->Size(); itPoints++)
+ {
+ std::cout << "vertex[" << itPoints << "]: " << itVector.Get()->GetPolygonExteriorRing()->GetVertexList()->GetElement(itPoints) <<std::endl;
+ }
+ std::cout << "Polygon region: " << itVector.Get()->GetPolygonExteriorRing()->GetBoundingRegion() << std::endl;
+ ++idPolygon;
+ }
+ ++itVector;
+
+ }
+ std::cout << "ListSampleGenerator::SetInputVectorData ... END" << std::endl;
}
template <class TImage, class TVectorData>
@@ -89,6 +112,7 @@ ListSampleGenerator<TImage, TVectorData>
return static_cast<const VectorDataType *>(this->ProcessObject::GetInput(1));
}
+
/**
*
*/
@@ -117,9 +141,14 @@ void
ListSampleGenerator<TImage, TVectorData>
::GenerateData()
{
- typename VectorDataType::ConstPointer vectorData = this->GetInputVectorData();
+ std::cout << "ListSampleGenerator::GenerateData() : BEGIN ..." <<std::endl;
- typename ImageType::Pointer image = const_cast<ImageType*>(this->GetInput());
+ ImagePointerType image = const_cast<ImageType*>(this->GetInput());
+
+ // Reproject VectorData
+ this->ReprojectVectorData(image, const_cast<VectorDataType*>(this->GetInputVectorData()));
+
+ VectorDataPointerType vectorData = const_cast<VectorDataType*>(this->GetInputVectorData());
//Gather some information about the relative size of the classes
//we would like to have the same number of samples per class
@@ -144,14 +173,21 @@ ListSampleGenerator<TImage, TVectorData>
{
if (itVector.Get()->IsPolygonFeature())
{
+ /*typename ImageType::RegionType polygonRegion =
+ otb::TransformPhysicalRegionToIndexRegion(itVector.Get()->GetPolygonExteriorRing()->GetBoundingRegion(),
+ image.GetPointer());*/
typename ImageType::RegionType polygonRegion =
- otb::TransformPhysicalRegionToIndexRegion(itVector.Get()->GetPolygonExteriorRing()->GetBoundingRegion(),
- image.GetPointer());
+ otb::TransformContinousRegionToIndexRegion(itVector.Get()->GetPolygonExteriorRing()->GetBoundingRegion(),
+ image.GetPointer());
+
+ std::cout << "Image region from polygon: " << polygonRegion << std::endl;
+ std::cout << "Image region : " << image->GetLargestPossibleRegion() << std::endl;
image->SetRequestedRegion(polygonRegion);
image->PropagateRequestedRegion();
image->UpdateOutputData();
+ std::cout << "Image region requested: " << image->GetRequestedRegion() << std::endl;
typedef itk::ImageRegionConstIteratorWithIndex<ImageType> IteratorType;
IteratorType it(image, polygonRegion);
@@ -160,7 +196,9 @@ ListSampleGenerator<TImage, TVectorData>
{
itk::ContinuousIndex<double, 2> point;
image->TransformIndexToPhysicalPoint(it.GetIndex(), point);
- if (itVector.Get()->GetPolygonExteriorRing()->IsInside(point))
+ //std::cout << it.GetIndex() << " -> " << point << std::endl;
+ if (itVector.Get()->GetPolygonExteriorRing()->IsInside(it.GetIndex()))
+ //if (itVector.Get()->GetPolygonExteriorRing()->IsInside(point))
{
double randomValue = m_RandomGenerator->GetUniformVariate(0.0, 1.0);
if (randomValue < m_ClassesProbTraining[itVector.Get()->GetFieldAsInt(m_ClassKey)])
@@ -188,6 +226,83 @@ ListSampleGenerator<TImage, TVectorData>
assert(m_TrainingListSample->Size() == m_TrainingListLabel->Size());
assert(m_ValidationListSample->Size() == m_ValidationListLabel->Size());
+
+ std::cout << "ListSampleGenerator::GenerateData() : ... END" <<std::endl;
+}
+
+template <class TImage, class TVectorData>
+void
+ListSampleGenerator<TImage, TVectorData>
+::ReprojectVectorData(const ImagePointerType image, VectorDataPointerType vectorROIs)
+{
+ typedef typename ImageType::IndexType IndexType;
+ typedef typename ImageType::PointType PointType;
+
+ if(image.IsNull())
+ {
+ itkExceptionMacro("Invalid input image.");
+ }
+
+ // Vector data reprojection
+ typename VectorDataProjectionFilterType::Pointer vproj;
+ typename VectorDataExtractROIType::Pointer vdextract;
+
+ // Extract The part of the VectorData that actually overlaps with
+ // the image extent
+ vdextract = VectorDataExtractROIType::New();
+ vdextract->SetInput(vectorROIs);
+
+ // Find the geographic region of interest
+
+ // Ge the index of the corner of the image
+ IndexType ul, ur, ll, lr;
+ PointType pul, pur, pll, plr;
+ ul = image->GetLargestPossibleRegion().GetIndex();
+ ur = ul;
+ ll = ul;
+ lr = ul;
+ ur[0] += image->GetLargestPossibleRegion().GetSize()[0];
+ lr[0] += image->GetLargestPossibleRegion().GetSize()[0];
+ lr[1] += image->GetLargestPossibleRegion().GetSize()[1];
+ ll[1] += image->GetLargestPossibleRegion().GetSize()[1];
+
+ // Transform to physical point
+ image->TransformIndexToPhysicalPoint(ul, pul);
+ image->TransformIndexToPhysicalPoint(ur, pur);
+ image->TransformIndexToPhysicalPoint(ll, pll);
+ image->TransformIndexToPhysicalPoint(lr, plr);
+
+ // Build the cartographic region
+ RemoteSensingRegionType rsRegion;
+ typename RemoteSensingRegionType::IndexType rsOrigin;
+ typename RemoteSensingRegionType::SizeType rsSize;
+ rsOrigin[0] = min(pul[0], plr[0]);
+ rsOrigin[1] = min(pul[1], plr[1]);
+ rsSize[0] = vcl_abs(pul[0] - plr[0]);
+ rsSize[1] = vcl_abs(pul[1] - plr[1]);
+
+ rsRegion.SetOrigin(rsOrigin);
+ rsRegion.SetSize(rsSize);
+ rsRegion.SetRegionProjection(image->GetProjectionRef());
+ rsRegion.SetKeywordList(image->GetImageKeywordlist());
+
+ // Set the cartographic region to the extract roi filter
+ vdextract->SetRegion(rsRegion);
+
+ // Reproject VectorData in image projection
+ vproj = VectorDataProjectionFilterType::New();
+ vproj->SetInput(vdextract->GetOutput());
+ vproj->SetInputProjectionRef(vectorROIs->GetProjectionRef());
+ vproj->SetOutputKeywordList(image->GetImageKeywordlist());
+ vproj->SetOutputProjectionRef(image->GetProjectionRef());
+ vproj->SetOutputOrigin(image->GetOrigin());
+ vproj->SetOutputSpacing(image->GetSpacing());
+
+ vproj->Update();
+
+ // Update InputData
+ std::cout<< "-----REPROJECTED VECTOR DATA-----" << std::endl;
+ this->SetInputVectorData(vproj->GetOutput());
}
template <class TImage, class TVectorData>
@@ -195,11 +310,13 @@ void
ListSampleGenerator<TImage, TVectorData>
::GenerateClassStatistics()
{
+ std::cout << "ListSampleGenerator::GenerateClassStatistics() : BEGIN ..." <<std::endl;
m_ClassesSize.clear();
//Compute pixel area:
typename ImageType::Pointer image = const_cast<ImageType*>(this->GetInput());
double pixelArea = vcl_abs(image->GetSpacing()[0] * image->GetSpacing()[1]);
+ std::cout<< "Pixel area: " << pixelArea << std::endl;
typename VectorDataType::ConstPointer vectorData = this->GetInputVectorData();
TreeIteratorType itVector(vectorData->GetDataTree());
@@ -208,8 +325,10 @@ ListSampleGenerator<TImage, TVectorData>
{
if (itVector.Get()->IsPolygonFeature())
{
+ std::cout << itVector.Get()->GetNodeTypeAsString() << std::endl;
m_ClassesSize[itVector.Get()->GetFieldAsInt(m_ClassKey)] +=
itVector.Get()->GetPolygonExteriorRing()->GetArea() / pixelArea; // in pixel
+ std::cout << "Area = "<<itVector.Get()->GetPolygonExteriorRing()->GetArea() << std::endl;
}
++itVector;
}
@@ -228,6 +347,8 @@ ListSampleGenerator<TImage, TVectorData>
m_ClassMinSize = minSize;
m_NumberOfClasses = m_ClassesSize.size();
+ std::cout << "m_ClassMinSize: " << m_ClassMinSize << ", m_NumberOfClasses: " << m_NumberOfClasses <<std::endl;
+ std::cout << "ListSampleGenerator::GenerateClassStatistics() : ... END" <<std::endl;
}
template <class TImage, class TVectorData>
diff --git a/Code/Learning/otbSVMSampleListModelEstimator.h b/Code/Learning/otbSVMSampleListModelEstimator.h
index f74ad67b90803617f189200431d60ffe3f207e58..3f996d9dfd7a244eed2a55d0c8d4f34a7794df3b 100644
--- a/Code/Learning/otbSVMSampleListModelEstimator.h
+++ b/Code/Learning/otbSVMSampleListModelEstimator.h
@@ -106,13 +106,13 @@ class ITK_EXPORT SVMSampleListModelEstimator :
{
public:
/** Standard class typedefs. */
- typedef SVMSampleListModelEstimator Self;
+ typedef SVMSampleListModelEstimator Self;
typedef SVMModelEstimator<typename TInputSampleList::MeasurementType,
- typename TTrainingSampleList::MeasurementType>
- Superclass;
+ typename TTrainingSampleList::MeasurementType>
+ Superclass;
- typedef itk::SmartPointer<Self> Pointer;
- typedef itk::SmartPointer<const Self> ConstPointer;
+ typedef itk::SmartPointer<Self> Pointer;
+ typedef itk::SmartPointer<const Self> ConstPointer;
/** Method for creation through the object factory. */
itkNewMacro(Self);
diff --git a/Code/Learning/otbSVMSampleListModelEstimator.txx b/Code/Learning/otbSVMSampleListModelEstimator.txx
index cac9fb7ec8aed087c1c7dc122e58235544fc42f4..f31104bdb505bf49093f0667f2143ea6eb72a3bd 100644
--- a/Code/Learning/otbSVMSampleListModelEstimator.txx
+++ b/Code/Learning/otbSVMSampleListModelEstimator.txx
@@ -69,11 +69,15 @@ SVMSampleListModelEstimator<TInputSampleList, TTrainingSampleList, TMeasurementF
// Check if size of the two inputs are same
if (inputSampleListSize != trainingSampleListSize)
- throw itk::ExceptionObject(
+ {
+ /*throw itk::ExceptionObject(
__FILE__,
__LINE__,
"Input pointset size is not the same as the training pointset size.",
- ITK_LOCATION);
+ ITK_LOCATION);*/
+ itkExceptionMacro(<< "Input pointset size is not the same as the training pointset size ("
+ << inputSampleListSize << " vs "<< trainingSampleListSize << ").");
+ }
// Declaration of the iterators on the input and training images
InputSampleListIteratorType inIt = inputSampleList->Begin();
diff --git a/Testing/Code/BasicFilters/CMakeLists.txt b/Testing/Code/BasicFilters/CMakeLists.txt
index 8ee553134ec91f613205f6214e4137abb96cdcc3..a731d4b1ea90a018676a32489212988fddf3a09a 100644
--- a/Testing/Code/BasicFilters/CMakeLists.txt
+++ b/Testing/Code/BasicFilters/CMakeLists.txt
@@ -304,6 +304,22 @@ ADD_TEST(bfTVectorRescaleIntensityImageFilter ${BASICFILTERS_TESTS3}
0 255
)
+# ------- otb::ShiftScaleVectorImageFilter ----------------------------
+
+ADD_TEST(bfTuShiftScaleVectorImageFilterNew ${BASICFILTERS_TESTS3}
+ otbShiftScaleVectorImageFilterNew)
+
+
+ADD_TEST(bfTvShiftScaleVectorImageFilter ${BASICFILTERS_TESTS3}
+ --compare-image ${EPSILON_7}
+ ${BASELINE}/bfTvShiftScaleVImageOutput.tif
+ ${TEMP}/bfTvShiftScaleVImageOutput.tif
+ otbShiftScaleVectorImageFilterTest
+ ${INPUTDATA}/qb_RoadExtract.img.hdr
+ ${TEMP}/bfTvShiftScaleVImageOutput.tif
+)
+
+
# ------- otb::VectorImageToImageListFilter ----------------------------
ADD_TEST(bfTuVectorImageToImageListFilterNew ${BASICFILTERS_TESTS3}
@@ -1883,6 +1899,8 @@ otbVectorImageToImageListFilter.cxx
otbImageListToVectorImageFilterNew.cxx
otbImageListToVectorImageFilter.cxx
otbImageListToVectorImageFilter2.cxx
+otbShiftScaleVectorImageFilterNew.cxx
+otbShiftScaleVectorImageFilterTest.cxx
)
# A enrichir
diff --git a/Testing/Code/BasicFilters/otbBasicFiltersTests3.cxx b/Testing/Code/BasicFilters/otbBasicFiltersTests3.cxx
index f89241bc82e8e5c14c482794196155c4ea89e103..6499ed9549698792351be6b2c770b2a16ad2dfd7 100644
--- a/Testing/Code/BasicFilters/otbBasicFiltersTests3.cxx
+++ b/Testing/Code/BasicFilters/otbBasicFiltersTests3.cxx
@@ -38,4 +38,6 @@ void RegisterTests()
REGISTER_TEST(otbImageListToVectorImageFilterNew);
REGISTER_TEST(otbImageListToVectorImageFilter);
REGISTER_TEST(otbImageListToVectorImageFilter2);
+ REGISTER_TEST(otbShiftScaleVectorImageFilterNew);
+ REGISTER_TEST(otbShiftScaleVectorImageFilterTest);
}
diff --git a/Testing/Code/BasicFilters/otbShiftScaleVectorImageFilterNew.cxx b/Testing/Code/BasicFilters/otbShiftScaleVectorImageFilterNew.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..c49d63e2897107efec28034805e4eeb0bd8e0d17
--- /dev/null
+++ b/Testing/Code/BasicFilters/otbShiftScaleVectorImageFilterNew.cxx
@@ -0,0 +1,38 @@
+/*=========================================================================
+
+ 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.
+
+=========================================================================*/
+#include "itkExceptionObject.h"
+
+#include "otbShiftScaleVectorImageFilter.h"
+#include "otbVectorImage.h"
+
+int otbShiftScaleVectorImageFilterNew(int argc, char * argv[])
+{
+ const unsigned int Dimension = 2;
+ typedef double InputPixelType;
+ typedef int OutputPixelType;
+ typedef otb::VectorImage<InputPixelType, Dimension> InputImageType;
+ typedef otb::VectorImage<OutputPixelType, Dimension> OutputImageType;
+ typedef otb::ShiftScaleVectorImageFilter<InputImageType, OutputImageType> ShiftScaleVImageFilterType;
+
+ // Instantiating object
+ ShiftScaleVImageFilterType::Pointer filter = ShiftScaleVImageFilterType::New();
+
+ std::cout << filter << std::endl;
+
+ return EXIT_SUCCESS;
+}
diff --git a/Testing/Code/BasicFilters/otbShiftScaleVectorImageFilterTest.cxx b/Testing/Code/BasicFilters/otbShiftScaleVectorImageFilterTest.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..447fda6a06c5fea7775ee3aa73d87ee0f193bf16
--- /dev/null
+++ b/Testing/Code/BasicFilters/otbShiftScaleVectorImageFilterTest.cxx
@@ -0,0 +1,112 @@
+/*=========================================================================
+
+ 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.
+
+=========================================================================*/
+#include "itkExceptionObject.h"
+
+#include "otbShiftScaleVectorImageFilter.h"
+#include "otbImage.h"
+#include "otbVectorImage.h"
+#include "otbImageFileReader.h"
+#include "otbImageFileWriter.h"
+#include "otbImageList.h"
+#include "otbVectorImageToImageListFilter.h"
+#include "otbStreamingStatisticsImageFilter.h"
+
+int otbShiftScaleVectorImageFilterTest(int argc, char * argv[])
+{
+ const char * infname = argv[1];
+ const char * outfname = argv[2];
+
+ const unsigned int Dimension = 2;
+ typedef double InputPixelType;
+ typedef float OutputPixelType;
+ typedef otb::VectorImage<InputPixelType, Dimension> InputImageType;
+ typedef otb::VectorImage<OutputPixelType, Dimension> OutputImageType;
+ typedef otb::Image<InputPixelType,2> ImageType;
+ typedef otb::ImageList<ImageType> ImageListType;
+ typedef otb::VectorImageToImageListFilter<InputImageType, ImageListType> VI2ILFilterType;
+ //Statistics estimator
+ typedef otb::StreamingStatisticsImageFilter<ImageType> StreamingStatisticsImageFilterType;
+
+ typedef otb::ShiftScaleVectorImageFilter<InputImageType, OutputImageType> ShiftScaleVImageFilterType;
+
+ typedef otb::ImageFileReader<InputImageType> ReaderType;
+ typedef otb::ImageFileWriter<OutputImageType> WriterType;
+
+ typedef itk::VariableLengthVector<InputPixelType> MeasurementType;
+
+ ReaderType::Pointer reader = ReaderType::New();
+ reader->SetFileName(infname);
+ reader->GenerateOutputInformation();
+
+ // Instantiating object
+ ShiftScaleVImageFilterType::Pointer filter = ShiftScaleVImageFilterType::New();
+ filter->SetInput(reader->GetOutput());
+
+ // Build a Measurement Vector of mean
+ MeasurementType mean;
+
+ // Build a MeasurementVector of variance
+ MeasurementType variance;
+
+ int nbBands = reader->GetOutput()->GetNumberOfComponentsPerPixel();
+
+ ImageType::SizeType size;
+ size = reader->GetOutput()->GetLargestPossibleRegion().GetSize();
+
+ //set the measurement vectors size
+ mean.SetSize(nbBands);
+ mean.Fill(0.);
+ variance.SetSize(nbBands);
+ variance.Fill(0.);
+
+ //Splitting image into channels
+ VI2ILFilterType::Pointer vi2ilFilter = VI2ILFilterType::New();
+ vi2ilFilter->SetInput(reader->GetOutput());
+ vi2ilFilter->GenerateOutputInformation();
+
+ ImageListType::Iterator ilIt = vi2ilFilter->GetOutput()->Begin();
+
+ unsigned int i = 0;
+ //Iterate over each bands on the input vector image
+ while (ilIt != vi2ilFilter->GetOutput()->End())
+ {
+ StreamingStatisticsImageFilterType::Pointer statsEstimator = StreamingStatisticsImageFilterType::New();
+ statsEstimator->SetInput(ilIt.Get());
+ statsEstimator->Update();
+
+ //Compute mean over band number i
+ mean[i] = statsEstimator->GetMean();
+ //Compute variance over band i
+ variance[i] = statsEstimator->GetVariance();
+ ++ilIt;
+ ++i;
+ }
+
+ std::cout<< "mean: " << mean << std::endl;
+ std::cout<< "variance: " << variance << std::endl;
+
+ filter->SetScale(variance);
+ filter->SetShift(mean);
+
+ WriterType::Pointer writer = WriterType::New();
+ writer->SetInput(filter->GetOutput());
+ writer->SetFileName(outfname);
+ writer->Update();
+
+ return EXIT_SUCCESS;
+}