OTB  6.7.0
Orfeo Toolbox
otbWrapperParameterList.hxx
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2005-2019 Centre National d'Etudes Spatiales (CNES)
3  *
4  * This file is part of Orfeo Toolbox
5  *
6  * https://www.orfeo-toolbox.org/
7  *
8  * Licensed under the Apache License, Version 2.0 (the "License");
9  * you may not use this file except in compliance with the License.
10  * You may obtain a copy of the License at
11  *
12  * http://www.apache.org/licenses/LICENSE-2.0
13  *
14  * Unless required by applicable law or agreed to in writing, software
15  * distributed under the License is distributed on an "AS IS" BASIS,
16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17  * See the License for the specific language governing permissions and
18  * limitations under the License.
19  */
20 
21 #ifndef otbWrapperParameterList_hxx
22 #define otbWrapperParameterList_hxx
23 
24 
25 #include <algorithm>
26 #include <iterator>
27 
28 #include "otbCast.h"
30 
31 
32 namespace otb
33 {
34 
35 namespace Wrapper
36 {
37 
38 
39 /*****************************************************************************/
40 template< typename T >
44  m_Parameters()
45 {
46 }
47 
48 /*****************************************************************************/
49 template< typename T >
52 {
53 }
54 
55 /*****************************************************************************/
56 template< typename T >
59 ::begin() const
60 {
61  return m_Parameters.begin();
62 }
63 
64 /*****************************************************************************/
65 template< typename T >
68 ::end() const
69 {
70  return m_Parameters.end();
71 }
72 
74 template< typename T >
75 bool
77 ::HasValue() const
78 {
79  return
80  Size()>0
81  &&
82  std::all_of(
83  begin(),
84  end(),
85  []( auto p ) -> bool
86  {
87  assert( p!=nullptr );
88  return p && p->HasValue();
89  }
90  );
91 }
93 
94 /*****************************************************************************/
95 template< typename T >
96 void
99 {
100  m_Parameters.clear();
101 
102  Superclass::ClearValue();
103 }
104 
105 /*****************************************************************************/
106 template< typename T >
107 void
110 {
111  this->SetStrings(strings);
112 }
113 
114 /*****************************************************************************/
115 template< typename T >
116 void
118 ::InsertNullElement( std::size_t index )
119 {
120  m_Parameters.insert(
121  index>=m_Parameters.size()
122  ? m_Parameters.end()
123  : m_Parameters.begin() + index,
124  typename T::Pointer()
125  );
126 
127  SetActive( false );
128 
129  Modified();
130 }
131 
132 /*****************************************************************************/
133 template< typename T >
134 void
136 ::AddFromFileName( const std::string & filename )
137 {
138  assert( !filename.empty() );
139 
140  typename T::Pointer p( T::New() );
141 
142  p->FromString(filename);
143 
144  m_Parameters.push_back( p );
145 
146  assert( !m_Parameters.back().IsNull() );
147 
148  SetActive( true );
149 
150  Modified();
151 }
152 
153 /*****************************************************************************/
154 template< typename T >
155 void
157 ::Insert( const std::string & filename, std::size_t index )
158 {
159  typename T::Pointer p( T::New() );
160 
161  p->FromString(filename);
162 
163  m_Parameters.insert( m_Parameters.begin() + index, p );
164 
165  assert( !m_Parameters.back().IsNull() );
166 
167  SetActive( true );
168 
169  Modified();
170 }
171 
173 template< typename T >
174 void
176 ::SetNthFileName( std::size_t i,
177  const std::string & filename )
178 {
179  assert( i<m_Parameters.size() );
180  assert( !m_Parameters[ i ].IsNull() );
182 
183  m_Parameters[i]->FromString(filename);
184 
185  SetActive( true );
186 
187  Modified();
188 }
189 
190 /*****************************************************************************/
191 template< typename T >
192 std::size_t
194 ::SetStrings( const StringVector & strings )
195 {
196  // First clear previous file chosen
197  ClearValue();
198 
199  if ( !strings.empty() )
200  {
201  std::transform(
202  strings.begin(),
203  strings.end(),
204  std::back_inserter( m_Parameters ),
205  []( auto s ) -> auto
206  {
207  typename T::Pointer parameter(T::New());
208  parameter->FromString(s);
209  return parameter;
210  }
211  );
212 
213  SetActive( true );
214  Modified();
215  }
216  return strings.size();
217 }
218 
220 template< typename T >
221 std::size_t
223 ::GetStrings( StringVector & strings ) const
224 {
225  std::transform(
226  begin(),
227  end(),
228  std::back_inserter( strings ),
229  []( auto p ) -> auto
230  {
231  return p->ToString();
232  }
233  );
235 
236  return m_Parameters.size();
237 }
238 
239 /*****************************************************************************/
240 template< typename T >
244 {
245  StringVector filenames;
246 
247  GetStrings( filenames );
248 
249  return filenames;
250 }
251 
252 /*****************************************************************************/
253 template< typename T >
254 std::string
256 ::GetNthFileName( std::size_t i ) const
257 {
258  assert( i<m_Parameters.size() );
259 
260  return m_Parameters[i]->ToString();
261 }
262 
264 template< typename T >
265 const std::string &
267 ::GetToolTip( std::size_t i ) const
268 {
269  assert( i<m_Parameters.size() );
270  assert( !m_Parameters[ i ].IsNull() );
272 
273  return m_Parameters[ i ]->GetDescription();
274 }
275 
277 template< typename T >
278 void
280 ::Erase( std::size_t start, std::size_t count )
281 {
282  assert( start<m_Parameters.size() );
283  assert( start+count<=m_Parameters.size() );
285 
286  m_Parameters.erase(
287  m_Parameters.begin() + start,
288  m_Parameters.begin() + start + count
289  );
290 
291  Modified();
292 }
293 
294 /*****************************************************************************/
295 template< typename T >
296 std::size_t
298 ::Size() const
299 {
300  return m_Parameters.size();
301 }
302 
304 template< typename T >
305 bool
307 ::IsActive( std::size_t i ) const
308 {
309  assert( i<m_Parameters.size() );
310  assert( !m_Parameters[ i ].IsNull() );
312 
313  return m_Parameters[ i ]->GetActive();
314 }
315 
316 /*****************************************************************************/
317 template< typename T >
318 void
320 ::Swap( std::size_t i1, std::size_t i2 )
321 {
322  assert( !m_Parameters.empty() );
323 
324  auto clamp = [ this ]( std::size_t i ) -> std::size_t
325  {
326  return
327  i>=m_Parameters.size()
328  ? m_Parameters.size() - 1
329  : i;
330  };
331 
332  std::swap(
333  m_Parameters[ clamp( i1 ) ],
334  m_Parameters[ clamp( i2 ) ]
335  );
336 }
337 
339 template< typename T >
340 template< typename L, typename From, typename Get >
341 void
343 ::SetObjectList( L & this_list,
344  const L & list,
345  From from,
346  Get get )
347 {
348  // Force update of input-list elements.
349  for( std::size_t i=0; i<list.Size(); i++ )
350  {
351  assert( list.GetNthElement( i )!=nullptr );
353 
354  list.GetNthElement( i )->UpdateOutputInformation();
355  }
356 
357  // Clear previous target list.
358  ClearValue();
359 
360  for( std::size_t i=0; i<list.Size(); i++ )
361  {
362  assert( list.GetNthElement( i )!=nullptr );
363 
364  typename T::Pointer parameter;
365 
366  from( parameter, list.GetNthElement( i ) );
367 
368  m_Parameters.push_back( parameter );
369 
370  assert( get( parameter )!=nullptr );
371 
372  this_list.PushBack( get( parameter ) );
373  }
374 
375  SetActive( true );
376 
377  Modified();
378 }
379 
380 /*****************************************************************************/
381 template< typename T >
382 template< typename L, typename Get >
383 typename L::ObjectType *
385 ::GetObjectList( L & this_list, Get get )
386 {
387  assert( this_list );
388 
389  this_list->Clear();
390 
391  std::for_each(
392  begin(),
393  end(),
394  [ this_list, get ]( auto parameter ) -> void
395  {
396  assert( parameter );
397  assert( parameter==otb::DynamicCast< T >( parameter ) );
398 
399  assert( get( DynamicCast< T >( parameter ) ) );
400 
401  this_list->PushBack(
402  get(
403  DynamicCast< T >( parameter )
404  )
405  );
406  }
407  );
408 
409  return this_list;
410 }
411 
412 /*****************************************************************************/
413 template< typename T >
414 template< typename L, typename Get >
415 const typename L::ObjectType *
417 ::GetObjectList( L & this_list, Get get ) const
418 {
419  return
420  const_cast< ParameterList< T > * >( this )
421  ->GetObjectList( this_list, get );
422 }
423 
424 /*****************************************************************************/
425 template< typename T >
426 template< typename D, typename From >
427 void
429 ::AddData( D * data, From from )
430 {
431  assert( data!=nullptr );
432 
433  // Check input availability
434  data->UpdateOutputInformation();
435 
436  // Build & add parameter.
437  m_Parameters.push_back( from( data ) );
438 
439  Modified();
440 }
441 
442 /*****************************************************************************/
443 template< typename T >
444 template< typename D, typename Set >
445 typename T::Pointer
447 ::FromData( D * data,
448  Set set,
449  const std::string & description )
450 {
451  assert( data!=nullptr );
452 
453  typename T::Pointer p;
454 
455  return From( p, data, set, description );
456 }
457 
458 /*****************************************************************************/
459 template< typename T >
460 template< typename D, typename Set >
461 typename T::Pointer &
463 ::FromData( typename T::Pointer & parameter,
464  D * data,
465  Set set,
466  const std::string & description )
467 {
468  assert( data!=nullptr );
469 
470  parameter = T::New();
471 
472  set( parameter, data );
473  parameter->SetDescription( description );
474 
475  return parameter;
476 }
477 
478 template <typename T>
479 std::vector<std::string> ParameterList<T>::ToStringList() const
480 {
481  return GetFileNameList();
482 }
483 
484 template <typename T>
485 void ParameterList<T>::FromStringList(const std::vector<std::string>& value)
486 {
487  SetStrings(value);
488 }
489 
490 template <typename T>
491 std::string ParameterList<T>::ToString() const
492 {
493  std::ostringstream oss;
494  oss << std::setprecision(10);
495  auto strList = GetFileNameList();
496  for (size_t i = 0; i < strList.size(); i++)
497  {
498  if (i != 0)
499  {
500  oss << " ";
501  }
502  oss << strList[i];
503  }
504  return oss.str();
505 }
506 
507 } // End namespace Wrapper
508 
509 
510 } // End namespace otb
511 
512 
513 #endif
std::vcl_size_t GetStrings(StringVector &) const override
This class is a base class for list-type parameters.
StringVector GetFileNameList() const override
std::vcl_size_t Size() const override
std::vector< std::string > ToStringList() const override
std::vcl_size_t SetStrings(const StringVector &) override
void SetListFromFileName(const StringVector &) override
void Erase(std::vcl_size_t start, std::vcl_size_t count) override
void FromStringList(const std::vector< std::string > &value) override
T::Pointer FromData(D *, Set, const std::string &description=std::string())
This class represents a InputImage parameter.
std::string ToString() const override
bool IsActive(vcl_size_t) const override
void AddFromFileName(const std::string &) override
void Swap(std::vcl_size_t, std::vcl_size_t) override
void Insert(const std::string &, std::vcl_size_t=-1) override
const std::string & GetToolTip(std::vcl_size_t) const override
ParameterVector::const_iterator end() const
std::string GetNthFileName(std::vcl_size_t) const override
void SetNthFileName(std::vcl_size_t, const std::string &) override
void SetObjectList(L &, const L &, From, Get)
ParameterVector::const_iterator begin() const
L::ObjectType * GetObjectList(L &, Get)
void InsertNullElement(std::vcl_size_t=-1) override