Pan-STARRS Foundation Library: psType.h Source File

00001 /** @file  psType.h
00002 *
00003 *  @brief Contains support for basic types
00004 *
00005 *  This file defines common datatypes used throughout psLib.
00006 *
00007 *  @ingroup DataContainer
00008 *
00009 *  @author Robert DeSonia, MHPCC
00010 *  @author Ross Harman, MHPCC
00011 *
00012 *  @version $Revision: 1.50 $ $Name: rel12 $
00013 *  @date $Date: 2006/06/10 02:28:17 $
00014 *
00015 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
00016 */
00017 
00018 #ifndef PS_TYPE_H
00019 #define PS_TYPE_H
00020 
00021 #include <complex.h>
00022 #include <stdint.h>
00023 #include <float.h>
00024 #include <stdbool.h>
00025 
00026 /// @addtogroup DataContainer
00027 /// @{
00028 
00029 /******************************************************************************/
00030 
00031 /*  TYPE DEFINITIONS                                                          */
00032 
00033 /******************************************************************************/
00034 
00035 /** Basic data types used by the containers.
00036  *
00037  * The basic types of the primitives used by psLib are defined within this enum. This enum is in turn used by
00038  * the psType struct.
00039  *
00040  */
00041 
00042 typedef uint8_t psU8;                  ///< 8-bit unsigned int
00043 typedef uint16_t psU16;                ///< 16-bit unsigned int
00044 typedef uint32_t psU32;                ///< 32-bit unsigned int
00045 typedef uint64_t psU64;                ///< 64-bit unsigned int
00046 typedef int8_t psS8;                   ///< 8-bit signed int
00047 typedef int16_t psS16;                 ///< 16-bit signed int
00048 typedef int32_t psS32;                 ///< 32-bit signed int
00049 typedef int64_t psS64;                 ///< 64-bit signed int
00050 typedef float psF32;                   ///< 32-bit floating point
00051 typedef double psF64;                  ///< 64-bit floating point
00052 
00053 #ifdef SWIG
00054 /** 32-bit complex value */
00055 typedef struct
00056 {
00057     float re, im;
00058 }
00059 psC32;
00060 
00061 /** 64-bit complex value */
00062 typedef struct
00063 {
00064     double re,im;
00065 }
00066 psC64;
00067 
00068 #else // SWIG
00069 typedef float complex psC32;          ///< complex with 32-bit floating point Real and Imagary numbers
00070 typedef double complex psC64;         ///< complex with 64-bit floating point Real and Imagary numbers
00071 #endif // !SWIG
00072 
00073 typedef char* psString;                ///< string value
00074 typedef void* psPtr;                   ///< void pointer
00075 typedef bool psBool;                   ///< boolean value
00076 
00077 /** Enumeration of data types for function elements.
00078  *  Contains replacements for native types.
00079  */
00080 typedef enum {
00081     PS_TYPE_S8   = 0x0101,             ///< Character.
00082     PS_TYPE_S16  = 0x0102,             ///< Short integer.
00083     PS_TYPE_S32  = 0x0104,             ///< Integer.
00084     PS_TYPE_S64  = 0x0108,             ///< Long integer.
00085     PS_TYPE_U8   = 0x0301,             ///< Unsigned character.
00086     PS_TYPE_U16  = 0x0302,             ///< Unsigned psS16 integer.
00087     PS_TYPE_U32  = 0x0304,             ///< Unsigned integer.
00088     PS_TYPE_U64  = 0x0308,             ///< Unsigned psS64 integer.
00089     PS_TYPE_F32  = 0x0404,             ///< Single-precision Floating point.
00090     PS_TYPE_F64  = 0x0408,             ///< Double-precision floating point.
00091     PS_TYPE_C32  = 0x0808,             ///< Complex numbers consisting of single-precision floating point.
00092     PS_TYPE_C64  = 0x0810,             ///< Complex numbers consisting of double-precision floating point.
00093     PS_TYPE_BOOL = 0x1301              ///< Boolean.
00094 } psElemType;
00095 
00096 /** Enumeration primarily used with metadata which defines a data structure
00097  *  e.g., list, array, FITS file, etc.
00098 */
00099 typedef enum {
00100     PS_DATA_S8   = PS_TYPE_S8,         ///< psS8
00101     PS_DATA_S16  = PS_TYPE_S16,        ///< psS16
00102     PS_DATA_S32  = PS_TYPE_S32,        ///< psS32
00103     PS_DATA_S64  = PS_TYPE_S64,        ///< psS64
00104     PS_DATA_U8   = PS_TYPE_U8,         ///< psU8
00105     PS_DATA_U16  = PS_TYPE_U16,        ///< psU16
00106     PS_DATA_U32  = PS_TYPE_U32,        ///< psU32
00107     PS_DATA_U64  = PS_TYPE_U64,        ///< psU64
00108     PS_DATA_F32  = PS_TYPE_F32,        ///< psF32
00109     PS_DATA_F64  = PS_TYPE_F64,        ///< psF64
00110     PS_DATA_BOOL = PS_TYPE_BOOL,       ///< psBool
00111     PS_DATA_STRING = 0x10000,          ///< psString (char *)
00112     PS_DATA_ARRAY,                     ///< psArray
00113     PS_DATA_BITSET,                    ///< psBitSet
00114     PS_DATA_CUBE,                      ///< psCube
00115     PS_DATA_FITS,                      ///< psFits
00116     PS_DATA_HASH,                      ///< psHash
00117     PS_DATA_HISTOGRAM,                 ///< psHistogram
00118     PS_DATA_IMAGE,                     ///< psImage
00119     PS_DATA_KERNEL,                    ///< psKernel
00120     PS_DATA_LIST,                      ///< psList
00121     PS_DATA_LOOKUPTABLE,               ///< psLookupTable
00122     PS_DATA_METADATA,                  ///< psMetadata
00123     PS_DATA_METADATAITEM,              ///< psMetadataItem
00124     PS_DATA_MINIMIZATION,              ///< psMinimization
00125     PS_DATA_PIXELS,                    ///< psPixels
00126     PS_DATA_PLANE,                     ///< psPlane
00127     PS_DATA_PLANEDISTORT,              ///< psPlaneDistort
00128     PS_DATA_PLANETRANSFORM,            ///< psPlaneTransform
00129     PS_DATA_POLYNOMIAL1D,              ///< psPolynomial1D
00130     PS_DATA_POLYNOMIAL2D,              ///< psPolynomial2D
00131     PS_DATA_POLYNOMIAL3D,              ///< psPolynomial3D
00132     PS_DATA_POLYNOMIAL4D,              ///< psPolynomial4D
00133     PS_DATA_PROJECTION,                ///< psProjection
00134     PS_DATA_REGION,                    ///< psRegion
00135     PS_DATA_SCALAR,                    ///< psScalar
00136     PS_DATA_SPHERE,                    ///< psSphere
00137     PS_DATA_SPHEREROT,                 ///< psSphereTransform
00138     PS_DATA_SPLINE1D,                  ///< psSpline1D
00139     PS_DATA_STATS,                     ///< psStats
00140     PS_DATA_TIME,                      ///< psTime
00141     PS_DATA_VECTOR,                    ///< psVector
00142     PS_DATA_UNKNOWN,                   ///< Other data of an unknown type
00143     PS_DATA_METADATA_MULTI             ///< Used internally for metadata; not a 'real' type
00144 } psDataType;
00145 
00146 #define PS_TYPE_MASK PS_TYPE_U8        /**< the psElemType to use for mask image */
00147 #define PS_TYPE_MASK_DATA U8           /**< the data member to use for mask image */
00148 #define PS_TYPE_MASK_NAME "psU8"       /**< the data type for mask as a string */
00149 
00150 typedef psU8 psMaskType;               ///< the C datatype for a mask image
00151 typedef psBool psBOOL;                 ///< allow psBOOL to be used instead of psBool (for macros)
00152 
00153 #define PS_MIN_S8        INT8_MIN      /**< minimum valid psS8 value */
00154 #define PS_MIN_S16       INT16_MIN     /**< minimum valid psS16 value */
00155 #define PS_MIN_S32       INT32_MIN     /**< minimum valid psS32 value */
00156 #define PS_MIN_S64       INT64_MIN     /**< minimum valid psS64 value */
00157 #define PS_MIN_U8        0             /**< minimum valid psU8 value */
00158 #define PS_MIN_U16       0             /**< minimum valid psU16 value */
00159 #define PS_MIN_U32       0             /**< minimum valid psU32 value */
00160 #define PS_MIN_U64       0             /**< minimum valid psU64 value */
00161 #define PS_MIN_F32       -FLT_MAX      /**< minimum valid psF32 value */
00162 #define PS_MIN_F64       -DBL_MAX      /**< minimum valid psF64 value */
00163 #define PS_MIN_C32       -FLT_MAX      /**< minimum valid real or imaginary psC32 value */
00164 #define PS_MIN_C64       -DBL_MAX      /**< minimum valid real or imaginary psC32 value */
00165 
00166 #define PS_MAX_S8        INT8_MAX      /**< maximum valid psS8 value */
00167 #define PS_MAX_S16       INT16_MAX     /**< maximum valid psS16 value */
00168 #define PS_MAX_S32       INT32_MAX     /**< maximum valid psS32 value */
00169 #define PS_MAX_S64       INT64_MAX     /**< maximum valid psS64 value */
00170 #define PS_MAX_U8        UINT8_MAX     /**< maximum valid psU8 value */
00171 #define PS_MAX_U16       UINT16_MAX    /**< maximum valid psU16 value */
00172 #define PS_MAX_U32       UINT32_MAX    /**< maximum valid psU32 value */
00173 #define PS_MAX_U64       UINT64_MAX    /**< maximum valid psU64 value */
00174 #define PS_MAX_F32       FLT_MAX       /**< maximum valid psF32 value */
00175 #define PS_MAX_F64       DBL_MAX       /**< maximum valid psF64 value */
00176 #define PS_MAX_C32       FLT_MAX       /**< maximum valid real or imaginary psC32 value */
00177 #define PS_MAX_C64       DBL_MAX       /**< maximum valid real or imaginary psC32 value */
00178 
00179 #define PS_TYPE_BOOL_NAME "psBool"
00180 #define PS_TYPE_S8_NAME   "psS8"
00181 #define PS_TYPE_S16_NAME  "psS16"
00182 #define PS_TYPE_S32_NAME  "psS32"
00183 #define PS_TYPE_S64_NAME  "psS64"
00184 #define PS_TYPE_U8_NAME   "psU8"
00185 #define PS_TYPE_U16_NAME  "psU16"
00186 #define PS_TYPE_U32_NAME  "psU32"
00187 #define PS_TYPE_U64_NAME  "psU64"
00188 #define PS_TYPE_F32_NAME  "psF32"
00189 #define PS_TYPE_F64_NAME  "psF64"
00190 #define PS_TYPE_C32_NAME  "psC32"
00191 #define PS_TYPE_C64_NAME  "psC64"
00192 
00193 #define PS_TYPE_NAME(value,type) \
00194 switch(type) { \
00195 case PS_TYPE_BOOL: \
00196     value = PS_TYPE_BOOL_NAME; \
00197     break; \
00198 case PS_TYPE_S8: \
00199     value = PS_TYPE_S8_NAME; \
00200     break; \
00201 case PS_TYPE_S16: \
00202     value = PS_TYPE_S16_NAME; \
00203     break; \
00204 case PS_TYPE_S32: \
00205     value = PS_TYPE_S32_NAME; \
00206     break; \
00207 case PS_TYPE_S64: \
00208     value = PS_TYPE_S64_NAME; \
00209     break; \
00210 case PS_TYPE_U8: \
00211     value = PS_TYPE_U8_NAME; \
00212     break; \
00213 case PS_TYPE_U16: \
00214     value = PS_TYPE_U16_NAME; \
00215     break; \
00216 case PS_TYPE_U32: \
00217     value = PS_TYPE_U32_NAME; \
00218     break; \
00219 case PS_TYPE_U64: \
00220     value = PS_TYPE_U64_NAME; \
00221     break; \
00222 case PS_TYPE_F32: \
00223     value = PS_TYPE_F32_NAME; \
00224     break; \
00225 case PS_TYPE_F64: \
00226     value = PS_TYPE_F64_NAME; \
00227     break; \
00228 case PS_TYPE_C32: \
00229     value = PS_TYPE_C32_NAME; \
00230     break; \
00231 case PS_TYPE_C64: \
00232     value = PS_TYPE_C64_NAME; \
00233     break; \
00234 default: \
00235     value = "unknown"; \
00236 };
00237 
00238 /// Macro to get the bad pixel reason code (stored as part of mask value)
00239 #define PS_BADPIXEL_BITMASK 0x0f
00240 #define PS_GET_BADPIXEL(maskValue) (maskValue & PS_BADPIXEL_BITMASK)
00241 
00242 #define PS_IS_BADPIXEL(maskValue) (PS_GET_BADPIXEL(maskValue) != 0)
00243 
00244 /// Macro to apply a bad pixel reason code to mask image
00245 #define PS_SET_BADPIXEL(maskValue, reasonCode) \
00246 { \
00247     maskValue = (psMaskType)((reasonCode & PS_BADPIXEL_BITMASK) | (maskValue & ~PS_BADPIXEL_BITMASK)); \
00248 }
00249 
00250 /// Macro to determine if the psElemType is an integer.
00251 #define PS_IS_PSELEMTYPE_INT(x) ((x & 0x100) == 0x100)
00252 /// Macro to determine if the psElemType is unsigned.
00253 #define PS_IS_PSELEMTYPE_UNSIGNED(x) ((x & 0x200) == 0x200)
00254 /// Macro to determine if the psElemType is a real (non-complex) floating-point type.
00255 #define PS_IS_PSELEMTYPE_REAL(x) ((x & 0x400) == 0x400)
00256 /// Macro to determine if the psElemType is complex number type.
00257 #define PS_IS_PSELEMTYPE_COMPLEX(x) ((x & 0x800) == 0x800)
00258 /// Macro to determine if the psElemType is boolean type.
00259 #define PS_IS_PSELEMTYPE_BOOL(x) ((x & 0x1000) == 0x1000)
00260 /// Macro to determine the storage size, in bytes, of the psElemType.
00261 #define PSELEMTYPE_SIZEOF(x) (x & 0xFF)
00262 
00263 /** Dimensions of a data type.
00264  *
00265  * The dimensions of containers used by psLib are defined within this enum. This enum is used by the psType
00266 struct. *
00267  */
00268 typedef enum {
00269     PS_DIMEN_SCALAR,            ///< Scalar.
00270     PS_DIMEN_VECTOR,            ///< Vector.
00271     PS_DIMEN_TRANSV,            ///< Transposed vector.
00272     PS_DIMEN_IMAGE,             ///< Image.
00273     PS_DIMEN_OTHER              ///< Something else that's not supported for arithmetic.
00274 } psDimen;
00275 
00276 /** The type of a data type.
00277  *
00278  * All psLib complex types consist of primitive components. This struct provides the description of those
00279  * primitives.
00280  *
00281  */
00282 typedef struct
00283 {
00284     psElemType type;                   ///< Primitive type.
00285     psDimen dimen;                     ///< Dimensionality.
00286 }
00287 psType;
00288 
00289 typedef struct
00290 {
00291     psElemType type;                   ///< The type
00292     psDimen dimen;                     ///< The dimensionality.
00293 }
00294 psMathType;
00295 
00296 /** The type of a basic data type
00297  *
00298  *  All psLib complex types consist of primitive components.  This structure provides the ability to cast
00299  *  an unknown data structure to safely test the underlining data type.
00300  *
00301  */
00302 typedef struct
00303 {
00304     psMathType type;              ///< Data type information
00305 }
00306 psMath;
00307 
00308 /// @}
00309 
00310 #endif // #ifndef PS_TYPE_H