Orfeo Toolbox  4.0
otbWrapperParameterGroup.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 =========================================================================*/
40 #include "otbWrapperParameterKey.h"
41 #include "otbWrapperRAMParameter.h"
42 
43 #include <boost/algorithm/string.hpp>
44 
45 namespace otb
46 {
47 namespace Wrapper
48 {
49 
51 {
52 }
53 
55 {
56 }
57 
58 std::vector<std::string>
60 {
61  std::vector<std::string> parameters;
62 
63  ParameterListType::iterator pit;
64  for (pit = m_ParameterList.begin(); pit != m_ParameterList.end(); ++pit)
65  {
66  Parameter* param = *pit;
67  parameters.push_back( param->GetKey() );
68 
69  if (recursive && dynamic_cast<ParameterGroup*>(param))
70  {
71  ParameterGroup* paramAsGroup = dynamic_cast<ParameterGroup*>(param);
72  std::vector<std::string> subparams = paramAsGroup->GetParametersKeys();
73  for (std::vector<std::string>::const_iterator it = subparams.begin();
74  it != subparams.end(); ++it)
75  {
76  parameters.push_back( std::string(paramAsGroup->GetKey()) + "." + *it );
77  }
78  }
79  else if (recursive && dynamic_cast<ChoiceParameter*>(param))
80  {
81  ChoiceParameter* paramAsChoice = dynamic_cast<ChoiceParameter*>(param);
82 
83  std::vector<std::string> subparams = paramAsChoice->GetParametersKeys();
84  for (std::vector<std::string>::const_iterator it = subparams.begin();
85  it != subparams.end(); ++it)
86  {
87  parameters.push_back( std::string(paramAsChoice->GetKey()) + "." + *it );
88  }
89  }
90  }
91  return parameters;
92 }
93 
94 
96 void
97 ParameterGroup::AddChoice(std::string paramKey, std::string paramName)
98 {
99  ParameterKey pKey( paramKey );
100  // Split the parameter name
101  std::vector<std::string> splittedKey = pKey.Split();
102 
103  if( splittedKey.size() > 1 )
104  {
105  // Get the last subkey
106  std::string lastkey = pKey.GetLastElement();
107 
108  std::string parentkey = pKey.GetRoot();
109  Parameter::Pointer parentParam = GetParameterByKey(parentkey);
110 
111  // parentParam must be a choice, a listBox or this is an error
112  ChoiceParameter* comboboxParentAsChoice = dynamic_cast<ChoiceParameter*>(parentParam.GetPointer());
113  ListViewParameter* listBoxParentAsChoice = dynamic_cast<ListViewParameter*>(parentParam.GetPointer());
114 
115  if (comboboxParentAsChoice)
116  {
117  comboboxParentAsChoice->AddChoice(lastkey, paramName);
118  }
119  else if (listBoxParentAsChoice)
120  {
121  listBoxParentAsChoice->AddChoice(lastkey, paramName);
122  }
123  else
124  {
125  itkExceptionMacro(<<parentkey << " is not a choice");
126  }
127  }
128  else
129  {
130  itkExceptionMacro(<<"No choice parameter key given");
131  }
132 }
133 
135 void
136 ParameterGroup::ClearChoices(std::string paramKey)
137 {
138  ParameterKey pKey( paramKey );
139  // Split the parameter name
140  std::vector<std::string> splittedKey = pKey.Split();
141 
142  std::string parentkey;
143  Parameter::Pointer parentParam;
144 
145  if (splittedKey.size() > 1)
146  {
147  parentkey = pKey.GetRoot();
148  parentParam = GetParameterByKey(parentkey);
149  }
150  else
151  {
152  parentParam = GetParameterByKey(splittedKey[0]);
153  }
154 
155  // parentParam must be a choice, a listBox or this is an error
156  ListViewParameter* listBoxParentAsChoice = dynamic_cast<ListViewParameter*>(parentParam.GetPointer());
157 
158  if (listBoxParentAsChoice)
159  {
160  listBoxParentAsChoice->ClearChoices();
161  }
162  else
163  {
164  itkExceptionMacro(<<parentkey << " is not a ListView");
165  }
166 }
167 
168 
170 {
171  Parameter::Pointer tmpParam;
172  tmpParam = OutputProcessXMLParameter::New();
173 // const std::string key = tmpParam->GetKey();
174 // const std::string descr = tmpParam->GetDescription();
175 const std::string defaultXMLFileName = std::string(GetName()) + ".xml";
176  tmpParam->SetActive(false);
177  AddParameter(tmpParam);
178 
179  tmpParam = NULL;
180  /*
181  AddParameter(ParameterType_OutputProcessXML, key, descr);
182  SetParameterDescription(key, descr);
183  MandatoryOff(key);
184  //SetParameterString(key, defaultXMLFileName);
185  DisableParameter(key);
186  */
187 }
188 
190 {
191  Parameter::Pointer tmpParam;
192  tmpParam = InputProcessXMLParameter::New();
193 // const std::string key = tmpParam->GetKey();
194 // const std::string descr = tmpParam->GetDescription();
195  const std::string defaultXMLFileName = std::string(GetName()) + ".xml";
196  tmpParam->SetActive(false);
197  AddParameter(tmpParam);
198 
199  tmpParam = NULL;
200  /*
201  AddParameter(ParameterType_InputProcessXML, key, descr);
202  SetParameterDescription(key, descr);
203  MandatoryOff(key);
204  //SetParameterString(key, defaultXMLFileName);
205  DisableParameter(key);
206 */
207 }
208 
210 std::vector<int>
211 ParameterGroup::GetSelectedItems(std::string paramKey)
212 {
213  std::vector<int> selectedItems;
214  ParameterKey pKey( paramKey );
215  // Split the parameter name
216  std::vector<std::string> splittedKey = pKey.Split();
217 
218  std::string parentkey;
219  Parameter::Pointer parentParam;
220 
221  if (splittedKey.size() > 1)
222  {
223  parentkey = pKey.GetRoot();
224  parentParam = GetParameterByKey(parentkey);
225  }
226  else
227  {
228  parentParam = GetParameterByKey(splittedKey[0]);
229  }
230 
231  // parentParam must be a choice, a listBox or this is an error
232  ListViewParameter* listBoxParentAsChoice = dynamic_cast<ListViewParameter*>(parentParam.GetPointer());
233 
234  if (listBoxParentAsChoice)
235  {
236  selectedItems = listBoxParentAsChoice->GetSelectedItems();
237  }
238  else
239  {
240  itkExceptionMacro(<<parentkey << " is not a ListView");
241  }
242 
243  return selectedItems;
244 }
245 
246 /* Get the parameter type from its string version of ParameterType enum */
248  {
249  if (type == "Choice")
250  {
251  return ParameterType_Choice;
252  }
253  else if (type == "ListView")
254  {
255  return ParameterType_ListView;
256  }
257  else if (type == "Radius")
258  {
259  return ParameterType_Radius;
260  }
261  else if (type == "Empty")
262  {
263  return ParameterType_Empty;
264  }
265  else if (type == "Int")
266  {
267  return ParameterType_Int;
268  }
269  else if (type == "Float")
270  {
271  return ParameterType_Float;
272  }
273  else if (type == "InputFilename")
274  {
276  }
277  else if (type == "InputFilenameList")
278  {
280  }
281  else if (type == "OutputFilename")
282  {
284  }
285  else if (type == "Directory")
286  {
288  }
289  else if (type == "InputImage")
290  {
292  }
293  else if (type == "InputImageList")
294  {
296  }
297  else if (type == "ComplexInputImage")
298  {
300  }
301  else if (type == "InputVectorData")
302  {
304  }
305  else if (type == "InputVectorDataList")
306  {
308  }
309  else if (type == "OutputImage")
310  {
312  }
313  else if (type == "ComplexOutputImage")
314  {
316  }
317  else if (type == "OutputVectorData")
318  {
320  }
321  else if (type == "String")
322  {
323  return ParameterType_String;
324  }
325  else if (type == "StringList")
326  {
328  }
329  else if (type == "RAM")
330  {
331  return ParameterType_RAM;
332  }
333  else if (type == "Group")
334  {
335  return ParameterType_Group;
336  }
337  else if (type == "OutputProcessXML")
338  {
340  }
341  else if (type == "InputProcessXML")
342  {
344  }
345  else
346  {
347  std::cerr << "Cannot find parameter type code for type: " << type << std::endl;
348  return ParameterType_Empty;
349  }
350 }
351 
352 /* Get the parameter type as string from its ParameterType enum */
354 {
355  std::string paramType;
356 
357  switch (type)
358  {
359  case ParameterType_Empty:
360  {
361  paramType = "Empty";
362  }
363  break;
364  case ParameterType_Int:
365  {
366  paramType = "Int";
367  }
368  break;
369  case ParameterType_Float:
370  {
371  paramType = "Float";
372  }
373  break;
375  {
376  paramType = "String";
377  }
378  break;
380  {
381  paramType = "InputFilename";
382  }
383  break;
385  {
386  paramType = "OutputFilename";
387  }
388  break;
390  {
391  paramType = "Directory";
392  }
393  break;
395  {
396  paramType = "InputImage";
397  }
398  break;
400  {
401  paramType = "InputVectorData";
402  }
403  break;
405  {
406  paramType = "OutputImage";
407  }
408  break;
410  {
411  paramType = "OutputVectorData";
412  }
413  break;
415  {
416  paramType = "Radius";
417  }
418  break;
420  {
421  paramType = "Choice";
422  }
423  break;
424  case ParameterType_Group:
425  {
426  paramType = "Group";
427  }
428  break;
430  {
431  paramType = "StringList";
432  }
433  break;
435  {
436  paramType = "InputFilenameList";
437  }
438  break;
440  {
441  paramType = "InputImageList";
442  }
443  break;
445  {
446  paramType = "InputVectorDataList";
447  }
448  break;
450  {
451  paramType = "ListView";
452  }
453  break;
455  {
456  paramType = "ComplexInputImage";
457  }
458  break;
460  {
461  paramType = "ComplexOutputImage";
462  }
463  break;
464  case ParameterType_RAM:
465  {
466  paramType = "RAM";
467  }
468  break;
470  {
471  paramType = "OutputProcessXML";
472  }
473  break;
475  {
476  paramType = "InputProcessXML";
477  }
478  break;
479  default:
480  {
481  std::cerr << "Cannot find string version of parameter type" << std::endl;
482  }
483  }
484  return paramType;
485 }
486 
488 void
489 ParameterGroup::AddParameter(ParameterType type, std::string paramKey, std::string paramName)
490 {
491  ParameterKey pKey(paramKey);
492  // Split the parameter name
493  std::vector<std::string> splittedKey = pKey.Split();
494 
495  // Get the last subkey
496  std::string lastkey = pKey.GetLastElement();
497 
498 
499  std::string parentkey;
500  Parameter::Pointer parentParam;
501 
502  if (splittedKey.size() > 1)
503  {
504  parentkey = pKey.GetRoot();
505  parentParam = GetParameterByKey(parentkey);
506  }
507  else
508  {
509  parentParam = this;
510  }
511 
512  ParameterGroup* parentAsGroup = dynamic_cast<ParameterGroup*> (parentParam.GetPointer());
513  if (parentAsGroup)
514  {
515  Parameter::Pointer newParam;
516  switch (type)
517  {
518  case ParameterType_Empty:
519  {
520  newParam = EmptyParameter::New();
521  }
522  break;
523  case ParameterType_Int:
524  {
525  newParam = IntParameter::New();
526  }
527  break;
528  case ParameterType_Float:
529  {
530  newParam = FloatParameter::New();
531  }
532  break;
534  {
535  newParam = StringParameter::New();
536  }
537  break;
539  {
540  newParam = InputFilenameParameter::New();
541  }
542  break;
544  {
545  newParam = OutputFilenameParameter::New();
546  }
547  break;
549  {
550  newParam = DirectoryParameter::New();
551  }
552  break;
554  {
555  newParam = InputImageParameter::New();
556  }
557  break;
559  {
560  newParam = InputVectorDataParameter::New();
561  }
562  break;
564  {
565  newParam = OutputImageParameter::New();
566  }
567  break;
569  {
570  newParam = OutputVectorDataParameter::New();
571  }
572  break;
574  {
575  newParam = RadiusParameter::New();
576  }
577  break;
579  {
580  newParam = ChoiceParameter::New();
581  }
582  break;
583  case ParameterType_Group:
584  {
585  newParam = ParameterGroup::New();
586  }
587  break;
589  {
590  newParam = StringListParameter::New();
591  }
592  break;
594  {
595  newParam = InputFilenameListParameter::New();
596  }
597  break;
599  {
600  newParam = InputImageListParameter::New();
601  }
602  break;
604  {
606  }
607  break;
609  {
610  newParam = ListViewParameter::New();
611  }
612  break;
614  {
615  newParam = ComplexInputImageParameter::New();
616  }
617  break;
619  {
621  }
622  break;
623  case ParameterType_RAM:
624  {
625  newParam = RAMParameter::New();
626  }
627  break;
629  {
630  newParam = OutputProcessXMLParameter::New();
631  }
632  break;
634  {
635  newParam = InputProcessXMLParameter::New();
636  }
637  break;
638  }
639 
640  if (newParam.IsNull())
641  {
642  itkExceptionMacro(<< "Parameter type not supported for " << paramKey);
643  }
644 
645  newParam->SetKey(lastkey);
646  newParam->SetName(paramName);
647 
648  // If splittedKey is greater than 1, that means that the parameter
649  // is not a root, and have a parent(s):
650  // - Add the parent as root of this param
651  // - Add the param as a child of its parents
652  if (splittedKey.size() > 1)
653  {
654  newParam->SetRoot(parentParam);
655  parentParam->AddChild(newParam);
656  }
657 
658  parentAsGroup->AddParameter(newParam);
659  }
660  else
661  {
662  itkExceptionMacro(<< "Cannot add " << lastkey << " to parameter " << parentkey);
663  }
664 }
665 
666 void
668 {
669  m_ParameterList.push_back(p);
670 }
671 
674 {
675  return m_ParameterList[i];
676 }
677 
680 {
681  ParameterKey pName(name);
682 
683  // Split the parameter name
684  std::vector<std::string> splittedName = pName.Split();
685 
686  // Get the first parameter key
687  std::string parentName = pName.GetFirstElement();
688 
689  // Look for parentName in the current group
690  Parameter::Pointer parentParam;
691  ParameterListType::iterator it;
692  for (it = m_ParameterList.begin(); it != m_ParameterList.end(); ++it)
693  {
694  Parameter::Pointer param = *it;
695 
696  if (param->GetKey() == parentName)
697  {
698  parentParam = param;
699  break;
700  }
701  }
702  if (parentParam.IsNull())
703  {
704  itkExceptionMacro(<< "Could not find parameter " << name)
705  }
706 
707  // If the name contains a child, make a recursive call
708  if (splittedName.size() > 1)
709  {
710  // Handle ParameterGroup case
711  ParameterGroup* parentAsGroup = dynamic_cast<ParameterGroup*>(parentParam.GetPointer());
712  if (parentAsGroup)
713  {
714  // Remove the parent from the param name
715  std::ostringstream childNameOss;
716  std::vector<std::string>::const_iterator it = splittedName.begin() + 1;
717  while(it != splittedName.end())
718  {
719  childNameOss << *it;
720  ++it;
721  if (it != splittedName.end())
722  {
723  childNameOss << ".";
724  }
725  }
726  std::string childName = childNameOss.str();
727 
728  return parentAsGroup->GetParameterByKey(childName);
729  }
730 
731  // Handle ChoiceParameter case
732  ChoiceParameter* parentAsChoice = dynamic_cast<ChoiceParameter*>(parentParam.GetPointer());
733  if (parentAsChoice)
734  {
735  // Check that splittedName[1] is one of the choice
736  ParameterGroup::Pointer associatedParam;
737 
738  // will throw if splittedName[1] is not a choice key
739  associatedParam = parentAsChoice->GetChoiceParameterGroupByKey(splittedName[1]);
740 
741  if (splittedName.size() > 2)
742  {
743  if (associatedParam.IsNull())
744  {
745  itkExceptionMacro(<< "Choice " << splittedName[1] << "in "
746  << splittedName[0] << " has no key named "
747  << splittedName[2]);
748  }
749 
750  // Remove the parent and the choice value from the param name
751  std::ostringstream childNameOss;
752  std::vector<std::string>::const_iterator it = splittedName.begin() + 2;
753  while(it != splittedName.end())
754  {
755  childNameOss << *it;
756  ++it;
757  if (it != splittedName.end())
758  {
759  childNameOss << ".";
760  }
761  }
762  std::string childName = childNameOss.str();
763  return associatedParam->GetParameterByKey(childName);
764  }
765  return associatedParam.GetPointer();
766  }
767  // Neither ParameterGroup, neither ChoiceParameter
768  itkExceptionMacro(<< "No parameter with key " << name);
769  }
770 
771  return parentParam.GetPointer();
772 }
773 
774 unsigned int
776 {
777  return m_ParameterList.size();
778 }
779 
780 }
781 }

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