rvcrast.h

Go to the documentation of this file.

/**
 * \file rvcrast.h <mi32/rvcrast.h>
 * \brief RVC Raster Definitions Header File
 *
 * \if NODOC
 * $Id: rvcrast.h_v 1.106 2004/09/07 13:57:23 mju Exp $
 *
 * $Log: rvcrast.h_v $
 * Revision 1.106  2004/09/07 13:57:23  mju
 * Another prototype removed.
 *
 * Revision 1.105  2004/09/07 13:51:39  mju
 * Remove unused prototype.
 *
 * Revision 1.104  2004/09/03 19:46:41  mju
 * Remove obsolete prototype.
 *
 * Revision 1.103  2004/09/02 15:51:30  mju
 * Move doThinRaster here.
 *
 * Revision 1.102  2004/07/15 19:28:43  mju
 * Use region2d for region computation functions.
 *
 * Revision 1.101  2004/07/14 19:52:01  scowan
 *  Removed lecagy compute region histogram function.
 *
 * Revision 1.100  2004/07/02 19:16:05  dwilliss
 * Prototypes for some new versions of functions that take REGION2D.
 *
 * Revision 1.99  2004/06/29 15:15:07  mju
 * Add histogram computation using region2d.
 *
 * Revision 1.98  2004/03/11 16:58:29  mju
 * Warn deprecated for legacy object selection dialogs.
 *
 * Revision 1.97  2004/03/10 17:20:56  mju
 * Remove dlgGetColorMap and dlgGetContrastTable.
 *
 * Revision 1.96  2004/02/16 21:07:05  scowan
 * Moved unused defined to private include file.
 *
 * Revision 1.95  2004/01/21 14:04:57  scowan
 * Moved raster set defines to own include file.
 *
 * Revision 1.94  2003/12/01 17:07:10  scowan
 * Removed legacy cache tile row flag.
 *
 * Revision 1.93  2003/11/21 20:33:34  mju
 * Change GetDftRastHist from macro to inline so has docs.
 *
 * Revision 1.92  2003/11/05 18:43:57  scowan
 * Added more conversion modes.
 *
 * Revision 1.91  2003/10/30 20:44:11  scowan
 * Removed unused function prototypes.
 *
 * Revision 1.90  2003/10/30 18:26:49  scowan
 * Added a flag.
 *
 * Revision 1.89  2003/10/23 22:53:26  scowan
 * Removed legacy get rast pyramid list.
 *
 * Revision 1.88  2003/10/20 20:45:21  scowan
 * Changed raster header member name.
 *
 * Revision 1.87  2003/10/15 17:39:28  mju
 * Deprecate groupkey.
 *
 * Revision 1.86  2003/09/26 19:55:54  scowan
 * Adjustment of include files.
 *
 * Revision 1.85  2003/09/26 16:17:46  scowan
 * Removed unuseg function prototypes and unnecessary header inclusion.
 *
 * Revision 1.84  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.83  2003/08/28 20:37:42  scowan
 * Removed  unused prototype.
 *
 * Revision 1.82  2003/08/28 19:33:53  scowan
 * Removed targa link function prototype.
 *
 * Revision 1.81  2003/08/28 16:50:04  scowan
 * Removed make link functions.
 *
 * Revision 1.80  2003/08/27 21:31:55  scowan
 * Added new data types and numbits and removed function prototypes.
 *
 * Revision 1.79  2003/08/08 21:23:35  mju
 * Remove unused prototype.
 *
 * Revision 1.78  2003/07/31 16:01:11  scowan
 * Compute raster by query parameter change.
 *
 * Revision 1.77  2003/07/24 22:02:38  mju
 * Change TIFF link parms.
 *
 * Revision 1.76  2003/07/11 14:22:41  scowan
 * Deprecated the raster mode dependant functions.
 *
 * Revision 1.75  2003/04/30 16:32:49  mju
 * Don't define MakeRastLink... prototypes on unsupported platforms.
 *
 * Revision 1.74  2002/10/02 16:13:43  mju
 * Add associate-with for surveyor.
 *
 * Revision 1.73  2002/09/09 13:57:25  mju
 * Always prevent_memfunc.
 *
 * Revision 1.72  2002/08/28 16:09:29  mju
 * Add SocetSetDT link support.
 *
 * Revision 1.71  2002/08/21 20:39:52  scowan
 * Deprecate old object name define.
 *
 * Revision 1.70  2002/08/19 19:29:11  mju
 * Add RastSetCacheRect.
 *
 * Revision 1.69  2002/08/15 15:58:44  mju
 * Remove obsolete fft functions.
 *
 * Revision 1.68  2002/05/30 15:51:07  mju
 * nc.
 *
 * Revision 1.67  2002/05/29 15:40:06  mju
 * nc.
 *
 * Revision 1.66  2002/04/29 16:05:26  mju
 * Remove mfrastercontrastmatching prototype as not used.
 *
 * Revision 1.65  2002/03/19 17:02:43  mju
 * Add LINKTYPE_JP2.
 *
 * Revision 1.64  2002/03/19 15:59:07  mju
 * Add RASTLINK_JP2.
 *
 * Revision 1.63  2002/03/08 18:28:35  scowan
 * Gave clear method to info structs.
 * deprecated mem... for info structs.
 *
 * Revision 1.62  2002/02/20 16:20:29  scowan
 * More const.
 *
 * Revision 1.61  2001/12/28 18:30:43  mju
 * Use const in MfGetRastNullAsDouble.
 *
 * Revision 1.60  2001/12/28 18:08:54  mju
 * Use const in ResampleRasterTransParm.
 *
 * Revision 1.59  2001/11/02 17:16:35  mju
 * Remove obsolete NullValid flag.
 *
 * Revision 1.58  2001/10/16 23:15:08  vdronov
 * added extra argument colormap to MfCopyRasterAveraged
 *
 * Revision 1.57  2001/10/16 21:30:03  vdronov
 * added MAKEPYRAMID_UseColorMap flag for averaging by color
 * rather than by value in 8 bits or 16 bits rasters
 *
 * Revision 1.56  2001/09/14 14:58:28  mju
 * No Mdlg in win32native.
 *
 * Revision 1.55  2001/06/22 22:22:58  mju
 * Remove specialized link flags, use MAKELINKFLAGS instead.
 *
 * Revision 1.54  2001/06/20 19:34:54  mju
 * Add MAKEPYRAMID_UseParentTileSize.
 *
 * Revision 1.53  2001/06/19 17:00:25  mju
 * Add ECW.
 *
 * Revision 1.51  2001/05/18 16:18:26  mju
 * Add MrSID linking.
 * Add MfCopyRasterRect().
 * Make some Mf...Rast functions inline instead of macros.
 *
 * Revision 1.50  2000/12/20 23:24:43  polson
 * added flag for mfcomputeviewshed
 *
 * \endif
**/

#ifndef INC_MI32_RVCRAST_H
#define INC_MI32_RVCRAST_H

#ifndef  INC_MI32_RVCDEFNS_H
   #include <mi32/rvcdefns.h>
#endif

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

#ifndef INC_MI32_TRANSGEN_H         // For TRANSFUNC definition
   #include <mi32/transgen.h>
#endif

struct COLMAPINFO;
struct TRANSPARM;

/*----------------------------------------------------------------------------*/
/*    Raster definitions                                                      */
/*----------------------------------------------------------------------------*/

struct RVCRASTINFO : public RVCGENLISTINFO {    //! Description of raster header
   DOUBLE linscale;                    //!< Line scale in units for given type
   DOUBLE colscale;                    //!< Column scale in units for given type
   DOUBLE datascale;                   //!< Scale factor for cell value
   DOUBLE dataoffset;                  //!< Offset for cell value
   ANYRASTVALUE nullvalue;
   INT32 numlins;                      //!< Number of lines in raster
   INT32 numcols;                      //!< Number of columns in raster
   INT32 TileLins;                     //!< Number of lines per tile
   INT32 TileCols;                     //!< Number of columns per tile
   UINT16 disktype;                    //!< Disk media type if separate file
   UINT16 m_UsedBits;                  //!< Number of bits actually used in the image, used for JP2 compression
   UINT16 flags;                       //!< Raster flags like inverted and compression
   UINT16 numbits;                     //!< Number of bits per cell, max = 256
   UINT32 datatype;                    //!< Raster data type
   UINT32 linktype;                    //!< Externally linked raster type
   UINT16 CompType;                    //!< Compression type
   UINT16 CompQuality;                 //!< Compression quality, 1-100, 0 == default
   INT32 Band;
   UINT16 Usage;                       //!< RASTUSAGE_..., Class, Average, PCA, Pyramid, ... */
   UINT16 Subusage;
   UINT8 spare[4];
   
   RVCRASTINFO (
      ) {Clear();}
   
   RVCRASTINFO (
      const RVCGENINFO& ginfo
      ) {Clear();*static_cast<RVCGENINFO*>(this) = ginfo;}
   
   RVCRASTINFO& operator= (
      const RVCGENINFO& ginfo
      ) {*static_cast<RVCGENINFO*>(this) = ginfo; return (*this);}

   void Clear (
      ) {memset(static_cast<void*>(this), 0, sizeof(*this));}
   
   };

//! External raster types for .linktype */
#define  RASTLINK_RVCInternal    0
#define  RASTLINK_SimpleArray    1
#define  RASTLINK_TIFF           2
#define  RASTLINK_Generic        3
#define  RASTLINK_MrSID          4
#define  RASTLINK_ECW            5
#define  RASTLINK_JP2            6
#define  RASTLINK_SocetSetDT     7
#define  RASTLINK_Last           7

//! Raster I/O and buffering mode flag bits
#define  RASTMODE_ModeMask          0xFF7F
#define  RASTMODE_ConvMask          0xFE7F
#define  RASTMODE_NoConversion      0x0000   //!< Don't perform any conversion on data
#define  RASTMODE_ConvToByteSpread  0x0001   //!< Convert < 8-bit to 8-bit by spreading over 0-255 range
#define  RASTMODE_ConvToWord        0x0002   //!< Convert binary to 16 bits/cell
#define  RASTMODE_ConvToLong        0x0004   //!< Convert binary to 32 bits/cell
#define  RASTMODE_ConvToByte        0x0008   //!< Convert 1/2/4 bits to 8-bit by copy
#define  RASTMODE_ConvToByteL       RASTMODE_ConvToByte  //!< Historical definition
#define  RASTMODE_ConvToDouble      0x0010   //!< Convert anything but RGB to doubles
#define  RASTMODE_ConvToYellow      0x0020   //!< Convert CMYK to Yellow
#define  RASTMODE_ConvToMagenta     0x0040   //!< Convert CMYK to Magenta
#define  RASTMODE_ConvToFloat       0x0200   //!< Convert anything but RGB to floats
#define  RASTMODE_ConvToCyan        0x0400   //!< Convert CMYK to Cyan
#define  RASTMODE_ConvToRed         0x0800   //!< Convert RGB to Red
#define  RASTMODE_ConvToAlpha       0x1000   //!< Convert RGBA or ARGB to Alpha
#define  RASTMODE_ConvToGreen       0x2000   //!< Convert RGB to Green
#define  RASTMODE_ConvToBlue        0x4000   //!< Convert RGB to Blue
#define  RASTMODE_ConvToBlack       0x8000   //!< Convert CMYK to Black
#define  RASTMODE_ConvToRGB         0x10000  //!< Convert BGR to RGB
#define  RASTMODE_ConvToBGR         0x20000  //!< Convert RGB to BGR

#define  RASTMODE_OpenMask          0x0080
#define  RASTMODE_UseAltTile        0x0080   //!< Programmer will specify tile size OR set tile to raster size

//! Raster flag bits
#define  RASTER_Inverted         0x0001   //!< Raster is inverted top to bottom
#define  RASTER_HasNullVal       0x0002   //!< raster has a null value set
#define  RASTER_PackLSB          0x0004   //!< Pack cell bit(s) starting with the least sig. bits default is most sig. bits first
#define  RASTER_Compressed       0x0010   //!< Raster is compressed
#define  RASTER_LossyComp        0x0020   //!< Raster is using lossy compression
//Other RASTER_ flag defines are now private, use RVC::RASTER

//! MfRastSetCacheSize() flags
#define  RASTCACHE_DiagonalRow   0x0001
#define  RASTCACHE_TileRow       0x0002
#define  RASTCACHE_NumTiles      0x0004

//! Raster compression types, only used if RASTER_Compressed is set
#define  RASTCOMP_RLE_DPCM       0
#define  RASTCOMP_JPEG           1     //!< Sets RASTER_LossyComp flag, for 8 and 24 bit only
#define  RASTCOMP_Huffman        2
#define  RASTCOMP_DPCM_NEW       3
//#define RASTCOMP_JP2 is defined elsewhere
#define  RASTCOMP_MAX            4     //!< Maximum compression value

//! Raster .Usage types
#define  RASTUSAGE_Default       0     //!< Ordinary raster
#define  RASTUSAGE_Pyramid       4     //!< Pyramid raster
//Other RASTUSAGE defines are now private, use RVC::RASTER

/*-------------------------------------------------------------------------*/
/*    Raster-related object header definitions                             */
/*-------------------------------------------------------------------------*/

struct RVC2DHISTINFO : public RVCGENINFO {   //! Description of 2-D histogram header
   UINT16 EntryScale;                  //!< Scale for array entries (default = 1)
   UINT8 dummy[6];
   RVC::OBJECTNAME xrastname;             //!< Name of raster displayed on X-axis
   RVC::OBJECTNAME yrastname;             //!< Name of raster displayed on Y-axis
   DOUBLE xdatainit;                   //!< Initial data value for histogram range
   DOUBLE xdatalast;                   //!< Final data value in histogram range
   DOUBLE xdatasample;                 //!< Sampling rate for data range
   DOUBLE ydatainit;                   //!< Initial data value for histogram range
   DOUBLE ydatalast;                   //!< Final data value in histogram range
   DOUBLE ydatasample;                 //!< Sampling rate for data range
   DOUBLE correlation;                 //!< Statistical correlation between rasters
   DOUBLE regx0;                       //!< Points for regression equation
   DOUBLE regy0;
   DOUBLE regx1;
   DOUBLE regy1;
   
   RVC2DHISTINFO (
      ) {Clear();}
   
   RVC2DHISTINFO (
      const RVCGENINFO& ginfo
      ) {Clear();*static_cast<RVCGENINFO*>(this) = ginfo;}
   
   RVC2DHISTINFO& operator= (
      const RVCGENINFO& ginfo
      ) {*static_cast<RVCGENINFO*>(this) = ginfo; return (*this);}

   void Clear (
      ) {memset(static_cast<void*>(this), 0, sizeof(*this));}
   
   };

struct RVCCMAPINFO : public RVCGENINFO {  //! Description of pseudo-color table header
   UINT16 numcolors;                   //!< Number of colors defined in this table
   UINT16 optcolors;                   //!< Number of colors used for optimization
   UINT16 usedcolors;                  //!< Number of colors used after optimization
   UINT16 redbits;                     //!< Number of significant bits for red
   UINT16 grnbits;                     //!< Number of significant bits for green
   UINT16 blubits;                     //!< Number of significant bits for blue
   INT32 offset;                       //!< Offset for 16 bit color maps
   
   RVCCMAPINFO (
      ) {Clear();}
   
   RVCCMAPINFO (
      const RVCGENINFO& ginfo
      ) {Clear();*static_cast<RVCGENINFO*>(this) = ginfo;}
   
   RVCCMAPINFO& operator= (
      const RVCGENINFO& ginfo
      ) {*static_cast<RVCGENINFO*>(this) = ginfo; return (*this);}

   void Clear (
      ) {memset(static_cast<void*>(this), 0, sizeof(*this));}
   
   };

struct RVCHISTINFO : public RVCARRAYINFO {   //! Histogram information header
   DOUBLE minvalue;                    //!< Minimum value in area for histogram
   DOUBLE maxvalue;                    //!< Maximum value in area for histogram
   DOUBLE datainit;                    //!< Initial data value for histogram range
   DOUBLE datalast;                    //!< Final data value in histogram range
   DOUBLE datasample;                  //!< Sampling rate for data range
   DOUBLE mean;                        //!< Mean value within selected data range
   DOUBLE meanfull;                    //!< Mean value for entire data range
   DOUBLE stddev;                      //!< Standard Deviation within selected data range
   DOUBLE sum;                         //!< Sum of values
   DOUBLE sum2;                        //!< Sum of squares of values
   INT32 initlin;                      //!< Initial line of window
   INT32 lastlin;                      //!< Final line of window
   INT32 initcol;                      //!< Initial column of window
   INT32 lastcol;                      //!< Final column of window
   UINT32 countltmin;                  //!< Number of cells with values less than datainit
   UINT32 countgtmax;                  //!< Number of cells with values greater than datalast
   UINT16 linsamp;                     //!< Line sampling rate
   UINT16 colsamp;                     //!< Column sampling rate
   UINT16 EntryScale;                  //!< Scale for array entries (default = 1)
   UINT16 histflags;                   //!< HasMean and HasStdDev
   UINT32 countnull;                   //!< Number of NULL cells in the raster
   UINT8 spare[4];
   
   RVCHISTINFO (
      ) {Clear();}
   
   RVCHISTINFO (
      const RVCGENINFO& ginfo
      ) {Clear();*static_cast<RVCGENINFO*>(this) = ginfo;}
   
   RVCHISTINFO& operator= (
      const RVCGENINFO& ginfo
      ) {*static_cast<RVCGENINFO*>(this) = ginfo; return (*this);}

   void Clear (
      ) {memset(static_cast<void*>(this), 0, sizeof(*this));}
   
   };

#define RVCHIST_HasMean       0x0001
#define RVCHIST_HasStdDev     0x0002

#define RVCHIST_ComplexMask   0x000C
#define RVCHIST_ComplexM      0x0000   //!< Histogram of magnitude component
#define RVCHIST_ComplexP      0x0004   //!< Histogram of phase component
#define RVCHIST_ComplexR      0x0008   //!< Histogram of real component
#define RVCHIST_ComplexI      0x000C   //!< Histogram of imaginary component

#define RVCHIST_ColorMask     0x000C
#define RVCHIST_ColorRed      0x0000   //!< Histogram of red component
#define RVCHIST_ColorGreen    0x0004   //!< Histogram of green component
#define RVCHIST_ColorBlue     0x0008   //!< Histogram of blue component

struct RVCCONTINFO : public RVCARRAYINFO {   //! Contrasting table information header
   DOUBLE dinplowlim;                  //!< Lower input limit for stretch
   DOUBLE dinpuprlim;                  //!< Upper input limit for stretch
   DOUBLE power;                       //!< Power for log/exp (replaces interpi/o)
   UINT16 type;                        //!< Contrast table type
   UINT16 contflags;                   //!< RVCCONT_xxx flags defined below
   INT16 outlowlim, outuprlim;         //!< Lower and upper output limits
   INT16 mean, stdevl, stdevr;         //!< Output mean and st devs for normalization
   INT16 outltminval;                  //!< Output value if input < dinplowlim (>8 bit only)
   INT16 outgtmaxval;                  //!< Output value if input > dinpuprlin (>8 bit only)
   INT16 outnullval;                   //!< Value to output if input = nullvalue && HasNullVal is set
   UINT8 spare[4];                     //!< dword align the size of the structure
   DOUBLE datainit;
   DOUBLE datalast;
   DOUBLE datasample;
   
   RVCCONTINFO (
      ) {Clear();}
   
   RVCCONTINFO (
      const RVCGENINFO& ginfo
      ) {Clear();*static_cast<RVCGENINFO*>(this) = ginfo;}
   
   RVCCONTINFO& operator= (
      const RVCGENINFO& ginfo
      ) {*static_cast<RVCGENINFO*>(this) = ginfo; return (*this);}

   void Clear (
      ) {memset(static_cast<void*>(this), 0, sizeof(*this));}
   
   };

#define  RVCCONT_Inverted     1

//! Disallow memset/memcpy.
PREVENT_MEMFUNC(RVCRASTINFO)
PREVENT_MEMFUNC(RVC2DHISTINFO)
PREVENT_MEMFUNC(RVCCMAPINFO)
PREVENT_MEMFUNC(RVCHISTINFO)
PREVENT_MEMFUNC(RVCCONTINFO)

/*----------------------------------------------------------------------------*/
/*    Definitions for generic raster I/O                                      */
/*----------------------------------------------------------------------------*/

typedef int RASTREADFUNC (INT32, INT32, INT32, void*, UINT8*, int*, void*);
typedef int RASTWRITEFUNC (INT32, INT32, INT32, void*, UINT8*, int, void*);

#define  MASKFLAG_Mixed       0
#define  MASKFLAG_AllValid    1
#define  MASKFLAG_AllNull     2

/*-------------------------------------------------------------------------*/
/*    Flags for MfMakeRastPyramidSetExt()                                  */
/*-------------------------------------------------------------------------*/

#define  MAKEPYRAMID_Rebuild           0x01  //!< Rebuild tiers even if exist
#define  MAKEPYRAMID_Average           0x02  //!< Average raster cells instead of sampling
#define  MAKEPYRAMID_Full              0x04  //!< Create "full" pyramid set (always 2x2 sample steps)
#define  MAKEPYRAMID_UseParentTileSize 0x08  //!< Use parent raster's tile size.
#define  MAKEPYRAMID_UseColorMap       0x10  //!< Use colormap for averaging

/*----------------------------------------------------------------------------*/
/*    Flags for MfChangeRasterNull()                                          */
/*----------------------------------------------------------------------------*/

#define  CHGRASTNULL_LeaveAlone  0
#define  CHGRASTNULL_Increase    1
#define  CHGRASTNULL_Decrease    2

/*-------------------------------------------------------------------------*/
/*    Definitions for Resample functions                                   */
/*-------------------------------------------------------------------------*/

#define  RESAMPLE_Nearest     0        //!< Nearest-neighbor
#define  RESAMPLE_Bilinear    1        //!< Bilinear interpolation
#define  RESAMPLE_CubicConv   2        //!< Cubic convolution

/*----------------------------------------------------------------------------*/
/*    Flags for MfThresholdRaster()                                           */
/*----------------------------------------------------------------------------*/

#define  THRESHRAST_Output1Below    0x0001
#define  THRESHRAST_Output1Outside  0x0001
#define  THRESHRAST_Output1Null     0x0002
#define  THRESHRAST_NoPyramid       0x0004

/*----------------------------------------------------------------------------*/
/*    Flags for MfComputeRasterProperties()                                            */
/*----------------------------------------------------------------------------*/

#define  BOUNDCELLS_IncludeAll            1
#define  BOUNDCELLS_IncludeLargest        2
#define  BOUNDCELLS_Proportionally        3
#define  BOUNDCELLS_ExcludeAll            4


#define  RASTPROP_ComputeHisto         0x0001
#define  RASTPROP_IncludeIslands       0x0002


/*----------------------------------------------------------------------------*/
/*    Structure used by MfComputeRasterSlantToGround()                           */
/*----------------------------------------------------------------------------*/

struct SLANTGROUNDPARMS {
   DOUBLE surf_elevation;              //!< surface elevation above sea level,(meters)
   DOUBLE altitude;                    //!< aircraft altitude above sea level,(meters)
   DOUBLE slant_spacing;               //!< resolution across radar track,(meters)
   DOUBLE azimuth_spacing;             //!< resolution along radar track,(meters)
   DOUBLE nearlook_angle;              //!< nadir angle to near side (rad)
   DOUBLE farlook_angle;               //!< nadir angle to far side (rad)
   };

/*----------------------------------------------------------------------------*/
/*    Flags for MfComputeClumpRaster() & MfComputeSieveRaster()               */
/*----------------------------------------------------------------------------*/

#define  CLUMPRAST_Larger     0x0001   //!< locate features larger than user-specified size
#define  CLUMPRAST_Smaller    0x0002   //!< locate features smaller than user-specified size

#define  CLUMPRAST_FillHoles  0x0008   //!< Fill holes in the "sieve" raster

/*----------------------------------------------------------------------------*/
/*    Flags for MfComputeViewshed()                                           */
/*----------------------------------------------------------------------------*/

#define  VIEWSHED_EarthCurvature          0x0001
#define  VIEWSHED_InvertTransparency      0x0002

/*-------------------------------------------------------------------------*/
/*    Definitions for ContrastEnhanceWallis                                */
/*-------------------------------------------------------------------------*/

#define WALLISFLAG_NullValue 0x0001
#define WALLISFLAG_Alpha     0x0002
#define WALLISFLAG_Mean      0x0004
#define WALLISFLAG_StDev     0x0008
#define WALLISFLAG_Gain      0x0010

#define WALLISCONV_NONE      0
#define WALLISCONV_RATIO     1
#define WALLISCONV_HIS       2

#define BCETFLAG_NullValue 0x0001

#define BCETFUNCTION_Start          0
#define BCETFUNCTION_Parabolic      0
#define BCETFUNCTION_Cubic          1
#define BCETFUNCTION_Count          2

/*-------------------------------------------------------------------------*/
/*    Definitions for MfRasterClassification                               */
/*-------------------------------------------------------------------------*/

#define CLM_K_means              1
#define CLM_FC_means             2
#define CLM_MinDistAngle         3
#define CLM_Isodata              4
#define CLM_SelfOrganization     5
#define CLM_AdaptiveResonance    6
#define CLM_MinDistToMean        7
#define CLM_MaximumLikelihood    8
#define CLM_StepwiseLinear       9
#define CLM_Suits               10

struct CL_KMEANSPARM {
   UINT16 NumClasses;
   UINT16 MaxIterations;
   double InitMinDist;
   double MaxMoveSteady;
   double MinSteadyPct;
   };
   
struct CL_FCMEANSPARM {
   UINT16 NumClasses;
   UINT16 MaxIterations;
   };

struct CL_MDANGLEPARM {
   UINT16 NumClasses;
   UINT16 MaxIterations;
   double MaxMoveSteady;
   double MinSteadyPct;
   };

struct CL_SELFORGPARM {
   UINT16 NumClasses;
   UINT16 MaxIterations;
   double InitMinDist;
   double MaxMoveSteady;
   double MinSteadyPct;
   };

struct CL_ADRESPARM {
   UINT16 NumClasses;
   UINT16 MaxIterations;
   double InitMinDist;
   };

struct CL_ISODATAPARM {
   UINT16 NumClasses;
   UINT16 MaxIterations;
   double SplitMaxStdDev;
   double CombMinDist;
   double ChainMinDist;
   INT32 MinClusterCells;
   };

struct CL_TOMEANPARM {
   FNAMEINODEUC *train;
   int DistMethod;
   };

struct CL_MAXLIKEPARM {
   FNAMEINODEUC *train;
   double MinLikelihoodPct;
   };

struct CL_STEPLINPARM {
   FNAMEINODEUC *train;
   };

struct CL_SUITSPARM {
   FNAMEINODEUC *train;
   double NumDevs;
   };

struct CLASSIFYPARM {
   UINT32 method;
   CL_KMEANSPARM  kmparm;
   CL_FCMEANSPARM fmparm;
   CL_MDANGLEPARM maparm;
   CL_SELFORGPARM soparm;
   CL_ADRESPARM   arparm;
   CL_ISODATAPARM idparm;
   CL_TOMEANPARM  tmparm;
   CL_MAXLIKEPARM mlparm;
   CL_STEPLINPARM slparm;
   CL_SUITSPARM   suparm;
   };

struct RASTLINKDATAGEN {
   //! DO NOT CHANGE THE SIZE OF THIS STRUCTURE as it is stored in the RVC file
   INT32 headerbytes;         //!<  Length of file header in bytes (to start of first line) 
   INT32 linetbytes;          //!<  Length of line trailer in bytes 
   INT32 bandtbytes;          //!<  Length of band trailer in bytes 
   INT32 intertbytes;            //!<  Interleave trailer in bytes (between lines of same band) 
   INT32 numbands;               //!<  Number of bands, needed if interleaved 
   INT16 inttype;             //!<  Interleave type: INTERLEAVE_XXX 
   INT16 intfact;             //!<  Interleave factor 
   INT16 intadd;              //!<  Value to add to line/column before using interleave factor 
   INT16 byteorder;           //!<  Byte/bit order: RASTLINK_LoHi or RASTLINK_HiLo 
   UINT8 reserved[36];        //!<  Reserved for future use, pad to 64 bytes 
   //! DO NOT CHANGE THE SIZE OF THIS STRUCTURE as it is stored in the RVC file
   };

#define  INTERLEAVE_None      0  //!<  No interleaving, all data for one band is together 
#define  INTERLEAVE_Line      1  //!<  Band interleaved by line 
#define  INTERLEAVE_Pixel     2  //!<  Band interleaved by pixel 

/*-------------------------------------------------------------------------*/
/*    Definitions for MfCombineRastersLinear                               */
/*-------------------------------------------------------------------------*/

struct LINEARTRANS {
   DOUBLE *offset;                     //!< list of offsets of linear combination
   DOUBLE *coeff;                      //!< matrix of coefficients of linear combination
   INT16 idim;                         //!< number of input raster objects
   INT16 odim;                         //!< number of output raster objects
   };

//!\addtogroup RvcRast RVC Raster Functions
//!@{

// Object selection dialogs
#if (defined(X_NATIVE) || defined(WIN32_MFC)) && !defined(DEPRECATE_GROUPKEY)

//! Get raster object.
DEPRECATED inline int MdlgGetRasterObject (
   MDLGPARENT dlgparent,
   FILEPATH& filename,
   INT32 *inode,
   const void *prompt,
   RVCRASTINFO *objinfo,
   MfFiltFuncProto filter=0,
   void *filtuserdata=0,
   GETOBJFLAGS flags=GETOBJFLAG_None
   ) {
   return (MdlgGetObject(dlgparent,filename,inode,prompt,OTYPE_RASTER,RVCCONV_RASTER,objinfo,sizeof(RVCRASTINFO),filter,filtuserdata,flags));
   }

//! Get raster object.
DEPRECATED inline int MdlgGetRasterObject (
   MDLGPARENT dlgparent,
   UNICODE *filename,
   INT32 *inode,
   const void *prompt,
   RVCRASTINFO *objinfo,
   MfFiltFuncProto filter=0,
   void *filtuserdata=0,
   GETOBJFLAGS flags=GETOBJFLAG_None
   ) {
   return (MdlgGetObject(dlgparent,filename,inode,prompt,OTYPE_RASTER,RVCCONV_RASTER,objinfo,sizeof(RVCRASTINFO),filter,filtuserdata,flags));
   }

//! Get multiple raster objects.
DEPRECATED inline int MdlgGetRasterObjects (
   MDLGPARENT dlgparent,
   FILEPATH& filename,                 //!< Default filename
   const void *prompt,
   int minobjs,                        //!< Minimum number of objects required
   int maxobjs,                        //!< Maximum allowed to be selected, 0 if no limit
   RVCOBJITEMLIST& ItemList,
   MfFiltFuncProto filter=0,
   void *filtuserdata=0,
   MfValidListProto validfunc=0,
   GETOBJFLAGS flags=GETOBJFLAG_None
   ) {
   return (MdlgGetObjects(dlgparent,filename,0,prompt,OTYPE_RASTER,minobjs,maxobjs,ItemList,filter,filtuserdata,validfunc,flags));
   }

//! Get multiple raster objects.
DEPRECATED inline int MdlgGetRasterObjects (
   MDLGPARENT dlgparent,
   UNICODE *filename,                  //!< Default filename
   const void *prompt,
   int minobjs,                        //!< Minimum number of objects required
   int maxobjs,                        //!< Maximum allowed to be selected, 0 if no limit
   FNAMEINODEUC **fnameinoderet,
   MfFiltFuncProto filter=0,
   void *filtuserdata=0,
   MfValidMultiProto validfunc=0,
   GETOBJFLAGS flags=GETOBJFLAG_None
   ) {
   return (MdlgGetObjects(dlgparent,filename,0,prompt,OTYPE_RASTER,minobjs,maxobjs,fnameinoderet,filter,filtuserdata,validfunc,flags));
   }

//! Pop-up dialog to prompt user to select raster object set.
DEPRECATED inline int MdlgGetRasterObjectSet (
   MDLGPARENT dlgparent,
   FILEPATH& filename,                 //!< Default filename
   const void *prompt,
   int numobjs,                        //!< Number of objects to be selected
   RVCOBJITEMLIST& ItemList,
   void *objlabel[],                   //! Label names for each object
   MfFiltFuncProto filter=0,
   void *filtuserdata=0,
   MfValidListProto validfunc=0,
   GETOBJFLAGS flags=GETOBJFLAG_None
   ) {
   return (MdlgGetObjectSet(dlgparent,filename,0,prompt,OTYPE_RASTER,numobjs,ItemList,objlabel,filter,filtuserdata,validfunc,flags));
   }

//! Pop-up dialog to prompt user to select raster object set.
DEPRECATED inline int MdlgGetRasterObjectSet (
   MDLGPARENT dlgparent,
   UNICODE *filename,                  //!< Default filename
   const void *prompt,
   int numobjs,                        //!< Number of objects to be selected
   FNAMEINODEUC fnameinode[],
   void *objlabel[],                   //! Label names for each object
   MfFiltFuncProto filter=0,
   void *filtuserdata=0,
   MfValidMultiProto validfunc=0,
   GETOBJFLAGS flags=GETOBJFLAG_None
   ) {
   return (MdlgGetObjectSet(dlgparent,filename,0,prompt,OTYPE_RASTER,sizeof(RVCRASTINFO),numobjs,fnameinode,objlabel,filter,filtuserdata,validfunc,flags));
   }

#endif   //!< X_NATIVE || WIN32_MFC


#if defined(__cplusplus)
extern "C" {
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
RVCAPPLIBEXPORT int     _Mf2DHistRead (int fhandle, INT32 objinode, RVC2DHISTINFO*, int);
RVCAPPLIBEXPORT int     _Mf2DHistWrite (int fhandle, INT32 objinode, RVC2DHISTINFO*, int);

RVCAPPLIBEXPORT int     _MfColorMapRead (int fhandle, INT32 cmapinode, RVCCMAPINFO*, int, COLMAPINFO*, int);
RVCAPPLIBEXPORT int     _MfColorMapWrite (int fhandle, INT32 cmapinode, RVCCMAPINFO*, int, COLMAPINFO*, int);

RVCAPPLIBEXPORT int     _MfHistogramCompute (int fhandle, INT32 rastinode, RVCHISTINFO *histinfo, int HeaderSize, UINT32 **phisto);
RVCAPPLIBEXPORT int     _MfHistogramComputeRegion2D (int fhandle, INT32 rastinode, const REGION2D& region, RVCHISTINFO *info, int HeaderSize, UINT32 **phisto);
RVCAPPLIBEXPORT int     _MfHistogramGetDefault (int fhandle, INT32 rastinode, RVCHISTINFO *histinfo, int HeaderSize, UINT32 **phisto, int complexcomp);
RVCAPPLIBEXPORT int     _MfHistogramRead (int fhandle, INT32 histinode, RVCHISTINFO*, int, UINT32**);
RVCAPPLIBEXPORT int     _MfHistogramWrite (int fhandle, INT32 histinode, RVCHISTINFO*, int, UINT32*);

RVCAPPLIBEXPORT int     _MfRasterClose (int, RVCRASTINFO*, int);
RVCAPPLIBEXPORT int     _MfRasterHeaderRead (int findex, INT32 inode, RVCRASTINFO *info, int HeaderSize);
RVCAPPLIBEXPORT int     _MfRasterHeaderWrite (int findex, INT32 inode, RVCRASTINFO *info, int HeaderSize);
RVCAPPLIBEXPORT int     _MfRasterMake (int, RVCRASTINFO*, int, UINT32);
RVCAPPLIBEXPORT int     _MfRasterMakeInitVal (int, RVCRASTINFO*, int, const ANYRASTVALUE*, UINT32);
RVCAPPLIBEXPORT int     _MfRasterOpen (int, INT32, RVCRASTINFO*, int, UINT32);
#endif //!< GENERATING_DOXYGEN_OUTPUT

#define  MfReadColmapHeader(f,i,h)        _MfReadHeader((f),(i),(h),sizeof(RVCCMAPINFO),RVCCONV_COLMAP)
#define  MfReadColorMap(_f,_c,_i,_d)      _MfColorMapRead((_f),(_c),(_i),sizeof(RVCCMAPINFO),(_d),sizeof(COLMAPINFO))
#define  MfWriteColorMap(_f,_c,_i,_d)     _MfColorMapWrite((_f),(_c),(_i),sizeof(RVCCMAPINFO),(_d),sizeof(COLMAPINFO))
#define  MfReadContabHeader(f,i,h)        _MfReadHeader((f),(i),(h),sizeof(RVCCONTINFO),RVCCONV_CONTAB)
#define  MfReadHistoHeader(f,i,h)         _MfReadHeader((f),(i),(h),sizeof(RVCHISTINFO),RVCCONV_HISTO)

//! Close previously opened raster.
inline ERRVALUE MfCloseRast (
   int rhandle,                           //!< Raster object handle
   RVCRASTINFO *info = 0                  //!< Raster header
   ) { return (_MfRasterClose(rhandle,info,sizeof(RVCRASTINFO))); }

//! Create new raster.
//! @return Open raster handle.
inline int MfMakeRast (
   int fhandle,
   RVCRASTINFO *rastinfo,
   UINT32 flags = 0
   ) { return (_MfRasterMake(fhandle,rastinfo,sizeof(RVCRASTINFO),flags)); }

//! Create new raster with initial value.
//! @return Open raster handle.
inline int MfMakeRastI (
   int fhandle,
   RVCRASTINFO *rastinfo,
   const ANYRASTVALUE *value,
   UINT32 flags = 0
   ) { return (_MfRasterMakeInitVal(fhandle,rastinfo,sizeof(RVCRASTINFO),value,flags)); }

//! Open raster object for read or write.
inline int MfOpenRast (
   int fhandle,
   RVCINODENUM rastinode,
   RVCRASTINFO *rastinfo,
   UINT32 flags = 0
   ) { return (_MfRasterOpen(fhandle,rastinode,rastinfo,sizeof(RVCRASTINFO),flags)); }

//! Read header for specified raster.
inline ERRVALUE MfReadRastHeader (
   int fhandle,
   RVCINODENUM rastinode,
   RVCRASTINFO *rastinfo
   ) { return (_MfRasterHeaderRead(fhandle,rastinode,rastinfo,sizeof(RVCRASTINFO))); }

#define  MfWriteRastHeader(_fi,_in,_info)                _MfRasterHeaderWrite((_fi),(_in),(_info),sizeof(RVCRASTINFO))

#define  MfComputeRastHist(_f,_roi,_info,_ph)            _MfHistogramCompute((_f),(_roi),(_info),sizeof(RVCHISTINFO),(_ph))

#if defined(__cplusplus)
}  // End extern C
#endif

inline ERRVALUE MfComputeRastHistRegion (
   int fhandle,
   RVCINODENUM rastinode,
   const REGION2D& region,
   RVCHISTINFO *histinfo,
   UINT32 **phisto
   ) { return (_MfHistogramComputeRegion2D(fhandle,rastinode,region,histinfo,sizeof(RVCHISTINFO),phisto)); }

#if defined(__cplusplus)
extern "C" {
#endif

//! Get default raster histogram.
inline ERRVALUE MfGetDftRastHist (
   int fhandle,                        //!< File handle
   RVCINODENUM rastinode,              //!< Raster inode
   RVCHISTINFO *histinfo,              //!< Histogram info returned
   UINT32 **phisto,                    //!< Histogram returned
   int complexcomp = 0,                //!< Complex raster component
   void *sdw = 0                       //!< Unused
   ) { return (_MfHistogramGetDefault(fhandle,rastinode,histinfo,sizeof(RVCHISTINFO),phisto,complexcomp)); }

#define  MfReadHistogram(_f,_c,_i,_d)                    _MfHistogramRead((_f),(_c),(_i),sizeof(RVCHISTINFO),(_d))
#define  MfWriteHistogram(_f,_c,_i,_d)                   _MfHistogramWrite((_f),(_c),(_i),sizeof(RVCHISTINFO),(_d))

#define  Mf2DHistWrite(_f,_c,_i)             _Mf2DHistWrite((_f),(_c),(_i),sizeof(RVCHISTINFO))

//! Get the default tile size for any raster.
//!
//! @return Size of one of the sides of the tile (Note: tiles are square).
RVCAPPLIBEXPORT int MfGetDftTileSize (
   int numbits                         //!< Number of bits in the raster
   );

//! Copy min/max extremes for a cell into ANYRASTVALUE structures.
//!
//! This function falls into the realm of MfSetDftNullVal() and MfSetRastNullValue.
RVCAPPLIBEXPORT void MfGetRasterValueMinMax (
   RVCRASTINFO *info,                  //!< Information about the raster
   ANYRASTVALUE *min,                  //!< Minimum cell value for datatype and depth
   ANYRASTVALUE *max                   //!< Maximum cell value for datatype and depth
   );

//! Obtain information about the sizes of tiles.
RVCAPPLIBEXPORT int MfGetRastTileInfo (int, INT32*, INT32*, INT32*, INT32*, INT32*);

//! 
RVCAPPLIBEXPORT int MfGetRastTileSize (RVCRASTINFO *info);

//! Create default histogram for a raster.
RVCAPPLIBEXPORT int MfMakeDftRastHist (
   int fhandle,                        //!< Handle for open RVC file
   INT32 rastinode,                    //!< Inode of raster object
   void *notused = 0                   //!< OBSOLETE (will use default handle)
   );

//! Get NUMTYPE value for raster datatype/numbits combination.
//!
//! @return NUMTYPE value or R_BadRastType.
//!
//!   See <mi32/stddefns.h> for a list of NUMTYPE values.
RVCAPPLIBEXPORT int MfRastGetNumType (
   RVCRASTINFO *rastinfo               //!< Raster header
   );

//! Set rectangle to cache.
RVCAPPLIBEXPORT int MfRastSetCacheRect (
   int id, 
   const LRECT2D& cacherect
   );

//! Set size of raster cache.
//!
//! Flags:     
//!      \li\b RASTCACHE_DiagonalRow   Cache a diagonal row of tiles, num ignored
//!      \li\b RASTCACHE_TileRow       Cache a row of tiles, num ignored
//!      \li\b RASTCACHE_NumTiles      Cache a number of tiles, num is number of tiles
//!      0                       Cache number of tiles that fit into 'num' Kbytes, num is KBytes.
RVCAPPLIBEXPORT int MfRastSetCacheSize (
   int id, 
   INT32 num, 
   UINT32 flags
   );

//! 
RVCAPPLIBEXPORT int MfReadRastCol (int id, INT32 lin, INT32 col, INT32 len, void *buff, UINT32 iomode);

//! Read data from a raster object with conversion.
//!
//! Raster modes:    
//!      \li\b RASTMODE_ConvToByteSpread  Convert 1/2/4 bits to 8-bit by stretch
//!      \li\b RASTMODE_ConvToByte        Convert 1/2/4 bits to 8-bit by copy
//!      \li\b RASTMODE_ConvToWord        Convert to 16 bits/cell
//!      \li\b RASTMODE_ConvToLong        Convert to 32 bits/cell
//!      \li\b RASTMODE_ConvToFloat       Convert anything but RGB to floats
//!      \li\b RASTMODE_ConvToDouble      Convert anything but RGB to doubles
RVCAPPLIBEXPORT int MfReadRastConv (
   int handle,                         //!< Open raster handle
   INT32 lin,                          //!< Raster line
   INT32 col,                          //!< Raster column
   INT32 len,                          //!< Number of cells to read
   void *data,                         //!< Pointer to buffer to read into
   UINT32 mode                         //!< Conversion method, 0 for no conversion
   );

//! Set the default NULL value in the raster header.
//!
//! This will also set the RASTER_HasNullVal flag.
RVCAPPLIBEXPORT void MfSetDftNullVal (
   RVCRASTINFO *info                   //!< Raster header to set default NULL value for
   );

//! Set NULL value for raster object from "double".
//!
//! This will also set the RASTER_HasNullVal flag.
RVCAPPLIBEXPORT void MfSetRastNullValueDouble (
   RVCRASTINFO *info,                  //!< Raster header to set dft NULL value
   double nullvalue                    //!< Null value to set
   );

//! Write data to a raster object with conversion.
//!
//! Raster modes:    
//!      \li\b RASTMODE_ConvToByteSpread  Convert 1/2/4 bits to 8-bit by stretch
//!      \li\b RASTMODE_ConvToByte        Convert 1/2/4 bits to 8-bit by copy
//!      \li\b RASTMODE_ConvToWord        Convert to 16 bits/cell
//!      \li\b RASTMODE_ConvToLong        Convert to 32 bits/cell
//!      \li\b RASTMODE_ConvToFloat       Convert anything but RGB to floats
//!      \li\b RASTMODE_ConvToDouble      Convert anything but RGB to doubles
RVCAPPLIBEXPORT int MfWriteRastConv (
   int handle,                         //!< Open raster handle
   INT32 lin,                          //!< Raster line
   INT32 col,                          //!< Raster column
   INT32 len,                          //!< Number of cells to read
   void *data,                         //!< Pointer to data to be written
   UINT32 mode                         //!< Raster conversion mode, 0 for no conversion
   );

//! Change raster null value and remap all null cells to new value.
//!
//! Flags:  
//!   \li\b CHGRASTNULL_LeaveAlone     Leave cells matching new null value alone
//!   \li\b CHGRASTNULL_Increase       Increase value of cells matching new null value (if possible)
//!   \li\b CHGRASTNULL_Decrease       Decrease value of cells matching new null value (if possible)
//!
//!   This function will automatically recompute the raster histogram and pyramid tiers if necessary.
int MfChangeRasterNull (
   int fhandle,                        //!< Open file handle
   INT32 rastinode,                    //!< Raster inode
   ANYRASTVALUE *newnull,              //!< New null value
   UINT32 flags                        //!< Flags
   );

//! Compute linear combination of raster objects.
int MfCombineRastersLinear (
   FNAMEINODEUC *ifnameinode,          //!< Input raster objects 
   FNAMEINODEUC *ofnameinode,          //!< Output raster objects
   RVCRASTINFO *orastinfo,             //!< Output rasters info
   LINEARTRANS *trans,                 //!< Parameters of linear transformation 
   UINT32 flags                        //!< 1 if doing autoscale for output rasters values, 0 if not
   );

//! Compute CLUMP raster.
int MfComputeClumpRaster (
   int ifhandle,                       //!< Input file handle