Orfeo Toolbox  3.16
otbWrapperOutputImageParameter.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 "otbWrapperOutputImageParameter.h"
19 #include "otbClampImageFilter.h"
20 #include "otbClampVectorImageFilter.h"
21 
22 namespace otb
23 {
24 namespace Wrapper
25 {
26 
27 OutputImageParameter::OutputImageParameter()
28  : m_PixelType(ImagePixelType_float), m_RAMValue(0)
29 {
30  this->SetName("Output Image");
31  this->SetKey("out");
32 }
33 
34 
35 OutputImageParameter::~OutputImageParameter()
36 {
37 }
38 
39 void OutputImageParameter::InitializeWriters()
40 {
41  m_UInt8Writer = UInt8WriterType::New();
42  m_Int16Writer = Int16WriterType::New();
43  m_UInt16Writer = UInt16WriterType::New();
44  m_Int32Writer = Int32WriterType::New();
45  m_UInt32Writer = UInt32WriterType::New();
46  m_FloatWriter = FloatWriterType::New();
47  m_DoubleWriter = DoubleWriterType::New();
48 
49  m_VectorUInt8Writer = VectorUInt8WriterType::New();
50  m_VectorInt16Writer = VectorInt16WriterType::New();
51  m_VectorUInt16Writer = VectorUInt16WriterType::New();
52  m_VectorInt32Writer = VectorInt32WriterType::New();
53  m_VectorUInt32Writer = VectorUInt32WriterType::New();
54  m_VectorFloatWriter = VectorFloatWriterType::New();
55  m_VectorDoubleWriter = VectorDoubleWriterType::New();
56 
57  m_RGBUInt8Writer = RGBUInt8WriterType::New();
58  m_RGBAUInt8Writer = RGBAUInt8WriterType::New();
59 }
60 
61 
62 #define otbClampAndWriteImageMacro(InputImageType, OutputImageType, writer) \
63  { \
64  typedef otb::ClampImageFilter<InputImageType, OutputImageType> ClampFilterType; \
65  typename ClampFilterType::Pointer clampFilter = ClampFilterType::New(); \
66  clampFilter->SetInput( dynamic_cast<InputImageType*>(m_Image.GetPointer()) ); \
67  writer->SetFileName( this->GetFileName() ); \
68  writer->SetInput(clampFilter->GetOutput()); \
69  writer->SetAutomaticAdaptativeStreaming(m_RAMValue); \
70  writer->Update(); \
71  }
72 
73 #define otbClampAndWriteVectorImageMacro(InputImageType, OutputImageType, writer) \
74  { \
75  typedef otb::ClampVectorImageFilter<InputImageType, OutputImageType> ClampFilterType; \
76  typename ClampFilterType::Pointer clampFilter = ClampFilterType::New(); \
77  clampFilter->SetInput( dynamic_cast<InputImageType*>(m_Image.GetPointer()) ); \
78  writer->SetFileName(this->GetFileName() ); \
79  writer->SetInput(clampFilter->GetOutput()); \
80  writer->SetAutomaticAdaptativeStreaming(m_RAMValue); \
81  writer->Update(); \
82  }
83 
84 
85 template <class TInputImageType>
86 void
87 OutputImageParameter::SwitchImageWrite()
88 {
89  switch(m_PixelType )
90  {
91  case ImagePixelType_uint8:
92  {
93  otbClampAndWriteImageMacro(TInputImageType, UInt8ImageType, m_UInt8Writer);
94  break;
95  }
96  case ImagePixelType_int16:
97  {
98  otbClampAndWriteImageMacro(TInputImageType, Int16ImageType, m_Int16Writer);
99  break;
100  }
101  case ImagePixelType_uint16:
102  {
103  otbClampAndWriteImageMacro(TInputImageType, UInt16ImageType, m_UInt16Writer);
104  break;
105  }
106  case ImagePixelType_int32:
107  {
108  otbClampAndWriteImageMacro(TInputImageType, Int32ImageType, m_Int32Writer);
109  break;
110  }
111  case ImagePixelType_uint32:
112  {
113  otbClampAndWriteImageMacro(TInputImageType, UInt32ImageType, m_UInt32Writer);
114  break;
115  }
116  case ImagePixelType_float:
117  {
118  otbClampAndWriteImageMacro(TInputImageType, FloatImageType, m_FloatWriter);
119  break;
120  }
121  case ImagePixelType_double:
122  {
123  otbClampAndWriteImageMacro(TInputImageType, DoubleImageType, m_DoubleWriter);
124  break;
125  }
126  }
127 }
128 
129 
130 template <class TInputVectorImageType>
131 void
132 OutputImageParameter::SwitchVectorImageWrite()
133  {
134  switch(m_PixelType )
135  {
136  case ImagePixelType_uint8:
137  {
138  otbClampAndWriteVectorImageMacro(TInputVectorImageType, UInt8VectorImageType, m_VectorUInt8Writer);
139  break;
140  }
141  case ImagePixelType_int16:
142  {
143  otbClampAndWriteVectorImageMacro(TInputVectorImageType, Int16VectorImageType, m_VectorInt16Writer);
144  break;
145  }
146  case ImagePixelType_uint16:
147  {
148  otbClampAndWriteVectorImageMacro(TInputVectorImageType, UInt16VectorImageType, m_VectorUInt16Writer);
149  break;
150  }
151  case ImagePixelType_int32:
152  {
153  otbClampAndWriteVectorImageMacro(TInputVectorImageType, Int32VectorImageType, m_VectorInt32Writer);
154  break;
155  }
156  case ImagePixelType_uint32:
157  {
158  otbClampAndWriteVectorImageMacro(TInputVectorImageType, UInt32VectorImageType, m_VectorUInt32Writer);
159  break;
160  }
161  case ImagePixelType_float:
162  {
163  otbClampAndWriteVectorImageMacro(TInputVectorImageType, FloatVectorImageType, m_VectorFloatWriter);
164  break;
165  }
166  case ImagePixelType_double:
167  {
168  otbClampAndWriteVectorImageMacro(TInputVectorImageType, DoubleVectorImageType, m_VectorDoubleWriter);
169  break;
170  }
171  }
172  }
173 
174 
175 template <class TInputRGBAImageType>
176 void
177 OutputImageParameter::SwitchRGBAImageWrite()
178  {
179  if( m_PixelType == ImagePixelType_uint8 )
180  {
181  m_RGBAUInt8Writer->SetFileName( this->GetFileName() );
182  m_RGBAUInt8Writer->SetInput(dynamic_cast<UInt8RGBAImageType*>(m_Image.GetPointer()) );
183  m_RGBAUInt8Writer->WriteGeomFileOn();
184  m_RGBAUInt8Writer->SetAutomaticAdaptativeStreaming(m_RAMValue);
185  m_RGBAUInt8Writer->Update();
186  }
187  else
188  itkExceptionMacro("Unknown PixelType for RGBA Image.");
189  }
190 
191 template <class TInputRGBImageType>
192 void
193 OutputImageParameter::SwitchRGBImageWrite()
194  {
195  if( m_PixelType == ImagePixelType_uint8 )
196  {
197  m_RGBUInt8Writer->SetFileName( this->GetFileName() );
198  m_RGBUInt8Writer->SetInput(dynamic_cast<UInt8RGBImageType*>(m_Image.GetPointer()) );
199  m_RGBUInt8Writer->WriteGeomFileOn();
200  m_RGBUInt8Writer->SetAutomaticAdaptativeStreaming(m_RAMValue);
201  m_RGBUInt8Writer->Update();
202  }
203  else
204  itkExceptionMacro("Unknown PixelType for RGB Image.");
205  }
206 
207 void
208 OutputImageParameter::Write()
209 {
210  m_Image->UpdateOutputInformation();
211 
212  if (dynamic_cast<UInt8ImageType*>(m_Image.GetPointer()))
213  {
214  SwitchImageWrite<UInt8ImageType>();
215  }
216  else if (dynamic_cast<Int16ImageType*>(m_Image.GetPointer()))
217  {
218  SwitchImageWrite<Int16ImageType>();
219  }
220  else if (dynamic_cast<UInt16ImageType*>(m_Image.GetPointer()))
221  {
222  SwitchImageWrite<UInt16ImageType>();
223  }
224  else if (dynamic_cast<Int32ImageType*>(m_Image.GetPointer()))
225  {
226  SwitchImageWrite<Int32ImageType>();
227  }
228  else if (dynamic_cast<UInt32ImageType*>(m_Image.GetPointer()))
229  {
230  SwitchImageWrite<UInt32ImageType>();
231  }
232  else if (dynamic_cast<FloatImageType*>(m_Image.GetPointer()))
233  {
234  SwitchImageWrite<FloatImageType>();
235  }
236  else if (dynamic_cast<DoubleImageType*>(m_Image.GetPointer()))
237  {
238  SwitchImageWrite<DoubleImageType>();
239  }
240  else if (dynamic_cast<UInt8VectorImageType*>(m_Image.GetPointer()))
241  {
242  SwitchVectorImageWrite<UInt8VectorImageType>();
243  }
244  else if (dynamic_cast<Int16VectorImageType*>(m_Image.GetPointer()))
245  {
246  SwitchVectorImageWrite<Int16VectorImageType>();
247  }
248  else if (dynamic_cast<UInt16VectorImageType*>(m_Image.GetPointer()))
249  {
250  SwitchVectorImageWrite<UInt16VectorImageType>();
251  }
252  else if (dynamic_cast<Int32VectorImageType*>(m_Image.GetPointer()))
253  {
254  SwitchVectorImageWrite<Int32VectorImageType>();
255  }
256  else if (dynamic_cast<UInt32VectorImageType*>(m_Image.GetPointer()))
257  {
258  SwitchVectorImageWrite<UInt32VectorImageType>();
259  }
260  else if (dynamic_cast<FloatVectorImageType*>(m_Image.GetPointer()))
261  {
262  SwitchVectorImageWrite<FloatVectorImageType>();
263  }
264  else if (dynamic_cast<DoubleVectorImageType*>(m_Image.GetPointer()))
265  {
266  SwitchVectorImageWrite<DoubleVectorImageType>();
267  }
268  else if (dynamic_cast<UInt8RGBImageType*>(m_Image.GetPointer()))
269  {
270  SwitchRGBImageWrite<UInt8RGBImageType>();
271  }
272  else if (dynamic_cast<UInt8RGBAImageType*>(m_Image.GetPointer()))
273  {
274  SwitchRGBAImageWrite<UInt8RGBAImageType>();
275  }
276  else
277  {
278  itkExceptionMacro("Unknown image type");
279  }
280  }
281 
282 
283 itk::ProcessObject*
284 OutputImageParameter::GetWriter()
285 {
286  int type = 0;
287  // 0 : image
288  // 1 : VectorImage
289  // 2 : RGBAImage
290  // 3 : RGBImage
291  itk::ProcessObject* writer = 0;
292  if (dynamic_cast<UInt8VectorImageType*> (m_Image.GetPointer())
293  || dynamic_cast<Int16VectorImageType*> (m_Image.GetPointer())
294  || dynamic_cast<UInt16VectorImageType*> (m_Image.GetPointer())
295  || dynamic_cast<Int32VectorImageType*> (m_Image.GetPointer())
296  || dynamic_cast<UInt32VectorImageType*> (m_Image.GetPointer())
297  || dynamic_cast<FloatVectorImageType*> (m_Image.GetPointer())
298  || dynamic_cast<DoubleVectorImageType*> (m_Image.GetPointer()))
299  {
300  type = 1;
301  }
302  else
303  if (dynamic_cast<UInt8RGBAImageType*> (m_Image.GetPointer()))
304  {
305  type = 2;
306  writer = m_RGBAUInt8Writer;
307  itkWarningMacro("UInt8RGBAImageType will be saved in UInt8 format.");
308  return writer;
309  }
310  else
311  if (dynamic_cast<UInt8RGBImageType*> (m_Image.GetPointer()))
312  {
313  type = 3;
314  writer = m_RGBUInt8Writer;
315  itkWarningMacro("UInt8RGBImageType will be saved in UInt8 format.");
316  return writer;
317  }
318 
319 
320  switch (GetPixelType())
321  {
322  case ImagePixelType_uint8:
323  {
324  if (type == 1)
325  writer = m_VectorUInt8Writer;
326  else
327  if (type == 0)
328  writer = m_UInt8Writer;
329  else
330  if (type == 2)
331  writer = m_RGBAUInt8Writer;
332  else writer = m_RGBUInt8Writer;
333  break;
334  }
335  case ImagePixelType_int16:
336  {
337  if (type == 1)
338  writer = m_VectorInt16Writer;
339  else
340  if (type == 0) writer = m_Int16Writer;
341  break;
342  }
343  case ImagePixelType_uint16:
344  {
345  if (type == 1)
346  writer = m_VectorUInt16Writer;
347  else
348  if (type == 0) writer = m_UInt16Writer;
349  break;
350  }
351  case ImagePixelType_int32:
352  {
353  if (type == 1)
354  writer = m_VectorInt32Writer;
355  else
356  if (type == 0) writer = m_Int32Writer;
357  break;
358  }
359  case ImagePixelType_uint32:
360  {
361  if (type == 1)
362  writer = m_VectorUInt32Writer;
363  else
364  if (type == 0) writer = m_UInt32Writer;
365  break;
366  }
367  case ImagePixelType_float:
368  {
369  if (type == 1)
370  writer = m_VectorFloatWriter;
371  else
372  if (type == 0) writer = m_FloatWriter;
373  break;
374  }
375  case ImagePixelType_double:
376  {
377  if (type == 1)
378  writer = m_VectorDoubleWriter;
379  else
380  if (type == 0) writer = m_DoubleWriter;
381  break;
382  }
383  }
384  if (0 == writer)
385  {
386  itkExceptionMacro("Unknown Writer type.");
387  }
388 
389  return writer;
390 }
391 
392 OutputImageParameter::ImageBaseType*
393 OutputImageParameter::GetValue( )
394 {
395  return m_Image;
396 }
397 
398 void
399 OutputImageParameter::SetValue(ImageBaseType* image)
400 {
401  m_Image = image;
402  SetActive(true);
403 }
404 
405 bool
406 OutputImageParameter::HasValue() const
407 {
408  std::string filename(this->GetFileName());
409  return !filename.empty();
410 }
411 
412 }
413 }
Generated at Sun Feb 3 2013 00:59:19 for Orfeo Toolbox with doxygen 1.8.1.1