Commit 55df022e authored by Cédric Traizet's avatar Cédric Traizet

Merge branch 'remove_commandlineparser' into 'develop'

Remove CommandLineParser submodule

See merge request !336
parents ecc8d78e bfd6a1a1
......@@ -26,7 +26,6 @@
#include "otbImageFileReader.h"
#include "otbImageFileWriter.h"
#include "otbCommandProgressUpdate.h"
#include "otbCommandLineArgumentParser.h"
#include "otbKullbackLeiblerSupervizedDistanceImageFilter.h"
......@@ -34,36 +33,13 @@ int main(int argc, char * argv[])
{
try
{
typedef otb::CommandLineArgumentParser ParserType;
ParserType::Pointer parser = ParserType::New();
parser->AddOption("--InputImage1", "Give Before image", "-1", 1, true);
parser->AddOption("--InputImage2", "Give After image", "-2", 1, true);
parser->AddOption("--Roi", "Give ROI image", "-r", 1, true);
parser->AddOption("--winSize",
"Sliding window size (def. 35)",
"-w",
1,
false);
parser->AddOutputImage();
typedef otb::CommandLineArgumentParseResult ParserResultType;
ParserResultType::Pointer parseResult = ParserResultType::New();
try
{
parser->ParseCommandLine(argc, argv, parseResult);
}
catch (itk::ExceptionObject& err)
if( argc < 5 )
{
std::string descriptionException = err.GetDescription();
if (descriptionException.find("ParseCommandLine(): Help Parser")
!= std::string::npos) return EXIT_SUCCESS;
if (descriptionException.find("ParseCommandLine(): Version Parser")
!= std::string::npos) return EXIT_SUCCESS;
std::cerr << "Usage: " << argv[0];
std::cerr << "inputNameImage1 inputNameImage2 ROIImageName outputName ";
std::cerr << "[winSize=35]";
return EXIT_FAILURE;
}
/*
* Types declaration
*/
......@@ -83,18 +59,14 @@ int main(int argc, char * argv[])
* Extract command line parameters
*/
std::string inputImageFileName1 = parseResult->GetParameterString(
"--InputImage1");
std::string inputImageFileName2 = parseResult->GetParameterString(
"--InputImage2");
std::string inputTrainingImageFileName = parseResult->GetParameterString(
"--Roi");
std::string outputImageFileName = parseResult->GetOutputImage();
std::string inputImageFileName1 = argv[1];
std::string inputImageFileName2 = argv[2];
std::string inputTrainingImageFileName = argv[3];
std::string outputImageFileName = argv[4];
int winSize = 35;
if (parseResult->IsOptionPresent("--winSize"))
winSize =
parseResult->GetParameterInt("--winSize");
if ( argc == 6 )
winSize = std::stoi(argv[5]);
/*
* JustDoIt
......
......@@ -37,7 +37,6 @@
#include "otbImageFileWriter.h"
#include "otbImageFileReader.h"
#include "otbCommandLineArgumentParser.h"
// Software Guide : BeginCodeSnippet
#include "otbNCCRegistrationFilter.h"
......@@ -111,14 +110,14 @@ int main(int argc, char** argv)
FixedBlurType::Pointer fBlur = FixedBlurType::New();
fBlur->SetInput(fReader->GetOutput());
fBlur->SetSigma(atof(argv[7]));
fBlur->SetSigma(std::stof(argv[7]));
typedef itk::RecursiveGaussianImageFilter<MovingImageType,
MovingImageType> MovingBlurType;
MovingBlurType::Pointer mBlur = MovingBlurType::New();
mBlur->SetInput(mReader->GetOutput());
mBlur->SetSigma(atof(argv[7]));
mBlur->SetSigma(std::stof(argv[7]));
// Software Guide : EndCodeSnippet
// Software Guide : BeginLatex
......@@ -153,8 +152,8 @@ int main(int argc, char** argv)
RadiusType radius;
radius[0] = atoi(argv[6]);
radius[1] = atoi(argv[6]);
radius[0] = std::stoi(argv[6]);
radius[1] = std::stoi(argv[6]);
registrator->SetNCCRadius(radius);
// Software Guide : EndCodeSnippet
......@@ -168,7 +167,7 @@ int main(int argc, char** argv)
// Software Guide : EndLatex
// Software Guide : BeginCodeSnippet
registrator->SetNumberOfIterations(atoi(argv[8]));
registrator->SetNumberOfIterations(std::stoi(argv[8]));
// Software Guide : EndCodeSnippet
// registrator->GetDisplacementField();
......
......@@ -40,7 +40,6 @@
#include "otbMultiChannelRAndNIRIndexImageFilter.h"
// Software Guide : EndCodeSnippet
#include "otbCommandLineArgumentParser.h"
#include "otbImage.h"
#include "otbImageFileWriter.h"
......
......@@ -59,7 +59,7 @@
// Software Guide : BeginCodeSnippet
#include "itkMacro.h"
#include "otbCommandLineArgumentParser.h"
// Software Guide : EndCodeSnippet
// Software Guide : BeginLatex
......@@ -95,96 +95,59 @@ int main(int argc, char * argv[])
// Software Guide : BeginCodeSnippet
try
{
// Software Guide : EndCodeSnippet
// Software Guide : EndCodeSnippet
// Software Guide : BeginLatex
//
// Now, we can declare the \doxygen{otb}{CommandLineArgumentParser} which is
// going to parse the command line, select the proper variables, handle the
// missing compulsory arguments and print an error message if necessary.
//
// Let's declare the parser:
//
// First we document the usage of the program, and get the different
// variables $\sigma_D$ (d=), $\sigma_I$ (i=) and $\alpha$ (a=) in
// c++ variables :
//
// Software Guide : EndLatex
// Software Guide : BeginCodeSnippet
typedef otb::CommandLineArgumentParser ParserType;
ParserType::Pointer parser = ParserType::New();
// Software Guide : EndCodeSnippet
// Software Guide : BeginLatex
//
// It's now time to tell the parser what are the options we want. Special
//options are available for input and output images with the
// \code{AddInputImage()} and \code{AddOutputImage()} methods.
//
// For the other options, we need to use the \code{AddOption()} method.
// This method allows us to specify
// \begin{itemize}
// \item the name of the option
// \item a message to explain the meaning of this option
// \item a shortcut for this option
// \item the number of expected parameters for this option
// \item whether or not this option is compulsory
// \end{itemize}
//
// Software Guide : EndLatex
// Software Guide : BeginCodeSnippet
parser->SetProgramDescription(
"This program applies a Harris detector on the input image");
parser->AddInputImage();
parser->AddOutputImage();
parser->AddOption("--SigmaD",
"Set the sigmaD parameter. Default is 1.0.",
"-d",
1,
false);
parser->AddOption("--SigmaI",
"Set the sigmaI parameter. Default is 1.0.",
"-i",
1,
false);
parser->AddOption("--Alpha",
"Set the alpha parameter. Default is 1.0.",
"-a",
1,
false);
// Software Guide : EndCodeSnippet
// Software Guide : BeginLatex
//
// Now that the parser has all this information, it can actually look at
// the command line to parse it. We have to do this within a \code{try} -
// \code{catch} loop to handle exceptions nicely.
//
// Software Guide : EndLatex
// Software Guide : BeginCodeSnippet
typedef otb::CommandLineArgumentParseResult ParserResultType;
ParserResultType::Pointer parseResult = ParserResultType::New();
try
// Software Guide : BeginCodeSnippet
if ( argc < 3 )
{
parser->ParseCommandLine(argc, argv, parseResult);
std::cerr << "This program applies the Harris detector on the input "
<< "image\n";
std::cerr << "Usage : " << argv[0] ;
std::cerr << " input_filename output_filename [d=1.0] [i=1.0] [a=1.0]\n";
std::cerr << "\"d=\" is for the sigmaD parameter, default value is 1.0\n";
std::cerr << "\"i=\" is for the sigmaI parameter, default value is 1.0\n";
std::cerr << "\"a=\" is for the alpha parameter, default value is 1.0\n";
return EXIT_FAILURE;
}
catch (itk::ExceptionObject& err)
std::string input_filename = argv[1];
std::string output_filename = argv[2];
bool is_there_sigma_d(false), is_there_sigma_i(false),
is_there_alpha(false);
double sigma_d(1.0), sigma_i(1.0), alpha(1.0);
for (auto i = 3 ; i < argc ; i++ )
{
std::string descriptionException = err.GetDescription();
if (descriptionException.find("ParseCommandLine(): Help Parser")
!= std::string::npos)
std::string temp_arg = argv[i];
auto pos_sigma_d = temp_arg.find("d=");
auto pos_sigma_i = temp_arg.find("i=");
auto pos_alpha = temp_arg.find("a=");
if ( pos_sigma_d != std::string::npos )
{
return EXIT_SUCCESS;
is_there_sigma_d = true;
sigma_d = std::stod( temp_arg.substr( pos_sigma_d + 2 ) );
continue;
}
if (descriptionException.find("ParseCommandLine(): Version Parser")
!= std::string::npos)
if ( pos_sigma_i != std::string::npos )
{
return EXIT_SUCCESS;
is_there_sigma_i = true;
sigma_i = std::stod( temp_arg.substr( pos_sigma_i + 2 ) );
continue;
}
if ( pos_alpha != std::string::npos )
{
is_there_alpha = true;
alpha = std::stod( temp_arg.substr( pos_alpha + 2 ) );
continue;
}
return EXIT_FAILURE;
}
// Software Guide : EndCodeSnippet
// Software Guide : EndCodeSnippet
// Software Guide : BeginLatex
//
......@@ -209,14 +172,14 @@ int main(int argc, char * argv[])
// Software Guide : BeginLatex
//
// We are getting the filenames for the input and the output
// images directly from the parser:
// We are setting the filenames of the input and the output and the
// reader and writer respectively:
//
// Software Guide : BeginLatex
// Software Guide : BeginCodeSnippet
reader->SetFileName(parseResult->GetInputImage());
writer->SetFileName(parseResult->GetOutputImage());
reader->SetFileName( input_filename );
writer->SetFileName( output_filename );
// Software Guide : EndCodeSnippet
// Software Guide : BeginLatex
......@@ -236,24 +199,20 @@ int main(int argc, char * argv[])
// Software Guide : BeginLatex
//
// We set the filter parameters from the parser. The method
// \code{IsOptionPresent()} let us know if an optional option
// was provided in the command line.
// We set the filter parameters from the variables we created from the
// commandline.
//
// Software Guide : EndLatex
// Software Guide : BeginCodeSnippet
if (parseResult->IsOptionPresent("--SigmaD"))
filter->SetSigmaD(
parseResult->GetParameterDouble("--SigmaD"));
if ( is_there_sigma_d )
filter->SetSigmaD( sigma_d );
if (parseResult->IsOptionPresent("--SigmaI"))
filter->SetSigmaI(
parseResult->GetParameterDouble("--SigmaI"));
if ( is_there_sigma_i )
filter->SetSigmaI( sigma_i );
if (parseResult->IsOptionPresent("--Alpha"))
filter->SetAlpha(
parseResult->GetParameterDouble("--Alpha"));
if ( is_there_alpha )
filter->SetAlpha( alpha );
// Software Guide : EndCodeSnippet
// Software Guide : BeginLatex
......
......@@ -70,11 +70,11 @@ otb_add_test(NAME trTeTutorialsSmarterFilteringPipelineTest COMMAND ${OTB_TEST_
${BASELINE}/TutorialsSmarterFilteringPipelineOutput.png
${TEMP}/TutorialsSmarterFilteringPipelineOutput.png
Execute $<TARGET_FILE:SmarterFilteringPipeline>
-in ${INPUTDATA}/QB_Suburb.png
-out ${TEMP}/TutorialsSmarterFilteringPipelineOutput.png
-d 1.5
-i 2
-a 0.1
${INPUTDATA}/QB_Suburb.png
${TEMP}/TutorialsSmarterFilteringPipelineOutput.png
d=1.5
i=2
a=0.1
)
otb_add_test(NAME trTeTutorialsOrthoFusionTest COMMAND ${OTB_TEST_DRIVER}
......
#
# Copyright (C) 2005-2019 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.
#
project(OTBCommandLineParser)
set(OTBCommandLineParser_LIBRARIES OTBCommandLineParser)
otb_module_impl()
#
# Copyright (C) 2005-2019 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.
#
set(DOCUMENTATION "TODO")
otb_module(OTBCommandLineParser
DEPENDS
OTBCommon
OTBITK
TEST_DEPENDS
OTBTestKernel
DESCRIPTION
"${DOCUMENTATION}"
)
#
# Copyright (C) 2005-2019 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.
#
set(OTBCommandLineParser_SRC
otbCommandLineArgumentParser.cxx
)
add_library(OTBCommandLineParser ${OTBCommandLineParser_SRC})
target_link_libraries(OTBCommandLineParser
${OTBCommon_LIBRARIES}
${OTBITK_LIBRARIES}
)
otb_module_target(OTBCommandLineParser)
#
# Copyright (C) 2005-2019 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.
#
otb_module_test()
set(OTBCommandLineParserTests
otbTestCommandLineArgumentParser.cxx
otbTestCommandLineArgumentParserHelp.cxx
otbTestCommandLineArgumentParserList.cxx
otbTestCommandLineArgumentParserWithError.cxx
otbCommandLineParserTestDriver.cxx )
add_executable(otbCommandLineParserTestDriver ${OTBCommandLineParserTests})
target_link_libraries(otbCommandLineParserTestDriver ${OTBCommandLineParser-Test_LIBRARIES})
otb_module_target_label(otbCommandLineParserTestDriver)
otb_add_test(NAME coTuCmdLineArgParserDeuxEntiers_ExactNumberArg COMMAND otbCommandLineParserTestDriver
otbTestCommandLineArgumentParser
-image image.png -entier 150 -double 12.25 -deuxentiers 78 56 )
otb_add_test(NAME coTuCmdLineArgParserHelpWithArg COMMAND otbCommandLineParserTestDriver
otbTestCommandLineArgumentParserHelp
--help -image image.png)
otb_add_test(NAME coTuCmdLineArgParserHelpWithoutArg COMMAND otbCommandLineParserTestDriver
otbTestCommandLineArgumentParserHelp
--help)
otb_add_test(NAME coTuCmdLineArgParser_List2Arg COMMAND otbCommandLineParserTestDriver
otbTestCommandLineArgumentParserList
-image image.png -entier 150 -double 12.25 -deuxentiers 78 56 -doubles 1.0 2.0)
otb_add_test(NAME coTuCmdLineArgParser_List2ArgBis COMMAND otbCommandLineParserTestDriver
otbTestCommandLineArgumentParserList
-image image.png -entier 150 -double 12.25 -doubles 1.0 2.0 -deuxentiers 78 56 )
otb_add_test(NAME coTuCmdLineArgParser_EmptyList COMMAND otbCommandLineParserTestDriver
otbTestCommandLineArgumentParserList
-image image.png -entier 150 -double 12.25 -deuxentiers 78 56 -doubles)
otb_add_test(NAME coTuCmdLineArgParser_List1Arg COMMAND otbCommandLineParserTestDriver
otbTestCommandLineArgumentParserList
-image image.png -entier 150 -double 12.25 -deuxentiers 78 56 -doubles 1.0 2.5)
otb_add_test(NAME coTuCmdLineArgParser_List3ArgWithError COMMAND otbCommandLineParserTestDriver
otbTestCommandLineArgumentParserList
-image image.png -entier 150 -double 12.25 -deuxentiers 78 56 -doubles 1.0 2.5 -3.5)
otb_add_test(NAME coTuCmdLineArgParserDeuxEntier_LessArg COMMAND otbCommandLineParserTestDriver
otbTestCommandLineArgumentParserWithError
-image image.png -entier 150 -double 12.25 -deuxentiers 78 )
otb_add_test(NAME coTuCmdLineArgParser_MissingObligatoryArg COMMAND otbCommandLineParserTestDriver
otbTestCommandLineArgumentParserWithError
-entier 150 -double 12.25 -deuxentiers 78 56 32)
otb_add_test(NAME coTuCmdLineArgParserDeuxEntier_MoreArg COMMAND otbCommandLineParserTestDriver
otbTestCommandLineArgumentParserWithError
-image image.png -entier 150 -double 12.25 -deuxentiers 78 56 32)
/*
* Copyright (C) 2005-2019 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 "otbTestMain.h"
void RegisterTests()
{
REGISTER_TEST(otbTestCommandLineArgumentParser);
REGISTER_TEST(otbTestCommandLineArgumentParserHelp);
REGISTER_TEST(otbTestCommandLineArgumentParserList);
REGISTER_TEST(otbTestCommandLineArgumentParserWithError);
}
/*
* Copyright (C) 2005-2019 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 <iostream>
#include "otbCommandLineArgumentParser.h"
int otbTestCommandLineArgumentParser(int argc, char * argv[])
{
// Parse command line parameters
typedef otb::CommandLineArgumentParser ParserType;
ParserType::Pointer parser = ParserType::New();
parser->AddOption("-image", "Nom d'une image", "-i", 1, true);
parser->AddOption("-entier", "Une Valeur entiere (obligatoire)", "-e");
parser->AddOption("-deuxentiers", "Deux Valeurs entieres non obligatoire", "-dede", 2, false);
parser->AddOption("-double", "Valeur reelle double", "-d");
typedef otb::CommandLineArgumentParseResult ParserResultType;
ParserResultType::Pointer parseResult = ParserResultType::New();
parser->ParseCommandLine(argc, argv, parseResult);
std::cout << "Image : " << parseResult->GetParameterString("-image") << std::endl;
unsigned int lEntier = parseResult->GetParameterUInt("-entier");
std::cout << "Entier : " << lEntier << std::endl;
if (parseResult->IsOptionPresent("-deuxentiers"))
{
std::cout << "Entier : " << lEntier << std::endl;
}
double lDouble = parseResult->GetParameterDouble("-double");
std::cout << "Double : " << lDouble << std::endl;
return EXIT_SUCCESS;
}
/*
* Copyright (C) 2005-2019 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 <iostream>
#include "itkMacro.h"
#include "otbCommandLineArgumentParser.h"
int otbTestCommandLineArgumentParserHelp(int argc, char * argv[])
{
try
{
// Parse command line parameters
typedef otb::CommandLineArgumentParser ParserType;
ParserType::Pointer parser = ParserType::New();
parser->AddOption("-image", "Nom d'une image", "-i", 1, true);
typedef otb::CommandLineArgumentParseResult ParserResultType;
ParserResultType::Pointer parseResult = ParserResultType::New();
parser->ParseCommandLine(argc, argv, parseResult);
std::cout << "Image : " << parseResult->GetParameterString("-image") << std::endl;
}
catch (CommandLineArgumentParserHelpException& err)
{
std::cerr << err;
return EXIT_SUCCESS;
}
return EXIT_FAILURE;
}
/*
* Copyright (C) 2005-2019 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 <iostream>
#include "otbCommandLineArgumentParser.h"
int otbTestCommandLineArgumentParserList(int argc, char * argv[])
{
// Parse command line parameters
typedef otb::CommandLineArgumentParser ParserType;
ParserType::Pointer parser = ParserType::New();
parser->AddOption("-image", "Nom d'une image", "-i", 1, true);
parser->AddOption("-entier", "Une Valeur entiere (obligatoire)", "-e");
parser->AddOption("-deuxentiers", "Deux Valeurs entieres non obligatoire", "-dede", 2, false);
parser->AddOption("-double", "Valeur reelle double", "-d");
parser->AddOptionNParams("-doubles", "Liste de Valeurs reelles", "-ld", false);
typedef otb::CommandLineArgumentParseResult ParserResultType;
ParserResultType::Pointer parseResult = ParserResultType::New();
parser->ParseCommandLine(argc, argv, parseResult);
std::cout << "Image : " << parseResult->GetParameterString("-image") << std::endl;
//unsigned int lEntier = otb::GetParameter<unsigned int>(parseResult,"-entier");
unsigned int lEntier = parseResult->GetParameterUInt("-entier");
std::cout << "Entier : " << lEntier << std::endl;
if (parseResult->IsOptionPresent("-deuxentiers"))
{
//unsigned int lEntierDeux = otb::GetParameter<unsigned int>(parseResult,"-deuxentiers", 1);
unsigned int lEntierDeux = parseResult->GetParameterUInt("-deuxentiers", 1);