diff --git a/Modules/Applications/AppClassification/app/otbPolygonClassStatistics.cxx b/Modules/Applications/AppClassification/app/otbPolygonClassStatistics.cxx
index ff4f4b01e4be8c30476b4aef78dadaf9819e606f..4a35145462f48ac18220bafc08c5ab2998426f35 100644
--- a/Modules/Applications/AppClassification/app/otbPolygonClassStatistics.cxx
+++ b/Modules/Applications/AppClassification/app/otbPolygonClassStatistics.cxx
@@ -76,7 +76,7 @@ private:
SetDocName("Polygon Class Statistics");
SetDocLongDescription("The application processes a set of geometries "
"intended for training (they should have a field giving the associated "
- "class). The geometries are analysed against a support image to compute "
+ "class). The geometries are analyzed against a support image to compute "
"statistics : \n"
" - number of samples per class\n"
" - number of samples per geometry\n"
@@ -92,17 +92,17 @@ private:
AddDocTag(Tags::Learning);
- AddParameter(ParameterType_InputImage, "in", "InputImage");
+ AddParameter(ParameterType_InputImage, "in", "Input image");
SetParameterDescription("in", "Support image that will be classified");
- AddParameter(ParameterType_InputImage, "mask", "InputMask");
+ AddParameter(ParameterType_InputImage, "mask", "Input validity mask");
SetParameterDescription("mask", "Validity mask (only pixels corresponding to a mask value greater than 0 will be used for statistics)");
MandatoryOff("mask");
AddParameter(ParameterType_InputFilename, "vec", "Input vectors");
- SetParameterDescription("vec","Input geometries to analyse");
+ SetParameterDescription("vec","Input geometries to analyze");
- AddParameter(ParameterType_OutputFilename, "out", "Output Statistics");
+ AddParameter(ParameterType_OutputFilename, "out", "Output XML statistics file");
SetParameterDescription("out","Output file to store statistics (XML format)");
AddParameter(ParameterType_ListView, "field", "Field Name");
@@ -155,6 +155,22 @@ private:
}
}
}
+
+ // Check that the extension of the output parameter is XML (mandatory for
+ // StatisticsXMLFileWriter)
+ // Check it here to trigger the error before polygons analysis
+
+ if ( HasValue("out") )
+ {
+ // Store filename extension
+ // Check that the right extension is given : expected .xml
+ const std::string extension = itksys::SystemTools::GetFilenameLastExtension(this->GetParameterString("out"));
+
+ if (itksys::SystemTools::LowerCase(extension) != ".xml")
+ {
+ otbAppLogFATAL( << extension << " is a wrong extension for parameter \"out\": Expected .xml" );
+ }
+ }
}
void DoExecute() ITK_OVERRIDE
@@ -223,7 +239,7 @@ private:
filter->SetLayerIndex(this->GetParameterInt("layer"));
filter->GetStreamer()->SetAutomaticAdaptativeStreaming(GetParameterInt("ram"));
- AddProcess(filter->GetStreamer(),"Analyse polygons...");
+ AddProcess(filter->GetStreamer(),"Analyze polygons...");
filter->Update();
FilterType::ClassCountMapType &classCount = filter->GetClassCountOutput()->Get();
diff --git a/Modules/Applications/AppDomainTransform/app/otbDomainTransform.cxx b/Modules/Applications/AppDomainTransform/app/otbDomainTransform.cxx
index dbe4c4bce0bfea5e15ed9636d0c65dc8606f1540..76c111e85879eb6064d7e7a7d09977c3baa848a8 100644
--- a/Modules/Applications/AppDomainTransform/app/otbDomainTransform.cxx
+++ b/Modules/Applications/AppDomainTransform/app/otbDomainTransform.cxx
@@ -264,7 +264,7 @@ private:
{
// fft ttransform
bool shift = GetParameterInt( "mode.fft.shift");
- typedef otb::Image< std::complex<OutputPixelType> > ComplexOutputImageType;
+ typedef otb::Image< std::complex<OutputPixelType> > ComplexOutputImageType;
if (dir == 0 )
{
diff --git a/Modules/Applications/AppImageUtils/test/CMakeLists.txt b/Modules/Applications/AppImageUtils/test/CMakeLists.txt
index d2852f4d46be0c1a130e293c101fdd1934e60aae..d428cc87bbeae493384dbbc4be46fb87b0807cc7 100644
--- a/Modules/Applications/AppImageUtils/test/CMakeLists.txt
+++ b/Modules/Applications/AppImageUtils/test/CMakeLists.txt
@@ -173,6 +173,14 @@ otb_test_application(NAME apTvUtExtractROIRightInputFile
${INPUTDATA}/couleurs_extrait.png
${TEMP}/apTvUtExtractROIRightInputFile.tif)
+otb_test_application(NAME apTvUtExtractROIComplexInputFile
+ APP ExtractROI
+ OPTIONS -in ${INPUTDATA}/complexInputCfloat.tif
+ -out ${TEMP}/apTvUtExtractROIComplexInputFile.tif cfloat
+ VALID --compare-image ${NOTOL}
+ ${INPUTDATA}/complexInputCfloat.tif
+ ${TEMP}/apTvUtExtractROIComplexInputFile.tif)
+
#----------- Rescale TESTS ----------------
otb_test_application(NAME apTvUtRescaleTest
@@ -207,6 +215,11 @@ otb_test_application(NAME apTuUtReadImageInfoExtendedFilename_reader
OPTIONS -in ${INPUTDATA}/ToulouseExtract_WithGeom.tif?&skipgeom=true&skipcarto=true
)
+otb_test_application(NAME apTuUtReadComplexImageInfoFilename_reader
+ APP ReadImageInfo
+ OPTIONS -in ${INPUTDATA}/complexInputCfloat.tif
+ )
+
set(TESTNAME
"gd-pleiades-1" #LARGEINPUT{PLEIADES/TLSE_JP2_DIMAPv2_PRIMARY_PMS_lossless_12bits/IMGPHR_201222215194743808/IMG_PHR1A_PMS_201201151100183_SEN_IPU_20120222_0901-001_R1C1.JP2}
diff --git a/Modules/Applications/AppOpticalCalibration/app/otbOpticalCalibration.cxx b/Modules/Applications/AppOpticalCalibration/app/otbOpticalCalibration.cxx
index 7b7e5ef1e232e9b9e041689abf81b961f80dae51..2f279a3565e5e5d9e551017de4dcaebbfe17326c 100644
--- a/Modules/Applications/AppOpticalCalibration/app/otbOpticalCalibration.cxx
+++ b/Modules/Applications/AppOpticalCalibration/app/otbOpticalCalibration.cxx
@@ -29,7 +29,7 @@
#include "otbReflectanceToRadianceImageFilter.h"
#include "otbReflectanceToSurfaceReflectanceImageFilter.h"
#include "itkMultiplyImageFilter.h"
-#include "otbClampVectorImageFilter.h"
+#include "otbClampImageFilter.h"
#include "otbSurfaceAdjacencyEffectCorrectionSchemeFilter.h"
#include "otbGroundSpacingImageFunction.h"
#include "vnl/vnl_random.h"
@@ -92,7 +92,7 @@ public:
typedef itk::MultiplyImageFilter<DoubleVectorImageType,DoubleImageType,DoubleVectorImageType> ScaleFilterOutDoubleType;
- typedef otb::ClampVectorImageFilter<DoubleVectorImageType,
+ typedef otb::ClampImageFilter<DoubleVectorImageType,
DoubleVectorImageType> ClampFilterType;
typedef ReflectanceToSurfaceReflectanceImageFilter<DoubleVectorImageType,
diff --git a/Modules/Applications/AppSARCalibration/app/otbSARCalibration.cxx b/Modules/Applications/AppSARCalibration/app/otbSARCalibration.cxx
index 07f4e0dadce61579cef63c40012c0190bdf1a6cf..0709ad8007ff37fd6dafd0d3fa6b9a00d59ce738 100644
--- a/Modules/Applications/AppSARCalibration/app/otbSARCalibration.cxx
+++ b/Modules/Applications/AppSARCalibration/app/otbSARCalibration.cxx
@@ -60,7 +60,7 @@ private:
AddDocTag(Tags::Calibration);
AddDocTag(Tags::SAR);
- AddParameter(ParameterType_ComplexInputImage, "in", "Input Image");
+ AddParameter(ParameterType_InputImage, "in", "Input Image");
SetParameterDescription("in", "Input complex image");
AddParameter(ParameterType_OutputImage, "out", "Output Image");
diff --git a/Modules/Applications/AppSARDecompositions/app/otbSARDecompositions.cxx b/Modules/Applications/AppSARDecompositions/app/otbSARDecompositions.cxx
index 155795417f8c78b96317cd7676e4ed1294be90b4..796d3f4e26a9fd34b7e7891f81846dab6fa95c2a 100644
--- a/Modules/Applications/AppSARDecompositions/app/otbSARDecompositions.cxx
+++ b/Modules/Applications/AppSARDecompositions/app/otbSARDecompositions.cxx
@@ -31,7 +31,7 @@
#include "otbSinclairToReciprocalCoherencyMatrixFunctor.h"
#include "otbPerBandVectorImageFilter.h"
#include "itkMeanImageFilter.h"
-#include "otbNRIBandImagesToOneNComplexBandsImage.h"
+// #include "otbNRIBandImagesToOneNComplexBandsImage.h"
#include "otbImageListToVectorImageFilter.h"
#include "otbImageList.h"
@@ -109,21 +109,21 @@ private:
AddDocTag(Tags::SAR);
- AddParameter(ParameterType_ComplexInputImage, "inhh", "Input Image");
+ AddParameter(ParameterType_InputImage, "inhh", "Input Image");
SetParameterDescription("inhh", "Input image (HH)");
- AddParameter(ParameterType_ComplexInputImage, "inhv", "Input Image");
+ AddParameter(ParameterType_InputImage, "inhv", "Input Image");
SetParameterDescription("inhv", "Input image (HV)");
MandatoryOff("inhv");
- AddParameter(ParameterType_ComplexInputImage, "invh", "Input Image");
+ AddParameter(ParameterType_InputImage, "invh", "Input Image");
SetParameterDescription("invh", "Input image (VH)");
MandatoryOff("invh");
- AddParameter(ParameterType_ComplexInputImage, "invv", "Input Image");
+ AddParameter(ParameterType_InputImage, "invv", "Input Image");
SetParameterDescription("invv", "Input image (VV)");
- AddParameter(ParameterType_ComplexOutputImage, "out", "Output Image");
+ AddParameter(ParameterType_OutputImage, "out", "Output Image");
SetParameterDescription("out", "Output image");
AddParameter(ParameterType_Choice, "decomp", "Decompositions");
@@ -201,7 +201,7 @@ private:
m_MeanFilter->SetInput(m_SRFilter->GetOutput());
m_HAFilter->SetInput(m_MeanFilter->GetOutput());
- SetParameterComplexOutputImage("out", m_HAFilter->GetOutput() );
+ SetParameterOutputImage("out", m_HAFilter->GetOutput() );
break;
@@ -220,7 +220,7 @@ private:
m_MeanFilter->SetInput(m_SRFilter->GetOutput());
m_BarnesFilter->SetInput(m_MeanFilter->GetOutput());
- SetParameterComplexOutputImage("out", m_BarnesFilter->GetOutput() );
+ SetParameterOutputImage("out", m_BarnesFilter->GetOutput() );
break;
@@ -239,7 +239,7 @@ private:
m_MeanFilter->SetInput(m_SRFilter->GetOutput());
m_HuynenFilter->SetInput(m_MeanFilter->GetOutput());
- SetParameterComplexOutputImage("out", m_HuynenFilter->GetOutput() );
+ SetParameterOutputImage("out", m_HuynenFilter->GetOutput() );
break;
@@ -257,7 +257,7 @@ private:
m_Concatener->SetInput( m_ImageList );
m_PauliFilter->SetInput(m_Concatener->GetOutput());
- SetParameterComplexOutputImage("out", m_PauliFilter->GetOutput() );
+ SetParameterOutputImage("out", m_PauliFilter->GetOutput() );
break;
}
diff --git a/Modules/Applications/AppSARPolarMatrixConvert/app/otbSARPolarMatrixConvert.cxx b/Modules/Applications/AppSARPolarMatrixConvert/app/otbSARPolarMatrixConvert.cxx
index 9c8c06211234eef4f9f8207c1762e6f10fbe88fb..657643541d477617e13a196a4a2853f76920f569 100644
--- a/Modules/Applications/AppSARPolarMatrixConvert/app/otbSARPolarMatrixConvert.cxx
+++ b/Modules/Applications/AppSARPolarMatrixConvert/app/otbSARPolarMatrixConvert.cxx
@@ -232,7 +232,7 @@ private:
AddDocTag(Tags::SAR);
- AddParameter(ParameterType_ComplexInputImage, "inc", "Input : multi-band complex image");
+ AddParameter(ParameterType_InputImage, "inc", "Input : multi-band complex image");
SetParameterDescription("inc", "Input : multi-band complex image");
MandatoryOff("inc");
@@ -241,23 +241,23 @@ private:
MandatoryOff("inf");
- AddParameter(ParameterType_ComplexInputImage, "inhh", "Input : one-band complex image (HH)");
+ AddParameter(ParameterType_InputImage, "inhh", "Input : one-band complex image (HH)");
SetParameterDescription("inhh", "Input : one-band complex image (HH)");
MandatoryOff("inhh");
- AddParameter(ParameterType_ComplexInputImage, "inhv", "Input : one-band complex image (HV)");
+ AddParameter(ParameterType_InputImage, "inhv", "Input : one-band complex image (HV)");
SetParameterDescription("inhv", "Input : one-band complex image (HV)");
MandatoryOff("inhv");
- AddParameter(ParameterType_ComplexInputImage, "invh", "Input : one-band complex image (VH)");
+ AddParameter(ParameterType_InputImage, "invh", "Input : one-band complex image (VH)");
SetParameterDescription("invh", "Input : one-band complex image (VH)");
MandatoryOff("invh");
- AddParameter(ParameterType_ComplexInputImage, "invv", "Input : one-band complex image (VV)");
+ AddParameter(ParameterType_InputImage, "invv", "Input : one-band complex image (VV)");
SetParameterDescription("invv", "Input : one-band complex image (VV)");
MandatoryOff("invv");
- AddParameter(ParameterType_ComplexOutputImage, "outc", "Output Complex Image");
+ AddParameter(ParameterType_OutputImage, "outc", "Output Complex Image");
SetParameterDescription("outc", "Output Complex image.");
MandatoryOff("outc");
@@ -509,7 +509,7 @@ private:
m_RCohSRFilter->SetInputHH(GetParameterComplexDoubleImage("inhh"));
m_RCohSRFilter->SetInputVV(GetParameterComplexDoubleImage("invv"));
- SetParameterComplexOutputImage("outc", m_RCohSRFilter->GetOutput() ); // input : 3 x 1 complex channel | output : 6 complex channels
+ SetParameterOutputImage("outc", m_RCohSRFilter->GetOutput() ); // input : 3 x 1 complex channel | output : 6 complex channels
break;
@@ -526,7 +526,7 @@ private:
m_RCovSRFilter->SetInputHH(GetParameterComplexDoubleImage("inhh"));
m_RCovSRFilter->SetInputVV(GetParameterComplexDoubleImage("invv"));
- SetParameterComplexOutputImage("outc", m_RCovSRFilter->GetOutput() ); // input : 3 x 1 complex channel | output : 6 complex channels
+ SetParameterOutputImage("outc", m_RCovSRFilter->GetOutput() ); // input : 3 x 1 complex channel | output : 6 complex channels
break;
@@ -544,7 +544,7 @@ private:
m_RCCSRFilter->SetInputHH(GetParameterComplexDoubleImage("inhh"));
m_RCCSRFilter->SetInputVV(GetParameterComplexDoubleImage("invv"));
- SetParameterComplexOutputImage("outc", m_RCCSRFilter->GetOutput() ); // input : 3 x 1 complex channel | output : 6 complex channels
+ SetParameterOutputImage("outc", m_RCCSRFilter->GetOutput() ); // input : 3 x 1 complex channel | output : 6 complex channels
break;
@@ -565,7 +565,7 @@ private:
m_RCCDFilter = RCCDFilterType::New();
m_RCCDFilter->SetInput(GetParameterComplexDoubleVectorImage("inc"));
- SetParameterComplexOutputImage("outc", m_RCCDFilter->GetOutput() ); // input : 6 complex channels | 3 complex channels
+ SetParameterOutputImage("outc", m_RCCDFilter->GetOutput() ); // input : 6 complex channels | 3 complex channels
break;
@@ -575,7 +575,7 @@ private:
m_RCRCFilter = RCRCFilterType::New();
m_RCRCFilter->SetInput(GetParameterComplexDoubleVectorImage("inc"));
- SetParameterComplexOutputImage("outc", m_RCRCFilter->GetOutput() ); // input : 6 complex channels | 6 complex channels
+ SetParameterOutputImage("outc", m_RCRCFilter->GetOutput() ); // input : 6 complex channels | 6 complex channels
break;
@@ -586,7 +586,7 @@ private:
m_RLCRCCFilter = RLCRCCFilterType::New();
m_RLCRCCFilter->SetInput(GetParameterComplexDoubleVectorImage("inc"));
- SetParameterComplexOutputImage("outc", m_RLCRCCFilter->GetOutput() ); // input : 6 complex channels | output : 6 complex channels
+ SetParameterOutputImage("outc", m_RLCRCCFilter->GetOutput() ); // input : 6 complex channels | output : 6 complex channels
break;
@@ -597,7 +597,7 @@ private:
m_MRCFilter->SetInput(GetParameterDoubleVectorImage("inf"));
- SetParameterComplexOutputImage("outc", m_MRCFilter->GetOutput() ); // input : 16 real channels | output : 6 complex channels
+ SetParameterOutputImage("outc", m_MRCFilter->GetOutput() ); // input : 16 real channels | output : 6 complex channels
break;
@@ -615,7 +615,7 @@ private:
m_CohSRFilter->SetInputVH(GetParameterComplexDoubleImage("invh"));
m_CohSRFilter->SetInputVV(GetParameterComplexDoubleImage("invv"));
- SetParameterComplexOutputImage("outc", m_CohSRFilter->GetOutput() ); // input : 4 x 1 complex channel | 10 complex channels
+ SetParameterOutputImage("outc", m_CohSRFilter->GetOutput() ); // input : 4 x 1 complex channel | 10 complex channels
break;
@@ -630,7 +630,7 @@ private:
m_CovSRFilter->SetInputVH(GetParameterComplexDoubleImage("invh"));
m_CovSRFilter->SetInputVV(GetParameterComplexDoubleImage("invv"));
- SetParameterComplexOutputImage("outc", m_CovSRFilter->GetOutput() ); // input : 4 x 1 complex channel | output : 10 complex channels
+ SetParameterOutputImage("outc", m_CovSRFilter->GetOutput() ); // input : 4 x 1 complex channel | output : 10 complex channels
break;
@@ -644,7 +644,7 @@ private:
m_CCSRFilter->SetInputVH(GetParameterComplexDoubleImage("invh"));
m_CCSRFilter->SetInputVV(GetParameterComplexDoubleImage("invv"));
- SetParameterComplexOutputImage("outc", m_CCSRFilter->GetOutput() ); // input : 4 x 1 complex channel | output : 10 complex channels
+ SetParameterOutputImage("outc", m_CCSRFilter->GetOutput() ); // input : 4 x 1 complex channel | output : 10 complex channels
break;
diff --git a/Modules/Applications/AppSARPolarSynth/app/otbSARPolarSynth.cxx b/Modules/Applications/AppSARPolarSynth/app/otbSARPolarSynth.cxx
index 236ac0789fa1e8e2077e9903bcc5c4c0e8aa9733..3db956847e1dba701365e3c1823e8d5370525063 100644
--- a/Modules/Applications/AppSARPolarSynth/app/otbSARPolarSynth.cxx
+++ b/Modules/Applications/AppSARPolarSynth/app/otbSARPolarSynth.cxx
@@ -86,7 +86,7 @@ private:
AddDocTag(Tags::SAR);
- AddParameter(ParameterType_ComplexInputImage, "in", "Input Image");
+ AddParameter(ParameterType_InputImage, "in", "Input Image");
SetParameterDescription("in", "Input image.");
AddParameter(ParameterType_OutputImage, "out", "Output Image");
SetParameterDescription("out", "Output image.");
diff --git a/Modules/Applications/AppSARUtils/app/otbComputeModulusAndPhase.cxx b/Modules/Applications/AppSARUtils/app/otbComputeModulusAndPhase.cxx
index 39db311e799737b730973d68c5156d273366896b..ec91b7e53b6c04b398a1e3d854475758d1f9d21e 100644
--- a/Modules/Applications/AppSARUtils/app/otbComputeModulusAndPhase.cxx
+++ b/Modules/Applications/AppSARUtils/app/otbComputeModulusAndPhase.cxx
@@ -75,7 +75,7 @@ private:
AddDocTag(Tags::SAR);
AddDocTag(Tags::Manip);
// Input images
- AddParameter(ParameterType_ComplexInputImage, "in", "Input Image");
+ AddParameter(ParameterType_InputImage, "in", "Input Image");
SetParameterDescription("in", "Input image (complex single band)");
// Outputs
@@ -110,7 +110,7 @@ private:
m_Modulus = ModulusFilterType::New();
m_Phase = PhaseFilterType::New();
- ComplexFloatVectorImageType::Pointer inImage = GetParameterComplexImage("in");
+ ComplexFloatVectorImageType::Pointer inImage = GetParameterComplexFloatVectorImage("in");
if (inImage->GetNumberOfComponentsPerPixel() != 1)
{
diff --git a/Modules/Core/ImageBase/include/otbDefaultConvertPixelTraits.h b/Modules/Core/ImageBase/include/otbDefaultConvertPixelTraits.h
index 3339a54a1a39b6be9d8ddd5dc17a757289a87213..be11633e7b98a62cded643e040e26aa76abd5d4c 100644
--- a/Modules/Core/ImageBase/include/otbDefaultConvertPixelTraits.h
+++ b/Modules/Core/ImageBase/include/otbDefaultConvertPixelTraits.h
@@ -1,5 +1,4 @@
/*
- * Copyright (C) 1999-2011 Insight Software Consortium
* Copyright (C) 2005-2017 Centre National d'Etudes Spatiales (CNES)
*
* This file is part of Orfeo Toolbox
@@ -19,322 +18,67 @@
* limitations under the License.
*/
-
#ifndef otbDefaultConvertPixelTraits_h
#define otbDefaultConvertPixelTraits_h
-#include "itkOffset.h"
-#include "itkVector.h"
-#include "itkMatrix.h"
+#include "itkDefaultConvertPixelTraits.h"
-namespace otb
+namespace otb
{
-/** \class DefaultConvertPixelTraits
- * \brief Traits class used to by ConvertPixels to convert blocks of pixels.
- *
- * TOutputPixelType is the destination type. The input type is inferred
- * by the templated static function Convert.
- *
- * This implementation does a simple assignment operator, so if you are
- * going from a higher bit representation to a lower bit one (int to
- * char), you may want to specialize and add some sort of transfer function.
- *
- * \ingroup OTBImageBase
- */
-template<typename PixelType>
-class DefaultConvertPixelTraits
+
+template < typename PixelType>
+class DefaultConvertPixelTraits
+: public itk::DefaultConvertPixelTraits < PixelType >
{
public:
- /** Determine the pixel data type. */
- typedef typename PixelType::ComponentType ComponentType;
-
- /** Return the number of components per pixel. */
- static unsigned int GetNumberOfComponents()
- { return PixelType::GetNumberOfComponents(); }
-
- /** Return the nth component of the pixel. */
- static ComponentType GetNthComponent(int c, const PixelType& pixel)
- { return pixel.GetNthComponent(c); }
-
- /** Set the nth component of the pixel. */
- static void SetNthComponent(int c, PixelType& pixel, const ComponentType& v)
- { pixel.SetNthComponent(c, v); }
- static void SetNthComponent(int itkNotUsed(c), PixelType & pixel, const PixelType& v)
- { pixel = v; }
+ typedef itk::DefaultConvertPixelTraits < PixelType > SuperClass;
+ using typename SuperClass::ComponentType;
- /** Return a single scalar value from this pixel. */
- static ComponentType GetScalarValue(const PixelType& pixel)
- { return pixel.GetScalarValue(); }
+ using SuperClass::SetNthComponent;
+ static void SetNthComponent(int , PixelType & pixel, const PixelType & v)
+ {
+ pixel = v;
+ }
};
-#define OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(type) \
-template<> \
-class DefaultConvertPixelTraits<type> \
-{ \
-public: \
- typedef type ComponentType; \
- static unsigned int GetNumberOfComponents() \
- { \
- return 1; \
- } \
- static void SetNthComponent(int , type& pixel, const ComponentType& v) \
- { \
- pixel = v; \
- } \
- static type GetScalarValue(const type& pixel) \
- { \
- return pixel; \
- } \
-};
-
-OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(float)
-OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(double)
-OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(int)
-OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(char)
-OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(short)
-OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(unsigned int)
-OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(signed char)
-OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(unsigned char)
-OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(unsigned short)
-OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(long)
-OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(unsigned long)
-OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL(bool)
-
-#undef OTB_DEFAULTCONVERTTRAITS_NATIVE_SPECIAL
-
-//
-// Default traits for the Offset<> pixel type
-//
+template < typename T >
+class DefaultConvertPixelTraits < ::std::complex < T > >
+: public itk::DefaultConvertPixelTraits < ::std::complex < T > >
+{
+public:
-#define OTB_DEFAULTCONVERTTRAITS_OFFSET_TYPE(dimension) \
-template<> \
-class DefaultConvertPixelTraits< itk::Offset<dimension> > \
-{ \
-public: \
- typedef itk::Offset<dimension> TargetType; \
- typedef TargetType::OffsetValueType ComponentType; \
- static unsigned int GetNumberOfComponents() \
- { \
- return dimension; \
- } \
- static void SetNthComponent(int i, TargetType & pixel, const ComponentType& v) \
- { \
- pixel[i] = v; \
- } \
- static void SetNthComponent(int , TargetType & pixel, const TargetType& v) \
- { \
- pixel = v; \
- } \
- static ComponentType GetScalarValue(const TargetType& pixel) \
- { \
- return pixel[0]; \
- } \
+ typedef itk::DefaultConvertPixelTraits < ::std::complex < T > > SuperClass;
+ using typename SuperClass::TargetType ;
+ using typename SuperClass::ComponentType ;
+
+ using SuperClass::SetNthComponent ;
+
+ static void SetNthComponent(int , TargetType & pixel, const TargetType & v)
+ {
+ pixel = v;
+ }
+
+ static TargetType GetNthComponent ( int , const TargetType & pixel )
+ {
+ return pixel;
+ }
+
+ static ComponentType GetScalarValue(const TargetType& pixel)
+ {
+ /*
+ * This seems to be dead code, since the complex to scalar
+ * conversion is done by ConvertPixelBuffer
+ *
+ * Historically, it was returning std::norm, which causes
+ * compilation error on MacOSX 10.9.
+ * Now returns the equivalent implementation of std::norm.
+ */
+ return static_cast<ComponentType>( pixel.real()*pixel.real()
+ + pixel.imag()*pixel.imag() );
+ }
};
-
-// Define traits for Offset<> from dimensions 1 to 5
- OTB_DEFAULTCONVERTTRAITS_OFFSET_TYPE(1)
- OTB_DEFAULTCONVERTTRAITS_OFFSET_TYPE(2)
- OTB_DEFAULTCONVERTTRAITS_OFFSET_TYPE(3)
- OTB_DEFAULTCONVERTTRAITS_OFFSET_TYPE(4)
- OTB_DEFAULTCONVERTTRAITS_OFFSET_TYPE(5)
-
-//
-// Default traits for the pixel types deriving from FixedArray<>
-//
-
-#define OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE(type,componenttype, dimension) \
-template<> \
-class DefaultConvertPixelTraits< type< componenttype, dimension> > \
-{ \
-public: \
- typedef type< componenttype, dimension > TargetType; \
- typedef componenttype ComponentType; \
- static unsigned int GetNumberOfComponents() \
- { \
- return dimension; \
- } \
- static void SetNthComponent(int i, TargetType & pixel, const ComponentType& v) \
- { \
- pixel[i] = v; \
- } \
- static void SetNthComponent(int , TargetType & pixel, const TargetType& v) \
- { \
- pixel = v; \
- } \
- static ComponentType GetScalarValue(const TargetType& pixel) \
- { \
- return pixel[0]; \
- } \
-}; \
-
-//
-//
-// Define traits for Classed deriving from FixedArray from dimensions 1 to 6
-// These classes include: Vector, CovariantVector and Point.
-//
-//
-#define OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, Type) \
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE(ArrayType,Type,1) \
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE(ArrayType,Type,2) \
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE(ArrayType,Type,3) \
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE(ArrayType,Type,4) \
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE(ArrayType,Type,5) \
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE(ArrayType,Type,6)
-
-#define OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_TYPES_MACRO(ArrayType) \
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, char); \
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, signed char); \
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, unsigned char); \
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, short); \
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, unsigned short); \
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, int); \
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, unsigned int); \
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, long); \
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, unsigned long); \
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, float); \
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_MACRO(ArrayType, double);
-
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_TYPES_MACRO(itk::Vector);
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_TYPES_MACRO(itk::CovariantVector);
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_TYPES_MACRO(itk::Point);
- OTB_DEFAULTCONVERTTRAITS_FIXEDARRAY_TYPE_ALL_TYPES_MACRO(itk::FixedArray);
-
-//
-// End of Traits for the classes deriving from FixedArray.
-//
-//
-
-
-//
-// Default traits for the pixel types deriving from Matrix<>
-//
-
-#define OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE(type,componenttype,rows,cols) \
-template<> \
-class DefaultConvertPixelTraits< type< componenttype, rows, cols > > \
-{ \
-public: \
- typedef type< componenttype, rows, cols > TargetType; \
- typedef componenttype ComponentType; \
- static unsigned int GetNumberOfComponents() \
- { \
- return rows * cols; \
- } \
- static void SetNthComponent(int i, TargetType & pixel, const ComponentType& v) \
- { \
- const unsigned int row = i / cols; \
- const unsigned int col = i % cols; \
- pixel[row][col] = v; \
- } \
- static void SetNthComponent(int , TargetType & pixel, const TargetType& v) \
- { \
- pixel = v; \
- } \
- static ComponentType GetScalarValue(const TargetType& pixel) \
- { \
- return pixel[0][0]; \
- } \
-}; \
-
-//
-//
-// Define traits for Classed deriving from Matrix from dimensions 1 to 6
-//
-//
-#define OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, Type) \
- OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE(ArrayType,Type,1,1) \
- OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE(ArrayType,Type,2,2) \
- OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE(ArrayType,Type,3,3) \
- OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE(ArrayType,Type,4,4) \
- OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE(ArrayType,Type,5,5) \
- OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE(ArrayType,Type,6,6)
-
-#define OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_TYPES_MACRO(ArrayType) \
- OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, char); \
- OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, signed char); \
- OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, unsigned char); \
- OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, short); \
- OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, unsigned short); \
- OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, int); \
- OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, unsigned int); \
- OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, long); \
- OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, unsigned long); \
- OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, float); \
- OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_MACRO(ArrayType, double);
-
-//
-// Add here other classes that derive from Matrix or that have the same API
-//
- OTB_DEFAULTCONVERTTRAITS_MATRIX_TYPE_ALL_TYPES_MACRO(itk::Matrix);
-
-//
-// End of Traits for the classes deriving from Matrix.
-//
-//
-
-
-//
-// Default traits for the pixel types deriving from std::complex<>
-//
-
-#define OTB_DEFAULTCONVERTTRAITS_COMPLEX_TYPE( componenttype ) \
-template<> \
-class DefaultConvertPixelTraits< ::std::complex< componenttype > > \
-{ \
-public: \
- typedef ::std::complex< componenttype> TargetType; \
- typedef componenttype ComponentType; \
- static unsigned int GetNumberOfComponents() \
- { \
- return 2; \
- } \
- static void SetNthComponent(int i, TargetType & pixel, const ComponentType& v) \
- { \
- if( i == 0 ) \
- { \
- pixel = TargetType( v, pixel.imag() ); \
- } \
- else \
- { \
- pixel = TargetType( pixel.real(), v ); \
- } \
- } \
- static void SetNthComponent(int , TargetType & pixel, const TargetType& v) \
- { \
- pixel = v; \
- } \
- static ComponentType GetScalarValue(const TargetType& pixel) \
- { \
- /* \
- * This seems to be dead code, since the complex to scalar \
- * conversion is done by ConvertPixelBuffer \
- * \
- * Historically, it was returning std::norm, which causes \
- * compilation error on MacOSX 10.9. \
- * Now returns the equivalent implementation of std::norm. \
- */ \
- return static_cast<ComponentType>( pixel.real()*pixel.real() \
- + pixel.imag()*pixel.imag() ); \
- } \
-}; \
-
-OTB_DEFAULTCONVERTTRAITS_COMPLEX_TYPE(float);
-OTB_DEFAULTCONVERTTRAITS_COMPLEX_TYPE(double);
-OTB_DEFAULTCONVERTTRAITS_COMPLEX_TYPE(signed int);
-OTB_DEFAULTCONVERTTRAITS_COMPLEX_TYPE(unsigned int);
-OTB_DEFAULTCONVERTTRAITS_COMPLEX_TYPE(short int);
-OTB_DEFAULTCONVERTTRAITS_COMPLEX_TYPE(signed char);
-OTB_DEFAULTCONVERTTRAITS_COMPLEX_TYPE(unsigned char);
-OTB_DEFAULTCONVERTTRAITS_COMPLEX_TYPE(signed long);
-OTB_DEFAULTCONVERTTRAITS_COMPLEX_TYPE(unsigned long);
-
-//
-// End of Traits for the classes deriving from std::complex.
-//
-//
-
-} // end namespace otb
+} // end namespace
#endif
diff --git a/Modules/Core/ObjectList/include/otbImageList.h b/Modules/Core/ObjectList/include/otbImageList.h
index 611d84a47a18efdb93a79085fa4a764968338ddf..4cb77bddec306437bccb05b45b81bdf71c9b9610 100644
--- a/Modules/Core/ObjectList/include/otbImageList.h
+++ b/Modules/Core/ObjectList/include/otbImageList.h
@@ -68,6 +68,8 @@ public:
throw (itk::InvalidRequestedRegionError) ITK_OVERRIDE;
void UpdateOutputData(void) ITK_OVERRIDE;
+ void SetRequestedRegion(const itk::DataObject * source);
+
protected:
/** Constructor */
ImageList() {};
diff --git a/Modules/Core/ObjectList/include/otbImageList.txx b/Modules/Core/ObjectList/include/otbImageList.txx
index dc0cbc9b6fef35e3430891fb9cd08a7e4324aefd..dec0ab8b3e5ce3a834ee5a6dc9a247831d432f5b 100644
--- a/Modules/Core/ObjectList/include/otbImageList.txx
+++ b/Modules/Core/ObjectList/include/otbImageList.txx
@@ -39,10 +39,32 @@ ImageList<TImage>
|| it.Get()->GetDataReleased()
|| it.Get()->RequestedRegionIsOutsideOfTheBufferedRegion())
{
+ if(it.Get()->GetSource())
+ {
+ it.Get()->GetSource()->UpdateOutputData(it.Get());
+ }
+ }
+ }
+}
+
+template <class TImage>
+void
+ImageList<TImage>
+::PropagateRequestedRegion() throw (itk::InvalidRequestedRegionError)
+ {
+ Superclass::PropagateRequestedRegion();
+
+ for (ConstIterator it = this->Begin(); it != this->End(); ++it)
+ {
+ if (it.Get()->GetUpdateMTime() < it.Get()->GetPipelineMTime()
+ || it.Get()->GetDataReleased()
+ || it.Get()->RequestedRegionIsOutsideOfTheBufferedRegion())
+ {
+
if (it.Get()->GetSource())
{
it.Get()->GetSource()->PropagateRequestedRegion(it.Get());
-
+
// Check that the requested region lies within the largest possible region
if (!it.Get()->VerifyRequestedRegion())
{
@@ -51,23 +73,24 @@ ImageList<TImage>
e.SetLocation(ITK_LOCATION);
e.SetDataObject(it.Get());
e.SetDescription("Requested region is (at least partially) outside the largest possible region.");
-
+
throw e;
}
-
- it.Get()->GetSource()->UpdateOutputData(it.Get());
}
}
}
-}
+ }
-template <class TImage>
+template<class TImage>
void
ImageList<TImage>
-::PropagateRequestedRegion() throw (itk::InvalidRequestedRegionError)
- {
- Superclass::PropagateRequestedRegion();
- }
+::SetRequestedRegion(const itk::DataObject * source)
+{
+ for (ConstIterator it = this->Begin(); it != this->End(); ++it)
+ {
+ it.Get()->SetRequestedRegion(source);
+ }
+}
template <class TImage>
void
diff --git a/Modules/Core/Streaming/include/otbPipelineMemoryPrintCalculator.h b/Modules/Core/Streaming/include/otbPipelineMemoryPrintCalculator.h
index 826478711d24b2c9ab3ac7e75d4e8586354c8afb..41fe7808e9d84a0d0ae3017996e417ea0cd97c3a 100644
--- a/Modules/Core/Streaming/include/otbPipelineMemoryPrintCalculator.h
+++ b/Modules/Core/Streaming/include/otbPipelineMemoryPrintCalculator.h
@@ -121,7 +121,7 @@ public:
static const double MegabyteToByte;
/** Evaluate the print (in bytes) of a single data object */
- MemoryPrintType EvaluateDataObjectPrint(DataObjectType * data) const;
+ MemoryPrintType EvaluateDataObjectPrint(DataObjectType * data);
protected:
/** Constructor */
diff --git a/Modules/Core/Streaming/src/otbPipelineMemoryPrintCalculator.cxx b/Modules/Core/Streaming/src/otbPipelineMemoryPrintCalculator.cxx
index 033c58bc379fed6aba092e28e346b1d58ab35b84..d7d62e8c88cd6a779425feb92d5c9eeea7a71497 100644
--- a/Modules/Core/Streaming/src/otbPipelineMemoryPrintCalculator.cxx
+++ b/Modules/Core/Streaming/src/otbPipelineMemoryPrintCalculator.cxx
@@ -162,7 +162,7 @@ PipelineMemoryPrintCalculator
PipelineMemoryPrintCalculator::MemoryPrintType
PipelineMemoryPrintCalculator
-::EvaluateDataObjectPrint(DataObjectType * data) const
+::EvaluateDataObjectPrint(DataObjectType * data)
{
otbMsgDevMacro(<< "EvaluateMemoryPrint for " << data->GetNameOfClass() << " (" << data << ")")
@@ -183,11 +183,13 @@ PipelineMemoryPrintCalculator
{ \
ImageList<Image<type, 2> > * imageList = dynamic_cast<otb::ImageList<otb::Image<type, 2> > *>(data); \
MemoryPrintType print(0); \
- for(ImageList<Image<type, 2> >::ConstIterator it = imageList->Begin(); \
+ for(ImageList<Image<type, 2> >::Iterator it = imageList->Begin(); \
it != imageList->End(); ++it) \
{ \
- print += it.Get()->GetRequestedRegion().GetNumberOfPixels() \
- * it.Get()->GetNumberOfComponentsPerPixel() * sizeof(type); \
+ if(it.Get()->GetSource()) \
+ print += this->EvaluateProcessObjectPrintRecursive(it.Get()->GetSource());\
+ else \
+ print += this->EvaluateDataObjectPrint(it.Get()); \
} \
return print; \
} \
@@ -198,8 +200,10 @@ PipelineMemoryPrintCalculator
for(ImageList<VectorImage<type, 2> >::ConstIterator it = imageList->Begin(); \
it != imageList->End(); ++it) \
{ \
- print += it.Get()->GetRequestedRegion().GetNumberOfPixels() \
- * it.Get()->GetNumberOfComponentsPerPixel() * sizeof(type); \
+ if(it.Get()->GetSource()) \
+ print += this->EvaluateProcessObjectPrintRecursive(it.Get()->GetSource());\
+ else \
+ print += this->EvaluateDataObjectPrint(it.Get()); \
} \
return print; \
} \
diff --git a/Modules/Filtering/ImageManipulation/include/otbClampImageFilter.h b/Modules/Filtering/ImageManipulation/include/otbClampImageFilter.h
index 6fdd16e955a3b7a754779b6d1acd76de60e711d8..478eb952220a8cf08eed6b8550114d2053ba2ccd 100644
--- a/Modules/Filtering/ImageManipulation/include/otbClampImageFilter.h
+++ b/Modules/Filtering/ImageManipulation/include/otbClampImageFilter.h
@@ -21,121 +21,104 @@
#ifndef otbClampImageFilter_h
#define otbClampImageFilter_h
-#include "itkImageToImageFilter.h"
+#include "otbConvertTypeFunctor.h"
+#include "itkUnaryFunctorImageFilter.h"
namespace otb
{
/** \class ClampImageFilter
- * \brief Set image values to a user-specified value if they are below,
- * above, or between simple threshold values.
+ * \brief Clamp image values to be below, over, or between threhold values.
*
* ClampImageFilter clamp image values to be between an upper
* and lower value. Values lower than m_Lower values are set to lower,
* and values greater than upper threshold are set to upper threshold
* value.
+ * This filter can also be used to cast any type of image into any other type
+ * as long as those types are arithmetics or complex.
*
* By default lower and upper thresholds are set to the maximum and
- * minimum bounds of the image pixel type.
- *
- * The pixels must support the operators >= and <=.
+ * minimum bounds of the image internal pixel value.
*
* \ingroup IntensityImageFilters Multithreaded
*
* \ingroup OTBImageManipulation
*/
template <class TInputImage, class TOutputImage=TInputImage>
- class ITK_EXPORT ClampImageFilter : public itk::ImageToImageFilter<TInputImage, TOutputImage>
+ class ITK_EXPORT ClampImageFilter
+ : public itk::UnaryFunctorImageFilter< TInputImage , TOutputImage ,
+ Functor::ConvertTypeFunctor <typename TInputImage::PixelType ,
+ typename TOutputImage::PixelType> >
{
public:
/** Standard class typedefs. */
- typedef ClampImageFilter Self;
- typedef itk::ImageToImageFilter<TInputImage, TOutputImage> Superclass;
- typedef itk::SmartPointer<Self> Pointer;
- typedef itk::SmartPointer<const Self> ConstPointer;
+ typedef ClampImageFilter Self;
+ typedef itk::UnaryFunctorImageFilter< TInputImage , TOutputImage ,
+ Functor::ConvertTypeFunctor <typename TInputImage::PixelType ,
+ typename TOutputImage::PixelType> > Superclass;
+ typedef itk::SmartPointer<Self> Pointer;
+ typedef itk::SmartPointer<const Self> ConstPointer;
/** Method for creation through the object factory. */
- itkNewMacro(Self);
+ itkNewMacro( Self );
/** Run-time type information (and related methods). */
- itkTypeMacro(ClampImageFilter, itk::ImageToImageFilter);
+ itkTypeMacro( ClampImageFilter , itk::UnaryFunctorImageFilter );
/** Some additional typedefs. */
typedef TInputImage InputImageType;
- typedef typename InputImageType::ConstPointer InputImagePointer;
typedef typename InputImageType::RegionType InputImageRegionType;
typedef typename InputImageType::PixelType InputImagePixelType;
/** Some additional typedefs. */
- typedef TOutputImage OutputImageType;
- typedef typename OutputImageType::Pointer OutputImagePointer;
- typedef typename OutputImageType::RegionType OutputImageRegionType;
- typedef typename OutputImageType::PixelType OutputImagePixelType;
+ typedef TOutputImage OutputImageType;
+ typedef typename OutputImageType::RegionType OutputImageRegionType;
+ typedef typename OutputImageType::PixelType OutputImagePixelType;
+ typedef typename OutputImageType::InternalPixelType OutputInternalPixelType;
+ typedef typename itk::NumericTraits< OutputInternalPixelType >::ValueType OutputPixelValueType;
- /** The values greater than or equal to the value are set to OutsideValue. */
- void ClampAbove(const OutputImagePixelType &thresh);
+ /** The values greater than or equal to the value are set to \p thresh. */
+ void ClampAbove(const OutputPixelValueType &thresh);
- /** The values less than or equal to the value are set to OutsideValue. */
- void ClampBelow(const OutputImagePixelType &thresh);
+ /** The values less than or equal to the value are set to \p thresh. */
+ void ClampBelow(const OutputPixelValueType &thresh);
- /** The values outside the range are set to OutsideValue. */
- void ClampOutside(const OutputImagePixelType &lower, const OutputImagePixelType &upper);
+ /** The values outside the range are set to \p lower or \p upper. */
+ void ClampOutside(const OutputPixelValueType &lower, const OutputPixelValueType &upper);
/** Set/Get methods to set the lower threshold */
- void SetLower(OutputImagePixelType val)
- {
- m_Lower = val;
- m_DLower = static_cast<double>(val);
- this->Modified();
- }
- itkGetConstMacro(Lower, OutputImagePixelType);
+ void SetLower(OutputPixelValueType val);
+
+ itkGetConstMacro(Lower, OutputPixelValueType);
/** Set/Get methods to set the upper threshold */
- void SetUpper(OutputImagePixelType val)
- {
- m_Upper = val;
- m_DUpper = static_cast<double>(val);
- this->Modified();
- }
- itkGetConstMacro(Upper, OutputImagePixelType);
+ void SetUpper(OutputPixelValueType val);
+
+ itkGetConstMacro(Upper, OutputPixelValueType);
protected:
ClampImageFilter();
- ~ClampImageFilter() ITK_OVERRIDE {};
- void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE;
-
- /** ClampImageFilter can be implemented as a multithreaded filter.
- * Therefore, this implementation provides a ThreadedGenerateData() routine
- * which is called for each processing thread. The output image data is
- * allocated automatically by the superclass prior to calling
- * ThreadedGenerateData(). ThreadedGenerateData can only write to the
- * portion of the output image specified by the parameter
- * "outputRegionForThread"
- *
- * \sa ImageToImageFilter::ThreadedGenerateData(),
- * ImageToImageFilter::GenerateData() */
- void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
- itk::ThreadIdType threadId ) ITK_OVERRIDE;
-
- void GenerateOutputInformation(void) ITK_OVERRIDE
- {
- Superclass::GenerateOutputInformation();
+ ~ClampImageFilter() override {};
+ void PrintSelf(std::ostream& os, itk::Indent indent) const override;
- this->GetOutput()->SetNumberOfComponentsPerPixel( this->GetInput()->GetNumberOfComponentsPerPixel() );
- }
+ void GenerateOutputInformation(void) override
+ {
+ Superclass::GenerateOutputInformation();
+ unsigned int sizeIn = this->GetInput()->GetNumberOfComponentsPerPixel();
+ this->GetFunctor().SetInputComponents( sizeIn );
+ this->GetOutput()->SetNumberOfComponentsPerPixel(
+ this->GetFunctor().GetOutputSize () );
+ }
private:
- ClampImageFilter(const Self&); //purposely not implemented
- void operator=(const Self&); //purposely not implemented
-
- double m_DLower;
- double m_DUpper;
+ ClampImageFilter(const Self&) = delete ;
+ void operator=(const Self&) = delete ;
- OutputImagePixelType m_Lower;
- OutputImagePixelType m_Upper;
+ OutputPixelValueType m_Lower;
+ OutputPixelValueType m_Upper;
};
diff --git a/Modules/Filtering/ImageManipulation/include/otbClampImageFilter.txx b/Modules/Filtering/ImageManipulation/include/otbClampImageFilter.txx
index fd1ed1320ec1cbe7768eb8ccb44f7b9ba317d8f9..b1ac37e2e3df315e4b2e402f9034a73ef25a4665 100644
--- a/Modules/Filtering/ImageManipulation/include/otbClampImageFilter.txx
+++ b/Modules/Filtering/ImageManipulation/include/otbClampImageFilter.txx
@@ -25,6 +25,7 @@
#include "otbClampImageFilter.h"
#include "itkImageRegionIterator.h"
#include "itkNumericTraits.h"
+#include <limits>
#include "itkObjectFactory.h"
#include "itkProgressReporter.h"
@@ -38,13 +39,35 @@ template <class TInputImage, class TOutputImage>
ClampImageFilter<TInputImage, TOutputImage>
::ClampImageFilter()
{
- m_Lower = itk::NumericTraits<OutputImagePixelType>::NonpositiveMin();
- m_Upper = itk::NumericTraits<OutputImagePixelType>::max();
+ m_Lower = std::numeric_limits < OutputPixelValueType >::lowest();
+ m_Upper = std::numeric_limits < OutputPixelValueType >::max();
+}
- m_DLower = static_cast<double>(m_Lower);
- m_DUpper = static_cast<double>(m_Upper);
+template <class TInputImage, class TOutputImage>
+void
+ClampImageFilter<TInputImage, TOutputImage>
+::SetLower(OutputPixelValueType val)
+{
+ if ( m_Lower != val )
+ {
+ m_Lower = val;
+ this->GetFunctor().SetLowest( m_Lower );
+ this->Modified();
+ }
}
+template <class TInputImage, class TOutputImage>
+void
+ClampImageFilter<TInputImage, TOutputImage>
+::SetUpper(OutputPixelValueType val)
+{
+ if ( m_Upper != val )
+ {
+ m_Upper = val;
+ this->GetFunctor().SetHighest( m_Upper );
+ this->Modified();
+ }
+}
/**
*
@@ -70,14 +93,15 @@ ClampImageFilter<TInputImage, TOutputImage>
template <class TInputImage, class TOutputImage>
void
ClampImageFilter<TInputImage, TOutputImage>
-::ClampAbove(const OutputImagePixelType &thresh)
+::ClampAbove(const OutputPixelValueType &thresh)
{
if (m_Upper != thresh
- || m_Lower > itk::NumericTraits<OutputImagePixelType>::NonpositiveMin())
+ || m_Lower > std::numeric_limits < OutputPixelValueType >::lowest())
{
- m_Lower = itk::NumericTraits<OutputImagePixelType>::NonpositiveMin();
+ m_Lower = std::numeric_limits < OutputPixelValueType >::lowest();
m_Upper = thresh;
- m_DUpper = static_cast<double>(m_Upper);
+ this->GetFunctor().SetLowest( m_Lower );
+ this->GetFunctor().SetHighest( m_Upper );
this->Modified();
}
}
@@ -88,13 +112,14 @@ ClampImageFilter<TInputImage, TOutputImage>
template <class TInputImage, class TOutputImage>
void
ClampImageFilter<TInputImage, TOutputImage>
-::ClampBelow(const OutputImagePixelType &thresh)
+::ClampBelow(const OutputPixelValueType &thresh)
{
- if (m_Lower != thresh || m_Upper < itk::NumericTraits<OutputImagePixelType>::max())
+ if (m_Lower != thresh || m_Upper < std::numeric_limits < OutputPixelValueType >::max())
{
+ m_Upper = std::numeric_limits < OutputPixelValueType >::max();
m_Lower = thresh;
- m_DLower = m_Lower;
- m_Upper = itk::NumericTraits<InputImagePixelType>::max();
+ this->GetFunctor().SetLowest( m_Lower );
+ this->GetFunctor().SetHighest( m_Upper );
this->Modified();
}
}
@@ -106,7 +131,7 @@ ClampImageFilter<TInputImage, TOutputImage>
template <class TInputImage, class TOutputImage>
void
ClampImageFilter<TInputImage, TOutputImage>
-::ClampOutside(const OutputImagePixelType &lower, const OutputImagePixelType &upper)
+::ClampOutside(const OutputPixelValueType &lower, const OutputPixelValueType &upper)
{
if (lower > upper)
{
@@ -118,73 +143,12 @@ ClampImageFilter<TInputImage, TOutputImage>
{
m_Lower = lower;
m_Upper = upper;
- m_DLower = m_Lower;
- m_DUpper = m_Upper;
+ this->GetFunctor().SetLowest( m_Lower );
+ this->GetFunctor().SetHighest( m_Upper );
this->Modified();
}
}
-
-/**
- *
- */
-template <class TInputImage, class TOutputImage>
-void
-ClampImageFilter<TInputImage, TOutputImage>
-::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
- itk::ThreadIdType threadId)
-{
- itkDebugMacro(<<"Actually executing");
-
- // Get the input and output pointers
- InputImagePointer inputPtr = this->GetInput();
- OutputImagePointer outputPtr = this->GetOutput(0);
-
- // Define/declare an iterator that will walk the output region for this
- // thread.
- typedef itk::ImageRegionConstIterator<TInputImage> InputIterator;
- typedef itk::ImageRegionIterator<TOutputImage> OutputIterator;
-
- InputIterator inIt(inputPtr, outputRegionForThread);
- OutputIterator outIt(outputPtr, outputRegionForThread);
-
- // support progress methods/callbacks
- itk::ProgressReporter progress(this, threadId, outputRegionForThread.GetNumberOfPixels());
-
- // walk the regions, threshold each pixel
- while( !outIt.IsAtEnd() && !inIt.IsAtEnd() )
- {
- // Cast the value of the pixel to double in order to compare
- // with the double version of the upper and the lower bounds of
- // output image
- const double value = static_cast<double>(inIt.Get());
- OutputImagePixelType outPix = m_Lower;
-
- if ( m_DLower <= value && value <= m_DUpper)
- {
- // pixel passes to output unchanged
- outPix = static_cast<OutputImagePixelType>(value);
- }
- /* Already outPix is initialized with m_Lower even for preventing Warning.
- *
- else if ( value < m_DLower )
- {
- outPix = m_Lower;
- }
- */
- else if ( value > m_DUpper)
- {
- outPix = m_Upper;
- }
-
- outIt.Set( outPix );
-
- ++inIt;
- ++outIt;
- progress.CompletedPixel();
- }
-}
-
} // end namespace itk
#endif
diff --git a/Modules/Filtering/ImageManipulation/include/otbClampVectorImageFilter.h b/Modules/Filtering/ImageManipulation/include/otbClampVectorImageFilter.h
index 053c3060001c7bc0961d1f4aac7d16ead7cd1fa2..50b43302e4bc18ff3d0cb89c998ee05c5fc710a2 100644
--- a/Modules/Filtering/ImageManipulation/include/otbClampVectorImageFilter.h
+++ b/Modules/Filtering/ImageManipulation/include/otbClampVectorImageFilter.h
@@ -21,6 +21,7 @@
#ifndef otbClampVectorImageFilter_h
#define otbClampVectorImageFilter_h
+#include <vcl_deprecated_header.h>
#include "itkImageToImageFilter.h"
namespace otb
diff --git a/Modules/Filtering/ImageManipulation/include/otbConvertTypeFunctor.h b/Modules/Filtering/ImageManipulation/include/otbConvertTypeFunctor.h
new file mode 100644
index 0000000000000000000000000000000000000000..c5a73b5cb1591868f4f67a1ddf65df3b5544a6ff
--- /dev/null
+++ b/Modules/Filtering/ImageManipulation/include/otbConvertTypeFunctor.h
@@ -0,0 +1,243 @@
+/*
+ * Copyright (C) 2005-2017 Centre National d'Etudes Spatiales (CNES)
+ *
+ * This file is part of Orfeo Toolbox
+ *
+ * https://www.orfeo-toolbox.org/
+ *
+ * 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
+ *
+ * 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 otbConvertTypeFunctor_h
+#define otbConvertTypeFunctor_h
+
+#include <limits>
+#include <type_traits>
+#include <boost/type_traits/is_complex.hpp>
+#include <boost/type_traits/is_scalar.hpp>
+
+#include "itkNumericTraits.h"
+#include "otbDefaultConvertPixelTraits.h"
+
+namespace otb
+{
+namespace Functor
+{
+
+template < class TInputPixelType , class TOutputPixelType >
+class ConvertTypeFunctor
+{
+public:
+ typedef TInputPixelType InputPixelType;
+ typedef TOutputPixelType OutputPixelType;
+ typedef ConvertTypeFunctor Self;
+
+ typedef typename itk::NumericTraits < InputPixelType > :: ValueType InputInternalPixelType;
+ typedef typename itk::NumericTraits < OutputPixelType > :: ValueType OutputInternalPixelType;
+
+ typedef typename itk::NumericTraits < InputInternalPixelType > :: ValueType InputPixelValueType;
+ typedef typename itk::NumericTraits < OutputInternalPixelType > :: ValueType OutputPixelValueType;
+
+ static constexpr bool m_cInPix = boost::is_complex < InputPixelType > :: value ;
+ static constexpr bool m_cOutPix = boost::is_complex < OutputPixelType > :: value ;
+ static constexpr bool m_cInInternalPix = boost::is_complex < InputInternalPixelType > :: value ;
+ static constexpr bool m_cOutInternalPix = boost::is_complex < OutputInternalPixelType > :: value ;
+
+ ConvertTypeFunctor()
+ // m_cInPix ( boost::is_complex < InputPixelType > :: value ) ,
+ // m_cOutPix ( boost::is_complex < OutputPixelType > :: value ) ,
+ // m_cInInternalPix ( boost::is_complex < InputInternalPixelType > :: value ) ,
+ // m_cOutInternalPix ( boost::is_complex < OutputInternalPixelType > :: value )
+ {
+ m_LowestB = std::numeric_limits < OutputPixelValueType >::lowest();
+ m_HighestB = std::numeric_limits < OutputPixelValueType >::max();
+
+ m_LowestBD = static_cast < double > ( m_LowestB );
+ m_HighestBD = static_cast < double > ( m_HighestB );
+
+ // m_cInPix = boost::is_complex < InputPixelType > :: value ;
+ // m_cOutPix = boost::is_complex < OutputPixelType > :: value ;
+ // m_cInInternalPix = boost::is_complex < InputInternalPixelType > :: value ;
+ // m_cOutInternalPix = boost::is_complex < OutputInternalPixelType > :: value ;
+ }
+
+ // template < class InternalPixelType >
+ void SetInputComponents( unsigned int sizeIn )
+ {
+ m_CompIn = sizeIn ;
+ if ( m_cInPix )
+ {
+ // needed as ITK thinks that one complex component is actually
+ // two components...
+ m_CompIn /= 2 ;
+ }
+ }
+
+ unsigned int GetOutputSize()
+ {
+ if ( m_cInInternalPix || m_cInPix )
+ m_Scal = 2 * m_CompIn;
+ else
+ m_Scal = m_CompIn;
+
+ OutputPixelType out;
+ unsigned int size =
+ itk::NumericTraits < OutputPixelType > :: GetLength( out );
+ if ( size == 0 ) // That means it is a variable size container
+ {
+ if ( m_cOutInternalPix )
+ m_CompOut = ( m_Scal + 1 ) / 2 ;
+ else
+ m_CompOut = m_Scal ;
+ }
+ // It is a fixed size container, m_CompOut should be equal to its size
+ else if ( m_cOutPix ) // one complex is one component
+ m_CompOut = 1 ;
+ else // fized size container or scalar
+ m_CompOut = size;
+
+
+ return m_CompOut ;
+ }
+
+ void SetLowest( OutputPixelValueType & lowest )
+ {
+ m_LowestB = lowest;
+ m_LowestBD = static_cast < double > ( m_LowestB );
+ }
+
+ void SetHighest( OutputPixelValueType & highest )
+ {
+ m_HighestB = highest;
+ m_HighestBD = static_cast < double > ( m_HighestB );
+ }
+
+ OutputPixelType operator() ( InputPixelType const & in ) const
+ {
+ std::vector < double > vPixel;
+ for ( unsigned int i = 0 ; i < m_CompIn ; i ++)
+ FillIn < InputPixelType > ( i , in , vPixel );
+ assert( m_Scal == vPixel.size() );
+ if ( ( m_cOutPix || m_cOutInternalPix ) && vPixel.size()%2 )
+ {
+ vPixel.push_back(0); // last component has no imaginary part
+ }
+ Clamp( vPixel );
+ OutputPixelType out;
+
+ int hack = 1;
+ if ( m_cOutPix )
+ hack += 1; // needed in case we have OutputPixelType == complex<t> as
+ // itk::NumericTraits::SetLength() will ask a length of 2!
+ itk::NumericTraits < OutputPixelType > :: SetLength( out ,
+ hack * m_CompOut );
+
+ for ( unsigned int i = 0 ; i < m_CompOut ; i ++)
+ FillOut < OutputPixelType > ( i , out , vPixel );
+ return out;
+ }
+
+ ~ConvertTypeFunctor() {};
+
+protected:
+
+ template <class PixelType ,
+ std::enable_if_t < std::is_arithmetic < PixelType > ::value , int > = 0 >
+ void FillIn( unsigned int i ,
+ InputPixelType const & pix ,
+ std::vector < double > & vPix ) const
+ {
+ vPix.push_back( DefaultConvertPixelTraits < InputPixelType > ::
+ GetNthComponent( i , pix ) );
+ }
+
+ template <class PixelType ,
+ std::enable_if_t < boost::is_complex < PixelType > :: value , int > = 0 >
+ void FillIn( unsigned int i ,
+ InputPixelType const & pix ,
+ std::vector < double > & vPix ) const
+ {
+ PixelType comp = DefaultConvertPixelTraits < InputPixelType > ::
+ GetNthComponent( i , pix );
+ vPix.push_back( static_cast < double > ( real( comp ) ) );
+ vPix.push_back( static_cast < double > ( imag( comp ) ) );
+ }
+
+ template <class PixelType ,
+ std::enable_if_t < !( boost::is_complex < PixelType > :: value
+ || std::is_arithmetic < PixelType > ::value ) , int > = 0 >
+ void FillIn( unsigned int i ,
+ InputPixelType const & pix ,
+ std::vector < double > & vPix ) const
+ {
+ FillIn < InputInternalPixelType > ( i , pix , vPix );
+ }
+
+ void Clamp( std::vector < double > & vPixel ) const
+ {
+ for ( double & comp : vPixel )
+ {
+ if ( comp >= m_HighestBD )
+ comp = m_HighestBD;
+ else if ( comp <= m_LowestBD )
+ comp = m_LowestBD;
+ }
+ }
+
+ template <class PixelType ,
+ std::enable_if_t < std::is_arithmetic < PixelType > ::value , int > = 0 >
+ void FillOut( unsigned int i ,
+ OutputPixelType & pix ,
+ std::vector < double > & vPix ) const
+ {
+ DefaultConvertPixelTraits < OutputPixelType > ::
+ SetNthComponent( i , pix , vPix[i] );
+ }
+
+ template <class PixelType ,
+ std::enable_if_t < boost::is_complex < PixelType > :: value , int > = 0 >
+ void FillOut( unsigned int i ,
+ OutputPixelType & pix ,
+ std::vector < double > & vPix ) const
+ {
+ DefaultConvertPixelTraits < OutputPixelType > ::
+ SetNthComponent( i , pix ,
+ PixelType ( vPix[ 2 * i] , vPix[ 2 * i + 1] ) );
+ }
+
+ template <class PixelType ,
+ std::enable_if_t < !( boost::is_complex < PixelType > :: value
+ || std::is_arithmetic < PixelType > ::value ) , int > = 0 >
+ void FillOut( unsigned int i ,
+ OutputPixelType & pix ,
+ std::vector < double > & vPix ) const
+ {
+ FillOut < OutputInternalPixelType > ( i , pix , vPix );
+ }
+
+private:
+ ConvertTypeFunctor(const Self &) = delete;
+ void operator =(const Self&) = delete;
+
+ double m_LowestBD , m_HighestBD ;
+ OutputPixelValueType m_LowestB , m_HighestB ;
+ unsigned int m_CompIn , m_CompOut , m_Scal ;
+ // const bool m_cInPix , m_cOutPix , m_cInInternalPix , m_cOutInternalPix ;
+
+};
+
+} //end namespace Functor
+
+} //end namespace otb
+
+#endif
diff --git a/Modules/Filtering/ImageManipulation/include/otbOneRIBandImageToOneComplexBandImage.h b/Modules/Filtering/ImageManipulation/include/otbOneRIBandImageToOneComplexBandImage.h
index 8582158d36343dd3449f79e27e7135fb04a435b7..01fe68c1150b7ce971cc105833b431b980d3981a 100644
--- a/Modules/Filtering/ImageManipulation/include/otbOneRIBandImageToOneComplexBandImage.h
+++ b/Modules/Filtering/ImageManipulation/include/otbOneRIBandImageToOneComplexBandImage.h
@@ -21,6 +21,7 @@
#ifndef otbOneRIBandImageToOneComplexBandImage_h
#define otbOneRIBandImageToOneComplexBandImage_h
+#include <vcl_deprecated_header.h>
#include "itkImageToImageFilter.h"
#include "itkImage.h"
#include "itkNumericTraits.h"
diff --git a/Modules/Filtering/ImageManipulation/include/otbRealImageToComplexImageFilter.h b/Modules/Filtering/ImageManipulation/include/otbRealImageToComplexImageFilter.h
index c426b5a2f9e5a2225d842b51cb92640841bcefbd..8e86ee82f3bf7df11abc7ba99955e673e3b522e8 100644
--- a/Modules/Filtering/ImageManipulation/include/otbRealImageToComplexImageFilter.h
+++ b/Modules/Filtering/ImageManipulation/include/otbRealImageToComplexImageFilter.h
@@ -21,6 +21,7 @@
#ifndef otbRealImageToComplexImageFilter_h
#define otbRealImageToComplexImageFilter_h
+#include <vcl_deprecated_header.h>
#include "itkUnaryFunctorImageFilter.h"
#include "vnl/vnl_math.h"
diff --git a/Modules/Filtering/ImageManipulation/include/otbTwoNRIBandsImageToNComplexBandsImage.h b/Modules/Filtering/ImageManipulation/include/otbTwoNRIBandsImageToNComplexBandsImage.h
index 538b07214964f53fb86a9238d9417b968ae13630..c4adb6a9f7b78e4b040a916ef1a970ff6be05627 100644
--- a/Modules/Filtering/ImageManipulation/include/otbTwoNRIBandsImageToNComplexBandsImage.h
+++ b/Modules/Filtering/ImageManipulation/include/otbTwoNRIBandsImageToNComplexBandsImage.h
@@ -21,6 +21,7 @@
#ifndef otbTwoNRIBandsImageToNComplexBandsImage_h
#define otbTwoNRIBandsImageToNComplexBandsImage_h
+#include <vcl_deprecated_header.h>
#include "itkImageToImageFilter.h"
#include "itkImage.h"
#include "itkNumericTraits.h"
diff --git a/Modules/Filtering/ImageManipulation/test/CMakeLists.txt b/Modules/Filtering/ImageManipulation/test/CMakeLists.txt
index 386b4294793890480773aa72640551525dfaedcf..834a6d3da072adf5c4dbc385d46db7931132de97 100644
--- a/Modules/Filtering/ImageManipulation/test/CMakeLists.txt
+++ b/Modules/Filtering/ImageManipulation/test/CMakeLists.txt
@@ -58,7 +58,6 @@ otbStreamingInnerProductVectorImageFilter.cxx
otbPhaseFunctorTest.cxx
otbShiftScaleVectorImageFilterNew.cxx
otbChangeLabelImageFilter.cxx
-otbClampVectorImageFilter.cxx
otbPrintableImageFilterNew.cxx
otbShiftScaleImageAdaptorNew.cxx
otbStreamingInnerProductVectorImageFilterNew.cxx
@@ -442,20 +441,6 @@ otb_add_test(NAME bfTvChangeLabelImageFilter COMMAND otbImageManipulationTestDri
255 # upper threshold
)
-
-otb_add_test(NAME bfTvClampVectorImageFilterTest COMMAND otbImageManipulationTestDriver
- --compare-image 0.0001
- ${BASELINE}/bfTvClampVectorImageFilterTest_Output.tif
- ${TEMP}/bfTvClampVectorImageFilterTest_Output.tif
- otbClampVectorImageFilterTest
- ${INPUTDATA}/QB_TOULOUSE_MUL_Extract_500_500.tif
- ${TEMP}/bfTvClampVectorImageFilterTest_Output.tif
- )
-
-otb_add_test(NAME bfTuClampVectorImageFilterNew COMMAND otbImageManipulationTestDriver
- otbClampVectorImageFilterNew
- )
-
otb_add_test(NAME bfTuPrintableImageFilterNew COMMAND otbImageManipulationTestDriver
otbPrintableImageFilterNew)
@@ -638,6 +623,11 @@ otb_add_test(NAME bfTvClampImageFilterTest COMMAND otbImageManipulationTestDrive
${TEMP}/bfTvClampImageFilterTest_Output.tif
)
+otb_add_test(NAME bfTvClampImageFilterConversionTest COMMAND otbImageManipulationTestDriver
+ otbClampImageFilterConversionTest
+ ${INPUTDATA}/veryverySmallFSATSW.tif
+ )
+
otb_add_test(NAME coTvConcatenateVectorImageFilter COMMAND otbImageManipulationTestDriver
--compare-image ${NOTOL}
${BASELINE}/coConcatenateVectorImageFilterOutput1.hdr
diff --git a/Modules/Filtering/ImageManipulation/test/otbClampImageFilter.cxx b/Modules/Filtering/ImageManipulation/test/otbClampImageFilter.cxx
index 82deca5f4fc74917e5e3bc5d78bf1acf5e0a41c6..29ac5602eacbc38ffda2b5914822024b2a20d0df 100644
--- a/Modules/Filtering/ImageManipulation/test/otbClampImageFilter.cxx
+++ b/Modules/Filtering/ImageManipulation/test/otbClampImageFilter.cxx
@@ -21,10 +21,14 @@
#include "otbClampImageFilter.h"
#include "otbImage.h"
+#include "otbVectorImage.h"
+#include <limits>
#include "otbImageFileReader.h"
#include "otbImageFileWriter.h"
+#include "itkImageRegionConstIterator.h"
+
/** Pixel typedefs */
typedef double InputPixelType;
typedef unsigned int OutputPixelType;
@@ -65,3 +69,423 @@ int otbClampImageFilterTest(int itkNotUsed(argc), char* argv[])
return EXIT_SUCCESS;
}
+
+template < class InImageType , class OutImageType >
+typename OutImageType::Pointer
+Cross ( std::string const & inputFileName )
+{
+ typedef otb::ImageFileReader< InImageType > ReaderType;
+ typedef otb::ClampImageFilter< InImageType , OutImageType > ClampFilter;
+ typename ReaderType::Pointer reader ( ReaderType::New() );
+ reader->SetFileName( inputFileName );
+ typename ClampFilter::Pointer clamp ( ClampFilter::New() );
+ clamp->SetInput( reader->GetOutput() );
+ clamp->Update();
+ return clamp->GetOutput();
+}
+
+template < class OutImageType >
+typename OutImageType::Pointer
+Cross ( otb::VectorImage< std::complex<float> >::Pointer input )
+{
+ typedef otb::ClampImageFilter< otb::VectorImage< std::complex<float> > ,
+ OutImageType > ClampFilter;
+ typename ClampFilter::Pointer clamp ( ClampFilter::New() );
+ clamp->SetInput( input );
+ clamp->Update();
+ return clamp->GetOutput();
+}
+
+template < class OutImageType >
+typename OutImageType::Pointer
+Cross ( otb::Image< itk::FixedArray< std::complex<float> , 2 > >::Pointer input )
+{
+ typedef otb::ClampImageFilter< otb::Image< itk::FixedArray< std::complex<float> , 2 > > ,
+ OutImageType > ClampFilter;
+ typename ClampFilter::Pointer clamp ( ClampFilter::New() );
+ clamp->SetInput( input );
+ clamp->Update();
+ return clamp->GetOutput();
+}
+
+typedef otb::VectorImage<double> ImageRefType;
+
+template <class ImageType >
+bool
+CompareImageReal( const ImageRefType::Pointer imRef ,
+ const ImageType * im )
+{
+ typedef typename ImageType::PixelType RealPixelType;
+
+ RealPixelType min = std::numeric_limits< RealPixelType >::lowest();
+ RealPixelType max = std::numeric_limits< RealPixelType >::max();
+ auto itRef = itk::ImageRegionConstIterator< ImageRefType >( imRef ,
+ imRef->GetLargestPossibleRegion() );
+ auto it = itk::ImageRegionConstIterator< ImageType >( im ,
+ im->GetLargestPossibleRegion() );
+ itRef.GoToBegin();
+ it.GoToBegin();
+ RealPixelType val;
+ double ref;
+ while ( !it.IsAtEnd() )
+ {
+ val = it.Get();
+ ref = itRef.Get()[0];
+ if ( ref > static_cast<double>( max ) && val != max )
+ {
+ return false;
+ }
+ else if ( ref < static_cast<double>( min ) && val != min )
+ {
+ return false;
+ }
+ else if ( static_cast<RealPixelType>( ref ) != val )
+ {
+ return false;
+ }
+ ++it;
+ ++itRef;
+ }
+ return true;
+}
+
+template <class ImageType >
+bool
+CompareVectorReal( const ImageRefType::Pointer imRef ,
+ const ImageType * im )
+{
+ typedef typename ImageType::InternalPixelType RealPixelType;
+ RealPixelType min = std::numeric_limits< RealPixelType >::lowest();
+ RealPixelType max = std::numeric_limits< RealPixelType >::max();
+ auto itRef = itk::ImageRegionConstIterator< ImageRefType >( imRef ,
+ imRef->GetLargestPossibleRegion() );
+ auto it = itk::ImageRegionConstIterator< ImageType >( im ,
+ im->GetLargestPossibleRegion() );
+ itRef.GoToBegin();
+ it.GoToBegin();
+ unsigned int nbChanel = im->GetNumberOfComponentsPerPixel ();
+ // unsigned int nbChanelRef = imRef->GetNumberOfComponentsPerPixel ();
+ RealPixelType val;
+ double ref;
+ while ( !it.IsAtEnd() )
+ {
+ // std::cout<<it.Get()<<std::endl;
+ // std::cout<<itRef.Get()<<std::endl;
+ for ( unsigned int i = 0 ; i < nbChanel ; i++ )
+ {
+ val = it.Get()[i];
+ ref = itRef.Get()[i];
+
+ if ( ref > static_cast<double>( max ) && val != max )
+ {
+ std::cout<<"ref : "<<static_cast<RealPixelType>(ref)<<std::endl;
+ std::cout<<"val : "<<val<<std::endl;
+ return false;
+ }
+ else if ( ref < static_cast<double>( min ) && val != min )
+ {
+ std::cout<<"ref : "<<static_cast<RealPixelType>(ref)<<std::endl;
+ std::cout<<"val : "<<val<<std::endl;
+ return false;
+ }
+ else if ( static_cast<RealPixelType>(ref) != val )
+ {
+ std::cout<<"ref : "<<static_cast<RealPixelType>(ref)<<std::endl;
+ std::cout<<"val : "<<val<<std::endl;
+ return false;
+ }
+ }
+ ++it;
+ ++itRef;
+ }
+ return true;
+}
+
+template <class ImageType >
+bool
+CompareImageComplex( const ImageRefType::Pointer imageRef ,
+ const ImageType * im )
+{
+ typedef typename ImageType::PixelType ComplexType;
+ typedef typename ComplexType::value_type RealType;
+
+ RealType min = std::numeric_limits< RealType >::lowest();
+ RealType max = std::numeric_limits< RealType >::max();
+ auto itRef = itk::ImageRegionConstIterator< ImageRefType >( imageRef ,
+ imageRef->GetLargestPossibleRegion() );
+ auto it = itk::ImageRegionConstIterator< ImageType >( im ,
+ im->GetLargestPossibleRegion() );
+ itRef.GoToBegin();
+ it.GoToBegin();
+ ComplexType val;
+ double reRef , imRef;
+ while ( !it.IsAtEnd() )
+ {
+ val = it.Get();
+ reRef = itRef.Get()[0];
+ imRef = itRef.Get()[1];
+ if ( ( reRef > static_cast<double>( max ) && val.real() != max )
+ || ( imRef > static_cast<double>( max ) && val.imag() != max ) )
+ {
+ return false;
+ }
+ else if ( ( reRef < static_cast<double>( min ) && val.real() != min )
+ || ( imRef < static_cast<double>( min ) && val.imag() != min ) )
+ {
+ return false;
+ }
+ else if ( static_cast<RealType>( reRef ) != val.real()
+ || static_cast<RealType>( imRef ) != val.imag() )
+ {
+ return false;
+ }
+ ++it;
+ ++itRef;
+ }
+ return true;
+}
+
+template <class ImageType >
+bool
+CompareVectorComplex( const ImageRefType::Pointer imageRef ,
+ const ImageType * im )
+{
+ typedef typename ImageType::InternalPixelType ComplexType;
+ typedef typename ComplexType::value_type RealType;
+
+ RealType min = std::numeric_limits< RealType >::lowest();
+ RealType max = std::numeric_limits< RealType >::max();
+ auto itRef = itk::ImageRegionConstIterator< ImageRefType >( imageRef ,
+ imageRef->GetLargestPossibleRegion() );
+ auto it = itk::ImageRegionConstIterator< ImageType >( im ,
+ im->GetLargestPossibleRegion() );
+ itRef.GoToBegin();
+ it.GoToBegin();
+ unsigned int nbChanel = im->GetNumberOfComponentsPerPixel ();
+ ComplexType val;
+ float reRef , imRef;
+ while ( !it.IsAtEnd() )
+ {
+ for (unsigned int i = 0 ; i < nbChanel ; i++ )
+ {
+ val = it.Get()[i];
+ reRef = itRef.Get()[ 2 * i ];
+ imRef = itRef.Get()[ 2 * i + 1 ];
+ if ( ( reRef > static_cast<double>( max ) && val.real() != max )
+ || ( imRef > static_cast<double>( max ) && val.imag() != max ) )
+ {
+ return false;
+ }
+ else if ( ( reRef < static_cast<double>( min ) && val.real() != min )
+ || ( imRef < static_cast<double>( min ) && val.imag() != min ) )
+ {
+ return false;
+ }
+ else if ( static_cast<RealType>( reRef ) != val.real()
+ || static_cast<RealType>( imRef ) != val.imag() )
+ {
+ return false;
+ }
+ }
+ ++it;
+ ++itRef;
+ }
+ return true;
+}
+
+template <class ImageType >
+bool
+CompareArrayComplex( const ImageRefType::Pointer imageRef ,
+ const ImageType * im )
+{
+ typedef typename ImageType::PixelType ArrayType;
+ typedef typename ArrayType::ValueType ComplexType;
+ typedef typename ComplexType::value_type RealType;
+
+ RealType min = std::numeric_limits< RealType >::lowest();
+ RealType max = std::numeric_limits< RealType >::max();
+ auto itRef = itk::ImageRegionConstIterator< ImageRefType >( imageRef ,
+ imageRef->GetLargestPossibleRegion() );
+ auto it = itk::ImageRegionConstIterator< ImageType >( im ,
+ im->GetLargestPossibleRegion() );
+ itRef.GoToBegin();
+ it.GoToBegin();
+ unsigned int nbChanel = im->GetNumberOfComponentsPerPixel ();
+ ComplexType val;
+ float reRef , imRef;
+ while ( !it.IsAtEnd() )
+ {
+ for (unsigned int i = 0 ; i < nbChanel ; i++ )
+ {
+ val = it.Get()[i];
+ reRef = itRef.Get()[ 2 * i ];
+ imRef = itRef.Get()[ 2 * i + 1 ];
+ if ( ( reRef > static_cast<double>( max ) && val.real() != max )
+ || ( imRef > static_cast<double>( max ) && val.imag() != max ) )
+ {
+ return false;
+ }
+ else if ( ( reRef < static_cast<double>( min ) && val.real() != min )
+ || ( imRef < static_cast<double>( min ) && val.imag() != min ) )
+ {
+ return false;
+ }
+ else if ( static_cast<RealType>( reRef ) != val.real()
+ || static_cast<RealType>( imRef ) != val.imag() )
+ {
+ return false;
+ }
+ }
+ ++it;
+ ++itRef;
+ }
+ return true;
+}
+
+int otbClampImageFilterConversionTest(int itkNotUsed(argc), char* argv[])
+{
+ typedef otb::ImageFileReader< ImageRefType > ReaderType;
+ ReaderType::Pointer reader ( ReaderType::New() );
+ reader->SetFileName( argv[1] );
+ reader->Update();
+ ImageRefType::Pointer imageRef = reader->GetOutput();
+
+ // vect<real> --> vect<real>
+ otb::VectorImage< short >::Pointer image0 =
+ Cross < otb::VectorImage< double > , otb::VectorImage< short > > ( argv[1] );
+ bool test0 = CompareVectorReal < otb::VectorImage< short > >( imageRef , image0 );
+ std::cout<< "Test 0 : "<<test0<<std::endl;
+ image0 =nullptr;
+
+ // vect<real> --> vect<complex>
+ otb::VectorImage< std::complex<unsigned short>>::Pointer image1 =
+ Cross < otb::VectorImage< float > , otb::VectorImage<std::complex<unsigned short>> > ( argv[1] );
+ bool test1 = CompareVectorComplex < otb::VectorImage<std::complex<unsigned short>> >( imageRef , image1 );
+ std::cout<< "Test 1 : "<<test1<<std::endl;
+ image1 = nullptr;
+
+ // vect<real> --> image<real>
+ otb::Image<int>::Pointer image2 =
+ Cross < otb::VectorImage< float > , otb::Image<int> > ( argv[1] );
+ bool test2 = CompareImageReal < otb::Image<int> >( imageRef , image2 );
+ std::cout<< "Test 2 : "<<test2<<std::endl;
+ image2 = nullptr;
+
+ // vect<real> --> image<complex>
+ otb::Image< std::complex<float>>::Pointer image3 =
+ Cross < otb::VectorImage< float > , otb::Image<std::complex<float>> > ( argv[1] );
+ bool test3 = CompareImageComplex < otb::Image<std::complex<float>> >( imageRef , image3 );
+ std::cout<< "Test 3 : "<<test3<<std::endl;
+ image3 = nullptr;
+
+ // image<real> --> image<real>
+ otb::Image< unsigned short >::Pointer image4 =
+ Cross < otb::Image< itk::FixedArray < double , 4 > > , otb::Image< unsigned short > > ( argv[1] );
+ bool test4 = CompareImageReal < otb::Image< unsigned short > >( imageRef , image4 );
+ std::cout<< "Test 4 : "<<test4<<std::endl;
+ image4 = nullptr;
+
+ // image<real> --> image<complex>
+ otb::Image< std::complex<int> >::Pointer image5 =
+ Cross < otb::Image< itk::FixedArray < double , 4 > > , otb::Image< std::complex<int> > > ( argv[1] );
+ bool test5 = CompareImageComplex < otb::Image< std::complex<int> > >( imageRef , image5 );
+ std::cout<< "Test 5 : "<<test5<<std::endl;
+ image5 = nullptr;
+
+ // image<real> --> vector<real>
+ otb::VectorImage< float >::Pointer image6 =
+ Cross < otb::Image< itk::FixedArray < double , 4 > > , otb::VectorImage< float > > ( argv[1] );
+ bool test6 = CompareVectorReal < otb::VectorImage< float > >( imageRef , image6 );
+ std::cout<< "Test 6 : "<<test6<<std::endl;
+ image6 = nullptr;
+
+ // image<real> --> vector<complex>
+ otb::VectorImage< std::complex<float> >::Pointer image7 =
+ Cross < otb::Image< itk::FixedArray < double , 4 > > , otb::VectorImage< std::complex<float> > > ( argv[1] );
+ bool test7 = CompareVectorComplex < otb::VectorImage< std::complex<float> > >( imageRef , image7 );
+ std::cout<< "Test 7 : "<<test7<<std::endl;
+
+ // vector<complex> --> vector<real>
+ otb::VectorImage< int >::Pointer image8 =
+ Cross < otb::VectorImage< int > > ( image7 );
+ bool test8 = CompareVectorReal < otb::VectorImage< int > >( imageRef , image8 );
+ std::cout<< "Test 8 : "<<test8<<std::endl;
+ image8=nullptr;
+
+ // vector<complex> --> vector<complex>
+ otb::VectorImage< std::complex<int> >::Pointer image9 =
+ Cross < otb::VectorImage< std::complex<int> > > ( image7 );
+ bool test9 = CompareVectorComplex < otb::VectorImage< std::complex<int> > >( imageRef , image9 );
+ std::cout<< "Test 9 : "<<test9<<std::endl;
+ image9=nullptr;
+
+ // vector<complex> --> image<real>
+ otb::Image< int >::Pointer image10 =
+ Cross < otb::Image< int > > ( image7 );
+ bool test10 = CompareImageReal < otb::Image< int > >( imageRef , image10 );
+ std::cout<< "Test 10 : "<<test10<<std::endl;
+ image10=nullptr;
+
+ // vector<complex> --> image<complex>
+ otb::Image< std::complex<unsigned short> >::Pointer image11 =
+ Cross < otb::Image< std::complex<unsigned short> > > ( image7 );
+ bool test11 = CompareImageComplex < otb::Image< std::complex<unsigned short> > >( imageRef , image11 );
+ std::cout<< "Test 11 : "<<test11<<std::endl;
+ image11=nullptr;
+
+ // image<complex> --> vector<complex>
+ otb::VectorImage<std::complex<float>>::Pointer image12 =
+ Cross < otb::Image< std::complex<float> > , otb::VectorImage< std::complex<float>> > ( argv[1] );
+ bool test12 = CompareVectorComplex < otb::VectorImage<std::complex<float>> >( imageRef , image12 );
+ std::cout<< "Test 12 : "<<test12<<std::endl;
+ image12 = nullptr;
+
+ // image<complex> --> image<complex>
+ otb::Image< std::complex< short >>::Pointer image13 =
+ Cross < otb::Image< std::complex<float> > , otb::Image< std::complex< short >> > ( argv[1] );
+ bool test13 = CompareImageComplex < otb::Image< std::complex< short >> >( imageRef , image13 );
+ std::cout<< "Test 13 : "<<test13<<std::endl;
+ image13 = nullptr;
+
+ // image<complex> --> image<real>
+ otb::Image< int >::Pointer image14 =
+ Cross < otb::Image< std::complex<float> > , otb::Image< int > > ( argv[1] );
+ bool test14 = CompareImageReal < otb::Image< int > >( imageRef , image14 );
+ std::cout<< "Test 14 : "<<test14<<std::endl;
+ image14 = nullptr;
+
+ // image<complex> --> vector<real>
+ otb::VectorImage< unsigned short >::Pointer image15 =
+ Cross < otb::Image< std::complex<float> > , otb::VectorImage< unsigned short > > ( argv[1] );
+ bool test15 = CompareVectorReal < otb::VectorImage< unsigned short > >( imageRef , image15 );
+ std::cout<< "Test 15 : "<<test15<<std::endl;
+ image15 = nullptr;
+
+ // image<fixedarray<real>> --> image<fixedarray<complex>>
+ otb::Image< itk::FixedArray < std::complex<float> , 2 > >::Pointer image16 =
+ Cross < otb::Image< itk::FixedArray < double , 4 > > ,
+ otb::Image< itk::FixedArray < std::complex<float> , 2 > > > ( argv[1] );
+ bool test16 = CompareArrayComplex < otb::Image< itk::FixedArray < std::complex<float> , 2 > > >( imageRef , image16 );
+ std::cout<< "Test 16 : "<<test16<<std::endl;
+
+ // image<fixedarray<complex>> --> vectorimage<real>
+ otb::VectorImage< int >::Pointer image17 =
+ Cross < otb::VectorImage< int > >( image16 );
+ bool test17 = CompareVectorReal < otb::VectorImage< int > >( imageRef , image17 );
+ std::cout<< "Test 17 : "<<test17<<std::endl;
+ image17 = nullptr;
+
+ // vector<real> --> image<fixedarray<complex>>
+ otb::Image< itk::FixedArray < std::complex<float> , 2 > >::Pointer image18 =
+ Cross < otb::VectorImage< int > ,
+ otb::Image< itk::FixedArray < std::complex<float> , 2 > > > ( argv[1] );
+ bool test18 = CompareArrayComplex < otb::Image< itk::FixedArray < std::complex<float> , 2 > > >( imageRef , image18 );
+ image18 = nullptr;
+ std::cout<< "Test 18 : "<<test18<<std::endl;
+
+ if (test1 && test2 && test3 && test4 && test5 &&test6 && test7 && test8
+ && test9 && test10 && test11 && test12 && test13 && test14 && test15
+ && test16 && test17 && test18 )
+ return EXIT_SUCCESS;
+ return EXIT_FAILURE;
+}
diff --git a/Modules/Filtering/ImageManipulation/test/otbImageManipulationTestDriver.cxx b/Modules/Filtering/ImageManipulation/test/otbImageManipulationTestDriver.cxx
index b5176d976154edad57bcd2f470a2cff6eb76085c..c5b59f8ef2d62eb790adf085e5c9121db5f28d4a 100644
--- a/Modules/Filtering/ImageManipulation/test/otbImageManipulationTestDriver.cxx
+++ b/Modules/Filtering/ImageManipulation/test/otbImageManipulationTestDriver.cxx
@@ -61,8 +61,6 @@ void RegisterTests()
REGISTER_TEST(otbPhaseFunctorTest);
REGISTER_TEST(otbShiftScaleVectorImageFilterNew);
REGISTER_TEST(otbChangeLabelImageFilter);
- REGISTER_TEST(otbClampVectorImageFilterNew);
- REGISTER_TEST(otbClampVectorImageFilterTest);
REGISTER_TEST(otbPrintableImageFilterNew);
REGISTER_TEST(otbShiftScaleImageAdaptorNew);
REGISTER_TEST(otbStreamingInnerProductVectorImageFilterNew);
@@ -87,6 +85,7 @@ void RegisterTests()
REGISTER_TEST(otbMultiplyByScalarImageFilterTest);
REGISTER_TEST(otbClampImageFilterNew);
REGISTER_TEST(otbClampImageFilterTest);
+ REGISTER_TEST(otbClampImageFilterConversionTest);
REGISTER_TEST(otbConcatenateVectorImageFilter);
REGISTER_TEST(otbBinaryImageMinimalBoundingRegionCalculatorNew);
REGISTER_TEST(otbVectorRescaleIntensityImageFilterNew);
diff --git a/Modules/Filtering/ImageManipulation/test/otbOneRIBandImageToOneComplexBandImage.cxx b/Modules/Filtering/ImageManipulation/test/otbOneRIBandImageToOneComplexBandImage.cxx
index b7d8de1665289709964b8938b56ab693ee62b93b..41a18d0bb3b611e3eee571932648c0803e92c3aa 100644
--- a/Modules/Filtering/ImageManipulation/test/otbOneRIBandImageToOneComplexBandImage.cxx
+++ b/Modules/Filtering/ImageManipulation/test/otbOneRIBandImageToOneComplexBandImage.cxx
@@ -20,7 +20,8 @@
#include "itkMacro.h"
-#include "otbOneRIBandImageToOneComplexBandImage.h"
+// #include "otbOneRIBandImageToOneComplexBandImage.h"
+#include "otbClampImageFilter.h"
#include "otbImage.h"
#include "otbVectorImage.h"
@@ -37,7 +38,7 @@ int otbOneRIBandImageToOneComplexBandImage(int itkNotUsed(argc), char * argv[])
typedef otb::Image<OutputPixelType, 2> OutputImageType;
- typedef otb::OneRIBandImageToOneComplexBandImage<InputImageType, OutputImageType> FilterType;
+ typedef otb::ClampImageFilter<InputImageType, OutputImageType> FilterType;
typedef otb::ImageFileReader<InputImageType> ReaderType;
typedef otb::ImageFileWriter<OutputImageType> WriterType;
diff --git a/Modules/IO/IOXML/include/otbStatisticsXMLFileWriter.txx b/Modules/IO/IOXML/include/otbStatisticsXMLFileWriter.txx
index f1d830132a227162ceb539c3435fd8436b085de4..b20416b4d77617e0c23ea967603cbd910489ea5c 100644
--- a/Modules/IO/IOXML/include/otbStatisticsXMLFileWriter.txx
+++ b/Modules/IO/IOXML/include/otbStatisticsXMLFileWriter.txx
@@ -72,7 +72,7 @@ StatisticsXMLFileWriter<TMeasurementVector>
itkExceptionMacro(<<"The XML output FileName is empty, please set the filename via the method SetFileName");
// Check that the right extension is given : expected .xml */
- std::string extension = itksys::SystemTools::GetFilenameLastExtension(m_FileName);
+ const std::string extension = itksys::SystemTools::GetFilenameLastExtension(m_FileName);
if (itksys::SystemTools::LowerCase(extension) != ".xml")
{
itkExceptionMacro(<<extension
diff --git a/Modules/Remote/otb-bv.remote.cmake b/Modules/Remote/otb-bv.remote.cmake
index 06e067e6586cc345fed2d1f6aade487cf08350b3..739f46126b5c658ce1eb11dcd0d07879dfbbcc8d 100644
--- a/Modules/Remote/otb-bv.remote.cmake
+++ b/Modules/Remote/otb-bv.remote.cmake
@@ -22,8 +22,8 @@
otb_fetch_module(OTBBioVars
"Biophysical variable estimation from remote sensing imagery.
A more detailed description can be found on the project website:
-http://tully.ups-tlse.fr/jordi/otb-bv
+https://gitlab.orfeo-toolbox.org/jinglada/otb-bv
"
- GIT_REPOSITORY http://tully.ups-tlse.fr/jordi/otb-bv.git
+ GIT_REPOSITORY https://gitlab.orfeo-toolbox.org/jinglada/otb-bv.git
GIT_TAG 0e56e487aebc4a493e25223960560e9ef0ca27ec
)
diff --git a/Modules/Remote/phenotb.remote.cmake b/Modules/Remote/phenotb.remote.cmake
index aa9e9a8ead204e1b3a4f8492e16825c838da95d7..74d83a9d96d04bd545ee5b02d4790fcac6ab6e3e 100644
--- a/Modules/Remote/phenotb.remote.cmake
+++ b/Modules/Remote/phenotb.remote.cmake
@@ -24,8 +24,8 @@ otb_fetch_module(OTBPhenology
information from time profiles. These time profiles should represent
vegetation status as for instance NDVI, LAI, etc.
A more detailed description can be found on the project website:
-http://tully.ups-tlse.fr/jordi/phenotb
+https://gitlab.orfeo-toolbox.org/jinglada/phenotb
"
- GIT_REPOSITORY http://tully.ups-tlse.fr/jordi/phenotb.git
+ GIT_REPOSITORY https://gitlab.orfeo-toolbox.org/jinglada/phenotb.git
GIT_TAG c9349eb89a652a18b28a40dfb3fa352b76388527
)
diff --git a/Modules/Remote/temporal-gapfilling.remote.cmake b/Modules/Remote/temporal-gapfilling.remote.cmake
index 469a857fb8119f1564de992b6d0481f82920e61b..2dd788d21391a19390f40ac90ff3af1b5271311b 100644
--- a/Modules/Remote/temporal-gapfilling.remote.cmake
+++ b/Modules/Remote/temporal-gapfilling.remote.cmake
@@ -23,9 +23,9 @@ otb_fetch_module(OTBTemporalGapFilling
"Gapfilling for time series replaces invalid pixels (as designated by a mask)
by an interpolation using the valid dates of the series.
A more detailed description can be found on the project website:
-http://tully.ups-tlse.fr/jordi/temporalgapfilling
+https://gitlab.orfeo-toolbox.org/jinglada/temporalgapfilling
"
- GIT_REPOSITORY http://tully.ups-tlse.fr/jordi/temporalgapfilling.git
+ GIT_REPOSITORY https://gitlab.orfeo-toolbox.org/jinglada/temporalgapfilling.git
# Commit on develop branch which includes patches for Windows support
GIT_TAG 4fc4a71acf7b9b051cda5a3b950de2cdb9d26287
)
diff --git a/Modules/Wrappers/ApplicationEngine/include/otbWrapperApplication.h b/Modules/Wrappers/ApplicationEngine/include/otbWrapperApplication.h
index f97134cbd1e4eb32f6768168b50eb5cab7c94158..c6317be14289016f5a5f9636b1af864a1d0c969c 100644
--- a/Modules/Wrappers/ApplicationEngine/include/otbWrapperApplication.h
+++ b/Modules/Wrappers/ApplicationEngine/include/otbWrapperApplication.h
@@ -592,11 +592,16 @@ public:
{ \
Image##Type::Pointer ret; \
Parameter* param = GetParameterByKey(parameter); \
- if (dynamic_cast<InputImageParameter*>(param)) \
+ InputImageParameter* paramDown = dynamic_cast<InputImageParameter*>(param); \
+ ComplexInputImageParameter* paramDownC = dynamic_cast<ComplexInputImageParameter*>(param); \
+ if ( paramDown ) \
{ \
- InputImageParameter* paramDown = dynamic_cast<InputImageParameter*>(param); \
ret = paramDown->Get##Image(); \
} \
+ else if ( paramDownC ) /* Support of ComplexInputImageParameter */ \
+ { \
+ ret = paramDownC->Get##Image(); \
+ } \
return ret; \
}
@@ -619,30 +624,16 @@ public:
otbGetParameterImageMacro(UInt8RGBImage);
otbGetParameterImageMacro(UInt8RGBAImage);
- /* Get a complex image value
- *
- * Can be called for types :
- * \li ParameterType_ComplexInputImage
- */
-
-#define otbGetParameterComplexImageMacro( Image ) \
- Image##Type * GetParameter##Image( std::string parameter ) \
- { \
- Image##Type::Pointer ret; \
- Parameter* param = GetParameterByKey(parameter); \
- ComplexInputImageParameter* paramDown = dynamic_cast<ComplexInputImageParameter*>(param); \
- if (paramDown) \
- { \
- ret = paramDown->Get##Image(); \
- } \
- return ret; \
- }
-
- otbGetParameterComplexImageMacro(ComplexFloatImage);
- otbGetParameterComplexImageMacro(ComplexDoubleImage);
+ // Complex image
+ otbGetParameterImageMacro(ComplexInt16Image);
+ otbGetParameterImageMacro(ComplexInt32Image);
+ otbGetParameterImageMacro(ComplexFloatImage);
+ otbGetParameterImageMacro(ComplexDoubleImage);
- otbGetParameterComplexImageMacro(ComplexFloatVectorImage);
- otbGetParameterComplexImageMacro(ComplexDoubleVectorImage);
+ otbGetParameterImageMacro(ComplexInt16VectorImage);
+ otbGetParameterImageMacro(ComplexInt32VectorImage);
+ otbGetParameterImageMacro(ComplexFloatVectorImage);
+ otbGetParameterImageMacro(ComplexDoubleVectorImage);
/* Get an image list value
*
diff --git a/Modules/Wrappers/ApplicationEngine/include/otbWrapperComplexInputImageParameter.h b/Modules/Wrappers/ApplicationEngine/include/otbWrapperComplexInputImageParameter.h
index 1fa00dd77d70660769bdd48e0031ac0d77d8e368..264967e376a209e0bf36929e4f4960b2e8cc5490 100644
--- a/Modules/Wrappers/ApplicationEngine/include/otbWrapperComplexInputImageParameter.h
+++ b/Modules/Wrappers/ApplicationEngine/include/otbWrapperComplexInputImageParameter.h
@@ -60,12 +60,37 @@ public:
ComplexFloatVectorImageType* GetImage();
/** Get the input image as XXXImageType */
+ ComplexInt16ImageType* GetComplexInt16Image();
+ ComplexInt32ImageType* GetComplexInt32Image();
ComplexFloatImageType* GetComplexFloatImage();
ComplexDoubleImageType* GetComplexDoubleImage();
+ ComplexInt16VectorImageType* GetComplexInt16VectorImage();
+ ComplexInt32VectorImageType* GetComplexInt32VectorImage();
ComplexFloatVectorImageType* GetComplexFloatVectorImage();
ComplexDoubleVectorImageType* GetComplexDoubleVectorImage();
+/* Support for ComplexInputImageParameter. This has been done to support
+the macro otbGetParameterImageMacro of otbWrapperApplication.h */
+ UInt8ImageType* GetUInt8Image();
+ UInt16ImageType* GetUInt16Image();
+ Int16ImageType* GetInt16Image();
+ UInt32ImageType* GetUInt32Image();
+ Int32ImageType* GetInt32Image();
+ FloatImageType* GetFloatImage();
+ DoubleImageType* GetDoubleImage();
+
+ UInt8VectorImageType* GetUInt8VectorImage();
+ UInt16VectorImageType* GetUInt16VectorImage();
+ Int16VectorImageType* GetInt16VectorImage();
+ UInt32VectorImageType* GetUInt32VectorImage();
+ Int32VectorImageType* GetInt32VectorImage();
+ FloatVectorImageType* GetFloatVectorImage();
+ DoubleVectorImageType* GetDoubleVectorImage();
+
+ UInt8RGBImageType* GetUInt8RGBImage();
+ UInt8RGBAImageType* GetUInt8RGBAImage();
+
/** Get the input image as templated image type. */
template <class TImageType>
TImageType* GetImage();
@@ -81,15 +106,6 @@ public:
template <class TComplexInputImage, class TOutputImage>
TOutputImage* CastImage();
- /** Cast an image to an image of the same type
- * Image to Image, VectorImage to VectorImage, RGBAImage to RGBAImage. */
- template <class TComplexInputImage, class TOutputImage>
- TOutputImage* SimpleCastImage();
-
- /** Cast an image to a vector image. */
- template <class TComplexInputImage, class TOutputImage>
- TOutputImage* CastVectorImageFromImage();
-
bool HasValue() const ITK_OVERRIDE;
void ClearValue() ITK_OVERRIDE;
@@ -107,9 +123,6 @@ protected:
/** Readers typedefs */
- typedef otb::ImageFileReader<ComplexFloatImageType> ComplexFloatReaderType;
- typedef otb::ImageFileReader<ComplexDoubleImageType> ComplexDoubleReaderType;
-
typedef otb::ImageFileReader<ComplexFloatVectorImageType> ComplexFloatVectorReaderType;
typedef otb::ImageFileReader<ComplexDoubleVectorImageType> ComplexDoubleVectorReaderType;
@@ -128,33 +141,6 @@ private:
}; // End class ComplexInputImage Parameter
-
-// template specializations of CastImage<> should be declared in header
-// so that the linker knows they exist when building OTB Applications
-
-#define otbDefineCastImageMacro(ComplexInputImageType, OutputImageType) \
- template<> OutputImageType * \
- ComplexInputImageParameter::CastImage<ComplexInputImageType , OutputImageType>(); \
-
-#define otbGenericDefineCastImageMacro(ComplexInputImageType, prefix) \
- otbDefineCastImageMacro(ComplexInputImageType, ComplexFloat##prefix##ImageType) \
- otbDefineCastImageMacro(ComplexInputImageType, ComplexDouble##prefix##ImageType)
-
-
-/*********************************************************************
-********************** Image -> Image
-**********************************************************************/
-
- otbGenericDefineCastImageMacro(ComplexFloatImageType, )
- otbGenericDefineCastImageMacro(ComplexDoubleImageType, )
-
-
-/*********************************************************************
-********************** VectorImage -> VectorImage
-**********************************************************************/
- otbGenericDefineCastImageMacro(ComplexFloatVectorImageType, Vector)
- otbGenericDefineCastImageMacro(ComplexDoubleVectorImageType, Vector)
-
} // End namespace Wrapper
} // End namespace otb
diff --git a/Modules/Wrappers/ApplicationEngine/include/otbWrapperComplexInputImageParameter.txx b/Modules/Wrappers/ApplicationEngine/include/otbWrapperComplexInputImageParameter.txx
index 774dfdbf789b8cdb48252f76e7aad13bba90399c..92e8dfd32e135ecc522a178f90a2be8fd3e1386a 100644
--- a/Modules/Wrappers/ApplicationEngine/include/otbWrapperComplexInputImageParameter.txx
+++ b/Modules/Wrappers/ApplicationEngine/include/otbWrapperComplexInputImageParameter.txx
@@ -24,8 +24,9 @@
#include "otbWrapperComplexInputImageParameter.h"
#include "itkUnaryFunctorImageFilter.h"
-#include "itkCastImageFilter.h"
-#include "otbImageToVectorImageCastFilter.h"
+// #include "itkCastImageFilter.h"
+// #include "otbImageToVectorImageCastFilter.h"
+#include "otbClampImageFilter.h"
namespace otb
{
@@ -91,7 +92,15 @@ ComplexInputImageParameter::GetImage()
}
else
{
- if (dynamic_cast<ComplexFloatVectorImageType*>(m_Image.GetPointer()))
+ if (dynamic_cast<ComplexInt16VectorImageType*>(m_Image.GetPointer()))
+ {
+ return CastImage<ComplexInt16VectorImageType, TOutputImage>();
+ }
+ else if (dynamic_cast<ComplexInt32VectorImageType*>(m_Image.GetPointer()))
+ {
+ return CastImage<ComplexInt32VectorImageType, TOutputImage>();
+ }
+ else if (dynamic_cast<ComplexFloatVectorImageType*>(m_Image.GetPointer()))
{
return CastImage<ComplexFloatVectorImageType, TOutputImage>();
}
@@ -99,6 +108,14 @@ ComplexInputImageParameter::GetImage()
{
return CastImage<ComplexDoubleVectorImageType, TOutputImage>();
}
+ else if (dynamic_cast<ComplexInt16ImageType*>(m_Image.GetPointer()))
+ {
+ return CastImage<ComplexInt16ImageType, TOutputImage>();
+ }
+ else if (dynamic_cast<ComplexInt32ImageType*>(m_Image.GetPointer()))
+ {
+ return CastImage<ComplexInt32ImageType, TOutputImage>();
+ }
else if (dynamic_cast<ComplexFloatImageType*>(m_Image.GetPointer()))
{
return CastImage<ComplexFloatImageType, TOutputImage>();
@@ -119,38 +136,10 @@ ComplexInputImageParameter::GetImage()
template <class TComplexInputImage, class TOutputImage>
TOutputImage*
ComplexInputImageParameter::CastImage()
-{
- itkExceptionMacro("Cast from "<<typeid(TComplexInputImage).name()
- <<" to "<<typeid(TOutputImage).name()<<" not authorized.");
-}
-
-
-template <class TComplexInputImage, class TOutputImage>
-TOutputImage*
-ComplexInputImageParameter::SimpleCastImage()
-{
- TComplexInputImage* realComplexInputImage = dynamic_cast<TComplexInputImage*>(m_Image.GetPointer());
-
- typedef itk::CastImageFilter<TComplexInputImage, TOutputImage> CasterType;
- typename CasterType::Pointer caster = CasterType::New();
-
- caster->SetInput(realComplexInputImage);
- caster->UpdateOutputInformation();
-
- m_Image = caster->GetOutput();
- m_Caster = caster;
-
- return caster->GetOutput();
-}
-
-
-template <class TComplexInputImage, class TOutputImage>
-TOutputImage*
-ComplexInputImageParameter::CastVectorImageFromImage()
{
TComplexInputImage* realComplexInputImage = dynamic_cast<TComplexInputImage*>(m_Image.GetPointer());
- typedef ImageToVectorImageCastFilter<TComplexInputImage, TOutputImage> CasterType;
+ typedef ClampImageFilter<TComplexInputImage, TOutputImage> CasterType;
typename CasterType::Pointer caster = CasterType::New();
caster->SetInput(realComplexInputImage);
@@ -160,6 +149,8 @@ ComplexInputImageParameter::CastVectorImageFromImage()
m_Caster = caster;
return caster->GetOutput();
+ // itkExceptionMacro("Cast from "<<typeid(TComplexInputImage).name()
+ // <<" to "<<typeid(TOutputImage).name()<<" not authorized.");
}
template <class TComplexInputImage>
diff --git a/Modules/Wrappers/ApplicationEngine/include/otbWrapperComplexOutputImageParameter.h b/Modules/Wrappers/ApplicationEngine/include/otbWrapperComplexOutputImageParameter.h
index 371c4d416691d36e3e07ffe50ea69c1580c20284..0613816b47f09f9c38ceafa4ad9fccbedea2582e 100644
--- a/Modules/Wrappers/ApplicationEngine/include/otbWrapperComplexOutputImageParameter.h
+++ b/Modules/Wrappers/ApplicationEngine/include/otbWrapperComplexOutputImageParameter.h
@@ -122,23 +122,18 @@ protected:
template <class TInputVectorImageType>
void SwitchVectorImageWrite();
- //FloatVectorImageType::Pointer m_Image;
ImageBaseType::Pointer m_Image;
std::string m_FileName;
ComplexImagePixelType m_ComplexPixelType;
ComplexImagePixelType m_DefaultComplexPixelType;
- typedef otb::ImageFileWriter<ComplexFloatImageType> ComplexFloatWriterType;
- typedef otb::ImageFileWriter<ComplexDoubleImageType> ComplexDoubleWriterType;
-
-
+ typedef otb::ImageFileWriter<ComplexInt16VectorImageType> ComplexVectorInt16WriterType;
+ typedef otb::ImageFileWriter<ComplexInt32VectorImageType> ComplexVectorInt32WriterType;
typedef otb::ImageFileWriter<ComplexFloatVectorImageType> ComplexVectorFloatWriterType;
typedef otb::ImageFileWriter<ComplexDoubleVectorImageType> ComplexVectorDoubleWriterType;
-
- ComplexFloatWriterType::Pointer m_ComplexFloatWriter;
- ComplexDoubleWriterType::Pointer m_ComplexDoubleWriter;
-
+ ComplexVectorInt16WriterType::Pointer m_ComplexVectorInt16Writer;
+ ComplexVectorInt32WriterType::Pointer m_ComplexVectorInt32Writer;
ComplexVectorFloatWriterType::Pointer m_ComplexVectorFloatWriter;
ComplexVectorDoubleWriterType::Pointer m_ComplexVectorDoubleWriter;
diff --git a/Modules/Wrappers/ApplicationEngine/include/otbWrapperInputImageParameter.h b/Modules/Wrappers/ApplicationEngine/include/otbWrapperInputImageParameter.h
index 6ff36eedeed7f32c1382aa06be580d2904741967..3f83839de104e5bb536c821d9efa2573d13e8890 100644
--- a/Modules/Wrappers/ApplicationEngine/include/otbWrapperInputImageParameter.h
+++ b/Modules/Wrappers/ApplicationEngine/include/otbWrapperInputImageParameter.h
@@ -80,6 +80,16 @@ public:
UInt8RGBImageType* GetUInt8RGBImage();
UInt8RGBAImageType* GetUInt8RGBAImage();
+ // Complex image
+ ComplexInt16ImageType* GetComplexInt16Image();
+ ComplexInt32ImageType* GetComplexInt32Image();
+ ComplexFloatImageType* GetComplexFloatImage();
+ ComplexDoubleImageType* GetComplexDoubleImage();
+
+ ComplexInt16VectorImageType* GetComplexInt16VectorImage();
+ ComplexInt32VectorImageType* GetComplexInt32VectorImage();
+ ComplexFloatVectorImageType* GetComplexFloatVectorImage();
+ ComplexDoubleVectorImageType* GetComplexDoubleVectorImage();
/** Get the input image as templated image type. */
template <class TImageType>
@@ -97,17 +107,6 @@ public:
template <class TInputImage, class TOutputImage>
TOutputImage* CastImage();
- /** Cast an image to an image of the same type
- * Image to Image, VectorImage to VectorImage, RGBAImage to RGBAImage. */
- template <class TInputImage, class TOutputImage>
- TOutputImage* SimpleCastImage();
-
-
- /** Cast an image to a vector image. */
- template <class TInputImage, class TOutputImage>
- TOutputImage* CastVectorImageFromImage();
-
-
bool HasValue() const ITK_OVERRIDE;
void ClearValue() ITK_OVERRIDE;
@@ -145,6 +144,17 @@ protected:
typedef otb::ImageFileReader<UInt8RGBImageType> UInt8RGBReaderType;
typedef otb::ImageFileReader<UInt8RGBAImageType> UInt8RGBAReaderType;
+ // Complex
+ typedef otb::ImageFileReader<ComplexInt16ImageType> ComplexInt16ReaderType;
+ typedef otb::ImageFileReader<ComplexInt32ImageType> ComplexInt32ReaderType;
+ typedef otb::ImageFileReader<ComplexFloatImageType> ComplexFloatReaderType;
+ typedef otb::ImageFileReader<ComplexDoubleImageType> ComplexDoubleReaderType;
+
+ typedef otb::ImageFileReader<ComplexInt16VectorImageType> ComplexInt16VectorReaderType;
+ typedef otb::ImageFileReader<ComplexInt32VectorImageType> ComplexInt32VectorReaderType;
+ typedef otb::ImageFileReader<ComplexFloatVectorImageType> ComplexFloatVectorReaderType;
+ typedef otb::ImageFileReader<ComplexDoubleVectorImageType> ComplexDoubleVectorReaderType;
+
itk::ProcessObject::Pointer m_Reader;
itk::ProcessObject::Pointer m_Caster;
@@ -160,63 +170,6 @@ private:
}; // End class InputImage Parameter
-
-// template specializations of CastImage<> should be declared in header
-// so that the linker knows they exist when building OTB Applications
-
-#define otbDeclareCastImageMacro(InputImageType, OutputImageType) \
- template<> OTBApplicationEngine_EXPORT OutputImageType * \
- InputImageParameter::CastImage<InputImageType , OutputImageType>(); \
-
-#define otbGenericDeclareCastImageMacro(InputImageType, prefix) \
- otbDeclareCastImageMacro(InputImageType, UInt8##prefix##ImageType) \
- otbDeclareCastImageMacro(InputImageType, UInt16##prefix##ImageType) \
- otbDeclareCastImageMacro(InputImageType, Int16##prefix##ImageType) \
- otbDeclareCastImageMacro(InputImageType, UInt32##prefix##ImageType) \
- otbDeclareCastImageMacro(InputImageType, Int32##prefix##ImageType) \
- otbDeclareCastImageMacro(InputImageType, Float##prefix##ImageType) \
- otbDeclareCastImageMacro(InputImageType, Double##prefix##ImageType)
-
-
-/*********************************************************************
-********************** Image -> Image
-**********************************************************************/
-otbGenericDeclareCastImageMacro(UInt8ImageType, )
-otbGenericDeclareCastImageMacro(Int16ImageType, )
-otbGenericDeclareCastImageMacro(UInt16ImageType, )
-otbGenericDeclareCastImageMacro(Int32ImageType, )
-otbGenericDeclareCastImageMacro(UInt32ImageType, )
-otbGenericDeclareCastImageMacro(FloatImageType, )
-otbGenericDeclareCastImageMacro(DoubleImageType, )
-
-
-/*********************************************************************
-********************** VectorImage -> VectorImage
-**********************************************************************/
-otbGenericDeclareCastImageMacro(UInt8VectorImageType, Vector)
-otbGenericDeclareCastImageMacro(Int16VectorImageType, Vector)
-otbGenericDeclareCastImageMacro(UInt16VectorImageType, Vector)
-otbGenericDeclareCastImageMacro(Int32VectorImageType, Vector)
-otbGenericDeclareCastImageMacro(UInt32VectorImageType, Vector)
-otbGenericDeclareCastImageMacro(FloatVectorImageType, Vector)
-otbGenericDeclareCastImageMacro(DoubleVectorImageType, Vector)
-
-
-/*********************************************************************
-********************** Image -> VectorImage
-**********************************************************************/
-otbGenericDeclareCastImageMacro(UInt8ImageType, Vector)
-otbGenericDeclareCastImageMacro(Int16ImageType, Vector)
-otbGenericDeclareCastImageMacro(UInt16ImageType, Vector)
-otbGenericDeclareCastImageMacro(Int32ImageType, Vector)
-otbGenericDeclareCastImageMacro(UInt32ImageType, Vector)
-otbGenericDeclareCastImageMacro(FloatImageType, Vector)
-otbGenericDeclareCastImageMacro(DoubleImageType, Vector)
-
-#undef otbDeclareCastImageMacro
-#undef otbGenericDeclareCastImageMacro
-
-
} // End namespace Wrapper
} // End namespace otb
diff --git a/Modules/Wrappers/ApplicationEngine/include/otbWrapperInputImageParameter.txx b/Modules/Wrappers/ApplicationEngine/include/otbWrapperInputImageParameter.txx
index 9db0e6140868eb635b115f0b46627f956615d178..74e7385133261080cf1e05a831fbac8608f94abe 100644
--- a/Modules/Wrappers/ApplicationEngine/include/otbWrapperInputImageParameter.txx
+++ b/Modules/Wrappers/ApplicationEngine/include/otbWrapperInputImageParameter.txx
@@ -24,8 +24,7 @@
#include "otbWrapperInputImageParameter.h"
#include "itkUnaryFunctorImageFilter.h"
-#include "itkCastImageFilter.h"
-#include "otbImageToVectorImageCastFilter.h"
+#include "otbClampImageFilter.h"
namespace otb
{
@@ -138,6 +137,22 @@ InputImageParameter::GetImage()
{
return CastImage<DoubleImageType, TImageType> ();
}
+ else if (dynamic_cast<ComplexInt16ImageType*>(m_Image.GetPointer()))
+ {
+ return CastImage<ComplexInt16ImageType, TImageType>();
+ }
+ else if (dynamic_cast<ComplexInt32ImageType*>(m_Image.GetPointer()))
+ {
+ return CastImage<ComplexInt32ImageType, TImageType>();
+ }
+ else if (dynamic_cast<ComplexFloatImageType*>(m_Image.GetPointer()))
+ {
+ return CastImage<ComplexFloatImageType, TImageType>();
+ }
+ else if (dynamic_cast<ComplexDoubleImageType*>(m_Image.GetPointer()))
+ {
+ return CastImage<ComplexDoubleImageType, TImageType>();
+ }
else if (dynamic_cast<UInt8VectorImageType*> (m_Image.GetPointer()))
{
return CastImage<UInt8VectorImageType, TImageType> ();
@@ -174,6 +189,22 @@ InputImageParameter::GetImage()
{
return CastImage<UInt8RGBImageType, TImageType> ();
}
+ else if (dynamic_cast<ComplexInt16VectorImageType*>(m_Image.GetPointer()))
+ {
+ return CastImage<ComplexInt16VectorImageType, TImageType>();
+ }
+ else if (dynamic_cast<ComplexInt32VectorImageType*>(m_Image.GetPointer()))
+ {
+ return CastImage<ComplexInt32VectorImageType, TImageType>();
+ }
+ else if (dynamic_cast<ComplexFloatVectorImageType*>(m_Image.GetPointer()))
+ {
+ return CastImage<ComplexFloatVectorImageType, TImageType>();
+ }
+ else if (dynamic_cast<ComplexDoubleVectorImageType*>(m_Image.GetPointer()))
+ {
+ return CastImage<ComplexDoubleVectorImageType, TImageType>();
+ }
else
{
#if INPUT_IMAGE_PARAMETER_GET_IMAGE_EXCEPTION
@@ -190,14 +221,6 @@ InputImageParameter::GetImage()
template <class TInputImage, class TOutputImage>
TOutputImage*
InputImageParameter::CastImage()
-{
- itkExceptionMacro("Cast from "<<typeid(TInputImage).name()<<" to "<<typeid(TOutputImage).name()<<" not authorized.");
-}
-
-
-template <class TInputImage, class TOutputImage>
-TOutputImage*
-InputImageParameter::SimpleCastImage()
{
if ( dynamic_cast<TOutputImage*> (m_Image.GetPointer()) )
{
@@ -207,7 +230,7 @@ InputImageParameter::SimpleCastImage()
{
TInputImage* realInputImage = dynamic_cast<TInputImage*>(m_Image.GetPointer());
- typedef itk::CastImageFilter<TInputImage, TOutputImage> CasterType;
+ typedef ClampImageFilter<TInputImage, TOutputImage> CasterType;
typename CasterType::Pointer caster = CasterType::New();
caster->SetInput(realInputImage);
@@ -217,29 +240,10 @@ InputImageParameter::SimpleCastImage()
m_Caster = caster;
return caster->GetOutput();
- }
+ }
+ // itkExceptionMacro("Cast from "<<typeid(TInputImage).name()<<" to "<<typeid(TOutputImage).name()<<" not authorized.");
}
-
-template <class TInputImage, class TOutputImage>
-TOutputImage*
-InputImageParameter::CastVectorImageFromImage()
-{
- TInputImage* realInputImage = dynamic_cast<TInputImage*>(m_Image.GetPointer());
-
- typedef ImageToVectorImageCastFilter<TInputImage, TOutputImage> CasterType;
- typename CasterType::Pointer caster = CasterType::New();
-
- caster->SetInput(realInputImage);
- caster->UpdateOutputInformation();
-
- m_Image = caster->GetOutput();
- m_Caster = caster;
-
- return caster->GetOutput();
-}
-
-
template <class TInputImage>
void
InputImageParameter::SetImage(TInputImage* image)
diff --git a/Modules/Wrappers/ApplicationEngine/include/otbWrapperOutputImageParameter.h b/Modules/Wrappers/ApplicationEngine/include/otbWrapperOutputImageParameter.h
index b420299ff6b707f8ccbed39577b488684e527fae..fd0c392b706d11977caa60031c601b046860210c 100644
--- a/Modules/Wrappers/ApplicationEngine/include/otbWrapperOutputImageParameter.h
+++ b/Modules/Wrappers/ApplicationEngine/include/otbWrapperOutputImageParameter.h
@@ -119,9 +119,6 @@ protected:
/** Destructor */
~OutputImageParameter() ITK_OVERRIDE;
- template <class TInputImageType>
- void SwitchImageWrite();
-
template <class TInputVectorImageType>
void SwitchVectorImageWrite();
@@ -137,14 +134,6 @@ protected:
ImagePixelType m_PixelType;
ImagePixelType m_DefaultPixelType;
- typedef otb::ImageFileWriter<UInt8ImageType> UInt8WriterType;
- typedef otb::ImageFileWriter<Int16ImageType> Int16WriterType;
- typedef otb::ImageFileWriter<UInt16ImageType> UInt16WriterType;
- typedef otb::ImageFileWriter<Int32ImageType> Int32WriterType;
- typedef otb::ImageFileWriter<UInt32ImageType> UInt32WriterType;
- typedef otb::ImageFileWriter<FloatImageType> FloatWriterType;
- typedef otb::ImageFileWriter<DoubleImageType> DoubleWriterType;
-
typedef otb::ImageFileWriter<UInt8VectorImageType> VectorUInt8WriterType;
typedef otb::ImageFileWriter<Int16VectorImageType> VectorInt16WriterType;
typedef otb::ImageFileWriter<UInt16VectorImageType> VectorUInt16WriterType;
@@ -156,13 +145,10 @@ protected:
typedef otb::ImageFileWriter<UInt8RGBAImageType> RGBAUInt8WriterType;
typedef otb::ImageFileWriter<UInt8RGBImageType> RGBUInt8WriterType;
- UInt8WriterType::Pointer m_UInt8Writer;
- Int16WriterType::Pointer m_Int16Writer;
- UInt16WriterType::Pointer m_UInt16Writer;
- Int32WriterType::Pointer m_Int32Writer;
- UInt32WriterType::Pointer m_UInt32Writer;
- FloatWriterType::Pointer m_FloatWriter;
- DoubleWriterType::Pointer m_DoubleWriter;
+ typedef otb::ImageFileWriter<ComplexInt16VectorImageType> ComplexVectorInt16WriterType;
+ typedef otb::ImageFileWriter<ComplexInt32VectorImageType> ComplexVectorInt32WriterType;
+ typedef otb::ImageFileWriter<ComplexFloatVectorImageType> ComplexVectorFloatWriterType;
+ typedef otb::ImageFileWriter<ComplexDoubleVectorImageType> ComplexVectorDoubleWriterType;
VectorUInt8WriterType::Pointer m_VectorUInt8Writer;
VectorInt16WriterType::Pointer m_VectorInt16Writer;
@@ -175,6 +161,11 @@ protected:
RGBUInt8WriterType::Pointer m_RGBUInt8Writer;
RGBAUInt8WriterType::Pointer m_RGBAUInt8Writer;
+ ComplexVectorInt16WriterType::Pointer m_ComplexVectorInt16Writer;
+ ComplexVectorInt32WriterType::Pointer m_ComplexVectorInt32Writer;
+ ComplexVectorFloatWriterType::Pointer m_ComplexVectorFloatWriter;
+ ComplexVectorDoubleWriterType::Pointer m_ComplexVectorDoubleWriter;
+
private:
OutputImageParameter(const Parameter &); //purposely not implemented
void operator =(const Parameter&); //purposely not implemented
diff --git a/Modules/Wrappers/ApplicationEngine/include/otbWrapperTypes.h b/Modules/Wrappers/ApplicationEngine/include/otbWrapperTypes.h
index 86fc40fa9cbe4da613d8dfbb11aa3a8e969e2630..a27e22508403dc4fed5069571f16991ea9a07310 100644
--- a/Modules/Wrappers/ApplicationEngine/include/otbWrapperTypes.h
+++ b/Modules/Wrappers/ApplicationEngine/include/otbWrapperTypes.h
@@ -78,10 +78,16 @@ typedef enum
ImagePixelType_uint32,
ImagePixelType_float,
ImagePixelType_double,
+ ImagePixelType_cint16,
+ ImagePixelType_cint32,
+ ImagePixelType_cfloat,
+ ImagePixelType_cdouble,
} ImagePixelType;
typedef enum
{
+ ComplexImagePixelType_int16,
+ ComplexImagePixelType_int32,
ComplexImagePixelType_float,
ComplexImagePixelType_double,
} ComplexImagePixelType;
@@ -120,13 +126,19 @@ typedef otb::VectorImage<double> DoubleVectorImageType;
typedef otb::Image< itk::RGBPixel<unsigned char> > UInt8RGBImageType;
typedef otb::Image< itk::RGBAPixel<unsigned char> > UInt8RGBAImageType;
+typedef std::complex<short> Int16ComplexPixelType;
+typedef std::complex<int> Int32ComplexPixelType;
typedef std::complex<float> FloatComplexPixelType;
typedef std::complex<double> DoubleComplexPixelType;
-// Complex Image Type (first : double and float)
+// Complex Image Type
+typedef otb::Image< Int16ComplexPixelType, 2 > ComplexInt16ImageType;
+typedef otb::Image< Int32ComplexPixelType, 2 > ComplexInt32ImageType;
typedef otb::Image< FloatComplexPixelType, 2 > ComplexFloatImageType;
typedef otb::Image< DoubleComplexPixelType, 2 > ComplexDoubleImageType;
+typedef otb::VectorImage< Int16ComplexPixelType, 2 > ComplexInt16VectorImageType;
+typedef otb::VectorImage< Int32ComplexPixelType, 2 > ComplexInt32VectorImageType;
typedef otb::VectorImage<FloatComplexPixelType, 2 > ComplexFloatVectorImageType;
typedef otb::VectorImage< DoubleComplexPixelType, 2 > ComplexDoubleVectorImageType;
diff --git a/Modules/Wrappers/ApplicationEngine/src/CMakeLists.txt b/Modules/Wrappers/ApplicationEngine/src/CMakeLists.txt
index 90853b7ede3c748b8e41f16c1b56fee904aa2d5d..9c0ec07d803e640a5fd67bf805e43e93bd985ac2 100644
--- a/Modules/Wrappers/ApplicationEngine/src/CMakeLists.txt
+++ b/Modules/Wrappers/ApplicationEngine/src/CMakeLists.txt
@@ -31,13 +31,6 @@ set( OTBApplicationEngine_SRC
otbWrapperInputFilenameListParameter.cxx
otbWrapperOutputImageParameter.cxx
otbWrapperInputImageParameter.cxx
- otbWrapperInputImageParameterUInt8.cxx
- otbWrapperInputImageParameterInt16.cxx
- otbWrapperInputImageParameterUInt16.cxx
- otbWrapperInputImageParameterInt32.cxx
- otbWrapperInputImageParameterUInt32.cxx
- otbWrapperInputImageParameterFloat.cxx
- otbWrapperInputImageParameterDouble.cxx
otbWrapperParameterKey.cxx
otbWrapperDocExampleStructure.cxx
otbWrapperInputVectorDataParameter.cxx
diff --git a/Modules/Wrappers/ApplicationEngine/src/otbWrapperComplexInputImageParameter.cxx b/Modules/Wrappers/ApplicationEngine/src/otbWrapperComplexInputImageParameter.cxx
index 6c59ad4c83753feeacf012655642eba680586279..22629f407458a925afa397824fa678456a9878d6 100644
--- a/Modules/Wrappers/ApplicationEngine/src/otbWrapperComplexInputImageParameter.cxx
+++ b/Modules/Wrappers/ApplicationEngine/src/otbWrapperComplexInputImageParameter.cxx
@@ -73,14 +73,18 @@ ComplexInputImageParameter::GetImage()
return this->GetImage< image##Type > (); \
}
+otbGetImageMacro(ComplexInt16Image);
+otbGetImageMacro(ComplexInt32Image);
otbGetImageMacro(ComplexFloatImage);
otbGetImageMacro(ComplexDoubleImage);
+otbGetImageMacro(ComplexInt16VectorImage);
+otbGetImageMacro(ComplexInt32VectorImage);
otbGetImageMacro(ComplexFloatVectorImage);
otbGetImageMacro(ComplexDoubleVectorImage);
-#define otbCastImageMacro(ComplexInputImageType, OutputImageType, theMethod) \
+/*#define otbCastImageMacro(ComplexInputImageType, OutputImageType, theMethod) \
template<> OutputImageType * \
ComplexInputImageParameter::CastImage<ComplexInputImageType , OutputImageType>() \
{ \
@@ -89,22 +93,22 @@ otbGetImageMacro(ComplexDoubleVectorImage);
#define otbGenericCastImageMacro(ComplexInputImageType, theMethod, prefix) \
otbCastImageMacro(ComplexInputImageType, ComplexFloat##prefix##ImageType, theMethod) \
- otbCastImageMacro(ComplexInputImageType, ComplexDouble##prefix##ImageType, theMethod)
+ otbCastImageMacro(ComplexInputImageType, ComplexDouble##prefix##ImageType, theMethod)*/
-/*********************************************************************
+/********************************************************************
********************** Image -> Image
-**********************************************************************/
+*********************************************************************/
- otbGenericCastImageMacro(ComplexFloatImageType, SimpleCastImage, )
- otbGenericCastImageMacro(ComplexDoubleImageType, SimpleCastImage, )
+// otbGenericCastImageMacro(ComplexFloatImageType, SimpleCastImage, )
+// otbGenericCastImageMacro(ComplexDoubleImageType, SimpleCastImage, )
/*********************************************************************
********************** VectorImage -> VectorImage
**********************************************************************/
- otbGenericCastImageMacro(ComplexFloatVectorImageType, SimpleCastImage, Vector)
- otbGenericCastImageMacro(ComplexDoubleVectorImageType, SimpleCastImage, Vector)
+// otbGenericCastImageMacro(ComplexFloatVectorImageType, SimpleCastImage, Vector)
+// otbGenericCastImageMacro(ComplexDoubleVectorImageType, SimpleCastImage, Vector)
void
ComplexInputImageParameter::SetImage(ComplexFloatVectorImageType* image)
@@ -133,6 +137,38 @@ ComplexInputImageParameter::ClearValue()
m_UseFilename = true;
}
+/* Support for ComplexInputImageParameter. This has been done to support
+the macro otbGetParameterImageMacro of otbWrapperApplication.h */
+#define otbGetFalseImageMacro(image) \
+ image##Type * \
+ ComplexInputImageParameter::Get##image () \
+ { \
+ return nullptr; \
+ }
+
+otbGetFalseImageMacro(DoubleImage);
+otbGetFalseImageMacro(DoubleVectorImage);
+
+otbGetFalseImageMacro(FloatImage);
+otbGetFalseImageMacro(FloatVectorImage);
+
+otbGetFalseImageMacro(Int16Image);
+otbGetFalseImageMacro(Int16VectorImage);
+
+otbGetFalseImageMacro(UInt16Image);
+otbGetFalseImageMacro(UInt16VectorImage);
+
+otbGetFalseImageMacro(Int32Image);
+otbGetFalseImageMacro(Int32VectorImage);
+
+otbGetFalseImageMacro(UInt32Image);
+otbGetFalseImageMacro(UInt32VectorImage);
+
+otbGetFalseImageMacro(UInt8Image);
+otbGetFalseImageMacro(UInt8VectorImage);
+
+otbGetFalseImageMacro(UInt8RGBImage);
+otbGetFalseImageMacro(UInt8RGBAImage);
}
}
diff --git a/Modules/Wrappers/ApplicationEngine/src/otbWrapperComplexOutputImageParameter.cxx b/Modules/Wrappers/ApplicationEngine/src/otbWrapperComplexOutputImageParameter.cxx
index 64ef3657181d767341ce804d642374d6ed7b6a27..6d86118c4591da5f17e8a932356fbede5d2cdc3d 100644
--- a/Modules/Wrappers/ApplicationEngine/src/otbWrapperComplexOutputImageParameter.cxx
+++ b/Modules/Wrappers/ApplicationEngine/src/otbWrapperComplexOutputImageParameter.cxx
@@ -20,8 +20,7 @@
#include "otbWrapperComplexOutputImageParameter.h"
#include "itkUnaryFunctorImageFilter.h"
-#include "itkCastImageFilter.h"
-#include "itkVectorCastImageFilter.h"
+#include "otbClampImageFilter.h"
#ifdef OTB_USE_MPI
@@ -59,6 +58,16 @@ ComplexOutputImageParameter::ConvertPixelTypeToString(ComplexImagePixelType type
std::string ret;
switch(type)
{
+ case ComplexImagePixelType_int16:
+ {
+ ret = "cint16";
+ break;
+ }
+ case ComplexImagePixelType_int32:
+ {
+ ret = "cint32";
+ break;
+ }
case ComplexImagePixelType_float:
{
ret = "cfloat";
@@ -76,7 +85,11 @@ ComplexOutputImageParameter::ConvertPixelTypeToString(ComplexImagePixelType type
bool
ComplexOutputImageParameter::ConvertStringToPixelType(const std::string &value, ComplexImagePixelType &type)
{
- if (value == "cfloat")
+ if (value == "cint16")
+ type = ComplexImagePixelType_int16;
+ if (value == "cint32")
+ type = ComplexImagePixelType_int32;
+ else if (value == "cfloat")
type = ComplexImagePixelType_float;
else if (value == "cdouble")
type = ComplexImagePixelType_double;
@@ -87,16 +100,15 @@ ComplexOutputImageParameter::ConvertStringToPixelType(const std::string &value,
void ComplexOutputImageParameter::InitializeWriters()
{
- m_ComplexFloatWriter = ComplexFloatWriterType::New();
- m_ComplexDoubleWriter = ComplexDoubleWriterType::New();
-
+ m_ComplexVectorInt16Writer = ComplexVectorInt16WriterType::New();
+ m_ComplexVectorInt32Writer = ComplexVectorInt32WriterType::New();
m_ComplexVectorFloatWriter = ComplexVectorFloatWriterType::New();
m_ComplexVectorDoubleWriter = ComplexVectorDoubleWriterType::New();
}
template <typename TInput, typename TOutput> void CastAndWriteImage(itk::ImageBase<2> * in, otb::ImageFileWriter<TOutput> * writer, const std::string & filename, const unsigned int & ramValue)
{
- typedef itk::CastImageFilter<TInput, TOutput> ClampFilterType;
+ typedef ClampImageFilter<TInput, TOutput> ClampFilterType;
typename ClampFilterType::Pointer clampFilter = ClampFilterType::New();
clampFilter->SetInput( dynamic_cast<TInput*>(in));
@@ -157,46 +169,58 @@ ComplexOutputImageParameter::SwitchImageWrite()
{
switch(m_ComplexPixelType )
{
- case ComplexImagePixelType_float:
+ case ComplexImagePixelType_int16:
{
- CastAndWriteImage<TInputImageType,ComplexFloatImageType>(m_Image,m_ComplexFloatWriter,m_FileName,m_RAMValue);
+ CastAndWriteImage<TInputImageType,ComplexInt16VectorImageType>(
+ m_Image ,
+ m_ComplexVectorInt16Writer ,
+ m_FileName ,
+ m_RAMValue );
break;
}
- case ComplexImagePixelType_double:
+ case ComplexImagePixelType_int32:
{
- CastAndWriteImage<TInputImageType,ComplexDoubleImageType>(m_Image,m_ComplexDoubleWriter,m_FileName,m_RAMValue);
+ CastAndWriteImage<TInputImageType,ComplexInt32VectorImageType>(
+ m_Image ,
+ m_ComplexVectorInt32Writer ,
+ m_FileName ,
+ m_RAMValue );
break;
}
- }
-}
-
-
-template <class TInputVectorImageType>
-void
-ComplexOutputImageParameter::SwitchVectorImageWrite()
- {
- switch(m_ComplexPixelType )
- {
case ComplexImagePixelType_float:
{
- CastAndWriteImage<TInputVectorImageType,ComplexFloatVectorImageType>(m_Image,m_ComplexVectorFloatWriter,m_FileName,m_RAMValue);
+ CastAndWriteImage<TInputImageType,ComplexFloatVectorImageType>(
+ m_Image ,
+ m_ComplexVectorFloatWriter ,
+ m_FileName ,
+ m_RAMValue );
break;
}
case ComplexImagePixelType_double:
{
- CastAndWriteImage<TInputVectorImageType,ComplexDoubleVectorImageType>(m_Image,m_ComplexVectorDoubleWriter,m_FileName,m_RAMValue);
+ CastAndWriteImage<TInputImageType,ComplexDoubleVectorImageType>(
+ m_Image ,
+ m_ComplexVectorDoubleWriter ,
+ m_FileName ,
+ m_RAMValue );
break;
}
}
- }
-
+}
void
ComplexOutputImageParameter::Write()
{
m_Image->UpdateOutputInformation();
-
- if (dynamic_cast<ComplexFloatImageType*>(m_Image.GetPointer()))
+ if (dynamic_cast<ComplexInt16ImageType*>(m_Image.GetPointer()))
+ {
+ SwitchImageWrite<ComplexInt16ImageType>();
+ }
+ else if (dynamic_cast<ComplexInt16ImageType*>(m_Image.GetPointer()))
+ {
+ SwitchImageWrite<ComplexInt16ImageType>();
+ }
+ else if (dynamic_cast<ComplexFloatImageType*>(m_Image.GetPointer()))
{
SwitchImageWrite<ComplexFloatImageType>();
}
@@ -204,13 +228,21 @@ ComplexOutputImageParameter::Write()
{
SwitchImageWrite<ComplexDoubleImageType>();
}
+ else if (dynamic_cast<ComplexInt16VectorImageType*>(m_Image.GetPointer()))
+ {
+ SwitchImageWrite<ComplexInt16VectorImageType>();
+ }
+ else if (dynamic_cast<ComplexInt32VectorImageType*>(m_Image.GetPointer()))
+ {
+ SwitchImageWrite<ComplexInt32VectorImageType>();
+ }
else if (dynamic_cast<ComplexFloatVectorImageType*>(m_Image.GetPointer()))
{
- SwitchVectorImageWrite<ComplexFloatVectorImageType>();
+ SwitchImageWrite<ComplexFloatVectorImageType>();
}
else if (dynamic_cast<ComplexDoubleVectorImageType*>(m_Image.GetPointer()))
{
- SwitchVectorImageWrite<ComplexDoubleVectorImageType>();
+ SwitchImageWrite<ComplexDoubleVectorImageType>();
}
else
{
@@ -221,33 +253,25 @@ ComplexOutputImageParameter::Write()
itk::ProcessObject*
ComplexOutputImageParameter::GetWriter()
{
- int type = 0;
- // 0 : image
- // 1 : VectorImage
-
- if ( dynamic_cast<ComplexFloatVectorImageType*>( m_Image.GetPointer()) ||
- dynamic_cast<ComplexDoubleVectorImageType*>(m_Image.GetPointer()))
- {
- type = 1;
- }
-
itk::ProcessObject* writer = ITK_NULLPTR;
switch ( GetComplexPixelType() )
{
+ case ComplexImagePixelType_int16:
+ {
+ writer = m_ComplexVectorInt16Writer;
+ }
+ case ComplexImagePixelType_int32:
+ {
+ writer = m_ComplexVectorInt32Writer;
+ }
case ComplexImagePixelType_float:
{
- if( type == 1 )
writer = m_ComplexVectorFloatWriter;
- else
- writer = m_ComplexFloatWriter;
break;
}
case ComplexImagePixelType_double:
{
- if( type == 1 )
writer = m_ComplexVectorDoubleWriter;
- else
- writer = m_ComplexDoubleWriter;
break;
}
}
diff --git a/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameter.cxx b/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameter.cxx
index 166ab2956ad5fc46a6bd1df6a1298e3066b4f23f..fe226ef2ffbd7ccb6f588e3926642181c31819ea 100644
--- a/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameter.cxx
+++ b/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameter.cxx
@@ -70,6 +70,17 @@ InputImageParameter::GetImage()
otbGetImageMacro(UInt8RGBImage);
otbGetImageMacro(UInt8RGBAImage);
+otbGetImageAndVectorImageMacro(UInt8);
+otbGetImageAndVectorImageMacro(UInt16);
+otbGetImageAndVectorImageMacro(UInt32);
+otbGetImageAndVectorImageMacro(Int16);
+otbGetImageAndVectorImageMacro(Int32);
+otbGetImageAndVectorImageMacro(Float);
+otbGetImageAndVectorImageMacro(Double);
+otbGetImageAndVectorImageMacro(ComplexInt16);
+otbGetImageAndVectorImageMacro(ComplexInt32);
+otbGetImageAndVectorImageMacro(ComplexFloat);
+otbGetImageAndVectorImageMacro(ComplexDouble);
void
diff --git a/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterDouble.cxx b/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterDouble.cxx
deleted file mode 100644
index e6a07bc294ff440924d5efa5f42f5634cffd1081..0000000000000000000000000000000000000000
--- a/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterDouble.cxx
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2005-2017 Centre National d'Etudes Spatiales (CNES)
- *
- * This file is part of Orfeo Toolbox
- *
- * https://www.orfeo-toolbox.org/
- *
- * 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
- *
- * 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.
- */
-
-#include "otbWrapperInputImageParameter.h"
-#include "itksys/SystemTools.hxx"
-#include "otbWrapperTypes.h"
-#include "otbWrapperInputImageParameterMacros.h"
-#include "otb_boost_string_header.h"
-
-namespace otb
-{
-namespace Wrapper
-{
-otbGetImageMacro(DoubleImage);
-otbGetImageMacro(DoubleVectorImage)
-otbGenericCastImageMacro(DoubleImageType, SimpleCastImage, )
-otbGenericCastImageMacro(DoubleVectorImageType, SimpleCastImage, Vector)
-otbGenericCastImageMacro(DoubleImageType, CastVectorImageFromImage, Vector)
-}
-}
diff --git a/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterFloat.cxx b/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterFloat.cxx
deleted file mode 100644
index fda1544048718215b7dd7757d37baeee12fbb6af..0000000000000000000000000000000000000000
--- a/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterFloat.cxx
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2005-2017 Centre National d'Etudes Spatiales (CNES)
- *
- * This file is part of Orfeo Toolbox
- *
- * https://www.orfeo-toolbox.org/
- *
- * 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
- *
- * 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.
- */
-
-#include "otbWrapperInputImageParameter.h"
-#include "otbWrapperInputImageParameterMacros.h"
-#include "itksys/SystemTools.hxx"
-#include "otbWrapperTypes.h"
-#include "otb_boost_string_header.h"
-
-namespace otb
-{
-namespace Wrapper
-{
-otbGetImageMacro(FloatImage);
-otbGetImageMacro(FloatVectorImage)
-otbGenericCastImageMacro(FloatImageType, SimpleCastImage, )
-otbGenericCastImageMacro(FloatVectorImageType, SimpleCastImage, Vector)
-otbGenericCastImageMacro(FloatImageType, CastVectorImageFromImage, Vector)
-}
-}
diff --git a/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterInt16.cxx b/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterInt16.cxx
deleted file mode 100644
index 22f617fce468169f23ed64db00e695902430f127..0000000000000000000000000000000000000000
--- a/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterInt16.cxx
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2005-2017 Centre National d'Etudes Spatiales (CNES)
- *
- * This file is part of Orfeo Toolbox
- *
- * https://www.orfeo-toolbox.org/
- *
- * 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
- *
- * 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.
- */
-
-#include "otbWrapperInputImageParameter.h"
-#include "itksys/SystemTools.hxx"
-#include "otbWrapperTypes.h"
-#include "otbWrapperInputImageParameterMacros.h"
-#include "otb_boost_string_header.h"
-
-namespace otb
-{
-namespace Wrapper
-{
-otbGetImageMacro(Int16Image);
-otbGetImageMacro(Int16VectorImage)
-otbGenericCastImageMacro(Int16ImageType, SimpleCastImage, )
-otbGenericCastImageMacro(Int16VectorImageType, SimpleCastImage, Vector)
-otbGenericCastImageMacro(Int16ImageType, CastVectorImageFromImage, Vector)
-}
-}
diff --git a/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterInt32.cxx b/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterInt32.cxx
deleted file mode 100644
index ab59107c9e357068ef461bd3b975ec3e16d524b2..0000000000000000000000000000000000000000
--- a/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterInt32.cxx
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2005-2017 Centre National d'Etudes Spatiales (CNES)
- *
- * This file is part of Orfeo Toolbox
- *
- * https://www.orfeo-toolbox.org/
- *
- * 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
- *
- * 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.
- */
-
-#include "otbWrapperInputImageParameter.h"
-#include "itksys/SystemTools.hxx"
-#include "otbWrapperTypes.h"
-#include "otbWrapperInputImageParameterMacros.h"
-#include "otb_boost_string_header.h"
-
-namespace otb
-{
-namespace Wrapper
-{
-otbGetImageMacro(Int32Image);
-otbGetImageMacro(Int32VectorImage)
-otbGenericCastImageMacro(Int32ImageType, SimpleCastImage, )
-otbGenericCastImageMacro(Int32VectorImageType, SimpleCastImage, Vector)
-otbGenericCastImageMacro(Int32ImageType, CastVectorImageFromImage, Vector)
-}
-}
diff --git a/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterMacros.h b/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterMacros.h
index 4cc9d4d7ae998e8aec82b0856b8ac6e44dcad377..2f1a7915b4f9b1491fde3ba0f9d77fc004e9e021 100644
--- a/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterMacros.h
+++ b/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterMacros.h
@@ -28,22 +28,9 @@
return this->GetImage< image##Type > (); \
}
-
-#define otbCastImageMacro(InputImageType, OutputImageType, theMethod) \
- template<> OutputImageType * \
- InputImageParameter::CastImage<InputImageType , OutputImageType>() \
- { \
- return this->theMethod<InputImageType , OutputImageType>(); \
- }
-
-#define otbGenericCastImageMacro(InputImageType, theMethod, prefix) \
- otbCastImageMacro(InputImageType, UInt8##prefix##ImageType, theMethod) \
- otbCastImageMacro(InputImageType, UInt16##prefix##ImageType, theMethod) \
- otbCastImageMacro(InputImageType, Int16##prefix##ImageType, theMethod) \
- otbCastImageMacro(InputImageType, UInt32##prefix##ImageType, theMethod) \
- otbCastImageMacro(InputImageType, Int32##prefix##ImageType, theMethod) \
- otbCastImageMacro(InputImageType, Float##prefix##ImageType, theMethod) \
- otbCastImageMacro(InputImageType, Double##prefix##ImageType, theMethod)
+#define otbGetImageAndVectorImageMacro(type) \
+ otbGetImageMacro(type##Image); \
+ otbGetImageMacro(type##VectorImage);
#endif
diff --git a/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterUInt16.cxx b/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterUInt16.cxx
deleted file mode 100644
index c63857e57bd7bfd30fb466f74e9e36bcc1ddeea7..0000000000000000000000000000000000000000
--- a/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterUInt16.cxx
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2005-2017 Centre National d'Etudes Spatiales (CNES)
- *
- * This file is part of Orfeo Toolbox
- *
- * https://www.orfeo-toolbox.org/
- *
- * 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
- *
- * 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.
- */
-
-#include "otbWrapperInputImageParameter.h"
-#include "itksys/SystemTools.hxx"
-#include "otbWrapperTypes.h"
-#include "otbWrapperInputImageParameterMacros.h"
-#include "otb_boost_string_header.h"
-
-namespace otb
-{
-namespace Wrapper
-{
-otbGetImageMacro(UInt16Image);
-otbGetImageMacro(UInt16VectorImage)
-otbGenericCastImageMacro(UInt16ImageType, SimpleCastImage, )
-otbGenericCastImageMacro(UInt16VectorImageType, SimpleCastImage, Vector)
-otbGenericCastImageMacro(UInt16ImageType, CastVectorImageFromImage, Vector)
-}
-}
diff --git a/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterUInt32.cxx b/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterUInt32.cxx
deleted file mode 100644
index 50fdf0adf18aefe30b7b1efac80f2b5028619565..0000000000000000000000000000000000000000
--- a/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterUInt32.cxx
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2005-2017 Centre National d'Etudes Spatiales (CNES)
- *
- * This file is part of Orfeo Toolbox
- *
- * https://www.orfeo-toolbox.org/
- *
- * 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
- *
- * 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.
- */
-
-#include "otbWrapperInputImageParameter.h"
-#include "itksys/SystemTools.hxx"
-#include "otbWrapperTypes.h"
-#include "otbWrapperInputImageParameterMacros.h"
-#include "otb_boost_string_header.h"
-
-namespace otb
-{
-namespace Wrapper
-{
-otbGetImageMacro(UInt32Image);
-otbGetImageMacro(UInt32VectorImage)
-otbGenericCastImageMacro(UInt32ImageType, SimpleCastImage, )
-otbGenericCastImageMacro(UInt32VectorImageType, SimpleCastImage, Vector)
-otbGenericCastImageMacro(UInt32ImageType, CastVectorImageFromImage, Vector)
-}
-}
diff --git a/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterUInt8.cxx b/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterUInt8.cxx
deleted file mode 100644
index d388456e4267e8ba0753d54ff05439657d2c2e13..0000000000000000000000000000000000000000
--- a/Modules/Wrappers/ApplicationEngine/src/otbWrapperInputImageParameterUInt8.cxx
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (C) 2005-2017 Centre National d'Etudes Spatiales (CNES)
- *
- * This file is part of Orfeo Toolbox
- *
- * https://www.orfeo-toolbox.org/
- *
- * 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
- *
- * 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.
- */
-
-#include "otbWrapperInputImageParameter.h"
-#include "itksys/SystemTools.hxx"
-#include "otbWrapperTypes.h"
-#include "otbWrapperInputImageParameterMacros.h"
-#include "otb_boost_string_header.h"
-
-namespace otb
-{
-namespace Wrapper
-{
-otbGetImageMacro(UInt8Image);
-otbGetImageMacro(UInt8VectorImage)
-otbGenericCastImageMacro(UInt8ImageType, SimpleCastImage, )
-otbGenericCastImageMacro(UInt8VectorImageType, SimpleCastImage, Vector)
-otbGenericCastImageMacro(UInt8ImageType, CastVectorImageFromImage, Vector)
-}
-}
diff --git a/Modules/Wrappers/ApplicationEngine/src/otbWrapperOutputImageParameter.cxx b/Modules/Wrappers/ApplicationEngine/src/otbWrapperOutputImageParameter.cxx
index 2790bdce255aa5d0e8a3f92ab625e274ce48bf10..d0dd6678797767b6f50d61ba0a9667173d1a77e1 100644
--- a/Modules/Wrappers/ApplicationEngine/src/otbWrapperOutputImageParameter.cxx
+++ b/Modules/Wrappers/ApplicationEngine/src/otbWrapperOutputImageParameter.cxx
@@ -20,7 +20,6 @@
#include "otbWrapperOutputImageParameter.h"
#include "otbClampImageFilter.h"
-#include "otbClampVectorImageFilter.h"
#include "otbImageIOFactory.h"
#include "itksys/SystemTools.hxx"
@@ -94,6 +93,26 @@ std::string OutputImageParameter::ConvertPixelTypeToString(ImagePixelType type)
ret = "double";
break;
}
+ case ImagePixelType_cint16:
+ {
+ ret = "cint16";
+ break;
+ }
+ case ImagePixelType_cint32:
+ {
+ ret = "cint32";
+ break;
+ }
+ case ImagePixelType_cfloat:
+ {
+ ret = "cfloat";
+ break;
+ }
+ case ImagePixelType_cdouble:
+ {
+ ret = "cdouble";
+ break;
+ }
}
return ret;
}
@@ -115,6 +134,14 @@ OutputImageParameter::ConvertStringToPixelType(const std::string &value, ImagePi
type = ImagePixelType_float;
else if (value == "double")
type = ImagePixelType_double;
+ else if (value == "cint16")
+ type = ImagePixelType_cint16;
+ else if (value == "cint32")
+ type = ImagePixelType_cint32;
+ else if (value == "cfloat")
+ type = ImagePixelType_cfloat;
+ else if (value == "cdouble")
+ type = ImagePixelType_cdouble;
else
return false;
return true;
@@ -122,14 +149,6 @@ OutputImageParameter::ConvertStringToPixelType(const std::string &value, ImagePi
void OutputImageParameter::InitializeWriters()
{
- m_UInt8Writer = UInt8WriterType::New();
- m_Int16Writer = Int16WriterType::New();
- m_UInt16Writer = UInt16WriterType::New();
- m_Int32Writer = Int32WriterType::New();
- m_UInt32Writer = UInt32WriterType::New();
- m_FloatWriter = FloatWriterType::New();
- m_DoubleWriter = DoubleWriterType::New();
-
m_VectorUInt8Writer = VectorUInt8WriterType::New();
m_VectorInt16Writer = VectorInt16WriterType::New();
m_VectorUInt16Writer = VectorUInt16WriterType::New();
@@ -140,13 +159,24 @@ void OutputImageParameter::InitializeWriters()
m_RGBUInt8Writer = RGBUInt8WriterType::New();
m_RGBAUInt8Writer = RGBAUInt8WriterType::New();
+
+ m_ComplexVectorInt16Writer = ComplexVectorInt16WriterType::New();
+ m_ComplexVectorInt32Writer = ComplexVectorInt32WriterType::New();
+ m_ComplexVectorFloatWriter = ComplexVectorFloatWriterType::New();
+ m_ComplexVectorDoubleWriter = ComplexVectorDoubleWriterType::New();
}
-template <typename TInput, typename TOutput> void ClampAndWriteImage(itk::ImageBase<2> * in, otb::ImageFileWriter<TOutput> * writer, const std::string & filename, const unsigned int & ramValue)
+template <typename TInput, typename TOutput>
+void
+ClampAndWriteVectorImage( itk::ImageBase<2> * in ,
+ otb::ImageFileWriter<TOutput> * writer ,
+ const std::string & filename ,
+ const unsigned int & ramValue )
{
- typedef otb::ClampImageFilter<TInput, TOutput> ClampFilterType;
- typename ClampFilterType::Pointer clampFilter = ClampFilterType::New();
+ typedef ClampImageFilter < TInput , TOutput > ClampFilterType;
+ typename ClampFilterType::Pointer clampFilter ( ClampFilterType::New() );
+
clampFilter->SetInput( dynamic_cast<TInput*>(in));
bool useStandardWriter = true;
@@ -200,152 +230,116 @@ template <typename TInput, typename TOutput> void ClampAndWriteImage(itk::ImageB
}
}
-template <typename TInput, typename TOutput > void ClampAndWriteVectorImage(itk::ImageBase<2> * in, otb::ImageFileWriter<TOutput > * writer, const std::string & filename, const unsigned int & ramValue)
-{
- typedef otb::ClampVectorImageFilter<TInput, TOutput> ClampFilterType;
- typename ClampFilterType::Pointer clampFilter = ClampFilterType::New();
- clampFilter->SetInput( dynamic_cast<TInput*>(in));
-
- bool useStandardWriter = true;
-
-#ifdef OTB_USE_MPI
-
- otb::MPIConfig::Pointer mpiConfig = otb::MPIConfig::Instance();
-
- if (mpiConfig->GetNbProcs() > 1)
- {
- useStandardWriter = false;
-
- // Get file extension
- std::string extension = itksys::SystemTools::GetFilenameExtension(filename);
-
- if(extension == ".vrt")
- {
- // Use the WriteMPI function
- WriteMPI(clampFilter->GetOutput(),filename,ramValue);
- }
- #ifdef OTB_USE_SPTW
- else if (extension == ".tif")
- {
- // Use simple parallel tiff writer
- typedef otb::SimpleParallelTiffWriter<TOutput> SPTWriterType;
-
- typename SPTWriterType::Pointer sptWriter = SPTWriterType::New();
- sptWriter->SetFileName(filename);
- sptWriter->SetInput(clampFilter->GetOutput());
- sptWriter->SetAutomaticAdaptativeStreaming(ramValue);
- sptWriter->Update();
- }
-
- #endif
- else
- {
- itkGenericExceptionMacro("File format "<<extension<<" not supported for parallel writing with MPI. Supported formats are .vrt and .tif. Extended filenames are not supported.");
- }
- }
- #endif
-
- if(useStandardWriter)
- {
-
- writer->SetFileName( filename );
- writer->SetInput(clampFilter->GetOutput());
- writer->SetAutomaticAdaptativeStreaming(ramValue);
- writer->Update();
- }
-}
-
-
-template <class TInputImageType>
+template <class TInput>
void
-OutputImageParameter::SwitchImageWrite()
-{
+OutputImageParameter::SwitchVectorImageWrite()
+ {
switch(m_PixelType )
{
case ImagePixelType_uint8:
{
- ClampAndWriteImage<TInputImageType,UInt8ImageType>(m_Image,m_UInt8Writer,m_FileName,m_RAMValue);
+ ClampAndWriteVectorImage< TInput , UInt8VectorImageType > (
+ m_Image ,
+ m_VectorUInt8Writer ,
+ m_FileName ,
+ m_RAMValue );
break;
}
case ImagePixelType_int16:
{
- ClampAndWriteImage<TInputImageType,Int16ImageType>(m_Image,m_Int16Writer,m_FileName,m_RAMValue);
+ ClampAndWriteVectorImage< TInput , Int16VectorImageType > (
+ m_Image ,
+ m_VectorInt16Writer ,
+ m_FileName ,
+ m_RAMValue );
break;
}
case ImagePixelType_uint16:
{
- ClampAndWriteImage<TInputImageType,UInt16ImageType>(m_Image,m_UInt16Writer,m_FileName,m_RAMValue);
+ ClampAndWriteVectorImage< TInput , UInt16VectorImageType > (
+ m_Image ,
+ m_VectorUInt16Writer ,
+ m_FileName ,
+ m_RAMValue );
break;
}
case ImagePixelType_int32:
{
- ClampAndWriteImage<TInputImageType,Int32ImageType>(m_Image,m_Int32Writer,m_FileName,m_RAMValue);
+ ClampAndWriteVectorImage< TInput , Int32VectorImageType > (
+ m_Image ,
+ m_VectorInt32Writer ,
+ m_FileName ,
+ m_RAMValue );
break;
}
case ImagePixelType_uint32:
{
- ClampAndWriteImage<TInputImageType,UInt32ImageType>(m_Image,m_UInt32Writer,m_FileName,m_RAMValue);
+ ClampAndWriteVectorImage< TInput , UInt32VectorImageType > (
+ m_Image ,
+ m_VectorUInt32Writer ,
+ m_FileName ,
+ m_RAMValue );
break;
}
case ImagePixelType_float:
{
- ClampAndWriteImage<TInputImageType,FloatImageType>(m_Image,m_FloatWriter,m_FileName,m_RAMValue);
+ ClampAndWriteVectorImage< TInput , FloatVectorImageType > (
+ m_Image ,
+ m_VectorFloatWriter ,
+ m_FileName ,
+ m_RAMValue );
break;
}
case ImagePixelType_double:
{
- ClampAndWriteImage<TInputImageType,DoubleImageType>(m_Image,m_DoubleWriter,m_FileName,m_RAMValue);
- break;
- }
- }
-}
-
-
-template <class TInputVectorImageType>
-void
-OutputImageParameter::SwitchVectorImageWrite()
- {
- switch(m_PixelType )
- {
- case ImagePixelType_uint8:
- {
- ClampAndWriteVectorImage<TInputVectorImageType,UInt8VectorImageType>(m_Image,m_VectorUInt8Writer,m_FileName,m_RAMValue);
- break;
- }
- case ImagePixelType_int16:
- {
- ClampAndWriteVectorImage<TInputVectorImageType,Int16VectorImageType>(m_Image,m_VectorInt16Writer,m_FileName,m_RAMValue);
+ ClampAndWriteVectorImage< TInput , DoubleVectorImageType > (
+ m_Image ,
+ m_VectorDoubleWriter ,
+ m_FileName ,
+ m_RAMValue );
break;
}
- case ImagePixelType_uint16:
+ case ImagePixelType_cint16:
{
- ClampAndWriteVectorImage<TInputVectorImageType,UInt16VectorImageType>(m_Image,m_VectorUInt16Writer,m_FileName,m_RAMValue);
+ ClampAndWriteVectorImage < TInput , ComplexInt16VectorImageType > (
+ m_Image ,
+ m_ComplexVectorInt16Writer ,
+ m_FileName ,
+ m_RAMValue );
break;
}
- case ImagePixelType_int32:
+ case ImagePixelType_cint32:
{
- ClampAndWriteVectorImage<TInputVectorImageType,Int32VectorImageType>(m_Image,m_VectorInt32Writer,m_FileName,m_RAMValue);
+ ClampAndWriteVectorImage < TInput , ComplexInt32VectorImageType > (
+ m_Image ,
+ m_ComplexVectorInt32Writer ,
+ m_FileName ,
+ m_RAMValue );
break;
}
- case ImagePixelType_uint32:
+ case ImagePixelType_cfloat:
{
- ClampAndWriteVectorImage<TInputVectorImageType,UInt32VectorImageType>(m_Image,m_VectorUInt32Writer,m_FileName,m_RAMValue);
+ ClampAndWriteVectorImage < TInput , ComplexFloatVectorImageType > (
+ m_Image ,
+ m_ComplexVectorFloatWriter ,
+ m_FileName ,
+ m_RAMValue );
break;
}
- case ImagePixelType_float:
+ case ImagePixelType_cdouble:
{
- ClampAndWriteVectorImage<TInputVectorImageType,FloatVectorImageType>(m_Image,m_VectorFloatWriter,m_FileName,m_RAMValue);
- break;
- }
- case ImagePixelType_double:
- {
- ClampAndWriteVectorImage<TInputVectorImageType,DoubleVectorImageType>(m_Image,m_VectorDoubleWriter,m_FileName,m_RAMValue);
+ ClampAndWriteVectorImage < TInput , ComplexDoubleVectorImageType > (
+ m_Image ,
+ m_ComplexVectorDoubleWriter ,
+ m_FileName ,
+ m_RAMValue );
break;
}
+ default:
+ break;
}
}
-
template <class TInputRGBAImageType>
void
OutputImageParameter::SwitchRGBAImageWrite()
@@ -383,31 +377,47 @@ OutputImageParameter::Write()
if (dynamic_cast<UInt8ImageType*>(m_Image.GetPointer()))
{
- SwitchImageWrite<UInt8ImageType>();
+ SwitchVectorImageWrite<UInt8ImageType>();
}
else if (dynamic_cast<Int16ImageType*>(m_Image.GetPointer()))
{
- SwitchImageWrite<Int16ImageType>();
+ SwitchVectorImageWrite<Int16ImageType>();
}
else if (dynamic_cast<UInt16ImageType*>(m_Image.GetPointer()))
{
- SwitchImageWrite<UInt16ImageType>();
+ SwitchVectorImageWrite<UInt16ImageType>();
}
else if (dynamic_cast<Int32ImageType*>(m_Image.GetPointer()))
{
- SwitchImageWrite<Int32ImageType>();
+ SwitchVectorImageWrite<Int32ImageType>();
}
else if (dynamic_cast<UInt32ImageType*>(m_Image.GetPointer()))
{
- SwitchImageWrite<UInt32ImageType>();
+ SwitchVectorImageWrite<UInt32ImageType>();
}
else if (dynamic_cast<FloatImageType*>(m_Image.GetPointer()))
{
- SwitchImageWrite<FloatImageType>();
+ SwitchVectorImageWrite<FloatImageType>();
}
else if (dynamic_cast<DoubleImageType*>(m_Image.GetPointer()))
{
- SwitchImageWrite<DoubleImageType>();
+ SwitchVectorImageWrite<DoubleImageType>();
+ }
+ else if (dynamic_cast<ComplexInt16ImageType*>(m_Image.GetPointer()) )
+ {
+ SwitchVectorImageWrite<ComplexInt16ImageType>();
+ }
+ else if (dynamic_cast<ComplexInt32ImageType*>(m_Image.GetPointer()) )
+ {
+ SwitchVectorImageWrite<ComplexInt32ImageType>();
+ }
+ else if (dynamic_cast<ComplexFloatImageType*>(m_Image.GetPointer()) )
+ {
+ SwitchVectorImageWrite<ComplexFloatImageType>();
+ }
+ else if (dynamic_cast<ComplexDoubleImageType*>(m_Image.GetPointer()) )
+ {
+ SwitchVectorImageWrite<ComplexDoubleImageType>();
}
else if (dynamic_cast<UInt8VectorImageType*>(m_Image.GetPointer()))
{
@@ -437,6 +447,22 @@ OutputImageParameter::Write()
{
SwitchVectorImageWrite<DoubleVectorImageType>();
}
+ else if (dynamic_cast<ComplexInt16VectorImageType*>(m_Image.GetPointer()))
+ {
+ SwitchVectorImageWrite<ComplexInt16VectorImageType>();
+ }
+ else if (dynamic_cast<ComplexInt32VectorImageType*>(m_Image.GetPointer()))
+ {
+ SwitchVectorImageWrite<ComplexInt32VectorImageType>();
+ }
+ else if (dynamic_cast<ComplexFloatVectorImageType*>(m_Image.GetPointer()))
+ {
+ SwitchVectorImageWrite<ComplexFloatVectorImageType>();
+ }
+ else if (dynamic_cast<ComplexDoubleVectorImageType*>(m_Image.GetPointer()))
+ {
+ SwitchVectorImageWrite<ComplexDoubleVectorImageType>();
+ }
else if (dynamic_cast<UInt8RGBImageType*>(m_Image.GetPointer()))
{
SwitchRGBImageWrite<UInt8RGBImageType>();
@@ -455,23 +481,14 @@ OutputImageParameter::Write()
itk::ProcessObject*
OutputImageParameter::GetWriter()
{
- int type = 0;
+ int type = 1;
// 0 : image
// 1 : VectorImage
// 2 : RGBAImage
// 3 : RGBImage
itk::ProcessObject* writer = ITK_NULLPTR;
- if (dynamic_cast<UInt8VectorImageType*> (m_Image.GetPointer())
- || dynamic_cast<Int16VectorImageType*> (m_Image.GetPointer())
- || dynamic_cast<UInt16VectorImageType*> (m_Image.GetPointer())
- || dynamic_cast<Int32VectorImageType*> (m_Image.GetPointer())
- || dynamic_cast<UInt32VectorImageType*> (m_Image.GetPointer())
- || dynamic_cast<FloatVectorImageType*> (m_Image.GetPointer())
- || dynamic_cast<DoubleVectorImageType*> (m_Image.GetPointer()))
- {
- type = 1;
- }
- else if (dynamic_cast<UInt8RGBAImageType*> (m_Image.GetPointer()))
+
+ if (dynamic_cast<UInt8RGBAImageType*> (m_Image.GetPointer()))
{
type = 2;
writer = m_RGBAUInt8Writer;
@@ -492,9 +509,6 @@ OutputImageParameter::GetWriter()
{
switch(type)
{
- case 0:
- writer = m_UInt8Writer;
- break;
case 1:
writer = m_VectorUInt8Writer;
break;
@@ -511,48 +525,60 @@ OutputImageParameter::GetWriter()
{
if (type == 1)
writer = m_VectorInt16Writer;
- else
- if (type == 0) writer = m_Int16Writer;
break;
}
case ImagePixelType_uint16:
{
if (type == 1)
writer = m_VectorUInt16Writer;
- else
- if (type == 0) writer = m_UInt16Writer;
break;
}
case ImagePixelType_int32:
{
if (type == 1)
writer = m_VectorInt32Writer;
- else
- if (type == 0) writer = m_Int32Writer;
break;
}
case ImagePixelType_uint32:
{
if (type == 1)
writer = m_VectorUInt32Writer;
- else
- if (type == 0) writer = m_UInt32Writer;
break;
}
case ImagePixelType_float:
{
if (type == 1)
writer = m_VectorFloatWriter;
- else
- if (type == 0) writer = m_FloatWriter;
break;
}
case ImagePixelType_double:
{
if (type == 1)
writer = m_VectorDoubleWriter;
- else
- if (type == 0) writer = m_DoubleWriter;
+ break;
+ }
+ case ImagePixelType_cint16:
+ {
+ if( type == 1 )
+ writer = m_ComplexVectorInt16Writer;
+ break;
+ }
+ case ImagePixelType_cint32:
+ {
+ if( type == 1 )
+ writer = m_ComplexVectorInt32Writer;
+ break;
+ }
+ case ImagePixelType_cfloat:
+ {
+ if( type == 1 )
+ writer = m_ComplexVectorFloatWriter;
+ break;
+ }
+ case ImagePixelType_cdouble:
+ {
+ if( type == 1 )
+ writer = m_ComplexVectorDoubleWriter;
break;
}
}
diff --git a/Modules/Wrappers/ApplicationEngine/test/CMakeLists.txt b/Modules/Wrappers/ApplicationEngine/test/CMakeLists.txt
index 860c8673636aff84ee7d5ae5f26c9c5ab0bc733d..319466cb4c49d21b321d55aa57ff0df847f56a53 100644
--- a/Modules/Wrappers/ApplicationEngine/test/CMakeLists.txt
+++ b/Modules/Wrappers/ApplicationEngine/test/CMakeLists.txt
@@ -171,6 +171,12 @@ otb_add_test(NAME owTvOutputImageParameter COMMAND otbApplicationEngineTestDrive
"my description"
)
+#~ otb_add_test(NAME owTvOutputImageParameterConversion COMMAND otbApplicationEngineTestDriver
+ #~ otbWrapperOutputImageParameterConversionTest
+ #~ ${INPUTDATA}/poupees.tif
+ #~ ${TEMP}/poupees_out.tif
+ #~ )
+
otb_add_test(NAME owTvDocExampleStructureTest COMMAND otbApplicationEngineTestDriver
--compare-ascii ${NOTOL}
${BASELINE}/owTuDocExampleStructureTest.txt
diff --git a/Modules/Wrappers/ApplicationEngine/test/otbApplicationEngineTestDriver.cxx b/Modules/Wrappers/ApplicationEngine/test/otbApplicationEngineTestDriver.cxx
index f5b3aabf3d5b4642044293927422883c491198f1..5ccef4965304591a54437f5f75e1d4070bff360a 100644
--- a/Modules/Wrappers/ApplicationEngine/test/otbApplicationEngineTestDriver.cxx
+++ b/Modules/Wrappers/ApplicationEngine/test/otbApplicationEngineTestDriver.cxx
@@ -51,5 +51,6 @@ void RegisterTests()
REGISTER_TEST(otbWrapperInputVectorDataParameterNew);
REGISTER_TEST(otbWrapperOutputImageParameterNew);
REGISTER_TEST(otbWrapperOutputImageParameterTest1);
+ //~ REGISTER_TEST(otbWrapperOutputImageParameterConversionTest);
REGISTER_TEST(otbApplicationMemoryConnectTest);
}
diff --git a/Modules/Wrappers/ApplicationEngine/test/otbWrapperOutputImageParameterTest.cxx b/Modules/Wrappers/ApplicationEngine/test/otbWrapperOutputImageParameterTest.cxx
index 76d6c6056e6ba55ed46f3edda89923fc1ad0c861..ea8899b8e0d50685f8e0973f17e1a50081dde7f5 100644
--- a/Modules/Wrappers/ApplicationEngine/test/otbWrapperOutputImageParameterTest.cxx
+++ b/Modules/Wrappers/ApplicationEngine/test/otbWrapperOutputImageParameterTest.cxx
@@ -23,8 +23,10 @@
#endif
#include "otbWrapperOutputImageParameter.h"
+#include "otbWrapperInputImageParameter.h"
#include "otbImageFileReader.h"
#include "otbWrapperTypes.h"
+#include <vector>
int otbWrapperOutputImageParameterNew(int itkNotUsed(argc), char * itkNotUsed(argv)[])
{
@@ -34,7 +36,6 @@ int otbWrapperOutputImageParameterNew(int itkNotUsed(argc), char * itkNotUsed(ar
return EXIT_SUCCESS;
}
-
int otbWrapperOutputImageParameterTest1(int itkNotUsed(argc), char* argv[])
{
typedef otb::Wrapper::OutputImageParameter OutputImageParameterType;
@@ -59,3 +60,59 @@ int otbWrapperOutputImageParameterTest1(int itkNotUsed(argc), char* argv[])
return EXIT_SUCCESS;
}
+
+
+// template < typename ImageType >
+// void Cross( int p , std::string inputfilename, std::string outputfilename)
+// {
+// otb::Wrapper::InputImageParameter::Pointer paramIn (
+// otb::Wrapper::InputImageParameter::New() );
+// paramIn->SetFromFileName( inputfilename );
+// otb::Wrapper::OutputImageParameter::Pointer paramOut(
+// otb::Wrapper::OutputImageParameter::New() );
+// paramOut->SetFileName( outputfilename );
+// paramOut->SetImage(paramIn->GetImage<ImageType>());
+// paramOut->InitializeWriters();
+// paramOut->SetPixelType(static_cast<otb::Wrapper::ImagePixelType>(p));
+// paramOut->Write();
+// }
+
+
+// int otbWrapperOutputImageParameterConversionTest(int , char* argv[])
+// {
+// std::string filenamein = argv[1];
+// std::string filenameout = argv[2] ;
+// std::string extension = filenameout.substr( filenameout.find_last_of('.') );
+
+// filenameout = filenameout.substr( 0 , filenameout.find_last_of('.') );
+
+// for ( int i = otb::Wrapper::ImagePixelType_uint8 ; i < 11 ; i++ )
+// {
+// std::string type =
+// otb::Wrapper::OutputImageParameter::ConvertPixelTypeToString(
+// static_cast<otb::Wrapper::ImagePixelType>(i) );
+// Cross< otb::Wrapper::UInt8ImageType > (i , filenamein , filenameout+"_UInt8_"+ type + extension ) ;
+// Cross< otb::Wrapper::Int16ImageType > ( i , filenamein , filenameout+"_Int16_"+ type + extension ) ;
+// Cross< otb::Wrapper::UInt16ImageType > ( i , filenamein , filenameout+"_UInt16_"+ type + extension ) ;
+// Cross< otb::Wrapper::Int32ImageType > ( i , filenamein , filenameout+"_Int21_"+ type + extension ) ;
+// Cross< otb::Wrapper::UInt32ImageType > ( i , filenamein , filenameout+"_UInt32_"+ type + extension ) ;
+// Cross< otb::Wrapper::FloatImageType > ( i , filenamein , filenameout+"_float_"+ type + extension ) ;
+// Cross< otb::Wrapper::DoubleImageType > ( i , filenamein , filenameout+"_double_"+ type + extension ) ;
+// Cross< otb::Wrapper::UInt8VectorImageType > ( i , filenamein , filenameout+"_UInt8Vect_"+ type + extension ) ;
+// Cross< otb::Wrapper::Int16VectorImageType > ( i , filenamein , filenameout+"_Int16Vect_"+ type + extension ) ;
+// Cross< otb::Wrapper::UInt16VectorImageType > ( i , filenamein , filenameout+"_UInt16Vect_"+ type + extension ) ;
+// Cross< otb::Wrapper::Int32VectorImageType > ( i , filenamein , filenameout+"_Int21Vect_"+ type + extension ) ;
+// Cross< otb::Wrapper::UInt32VectorImageType > ( i , filenamein , filenameout+"_UInt32Vect_"+ type + extension ) ;
+// Cross< otb::Wrapper::FloatVectorImageType > ( i , filenamein , filenameout+"_floatVect_"+ type + extension ) ;
+// Cross< otb::Wrapper::DoubleVectorImageType > ( i , filenamein , filenameout+"_doubleVect_"+ type + extension ) ;
+// Cross< otb::Wrapper::ComplexInt16ImageType > ( i , filenamein , filenameout+"_CInt16_"+ type + extension ) ;
+// Cross< otb::Wrapper::ComplexInt32ImageType > ( i , filenamein , filenameout+"_CInt32_"+ type + extension ) ;
+// Cross< otb::Wrapper::ComplexFloatImageType > ( i , filenamein , filenameout+"_Cfloat_"+ type + extension ) ;
+// Cross< otb::Wrapper::ComplexDoubleImageType > ( i , filenamein , filenameout+"_Cdouble_"+ type + extension ) ;
+// Cross< otb::Wrapper::ComplexInt16VectorImageType > ( i , filenamein , filenameout+"_CInt16Vect_"+ type + extension ) ;
+// Cross< otb::Wrapper::ComplexInt32VectorImageType > ( i , filenamein , filenameout+"_CInt32Vect_"+ type + extension ) ;
+// Cross< otb::Wrapper::ComplexFloatVectorImageType > ( i , filenamein , filenameout+"_CfloatVect_"+ type + extension ) ;
+// Cross< otb::Wrapper::ComplexDoubleVectorImageType > ( i , filenamein , filenameout+"_CdoubleVect_"+ type + extension ) ;
+// }
+// return 0;
+// }
diff --git a/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetComplexOutputImageParameter.cxx b/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetComplexOutputImageParameter.cxx
index 0cd5800dfa462ba05af6123a247ca48c15d29d78..ab35389152756e9c4db507cd6478520ae5db9bba 100644
--- a/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetComplexOutputImageParameter.cxx
+++ b/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetComplexOutputImageParameter.cxx
@@ -67,6 +67,8 @@ void QtWidgetComplexOutputImageParameter::DoCreateWidget()
// Set the Output PixelType choice Combobox
m_ComboBox = new QComboBox;
m_ComboBox->setToolTip("Complex Output Pixel Type");
+ m_ComboBox->addItem( "cint16");
+ m_ComboBox->addItem( "cint32");
m_ComboBox->addItem( "cfloat");
m_ComboBox->addItem( "cdouble");
m_ComboBox->setCurrentIndex(m_OutputImageParam->GetComplexPixelType());
diff --git a/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetOutputImageParameter.cxx b/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetOutputImageParameter.cxx
index 140ff6534f8487f97bbda7d0a99fc49128401843..9bcf5430d20d65864bb072d00a32792806610411 100644
--- a/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetOutputImageParameter.cxx
+++ b/Modules/Wrappers/QtWidget/src/otbWrapperQtWidgetOutputImageParameter.cxx
@@ -75,6 +75,10 @@ void QtWidgetOutputImageParameter::DoCreateWidget()
m_ComboBox->addItem( "uint 32");
m_ComboBox->addItem( "float");
m_ComboBox->addItem( "double");
+ m_ComboBox->addItem( "cint16");
+ m_ComboBox->addItem( "cint32");
+ m_ComboBox->addItem( "cfloat");
+ m_ComboBox->addItem( "cdouble");
m_ComboBox->setCurrentIndex(m_OutputImageParam->GetPixelType());
connect( m_ComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(SetPixelType(int)) );
connect( m_ComboBox, SIGNAL(currentIndexChanged(int)), GetModel(), SLOT(NotifyUpdate()) );