raster.h

Go to the documentation of this file.

/***
 * \file rvc/raster.h 
 * \brief interface for the RVC::RASTER class.
 *
 * \if NODOC
 * $Id: raster.h_v 1.48 2004/11/10 18:25:19 mju Exp $
 *
 * $Log: raster.h_v $
 * Revision 1.48  2004/11/10 18:25:19  mju
 * Add getComponents.
 *
 * Revision 1.47  2004/11/10 14:45:50  mju
 * Change method for setting whether to include embedded pyramid tiers to match actual meaning.
 *
 * Revision 1.46  2004/08/31 17:46:00  scowan
 * Moved cache size methods to image class.
 *
 * Revision 1.45  2004/07/07 19:49:51  scowan
 * Added set embedded pyramid method.
 *
 * Revision 1.44  2004/03/04 18:45:21  scowan
 * Added virtual dtors to filter classes.
 *
 * Revision 1.43  2004/03/01 15:45:43  mju
 * Add validatePyramidFlags.
 *
 * Revision 1.42  2004/02/24 18:39:43  scowan
 * Added opacity usage.
 *
 * Revision 1.41  2004/01/28 20:24:05  scowan
 * Added new link types.
 *
 * Revision 1.40  2004/01/19 17:01:50  scowan
 * Added makeparm method.
 *
 * Revision 1.39  2003/12/04 23:43:52  scowan
 * Fixed ecw link ctor.
 *
 * Revision 1.38  2003/12/03 14:52:17  mju
 * Remove hasPyramids.
 * If skip sample when make pyramid tier then skip tier number too.
 *
 * Revision 1.37  2003/11/21 22:17:08  scowan
 * Support new Capabilities system.
 *
 * Revision 1.36  2003/10/31 23:01:57  scowan
 * SOmething.
 *
 * Revision 1.35  2003/10/30 18:27:54  scowan
 * Added copy raster methods.
 *
 * Revision 1.34  2003/10/23 21:25:09  scowan
 * Changed get pyramid list function.
 *
 * Revision 1.33  2003/10/23 16:55:49  scowan
 * Allow JP2 links to be pyramids.
 *
 * Revision 1.32  2003/10/22 22:22:23  scowan
 * Added new makeparm method.
 *
 * Revision 1.31  2003/10/20 20:57:51  scowan
 * Added used bits setting.
 *
 * Revision 1.30  2003/10/15 15:05:25  scowan
 * nc.
 *
 * Revision 1.29  2003/10/07 17:30:46  scowan
 * Object virtual method changes.
 *
 * Revision 1.28  2003/10/01 22:08:10  scowan
 * Made more items const.
 *
 * Revision 1.27  2003/09/30 16:52:06  dwilliss
 * Doxygen
 *
 * Revision 1.26  2003/09/25 21:20:04  dwilliss
 * Fixed doxygen comment
 *
 * Revision 1.25  2003/09/15 23:17:17  scowan
 * Support new set null value virtual method.
 *
 * Revision 1.24  2003/09/15 13:49:45  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.23  2003/08/28 16:49:50  scowan
 * added to generic link parms class.
 *
 * Revision 1.22  2003/08/28 15:59:33  scowan
 * Added static method for auto link tiff's.
 *
 * Revision 1.21  2003/08/27 21:26:11  scowan
 * Uses new rvc raster class interface and handle.
 *
 * Revision 1.20  2003/06/27 20:38:56  scowan
 * Added composite band reading.
 *
 * Revision 1.19  2003/05/07 22:19:55  scowan
 * Changed virtual method format.
 *
 * Revision 1.18  2002/09/05 21:31:17  scowan
 * Changed inclide file name.
 *
 * Revision 1.17  2002/04/26 22:44:45  scowan
 * Added more virtual methods.
 *
 * Revision 1.16  2002/04/24 22:37:30  scowan
 * Added more methods.
 *
 * Revision 1.15  2002/01/30 15:56:51  scowan
 * Added sml context creation method.
 *
 * Revision 1.14  2002/01/09 23:05:06  scowan
 * Added methods to get compression type from makeparms.
 *
 * Revision 1.13  2002/01/08 18:38:01  scowan
 * Attempted to move nested classes outside for docs, could not do it.
 *
 * Revision 1.12  2001/11/02 17:15:07  mju
 * Use CELLTYPE instead of DATATYPE/numbits.
 * Add HasNullValue() methods.
 *
 * Revision 1.11  2001/10/25 21:29:44  scowan
 * Nothing.
 *
 * Revision 1.10  2001/10/16 21:34:46  vdronov
 * added PYRAMID_UseColorMap
 *
 * Revision 1.9  2001/09/06 19:42:27  scowan
 * Bitwise use of pyramid flags.
 *
 * Revision 1.8  2001/09/06 19:31:51  scowan
 * Added pyramid wrapper methods.
 *
 * Revision 1.7  2001/06/14 16:09:41  scowan
 * Changed source type.
 *
 * Revision 1.6  2001/06/14 14:59:24  scowan
 * Added to RVC namespace.
 *
 * Revision 1.5  2001/06/13 15:46:19  scowan
 * Changed objtypoe enum.
 *
 * Revision 1.4  2001/05/25 21:42:49  scowan
 * Create only one make method.
 * Make link parms for link method.
 *
 * Revision 1.3  2000/12/01 14:54:05  scowan
 * Fixed MAC errors.
 *
 * Revision 1.2  2000/10/19 21:18:11  scowan
 * Checked in for vacation.
 *
 * Revision 1.1  2000/10/02 17:23:21  scowan
 * Initial revision
 *
 * \endif
***/

//!   \class RVC::RASTER rvc/raster.h
//!   \brief Manages RVC::OBJTYPE_Raster RVC objects.  
//!   
//!   The interface currently wraps the MfRaster functions.
//!   
//!   RVC Object Types that this class supports: RVC::OBJTYPE_Raster.
//!
//!   Default RVC Object Type for this class: RVC::OBJTYPE_Raster.
//!
//!   Valid parents for this class:
//!      - RVC::OBJTYPE_File
//!      - RVC::OBJTYPE_Folder
//!      - RVC::OBJTYPE_Raster
//!      - RVC::OBJTYPE_Hyperspectral
//!      - RVC::OBJTYPE_RasterSet
//!      - RVC::OBJTYPE_Thumbnail

#ifndef INC_RVC_RASTER_H
#define INC_RVC_RASTER_H

#ifndef INC_RVC_IMAGE_H
   #include <rvc/image.h>
#endif

#ifndef INC_MI32_ANYRASTV_H
   #include <mi32/anyrastv.h>
#endif

#ifndef INC_MI32_SIMPLEAR_H
   #include <mi32/simplear.h>
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
struct RVCRASTINFO;        // Forward declarations
struct SMLCONTEXT;
#endif // GENERATING_DOXYGEN_OUTPUT

namespace RVC {

#ifndef GENERATING_DOXYGEN_OUTPUT
class RASTERHANDLE;
struct RASTERLINKPARMS;
struct RASTERLINKDATAGEN;
#endif // GENERATING_DOXYGEN_OUTPUT

class RASTER : public RVC::IMAGE {
   public:

      enum LINKTYPE {               //! Type of external objects that can be linked to
         LINKTYPE_NoLink = 0,       //!< Raster is internal
         LINKTYPE_TIFF = 2,         //!< Raster is a link to TIFF image
         LINKTYPE_Generic = 3,      //!< Raster is a link to a generic raster image
         LINKTYPE_MrSID = 4,
         LINKTYPE_ECW = 5,
         LINKTYPE_JP2 = 6,
         LINKTYPE_SocetSetDT = 7,
         LINKTYPE_PNG = 8,
         LINKTYPE_JPEG = 9
         };

      enum COMPONENT {           //! Possible data conversion modes for Read(), ReadColumn() and Write()
         COMPONENT_Default = 0,     //!< Select default component
         COMPONENT_Red,             //!< Convert RGB to Red
         COMPONENT_Green,           //!< Convert RGB to Green
         COMPONENT_Blue,            //!< Convert RGB to Blue
         COMPONENT_Real,            //!< Convert to Real complex component
         COMPONENT_Imaginary,       //!< Convert to Imaginary complex component
         COMPONENT_Magnitude,       //!< Convert to Magnitude complex component
         COMPONENT_Phase,           //!< Convert to Phase complex component
         COMPONENT_Alpha,           //!< Convert to Alpha channel component from RGBA or ARGB
         COMPONENT_Cyan,            //!< Convert to Cyan from CMYK or KCMY
         COMPONENT_Magenta,         //!< Convert to Magenta from CMYK or KCMY
         COMPONENT_Yellow,          //!< Convert to Yellow from CMYK or KCMY
         COMPONENT_Black            //!< Convert to Black from CMYK or KCMY
         };

      enum USAGE {               //! Raster usage values, used in Make()
         USAGE_Default = 0,         //!< Ordinary raster
         USAGE_HyspcBand,           //!< HyperSpectral Band raster
         USAGE_HyspcClass,          //!< HyperSpectral Class raster
         USAGE_HyspcAverage,        //!< HyperSpectral Average raster
         USAGE_Pyramid,             //!< Pyramid raster
         USAGE_PrinComp,            //!< Principle Components raster
         USAGE_NullBand,            //!< Null band raster
         USAGE_Opacity              //!< Opacity mask raster
         };

      enum COMPTYPE {            //! Raster compression types
         COMPTYPE_None = 0,         //!< Set no compression
         COMPTYPE_RLE,              //!< Uses RLE compression, valid for 1-bit rasters
         COMPTYPE_JPEG,             //!< Uses JPEG compression, valid for 8-bit and 24-bit rasters
         COMPTYPE_Huffman,          //!< Uses Huffman compression, used in Hyperspectral images
         COMPTYPE_DPCM,             //!< Uses DPCM compression
         COMPTYPE_JP2               //!< Uses JP2 compression
         };

      #ifndef GENERATING_DOXYGEN_OUTPUT
      //! Forward declarations
      class GETOBJFILTER_ISSELECTABLE;
      class GETOBJFILTER_ISOVERLAPPING;
      #endif // GENERATING_DOXYGEN_OUTPUT
      
      //! Class to implement raster scale values
      class IMAGESCALE {
         public:

            //! Default constructor
            IMAGESCALE (
               ) :
               m_LineScale(1.0),
               m_ColumnScale(1.0),
               m_DataScale(1.0),
               m_DataOffset(0.0)
               {}

            //! Obtain raster column scale
            //! @return raster column scale
            double GetColumnScale (
               ) const {return (m_ColumnScale); }

            //! Obtain raster data offset
            //! @return raster data offset
            double GetDataOffset (
               ) const {return (m_DataOffset);}

            //! Obtain raster data scale
            //! @return raster data scale
            double GetDataScale (
               ) const {return (m_DataScale);}

            //! Obtain raster line scale
            //! @return raster line scale
            double GetLineScale (
               ) const {return (m_LineScale);}

            //! Set raster column scale
            void SetColumnScale (
               double ColumnScale
               ) {
               m_ColumnScale = ColumnScale;
               if (m_ColumnScale == 0.0) m_ColumnScale = 1.0;
               return;
               }

            //! Set raster data offset
            void SetDataOffset (
               double DataOffset
               ) {m_DataOffset = DataOffset; }

            //! Set raster data scale
            void SetDataScale (
               double DataScale
               ) {
               m_DataScale = DataScale;
               if (m_DataScale == 0.0) m_DataScale = 1.0;
               return;
               }

            //! Set raster line scale
            void SetLineScale (
               double LineScale
               ) {
               m_LineScale = LineScale;
               if (m_LineScale == 0.0) m_LineScale = 1.0;
               return;
               }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            double m_LineScale;           //!< Line scale
            double m_ColumnScale;         //!< Column scale
            double m_DataScale;           //!< Scale factor for cell value
            double m_DataOffset;       //!< Offset for cell value
            #endif // GENERATING_DOXYGEN_OUTPUT
         }; // End of IMAGESCALE nested class.

      #ifndef GENERATING_DOXYGEN_OUTPUT
      //! Forward declarations
      class LINKPARMS;     
      class LINKPARMS_ECW;
      class LINKPARMS_GENERIC;
      class LINKPARMS_JP2;
      class LINKPARMS_JPEG;
      class LINKPARMS_MRSID;
      class LINKPARMS_PNG;
      class LINKPARMS_SOCETSETDT;
      class LINKPARMS_TIFF;
      #endif // GENERATING_DOXYGEN_OUTPUT
      
      //! Class to handle values needed to define the characteristics of a raster
      class MAKEPARMS {
         public:

            //! Constructor, initialize with critical raster creation parameters
            MAKEPARMS (
               INT32 NumLines,
               INT32 NumColumns,
               IMAGE::CELLTYPE CellType
               ) :
               m_NumLines(NumLines),
               m_NumColumns(NumColumns),
               m_CellType(CellType),
               m_TileLines(0), 
               m_TileColumns(0), 
               m_Usage(USAGE_Default),
               m_Inverted(false),
               m_PackOrder(PACKORDER_MostSigBit),
               m_CompType(COMPTYPE_None),
               m_CompQuality(75),
               m_UsedBits(0),
               m_IsCompressed(false),
               m_IsLossyCompressed(false),
               m_Fill(false),
               m_NoEmbeddedPyramidTiers(false)
               { }

            //! Template constructor
            MAKEPARMS (
               const RASTER& Template,          //!< Raster template to determine NumLines, NumColumns, Usage, and scaling
               IMAGE::CELLTYPE CellType = CELLTYPE_Invalid  //!< Optional cell type, default uses type from template
               ) :
               m_NumLines(Template.GetNumLines()),
               m_NumColumns(Template.GetNumColumns()),
               m_CellType((CellType!=CELLTYPE_Invalid)?CellType:Template.GetCellType()),
               m_TileLines(Template.GetNumTileLines()),
               m_TileColumns(Template.GetNumTileColumns()),
               m_Usage(Template.GetUsage()),
               m_Inverted(false),
               m_PackOrder(PACKORDER_MostSigBit),
               m_CompType(COMPTYPE_None),
               m_CompQuality(75),
               m_UsedBits(Template.GetNumUsedBits()),
               m_IsCompressed(false),
               m_IsLossyCompressed(false),
               m_Fill(false),
               m_NoEmbeddedPyramidTiers(false)
               {
               Template.GetImageScale(m_ImageScale);
               }

            //! Obtain image cell type.
            //! @return RVC::IMAGE::CELLTYPE for the raster.
            IMAGE::CELLTYPE GetCellType (
               ) const {return (m_CellType);}
               
            //! Obtain raster compression quality
            //! @return Compression quality for the raster.
            UINT16 GetCompressionQuality (
               ) const {return (m_CompQuality);}

            //! Obtain raster compression type
            //! @return RVC::RASTER::COMPTYPE for the raster.
            COMPTYPE GetCompressionType (
               ) const {return (m_CompType);}

            //! Obtain datatype based on raster creation parameters
            //! @return RVC::IMAGE::DATATYPE of the raster
            IMAGE::DATATYPE GetDataType (
               ) const {return (IMAGE::GetDataTypeFromCellType(m_CellType));}
         
            //! Obtain default raster tile size based on creation parameters
            //! @return default tile size
            INT32 GetDftTileSize (
               ) const;
               
            //! Get image scale information (RVC::RASTER::IMAGESCALE)
            //! @return IMAGESCALE reference
            const IMAGESCALE& GetImageScale (
               ) const {return (m_ImageScale);} 

            //! Get initial raster value
            bool GetInitialValue (
               ANYRASTVALUE& value
               ) const {
               value = m_InitValue;
               return (m_Fill);
               }
               
            //! Obtain number of bits in a raster cell
            //! @return number of raster bits
            UINT16 GetNumBits (
               ) const {return (IMAGE::GetNumBitsFromCellType(m_CellType));}
         
            //! Obtain number of columns in a raster
            //! @return number of raster columns
            INT32 GetNumColumns (
               ) const {return (m_NumColumns);}
         
            //! Obtain number of lines in a raster
            //! @return number of raster lines
            INT32 GetNumLines (
               ) const {return (m_NumLines);}

            //! Get the number of used bits.
            //! This related to JP2 compression and is dependent on the source raster value range.
            //! The number of used bits will be less than or equal to the number of bits in the created raster object.
            UINT16 GetNumUsedBits (
               ) const { return (m_UsedBits); }
               
            //! Obtain raster tile size based on creation parameters
            void GetTileSize (
               INT32& TileLines,       //!< Number of lines in a tile RETURNED
               INT32& TileColumns         //!< Number of columns in a tile RETURNED
               ) const;

            //! Obtain raster value range 
            void GetValueMinMax (
               ANYRASTVALUE& min,         //!< Minimum possible raster value
               ANYRASTVALUE& max       //!< Maximum possible raster value
               ) const;

            //! Is the raster compressed with a lossy compression algorithm?
            //! @return true if the raster is compressed with a lossy compression algorithm
            bool IsLossyCompressed (
               ) const {return (m_IsLossyCompressed);}

            //! Is the compression type valid for the raster cell type
            //! @return True if it is, false if not
            bool IsValidCompression (
               COMPTYPE CompType
               ) const;
               
            //! Set image cell type.
            void SetCellType (
               CELLTYPE CellType
               ) {m_CellType = CellType;}

            //! Set raster compression values
            void SetCompression (
               COMPTYPE CompType,         //!< Raster compression type
               UINT16 CompQuality         //!< Compression quality for lossy compression
               );
               
            //! Set whether to include embedded pyramid tiers if supported.
            //! Used in JPEG2000 compressed rasters produce only single resolution level.
            //! Default is to include embedded pyramid tiers.
            void SetIncludeEmbeddedPyramidTiers (
               bool IncludeTiers
               ) { m_NoEmbeddedPyramidTiers = !IncludeTiers; }
               
            //! Set image scale information (RVC::RASTER::IMAGESCALE)
            void SetImageScale (
               const IMAGESCALE& ImageScale
               ) {m_ImageScale = ImageScale; }  

            //! Set initial raster value
            void SetInitialValue (
               const ANYRASTVALUE& value
               ) {
               m_InitValue = value;
               m_Fill = true;
               return;
               }

            //! Set raster inversion flag
            void SetInverted (
               ) {m_Inverted = true;}

            //! Set number of columns in a raster
            void SetNumColumns (
               INT32 NumColumns
               ) {m_NumColumns = NumColumns;}

            //! Set number of lines in a raster
            void SetNumLines (
               INT32 NumLines
               ) {m_NumLines = NumLines;}
               
            //! Set the number of used bits.
            //! This related to JP2 compression and is dependent on the source raster value range.
            //! The number of used bits will be less than or equal to the number of bits in the created raster object.
            void SetNumUsedBits (
               const RASTER& SrcRastObj
               );

            //! Set the number of used bits.
            //! This related to JP2 compression and is dependent on the source raster value range.
            //! The number of used bits will be less than or equal to the number of bits in the created raster object.
            void SetNumUsedBits (
               UINT16 UsedBits
               ) { m_UsedBits = UsedBits; }

            //! Set raster pack order
            void SetPackOrder (
               PACKORDER PackOrder        //!< New raster pack order
               ) {m_PackOrder = PackOrder;}

            //! Set raster tile size, only if you know what you are doing!
            void SetTileSize (
               INT32 TileLines,
               INT32 TileColumns
               ) {
               m_TileLines = TileLines;
               m_TileColumns = TileColumns;
               return;
               }

            //! Set raster usage parameter, only if you know what you are doing
            void SetUsage (
               USAGE usage
               ) {m_Usage = usage;}

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            INT32 m_NumLines;             //!< Number of lines in raster
            INT32 m_NumColumns;           //!< Number of columns in raster
            CELLTYPE m_CellType;          //!< Image cell type
            PACKORDER m_PackOrder;        //!< Raster pack order
            USAGE m_Usage;                //!< Raster usage, see enum
            INT32 m_TileLines;            //!< Number of lines per tile
            INT32 m_TileColumns;          //!< Number of columns per tile
            COMPTYPE m_CompType;          //!< Compression type
            UINT16 m_CompQuality;         //!< Compression quality, 1-100, 0 == default
            UINT16 m_UsedBits;            //!< The number of used bits will be less than or equal to the number of bits in the created raster object.
            bool m_Inverted;              //!< Is raster inverted?
            bool m_IsCompressed;          //!< Is raster compressed
            bool m_IsLossyCompressed;     //!< Is raster lossy compressed
            bool m_Fill;
            bool m_NoEmbeddedPyramidTiers;
            ANYRASTVALUE m_InitValue;     //!< Value to initialize raster with
            IMAGESCALE m_ImageScale;

            friend class RASTER;
            #endif // GENERATING_DOXYGEN_OUTPUT
         }; // End of MAKEPARMS nested class.

      
      //! Default constructor.
      RASTER (
         );

      //! Copy constructor.
      RASTER (
         const RVC::RASTER& rhs
         );

      //! Destructor
      virtual ~RASTER (
         );

      //! Assignment.
      RVC::RASTER& operator= (
         const RVC::RASTER& rhs
         );

      static ERRVALUE AutoLinkTIFF (
         RVC::OBJECT& ParentObj,
         const FILEPATH& LinkFile,
         RVC::GEOSPATIAL::MAKELINKFLAGS LinkFlags
         );
         
      //! Compute the next pyramid size based on the sizes passed in
      //! @return 'True' if the next size is valid, 'false' if not
      static bool ComputeNextPyramidSize (
         INT32& NumColumns,
         INT32& NumLines
         );

      //! Copy the raster into the 'DestRaster' object using the sampling rates 'ColumnSample' and 'LineSample'
      //! This algorithm averages the cell cluster based on the sample rate for the destination
      ERRVALUE CopyAverageTo (
         RASTER& DestRaster,
         INT32 ColumnSample,
         INT32 LineSample,
         SIMPLE_ARRAY<COLOR>* ColorMap = 0
         );

      //! Copy the raster into the 'DestRaster' object using the sampling rates 'ColumnSample' and 'LineSample'
      //! This algorithm selects a cell to copy to the destination raster based on the sample rate
      ERRVALUE CopySampledTo (
         RASTER& DestRaster,
         INT32 ColumnSample,
         INT32 LineSample
         );

      //! Create an SML context for the given raster class instance
      ERRVALUE CreateSMLContext (
         SMLCONTEXT **pcontext               //!< SML context allocated and RETURNED
         );

      //! Obtain raster cell type.
      //! @return RVC::IMAGE::CELLTYPE of the raster
      IMAGE::CELLTYPE GetCellType (
         ) const {return (m_MakeParms.GetCellType());}

      //! Obtain array of components present for this raster.
      ERRVALUE GetComponents (
         SIMPLE_ARRAY<COMPONENT>& Components
         ) const;

      //! Obtain raster compression type
      //! @return RVC::RASTER::COMPTYPE for the raster.
      COMPTYPE GetCompressionType (
         ) const {return (m_MakeParms.m_CompType);}

      //! Obtain raster datatype based on RVC::IMAGE::DATATYPE enumeration
      //! @return RVC::IMAGE::DATATYPE of the raster
      IMAGE::DATATYPE GetDataType (
         ) const {return (m_MakeParms.GetDataType());}
      
      //! Obtain raster creation parameters
      //! @return const RVC::RASTER::MAKEPARMS
      const MAKEPARMS& GetMakeParms (
         ) const {return (m_MakeParms);}

      //! Obtain raster scale values (line, column, data scale and data offset)
      ERRVALUE GetImageScale (
         IMAGESCALE& scale                //!< Class to hold image scale values RETURNED
         ) const;

      //! Obtain type of external image the raster object is linked to
      //! @return RVC::RASTER::LINKTYPE enumeration value
      LINKTYPE GetLinkType (
         ) const {return (m_LinkType);}
         
      //! Obtain raster null value information
      ERRVALUE GetNullValue (
         NULLVALUE& NullValue             //!< Current NULLVALUE to get from raster
         ) const;

      //! Obtain number of bits in a raster cell
      //! @return number of bits in a raster cell
      UINT16 GetNumBits (
         ) const {return (m_MakeParms.GetNumBits());}

      //! Obtain number of columns in a raster tile
      //! @return number of columns in the raster tile
      INT32 GetNumTileColumns (
         ) const {return (m_MakeParms.m_TileColumns);}

      //! Obtain number of lines in a raster tile
      //! @return number of lines in the raster tile
      INT32 GetNumTileLines (
         ) const {return (m_MakeParms.m_TileLines);}

      //! Get the number of used bits.
      //! This related to JP2 compression and is dependent on the source raster value range.
      //! The number of used bits will be less than or equal to the number of bits in the created raster object.
      UINT16 GetNumUsedBits (
         ) const { return (m_MakeParms.m_UsedBits); }
            
      //! Obtain number of tiles in a raster row
      //! @return number of row tiles
      INT32 GetNumXTiles (
         ) const {return (m_XTiles);}

      //! Obtain number of tiles in a raster column
      //! @return number of column tiles
      INT32 GetNumYTiles (
         ) const {return (m_YTiles);}

      //! Obtain raster pack order
      //! @return Raster pack order
      PACKORDER GetPackOrder (
         ) const {return (m_MakeParms.m_PackOrder);}

      //! Return list of available raster pyramid sub-rasters.
      //!   The sample rate list will be sorted in ascending order and the array and list are aligned.
      ERRVALUE GetPyramidList (
         SIMPLE_ARRAY<INT32>& SampleList,    //!< Simple array of available sample rates RETURNED
         RVC::OBJITEMLIST& PyramidList       //!< List of pyramid raster ObjItem's RETURNED
         );
         
      //! Obtain number of bytes in a raster tile
      //! @return size of raster tile in bytes
      INT32 GetTileSizeBytes (
         ) const {return (m_TileSize);}

      //! Obtain purpose of raster image
      //! @return RVC::RASTER::USAGE enumeration value
      USAGE GetUsage (
         ) const {return (m_MakeParms.m_Usage);}

      //! Determine if null value exists for raster.
      bool HasNullValue (
         ) const;
         
      //! Is the raster compressed?
      //! @return true if the raster is compressed
      bool IsCompressed (
         ) const {return (m_MakeParms.m_IsCompressed);}

      //! Is the raster compressed with a lossy compression algorithm?
      //! @return true if the raster is compressed with a lossy compression algorithm
      bool IsLossyCompressed (
         ) const {return (m_MakeParms.m_IsLossyCompressed);}

      //! Is the raster flipped around such that the first raster line is at the bottom of the image
      //! @return true if the raster is inverted
      bool IsInverted (
         ) const {return (m_MakeParms.m_Inverted);}

      //! Create a raster object and establish a link to an external image
      ERRVALUE Link (
         const RVC::OBJECT& parent,             //!< Parent object to create raster under
         const RVC::OBJECTNAME& name,           //!< Name of raster object
         const RVC::OBJECTDESC& desc,           //!< Raster object description
         const LINKPARMS& LinkParms,
         const char* Source = 0                 //!< Source of raster creation, default is GetAppName()
         );

      //! Create a raster object
      ERRVALUE Make (
         const RVC::OBJECT& parent,             //!< Parent object to create raster under
         const RVC::OBJECTNAME& name,           //!< Name of raster object
         const RVC::OBJECTDESC& desc,           //!< Raster object description
         MAKEPARMS& MakeParms,                  //!< Parameters needed to create raster, cannot be changed after creation
         const char* Source = 0                 //!< Source of raster creation, default is GetAppName()
         );

      //! Create a raster object
      ERRVALUE Make (
         const RVC::OBJITEM& ObjItem,
         MAKEPARMS& MakeParms,                  //!< Parameters needed to create raster, cannot be changed after creation
         const char* Source = 0                 //!< Source of raster creation, default is GetAppName()
         );

      //! Create pyramid set under this raster object
      //! It will not write over valid pyramids unless PYRAMID_Rebuild is specified
      ERRVALUE MakePyramidSet (
         IMAGE::PYRAMID flags = IMAGE::PYRAMID_None
         );

      //! Read a line of raster cells up to a certain length
      ERRVALUE Read (
         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
         COMPONENT Component = COMPONENT_Default   //!< Component extraction value
         ) const;

      //! Read a line of raster cells up to a certain length, converting to signed 8 bit
      ERRVALUE 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
         COMPONENT Component = COMPONENT_Default   //!< Component extraction value
         ) const { return (Read(Line, StartColumn, data, Length, CONVMODE_INT8, Component)); }

      //! Read a line of raster cells up to a certain length, converting to unsigned 8 bit
      ERRVALUE 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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) const { return (Read(Line, StartColumn, data, Length, CONVMODE_INT8, Component)); }

      //! Read a line of raster cells up to a certain length, converting to signed 16 bit
      ERRVALUE 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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) const { return (Read(Line, StartColumn, data, Length, CONVMODE_INT16, Component)); }

      //! Read a line of raster cells up to a certain length, converting to unsigned 16 bit
      ERRVALUE 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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) const { return (Read(Line, StartColumn, data, Length, CONVMODE_INT16, Component)); }

      //! Read a line of raster cells up to a certain length, converting to signed 32 bit
      ERRVALUE 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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) const { return (Read(Line, StartColumn, data, Length, CONVMODE_INT32, Component)); }

      //! Read a line of raster cells up to a certain length, converting to unsigned 32 bit
      ERRVALUE 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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) const { return (Read(Line, StartColumn, data, Length, CONVMODE_INT32, Component)); }

      //! Read a line of raster cells up to a certain length, converting to 32 bit float
      ERRVALUE 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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) const { return (Read(Line, StartColumn, data, Length, CONVMODE_Float, Component)); }

      //! Read a line of raster cells up to a certain length, converting to 64 bit double
      ERRVALUE 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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) const { return (Read(Line, StartColumn, data, Length, CONVMODE_Double, Component)); }

      //! Read a column of raster cells up to a certain length
      ERRVALUE ReadColumn (
         INT32 Line,                         //!< Raster line to start reading on
         INT32 StartColumn,                     //!< Raster column to read
         void *data,                         //!< Buffer to read into
         INT32 Length = 1,                   //!< Number of lines to read
         CONVMODE Convert = CONVMODE_None,         //!< Data conversion mode
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) const;

      //! Read a column of raster cells up to a certain length, converting to signed 8 bit
      ERRVALUE ReadColumn (
         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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) const { return (ReadColumn(Line, StartColumn, data, Length, CONVMODE_INT8, Component)); }

      //! Read a column of raster cells up to a certain length, converting to unsigned 8 bit
      ERRVALUE ReadColumn (
         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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) const { return (ReadColumn(Line, StartColumn, data, Length, CONVMODE_INT8, Component)); }

      //! Read a column of raster cells up to a certain length, converting to signed 16 bit
      ERRVALUE ReadColumn (
         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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) const { return (ReadColumn(Line, StartColumn, data, Length, CONVMODE_INT16, Component)); }

      //! Read a column of raster cells up to a certain length, converting to unsigned 16 bit
      ERRVALUE ReadColumn (
         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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) const { return (ReadColumn(Line, StartColumn, data, Length, CONVMODE_INT16, Component)); }

      //! Read a column of raster cells up to a certain length, converting to signed 32 bit
      ERRVALUE ReadColumn (
         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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) const { return (ReadColumn(Line, StartColumn, data, Length, CONVMODE_INT32, Component)); }

      //! Read a column of raster cells up to a certain length, converting to unsigned 32 bit
      ERRVALUE ReadColumn (
         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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) const { return (ReadColumn(Line, StartColumn, data, Length, CONVMODE_INT32, Component)); }

      //! Read a column of raster cells up to a certain length, converting to 32 bit float
      ERRVALUE ReadColumn (
         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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) const { return (ReadColumn(Line, StartColumn, data, Length, CONVMODE_Float, Component)); }

      //! Read a column of raster cells up to a certain length, converting to 64 bit double
      ERRVALUE ReadColumn (
         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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) const { return (ReadColumn(Line, StartColumn, data, Length, CONVMODE_Double, Component)); }

      //! Set the raster scale value parameters
      ERRVALUE SetImageScale (
         const IMAGESCALE& scale                //!< Scale values to set in raster
         );

      //! Set the raster null value parameters
      ERRVALUE SetNullValue (
         const NULLVALUE& NullValue,               //!< Null value to set in raster
         bool NullUsed = true                      //!< Whether null value is used or not
         );

      //! Write a line of raster cells up to a certain length
      ERRVALUE Write (
         INT32 Line,                               //!< Raster line to write
         INT32 StartColumn,                        //!< Raster column to start writing on
         void *data,                               //!< Buffer to write from
         INT32 Length = 1,                         //!< Number of columns to write
         CONVMODE Convert = CONVMODE_None,         //!< Data conversion mode
         COMPONENT Component = COMPONENT_Default   //!< Component extraction value
         );

      //! Write a line of raster cells up to a certain length, converting from signed 8 bit
      ERRVALUE 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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) { return (Write(Line, StartColumn, data, Length, CONVMODE_INT8, Component)); }

      //! Write a line of raster cells up to a certain length, converting from unsigned 8 bit
      ERRVALUE 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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) { return (Write(Line, StartColumn, data, Length, CONVMODE_INT8, Component)); }

      //! Write a line of raster cells up to a certain length, converting from signed 16 bit
      ERRVALUE 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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) { return (Write(Line, StartColumn, data, Length, CONVMODE_INT16, Component)); }

      //! Write a line of raster cells up to a certain length, converting from unsigned 16 bit
      ERRVALUE 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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) { return (Write(Line, StartColumn, data, Length, CONVMODE_INT16, Component)); }

      //! Write a line of raster cells up to a certain length, converting from signed 32 bit
      ERRVALUE 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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) { return (Write(Line, StartColumn, data, Length, CONVMODE_INT32, Component)); }

      //! Write a line of raster cells up to a certain length, converting from unsigned 32 bit
      ERRVALUE 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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) { return (Write(Line, StartColumn, data, Length, CONVMODE_INT32, Component)); }

      //! Write a line of raster cells up to a certain length, converting from 32 bit float
      ERRVALUE 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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) { return (Write(Line, StartColumn, data, Length, CONVMODE_Float, Component)); }

      //! Write a line of raster cells up to a certain length, converting from 64 bit double
      ERRVALUE 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
         COMPONENT Component = COMPONENT_Default      //!< Component extraction value
         ) { return (Write(Line, StartColumn, data, Length, CONVMODE_Double, Component)); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      //! Implementation of RVC::OBJECT virtual methods
      virtual ERRVALUE v_CloseObject ();
      virtual RVC::OBJTYPE v_GetDftObjectType () const;
      virtual bool v_IsObjectOpen () const;
      virtual ERRVALUE v_OpenObject (OPENMODE OpenFlags, MDLGPARENT parent = 0);

      //! Implementation of RVC::GEOSPATIAL virtual methods
      virtual void v_GetExtents (DRECT3D &extents) const;
      virtual void v_GetScale (double& xscale, double& yscale) const;
      virtual double v_GetZScale () const;
      virtual double v_GetZOffset () const;
      virtual bool v_HasCapability (int Capability) const;
      virtual void v_SetScale (double xscale, double yscale);
      virtual void v_SetZOffset (double zoffset);
      virtual void v_SetZScale (double zscale);

      //! Implementation of RVC::IMAGE virtual methods
      virtual ERRVALUE v_GetBandParms (INT32 BandNum, BANDPARMS& BandParms) const;
      virtual double v_GetColumnScale () const;
      virtual double v_GetLineScale () const;
      virtual ERRVALUE v_GetNullValue (INT32 BandNum, NULLVALUE& NullValue) const;
      virtual INT32 v_GetNumBands () const;
      virtual INT32 v_GetNumColumns () const { return (m_MakeParms.GetNumColumns()); }
      virtual INT32 v_GetNumLines () const { return (m_MakeParms.GetNumLines()); }
      virtual bool v_HasNullValue (INT32 BandNum) const;
      virtual ERRVALUE v_ReadBand (INT32 Band, INT32 Line, INT32 StartColumn, void *data, INT32 Length, CONVMODE Convert) const;
      virtual ERRVALUE v_ReadColumnBand (INT32 Band, INT32 Line, INT32 StartColumn, void *data, INT32 Length, CONVMODE Convert) const;
      virtual ERRVALUE v_SetCacheSize (INT32 NumTiles);
      virtual ERRVALUE v_SetCacheSize (CACHEMODE CacheFlags);
      virtual ERRVALUE v_SetNullValue (INT32 BandNum, const NULLVALUE* NullValue);
      virtual ERRVALUE v_WriteBand (INT32 Band, INT32 Line, INT32 StartColumn, void *data, INT32 Length, CONVMODE Convert);

      void AssignValues (const RVCRASTINFO& rinfo);
      int ComputeNumPyramidLevels (PYRAMID flags);
      PYRAMID ValidatePyramidFlags (PYRAMID flags) const;

      //! Open raster handle, might change later
      RASTERHANDLE* m_RasterHandle;

      //! Unchangeable values, safe from multi-threading
      MAKEPARMS m_MakeParms;        //!< Raster creation parameters
      LINKTYPE m_LinkType;       //!< Raster Link Type, see enum
      INT32 m_XTiles;               //!< Number of XTiles in a raster
      INT32 m_YTiles;               //!< Number of YTiles in a raster
      INT32 m_TileSize;          //!< Size of raster tile in bytes

      friend class MAKEPARMS;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//! Convenience filter for raster selection.
//! This class provides for allowed and/or denied cell types to be specified during
//! construction, as well as whether all rasters in a multiple selection are
//! required to have the same dimensions.  Appropriate message IDs are set
//! based on the specified cell types.
class RASTER::GETOBJFILTER_ISSELECTABLE : public GETOBJFILTER {
   public:
   
      //! Constructor specifying allowed or denied cell types.
      GETOBJFILTER_ISSELECTABLE (
         RVC::IMAGE::CELLTYPE CellTypes,
         bool DenyTypes = false,
         bool NeedSameSize = false
         );

      virtual ~GETOBJFILTER_ISSELECTABLE () {}
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      IMAGE::CELLTYPE m_CellTypes;
      bool m_NeedSameSize;
   
      virtual bool v_IsSelectable (const RVC::OBJITEM& objitem, int position = -1);
      virtual bool v_IsValidList (const RVC::OBJITEMLIST& objlist);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//! Convenience filter for raster selection.
//! This class combines the RVC::RASTER::GETOBJFILTER_ISSELECTABLE and
//! RVC::GEOSPATIAL::GETOBJFILTER_ISOVERLAPPING filters
class RASTER::GETOBJFILTER_ISOVERLAPPING : public GETOBJFILTER {
   public:
   
      //! Constructor specifying allowed or denied cell types.
      GETOBJFILTER_ISOVERLAPPING (
         const RVC::OBJITEM& SrcObjItem,
         RVC::IMAGE::CELLTYPE CellTypes,
         bool DenyTypes = false,
         bool NeedSameSize = false
         );

      virtual ~GETOBJFILTER_ISOVERLAPPING () {}
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      RASTER::GETOBJFILTER_ISSELECTABLE m_IsSelectable;
      GEOSPATIAL::GETOBJFILTER_ISOVERLAPPING m_IsOverlapping;
   
      virtual bool v_IsSelectable (const RVC::OBJITEM& objitem, int position = -1);
      virtual bool v_IsValidList (const RVC::OBJITEMLIST& objlist);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//! Parmeters needed to link to external rasters      
class RASTER::LINKPARMS {
   protected:
   
      //! Constructor
      LINKPARMS (
         const FILEPATH& filename,           //!< File to link to
         RASTER::LINKTYPE LinkType,