Orfeo Toolbox  4.0
otbBSQImageIO.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 "otbBSQImageIO.h"
19 
20 #include <fstream>
21 #include <iostream>
22 
23 #include "itkByteSwapper.h"
24 #include "otbSystem.h"
25 #include "itksys/SystemTools.hxx"
26 
27 #include "otbMacro.h"
28 
29 
30 namespace otb
31 {
32 
34 {
35  // By default set number of dimensions to two.
36  this->SetNumberOfDimensions(2);
40  {
42  }
43  else
44  {
46  }
47 
49  m_TypeBsq = "";
50  // Set default spacing to one
51  m_Spacing[0] = 1.0;
52  m_Spacing[1] = 1.0;
53  // Set default origin to zero
54  m_Origin[0] = 0.0;
55  m_Origin[1] = 0.0;
58 
59  this->AddSupportedWriteExtension(".hd");
60  this->AddSupportedWriteExtension(".HD");
61 
62  this->AddSupportedReadExtension(".hd");
63  this->AddSupportedReadExtension(".HD");
64 
65 }
66 
68 {
69  if (m_HeaderFile.is_open())
70  {
71  m_HeaderFile.close();
72  }
73  if (m_ChannelsFile != NULL)
74  {
75  for (unsigned int numComponent = 0; numComponent < this->GetNumberOfComponents(); numComponent++)
76  {
77  if (m_ChannelsFile[numComponent].is_open())
78  {
79  m_ChannelsFile[numComponent].close();
80  }
81  }
82  delete[] m_ChannelsFile;
83  }
84 }
85 
86 bool BSQImageIO::CanReadFile(const char* filename)
87 {
88  std::fstream header_file;
89  std::string lFileName(filename);
90  std::string extension = itksys::SystemTools::GetFilenameLastExtension(filename);
91  if ((extension != ".HD") && (extension != ".hd"))
92  {
93  return false;
94  }
95  if (itksys::SystemTools::FileIsDirectory(lFileName.c_str()) == true)
96  {
97  return false;
98  }
99  if (itksys::SystemTools::LowerCase(itksys::SystemTools::GetFilenameLastExtension(lFileName)) != ".hd")
100  {
101  return false;
102  }
103 
104  header_file.open(lFileName.c_str(), std::ios::in);
105  if (header_file.fail())
106  {
107  otbMsgDevMacro(<< "BSQImageIO::CanReadFile() failed header open ! ");
108  return false;
109  }
110  //Read header informations
111  bool lResult = InternalReadHeaderInformation(lFileName, header_file, false);
112  header_file.close();
113  return (lResult);
114 }
115 
116 // Used to print information about this object
117 void BSQImageIO::PrintSelf(std::ostream& os, itk::Indent indent) const
118 {
119  Superclass::PrintSelf(os, indent);
120 }
121 
122 // Read a 3D image (or event more bands)... not implemented yet
124 {
125 }
126 
127 // Read image
128 void BSQImageIO::Read(void* buffer)
129 {
130  unsigned long step = this->GetNumberOfComponents();
131  char * p = static_cast<char *>(buffer);
132 
133  int lNbLines = this->GetIORegion().GetSize()[1];
134  int lNbColumns = this->GetIORegion().GetSize()[0];
135  int lFirstLine = this->GetIORegion().GetIndex()[1]; // [1... ]
136  int lFirstColumn = this->GetIORegion().GetIndex()[0]; // [1... ]
137 
138  otbMsgDevMacro(<< " BSQImageIO::Read() ");
139  otbMsgDevMacro(<< " Image size : " << m_Dimensions[0] << "," << m_Dimensions[1]);
140  otbMsgDevMacro(<< " Region read (IORegion) : " << this->GetIORegion());
141  otbMsgDevMacro(<< " Nb Of Components : " << this->GetNumberOfComponents());
142 
143  std::streamoff headerLength(0);
144  std::streamoff numberOfBytesPerLines = static_cast<std::streamoff>(this->GetComponentSize() * m_Dimensions[0]);
145  std::streamoff offset;
146  std::streamsize numberOfBytesToBeRead = this->GetComponentSize() * lNbColumns;
147  std::streamsize numberOfBytesRead;
148  unsigned long cpt = 0;
149 
150  // Update the step variable
151  step = step * (unsigned long) (this->GetComponentSize());
152 
153  char * value = new char[numberOfBytesToBeRead];
154  if (value == NULL)
155  {
156  itkExceptionMacro(<< "BSQImageIO::Read(): Bad alloc");
157  return;
158  }
159 
160  otbMsgDevMacro(<< " sizeof(streamsize) : " << sizeof(std::streamsize));
161  otbMsgDevMacro(<< " sizeof(streampos) : " << sizeof(std::streampos));
162  otbMsgDevMacro(<< " sizeof(streamoff) : " << sizeof(std::streamoff));
163  otbMsgDevMacro(<< " sizeof(std::ios::beg) : " << sizeof(std::ios::beg));
164  otbMsgDevMacro(<< " sizeof(size_t) : " << sizeof(size_t));
165  otbMsgDevMacro(<< " sizeof(unsigned long) : " << sizeof(unsigned long));
166 
167  for (unsigned int nbComponents = 0; nbComponents < this->GetNumberOfComponents(); ++nbComponents)
168  {
169  cpt = (unsigned long) (nbComponents) * (unsigned long) (this->GetComponentSize());
170  //Read region of the channel
171  for (int LineNo = lFirstLine; LineNo < lFirstLine + lNbLines; LineNo++)
172  {
173  offset = headerLength + numberOfBytesPerLines * static_cast<std::streamoff>(LineNo);
174  offset += static_cast<std::streamoff>(this->GetComponentSize() * lFirstColumn);
175  m_ChannelsFile[nbComponents].seekg(offset, std::ios::beg);
176  //Read a line
177  m_ChannelsFile[nbComponents].read(static_cast<char *>(value), numberOfBytesToBeRead);
178  numberOfBytesRead = m_ChannelsFile[nbComponents].gcount();
179 #ifdef __APPLE_CC__
180  // fail() is broken in the Mac. It returns true when reaches eof().
181  if (numberOfBytesRead != numberOfBytesToBeRead)
182 #else
183  if ((numberOfBytesRead != numberOfBytesToBeRead) || m_ChannelsFile[nbComponents].fail())
184 #endif
185  {
186  itkExceptionMacro(<< "BSQImageIO::Read() Can Read the specified Region"); // read failed
187  }
188 // cpt = (unsigned long )(nbComponents)* (unsigned long)(this->GetComponentSize()) + numberOfBytesToBeRead * this->GetNumberOfComponents() * LineNo;
189 // cpt = (unsigned long )(nbComponents)* (unsigned long)(this->GetComponentSize()) + numberOfBytesToBeRead * this->GetNumberOfComponents();
190  for (std::streamsize i = 0;
191  i < numberOfBytesToBeRead;
192  i = i + static_cast<std::streamsize>(this->GetComponentSize()))
193  {
194  memcpy((void*) (&(p[cpt])), (const void*) (&(value[i])), (size_t) (this->GetComponentSize()));
195  cpt += step;
196  }
197  }
198  }
199  unsigned long numberOfPixelsOfRegion = lNbLines * lNbColumns * this->GetNumberOfComponents();
200 
201  delete[] value;
202 
203  // Swap bytes if necessary
204  if (0) {}
205  otbSwappFileToSystemMacro(unsigned short, USHORT, buffer, numberOfPixelsOfRegion)
206  otbSwappFileToSystemMacro(short, SHORT, buffer, numberOfPixelsOfRegion)
207  otbSwappFileToSystemMacro(char, CHAR, buffer, numberOfPixelsOfRegion)
208  otbSwappFileToSystemMacro(unsigned char, UCHAR, buffer, numberOfPixelsOfRegion)
209  otbSwappFileToSystemMacro(unsigned int, UINT, buffer, numberOfPixelsOfRegion)
210  otbSwappFileToSystemMacro(int, INT, buffer, numberOfPixelsOfRegion)
211  otbSwappFileToSystemMacro(long, LONG, buffer, numberOfPixelsOfRegion)
212  otbSwappFileToSystemMacro(unsigned long, ULONG, buffer, numberOfPixelsOfRegion)
213  otbSwappFileToSystemMacro(float, FLOAT, buffer, numberOfPixelsOfRegion)
214  otbSwappFileToSystemMacro(double, DOUBLE, buffer, numberOfPixelsOfRegion)
215  else
216  {
217  itkExceptionMacro(<< "BSQImageIO::Read() undefined component type! ");
218  }
219 }
220 
222 {
223  if (m_HeaderFile.is_open())
224  {
225  m_HeaderFile.close();
226  }
227  m_HeaderFile.open(m_FileName.c_str(), std::ios::in);
228  if (m_HeaderFile.fail())
229  {
230  itkExceptionMacro(<< "BSQImageIO::ReadImageInformation() failed header open ! ");
231  }
232 
233  //Read header informations
235 
236  otbMsgDebugMacro(<< "Driver to read: BSQ");
237  otbMsgDebugMacro(<< " Read file : " << m_FileName);
238  otbMsgDebugMacro(<< " Size : " << m_Dimensions[0] << "," << m_Dimensions[1]);
239  otbMsgDebugMacro(<< " ComponentType : " << this->GetComponentType());
240  otbMsgDebugMacro(<< " NumberOfComponents : " << this->GetNumberOfComponents());
241  otbMsgDebugMacro(<< " ComponentSize : " << this->GetComponentSize());
242  otbMsgDebugMacro(<< " GetPixelSize : " << this->GetPixelSize());
243 
244 }
245 
246 bool BSQImageIO::InternalReadHeaderInformation(const std::string& file_name, std::fstream& file, const bool reportError)
247 {
248 
249  std::string lString;
250  std::string lStrCodePix;
251  //Read TYPE information
252  file >> lString;
253  lString = itksys::SystemTools::UpperCase(lString);
254  if (lString != "TYPE")
255  {
256  if (reportError == true)
257  {
258  itkExceptionMacro(<< "BSQ : the first line of the header file must be contains 'TYPE' caracters.");
259  }
260  else
261  {
262  return false;
263  }
264  }
265  file >> lStrCodePix;
266  lStrCodePix = itksys::SystemTools::UpperCase(lStrCodePix);
267  if (lStrCodePix == "OCT")
268  {
270  }
271  else if (lStrCodePix == "UOCT")
272  {
274  }
275  else if (lStrCodePix == "I2")
276  {
278  }
279  else if (lStrCodePix == "UI2")
280  {
282  }
283  else if (lStrCodePix == "I4")
284  {
286  }
287  else if (lStrCodePix == "UI4")
288  {
290  }
291  else if (lStrCodePix == "R4")
292  {
294  }
295  else if (lStrCodePix == "R8")
296  {
298  }
299  else
300  {
301  if (reportError == true)
302  {
303  itkExceptionMacro(
304  << "BSQ : the value type '" << lStrCodePix <<
305  "' (second line) set in the header file is not reconized as correct value.");
306  }
307  else
308  {
309  return false;
310  }
311  }
312  //Read LABEL information
313  file >> lString;
314  lString = itksys::SystemTools::UpperCase(lString);
315  if (lString != "LABEL")
316  {
317  if (reportError == true)
318  {
319  itkExceptionMacro(<< "BSQ : the third line of the header file must be contains 'LABEL' caracters.");
320  }
321  else
322  {
323  return false;
324  }
325  }
326  while ((lString != "CHANNELS") || (file.eof()))
327  {
328  file >> lString;
329  lString = itksys::SystemTools::UpperCase(lString);
330  }
331  if (lString != "CHANNELS")
332  {
333  if (reportError == true)
334  {
335  itkExceptionMacro(<< "BSQ : 'CHANNELS' keyword is not find in the header file.");
336  }
337  else
338  {
339  return false;
340  }
341  }
342  unsigned int lNbChannels;
343  file >> lNbChannels;
344  this->SetNumberOfComponents(lNbChannels);
345 
346  //Read LINES information
347  file >> lString;
348  lString = itksys::SystemTools::UpperCase(lString);
349  if (lString != "LINES")
350  {
351  if (reportError == true)
352  {
353  itkExceptionMacro(<< "BSQ : 'LINES' keyword is not find in the header file.");
354  }
355  else
356  {
357  return false;
358  }
359  }
360  file >> m_Dimensions[1];
361  //Read COLUMNS information
362  file >> lString;
363  lString = itksys::SystemTools::UpperCase(lString);
364  if (lString != "COLUMNS")
365  {
366  if (reportError == true)
367  {
368  itkExceptionMacro(<< "BSQ : 'COLUMNS' keyword is not find in the header file.");
369  }
370  else
371  {
372  return false;
373  }
374  }
375  file >> m_Dimensions[0];
376 
377  //Read "BITS PER PIXEL" informations
378  file >> lString;
379  std::string lStrBitsPerPixels(lString);
380  file >> lString;
381  lStrBitsPerPixels = lStrBitsPerPixels + " " + lString;
382  file >> lString;
383  lStrBitsPerPixels = lStrBitsPerPixels + " " + lString;
384  lStrBitsPerPixels = itksys::SystemTools::UpperCase(lStrBitsPerPixels);
385  if (lStrBitsPerPixels != "BITS PER PIXEL")
386  {
387  if (reportError == true)
388  {
389  itkExceptionMacro(<< "BSQ : 'BITS PER PIXEL' keyword is not find in the header file.");
390  }
391  else
392  {
393  return false;
394  }
395  }
396  int lNbBitsPerPixels;
397  file >> lNbBitsPerPixels;
398 
399  //Read "SENSCODAGE" informations (optionnal)
400  file >> lString;
401  if (lString.empty() == false)
402  {
403  lString = itksys::SystemTools::UpperCase(lString);
404  if (lString == "SENSCODAGE")
405  {
406  file >> lString;
407  lString = itksys::SystemTools::UpperCase(lString);
408  if (lString == "INTEL")
409  {
411  }
412  else if (lString == "IEEE")
413  {
415  }
416  else
417  {
418  if (reportError == true)
419  {
420  itkExceptionMacro(
421  << "BSQ : the value SENSCODAGE '" << lString <<
422  "' set in the header file is not reconized as correct value. Possible values are INTEL or IEEE");
423  }
424  else
425  {
426  return false;
427  }
428  }
429  }
430  }
431  file.close();
432 
433  //Define channels file name
434  std::string lRootName = System::GetRootName(file_name);
435  m_ChannelsFileName.clear();
436  for (unsigned int i = 0; i < this->GetNumberOfComponents(); ++i)
437  {
438  std::ostringstream lStream;
439  lStream << lRootName << ".c" << i + 1;
440  m_ChannelsFileName.push_back(lStream.str());
441  }
442 
443  m_ChannelsFile = new std::fstream[this->GetNumberOfComponents()];
444 
445  //Try to open channels file
446  for (unsigned int channels = 0; channels < m_ChannelsFileName.size(); ++channels)
447  {
448  m_ChannelsFile[channels].open(m_ChannelsFileName[channels].c_str(), std::ios::in | std::ios::binary);
449  if (m_ChannelsFile[channels].fail())
450  {
451  if (reportError == true)
452  {
453  itkExceptionMacro(<< "BSQ : impossible to find the file <" << m_ChannelsFileName[channels] << ">.");
454  }
455  else
456  {
457  return false;
458  }
459  }
460  }
461  this->SetFileTypeToBinary();
462  this->SetNumberOfDimensions(2);
463 
464  return (true);
465 }
466 
467 bool BSQImageIO::CanWriteFile(const char* filename)
468 {
469  std::string lFileName(filename);
470  std::string extension = itksys::SystemTools::GetFilenameLastExtension(filename);
471  if ((extension != ".HD") && (extension != ".hd"))
472  {
473  return false;
474  }
475  if (itksys::SystemTools::FileIsDirectory(lFileName.c_str()) == true)
476  {
477  return false;
478  }
479  const std::string Extension = itksys::SystemTools::GetFilenameLastExtension(filename);
480  if ((Extension == ".hd") || (Extension == ".HD"))
481  {
482  return true;
483  }
484  else
485  {
486  return false;
487  }
488 }
489 
490 void BSQImageIO::Write(const void* buffer)
491 {
492  if (m_FlagWriteImageInformation == true)
493  {
494  this->WriteImageInformation();
496  }
497 
498  unsigned long step = this->GetNumberOfComponents();
499  unsigned int lNbLines = this->GetIORegion().GetSize()[1];
500  unsigned int lNbColumns = this->GetIORegion().GetSize()[0];
501  int lFirstLine = this->GetIORegion().GetIndex()[1]; // [1... ]
502  int lFirstColumn = this->GetIORegion().GetIndex()[0]; // [1... ]
503 
504  // Special case: check that the region to write is the same size as the entire
505  // image. Start at offset 0 (when no streaming)
506  if ((lNbLines == m_Dimensions[1]) && (lNbColumns == m_Dimensions[0]))
507  {
508  otbMsgDevMacro(<< "Forcing offset to [0, 0]");
509  lFirstLine = 0;
510  lFirstColumn = 0;
511  }
512 
513  otbMsgDevMacro(<< " BSQImageIO::Write() ");
514  otbMsgDevMacro(<< " Image size : " << m_Dimensions[0] << "," << m_Dimensions[1]);
515  otbMsgDevMacro(<< " Region read (IORegion) : " << this->GetIORegion());
516  otbMsgDevMacro(<< " Nb Of Components : " << this->GetNumberOfComponents());
517  otbMsgDevMacro(<< " GetComponentSize : " << this->GetComponentSize());
518 
519  std::streamoff headerLength(0);
520  std::streamoff numberOfBytesPerLines = static_cast<std::streamoff>(this->GetComponentSize() * m_Dimensions[0]);
521  std::streamsize numberOfBytesToBeWrite = static_cast<std::streamsize>(this->GetComponentSize() * lNbColumns);
522  std::streamoff offset = 0;
523  unsigned long cpt = 0;
524 
525  // Update the step variable
526  step = step * (unsigned long) (this->GetComponentSize());
527  const char * p = static_cast<const char *>(buffer);
528 
529  char* value = new char[numberOfBytesToBeWrite];
530  if (value == NULL)
531  {
532  itkExceptionMacro(<< "Memory allocation error");
533  return;
534  }
535 
536  for (unsigned int nbComponents = 0; nbComponents < this->GetNumberOfComponents(); ++nbComponents)
537  {
538  cpt = (unsigned long) (nbComponents) * (unsigned long) (this->GetComponentSize());
539  //Read region of the channel
540  for (unsigned int LineNo = lFirstLine; LineNo < lFirstLine + lNbLines; LineNo++)
541  {
542  for (std::streamsize i = 0;
543  i < numberOfBytesToBeWrite;
544  i = i + static_cast<std::streamsize>(this->GetComponentSize()))
545  {
546  memcpy((void*) (&(value[i])), (const void*) (&(p[cpt])), (size_t) (this->GetComponentSize()));
547  cpt += step;
548  }
549 
550  offset = headerLength + numberOfBytesPerLines * static_cast<std::streamoff>(LineNo);
551  offset += static_cast<std::streamoff>(this->GetComponentSize() * lFirstColumn);
552  m_ChannelsFile[nbComponents].seekp(offset, std::ios::beg);
553  //Write a line
554  m_ChannelsFile[nbComponents].write(static_cast<char *>(value), numberOfBytesToBeWrite);
555  }
556  }
557  delete[] value;
558 }
559 
561 {
562  if (m_FileName == "")
563  {
564  itkExceptionMacro(<< "A FileName must be specified.");
565  }
566  if (CanWriteFile(m_FileName.c_str()) == false)
567  {
568  itkExceptionMacro(<< "The file " << m_FileName.c_str() << " is not defined as a BSQ file");
569  }
570  // Close file from any previous image
571  if (m_HeaderFile.is_open())
572  {
573  m_HeaderFile.close();
574  }
575 
576  // Open the new file for writing
577  // Actually open the file
578  m_HeaderFile.open(m_FileName.c_str(), std::ios::out | std::ios::trunc);
579  if (m_HeaderFile.fail())
580  {
581  itkExceptionMacro(<< "Cannot write requested file " << m_FileName.c_str() << ".");
582  }
583 
584  if (0) {}
585  otbSetTypeBsqMacro(CHAR, "OCT")
586  otbSetTypeBsqMacro(UCHAR, "UOCT")
588  otbSetTypeBsqMacro(USHORT, "UI2")
589  otbSetTypeBsqMacro(INT, "I4")
590  otbSetTypeBsqMacro(UINT, "UI4")
593  else
594  {
595  itkExceptionMacro(<< "BSQ format doesn't reconized (TYPE).");
596  }
597 
598  std::string lString;
599  //Write TYPE information
600  m_HeaderFile << "TYPE" << std::endl;
601  m_HeaderFile << m_TypeBsq << std::endl;
602 
603  //Write LABEL information
604  m_HeaderFile << "LABEL" << std::endl;
605  m_HeaderFile << m_TypeBsq << " - This BSQ image file was producted by OTB software." << std::endl;
606 
607  //Write CHANNELS information
608  m_HeaderFile << "CHANNELS" << std::endl;
609  m_HeaderFile << this->GetNumberOfComponents() << std::endl;
610 
611  //Write LINES information
612  m_HeaderFile << "LINES" << std::endl;
613  m_HeaderFile << m_Dimensions[1] << std::endl;
614  //Write COLUMNS information
615  m_HeaderFile << "COLUMNS" << std::endl;
616  m_HeaderFile << m_Dimensions[0] << std::endl;
617 
618  //Write "BITS PER PIXEL" informations
619  m_HeaderFile << "BITS PER PIXEL" << std::endl;
620  m_HeaderFile << this->GetComponentSize() * 8 << std::endl;
621 
622  //Write "SENSCODAGE" informations
623  m_HeaderFile << "SENSCODAGE" << std::endl;
624  if (m_ByteOrder == LittleEndian)
625  {
626  m_HeaderFile << "INTEL" << std::endl;
627  }
628  else
629  {
630  m_HeaderFile << "IEEE" << std::endl;
631  }
632 
633  m_HeaderFile.close();
634 
635  //Create channels files
636 
637  //Define channels file name
638  std::string lRootName = System::GetRootName(m_FileName);
639  m_ChannelsFileName.clear();
640  for (unsigned int i = 0; i < this->GetNumberOfComponents(); ++i)
641  {
642  std::ostringstream lStream;
643  lStream << lRootName << ".c" << i + 1;
644  m_ChannelsFileName.push_back(lStream.str());
645  }
646 
647  //Allocate buffer of stream file
648  m_ChannelsFile = new std::fstream[this->GetNumberOfComponents()];
649 
650  //Try to open channels file
651  for (unsigned int channels = 0; channels < m_ChannelsFileName.size(); ++channels)
652  {
653  m_ChannelsFile[channels].open(
654  m_ChannelsFileName[channels].c_str(), std::ios::out | std::ios::trunc | std::ios::binary);
655  if (m_ChannelsFile[channels].fail())
656  {
657  itkExceptionMacro(<< "BSQ : unable to find the file <" << m_ChannelsFileName[channels] << ">");
658  }
659  }
660  this->SetFileTypeToBinary();
661  this->SetNumberOfDimensions(2);
662 
663  unsigned long headerLength = this->GetComponentSize() * m_Dimensions[0];
664  char* value = new char[headerLength];
665 
666  for (unsigned int channels = 0; channels < m_ChannelsFileName.size(); ++channels)
667  {
668  m_ChannelsFile[channels].seekp(0, std::ios::beg);
669  //Write Header line and all file (whitout information)
670  for (unsigned int numLigne = 0; numLigne < (m_Dimensions[1]); numLigne++)
671  {
672  m_ChannelsFile[channels].write(value, headerLength);
673  }
674  }
675 
676  delete[] value;
677 
678  otbMsgDebugMacro(<< "Driver to write: BSQ");
679  otbMsgDebugMacro(<< " Write file : " << m_FileName);
680  otbMsgDebugMacro(<< " Size : " << m_Dimensions[0] << "," << m_Dimensions[1]);
681  otbMsgDebugMacro(<< " Type Bsq : " << m_TypeBsq);
682  otbMsgDebugMacro(<< " ComponentType : " << this->GetComponentType());
683  otbMsgDebugMacro(<< " NumberOfComponents : " << this->GetNumberOfComponents());
684  otbMsgDebugMacro(<< " ComponentSize : " << this->GetComponentSize());
685  otbMsgDebugMacro(<< " GetPixelSize : " << this->GetPixelSize());
686 
687 }
688 
689 } // end namespace otb

Generated at Sat Mar 8 2014 15:52:23 for Orfeo Toolbox with doxygen 1.8.3.1