Orfeo Toolbox  4.0
otbWrapperApplication.cxx
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: ORFEO Toolbox
4  Language: C++
5  Date: $Date$
6  Version: $Revision$
7 
8 
9  Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
10  See OTBCopyright.txt for details.
11 
12 
13  This software is distributed WITHOUT ANY WARRANTY; without even
14  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15  PURPOSE. See the above copyright notices for more information.
16 
17 =========================================================================*/
18 #include "otbWrapperApplication.h"
19 
37 #include "otbWrapperRAMParameter.h"
38 
40 
42 
43 
44 #include "otbWrapperTypes.h"
45 #include <exception>
46 #include "itkMacro.h"
47 
48 namespace otb
49 {
50 namespace Wrapper
51 {
52 
54  : m_Name(""),
55  m_Description(""),
56  m_Logger(itk::Logger::New()),
57  m_ProgressSourceDescription(""),
58  m_DocName(""),
59  m_DocLongDescription(""),
60  m_DocAuthors(""),
61  m_DocLimitations(""),
62  m_DocSeeAlso(""),
63  m_DocTags(),
64  m_HaveInXML(true),
65  m_HaveOutXML(true),
66  m_IsInXMLParsed(false)
67 {
68  // Don't call Init from the constructor, since it calls a virtual method !
69  m_Logger->SetName("Application.logger");
70  m_Logger->SetPriorityLevel(itk::LoggerBase::DEBUG);
71  m_Logger->SetLevelForFlushing(itk::LoggerBase::CRITICAL);
72 }
73 
75 {
76 }
77 
79 {
80  return m_Logger;
81 }
82 
83 std::vector<std::string>
85 {
86  return GetParameterList()->GetParametersKeys(recursive);
87 }
88 
90 {
92 }
93 
95 {
96  if (!IsInitialized())
97  {
98  Init();
99  }
100 
101  return m_ParameterList;
102 }
103 
105 {
106  return GetParameterList()->GetParameterByKey(name);
107 }
108 
109 void Application::SetParameterInt(std::string parameter, int value, bool hasUserValueFlag)
110 {
111  this->SetParameterInt(parameter, value);
112  this->SetParameterUserValue(parameter, hasUserValueFlag);
113 }
114 void Application::SetParameterFloat(std::string parameter, float value, bool hasUserValueFlag)
115 {
116  this->SetParameterFloat(parameter, value);
117  this->SetParameterUserValue(parameter, hasUserValueFlag);
118 }
119 
120 void Application::SetParameterString(std::string parameter, std::string value, bool hasUserValueFlag)
121 {
122  this->SetParameterString(parameter, value);
123  this->SetParameterUserValue(parameter, hasUserValueFlag);
124 }
125 
126 void Application::SetParameterStringList(std::string parameter, std::vector<std::string> values, bool hasUserValueFlag)
127 {
128  this->SetParameterStringList(parameter, values);
129  this->SetParameterUserValue(parameter, hasUserValueFlag);
130 }
131 
132 void Application::SetParameterEmpty(std::string parameter, bool value, bool hasUserValueFlag)
133 {
134  this->SetParameterEmpty(parameter, value);
135  this->SetParameterUserValue(parameter, hasUserValueFlag);
136 }
137 
138 void Application::SetParameterUserValue(std::string paramKey, bool value)
139 {
144  EnableParameter(paramKey);
145  GetParameterByKey(paramKey)->SetUserValue(value);
146 }
147 
148 const Parameter* Application::GetParameterByKey(std::string name) const
149 {
150  // GetParameterList is non const...
151  Application* _this = const_cast<Application*>(this);
152  return _this->GetParameterByKey(name);
153 }
154 
156 {
159  //reset inXML parse checker in case if reinit-ing
160  m_IsInXMLParsed = false;
161  this->DoInit();
162 
163  //rashad: global parameters. now used only for inxml and outxml
164  if(this->GetHaveInXML())
165  {
167  }
168  if(this->GetHaveOutXML())
169  {
171  }
172 }
173 
175 {
176  //read application from xml only once m_IsInXMLParsed is in charge of it.
177  std::string inXMLKey = "inxml";
179  {
181  IsParameterEnabled(inXMLKey) && HasValue(inXMLKey) )
182  {
183  Parameter* param = GetParameterByKey(inXMLKey);
184  InputProcessXMLParameter* inXMLParam = dynamic_cast<InputProcessXMLParameter*>(param);
185  inXMLParam->Read(this);
186  m_IsInXMLParsed = true;
187  }
188  }
189  this->DoUpdateParameters();
190 }
191 
193 {}
194 
196 {
197 
198  this->UpdateParameters();
199 
200  // before execute we set the seed of mersenne twister
201  std::vector<std::string> paramList = GetParametersKeys(true);
202  bool UseSpecificSeed = false;
203 
204  for (std::vector<std::string>::const_iterator it = paramList.begin(); it != paramList.end(); ++it)
205  {
206  std::string key = *it;
207  if ((key.compare(0, 4, "rand") == 0) && HasValue("rand"))
208  {
209  UseSpecificSeed = true;
210  Parameter* param = GetParameterByKey(key);
211  IntParameter* randParam = dynamic_cast<IntParameter*> (param);
212  int seed = randParam->GetValue();
214  }
215  }
216  if (!UseSpecificSeed)
217  {
219  }
220 
221  this->DoExecute();
222 
223  return 0;
224 }
225 
227 {
228  int status = this->Execute();
229 
230  if (status == 0)
231  {
232  std::vector<std::string> paramList = GetParametersKeys(true);
233  // First Get the value of the available memory to use with the
234  // writer if a RAMParameter is set
235  bool useRAM = false;
236  unsigned int ram = 0;
237  for (std::vector<std::string>::const_iterator it = paramList.begin();
238  it != paramList.end();
239  ++it)
240  {
241  std::string key = *it;
242 
244  && IsParameterEnabled(key))
245  {
246  Parameter* param = GetParameterByKey(key);
247  RAMParameter* ramParam = dynamic_cast<RAMParameter*>(param);
248  ram = ramParam->GetValue();
249  useRAM = true;
250  }
251  }
252 
253  for (std::vector<std::string>::const_iterator it = paramList.begin();
254  it != paramList.end();
255  ++it)
256  {
257  std::string key = *it;
259  && IsParameterEnabled(key) && HasValue(key) )
260  {
261  Parameter* param = GetParameterByKey(key);
262  OutputImageParameter* outputParam = dynamic_cast<OutputImageParameter*>(param);
263  outputParam->InitializeWriters();
264  if (useRAM)
265  {
266  outputParam->SetRAMValue(ram);
267  }
268  std::ostringstream progressId;
269  progressId << "Writing " << outputParam->GetFileName() << "...";
270  AddProcess(outputParam->GetWriter(), progressId.str());
271  outputParam->Write();
272  }
274  && IsParameterEnabled(key) && HasValue(key) )
275  {
276  Parameter* param = GetParameterByKey(key);
277  OutputVectorDataParameter* outputParam = dynamic_cast<OutputVectorDataParameter*>(param);
278  outputParam->InitializeWriters();
279  std::ostringstream progressId;
280  progressId << "Writing " << outputParam->GetFileName() << "...";
281  AddProcess(outputParam->GetWriter(), progressId.str());
282  outputParam->Write();
283  }
285  && IsParameterEnabled(key) && HasValue(key) )
286  {
287  Parameter* param = GetParameterByKey(key);
288  ComplexOutputImageParameter* outputParam = dynamic_cast<ComplexOutputImageParameter*>(param);
289  outputParam->InitializeWriters();
290  if (useRAM)
291  {
292  outputParam->SetRAMValue(ram);
293  }
294  std::ostringstream progressId;
295  progressId << "Writing " << outputParam->GetFileName() << "...";
296  AddProcess(outputParam->GetWriter(), progressId.str());
297  outputParam->Write();
298  }
299 
300  //xml writer parameter
302  && IsParameterEnabled(key) && HasValue(key) )
303  {
304  Parameter* param = GetParameterByKey(key);
305  OutputProcessXMLParameter* outXMLParam = dynamic_cast<OutputProcessXMLParameter*>(param);
306  outXMLParam->Write(this);
307  }
308  }
309  }
310 
312 
313  return status;
314 }
315 
316 /* Enable the use of an optional parameter. Returns the previous state */
317 void Application::EnableParameter(std::string paramKey)
318 {
319  Parameter* param = GetParameterByKey(paramKey);
320  param->SetActive(true);
321 }
322 
323 /* Disable the use of an optional parameter. Returns the previous state */
324 void Application::DisableParameter(std::string paramKey)
325 {
326  GetParameterByKey(paramKey)->SetActive(false);
327 }
328 
329 /* Return the enable state of an optional parameter */
330 bool Application::IsParameterEnabled(std::string paramKey, bool recurseParents) const
331 {
332  return GetParameterByKey(paramKey)->GetActive(recurseParents);
333 }
334 
335 /* Return true if the specified parameter is mandatory */
336 bool Application::IsMandatory(std::string paramKey) const
337 {
338  return GetParameterByKey(paramKey)->GetMandatory();
339 }
340 
341 void Application::MandatoryOn(std::string paramKey)
342 {
343  GetParameterByKey(paramKey)->SetMandatory(true);
344 }
345 
346 void Application::MandatoryOff(std::string paramKey)
347 {
348  GetParameterByKey(paramKey)->SetMandatory(false);
349 }
350 
351 /* Return true if the specified parameter was set automatically in the
352  * application
353  */
354 bool Application::HasAutomaticValue(std::string paramKey) const
355 {
356  return GetParameterByKey(paramKey)->GetAutomaticValue();
357 }
358 
359 void Application::AutomaticValueOn(std::string paramKey)
360 {
361  GetParameterByKey(paramKey)->SetAutomaticValue(true);
362 }
363 
364 void Application::AutomaticValueOff(std::string paramKey)
365 {
366  GetParameterByKey(paramKey)->SetAutomaticValue(false);
367 }
368 
369 /* Returns true if the parameter has an associated value provided externally
370  * (not automatically computed by the application) */
371 bool Application::HasUserValue(std::string paramKey) const
372 {
373  return GetParameterByKey(paramKey)->HasUserValue();
374 }
375 
376 /* If a user value was provided clear it and update the other parameters */
377 void Application::ClearValue(std::string paramKey)
378 {
379  GetParameterByKey(paramKey)->ClearValue();
380 }
381 
382 /* Returns true if the parameter has an associated value.
383  * This value can be an automatically computed value or default value,
384  * or a value set externally by user */
385 bool Application::HasValue(std::string paramKey) const
386 {
387  return GetParameterByKey(paramKey)->HasValue();
388 }
389 
390 /* Return the user level of access to a parameter */
392 {
393  return GetParameterByKey(paramKey)->GetUserLevel();
394 }
395 
396 
397 /* Return the role (input/output) of a parameter */
398 Role Application::GetParameterRole(std::string paramKey) const
399 {
400  return GetParameterByKey(paramKey)->GetRole();
401 }
402 
403 void Application::SetParameterEmpty(std::string paramKey, bool active)
404 {
405  GetParameterByKey(paramKey)->SetActive(active);
406 }
407 
408 bool Application::GetParameterEmpty(std::string paramKey)
409 {
410  return GetParameterByKey(paramKey)->GetActive();
411 }
412 
413 /* Return the role (input/output) of a parameter */
414 void Application::SetParameterRole(std::string paramKey, Role role)
415 {
416  GetParameterByKey(paramKey)->SetRole(role);
417 }
418 
419 /* Get the parameter type from its name */
420 ParameterType Application::GetParameterType(std::string paramKey) const
421 {
422  const Parameter* param = GetParameterByKey(paramKey);
423 
424  ParameterType type;
425 
426  if (dynamic_cast<const ChoiceParameter*>(param))
427  {
428  type = ParameterType_Choice;
429  }
430  else if (dynamic_cast<const ListViewParameter*>(param))
431  {
432  type = ParameterType_ListView;
433  }
434  else if (dynamic_cast<const RadiusParameter*>(param))
435  {
436  type = ParameterType_Radius;
437  }
438  else if (dynamic_cast<const EmptyParameter*>(param))
439  {
440  type = ParameterType_Empty;
441  }
442  else if (dynamic_cast<const IntParameter*>(param))
443  {
444  type = ParameterType_Int;
445  }
446  else if (dynamic_cast<const FloatParameter*>(param))
447  {
448  type = ParameterType_Float;
449  }
450  else if (dynamic_cast<const InputFilenameParameter*>(param))
451  {
453  }
454  else if (dynamic_cast<const InputFilenameListParameter*>(param))
455  {
457  }
458  else if (dynamic_cast<const OutputFilenameParameter*>(param))
459  {
461  }
462  else if (dynamic_cast<const DirectoryParameter*>(param))
463  {
465  }
466  else if (dynamic_cast<const InputImageParameter*>(param))
467  {
469  }
470  else if (dynamic_cast<const InputImageListParameter*>(param))
471  {
473  }
474  else if (dynamic_cast<const ComplexInputImageParameter*>(param))
475  {
477  }
478  else if (dynamic_cast<const InputVectorDataParameter*>(param))
479  {
481  }
482  else if (dynamic_cast<const InputVectorDataListParameter*>(param))
483  {
485  }
486  else if (dynamic_cast<const OutputImageParameter*>(param))
487  {
489  }
490  else if (dynamic_cast<const ComplexOutputImageParameter*>(param))
491  {
493  }
494  else if (dynamic_cast<const OutputVectorDataParameter*>(param))
495  {
497  }
498  else if (dynamic_cast<const StringParameter*>(param))
499  {
500  type = ParameterType_String;
501  }
502  else if (dynamic_cast<const StringListParameter*>(param))
503  {
505  }
506  else if (dynamic_cast<const RAMParameter*>(param))
507  {
508  type = ParameterType_RAM;
509  }
510  else if (dynamic_cast<const ParameterGroup*>(param))
511  {
512  type = ParameterType_Group;
513  }
514  else if (dynamic_cast<const OutputProcessXMLParameter*>(param))
515  {
517  }
518  else if (dynamic_cast<const InputProcessXMLParameter*>(param))
519  {
521  }
522  else
523  {
524  itkExceptionMacro(<< "Unknown parameter : " << paramKey);
525  }
526 
527  return type;
528 }
529 
530 std::vector<std::string> Application::GetChoiceKeys(std::string name)
531 {
532  Parameter* param = GetParameterByKey(name);
533  if (dynamic_cast<ChoiceParameter*>(param))
534  {
535  ChoiceParameter* paramChoice = dynamic_cast<ChoiceParameter*>(param);
536  return paramChoice->GetChoiceKeys();
537  }
538  else if (dynamic_cast<ListViewParameter*>(param))
539  {
540  ListViewParameter* paramList = dynamic_cast<ListViewParameter*>(param);
541  return paramList->GetChoiceKeys();
542  }
543  itkExceptionMacro(<< name << " is not a choice parameter");
544 }
545 
546 std::vector<std::string> Application::GetChoiceNames(std::string name)
547 {
548  Parameter* param = GetParameterByKey(name);
549  if (dynamic_cast<ChoiceParameter*>(param))
550  {
551  ChoiceParameter* paramChoice = dynamic_cast<ChoiceParameter*>(param);
552  return paramChoice->GetChoiceNames();
553  }
554  else if (dynamic_cast<ListViewParameter*>(param))
555  {
556  ListViewParameter* paramList = dynamic_cast<ListViewParameter*>(param);
557  return paramList->GetChoiceNames();
558  }
559  itkExceptionMacro(<< name << " is not a choice parameter");
560 }
561 
562 void Application::SetParameterInt(std::string parameter, int value)
563 {
564  Parameter* param = GetParameterByKey(parameter);
565 
566  if (dynamic_cast<IntParameter*>(param))
567  {
568  IntParameter* paramInt = dynamic_cast<IntParameter*>(param);
569  paramInt->SetValue(value);
570  }
571  else if (dynamic_cast<FloatParameter*>(param))
572  {
573  FloatParameter* paramFloat = dynamic_cast<FloatParameter*>(param);
574  paramFloat->SetValue(static_cast<float>(value));
575  }
576  else if (dynamic_cast<RadiusParameter*>(param))
577  {
578  RadiusParameter* paramRadius = dynamic_cast<RadiusParameter*>(param);
579  paramRadius->SetValue(static_cast<unsigned int>(value));
580  }
581  else if (dynamic_cast<ChoiceParameter*>(param))
582  {
583  ChoiceParameter* paramChoice = dynamic_cast<ChoiceParameter*>(param);
584  paramChoice->SetValue(value);
585  }
586 }
587 
588 void Application::SetParameterFloat(std::string parameter, float value)
589 {
590  Parameter* param = GetParameterByKey(parameter);
591 
592  if (dynamic_cast<FloatParameter*>(param))
593  {
594  FloatParameter* paramFloat = dynamic_cast<FloatParameter*>(param);
595  paramFloat->SetValue(value);
596  }
597 }
598 
599 void Application::SetDefaultParameterInt(std::string parameter, int value)
600 {
601  Parameter* param = GetParameterByKey(parameter);
602 
603  if (dynamic_cast<RadiusParameter*>(param))
604  {
605  RadiusParameter* paramRadius = dynamic_cast<RadiusParameter*>(param);
606  paramRadius->SetDefaultValue(value);
607  paramRadius->SetValue(value);
608  }
609  else if (dynamic_cast<IntParameter*>(param))
610  {
611  IntParameter* paramInt = dynamic_cast<IntParameter*>(param);
612  paramInt->SetDefaultValue(value);
613  paramInt->SetValue(value);
614  }
615  else if (dynamic_cast<FloatParameter*>(param))
616  {
617  FloatParameter* paramFloat = dynamic_cast<FloatParameter*>(param);
618  paramFloat->SetDefaultValue(static_cast<float>(value));
619  paramFloat->SetValue(static_cast<float>(value));
620  }
621  else if (dynamic_cast<RAMParameter*>(param))
622  {
623  RAMParameter* paramRAM = dynamic_cast<RAMParameter*>(param);
624  paramRAM->SetDefaultValue(static_cast<unsigned int>(value));
625  paramRAM->SetValue(static_cast<unsigned int>(value));
626  }
627 }
628 
629 void Application::SetDefaultParameterFloat(std::string parameter, float value)
630 {
631  Parameter* param = GetParameterByKey(parameter);
632 
633  if (dynamic_cast<FloatParameter*>(param))
634  {
635  FloatParameter* paramFloat = dynamic_cast<FloatParameter*>(param);
636  paramFloat->SetDefaultValue(value);
637  paramFloat->SetValue(value);
638  }
639 }
640 
641 void Application::SetMinimumParameterIntValue(std::string parameter, int value)
642 {
643  Parameter* param = GetParameterByKey(parameter);
644 
645  if (dynamic_cast<IntParameter*>(param))
646  {
647  IntParameter* paramInt = dynamic_cast<IntParameter*>(param);
648  paramInt->SetMinimumValue(value);
649  }
650  else
651  itkExceptionMacro(<<parameter << "parameter can't be casted to int");
652 }
653 
654 void Application::SetMaximumParameterIntValue(std::string parameter, int value)
655 {
656  Parameter* param = GetParameterByKey(parameter);
657 
658  if (dynamic_cast<IntParameter*>(param))
659  {
660  IntParameter* paramInt = dynamic_cast<IntParameter*>(param);
661  paramInt->SetMaximumValue(value);
662  }
663  else
664  itkExceptionMacro(<<parameter << "parameter can't be casted to int");
665 
666 }
667 
668 void Application::SetMinimumParameterFloatValue(std::string parameter, float value)
669 {
670  Parameter* param = GetParameterByKey(parameter);
671 
672  if (dynamic_cast<FloatParameter*>(param))
673  {
674  FloatParameter* paramFloat = dynamic_cast<FloatParameter*>(param);
675  paramFloat->SetMinimumValue(value);
676  }
677  else
678  itkExceptionMacro(<<parameter << "parameter can't be casted to float");
679 }
680 
681 void Application::SetMaximumParameterFloatValue(std::string parameter, float value)
682 {
683  Parameter* param = GetParameterByKey(parameter);
684 
685  if (dynamic_cast<FloatParameter*>(param))
686  {
687  FloatParameter* paramFloat = dynamic_cast<FloatParameter*>(param);
688  paramFloat->SetMaximumValue(value);
689  }
690  else
691  itkExceptionMacro(<<parameter << "parameter can't be casted to float");
692 
693 }
694 
695 
696 void Application::SetParameterString(std::string parameter, std::string value)
697 {
698  Parameter* param = GetParameterByKey(parameter);
699 
700  if (dynamic_cast<ChoiceParameter*>(param))
701  {
702  ChoiceParameter* paramDown = dynamic_cast<ChoiceParameter*>(param);
703  paramDown->SetValue(value);
704  }
705  else if (dynamic_cast<ListViewParameter*>(param))
706  {
707  ListViewParameter* paramDown = dynamic_cast<ListViewParameter*>(param);
708  paramDown->SetValue(value);
709  }
710  else if (dynamic_cast<StringParameter*>(param))
711  {
712  StringParameter* paramDown = dynamic_cast<StringParameter*>(param);
713  paramDown->SetValue(value);
714  }
715  else if (dynamic_cast<InputFilenameParameter*>(param))
716  {
717  InputFilenameParameter* paramDown = dynamic_cast<InputFilenameParameter*>(param);
718  paramDown->SetValue(value);
719  }
720  else if (dynamic_cast<OutputFilenameParameter*>(param))
721  {
722  OutputFilenameParameter* paramDown = dynamic_cast<OutputFilenameParameter*>(param);
723  paramDown->SetValue(value);
724  }
725  else if (dynamic_cast<DirectoryParameter*>(param))
726  {
727  DirectoryParameter* paramDown = dynamic_cast<DirectoryParameter*>(param);
728  paramDown->SetValue(value);
729  }
730  else if (dynamic_cast<FloatParameter*>(param))
731  {
732  FloatParameter* paramDown = dynamic_cast<FloatParameter*>(param);
733  paramDown->SetValue(value);
734  }
735  else if (dynamic_cast<RadiusParameter*>(param))
736  {
737  RadiusParameter* paramDown = dynamic_cast<RadiusParameter*>(param);
738  paramDown->SetValue(value);
739  }
740  else if (dynamic_cast<IntParameter*>(param))
741  {
742  IntParameter* paramDown = dynamic_cast<IntParameter*>(param);
743  paramDown->SetValue(value);
744  }
745  else if (dynamic_cast<InputImageParameter*>(param))
746  {
747  InputImageParameter* paramDown = dynamic_cast<InputImageParameter*>(param);
748  if ( !paramDown->SetFromFileName(value) )
749  otbAppLogCRITICAL( <<"Invalid image filename " << value <<".");
750 
751  }
752  else if (dynamic_cast<ComplexInputImageParameter*>(param))
753  {
754  ComplexInputImageParameter* paramDown = dynamic_cast<ComplexInputImageParameter*>(param);
755  paramDown->SetFromFileName(value);
756  }
757  else if (dynamic_cast<InputVectorDataParameter*>(param))
758  {
759  InputVectorDataParameter* paramDown = dynamic_cast<InputVectorDataParameter*>(param);
760  if ( !paramDown->SetFromFileName(value) )
761  otbAppLogCRITICAL( <<"Invalid vector data filename " << value <<".");
762  }
763  else if (dynamic_cast<OutputImageParameter*>(param))
764  {
765  OutputImageParameter* paramDown = dynamic_cast<OutputImageParameter*>(param);
766  paramDown->SetFileName(value);
767  }
768  else if (dynamic_cast<ComplexOutputImageParameter*>(param))
769  {
770  ComplexOutputImageParameter* paramDown = dynamic_cast<ComplexOutputImageParameter*>(param);
771  paramDown->SetFileName(value);
772  }
773  else if (dynamic_cast<OutputVectorDataParameter*>(param))
774  {
775  OutputVectorDataParameter* paramDown = dynamic_cast<OutputVectorDataParameter*>(param);
776  paramDown->SetFileName(value);
777  }
778  else if (dynamic_cast<RAMParameter*>(param))
779  {
780  RAMParameter* paramDown = dynamic_cast<RAMParameter*>(param);
781  paramDown->SetValue(value);
782  }
783  else if (dynamic_cast<OutputProcessXMLParameter*>(param))
784  {
785  OutputProcessXMLParameter* paramDown = dynamic_cast<OutputProcessXMLParameter*>(param);
786  paramDown->SetValue(value);
787  }
788  else if (dynamic_cast<InputProcessXMLParameter*>(param))
789  {
790  InputProcessXMLParameter* paramDown = dynamic_cast<InputProcessXMLParameter*>(param);
791  paramDown->SetValue(value);
792  }
793 }
794 
795 void Application::SetParameterStringList(std::string parameter, std::vector<std::string> value)
796 {
797  Parameter* param = GetParameterByKey(parameter);
798 
799  if (dynamic_cast<InputImageListParameter*>(param))
800  {
801  InputImageListParameter* paramDown = dynamic_cast<InputImageListParameter*>(param);
802  if( !paramDown->SetListFromFileName(value) )
803  otbAppLogCRITICAL( <<"At least one image filename is invalid.");
804  }
805  else if (dynamic_cast<InputVectorDataListParameter*>(param))
806  {
807  InputVectorDataListParameter* paramDown = dynamic_cast<InputVectorDataListParameter*>(param);
808  if( !paramDown->SetListFromFileName(value) )
809  otbAppLogCRITICAL( <<"At least one vector data filename is invalid..");
810  }
811  else if (dynamic_cast<InputFilenameListParameter*>(param))
812  {
813  InputFilenameListParameter* paramDown = dynamic_cast<InputFilenameListParameter*>(param);
814  if( !paramDown->SetListFromFileName(value) )
815  otbAppLogCRITICAL( <<"At least one filename is invalid..");
816  }
817  else if (dynamic_cast<StringListParameter*>(param))
818  {
819  StringListParameter* paramDown = dynamic_cast<StringListParameter*>(param);
820  paramDown->SetValue(value);
821  }
822  else if(dynamic_cast<ListViewParameter *>(param))
823  {
824  ListViewParameter * paramDown = dynamic_cast<ListViewParameter *>(param);
825  paramDown->SetSelectedNames(value);
826  }
827 }
828 
830 {
831  Parameter* param = GetParameterByKey(parameter);
832 
833  if (dynamic_cast<OutputImageParameter*>(param))
834  {
835  OutputImageParameter* paramDown = dynamic_cast<OutputImageParameter*>(param);
836  paramDown->SetValue(value);
837  }
838 }
839 
841 {
842  Parameter* param = GetParameterByKey(parameter);
843 
844  if (dynamic_cast<ComplexOutputImageParameter*>(param))
845  {
846  ComplexOutputImageParameter* paramDown = dynamic_cast<ComplexOutputImageParameter*>(param);
847  paramDown->SetValue(value);
848  }
849 }
850 
851 void Application::SetParameterOutputImagePixelType(std::string parameter, ImagePixelType pixelType)
852 {
853  Parameter* param = GetParameterByKey(parameter);
854 
855  if (dynamic_cast<OutputImageParameter*>(param))
856  {
857  OutputImageParameter* paramDown = dynamic_cast<OutputImageParameter*>(param);
858  paramDown->SetPixelType(pixelType);
859  }
860 }
861 
863  ComplexImagePixelType cpixelType)
864 {
865  Parameter* param = GetParameterByKey(parameter);
866 
867  if (dynamic_cast<ComplexOutputImageParameter*>(param))
868  {
869  ComplexOutputImageParameter* paramDown = dynamic_cast<ComplexOutputImageParameter*>(param);
870  paramDown->SetComplexPixelType(cpixelType);
871  }
872 }
873 
875 {
876  Parameter* param = GetParameterByKey(parameter);
877 
878  if (dynamic_cast<OutputVectorDataParameter*>(param))
879  {
880  OutputVectorDataParameter* paramDown = dynamic_cast<OutputVectorDataParameter*>(param);
881  paramDown->SetValue(value);
882  }
883 }
884 
885 std::string Application::GetParameterName(std::string parameter)
886 {
887  Parameter* param = GetParameterByKey(parameter);
888  return param->GetName();
889 }
890 
891 std::string Application::GetParameterDescription(std::string parameter)
892 {
893  Parameter* param = GetParameterByKey(parameter);
894  return param->GetDescription();
895 }
896 
897 void Application::SetParameterDescription(std::string parameter, std::string desc)
898 {
899  Parameter* param = GetParameterByKey(parameter);
900  param->SetDescription(desc);
901 }
902 
903 int Application::GetParameterInt(std::string parameter)
904 {
905  int ret = 0;
906  Parameter* param = GetParameterByKey(parameter);
907 
908  if (dynamic_cast<IntParameter*>(param))
909  {
910  IntParameter* paramInt = dynamic_cast<IntParameter*>(param);
911  ret = paramInt->GetValue();
912  }
913  else if (dynamic_cast<FloatParameter*>(param))
914  {
915  FloatParameter* paramFloat = dynamic_cast<FloatParameter*>(param);
916  ret = static_cast<int>(paramFloat->GetValue());
917  }
918  else if (dynamic_cast<RadiusParameter*>(param))
919  {
920  RadiusParameter* paramRadius = dynamic_cast<RadiusParameter*>(param);
921  ret = paramRadius->GetValue();
922  }
923  else if (dynamic_cast<RAMParameter*>(param))
924  {
925  RAMParameter* paramRAM = dynamic_cast<RAMParameter*>(param);
926  ret = paramRAM->GetValue();
927  }
928  else if (dynamic_cast<ChoiceParameter*>(param))
929  {
930  ChoiceParameter* paramChoice = dynamic_cast<ChoiceParameter*>(param);
931  ret = paramChoice->GetValue();
932  }
933  else
934  {
935  itkExceptionMacro(<<parameter << "parameter can't be casted to int");
936  }
937 
938  return ret;
939 }
940 
941 float Application::GetParameterFloat(std::string parameter)
942 {
943  float ret = 0.0;
944  Parameter* param = GetParameterByKey(parameter);
945 
946  if (dynamic_cast<FloatParameter*> (param))
947  {
948  FloatParameter* paramFloat = dynamic_cast<FloatParameter*> (param);
949  ret = paramFloat->GetValue();
950  }
951  else
952  {
953  itkExceptionMacro(<<parameter << "parameter can't be casted to float");
954  }
955 
956  return ret;
957 }
958 
959 std::string Application::GetParameterString(std::string parameter)
960 {
961  std::string ret="";
962  Parameter* param = GetParameterByKey(parameter);
963 
964  if (dynamic_cast<ChoiceParameter*>(param))
965  {
966  ChoiceParameter* paramDown = dynamic_cast<ChoiceParameter*>(param);
967  std::string choiceKey = paramDown->GetChoiceKey( paramDown->GetValue() );
968  size_t lastPointPos = choiceKey.find_last_of('.');
969  if(lastPointPos != std::string::npos)
970  {
971  ret = choiceKey.substr(lastPointPos);
972  }
973  else
974  {
975  ret = choiceKey;
976  }
977  }
978  else if (dynamic_cast<ListViewParameter*>(param))
979  {
980  ListViewParameter* paramDown = dynamic_cast<ListViewParameter*>(param);
981  std::string choiceKey = paramDown->GetChoiceKey( paramDown->GetValue() );
982  size_t lastPointPos = choiceKey.find_last_of('.');
983  if(lastPointPos != std::string::npos)
984  {
985  ret = choiceKey.substr(lastPointPos);
986  }
987  else
988  {
989  ret = choiceKey;
990  }
991  }
992  else if (dynamic_cast<StringParameter*>(param))
993  {
994  StringParameter* paramDown = dynamic_cast<StringParameter*>(param);
995  ret = paramDown->GetValue();
996  }
997  else if (dynamic_cast<InputFilenameParameter*>(param))
998  {
999  InputFilenameParameter* paramDown = dynamic_cast<InputFilenameParameter*>(param);
1000  ret = paramDown->GetValue();
1001  }
1002  else if (dynamic_cast<OutputFilenameParameter*>(param))
1003  {
1004  OutputFilenameParameter* paramDown = dynamic_cast<OutputFilenameParameter*>(param);
1005  ret = paramDown->GetValue();
1006  }
1007  else if (dynamic_cast<DirectoryParameter*>(param))
1008  {
1009  DirectoryParameter* paramDown = dynamic_cast<DirectoryParameter*>(param);
1010  ret = paramDown->GetValue();
1011  }
1012  else if (dynamic_cast<InputImageParameter*>(param))
1013  {
1014  InputImageParameter* paramDown = dynamic_cast<InputImageParameter*>(param);
1015  ret = paramDown->GetFileName();
1016  }
1017  else if (dynamic_cast<ComplexInputImageParameter*>(param))
1018  {
1019  ComplexInputImageParameter* paramDown = dynamic_cast<ComplexInputImageParameter*>(param);
1020  ret = paramDown->GetFileName();
1021  }
1022  else if (dynamic_cast<InputVectorDataParameter*>(param))
1023  {
1024  InputVectorDataParameter* paramDown = dynamic_cast<InputVectorDataParameter*>(param);
1025  ret = paramDown->GetFileName();
1026  }
1027  else if (dynamic_cast<OutputImageParameter*>(param))
1028  {
1029  OutputImageParameter* paramDown = dynamic_cast<OutputImageParameter*>(param);
1030  ret = paramDown->GetFileName();
1031  }
1032  else if (dynamic_cast<OutputVectorDataParameter*>(param))
1033  {
1034  OutputVectorDataParameter* paramDown = dynamic_cast<OutputVectorDataParameter*>(param);
1035  ret = paramDown->GetFileName();
1036  }
1037  else if (dynamic_cast<OutputProcessXMLParameter*>(param))
1038  {
1039  OutputProcessXMLParameter* paramDown = dynamic_cast<OutputProcessXMLParameter*>(param);
1040  ret = paramDown->GetFileName();
1041  }
1042  else if (dynamic_cast<InputProcessXMLParameter*>(param))
1043  {
1044  InputProcessXMLParameter* paramDown = dynamic_cast<InputProcessXMLParameter*>(param);
1045  ret = paramDown->GetFileName();
1046  }
1047  else
1048  {
1049  itkExceptionMacro(<<parameter << " : parameter can't be casted to string");
1050  }
1051 
1052  return ret;
1053 }
1054 
1055 std::vector<std::string> Application::GetParameterStringList(std::string parameter)
1056 {
1057  std::vector<std::string> ret;
1058  Parameter* param = GetParameterByKey(parameter);
1059 
1060  if (dynamic_cast<InputImageListParameter*> (param))
1061  {
1062  InputImageListParameter* paramDown = dynamic_cast<InputImageListParameter*> (param);
1063  ret = paramDown->GetFileNameList();
1064  }
1065  else
1066  if (dynamic_cast<InputVectorDataListParameter*> (param))
1067  {
1068  InputVectorDataListParameter* paramDown = dynamic_cast<InputVectorDataListParameter*> (param);
1069  ret = paramDown->GetFileNameList();
1070  }
1071  else
1072  if (dynamic_cast<InputFilenameListParameter*> (param))
1073  {
1074  InputFilenameListParameter* paramDown = dynamic_cast<InputFilenameListParameter*> (param);
1075  ret = paramDown->GetFileNameList();
1076  }
1077  else
1078  if (dynamic_cast<StringListParameter*> (param))
1079  {
1080  StringListParameter* paramDown = dynamic_cast<StringListParameter*> (param);
1081  ret = paramDown->GetValue();
1082  }
1083  else
1084  if (dynamic_cast<ListViewParameter*> (param))
1085  {
1086  ListViewParameter* paramDown = dynamic_cast<ListViewParameter*> (param);
1087  ret = paramDown->GetSelectedNames();
1088  }
1089  else
1090  {
1091  itkExceptionMacro(<<parameter << "parameter can't be casted to StringList");
1092  }
1093 
1094  return ret;
1095 }
1096 
1097 
1099 {
1101  Parameter* param = GetParameterByKey(parameter);
1102 
1103  if (dynamic_cast<InputImageParameter*> (param))
1104  {
1105  InputImageParameter* paramDown = dynamic_cast<InputImageParameter*> (param);
1106  ret = paramDown->GetImage();
1107  }
1108  else
1109  {
1110  itkExceptionMacro(<<parameter << "parameter can't be casted to ImageType");
1111  }
1112 
1113  return ret;
1114 }
1115 
1117 {
1119  Parameter* param = GetParameterByKey(parameter);
1120 
1121  if (dynamic_cast<InputImageListParameter*>(param))
1122  {
1123  InputImageListParameter* paramDown = dynamic_cast<InputImageListParameter*>(param);
1124  ret = paramDown->GetImageList();
1125  }
1126  else
1127  {
1128  itkExceptionMacro(<<parameter << "parameter can't be casted to ImageListType");
1129  }
1130 
1131  return ret;
1132 }
1133 
1135 {
1137  Parameter* param = GetParameterByKey(parameter);
1138 
1139  if (dynamic_cast<ComplexInputImageParameter*>(param))
1140  {
1141  ComplexInputImageParameter* paramDown = dynamic_cast<ComplexInputImageParameter*>(param);
1142  ret = paramDown->GetImage();
1143  }
1144  else
1145  {
1146  itkExceptionMacro(<<parameter << "parameter can't be casted to ComplexImageType");
1147  }
1148 
1149  return ret;
1150 }
1151 
1153 {
1155  Parameter* param = GetParameterByKey(parameter);
1156 
1157  if (dynamic_cast<InputVectorDataParameter*>(param))
1158  {
1159  InputVectorDataParameter* paramDown = dynamic_cast<InputVectorDataParameter*>(param);
1160  ret = paramDown->GetVectorData();
1161  }
1162  else
1163  {
1164  itkExceptionMacro(<<parameter << "parameter can't be casted to Vector Data");
1165  }
1166  return ret;
1167 }
1168 
1170 {
1172  Parameter* param = GetParameterByKey(parameter);
1173 
1174  if (dynamic_cast<InputVectorDataListParameter*>(param))
1175  {
1176  InputVectorDataListParameter* paramDown = dynamic_cast<InputVectorDataListParameter*>(param);
1177  ret = paramDown->GetVectorDataList();
1178  }
1179  else
1180  {
1181  itkExceptionMacro(<<parameter << "parameter can't be casted to Vector Data List");
1182  }
1183  return ret;
1184 }
1185 
1186 
1187 std::string Application::GetParameterAsString(std::string paramKey)
1188 {
1189  std::string ret="";
1190  ParameterType type = this->GetParameterType( paramKey );
1191 
1196  || type == ParameterType_ListView || type == ParameterType_Choice
1198  {
1199  ret = this->GetParameterString( paramKey );
1200  }
1201  else if ( type == ParameterType_Int || type == ParameterType_Radius
1202  || type == ParameterType_RAM)
1203  {
1204  std::ostringstream oss;
1205  oss << this->GetParameterInt( paramKey );
1206  ret = oss.str();
1207  }
1208  else if( type == ParameterType_Float )
1209  {
1210  std::ostringstream oss;
1211  //oss << std::setprecision(10);
1212  oss << this->GetParameterFloat( paramKey );
1213  ret = oss.str();
1214  }
1215  else if( type == ParameterType_StringList )
1216  {
1217  std::ostringstream oss;
1218  oss << std::setprecision(10);
1219  const std::vector<std::string> strList = this->GetParameterStringList( paramKey );
1220  for (unsigned int i=0; i<strList.size(); i++)
1221  oss << strList[i] << std::endl;
1222  ret = oss.str();
1223  }
1224  else
1225  {
1226  itkExceptionMacro(<<paramKey << " parameter can't be casted to string");
1227  }
1228  return ret;
1229 }
1230 
1232 {
1233  Parameter* param = GetParameterByKey(parameter);
1234  ImagePixelType ret=ImagePixelType_uint8; //by default to avoid warning
1235 
1236  if (dynamic_cast<OutputImageParameter*>(param))
1237  {
1238  OutputImageParameter* paramDown = dynamic_cast<OutputImageParameter*>(param);
1239  ret = paramDown->GetPixelType();
1240  }
1241  else
1242  {
1243  itkExceptionMacro("Unable to find PixelType in parameter "<<parameter<<".");
1244  }
1245 
1246  return ret;
1247 }
1248 
1250 {
1251  Parameter* param = GetParameterByKey(parameter);
1252  ComplexImagePixelType ret=ComplexImagePixelType_float; //by default to avoid warning
1253 
1254  if (dynamic_cast<ComplexOutputImageParameter*>(param))
1255  {
1256  ComplexOutputImageParameter* paramDown = dynamic_cast<ComplexOutputImageParameter*>(param);
1257  ret = paramDown->GetComplexPixelType();
1258  }
1259  else
1260  {
1261  itkExceptionMacro("Unable to find PixelType in parameter "<<parameter<<".");
1262  }
1263 
1264  return ret;
1265 }
1266 
1267 void
1268 Application::AddChoice(std::string paramKey, std::string paramName)
1269 {
1270  GetParameterList()->AddChoice(paramKey, paramName);
1271 }
1272 
1273 void
1274 Application::ClearChoices(std::string paramKey)
1275 {
1276  GetParameterList()->ClearChoices(paramKey);
1277 }
1278 
1279 std::vector<int>
1281 {
1282  return GetParameterList()->GetSelectedItems(param);
1283 }
1284 
1285 void
1286 Application::AddParameter(ParameterType type, std::string paramKey, std::string paramName)
1287 {
1288  GetParameterList()->AddParameter(type, paramKey, paramName);
1289 }
1290 
1291 void Application::AddRAMParameter(std::string paramKey, std::string paramName, unsigned int defaultValue)
1292 {
1293  GetParameterList()->AddParameter(ParameterType_RAM, paramKey, paramName);
1294  SetDefaultParameterInt(paramKey, defaultValue);
1295  MandatoryOff(paramKey);
1296 }
1297 
1298 // paramKey default value = ram
1299 void Application::AddRAMParameter(std::string paramKey)
1300 {
1301  // Get the RAM Parameter from the configuration file
1302  if (otb::ConfigurationFile::GetInstance()->IsValid() )
1303  {
1304  AddRAMParameter(paramKey,
1305  "Available RAM (Mb)",
1306  otb::ConfigurationFile::GetInstance()->GetAvailableRAMInMBytes());
1307  }
1308  else
1309  {
1310  // TODO check this
1311  AddRAMParameter(paramKey,
1312  "Available RAM (Mb)",
1313  128);
1314  }
1315  MandatoryOff(paramKey);
1316  SetParameterDescription(paramKey, "Available memory for processing (in MB)");
1317 }
1318 
1319 void Application::AddRANDParameter(std::string paramKey, std::string paramName, unsigned int defaultValue)
1320 {
1321  GetParameterList()->AddParameter(ParameterType_Int, paramKey, paramName);
1322  SetDefaultParameterInt(paramKey, defaultValue);
1323  MandatoryOff(paramKey);
1324 }
1325 
1326 // paramKey default value = rand
1327 void Application::AddRANDParameter(std::string paramKey)
1328 {
1329  // Get the RAND Parameter from the configuration file
1330 
1331  GetParameterList()->AddParameter(ParameterType_Int, paramKey, "set user defined seed");
1332  MandatoryOff(paramKey);
1333  SetParameterDescription(paramKey, "Set specific seed. with integer value.");
1334 
1335 }
1336 
1337 std::vector< std::pair<std::string, std::string> >
1339 {
1340  std::vector< std::pair<std::string, std::string> > res;
1341  std::vector<std::string> paramList = GetParametersKeys(true);
1342  for (std::vector<std::string>::const_iterator it = paramList.begin();
1343  it != paramList.end();
1344  ++it)
1345  {
1346  Parameter* param = GetParameterByKey(*it);
1347  ParameterType type = GetParameterType(*it);
1348 
1349  if ( type != ParameterType_Group )
1350  {
1351  if ( param->GetRole() == Role_Output && IsParameterEnabled(*it) )
1352  {
1353  std::pair<std::string, std::string> keyVal;
1354  keyVal.first = (*it);
1355  if (type == ParameterType_Float)
1356  {
1357  std::ostringstream oss;
1358  oss << std::setprecision(10);
1359  oss << GetParameterFloat(*it);
1360  keyVal.second = oss.str();
1361  }
1362  else
1363  {
1364  keyVal.second = GetParameterAsString(*it);
1365  }
1366  res.push_back( keyVal );
1367  }
1368  }
1369  }
1370  return res;
1371 }
1372 
1373 bool
1375 {
1376  // Check if all the mandatory parameters are set
1377  bool ready = true;
1378 
1379  std::vector<std::string> paramList = GetParametersKeys(true);
1380  for (std::vector<std::string>::const_iterator it = paramList.begin();
1381  it != paramList.end();
1382  ++it)
1383  {
1384  // Check all Input Parameters with Input Role
1385  if (GetParameterByKey(*it)->GetRole() == Role_Input)
1386  {
1387  // When a parameter is mandatory :
1388  // return false when does not have value and:
1389  // - The param is root
1390  // - The param is not root and belonging to a Mandatory Group
1391  // wich is activated
1392  if ( !this->HasValue(*it) && IsMandatory(*it) )
1393  {
1394  if( GetParameterByKey(*it)->IsRoot() )
1395  {
1396  otbDebugMacro("MISSING : "<< (*it).c_str() << " ( Is Root)");
1397  return false;
1398  }
1399  else
1400  {
1401  // check if the parameter is linked to a root parameter with a chain of active parameters
1402  Parameter* currentParam = GetParameterByKey(*it)->GetRoot();
1403  if (currentParam->IsRoot())
1404  {
1405  otbDebugMacro("MISSING : "<< (*it).c_str() << " ( Is Level 1)");
1406  return false;
1407  }
1408 
1409  int level = 1;
1410 
1411  while (!currentParam->IsRoot())
1412  {
1413  if (!currentParam->GetActive())
1414  {
1415  // the missing parameter is not on an active branch : we can ignore it
1416  break;
1417  }
1418  currentParam = currentParam->GetRoot();
1419 
1420  level++;
1421 
1422  if (currentParam->IsRoot())
1423  {
1424  // the missing parameter is on an active branch : we need it
1425  otbDebugMacro("MISSING : "<< (*it).c_str() << " ( Is Level "<< level<<")");
1426  return false;
1427  }
1428  }
1429  }
1430  }
1431  }
1432  }
1433 
1434  return ready;
1435 }
1436 
1437 void
1438 Application::AddProcess(itk::ProcessObject* object, std::string description)
1439 {
1440  m_ProgressSource = object;
1441  m_ProgressSourceDescription = description;
1442 
1443  AddProcessToWatchEvent event;
1444  event.SetProcess(object);
1445  event.SetProcessDescription(description);
1446  this->InvokeEvent(event);
1447 }
1448 
1450 {
1451  return m_ProgressSource;
1452 }
1453 
1455 {
1457 }
1458 
1459 
1460 }
1461 }

Generated at Sat Mar 8 2014 16:28:47 for Orfeo Toolbox with doxygen 1.8.3.1