fmetypes.h

GIS格式转换软件vc源码.GIS格式转换软件vc源码.

   FME_Boolean operator==(const FMEColorModelRGB3BYTE& other) const
   {
      if ((this == &other) ||
         (red == other.red && green == other.green && blue == other.blue))
      {
         return FME_TRUE;
      }
      else
      {
         return FME_FALSE;
      }
   }

   FME_Boolean operator!=(const FMEColorModelRGB3BYTE& other) const
   {
      return ((*this == other) == FME_TRUE) ? FME_FALSE : FME_TRUE;
   }

   void reset()
   {
      red = 0;
      green = 0;
      blue = 0;
   }

   FME_UInt8 red;
   FME_UInt8 green;
   FME_UInt8 blue;
};


// =============================================================================
// FMEColorModelRGBA4BYTE

struct FMEColorModelRGBA4BYTE
{
public:
   FMEColorModelRGBA4BYTE() :
      red(0), green(0), blue(0), alpha(kFMERasterColorModel8BitAlphaDefault) {}

   FMEColorModelRGBA4BYTE(FME_UInt8 r, FME_UInt8 g, FME_UInt8 b, FME_UInt8 a) :
      red(r), green(g), blue(b), alpha(a) {}

   FMEColorModelRGBA4BYTE(const FMEColorModelRGBA4BYTE& other ) :
      red(other.red), green(other.green), blue(other.blue), alpha(other.alpha) {}

   FMEColorModelRGBA4BYTE& operator=(const FMEColorModelRGBA4BYTE& item )
   {
      if (this != &item) 
      {
         red = item.red;
         green = item.green;
         blue = item.blue;
         alpha = item.alpha;
      }

      return *this;
   }

   FME_Boolean operator==(const FMEColorModelRGBA4BYTE& other) const
   {
      if ((this == &other) ||
         (red == other.red && green == other.green && blue == other.blue && 
         alpha == other.alpha))
      {
         return FME_TRUE;
      }
      else
      {
         return FME_FALSE;
      }
   }

   FME_Boolean operator!=(const FMEColorModelRGBA4BYTE& other) const
   {
      return ((*this == other) == FME_TRUE) ? FME_FALSE : FME_TRUE;
   }

   void reset()
   {
       red = 0;
       green = 0;
       blue = 0;
       alpha = kFMERasterColorModel8BitAlphaDefault;
   }

   FME_UInt8 red;
   FME_UInt8 green;
   FME_UInt8 blue;
   FME_UInt8 alpha;
};

// =============================================================================
// FMEColorModelRGB6BYTE

struct FMEColorModelRGB6BYTE
{
public:
   FMEColorModelRGB6BYTE() :
      red(0), green(0), blue(0) {}

   FMEColorModelRGB6BYTE(FME_UInt16 r, FME_UInt16 g, FME_UInt16 b) :
      red(r), green(g), blue(b) {}

   FMEColorModelRGB6BYTE(const FMEColorModelRGB6BYTE& other ) :
      red(other.red), green(other.green), blue(other.blue) {}

   FMEColorModelRGB6BYTE& operator=(const FMEColorModelRGB6BYTE& item )
   {
      if (this != &item) 
      {
         red = item.red;
         green = item.green;
         blue = item.blue;
      }

      return *this;
   }

   FME_Boolean operator==(const FMEColorModelRGB6BYTE& other) const
   {
      if ((this == &other) ||
         (red == other.red && green == other.green && blue == other.blue))
      {
         return FME_TRUE;
      }
      else
      {
         return FME_FALSE;
      }
   }

   FME_Boolean operator!=(const FMEColorModelRGB6BYTE& other) const
   {
      return ((*this == other) == FME_TRUE) ? FME_FALSE : FME_TRUE;
   }

   void reset()
   {
       red = 0;
       green = 0;
       blue = 0;
   }

   FME_UInt16 red;
   FME_UInt16 green;
   FME_UInt16 blue;
};


// =============================================================================
// FMEColorModelRGBA8BYTE

struct FMEColorModelRGBA8BYTE
{
public:
   FMEColorModelRGBA8BYTE() :
      red(0), green(0), blue(0), alpha(kFMERasterColorModel16BitAlphaDefault) {}

   FMEColorModelRGBA8BYTE(FME_UInt16 r, FME_UInt16 g, FME_UInt16 b, FME_UInt16 a) :
      red(r), green(g), blue(b), alpha(a) {}

   FMEColorModelRGBA8BYTE(const FMEColorModelRGBA8BYTE& other ) :
      red(other.red), green(other.green), blue(other.blue), alpha(other.alpha) {}

   FMEColorModelRGBA8BYTE& operator=(const FMEColorModelRGBA8BYTE& item )
   {
      if (this != &item) 
      {
         red = item.red;
         green = item.green;
         blue = item.blue;
         alpha = item.alpha;
      }

      return *this;
   }

   FME_Boolean operator==(const FMEColorModelRGBA8BYTE& other) const
   {
      if ((this == &other) ||
         (red == other.red && green == other.green && blue == other.blue && 
         alpha == other.alpha))
      {
         return FME_TRUE;
      }
      else
      {
         return FME_FALSE;
      }
   }

   FME_Boolean operator!=(const FMEColorModelRGBA8BYTE& other) const
   {
      return ((*this == other) == FME_TRUE) ? FME_FALSE : FME_TRUE;
   }

   void reset()
   {
       red = 0;
       green = 0;
       blue = 0;
       alpha = kFMERasterColorModel16BitAlphaDefault;
   }

   FME_UInt16 red;
   FME_UInt16 green;
   FME_UInt16 blue;
   FME_UInt16 alpha;
};

// [PR#8981] Moved here from fmerasterpriv.h
//20050624: String constants for FME band types
static const char* kFME_BandTypeStr          = "FME_BAND_TYPE";
static const char* kFME_BandTypeContinuous   = "CONTINUOUS";
static const char* kFME_BandTypeClassified   = "CLASSIFIED";

//20050624: String constants for FME general cell types
static const char* kFME_GeneralCellType         = "FME_GENERAL_CELL_TYPE";
static const char* kFME_GeneralCellTypeNull     = "NULL";
static const char* kFME_GeneralCellTypeRaster   = "RASTER";
static const char* kFME_GeneralCellTypeImage    = "IMAGE";

// [hv 12/21/2005] String constants for interleave.
//BUG8919: Added NULL interleave type
static const char* kFME_InterleaveTypeStr = "FME_INTERLEAVE_TYPE";
static const char* kFME_InterleaveNULL    = "NULL";
static const char* kFME_InterleaveBSQ     = "BSQ";
static const char* kFME_InterleaveBIP     = "BIP";
static const char* kFME_InterleaveBIL     = "BIL";

//20050624: String constants for FME band color models
static const char* kFME_BandColorModelStr          = "FME_BAND_COLOR_MODEL";
static const char* kFME_BandColorModelNull         = "NULL";
static const char* kFME_BandColorModelRGBA4Byte    = "RGBA_4BYTE";
static const char* kFME_BandColorModelRGB3Byte     = "RGB_3BYTE";
static const char* kFME_BandColorModelRGBA8Byte    = "RGBA_8BYTE";
static const char* kFME_BandColorModelRGB6Byte     = "RGB_6BYTE";
static const char* kFME_BandColorModelRed1Byte     = "RED_1BYTE";
static const char* kFME_BandColorModelGreen1Byte   = "GREEN_1BYTE";
static const char* kFME_BandColorModelBlue1Byte    = "BLUE_1BYTE";
static const char* kFME_BandColorModelGray1Byte    = "GRAY_1BYTE";
static const char* kFME_BandColorModelAlpha1Byte   = "ALPHA_1BYTE";
static const char* kFME_BandColorModelRed2Byte     = "RED_2BYTE";
static const char* kFME_BandColorModelGreen2Byte   = "GREEN_2BYTE";
static const char* kFME_BandColorModelBlue2Byte    = "BLUE_2BYTE";
static const char* kFME_BandColorModelGray2Byte    = "GRAY_2BYTE";
static const char* kFME_BandColorModelAlpha2Byte   = "ALPHA_2BYTE";
static const char* kFME_BandColorModelRGBString    = "RGB_STRING";

//20050624: String constants for FME endianness
static const char* kFME_ByteOrderStr      = "FME_BYTE_ORDER";
static const char* kFME_ByteOrderMachine  = "MACHINE";
static const char* kFME_ByteOrderFlipped  = "FLIPPED";
static const char* kFME_ByteOrderMSB      = "MSB";
static const char* kFME_ByteOrderLSB      = "LSB";

//PR#8447: String constants without specified endianness
static const char* kFME_CellElementTypeStr          = "FME_CELL_ELEMENT_TYPE";
static const char* kFME_CellElementTypeNull         = "NULL";
static const char* kFME_CellElementTypeReal64       = "REAL64";
static const char* kFME_CellElementTypeReal32       = "REAL32";
static const char* kFME_CellElementTypeUInt32       = "UINT32";
static const char* kFME_CellElementTypeInt32        = "INT32";
static const char* kFME_CellElementTypeUInt16       = "UINT16";
static const char* kFME_CellElementTypeInt16        = "INT16";
static const char* kFME_CellElementTypeUInt8        = "UINT8";
static const char* kFME_CellElementTypeInt8         = "INT8";
static const char* kFME_CellElementTypeString8      = "STRING_8BYTE";
static const char* kFME_CellElementTypeString16     = "STRING_16BYTE";
static const char* kFME_CellElementTypeString32     = "STRING_32BYTE";
static const char* kFME_CellElementTypeString64     = "STRING_64BYTE";


#if defined(WIN32)
#  pragma pack(pop)
#  elif defined(__SUNPRO_CC) || defined(__GNUC__)
#  pragma pack()
#elif defined(_AIX)
#  pragma options align=reset
#elif !defined(__GNUC__)
#  pragma pack
#endif

//=================================================================
// FME Raster Type Declarations - End
//=================================================================


//=================================================================
// FME Rich Geometry Type Declarations - Start
//=================================================================

struct FMECoord2D
{
   FMECoord2D()
      : x(FME_NAN), y(FME_NAN) {}

   FMECoord2D(FME_Real64 xCoord, FME_Real64 yCoord)
      : x(xCoord), y(yCoord) {}

   FME_Real64 x, y;
};

struct FMECoord3D
{
   FMECoord3D()
      : x(FME_NAN), y(FME_NAN), z(FME_NAN) {}

   FMECoord3D(FME_Real64 xCoord, FME_Real64 yCoord, FME_Real64 zCoord)
      : x(xCoord), y(yCoord), z(zCoord) {}

   FME_Real64 x, y, z;
};

//=================================================================
// FME Rich Geometry Type Declarations - End
//=================================================================


// -------------------------------------------------------------------------

#ifdef WIN32
#pragma warning(disable:4127)
#endif

// End the C++ section
#endif


#endif