otbImageIOBase.h 22.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 * Copyright (C) 1999-2011 Insight Software Consortium
 * Copyright (C) 2005-2017 Centre National d'Etudes Spatiales (CNES)
 *
 * This file is part of Orfeo Toolbox
 *
 *     https://www.orfeo-toolbox.org/
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
21

22 23
#ifndef otbImageIOBase_h
#define otbImageIOBase_h
24 25 26 27 28 29 30 31

#include "itkLightProcessObject.h"
#include "itkIndent.h"
#include "itkImageIORegion.h"
#include "vnl/vnl_vector.h"

#include <string>

32 33
#include "OTBImageBaseExport.h"

34
namespace otb
35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
{

/** \class ImageIOBase
 * \brief Abstract superclass defines image IO interface.
 *
 * ImageIOBase is a class that reads and/or writes image data
 * of a particular format (such as PNG or raw binary). The
 * ImageIOBase encapsulates both the reading and writing of data. The
 * ImageIOBase is used by the ImageFileReader class (to read data)
 * and the ImageFileWriter (to write data) into a single file. The
 * ImageSeriesReader and ImageSeriesWriter classes are used to read
 * and write data (in conjunction with ImageIOBase) when the data is
 * represented by a series of files. Normally the user does not directly
 * manipulate this class other than to instantiate it, set the FileName,
 * and assign it to a ImageFileReader/ImageFileWriter or
 * ImageSeriesReader/ImageSeriesWriter.
 *
 * A Pluggable factory pattern is used this allows different kinds of readers
 * to be registered (even at run time) without having to modify the
 * code in this class.
 *
 * \sa ImageFileWriter
 * \sa ImageFileReader
 * \sa ImageSeriesWriter
 * \sa ImageSeriesReader
 *
 * \ingroup IOFilters
 *
63 64
 *
 * \ingroup OTBImageBase
65
 */
66
class OTBImageBase_EXPORT ImageIOBase : public itk::LightProcessObject
67 68 69 70
{
public:
  /** Standard class typedefs. */
  typedef ImageIOBase        Self;
71 72
  typedef itk::LightProcessObject Superclass;
  typedef itk::SmartPointer<Self> Pointer;
73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

  /** Run-time type information (and related methods). */
  itkTypeMacro(ImageIOBase, Superclass);

  /** Set/Get the name of the file to be read. */
  itkSetStringMacro(FileName);
  itkGetStringMacro(FileName);

  /** Types for managing image size and image index components. */
  typedef   long              IndexValueType;
  typedef   unsigned long     SizeValueType;

  /**
   * \class UnknownType
   * Used to return information when types are unknown.
88 89
 *
 * \ingroup OTBImageBase
90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
   */
  class UnknownType {};

  /** Enums used to manipulate the pixel type. The pixel type provides
   * context for automatic data conversions (for instance, RGB to
   * SCALAR, VECTOR to SCALAR). */
  typedef  enum {UNKNOWNPIXELTYPE,SCALAR,RGB,RGBA,OFFSET,VECTOR,
                 POINT,COVARIANTVECTOR,SYMMETRICSECONDRANKTENSOR,
                 DIFFUSIONTENSOR3D,COMPLEX,FIXEDARRAY,MATRIX}  IOPixelType;

  /** Enums used to manipulate the component type. The component type
   * refers to the actual storage class associated with either a
   * SCALAR pixel type or elements of a compound pixel.
   */
  typedef  enum {UNKNOWNCOMPONENTTYPE,UCHAR,CHAR,USHORT,SHORT,UINT,INT,
                 ULONG,LONG, FLOAT,DOUBLE, CSHORT, CINT, CFLOAT, CDOUBLE} IOComponentType;

  /** Set/Get the number of independent variables (dimensions) in the
   * image being read or written. Note this is not necessarily what
   * is written, rather the IORegion controls that. */
  void SetNumberOfDimensions(unsigned int);
  itkGetConstMacro(NumberOfDimensions, unsigned int);

  /** Set/Get the image dimensions in the x, y, z, etc. directions.
   * GetDimensions() is typically used after reading the data; the
   * SetDimensions() is used prior to writing the data. */
  virtual void SetDimensions(unsigned int i, unsigned int dim);
  virtual unsigned int GetDimensions(unsigned int i) const
  { return m_Dimensions[i]; }

  /** Set/Get the image origin on a axis-by-axis basis. The SetOrigin() method
   * is required when writing the image. */
  virtual void SetOrigin(unsigned int i, double origin);
  virtual double GetOrigin(unsigned int i) const
    {
    return m_Origin[i];
    }

  /** Set/Get the image spacing on an axis-by-axis basis. The
   * SetSpacing() method is required when writing the image. */
  virtual void SetSpacing(unsigned int i, double spacing);
  virtual double GetSpacing(unsigned int i) const
    {
    return m_Spacing[i];
    }

  /** Set/Get the image direction on an axis-by-axis basis. The
   * SetDirection() method is required when writing the image. */
  virtual void SetDirection(unsigned int i, std::vector<double> &direction);
  virtual void SetDirection(unsigned int i, vnl_vector<double> &direction);
  virtual std::vector<double> GetDirection(unsigned int i) const
    {
    return m_Direction[i];
    }

  /** Return the directions to be assigned by default to recipient
   *  images whose dimension is smaller than the image dimension in file.  */
  virtual std::vector<double> GetDefaultDirection(unsigned int i) const;

  /** Specify the region of the image data to either read or
   * write. The IORegion specifies the part of the image to read or
   * write. Regions are defined with an index and a size vector. These
   * vectors define the start (lower-left corner) and length of the
   * region within the image. Make sure that the IORegion lies within
   * the image. */
155 156
  itkSetMacro(IORegion, itk::ImageIORegion);
  itkGetConstReferenceMacro(IORegion, itk::ImageIORegion);
157 158 159 160 161

  /** Set/Get the type of the pixel. The PixelTypes provides context
   * to the IO mechanisms for data conversions.  PixelTypes can be
   * SCALAR, RGB, RGBA, VECTOR, COVARIANTVECTOR, POINT, INDEX. If
   * the PIXELTYPE is SCALAR, then the NumberOfComponents should be 1.
162
   * Any other of PIXELTYPE will have more than one component. */
163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268
  itkSetEnumMacro(PixelType, IOPixelType);
  itkGetEnumMacro(PixelType, IOPixelType);

  /** SetPixelTypeInfo is used by writers to convert from an ITK
   * strongly typed pixel to a ImageIO (weaker) typed pixel. This
   * function sets these PixelType, ComponentType, and
   * NumberOfComponents based on RTTI type_info structure passed
   * in. The function returns false if the pixel type is not
   * supported. */
  virtual bool SetPixelTypeInfo(const std::type_info& ptype);

  /** Set/Get the component type of the image. This is always a native
   * type. */
  itkSetEnumMacro(ComponentType,IOComponentType);
  itkGetEnumMacro(ComponentType,IOComponentType);
  virtual const std::type_info& GetComponentTypeInfo() const;

  /** Set/Get the number of components per pixel in the image. This may
   * be set by the reading process. For SCALAR pixel types,
   * NumberOfComponents will be 1.  For other pixel types,
   * NumberOfComponents will be greater than or equal to one. */
  itkSetMacro(NumberOfComponents,unsigned int);
  itkGetConstReferenceMacro(NumberOfComponents,unsigned int);

  /** Set/Get a boolean to use the compression or not. */
  itkSetMacro(UseCompression,bool);
  itkGetConstMacro(UseCompression,bool);
  itkBooleanMacro(UseCompression);

  /** Set/Get a boolean to use streaming while reading or not. */
  itkSetMacro(UseStreamedReading,bool);
  itkGetConstMacro(UseStreamedReading,bool);
  itkBooleanMacro(UseStreamedReading);

  /** Set/Get a boolean to use streaming while writing or not. */
  itkSetMacro(UseStreamedWriting,bool);
  itkGetConstMacro(UseStreamedWriting,bool);
  itkBooleanMacro(UseStreamedWriting);


  /** Convenience method returns the IOComponentType as a string. This can be
   * used for writing output files. */
  std::string GetComponentTypeAsString(IOComponentType) const;

  /** Convenience method returns the IOPixelType as a string. This can be
   * used for writing output files. */
  std::string GetPixelTypeAsString(IOPixelType) const;

  /** Enums used to specify write style: whether binary or ASCII. Some
   * subclasses use this, some ignore it. */
  typedef  enum {ASCII,Binary,TypeNotApplicable} FileType;

  /** Enums used to specify byte order; whether Big Endian or Little Endian.
   * Some subclasses use this, some ignore it. */
  typedef  enum {BigEndian,LittleEndian,OrderNotApplicable} ByteOrder;

  /** These methods control whether the file is written binary or ASCII.
   * Many file formats (i.e., subclasses) ignore this flag. */
  itkSetEnumMacro(FileType,FileType);
  itkGetEnumMacro(FileType,FileType);
  void SetFileTypeToASCII()
    {
    this->SetFileType(ASCII);
    }
  void SetFileTypeToBinary()
    {
    this->SetFileType(Binary);
    }

  /** These methods indicate the byte ordering of the file you are
   * trying to read in. These methods will then either swap or not
   * swap the bytes depending on the byte ordering of the machine it
   * is being run on. For example, reading in a BigEndian file on a
   * BigEndian machine will result in no swapping. Trying to read the
   * same file on a LittleEndian machine will result in swapping.
   * Note: most UNIX machines are BigEndian while PC's and VAX's are
   * LittleEndian. So if the file you are reading in was generated on
   * a VAX or PC, SetByteOrderToLittleEndian() otherwise
   * SetByteOrderToBigEndian().  Some ImageIOBase subclasses
   * ignore these methods. */
  itkSetEnumMacro(ByteOrder,ByteOrder);
  itkGetEnumMacro(ByteOrder,ByteOrder);
  void SetByteOrderToBigEndian()
    {
    this->SetByteOrder(BigEndian);
    }
  void SetByteOrderToLittleEndian()
    {
    this->SetByteOrder(LittleEndian);
    }

  /** Convenience method returns the FileType as a string. This can be
   * used for writing output files. */
  std::string GetFileTypeAsString(FileType) const;

  /** Convenience method returns the ByteOrder as a string. This can be
   * used for writing output files. */
  std::string GetByteOrderAsString(ByteOrder) const;

  /** Type for representing size of bytes, and or positions along a file */
  typedef std::streamoff SizeType;

  /** Type for representing size of bytes, and or positions along a memory buffer */
  typedef size_t    BufferSizeType;

  /** Convenient method for accessing the number of bytes to get to
OTB Bot's avatar
OTB Bot committed
269 270
   * the next pixel. Returns m_Strides[1];
   *
271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
   * Please note that this methods depends the private methods
   * ComputeStrides being called, otherwise this is the incorrect value.
   */
  virtual SizeType GetPixelStride () const;

  /** Return the number of pixels in the image. */
  SizeType GetImageSizeInPixels() const;

  /** Return the number of bytes in the image. */
  SizeType GetImageSizeInBytes() const;

  /** Return the number of pixels times the number
   * of components in the image. */
  SizeType GetImageSizeInComponents() const;


  /** Compute the size (in bytes) of the components of a pixel. For
OTB Bot's avatar
OTB Bot committed
288
   * example, and RGB pixel of unsigned char would have a
289 290 291
   * component size of 1 byte. This method can be invoked only after
   * the component type is set. */
  virtual unsigned int GetComponentSize() const;
292 293 294 295 296 297 298 299
  
  /** Get the number of overviews available into the file specified
   * Returns: overview count, zero if none. */
  virtual unsigned int GetOverviewsCount() = 0; 
  
  /** Get information about overviews available into the file specified
   * Returns: overview info, empty if none. */ 
  virtual std::vector<std::string> GetOverviewsInfo() = 0;
300 301 302 303 304

  /** Provide hist about the output container to deal with complex pixel
   *  type */ 
  virtual void SetOutputImagePixelType( bool isComplexInternalPixelType, 
                                        bool isVectorImage) = 0;
305
  
306 307 308 309 310 311 312 313 314 315 316 317 318
  /*-------- This part of the interfaces deals with reading data ----- */

  /** Determine the file type. Returns true if this ImageIO can read the
   * file specified. */
  virtual bool CanReadFile(const char*) = 0;

  /** Determine if the ImageIO can stream reading from this
      file. Default is false. */
  virtual bool CanStreamRead()
    {
    return false;
    }

319
  /** Read the spacing and dimensions of the image.
320 321 322 323 324 325 326 327 328 329 330 331 332
   * Assumes SetFileName has been called with a valid file name. */
  virtual void ReadImageInformation() = 0;

  /** Reads the data from disk into the memory buffer provided. */
  virtual void Read(void* buffer) = 0;


  /*-------- This part of the interfaces deals with writing data ----- */

  /** Determine the file type. Returns true if this ImageIO can read the
   * file specified. */
  virtual bool CanWriteFile(const char*)  = 0;

OTB Bot's avatar
OTB Bot committed
333
  /** Determine if the ImageIO can stream writing to this file. Default is false.
334
   *
335
   * There are two types of non exclusive streaming: pasting subregions, and iterative
OTB Bot's avatar
OTB Bot committed
336
   * If true then
337 338 339 340 341 342
   */
  virtual bool CanStreamWrite()
    {
    return false;
    }

343
  /** Writes the spacing and dimensions of the image.
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
   * Assumes SetFileName has been called with a valid file name. */
  virtual void WriteImageInformation() = 0;

  /** Writes the data to disk from the memory buffer provided. Make sure
   * that the IORegions has been set properly. The buffer is cast to a
   * pointer to the beginning of the image data. */
  virtual void Write( const void* buffer) = 0;

  /* --- Support reading and writing data as a series of files. --- */

  /** The different types of ImageIO's can support data of varying
   * dimensionality. For example, some file formats are strictly 2D
   * while others can support 2D, 3D, or even n-D. This method returns
   * true/false as to whether the ImageIO can support the dimension
   * indicated. */
  virtual bool SupportsDimension(unsigned long dim)
    {
    return (dim == 2);
    }

  /** Method for supporting streaming.  Given a requested region, determine what
   * could be the region that we can read from the file. This is called the
   * streamable region, which will be equal or smaller than the
   * LargestPossibleRegion (unless it was dimensionaly clipped) and
   * greater or equal to the RequestedRegion
   *
   * the resulting IORegion may be a greater dimensions the the
   * requested IORegion, if the the derived class is unable to read
   * the requested region. For example if the file has a size of [ 10,
   * 10, 10] but the requested region is [10, 10] the return may be 3 dimensions.
   */
375 376
  virtual itk::ImageIORegion
  GenerateStreamableReadRegionFromRequestedRegion( const itk::ImageIORegion & requested ) const;
377

378

379 380
  /** Before this method is called all the configuration will be done,
   * that is Streaming/PasteRegion/Compression/Filename etc
OTB Bot's avatar
OTB Bot committed
381 382
   * If pasting is being used the number of requested splits is for that
   * region not the largest. The derived ImageIO class should verify that
383
   * the file is capable of being written with this configuration.
OTB Bot's avatar
OTB Bot committed
384 385
   * If pasted is enabled and is not support or does not work with the file,
   * then an excepetion should be thrown.
386 387 388
   *
   * The default implementation depends on CanStreamWrite.
   * If false then 1 is returned (unless pasting is indicated), so that the whole file will be updated in one region.
389
   * If true then its assumed that any arbitrary region can be written
390 391 392 393
   * to any file. So the users request will be respected. If a derived
   * class has more restictive conditions then they should be checked
   */
  virtual unsigned int GetActualNumberOfSplitsForWriting(unsigned int numberOfRequestedSplits,
394 395
                                                         const itk::ImageIORegion &pasteRegion,
                                                         const itk::ImageIORegion &largestPossibleRegion);
396

OTB Bot's avatar
OTB Bot committed
397 398
  /** returns the ith IORegion
   *
399 400 401 402
   * numberOfActualSplits should be the value returned from GetActualNumberOfSplitsForWriting with the same parameters
   *
   * Derieved classes should overload this method to return a compatible region
   */
403 404 405 406
  virtual itk::ImageIORegion GetSplitRegionForWriting(unsigned int ithPiece,
                                                      unsigned int numberOfActualSplits,
                                                      const itk::ImageIORegion &pasteRegion,
                                                      const itk::ImageIORegion &largestPossibleRegion);
407 408 409 410 411 412

  /** Type for the list of strings to be used for extensions.  */
  typedef  std::vector< std::string >    ArrayOfExtensionsType;

  /** This method returns an array with the list of filename extensions
   * supported for reading by this ImageIO class. This is intended to
OTB Bot's avatar
OTB Bot committed
413
   * facilitate GUI and application level integration.
414 415 416 417 418
   */
  const ArrayOfExtensionsType & GetSupportedReadExtensions() const;

  /** This method returns an array with the list of filename extensions
   * supported for writing by this ImageIO class. This is intended to
OTB Bot's avatar
OTB Bot committed
419
   * facilitate GUI and application level integration.
420 421 422
   */
  const ArrayOfExtensionsType & GetSupportedWriteExtensions() const;

423 424 425 426 427 428
  /** Remap band order in an input buffer using band mapping bandList
   *  This operation is done in-place. The buffer size should enough to
   *  contain extracted bands before and after mapping. bandList mapping
   * between origin components and output components (before any
   * conversion)*/
  void DoMapBuffer(void* buffer, size_t numberOfPixels, std::vector<unsigned int>& bandList);
429 430 431

protected:
  ImageIOBase();
432 433
  ~ImageIOBase() ITK_OVERRIDE;
  void PrintSelf(std::ostream& os, itk::Indent indent) const ITK_OVERRIDE;
434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451

  /** Used internally to keep track of the type of the pixel. */
  IOPixelType m_PixelType;

  /** Used internally to keep track of the type of the component. It is set
   * when ComputeStrides() is invoked. */
  IOComponentType m_ComponentType;

  /** Big or Little Endian, and the type of the file. (May be ignored.) */
  ByteOrder      m_ByteOrder;
  FileType       m_FileType;

  /** Does the ImageIOBase object have enough info to be of use? */
  bool m_Initialized;

  /** Filename to read */
  std::string m_FileName;

OTB Bot's avatar
OTB Bot committed
452
  /** Stores the number of components per pixel. This will be 1 for
453 454 455 456 457 458 459 460 461 462 463
   * grayscale images, 3 for RGBPixel images, and 4 for RGBPixelA images. */
  unsigned int m_NumberOfComponents;

  /** The number of independent dimensions in the image. */
  unsigned int m_NumberOfDimensions;

  /** Should we compress the data? */
  bool m_UseCompression;

  /** Should we use streaming for reading */
  bool m_UseStreamedReading;
464

465 466 467 468 469
  /** Should we use streaming for writing */
  bool m_UseStreamedWriting;

  /** The region to read or write. The region contains information about the
   * data within the region to read or write. */
470
  itk::ImageIORegion m_IORegion;
471 472 473 474

  /** The array which stores the number of pixels in the x, y, z directions. */
  std::vector< SizeValueType > m_Dimensions;

OTB Bot's avatar
OTB Bot committed
475
  /** The array which stores the spacing of pixels in the
476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492
   * x, y, z directions. */
  std::vector<double> m_Spacing;

  /** The array which stores the origin of the image. */
  std::vector<double> m_Origin;

  /** The arrays which store the direction cosines of the image. */
  std::vector<std::vector<double> > m_Direction;

  /** Stores the number of bytes it takes to get to the next 'thing'
   * e.g. component, pixel, row, slice, etc. */
  std::vector< SizeType > m_Strides;

  /** Return the object to an initialized state, ready to be used */
  virtual void Reset(const bool freeDynamic = true);

  /** Resize the ImageIOBase object to new dimensions. */
OTB Bot's avatar
OTB Bot committed
493
  void Resize(const unsigned int numDimensions,
494 495 496 497 498 499 500 501 502 503 504 505 506 507
              const unsigned int* dimensions);

  /** Compute the size (in bytes) of the pixel. For
   * example, and RGB pixel of unsigned char would have size 3 bytes. */
  virtual unsigned int GetPixelSize() const;

  /** Calculates the different strides (distance from one thing to the next).
   * Upon return,
   * strides[0] = bytes to get to the next component of a pixel,
   * strides[1] = bytes to get to the next pixel in x direction,
   * strides[2] = bytes to get to the next row in y direction,
   * strides[3] = bytes to get to the next slice in z direction, etc. */
  void ComputeStrides();

OTB Bot's avatar
OTB Bot committed
508
  /** Convenient method for accessing number of bytes to get to the next pixel
509 510 511
   * component. Returns m_Strides[0]. */
  SizeType GetComponentStride() const;

OTB Bot's avatar
OTB Bot committed
512
  /** Convenient method for accessing the number of bytes to get to the
513 514 515
   * next row. Returns m_Strides[2]. */
  SizeType GetRowStride () const;

OTB Bot's avatar
OTB Bot committed
516
  /** Convenient method for accessing the number of bytes to get to the
517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532
   * next slice. Returns m_Strides[3]. */
  SizeType GetSliceStride () const;

  /** Convenient method to write a buffer as ASCII text. */
  void WriteBufferAsASCII(std::ostream& os, const void *buffer,
                          IOComponentType ctype,
                          SizeType numberOfBytesToWrite);

  /** Convenient method to read a buffer as ASCII text. */
  void ReadBufferAsASCII(std::istream& os, void *buffer,
                         IOComponentType ctype,
                         SizeType numberOfBytesToBeRead);

  /** Convenient method to read a buffer as binary. Return true on success. */
  bool ReadBufferAsBinary(std::istream& os, void *buffer, SizeType numberOfBytesToBeRead);

533

534 535 536 537 538 539
  /** Insert an extension to the list of supported extensions for reading. */
  void AddSupportedReadExtension( const char * extension );

  /** Insert an extension to the list of supported extensions for writing. */
  void AddSupportedWriteExtension( const char * extension );

OTB Bot's avatar
OTB Bot committed
540
  /** an implementation of ImageRegionSplitter:GetNumberOfSplits
541 542
   */
  virtual unsigned int GetActualNumberOfSplitsForWritingCanStreamWrite(unsigned int numberOfRequestedSplits,
543
                                                                       const itk::ImageIORegion &pasteRegion) const;
544 545 546

  /** an implementation of  ImageRegionSplitter:GetSplit
   */
547
  virtual itk::ImageIORegion GetSplitRegionForWritingCanStreamWrite(unsigned int ithPiece,
548
                                                               unsigned int numberOfActualSplits,
549
                                                               const itk::ImageIORegion &pasteRegion) const;
550 551 552 553 554 555 556 557 558 559 560 561

private:
  ImageIOBase(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

  ArrayOfExtensionsType    m_SupportedReadExtensions;
  ArrayOfExtensionsType    m_SupportedWriteExtensions;

};

} // end namespace itk

562
#endif // otbImageIOBase_h