diff --git a/Code/FeatureExtraction/otbRadiometricMomentsImageFunction.txx b/Code/FeatureExtraction/otbRadiometricMomentsImageFunction.txx
index 993898604607db33e59755fcf6635e5385dcd496..06d89f38c1fb147cf10ca619cfc4bbb3907824bf 100644
--- a/Code/FeatureExtraction/otbRadiometricMomentsImageFunction.txx
+++ b/Code/FeatureExtraction/otbRadiometricMomentsImageFunction.txx
@@ -64,6 +64,8 @@ RadiometricMomentsImageFunction<TInputImage,TCoordRep>
}
// Check for out of buffer
+ Self* _this = const_cast<Self*>(this);
+ _this->SetInputImage( this->GetInputImage() );
if ( !this->IsInsideBuffer( index ) )
{
return moments;
diff --git a/Code/ObjectDetection/otbDescriptorsListSampleGenerator.h b/Code/ObjectDetection/otbDescriptorsListSampleGenerator.h
new file mode 100644
index 0000000000000000000000000000000000000000..b625719f336943bea20a065812f8adae0f84b36b
--- /dev/null
+++ b/Code/ObjectDetection/otbDescriptorsListSampleGenerator.h
@@ -0,0 +1,332 @@
+/*=========================================================================
+
+ 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 __otbDescriptorsListSampleGenerator_h
+#define __otbDescriptorsListSampleGenerator_h
+
+#include <vector>
+
+#include "itkFixedArray.h"
+
+#include "otbListSampleSource.h"
+#include "otbVectorData.h"
+
+#include "itkDataObject.h"
+#include "itkDataObjectDecorator.h"
+#include "itkSimpleDataObjectDecorator.h"
+
+#include "otbPersistentImageFilter.h"
+#include "otbPersistentFilterStreamingDecorator.h"
+
+namespace otb
+{
+
+template <class TOutputPrecision>
+class DefaultDescriptorsType
+{
+public:
+ typedef itk::FixedArray<TOutputPrecision, 4> Type;
+};
+
+/** \class PersistentDescriptorsListSampleGenerator
+ * \brief
+ *
+ *
+ */
+template <class TInputImage, class TVectorData, class TFunctionType, class TListSample, class TLabelListSample>
+class ITK_EXPORT PersistentDescriptorsListSampleGenerator :
+ public PersistentImageFilter<TInputImage, TInputImage>
+{
+public:
+ /** Standard Self typedef */
+ typedef PersistentDescriptorsListSampleGenerator Self;
+ typedef PersistentImageFilter<TInputImage, TInputImage> Superclass;
+ typedef itk::SmartPointer<Self> Pointer;
+ typedef itk::SmartPointer<const Self> ConstPointer;
+
+ /** Method for creation through the object factory. */
+ itkNewMacro(Self);
+
+ /** Runtime information support. */
+ itkTypeMacro(PersistentDescriptorsListSampleGenerator, PersistentImageFilter);
+
+ /** Image related typedefs. */
+ typedef TInputImage InputImageType;
+ typedef typename TInputImage::Pointer InputImagePointer;
+ typedef typename TInputImage::RegionType RegionType;
+ typedef typename TInputImage::SizeType SizeType;
+ typedef typename TInputImage::IndexType IndexType;
+ typedef typename TInputImage::PixelType PixelType;
+
+ itkStaticConstMacro(InputImageDimension, unsigned int,
+ TInputImage::ImageDimension);
+
+ /** Image related typedefs. */
+ itkStaticConstMacro(ImageDimension, unsigned int,
+ TInputImage::ImageDimension);
+
+ /** Smart Pointer type to a DataObject. */
+ typedef typename itk::DataObject::Pointer DataObjectPointer;
+
+ /** Input VectorData */
+ typedef TVectorData VectorDataType;
+ typedef itk::DataObjectDecorator<VectorDataType> VectorDataObjectType;
+ typedef typename VectorDataObjectType::Pointer VectorDataObjectPointerType;
+ typedef typename VectorDataType::DataNodeType VectorDataNodeType;
+ typedef typename VectorDataType::DataNodePointerType VectorDataNodePointerType;
+ typedef typename VectorDataType::DataTreeType VectorDataTreeType;
+ typedef typename VectorDataType::DataTreePointerType VectorDataTreePointerType;
+ typedef typename VectorDataNodeType::PointType VectorDataPointType;
+ typedef typename VectorDataNodeType::LineType VectorDataLineType;
+ typedef typename VectorDataNodeType::PolygonType VectorDataPolygonType;
+ typedef itk::PreOrderTreeIterator<VectorDataTreeType> VectorDataTreeIteratorType;
+
+ /** Function type for descriptors extraction */
+ typedef TFunctionType DescriptorsFunctionType;
+ typedef typename DescriptorsFunctionType::Pointer DescriptorsFunctionPointerType;
+ typedef typename DescriptorsFunctionType::InputType DescriptorsFunctionPointType;
+
+ typedef itk::ContinuousIndex
+ <typename DescriptorsFunctionPointType::ValueType,
+ itkGetStaticConstMacro(InputImageDimension)> ContinuousIndexType;
+
+ /** ListSample output */
+ typedef TListSample ListSampleType;
+ typedef typename ListSampleType::Pointer ListSamplePointerType;
+ typedef itk::DataObjectDecorator<ListSampleType> ListSampleObjectType;
+ typedef typename ListSampleObjectType::Pointer ListSampleObjectPointerType;
+ typedef typename ListSampleType::MeasurementVectorType SampleMeasurementVectorType;
+ typedef typename ListSampleType::MeasurementType SampleMeasurementType;
+
+ /** LabelListSample output */
+ typedef TLabelListSample LabelListSampleType;
+ typedef typename LabelListSampleType::Pointer LabelListSamplePointerType;
+ typedef itk::DataObjectDecorator<LabelListSampleType> LabelListSampleObjectType;
+ typedef typename LabelListSampleObjectType::Pointer LabelListSampleObjectPointerType;
+ typedef typename LabelListSampleType::MeasurementVectorType LabelMeasurementVectorType;
+ typedef typename LabelListSampleType::MeasurementType LabelMeasurementType;
+
+ /** ListSamplePositions output */
+ typedef std::vector<DescriptorsFunctionPointType> SamplesPositionType;
+ typedef itk::SimpleDataObjectDecorator<SamplesPositionType> SamplesPositionObjectType;
+ typedef typename SamplesPositionObjectType::Pointer SamplesPositionObjectPointerType;
+
+ void SetSamplesLocations(VectorDataType * input);
+ VectorDataType * GetSamplesLocations(void);
+
+ /** The function to evaluate */
+ itkSetObjectMacro(DescriptorsFunction, DescriptorsFunctionType);
+ itkGetObjectMacro(DescriptorsFunction, DescriptorsFunctionType);
+ itkGetConstObjectMacro(DescriptorsFunction, DescriptorsFunctionType);
+
+ /** Output sample list */
+ ListSampleType* GetListSample();
+ ListSampleObjectType* GetListSampleObject();
+
+ /** Output label list */
+ LabelListSampleType* GetLabelListSample();
+ LabelListSampleObjectType* GetLabelListSampleObject();
+
+ /** Output sample position list */
+ SamplesPositionType& GetSamplesPositions();
+ SamplesPositionObjectType* GetSamplesPositionsObject();
+
+
+ /** Make a DataObject of the correct type to be used as the specified
+ * output. */
+ itk::DataObject::Pointer MakeOutput(unsigned int idx);
+
+ void AllocateOutputs();
+ void GenerateOutputInformation();
+ void Reset(void);
+ void Synthetize(void);
+
+protected:
+ PersistentDescriptorsListSampleGenerator();
+ virtual ~PersistentDescriptorsListSampleGenerator();
+ void PrintSelf(std::ostream& os, itk::Indent indent) const;
+
+ void BeforeThreadedGenerateData();
+
+ /** Multi-thread version GenerateData. */
+ void ThreadedGenerateData(const RegionType&
+ outputRegionForThread,
+ int threadId);
+
+private:
+ PersistentDescriptorsListSampleGenerator(const Self &); //purposely not implemented
+ void operator =(const Self&); //purposely not implemented
+
+ typedef std::vector<ListSamplePointerType> ListSampleArray;
+ typedef std::vector<LabelListSamplePointerType> LabelListSampleArray;
+ typedef std::vector<SamplesPositionType> SamplesPositionArray;
+
+ ListSampleArray m_ThreadListSample;
+ LabelListSampleArray m_ThreadLabelListSample;
+ SamplesPositionArray m_ThreadSamplesPosition;
+
+ DescriptorsFunctionPointerType m_DescriptorsFunction;
+};
+
+
+/** \class DescriptorsListSampleGenerator
+ * \brief
+ *
+ *
+ *
+ */
+template <class TInputImage, class TVectorData, class TListSample, class TLabelListSample, class TOutputPrecision = double, class TCoordRep = double>
+class ITK_EXPORT DescriptorsListSampleGenerator :
+ public PersistentFilterStreamingDecorator<
+ PersistentDescriptorsListSampleGenerator< TInputImage,
+ TVectorData,
+ itk::FunctionBase< itk::Point<TCoordRep, 2>,
+ typename DefaultDescriptorsType<TOutputPrecision>::Type >,
+ TListSample,
+ TLabelListSample > >
+{
+public:
+ /** Standard Self typedef */
+ typedef DescriptorsListSampleGenerator Self;
+ typedef PersistentFilterStreamingDecorator
+ < PersistentDescriptorsListSampleGenerator
+ <TInputImage,
+ TVectorData,
+ itk::FunctionBase< itk::Point<TCoordRep, 2>, typename DefaultDescriptorsType<TOutputPrecision>::Type >,
+ TListSample,
+ TLabelListSample> > Superclass;
+ typedef itk::SmartPointer<Self> Pointer;
+ typedef itk::SmartPointer<const Self> ConstPointer;
+
+ /** Type macro */
+ itkNewMacro(Self);
+
+ /** Creation through object factory macro */
+ itkTypeMacro(DescriptorsListSampleGenerator, PersistentFilterStreamingDecorator);
+
+ typedef TInputImage InputImageType;
+ typedef TVectorData InputVectorDataType;
+ typedef TListSample ListSampleType;
+ typedef TLabelListSample LabelListSampleType;
+ typedef TCoordRep CoordRepType;
+ typedef TOutputPrecision OutputPrecision;
+
+ /** The coordinates used when evaluating function */
+ typedef itk::Point<TCoordRep, 2> PointType;
+
+ /** The return value of the function */
+ typedef typename DefaultDescriptorsType<TOutputPrecision>::Type DescriptorType;
+
+ /** The function evaluated on the input image at locations specified by the vector data */
+ typedef itk::FunctionBase<PointType, DescriptorType> DescriptorsFunctionType;
+ typedef typename DescriptorsFunctionType::Pointer DescriptorsFunctionPointerType;
+
+ typedef typename Superclass::FilterType PersistentFilterType;
+ typedef typename PersistentFilterType::ListSampleObjectType ListSampleObjectType;
+ typedef typename PersistentFilterType::LabelListSampleObjectType LabelListSampleObjectType;
+ typedef typename PersistentFilterType::SamplesPositionObjectType SamplesPositionObjectType;
+ typedef typename PersistentFilterType::SamplesPositionType SamplesPositionType;
+
+
+ /** Input image to extract feature */
+ void SetInputImage(InputImageType * input)
+ {
+ this->GetFilter()->SetInput(input);
+ }
+
+ /** Input image to extract feature */
+ InputImageType * GetInputImage()
+ {
+ return this->GetFilter()->GetInput();
+ }
+
+ /** Sample locations as a VectorData of points. The label is in the ClassKey feature */
+ void SetSamplesLocations(InputVectorDataType * input)
+ {
+ this->GetFilter()->SetSamplesLocations(input);
+ }
+
+ /** Sample locations as a VectorData of points. The label is in the ClassKey feature */
+ InputImageType * GetSamplesLocations()
+ {
+ return this->GetFilter()->GetSamplesLocations();
+ }
+
+ /** The function to evaluate */
+ void SetDescriptorsFunction(DescriptorsFunctionType * input)
+ {
+ this->GetFilter()->SetDescriptorsFunction(input);
+ }
+
+ /** The function to evaluate */
+ DescriptorsFunctionType * GetDescriptorsFunction()
+ {
+ return this->GetFilter()->GetDescriptorsFunction();
+ }
+
+ /** Final sample list */
+ ListSampleType* GetListSample()
+ {
+ return this->GetFilter()->GetListSample();
+ }
+
+ ListSampleObjectType* GetListSampleObject()
+ {
+ return this->GetFilter()->GetListSampleObject();
+ }
+
+ /** Final label list */
+ LabelListSampleType* GetLabelListSample()
+ {
+ return this->GetFilter()->GetLabelListSample();
+ }
+
+ LabelListSampleObjectType* GetLabelListSampleObject()
+ {
+ return this->GetFilter()->GetLabelListSampleObject();
+ }
+
+ /** Final label list */
+ SamplesPositionType& GetSamplesPositions()
+ {
+ return this->GetFilter()->GetSamplesPositions();
+ }
+
+ SamplesPositionObjectType* GetSamplesPositionsObject()
+ {
+ return this->GetFilter()->GetSamplesPositionsObject();
+ }
+
+ protected:
+ /** Constructor */
+ DescriptorsListSampleGenerator();
+
+ /** Destructor */
+ virtual ~DescriptorsListSampleGenerator();
+
+ private:
+ DescriptorsListSampleGenerator(const Self &); //purposely not implemented
+ void operator =(const Self&); //purposely not implemented
+};
+
+} // end namespace otb
+
+#ifndef OTB_MANUAL_INSTANTIATION
+#include "otbDescriptorsListSampleGenerator.txx"
+#endif
+
+#endif
diff --git a/Code/ObjectDetection/otbDescriptorsListSampleGenerator.txx b/Code/ObjectDetection/otbDescriptorsListSampleGenerator.txx
new file mode 100644
index 0000000000000000000000000000000000000000..a311a99ebf62d64cbc56f3d2fa6fee0629fba66b
--- /dev/null
+++ b/Code/ObjectDetection/otbDescriptorsListSampleGenerator.txx
@@ -0,0 +1,309 @@
+/*=========================================================================
+
+ 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 __otbDescriptorsListSampleGenerator_txx
+#define __otbDescriptorsListSampleGenerator_txx
+
+#include "otbDescriptorsListSampleGenerator.h"
+
+#include "itkContinuousIndex.h"
+
+namespace otb
+{
+
+template <class TInputImage, class TVectorData, class TFunctionType, class TListSample, class TLabelListSample>
+PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>
+::PersistentDescriptorsListSampleGenerator()
+{
+ // Need 2 inputs : a vector image and a vectordata
+ this->SetNumberOfRequiredInputs(2);
+
+ // Have 4 outputs : the image created by Superclass,
+ // the sample list, the label sample list, the positions of the samples
+ this->SetNumberOfRequiredOutputs(3);
+ this->itk::ProcessObject::SetNthOutput(1, this->MakeOutput(1).GetPointer());
+ this->itk::ProcessObject::SetNthOutput(2, this->MakeOutput(2).GetPointer());
+ this->itk::ProcessObject::SetNthOutput(3, this->MakeOutput(3).GetPointer());
+}
+
+template <class TInputImage, class TVectorData, class TFunctionType, class TListSample, class TLabelListSample>
+PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>
+::~PersistentDescriptorsListSampleGenerator()
+{
+}
+
+template <class TInputImage, class TVectorData, class TFunctionType, class TListSample, class TLabelListSample>
+void
+PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>
+::AllocateOutputs()
+{
+ // This is commented to prevent the streaming of the whole image for the first stream strip
+ // It shall not cause any problem because the output image of this filter is not intended to be used.
+ //InputImagePointer image = const_cast< TInputImage * >( this->GetInput() );
+ //this->GraftOutput( image );
+ // Nothing that needs to be allocated for the remaining outputs
+}
+
+template <class TInputImage, class TVectorData, class TFunctionType, class TListSample, class TLabelListSample>
+void
+PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>
+::GenerateOutputInformation()
+{
+ Superclass::GenerateOutputInformation();
+ if (this->GetInput())
+ {
+ this->GetOutput()->CopyInformation(this->GetInput());
+ this->GetOutput()->SetLargestPossibleRegion(this->GetInput()->GetLargestPossibleRegion());
+
+ if (this->GetOutput()->GetRequestedRegion().GetNumberOfPixels() == 0)
+ {
+ this->GetOutput()->SetRequestedRegion(this->GetOutput()->GetLargestPossibleRegion());
+ }
+ }
+}
+
+template <class TInputImage, class TVectorData, class TFunctionType, class TListSample, class TLabelListSample>
+void
+PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>
+::SetSamplesLocations(VectorDataType* location)
+{
+ this->SetNthInput(1, location);
+}
+
+template <class TInputImage, class TVectorData, class TFunctionType, class TListSample, class TLabelListSample>
+typename PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>::VectorDataType*
+PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>
+::GetSamplesLocations()
+{
+
+ return static_cast<VectorDataType*>(this->itk::ProcessObject::GetInput(1));
+}
+
+template <class TInputImage, class TVectorData, class TFunctionType, class TListSample, class TLabelListSample>
+typename PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>::ListSampleType*
+PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>
+::GetListSample()
+{
+ return const_cast<ListSampleType*>(this->GetListSampleObject()->Get());
+}
+
+template <class TInputImage, class TVectorData, class TFunctionType, class TListSample, class TLabelListSample>
+typename PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>::ListSampleObjectType*
+PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>
+::GetListSampleObject()
+{
+ return dynamic_cast<ListSampleObjectType*>( this->itk::ProcessObject::GetOutput(1) );
+}
+
+template <class TInputImage, class TVectorData, class TFunctionType, class TListSample, class TLabelListSample>
+typename PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>::LabelListSampleType*
+PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>
+::GetLabelListSample()
+{
+ return const_cast<LabelListSampleType*>(this->GetLabelListSampleObject()->Get());
+}
+
+template <class TInputImage, class TVectorData, class TFunctionType, class TListSample, class TLabelListSample>
+typename PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>::LabelListSampleObjectType*
+PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>
+::GetLabelListSampleObject()
+{
+ return dynamic_cast<LabelListSampleObjectType*>(this->itk::ProcessObject::GetOutput(2));
+}
+
+template <class TInputImage, class TVectorData, class TFunctionType, class TListSample, class TLabelListSample>
+typename PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>::SamplesPositionType&
+PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>
+::GetSamplesPositions()
+{
+ return this->GetSamplesPositionsObject()->Get();
+}
+
+template <class TInputImage, class TVectorData, class TFunctionType, class TListSample, class TLabelListSample>
+typename PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>::SamplesPositionObjectType*
+PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>
+::GetSamplesPositionsObject()
+{
+ return dynamic_cast<SamplesPositionObjectType*>(this->itk::ProcessObject::GetOutput(3));
+}
+
+template <class TInputImage, class TVectorData, class TFunctionType, class TListSample, class TLabelListSample>
+itk::DataObject::Pointer
+PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>
+::MakeOutput(unsigned int idx)
+{
+ itk::DataObject::Pointer output;
+ switch (idx)
+ {
+ case 0:
+ output = static_cast<itk::DataObject*>(InputImageType::New().GetPointer());
+ break;
+ case 1:
+ {
+ ListSampleObjectPointerType listSample = ListSampleObjectType::New();
+ listSample->Set(ListSampleType::New());
+ output = static_cast<itk::DataObject*>(listSample.GetPointer());
+ break;
+ }
+ case 2:
+ {
+ LabelListSampleObjectPointerType labelListSample = LabelListSampleObjectType::New();
+ labelListSample->Set(LabelListSampleType::New());
+ output = static_cast<itk::DataObject*>(labelListSample.GetPointer());
+ break;
+ }
+ case 3:
+ {
+ SamplesPositionObjectPointerType samplesPositions = SamplesPositionObjectType::New();
+ output = static_cast<itk::DataObject*>(samplesPositions.GetPointer());
+ break;
+ }
+ default:
+ output = static_cast<itk::DataObject*>(InputImageType::New().GetPointer());
+ break;
+ }
+ return output;
+}
+
+template <class TInputImage, class TVectorData, class TFunctionType, class TListSample, class TLabelListSample>
+void
+PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>
+::Reset()
+{
+ m_ThreadListSample = ListSampleArray(this->GetNumberOfThreads());
+ for (int i = 0; i < this->GetNumberOfThreads(); ++i)
+ {
+ m_ThreadListSample[i] = ListSampleType::New();
+ }
+
+ m_ThreadLabelListSample = LabelListSampleArray(this->GetNumberOfThreads());
+ for (int i = 0; i < this->GetNumberOfThreads(); ++i)
+ {
+ m_ThreadLabelListSample[i] = LabelListSampleType::New();
+ }
+
+ m_ThreadSamplesPosition = SamplesPositionArray(this->GetNumberOfThreads());
+
+ this->GetListSample()->Clear();
+ this->GetLabelListSample()->Clear();
+ this->GetSamplesPositions().clear();
+}
+
+template <class TInputImage, class TVectorData, class TFunctionType, class TListSample, class TLabelListSample>
+void
+PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>
+::Synthetize()
+{
+ // Merge the ListSample from all the threads
+
+ ListSampleType* listSample = this->GetListSample();
+ LabelListSampleType* labelListSample = this->GetLabelListSample();
+ SamplesPositionType& samplesPosition = this->GetSamplesPositions();
+
+ for (int threadId = 0; threadId < this->GetNumberOfThreads(); ++threadId )
+ {
+ ListSampleType* threadListSample = m_ThreadListSample[threadId];
+ LabelListSampleType* threadLabelListSample = m_ThreadLabelListSample[threadId];
+ SamplesPositionType& threadSamplesPosition = m_ThreadSamplesPosition[threadId];
+
+ for (unsigned int i = 0; i < threadListSample->Size(); ++i)
+ {
+ listSample->PushBack( threadListSample->GetMeasurementVector(i) );
+ labelListSample->PushBack( threadLabelListSample->GetMeasurementVector(i) );
+ samplesPosition.push_back( threadSamplesPosition[i] );
+ }
+ }
+}
+
+template <class TInputImage, class TVectorData, class TFunctionType, class TListSample, class TLabelListSample>
+void
+PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>
+::PrintSelf(std::ostream& os, itk::Indent indent) const
+{
+ Superclass::PrintSelf(os, indent);
+}
+
+template <class TInputImage, class TVectorData, class TFunctionType, class TListSample, class TLabelListSample>
+void
+PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>
+::BeforeThreadedGenerateData()
+{
+}
+
+
+template <class TInputImage, class TVectorData, class TFunctionType, class TListSample, class TLabelListSample>
+void
+PersistentDescriptorsListSampleGenerator<TInputImage,TVectorData,TFunctionType,TListSample,TLabelListSample>
+::ThreadedGenerateData(const RegionType& outputRegionForThread,
+ int threadId)
+{
+ ListSampleType* listSample = m_ThreadListSample[threadId];
+ LabelListSampleType* labelListSample = m_ThreadLabelListSample[threadId];
+ SamplesPositionType& samplesPosition = m_ThreadSamplesPosition[threadId];
+
+ VectorDataTreeIteratorType vectorDataIt(this->GetSamplesLocations()->GetDataTree());
+
+ for (vectorDataIt.GoToBegin(); !vectorDataIt.IsAtEnd(); ++vectorDataIt)
+ {
+ if (vectorDataIt.Get()->IsPointFeature())
+ {
+ VectorDataPointType point = vectorDataIt.Get()->GetPoint();
+ ContinuousIndexType cidx;
+
+ // Without removing 0.5, some samples are processed two times
+ // TODO : check ImageRegion::InInside( ContinuousIndex )
+ cidx[0] = point[0] - 0.5;
+ cidx[1] = point[1] - 0.5;
+
+ if (outputRegionForThread.IsInside(cidx))
+ {
+ SampleMeasurementVectorType sample(m_DescriptorsFunction->Evaluate(point));
+ listSample->PushBack( sample );
+
+ LabelMeasurementVectorType label;
+ label[0] = static_cast<LabelMeasurementType>(vectorDataIt.Get()->GetFieldAsString("Class")[0]);
+ labelListSample->PushBack( label );
+
+ samplesPosition.push_back(point);
+ }
+ }
+ }
+}
+
+
+
+
+
+template <class TInputImage, class TVectorData, class TListSample, class TLabelListSample, class TOutputPrecision, class TCoordRep>
+DescriptorsListSampleGenerator<TInputImage,TVectorData,TListSample,TLabelListSample,TOutputPrecision,TCoordRep>
+::DescriptorsListSampleGenerator()
+{
+
+}
+
+template <class TInputImage, class TVectorData, class TListSample, class TLabelListSample, class TOutputPrecision, class TCoordRep>
+DescriptorsListSampleGenerator<TInputImage,TVectorData,TListSample,TLabelListSample,TOutputPrecision,TCoordRep>
+::~DescriptorsListSampleGenerator()
+{
+
+}
+
+
+
+} // end namespace otb
+
+#endif
diff --git a/Testing/Code/ObjectDetection/CMakeLists.txt b/Testing/Code/ObjectDetection/CMakeLists.txt
index 7c52af3a14cf84a7e15347038794a907fef790b0..d426771db5eb519c78a76496d1d28076b6890219 100644
--- a/Testing/Code/ObjectDetection/CMakeLists.txt
+++ b/Testing/Code/ObjectDetection/CMakeLists.txt
@@ -36,11 +36,37 @@ ADD_TEST(odTvLabeledSampleLocalizationGenerator ${OBJECTDETECTION_TESTS1}
${TEMP}/TvLabeledSampleLocalizationGeneratorOutput.shp
)
+ADD_TEST(odTuDescriptorsListSampleGeneratorNew ${OBJECTDETECTION_TESTS1}
+ otbDescriptorsListSampleGeneratorNew
+ )
+
+ADD_TEST(odTvDescriptorsListSampleGeneratorNoStreaming ${OBJECTDETECTION_TESTS1}
+ --compare-ascii ${NOTOL}
+ ${BASELINE_FILES}/TvDescriptorsListSampleGeneratorNoStreamingOutput.txt
+ ${TEMP}/TvDescriptorsListSampleGeneratorNoStreamingOutput.txt
+ otbDescriptorsListSampleGenerator
+ ${INPUTDATA}/ObjectReco/Boats/maur_B010202_01_amplitude.tif
+ ${INPUTDATA}/ObjectReco/Boats/maur_B010202_01LabeledPoints.shp
+ ${TEMP}/TvDescriptorsListSampleGeneratorNoStreamingOutput.txt
+ 0
+ )
+
+ADD_TEST(odTvDescriptorsListSampleGeneratorStreaming ${OBJECTDETECTION_TESTS1}
+ --compare-ascii ${NOTOL}
+ ${BASELINE_FILES}/TvDescriptorsListSampleGeneratorNoStreamingOutput.txt
+ ${TEMP}/TvDescriptorsListSampleGeneratorStreamingOutput.txt
+ otbDescriptorsListSampleGenerator
+ ${INPUTDATA}/ObjectReco/Boats/maur_B010202_01_amplitude.tif
+ ${INPUTDATA}/ObjectReco/Boats/maur_B010202_01LabeledPoints.shp
+ ${TEMP}/TvDescriptorsListSampleGeneratorStreamingOutput.txt
+ 50
+ )
# A enrichir
SET(ObjectDetection_SRCS1
otbObjectDetectionTests1.cxx
otbLabeledSampleLocalizationGenerator.cxx
+otbDescriptorsListSampleGenerator.cxx
)
diff --git a/Testing/Code/ObjectDetection/otbDescriptorsListSampleGenerator.cxx b/Testing/Code/ObjectDetection/otbDescriptorsListSampleGenerator.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..55b56a1f8a852abda3132ced87c25b231c09e4e4
--- /dev/null
+++ b/Testing/Code/ObjectDetection/otbDescriptorsListSampleGenerator.cxx
@@ -0,0 +1,185 @@
+/*=========================================================================
+
+ 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.
+
+=========================================================================*/
+#if defined(_MSC_VER)
+#pragma warning ( disable : 4786 )
+#endif
+
+#include <iterator>
+
+#include "otbImage.h"
+#include "otbVectorData.h"
+#include "otbRadiometricMomentsImageFunction.h"
+#include "itkListSample.h"
+#include "itkFixedArray.h"
+#include "otbDescriptorsListSampleGenerator.h"
+#include "otbImageFileReader.h"
+#include "otbVectorDataFileReader.h"
+
+const unsigned int Dimension = 2;
+typedef int LabelType;
+typedef double PixelType;
+typedef double FunctionPrecisionType;
+typedef double CoordRepType;
+
+typedef otb::Image<PixelType, Dimension> ImageType;
+typedef otb::VectorData<> VectorDataType;
+typedef otb::RadiometricMomentsImageFunction<ImageType, CoordRepType> FunctionType;
+
+typedef FunctionType::OutputType SampleType;
+typedef itk::Statistics::ListSample<SampleType> ListSampleType;
+typedef itk::FixedArray<LabelType, 1> LabelSampleType;
+typedef itk::Statistics::ListSample<LabelSampleType> LabelListSampleType;
+
+typedef otb::DescriptorsListSampleGenerator
+ < ImageType,
+ VectorDataType,
+ ListSampleType,
+ LabelListSampleType,
+ FunctionPrecisionType,
+ CoordRepType > DescriptorsListSampleGeneratorType;
+
+typedef otb::ImageFileReader<ImageType> ImageReaderType;
+typedef otb::VectorDataFileReader<VectorDataType> VectorDataReaderType;
+
+typedef FunctionType::PointType PointType;
+typedef DescriptorsListSampleGeneratorType::SamplesPositionType SamplesPositionType;
+
+
+struct SampleEntry
+{
+ PointType position;
+ LabelType label;
+ SampleType measurement;
+};
+
+struct CompareSampleEntry
+{
+ bool operator () (SampleEntry p, SampleEntry q)
+ {
+ // order with the y axis position
+ if (p.position[1] < q.position[1])
+ return true;
+ if (p.position[1] > q.position[1])
+ return false;
+
+ // If one the same line,
+ // order with the x axis position
+ if (p.position[0] < q.position[0])
+ return true;
+
+ return false;
+ }
+};
+
+ostream &operator<<(ostream &stream, SampleEntry entry)
+{
+ stream << "---" << std::endl
+ << "Label : " << entry.label << std::endl
+ << "Position : " << entry.position << std::endl
+ << "Measurements : " << entry.measurement;
+ return stream;
+}
+
+int otbDescriptorsListSampleGeneratorNew(int itkNotUsed(argc), char* itkNotUsed(argv)[])
+{
+ // instantiation
+ DescriptorsListSampleGeneratorType::Pointer generator = DescriptorsListSampleGeneratorType::New();
+
+ std::cout << generator << std::endl;
+
+ return EXIT_SUCCESS;
+}
+
+int otbDescriptorsListSampleGenerator(int argc, char* argv[])
+{
+ if (argc != 5)
+ {
+ std::cerr << "Wrong number of arguments" << std::endl;
+ return EXIT_FAILURE;
+ }
+
+ const char* inputImageFileName = argv[1];
+ const char* inputSamplesLocation = argv[2];
+ const char* outputFileName = argv[3];
+ int streaming = atoi(argv[4]);
+
+ ImageReaderType::Pointer imageReader = ImageReaderType::New();
+ imageReader->SetFileName(inputImageFileName);
+
+ VectorDataReaderType::Pointer vectorDataReader = VectorDataReaderType::New();
+ vectorDataReader->SetFileName(inputSamplesLocation);
+
+ //imageReader->Update();
+ //vectorDataReader->Update();
+
+ FunctionType::Pointer descriptorsFunction = FunctionType::New();
+ descriptorsFunction->SetInputImage(imageReader->GetOutput());
+ descriptorsFunction->SetNeighborhoodRadius(5);
+
+ DescriptorsListSampleGeneratorType::Pointer descriptorsGenerator = DescriptorsListSampleGeneratorType::New();
+ descriptorsGenerator->SetInputImage(imageReader->GetOutput());
+ descriptorsGenerator->SetSamplesLocations(vectorDataReader->GetOutput());
+ descriptorsGenerator->SetDescriptorsFunction(descriptorsFunction.GetPointer());
+
+ if (streaming == 0)
+ {
+ descriptorsGenerator->GetStreamer()->SetNumberOfStreamDivisions(1);
+ }
+ else
+ {
+ descriptorsGenerator->GetStreamer()->SetNumberOfStreamDivisions(streaming);
+ }
+
+ descriptorsGenerator->Update();
+
+
+ ListSampleType::Pointer samples = descriptorsGenerator->GetListSample();
+ LabelListSampleType::Pointer labels = descriptorsGenerator->GetLabelListSample();
+ SamplesPositionType& positions = descriptorsGenerator->GetSamplesPositions();
+
+ ListSampleType::Iterator sampleIt = samples->Begin();
+ LabelListSampleType::Iterator labelIt = labels->Begin();
+ SamplesPositionType::const_iterator posIt = positions.begin();
+
+ ListSampleType::Iterator sampleEnd = samples->End();
+ LabelListSampleType::Iterator labelEnd = labels->End();
+ SamplesPositionType::const_iterator posEnd = positions.end();
+
+ std::vector<SampleEntry> entries;
+
+ while (sampleIt != sampleEnd && labelIt != labelEnd && posIt != posEnd)
+ {
+ SampleEntry entry;
+ entry.position = *posIt;
+ entry.label = labelIt.GetMeasurementVector()[0];
+ entry.measurement = sampleIt.GetMeasurementVector();
+
+ entries.push_back(entry);
+
+ ++sampleIt;
+ ++labelIt;
+ ++posIt;
+ }
+
+ std::sort(entries.begin(), entries.end(), CompareSampleEntry());
+ std::ofstream file(outputFileName);
+ std::copy(entries.begin(), entries.end(), std::ostream_iterator<SampleEntry>(file, "\n"));
+ file.close();
+
+ return EXIT_SUCCESS;
+}
diff --git a/Testing/Code/ObjectDetection/otbObjectDetectionTests1.cxx b/Testing/Code/ObjectDetection/otbObjectDetectionTests1.cxx
index 057426962e844b851e257e97886786e570314e8e..9af78963820f77b89a91f2bf7a05e440a7f713a8 100644
--- a/Testing/Code/ObjectDetection/otbObjectDetectionTests1.cxx
+++ b/Testing/Code/ObjectDetection/otbObjectDetectionTests1.cxx
@@ -29,4 +29,6 @@ void RegisterTests()
{
REGISTER_TEST(otbLabeledSampleLocalizationGeneratorNew);
REGISTER_TEST(otbLabeledSampleLocalizationGenerator);
+ REGISTER_TEST(otbDescriptorsListSampleGeneratorNew);
+ REGISTER_TEST(otbDescriptorsListSampleGenerator);
}