image.h

Go to the documentation of this file.

/**
 * \file rvc/image.h
 * \brief RVC::IMAGE class definitions.
 *
 * \if NODOC
 * $Id: image.h_v 1.48 2005/11/29 17:34:17 dwilliss Exp $
 *
 * $Log: image.h_v $
 * Revision 1.48  2005/11/29 17:34:17  dwilliss
 * added a couple methods that were in 72 but not 71
 *
 * Revision 1.47  2005/11/18 18:48:22  scowan
 * Added complex conversions.
 *
 * Revision 1.46  2005/08/24 19:46:42  dfriberg
 * Add ConvToCellType method to IMAGE::NULLVALUE
 *
 * Revision 1.45  2005/04/08 16:16:38  mju
 * Add nullvalue applyMask and extractMask methods.
 *
 * Revision 1.44  2005/04/05 16:51:55  scowan
 * Added cell type histogram valid.
 *
 * Revision 1.43  2005/02/03 22:20:05  scowan
 * Added changes suggested by Mike and Dave.
 *
 * Revision 1.42  2005/02/03 21:04:01  scowan
 *  Added fields to statistics.
 *
 * Revision 1.41  2005/02/03 18:37:05  scowan
 * Added image statistics class.
 *
 * Revision 1.40  2004/12/03 17:04:26  scowan
 * SequentialReadOptim.
 *
 * Revision 1.39  2004/12/03 16:08:25  scowan
 * Added image capability.
 *
 * Revision 1.38  2004/11/19 15:31:25  scowan
 * Setup database to exist under signed rasters.
 * I do not think that this is a good idea.
 *
 * Revision 1.37  2004/08/31 17:45:38  scowan
 * Moved chache size methods to here and made virtual methods from them.
 *
 * Revision 1.36  2004/08/30 14:10:48  mju
 * Add pyramid_default.
 *
 * Revision 1.35  2004/03/01 15:45:32  mju
 * Add pyramid_Partial flag.
 *
 * Revision 1.34  2004/02/24 16:09:20  scowan
 * Added two new filter cell types.
 *
 * Revision 1.33  2004/02/03 21:19:21  scowan
 * Added rgb spread conversion.
 *
 * Revision 1.32  2003/11/05 18:44:27  scowan
 * Added red blue conversion modes.
 *
 * Revision 1.31  2003/10/30 18:27:28  scowan
 * Added new celltype.
 *
 * Revision 1.30  2003/10/23 21:24:48  scowan
 * nc.
 *
 * Revision 1.29  2003/10/22 17:07:27  scowan
 * Removed deprecated method.
 *
 * Revision 1.28  2003/10/22 16:17:21  scowan
 * Added get objtype set static method.
 *
 * Revision 1.27  2003/10/15 15:08:37  scowan
 * Added method to convert legacy datatype and numbits to  celltype.
 *
 * Revision 1.26  2003/10/10 16:02:22  scowan
 * Added method to get i18n string from celltype.
 *
 * Revision 1.25  2003/09/30 16:52:06  dwilliss
 * Doxygen
 *
 * Revision 1.24  2003/09/25 21:56:58  dwilliss
 * doxygen
 *
 * Revision 1.23  2003/09/15 23:16:55  scowan
 * Added observer class and set null value pure virtual method.
 *
 * Revision 1.22  2003/09/15 13:49:45  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.21  2003/09/11 20:09:19  scowan
 * Added is image function.
 *
 * Revision 1.20  2003/08/27 21:26:06  scowan
 * Added more celltypes.
 *
 * Revision 1.19  2003/07/31 14:27:20  scowan
 * Added method to get celltype range.
 *
 * Revision 1.18  2003/06/27 20:39:05  scowan
 * Added pyramid enum.
 *
 * Revision 1.17  2003/05/07 22:19:41  scowan
 * Changed virtual method format.
 *
 * Revision 1.16  2002/10/17 15:23:22  mju
 * Add GetCellTypeFromColorSpace and GetColorSpaceFromCellType.
 *
 * Revision 1.15  2002/09/03 22:05:32  mju
 * Change CELLTYPE to use separable bits and add combined types for filter.
 *
 * Revision 1.14  2001/11/02 17:14:26  mju
 * Redesign null value.
 * Add CELLTYPE enum.
 * Add HasNullValue() pure virtual method.
 *
 * Revision 1.13  2001/10/26 13:47:58  scowan
 * Added default band number for get null value.
 *
 * Revision 1.12  2001/10/25 21:30:38  scowan
 * Added get null value as a method.
 *
 * Revision 1.11  2001/08/06 16:56:08  scowan
 * Nothing.
 *
 * Revision 1.10  2001/08/06 16:54:14  scowan
 * Temp promotion of static method for legacy applications.
 *
 * Revision 1.8  2001/06/15 15:35:10  scowan
 * Added get null value method that returs a double.
 *
 * Revision 1.7  2001/06/14 14:50:36  scowan
 * Added to RVC namespace.
 *
 * Revision 1.1  2000/10/02 17:22:56  scowan
 * Initial revision
 * \endif
**/

//!   \class RVC::IMAGE rvc/image.h
//!   \brief Interface for RVC objects that support an multiple image band paradigm.
//!
//!   This includes methods to read and write to each individual image band
//!
//!   RVC Object Types that this class supports: Derived class
//!
//!   Default RVC Object Type for this class: Derived class
//!
//!   Valid parents for this class: Derived class

#ifndef INC_RVC_IMAGE_H
#define INC_RVC_IMAGE_H

#ifndef INC_RVC_GEOSPATL_H
   #include <rvc/geospatl.h>
#endif

#ifndef INC_MI32_RVCRAST_H
   #include <mi32/rvcrast.h>
#endif

#ifndef INC_MI32_COLORSPC_H
   #include <mi32/colorspc.h>
#endif

#ifndef INC_MI32_RANGE_H
   #include <mi32/range.h>
#endif


namespace RVC {

#ifndef GENERATING_DOXYGEN_OUTPUT
//Forward Declarations
class HISTOGRAM;
struct AnyCallbackStruct;
#endif

class IMAGE : public RVC::GEOSPATIAL {
   public:

      enum CACHEMODE {           //! Raster cache values for SetCacheMode()
         CACHEMODE_Default = 0,     //!< Default cache size is 4 tiles unless compressed
         CACHEMODE_DiagonalRow,     //!< Sets raster cache to allocate a hypotenuse amount of tiles
         CACHEMODE_TileRow          //!< Default cache size if raster is compressed, caches a row of tiles
         };

      enum CAPABILITY {
         CAPABILITY_None =                   0,
         CAPABILITY_SequentialReadOptimal = 1024   //!< Image is best accessed one scanline at a time in top to bottom order
         };

      //! Possible type conversion modes for Read(), ReadColumn() and Write()
      enum CONVMODE {
         CONVMODE_None = 0,            //!< No conversion
         CONVMODE_ByteSpread,          //!< Convert < 8-bit to 8-bit by spreading over 0-255 range
         CONVMODE_INT8,                //!< Convert 1/2/4 bits to 8-bit by copy
         CONVMODE_INT16,               //!< Convert < INT16 to INT16 bits/cell
         CONVMODE_INT32,               //!< Convert < INT32 to INT32 bits/cell
         CONVMODE_Float,               //!< Convert to float
         CONVMODE_Double,              //!< Convert to double
         CONVMODE_RGB,                 //!< Convert to RGB, only for Read() method
         CONVMODE_BGR,                 //!< Convert to BGR, only for Read() method
         CONVMODE_RGBSpread,           //!< Convert to RGB and spread 16 to 24 bit, only for Read() method
         CONVMODE_BGRSpread,           //!< Convert to BGR and spread 16 to 24 bit, only for Read() method
         CONVMODE_ComplexRIFloat,      //!< Convert to Complex Real/Imaginary
         CONVMODE_ComplexMPFloat,      //!< Convert to Complex Magnitude/Phase
         CONVMODE_ComplexRIDouble,     //!< Convert to Complex Real/Imaginary
         CONVMODE_ComplexMPDouble      //!< Convert to Complex Magnitude/Phase
         };

      //! Valid image datatypes.
      enum DATATYPE {
         DATATYPE_Invalid = 0,         //!< Not a valid raster datatype
         DATATYPE_Unsigned,            //!< UINT8, UINT16, UINT32 and < 8 bit
         DATATYPE_Signed,              //!< INT8, INT16, INT32
         DATATYPE_Float,               //!< FLOAT, DOUBLE
         DATATYPE_BGR,                 //!< RED, GREEN, BLUE packed (blue first byte)
         DATATYPE_RGB,                 //!< RED, GREEN, BLUE packed (red first byte)
         DATATYPE_BGR16,               //!< RED, GREEN, BLUE packed (blue high bits)
         DATATYPE_RGB16,               //!< RED, GREEN, BLUE packed (red high bits)
         DATATYPE_ComplexRI,           //!< Real, Imaginary
         DATATYPE_ComplexMP,           //!< Magnitude, Phase
         DATATYPE_RGBA,                //!< RED, GREEN, BLUE packed (red first byte)
         DATATYPE_ARGB,                //!< RED, GREEN, BLUE packed (red first byte)
         DATATYPE_CMYK,                //!< RED, GREEN, BLUE packed (red first byte)
         DATATYPE_KCMY                 //!< RED, GREEN, BLUE packed (red first byte)
         };

      //! Image cell type enumerating valid data type and bit depth combinations.
      enum CELLTYPE {
         CELLTYPE_Invalid =                   0x00000000,
         CELLTYPE_Binary =                    0x00000001,
         CELLTYPE_Unsigned_4 =                0x00000002,
         CELLTYPE_Unsigned_8 =                0x00000004,
         CELLTYPE_Unsigned_32 =               0x00000008,
         CELLTYPE_Unsigned_16 =               0x00000010,
         CELLTYPE_Unsigned_64 =               0x00000020,
         CELLTYPE_Signed_8 =                  0x00000040,
         CELLTYPE_Signed_16 =                 0x00000080,
         CELLTYPE_Signed_32 =                 0x00000100,
         CELLTYPE_Signed_64 =                 0x00000200,
         CELLTYPE_Float_32 =                  0x00000400,
         CELLTYPE_Float_64 =                  0x00000800,
         CELLTYPE_ComplexRI_64 =              0x00001000,
         CELLTYPE_ComplexMP_64 =              0x00002000,
         CELLTYPE_ComplexRI_128 =             0x00004000,
         CELLTYPE_ComplexMP_128 =             0x00008000,
         CELLTYPE_X1R5G5B5_16 =               0x00010000,   //!< Packed into UINT16 with Red in high bits
         CELLTYPE_X1B5G5R5_16 =               0x00020000,   //!< Packed into UINT16 with Blue in high bits
         CELLTYPE_RedGreenBlue_24 =           0x00040000,   //!< 3 bytes, red first
         CELLTYPE_BlueGreenRed_24 =           0x00080000,   //!< 3 bytes, blue first
         CELLTYPE_RedGreenBlueAlpha_32 =      0x00100000,   //!< 4 bytes, red first
         CELLTYPE_AlphaRedGreenBlue_32 =      0x00200000,   //!< 4 bytes, alpha first
         CELLTYPE_CyanMagentaYellowBlack_32 = 0x00400000,   //!< 4 bytes, cyan first
         CELLTYPE_BlackCyanMagentaYellow_32 = 0x00800000,   //!< 4 bytes, black first
         // When add types add also to IMAGE::GetCellTypeResourceString(), IMAGE::GetCellTypeString() and IMAGE::GetCellTypeRange() in image.c.
         // New types should be added here
         // Multiple-type specifications for filters, etc.
         CELLTYPE_None =                      0x00000000,
         CELLTYPE_Unsigned_Max8 =             (CELLTYPE_Binary + CELLTYPE_Unsigned_4 + CELLTYPE_Unsigned_8),
         CELLTYPE_Unsigned_Max16 =            (CELLTYPE_Unsigned_Max8 + CELLTYPE_Unsigned_16),
         CELLTYPE_Unsigned_Max32 =            (CELLTYPE_Unsigned_Max16 + CELLTYPE_Unsigned_32),
         CELLTYPE_Unsigned_Max64 =            (CELLTYPE_Unsigned_Max32 + CELLTYPE_Unsigned_64),
         CELLTYPE_Signed_Max32 =              (CELLTYPE_Signed_8 + CELLTYPE_Signed_16 + CELLTYPE_Signed_32),
         CELLTYPE_Signed_Max64 =              (CELLTYPE_Signed_Max32 + CELLTYPE_Signed_64),
         CELLTYPE_Integer_Max32 =             (CELLTYPE_Unsigned_Max32 + CELLTYPE_Signed_Max32),
         CELLTYPE_Integer_Max64 =             (CELLTYPE_Unsigned_Max64 + CELLTYPE_Signed_Max64),
         CELLTYPE_Float =                     (CELLTYPE_Float_32 + CELLTYPE_Float_64),
         CELLTYPE_Scalar =                    (CELLTYPE_Integer_Max64 + CELLTYPE_Float),
         CELLTYPE_Complex =                   (CELLTYPE_ComplexRI_64 + CELLTYPE_ComplexMP_64 + CELLTYPE_ComplexRI_128 + CELLTYPE_ComplexMP_128),
         CELLTYPE_3Cell_Color =               (CELLTYPE_X1R5G5B5_16 + CELLTYPE_X1B5G5R5_16 + CELLTYPE_RedGreenBlue_24 + CELLTYPE_BlueGreenRed_24),
         CELLTYPE_4Cell_Color =               (CELLTYPE_RedGreenBlueAlpha_32 + CELLTYPE_AlphaRedGreenBlue_32 + CELLTYPE_CyanMagentaYellowBlack_32 + CELLTYPE_BlackCyanMagentaYellow_32),
         CELLTYPE_Color =                     (CELLTYPE_3Cell_Color + CELLTYPE_4Cell_Color),
         CELLTYPE_ColorMapValid =             (CELLTYPE_Unsigned_4 + CELLTYPE_Unsigned_8 + CELLTYPE_Unsigned_16),
         CELLTYPE_HasAlphaBand =              (CELLTYPE_RedGreenBlueAlpha_32 + CELLTYPE_AlphaRedGreenBlue_32),
         CELLTYPE_DatabaseValid =             (CELLTYPE_Integer_Max32),
         CELLTYPE_HistogramValid =            (CELLTYPE_Scalar + CELLTYPE_Complex),
         CELLTYPE_All =                       (CELLTYPE_Scalar + CELLTYPE_Complex + CELLTYPE_Color)
         };

      enum PACKORDER {
         PACKORDER_LeastSigBit = 0,
         PACKORDER_MostSigBit
         };

      enum PYRAMID {
         PYRAMID_Default =             0x00,
         PYRAMID_None =                PYRAMID_Default,
         PYRAMID_Rebuild =             0x01, //!< Rebuild tiers even if exist
         PYRAMID_Average =             0x02, //!< Average raster cells instead of sampling
         PYRAMID_Full =                0x04, //!< Create 'full' pyramid set (always 2x2 sample steps)
         PYRAMID_UseParentTileSize =   0x08, //!< Use parent raster's tile size.
         PYRAMID_UseColorMap =         0x10, //!< Use colormap for averaging
         PYRAMID_Partial =             0x20  //!< Create 'partial' pyramid set (some 4x4 sample steps)
         };

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class BANDPARMS;  //!< Forward declarations
      class NULLVALUE;
      class OBSERVER;
      class STATISTICS;
      #endif // GENERATING_DOXYGEN_OUTPUT

      //! Default constructor
      IMAGE (
         );

      //! Copy constructor
      IMAGE (
         const IMAGE& rhs
         );

      //! Destructor
      virtual ~IMAGE (
         ) = 0;

      //! Get CELLTYPE corresponding to datatype and numbits
      //! @return CELLTYPE value or CELLTYPE_Invalid if no conversion possible.
      static CELLTYPE ComputeCellType (
         DATATYPE datatype,
         UINT16 numbits
         );

      //! Get CELLTYPE corresponding to legacy datatype and numbits
      //! @return CELLTYPE value or CELLTYPE_Invalid if no conversion possible.
      static CELLTYPE ComputeCellTypeFromLegacy (
         UINT32 datatype,
         UINT16 numbits
         );

      //! Obtain individual image band parameters.
      ERRVALUE GetBandParms (
         INT32 BandNum,
         BANDPARMS& BandParms
         ) const { return (v_GetBandParms(BandNum, BandParms)); }

      //! Get CELLTYPE corresponding to COLORSPACE.
      //! @return CELLTYPE value or CELLTYPE_Invalid if no conversion possible.
      static CELLTYPE GetCellTypeFromColorSpace (
         COLORSPACE ColorSpace
         );

      //! Get CELLTYPE corresponding to legacy datatype and numbits
      //! @return CELLTYPE value or CELLTYPE_Invalid if no conversion possible.
      static CELLTYPE GetCellTypeFromDataTypeAndNumBits (
         UINT32 datatype,
         UINT16 numbits
         );

      //! Get Image value range according to the CELLTYPE
      static void GetCellTypeRange (
         CELLTYPE CellType,
         DOUBLE_RANGE& Range
         );

      //! Get the string for the IMAGE::CELLTYPE specified.
      //! The string is determined from the 'CellType' and the resource file
      static MISTRING GetCellTypeString (
         CELLTYPE CellType
         );

      //! Get COLORSPACE corresponding to specified cell type.
      //! @return COLORSPACE value or COLORSPACE_Unknown if no conversion possible.
      static COLORSPACE GetColorSpaceFromCellType (
         CELLTYPE CellType,
         bool haspalette = false
         );

      //! Obtain the raster cell column scale value.
      //! @return raster cell column scale
      double GetColumnScale (
         ) const { return (v_GetColumnScale()); }

      //! Get the band number to use for composite image reading and writing in one image buffer
      //! Only useful for images of CELLTYPE_Complex and CELLTYPE_Color
      //! @return Band number to read(), write() for CELLTYPE_Complex and CELLTYPE_Color images in one image buffer
      static INT32 GetCompositeBandNum (
         ) { return (-1); }

      //! Get DATATYPE associated with specified CELLTYPE.
      static DATATYPE GetDataTypeFromCellType (
         CELLTYPE CellType
         );

      //! Get image object referred to by 'object'
      //! @return Allocated instance of RVC::IMAGE object (must be 'delete'd) or 0 if error
      static RVC::IMAGE* GetImage (
         const RVC::OBJECT& object
         );

      //! Get image object referred to by 'ObjItem'
      //! @return Allocated instance of RVC::IMAGE object (must be 'delete'd) or 0 if error
      static RVC::IMAGE* GetImage (
         const RVC::OBJITEM& ObjItem
         );

      //! Obtain the raster cell line scale value.
      //! @return raster cell line scale
      double GetLineScale (
         ) const { return (v_GetLineScale()); }

      //! Obtain raster band null value information.
      ERRVALUE GetNullValue (
         INT32 BandNum,                   //!< Raster band number to get NULLVALUE from
         NULLVALUE& NullValue             //!< Current NULLVALUE to get from raster
         ) const { return (v_GetNullValue(BandNum, NullValue)); }

      //! Determine the number of bands present in the raster
      //! @returns number of bands
      INT32 GetNumBands (
         ) const { return (v_GetNumBands()); }

      //! Get number of bits per cell for specified CELLTYPE.
      static UINT16 GetNumBitsFromCellType (
         CELLTYPE CellType
         );

      //! Obtain number of columns in the raster
      //! @return number of columns in the raster
      INT32 GetNumColumns (
         ) const { return (v_GetNumColumns()); }

      //! Obtain number of lines in the raster
      //! @return number of lines in the raster
      INT32 GetNumLines (
         ) const { return (v_GetNumLines()); }

      //! Get correct OBJTYPESET for all image OBJTYPE's
      //! @return OBJTYPESET for all image OBJTYPE's
      static RVC::OBJTYPESET GetObjTypeSet (
         );

      //! Determine if null value exists for specified band.
      //! @return 'true' if null value used, 'false' if not.
      bool HasNullValue (
         INT32 BandNum
         ) const { return (v_HasNullValue(BandNum)); }

      //! Determine if the object type is an image object
      static bool IsImage (
         RVC::OBJTYPE ObjType
         );

      //! Read a line of raster cells up to a certain length
      ERRVALUE ReadBand (
         INT32 Band,
         INT32 Line,                         //!< Raster line to read
         INT32 StartColumn,                  //!< Raster column to start reading on
         void *data,                         //!< Buffer to read into
         INT32 Length = 1,                   //!< Number of columns to read
         CONVMODE Convert = CONVMODE_None    //!< Data conversion mode
         ) const { return (v_ReadBand(Band, Line, StartColumn, data, Length, Convert)); }

      //! Read a line of raster cells up to a certain length, converting to signed 8 bit
      ERRVALUE ReadBand (                       //! Read a raster line, signed 8 bit
         INT32 Band,                         //!< Image band number to read
         INT32 Line,                         //!< Raster line to read
         INT32 StartColumn,                     //!< Raster column to start reading on
         INT8 *data,                         //!< Buffer to read into
         INT32 Length = 1                    //!< Number of columns to read
         ) const { return (v_ReadBand(Band, Line, StartColumn, data, Length, CONVMODE_INT8)); }

      //! Read a line of raster cells up to a certain length, converting to unsigned 8 bit
      ERRVALUE ReadBand (                       //! Read a raster line, unsigned 8 bit
         INT32 Band,                         //!< Image band number to read
         INT32 Line,                         //!< Raster line to read
         INT32 StartColumn,                     //!< Raster column to start reading on
         UINT8 *data,                        //!< Buffer to read into
         INT32 Length = 1                    //!< Number of columns to read
         ) const { return (v_ReadBand(Band, Line, StartColumn, data, Length, CONVMODE_INT8)); }

      //! Read a line of raster cells up to a certain length, converting to signed 16 bit
      ERRVALUE ReadBand (                       //! Read a raster line, signed 16 bit
         INT32 Band,                         //!< Image band number to read
         INT32 Line,                         //!< Raster line to read
         INT32 StartColumn,                     //!< Raster column to start reading on
         INT16 *data,                        //!< Buffer to read into
         INT32 Length = 1                    //!< Number of columns to read
         ) const { return (v_ReadBand(Band, Line, StartColumn, data, Length, CONVMODE_INT16)); }

      //! Read a line of raster cells up to a certain length, converting to unsigned 16 bit
      ERRVALUE ReadBand (                       //! Read a raster line, unsigned 16 bit
         INT32 Band,                         //!< Image band number to read
         INT32 Line,                         //!< Raster line to read
         INT32 StartColumn,                     //!< Raster column to start reading on
         UINT16 *data,                       //!< Buffer to read into
         INT32 Length = 1                    //!< Number of columns to read
         ) const { return (v_ReadBand(Band, Line, StartColumn, data, Length, CONVMODE_INT16)); }

      //! Read a line of raster cells up to a certain length, converting to signed 32 bit
      ERRVALUE ReadBand (                       //! Read a raster line, signed 32 bit
         INT32 Band,                         //!< Image band number to read
         INT32 Line,                         //!< Raster line to read
         INT32 StartColumn,                     //!< Raster column to start reading on
         INT32 *data,                        //!< Buffer to read into
         INT32 Length = 1                    //!< Number of columns to read
         ) const { return (v_ReadBand(Band, Line, StartColumn, data, Length, CONVMODE_INT32)); }

      //! Read a line of raster cells up to a certain length, converting to unsigned 32 bit
      ERRVALUE ReadBand (                       //! Read a raster line, unsigned 32 bit
         INT32 Band,                         //!< Image band number to read
         INT32 Line,                         //!< Raster line to read
         INT32 StartColumn,                     //!< Raster column to start reading on
         UINT32 *data,                       //!< Buffer to read into
         INT32 Length = 1                    //!< Number of columns to read
         ) const { return (v_ReadBand(Band, Line, StartColumn, data, Length, CONVMODE_INT32)); }

      //! Read a line of raster cells up to a certain length, converting to 32 bit float
      ERRVALUE ReadBand (                       //! Read a raster line, 4 byte floats
         INT32 Band,                         //!< Image band number to read
         INT32 Line,                         //!< Raster line to read
         INT32 StartColumn,                     //!< Raster column to start reading on
         float *data,                        //!< Buffer to read into
         INT32 Length = 1                    //!< Number of columns to read
         ) const { return (v_ReadBand(Band, Line, StartColumn, data, Length, CONVMODE_Float)); }

      //! Read a line of raster cells up to a certain length, converting to 64 bit double
      ERRVALUE ReadBand (                       //! Read a raster line, 8 byte doubles
         INT32 Band,                         //!< Image band number to read
         INT32 Line,                         //!< Raster line to read
         INT32 StartColumn,                     //!< Raster column to start reading on
         double *data,                       //!< Buffer to read into
         INT32 Length = 1                    //!< Number of columns to read
         ) const { return (v_ReadBand(Band, Line, StartColumn, data, Length, CONVMODE_Double)); }

      //! Read a line of raster cells up to a certain length
      ERRVALUE ReadColumnBand (
         INT32 Band,
         INT32 Line,                         //!< Raster line to read
         INT32 StartColumn,                  //!< Raster column to start reading on
         void *data,                         //!< Buffer to read into
         INT32 Length = 1,                   //!< Number of columns to read
         CONVMODE Convert = CONVMODE_None    //!< Data conversion mode
         ) const { return (v_ReadColumnBand(Band, Line, StartColumn, data, Length, Convert)); }

      //! Read a column of raster cells up to a certain length, converting to signed 8 bit
      ERRVALUE ReadColumnBand (                 //! Read a raster column, signed 8 bit
         INT32 Band,                         //!< Image band number to read
         INT32 Line,                         //!< Raster line to start reading on
         INT32 StartColumn,                     //!< Raster column to read
         INT8 *data,                         //!< Buffer to read into
         INT32 Length = 1                    //!< Number of lines to read
         ) const { return (v_ReadColumnBand(Band, Line, StartColumn, data, Length, CONVMODE_INT8)); }

      //! Read a column of raster cells up to a certain length, converting to unsigned 8 bit
      ERRVALUE ReadColumnBand (                 //! Read a raster column, unsigned 8 bit
         INT32 Band,                         //!< Image band number to read
         INT32 Line,                         //!< Raster line to start reading on
         INT32 StartColumn,                     //!< Raster column to read
         UINT8 *data,                        //!< Buffer to read into
         INT32 Length = 1                    //!< Number of lines to read
         ) const { return (v_ReadColumnBand(Band, Line, StartColumn, data, Length, CONVMODE_INT8)); }

      //! Read a column of raster cells up to a certain length, converting to signed 16 bit
      ERRVALUE ReadColumnBand (                 //! Read a raster column, signed 16 bit
         INT32 Band,                         //!< Image band number to read
         INT32 Line,                         //!< Raster line to start reading on
         INT32 StartColumn,                     //!< Raster column to read
         INT16 *data,                        //!< Buffer to read into
         INT32 Length = 1                    //!< Number of lines to read
         ) const { return (v_ReadColumnBand(Band, Line, StartColumn, data, Length, CONVMODE_INT16)); }

      //! Read a column of raster cells up to a certain length, converting to unsigned 16 bit
      ERRVALUE ReadColumnBand (                 //! Read a raster column, unsigned 16 bit
         INT32 Band,                         //!< Image band number to read
         INT32 Line,                         //!< Raster line to start reading on
         INT32 StartColumn,                     //!< Raster column to read
         UINT16 *data,                       //!< Buffer to read into
         INT32 Length = 1                    //!< Number of lines to read
         ) const { return (v_ReadColumnBand(Band, Line, StartColumn, data, Length, CONVMODE_INT16)); }

      //! Read a column of raster cells up to a certain length, converting to signed 32 bit
      ERRVALUE ReadColumnBand (                 //! Read a raster column, signed 32 bit
         INT32 Band,                         //!< Image band number to read
         INT32 Line,                         //!< Raster line to start reading on
         INT32 StartColumn,                     //!< Raster column to read
         INT32 *data,                        //!< Buffer to read into
         INT32 Length = 1                    //!< Number of lines to read
         ) const { return (v_ReadColumnBand(Band, Line, StartColumn, data, Length, CONVMODE_INT32)); }

      //! Read a column of raster cells up to a certain length, converting to unsigned 32 bit
      ERRVALUE ReadColumnBand (                 //! Read a raster column, unsigned 32 bit
         INT32 Band,                         //!< Image band number to read
         INT32 Line,                         //!< Raster line to start reading on
         INT32 StartColumn,                     //!< Raster column to read
         UINT32 *data,                       //!< Buffer to read into
         INT32 Length = 1                    //!< Number of lines to read
         ) const { return (v_ReadColumnBand(Band, Line, StartColumn, data, Length, CONVMODE_INT32)); }

      //! Read a column of raster cells up to a certain length, converting to 32 bit float
      ERRVALUE ReadColumnBand (                 //! Read a raster column, 4 byte floats
         INT32 Band,                         //!< Image band number to read
         INT32 Line,                         //!< Raster line to start reading on
         INT32 StartColumn,                     //!< Raster column to read
         float *data,                        //!< Buffer to read into
         INT32 Length = 1                    //!< Number of lines to read
         ) const { return (v_ReadColumnBand(Band, Line, StartColumn, data, Length, CONVMODE_Float)); }

      //! Read a column of raster cells up to a certain length, converting to 64 bit double
      ERRVALUE ReadColumnBand (                 //! Read a raster column, 8 byte doubles
         INT32 Band,                         //!< Image band number to read
         INT32 Line,                         //!< Raster line to start reading on
         INT32 StartColumn,                     //!< Raster column to read
         double *data,                       //!< Buffer to read into
         INT32 Length = 1                    //!< Number of lines to read
         ) const { return (v_ReadColumnBand(Band, Line, StartColumn, data, Length, CONVMODE_Double)); }

      //! Set the null value for the image
      //! If the 'NullValue' pointer is 'null', the image does not have a null value
      ERRVALUE SetNullValue (
         INT32 BandNum,
         const NULLVALUE* NullValue                //!< If pointer is 'null', the image has no null value, if not, the image has a null value
         ) { return (v_SetNullValue(BandNum, NullValue)); }

      //! Set the image tile cache to cache the number of tiles specified
      ERRVALUE SetCacheSize (
         INT32 NumTiles                      //!< Number of tiles to set cache
         ) { return (v_SetCacheSize(NumTiles)); }

      //! Set the image tile cache to cache a number of tiles specified by the RVC::IMAGE::CACHEMODE enumeration
      ERRVALUE SetCacheSize (
         CACHEMODE CacheFlags                //!< Tile row or diagonal tile cache sizes
         ) { return (v_SetCacheSize(CacheFlags)); }

      //! Write a line of raster cells up to a certain length
      ERRVALUE WriteBand (
         INT32 Band,                         //!< Image band number to write
         INT32 Line,                         //!< Raster line to write
         INT32 StartColumn,                     //!< Raster column to start writing on
         void *data,                         //!< Buffer to write into
         INT32 Length = 1,                   //!< Number of columns to write
         CONVMODE Convert = CONVMODE_None       //!< Data conversion mode
         ) { return (v_WriteBand(Band, Line, StartColumn, data, Length, Convert)); }

      //! Write a line of raster cells up to a certain length, converting from signed 8 bit
      ERRVALUE WriteBand (                   //! Write a raster line, signed 8 bit
         INT32 Band,                         //!< Image band number to write
         INT32 Line,                         //!< Raster line to write
         INT32 StartColumn,                     //!< Raster column to start writing on
         INT8 *data,                         //!< Buffer to write from
         INT32 Length = 1                    //!< Number of columns to write
         ) { return (v_WriteBand(Band, Line, StartColumn, data, Length, CONVMODE_INT8)); }

      //! Write a line of raster cells up to a certain length, converting from unsigned 8 bit
      ERRVALUE WriteBand (                   //! Write a raster line, unsigned 8 bit
         INT32 Band,                         //!< Image band number to write
         INT32 Line,                         //!< Raster line to write
         INT32 StartColumn,                     //!< Raster column to start writing on
         UINT8 *data,                        //!< Buffer to write from
         INT32 Length = 1                    //!< Number of columns to write
         ) { return (v_WriteBand(Band, Line, StartColumn, data, Length, CONVMODE_INT8)); }

      //! Write a line of raster cells up to a certain length, converting from signed 16 bit
      ERRVALUE WriteBand (                   //! Write a raster line, signed 16 bit
         INT32 Band,                         //!< Image band number to write
         INT32 Line,                         //!< Raster line to write
         INT32 StartColumn,                     //!< Raster column to start writing on
         INT16 *data,                        //!< Buffer to write from
         INT32 Length = 1                    //!< Number of columns to write
         ) { return (v_WriteBand(Band, Line, StartColumn, data, Length, CONVMODE_INT16)); }

      //! Write a line of raster cells up to a certain length, converting from unsigned 16 bit
      ERRVALUE WriteBand (                   //! Write a raster line, unsigned 16 bit
         INT32 Band,                         //!< Image band number to write
         INT32 Line,                         //!< Raster line to write
         INT32 StartColumn,                     //!< Raster column to start writing on
         UINT16 *data,                       //!< Buffer to write from
         INT32 Length = 1                    //!< Number of columns to write
         ) { return (v_WriteBand(Band, Line, StartColumn, data, Length, CONVMODE_INT16)); }

      //! Write a line of raster cells up to a certain length, converting from signed 32 bit
      ERRVALUE WriteBand (                   //! Write a raster line, signed 32 bit
         INT32 Band,                         //!< Image band number to write
         INT32 Line,                         //!< Raster line to write
         INT32 StartColumn,                     //!< Raster column to start writing on
         INT32 *data,                        //!< Buffer to write from
         INT32 Length = 1                    //!< Number of columns to write
         ) { return (v_WriteBand(Band, Line, StartColumn, data, Length, CONVMODE_INT32)); }

      //! Write a line of raster cells up to a certain length, converting from unsigned 32 bit
      ERRVALUE WriteBand (                   //! Write a raster line, unsigned 32 bit
         INT32 Band,                         //!< Image band number to write
         INT32 Line,                         //!< Raster line to write
         INT32 StartColumn,                     //!< Raster column to start writing on
         UINT32 *data,                       //!< Buffer to write from
         INT32 Length = 1                    //!< Number of columns to write
         ) { return (v_WriteBand(Band, Line, StartColumn, data, Length, CONVMODE_INT32)); }

      //! Write a line of raster cells up to a certain length, converting from 32 bit float
      ERRVALUE WriteBand (                   //! Write a raster line, 4 byte floats
         INT32 Band,                         //!< Image band number to write
         INT32 Line,                         //!< Raster line to write
         INT32 StartColumn,                     //!< Raster column to start writing on
         float *data,                        //!< Buffer to write from
         INT32 Length = 1                    //!< Number of columns to write
         ) { return (v_WriteBand(Band, Line, StartColumn, data, Length, CONVMODE_Float)); }

      //! Write a line of raster cells up to a certain length, converting from 64 bit double
      ERRVALUE WriteBand (                   //! Write a raster line, 8 byte doubles
         INT32 Band,                         //!< Image band number to write
         INT32 Line,                         //!< Raster line to write
         INT32 StartColumn,                     //!< Raster column to start writing on
         double *data,                       //!< Buffer to write from
         INT32 Length = 1                    //!< Number of columns to write
         ) { return (v_WriteBand(Band, Line, StartColumn, data, Length, CONVMODE_Double)); }

   protected:

      static DATATYPE ConvToDATATYPE (
         int RvcType,
         UINT16 NumBits
         );

      static UINT32 ConvToRastMode (
         CONVMODE value
         );

      #ifndef GENERATING_DOXYGEN_OUTPUT
      static void ImageCallbackFunc (RVC::AnyCallbackStruct *cb, void *data);
      #endif // GENERATING_DOXYGEN_OUTPUT

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      virtual ERRVALUE v_GetBandParms (INT32 BandNum, BANDPARMS& BandParms) const = 0;
      virtual double v_GetColumnScale () const = 0;
      virtual double v_GetLineScale () const = 0;
      virtual ERRVALUE v_GetNullValue (INT32 BandNum, NULLVALUE& NullValue) const = 0;
      virtual INT32 v_GetNumBands () const = 0;
      virtual INT32 v_GetNumColumns () const = 0;
      virtual INT32 v_GetNumLines () const = 0;
      virtual bool v_HasNullValue (INT32 BandNum) const = 0;
      virtual ERRVALUE v_ReadBand (INT32 Band, INT32 Line, INT32 StartColumn, void *data, INT32 Length, CONVMODE Convert) const = 0;
      virtual ERRVALUE v_ReadColumnBand (INT32 Band, INT32 Line, INT32 StartColumn, void *data, INT32 Length, CONVMODE Convert) const = 0;
      virtual ERRVALUE v_SetCacheSize (INT32 NumTiles) = 0;
      virtual ERRVALUE v_SetCacheSize (CACHEMODE CacheFlags) = 0;
      virtual ERRVALUE v_SetNullValue (INT32 BandNum, const NULLVALUE* NullValue) = 0;
      virtual ERRVALUE v_WriteBand (INT32 Band, INT32 Line, INT32 StartColumn, void *data, INT32 Length, CONVMODE Convert) = 0;
      #endif // GENERATING_DOXYGEN_OUTPUT

   public:
      //! Temporary static method to convert IMAGE::DATATYPE's to legacy RVCTYPE flags
      //! @return: RVCTYPE_ flag
      static UINT16 ConvToRVCTYPE (
         DATATYPE type,
         UINT16 NumBits
         );

   };

DEFINE_ENUM_OP_BITWISE(IMAGE::CELLTYPE)
DEFINE_ENUM_OP_BITWISE(IMAGE::PYRAMID);

//! Class to represent and manage band specific information.
class IMAGE::BANDPARMS {
   public:

      //! Default constructor
      BANDPARMS (
         ) :
         m_CellType(CELLTYPE_Invalid),
         m_PackOrder(PACKORDER_MostSigBit)
         {}

      //! Destructor
      ~BANDPARMS (
         ) {}

      //! Obtain the number of bits in this band.
      //! @return Number of bits.
      UINT16 GetNumBits (
         ) const { return (IMAGE::GetNumBitsFromCellType(m_CellType)); }

      //! Obtain the celltype of the image band
      //! @return Celltype of the image band
      CELLTYPE GetCellType (
         ) const { return (m_CellType); }

      //! Obtain the datatype of the image band
      //! @return Datatype of the image band
      DATATYPE GetDataType (
         ) const { return (IMAGE::GetDataTypeFromCellType(m_CellType)); }

      //! Obtain the packing order of the band
      //! @return Packing order
      PACKORDER GetPackOrder (
         ) const { return (m_PackOrder); }

      //! Set image band cell type.
      void SetCellType (
         CELLTYPE CellType
         ) { m_CellType = CellType; }

      //! Set the image band name.
      void SetName (
         const RVCOBJECTNAME& name
         ) { m_Name = name; }

      //! Set the image band name.
      void SetName (
         const char *name
         ) { m_Name.Assign(name); }

      //! Set the image band packing order
      void SetPackOrder (
         PACKORDER PackOrder
         ) { m_PackOrder = PackOrder; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      OBJECTNAME m_Name;
      CELLTYPE m_CellType;
      PACKORDER m_PackOrder;
      #endif // GENERATING_DOXYGEN_OUTPUT
   }; // End BANDPARMS.


//! Container for image null value.
class IMAGE::NULLVALUE {
   public:

      //! Mode for adjusting non-null cells having null value in ApplyMask.
      enum CONFLICTADJUST {
         CONFLICTADJUST_Auto,       //!< If null value <= 0 adjust up, otherwise down
         CONFLICTADJUST_None,       //!< Don't adjust conflicting values
         CONFLICTADJUST_Down,       //!< Adjust down (if null value minimum per cell type will adjust up)
         CONFLICTADJUST_Up          //!< Adjust up (if null value maximum per cell type will adjust down)
         };

      //! Default constructor.
      NULLVALUE (
         ): m_CellType(CELLTYPE_Invalid)
         {
         SetDefault();
         }

      //! Construct for specified cell type and initialize to default.
      explicit NULLVALUE (
         CELLTYPE CellType
         ): m_CellType(CellType)
         {
         SetDefault();
         }

      //! Apply mask to image cell buffer.
      //! Cells with mask values of 0 will be set to the null value.
      //! Cells with non-zero mask values and having the null value will be adjusted as specified.
      ERRVALUE ApplyMask (
         void *cellbuffer,                   //!< Cell buffer to apply mask to, must match cell type set for null value
         const UINT8 *maskbuffer,            //!< Mask buffer containing 0 where null and non-0 where valid
         INT32 count,                        //!< Number of cells to process
         CONFLICTADJUST conflictadjust = CONFLICTADJUST_Auto
         ) const;

      //! Convert value to cell type of *this.
      //! @return Error if value cannot be converted.
      ERRVALUE ConvToCellType (
         double value
         );

      //! Extract mask from image cell buffer.
      ERRVALUE ExtractMask (
         const void *cellbuffer,             //!< Cell buffer to extract mask from, must match cell type set
         UINT8 *maskbuffer,                  //!< Mask buffer returned, will contain 0 where null and 255 where valid
         INT32 count                         //!< Number of cells to process
         ) const;

      //! Obtain raster null value as ANYRASTVALUE.
      void GetValue (
         ANYRASTVALUE& value
         ) const;

      //! Get null value as INT8.
      //! @return Error if value cannot be converted without truncation.
      ERRVALUE GetValue (
         INT8& value
         ) const;

      //! Get null value as UINT8.
      //! @return Error if value cannot be converted without truncation.
      ERRVALUE GetValue (
         UINT8& value
         ) const;

      //! Get null value as INT16.
      //! @return Error if value cannot be converted without truncation.
      ERRVALUE GetValue (
         INT16& value
         ) const;

      //! Get null value as UINT16, suitable for 16-bit RGB also.
      //! @return Error if value cannot be converted without truncation.
      ERRVALUE GetValue (
         UINT16& value
         ) const;

      //! Get null value as INT32.
      //! @return Error if value cannot be converted without truncation.
      ERRVALUE GetValue (
         INT32& value
         ) const;

      //! Get null value as UINT32.
      //! @return Error if value cannot be converted without truncation.
      ERRVALUE GetValue (
         UINT32& value
         ) const;

      //! Get null value as float.
      //! @return Error if value cannot be converted without truncation.
      ERRVALUE GetValue (
         float& value
         ) const;

      //! Get null value as double.
      //! @return Error if value cannot be converted without truncation.
      ERRVALUE GetValue (
         double& value
         ) const;

      //! Get null value as FCOMPLEXRI.
      //! @return Error if value cannot be converted without truncation.
      ERRVALUE GetValue (
         FCOMPLEXRI& value
         ) const;

      //! Get null value as FCOMPLEXMP.
      //! @return Error if value cannot be converted without truncation.
      ERRVALUE GetValue (
         FCOMPLEXMP& value
         ) const;

      //! Get null value as DCOMPLEXRI.
      //! @return Error if value cannot be converted without truncation.
      ERRVALUE GetValue (
         DCOMPLEXRI& value
         ) const;

      //! Get null value as DCOMPLEXMP.
      //! @return Error if value cannot be converted without truncation.
      ERRVALUE GetValue (
         DCOMPLEXMP& value
         ) const;

      //! Set cell type for null value.
      //! This will also set the null value to the default for the specified cell type.
      void SetCellType (
         CELLTYPE CellType
         ) { m_CellType = CellType; SetDefault(); }

      //! Set default null value for current cell type.
      void SetDefault (
         );

      //! Set cell type and value from ANYRASTVALUE.
      void SetValue (
         CELLTYPE CellType,
         const ANYRASTVALUE& value
         );

      //! Set value from signed integer.
      //! @return Error if out of range for current cell type.
      ERRVALUE SetValue (
         int value
         );

      //! Set value from unsigned integer.
      //! @return Error if out of range for current cell type.
      ERRVALUE SetValue (
         unsigned int value
         );

      //! Set value from float/double.
      //! @return Error if out of range for current cell type.
      ERRVALUE SetValue (
         double value
         );

      //! Set value from FCOMPLEXRI.
      //! @return Error if out of range for current cell type.
      ERRVALUE SetValue (
         const FCOMPLEXRI& value
         );

      //! Set value from FCOMPLEXMP.
      //! @return Error if out of range for current cell type.
      ERRVALUE SetValue (
         const FCOMPLEXMP& value
         );

      //! Set value from DCOMPLEXRI.
      //! @return Error if out of range for current cell type.
      ERRVALUE SetValue (
         const DCOMPLEXRI& value
         );

      //! Set value from DCOMPLEXMP.
      //! @return Error if out of range for current cell type.
      ERRVALUE SetValue (
         const DCOMPLEXMP& value
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      double m_ValueD;
      double m_ValueD2;
      UINT8 m_ValueRGB[4];
      CELLTYPE m_CellType;

      bool ApplyAdjustment (CONFLICTADJUST adjustment);
      bool IsColor () const;
      bool IsComplex () const;
      bool IsInt () const;
      #endif // GENERATING_DOXYGEN_OUTPUT

   }; // End NULLVALUE


//! OBSERVER class for RVC::IMAGE objects.
class IMAGE::OBSERVER : public RVC::OBJECTOBSERVER {
   public:
      enum TYPE {
         TYPE_NullValueChange = 0x00000111
         };

      explicit OBSERVER (
         RVC::IMAGE& object
         ) : OBJECTOBSERVER(object) {}

      virtual ~OBSERVER (
         ) {}

   private:
      //! Called when the image object null value settings have changed
      virtual void v_OnNullValueChanged (
         const ANYRASTVALUE& NullValue,
         bool IsNullUsed
         ) { return; }

      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual void OnNotifyRaw (UINT32 reason, void *data);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class IMAGE::STATISTICS {
   public:
      STATISTICS (
         ) :
         m_MeanFull(0.0),
         m_StdDev(0.0),
         m_Sum(0.0),
         m_SumOfSquares(0.0),
         m_MinValue(0.0),
         m_MaxValue(0.0),
         m_CellCount(0),
         m_NullCount(0),
         m_IsEstimate(false)
         {}

      ~STATISTICS () {}

      //! Get the count of cells used in statistics
      //! @return Count of cells used in statistics
      INT64 GetCount (
         ) const { return (m_CellCount); }

      //! Get maximum value of the image
      //! @return Maximum value of the image
      double GetMaximum (
         ) const { return (m_MaxValue); }

      //! Get mean value of full image
      //! @return Mean value of full image
      double GetMean (
         ) const { return (m_MeanFull); }

      //! Get minimum value of the image
      //! @return Minimum value of the image
      double GetMinimum (
         ) const { return (m_MinValue); }

      //! Get the count of null cells in the image
      //! @return Count of null cells in the image
      INT64 GetNullCount (
         ) const { return (m_NullCount); }

      //! Get standard deviation of the image values
      //! @return Standard deviation of the image values
      double GetStandardDeviation (
         ) const { return (m_StdDev); }

      //! Get sum of the image values
      //! @return sum of the image values
      double GetSum (
         ) const { return (m_Sum); }

      //! Get sum of the image values
      //! @return sum of the image values
      double GetSumOfSquares (
         ) const { return (m_SumOfSquares); }

      bool IsEstimate (
         ) const { return (m_IsEstimate); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      double m_MeanFull;                     //!< Mean value for entire data range
      double m_StdDev;                       //!< Standard Deviation within selected bin range
      double m_Sum;                          //!< Sum of values
      double m_SumOfSquares;                 //!< Sum of squares of values
      double m_MinValue;                     //!< Minimum value in area for image
      double m_MaxValue;                     //!< Maximum value in area for image
      INT64 m_CellCount;
      INT64 m_NullCount;
      bool m_IsEstimate;

      friend class HISTOGRAM;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


}     //! End of RVC namespace

#endif      //!< INC_RVC_IMAGE_H

---