IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 3446


Ignore:
Timestamp:
Mar 17, 2005, 4:35:15 PM (21 years ago)
Author:
desonia
Message:

added BILINEAR_VARIANCE interpolation mode.

Location:
trunk/psLib
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/image/psImage.c

    r3442 r3446  
    99 *  @author Ross Harman, MHPCC
    1010 *
    11  *  @version $Revision: 1.60 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2005-03-17 19:02:01 $
     11 *  @version $Revision: 1.61 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2005-03-18 02:35:14 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2626
    2727#include "psImageErrors.h"
     28
     29#define SQUARE(x) ((x)*(x))
     30#define MIN(x,y) (((x) > (y)) ? (y) : (x))
     31#define MAX(x,y) (((x) > (y)) ? (x) : (y))
    2832
    2933static void imageFree(psImage* image)
    … …  
    116120}
    117121
    118 
    119 
    120122psRegion* psRegionFromString(char* region)
    121123{
    … …  
    165167    return psStringCopy(tmpText);
    166168}
    167 
    168169
    169170psImage* psImageRecycle(psImage* old,
    … …  
    428429    }
    429430
    430     #define PSIMAGE_PIXEL_INTERPOLATE_CASE(TYPE)                     \
     431    #define PSIMAGE_PIXEL_INTERPOLATE_CASE(TYPE)                             \
    431432case PS_TYPE_##TYPE:                                                 \
    432433    switch (mode) {                                                  \
    … …  
    449450                unexposedValue);                                     \
    450451        break;                                                       \
     452    case PS_INTERPOLATE_BILINEAR_VARIANCE:                           \
     453        return p_psImagePixelInterpolateBILINEAR_VARIANCE_##TYPE(    \
     454                input,                                               \
     455                x,                                                   \
     456                y,                                                   \
     457                mask,                                                \
     458                maskVal,                                             \
     459                unexposedValue);                                     \
     460        break;                                                       \
    451461    default:                                                         \
    452462        psError(PS_ERR_BAD_PARAMETER_VALUE,true,                     \
    … …  
    454464                mode);                                               \
    455465    }                                                                \
    456     break
     466    break;
    457467
    458468    switch (input->type.type) {
    … …  
    481491}
    482492
    483 #define PSIMAGE_PIXEL_INTERPOLATE_FLAT(TYPE) \
    484 inline psF64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage* input, \
     493#define PSIMAGE_PIXEL_INTERPOLATE_FLAT(TYPE,RETURNTYPE) \
     494inline RETURNTYPE p_psImagePixelInterpolateFLAT_##TYPE( \
     495        const psImage* input, \
    485496        float x, \
    486497        float y, \
    487498        const psImage* mask, \
    488499        psU32 maskVal, \
    489         psF64 unexposedValue) \
     500        RETURNTYPE unexposedValue) \
    490501{ \
    491502    psS32 intX = (psS32) round((psF64)(x) - 0.5 + FLT_EPSILON); \
    … …  
    506517}
    507518
    508 #define PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(TYPE) \
    509 inline psC64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage* input, \
     519PSIMAGE_PIXEL_INTERPOLATE_FLAT(U8,psF64)
     520PSIMAGE_PIXEL_INTERPOLATE_FLAT(U16,psF64)
     521PSIMAGE_PIXEL_INTERPOLATE_FLAT(U32,psF64)
     522PSIMAGE_PIXEL_INTERPOLATE_FLAT(U64,psF64)
     523PSIMAGE_PIXEL_INTERPOLATE_FLAT(S8,psF64)
     524PSIMAGE_PIXEL_INTERPOLATE_FLAT(S16,psF64)
     525PSIMAGE_PIXEL_INTERPOLATE_FLAT(S32,psF64)
     526PSIMAGE_PIXEL_INTERPOLATE_FLAT(S64,psF64)
     527PSIMAGE_PIXEL_INTERPOLATE_FLAT(F32,psF64)
     528PSIMAGE_PIXEL_INTERPOLATE_FLAT(F64,psF64)
     529PSIMAGE_PIXEL_INTERPOLATE_FLAT(C32,psC64)
     530PSIMAGE_PIXEL_INTERPOLATE_FLAT(C64,psC64)
     531
     532#define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(TYPE, RETURNTYPE, SUFFIX, FRACFUNC) \
     533inline RETURNTYPE p_psImagePixelInterpolateBILINEAR_##SUFFIX( \
     534        const psImage* input, \
    510535        float x, \
    511536        float y, \
    512537        const psImage* mask, \
    513538        psU32 maskVal, \
    514         psC64 unexposedValue) \
    515 { \
    516     psS32 intX = (psS32) round((psF64)(x) - 0.5); \
    517     psS32 intY = (psS32) round((psF64)(y) - 0.5); \
    518     psS32 lastX = input->numCols - 1; \
    519     psS32 lastY = input->numRows - 1; \
    520     \
    521     if ((intX < 0) || \
    522             (intX > lastX) || \
    523             (intY < 0) || \
    524             (intY > lastY) || \
    525             ( (mask!=NULL) && \
    526               ((mask->data.PS_TYPE_MASK_DATA[intY][intX] & maskVal) != 0) ) ) { \
    527         return unexposedValue; \
    528     } \
    529     \
    530     return input->data.TYPE[intY][intX]; \
    531 }
    532 
    533 PSIMAGE_PIXEL_INTERPOLATE_FLAT(U8)
    534 PSIMAGE_PIXEL_INTERPOLATE_FLAT(U16)
    535 PSIMAGE_PIXEL_INTERPOLATE_FLAT(U32)
    536 PSIMAGE_PIXEL_INTERPOLATE_FLAT(U64)
    537 PSIMAGE_PIXEL_INTERPOLATE_FLAT(S8)
    538 PSIMAGE_PIXEL_INTERPOLATE_FLAT(S16)
    539 PSIMAGE_PIXEL_INTERPOLATE_FLAT(S32)
    540 PSIMAGE_PIXEL_INTERPOLATE_FLAT(S64)
    541 PSIMAGE_PIXEL_INTERPOLATE_FLAT(F32)
    542 PSIMAGE_PIXEL_INTERPOLATE_FLAT(F64)
    543 PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C32)
    544 PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C64)
    545 
    546 #define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(TYPE) \
    547 inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage* input, \
    548         float x, \
    549         float y, \
    550         const psImage* mask, \
    551         psU32 maskVal, \
    552         psF64 unexposedValue) \
     539        RETURNTYPE unexposedValue) \
    553540{ \
    554541    double floorX = floor((psF64)(x) - 0.5); \
    … …  
    597584    if (valid00 && valid10 && valid01 && valid11) { \
    598585        /* formula from the ADD */ \
    599         psF64 rx = V00 + (V10-V00)*fracX; \
    600         return (rx + (V01 + (V11 - V01) * fracX - rx) * fracY); \
     586        return V00*FRACFUNC((1.0-fracX)*(1.0-fracY)) + V10*FRACFUNC(fracX*(1.0-fracY)) + \
     587               V01*FRACFUNC(fracY*(1.0-fracX)) + V11*FRACFUNC(fracX*fracY); \
    601588    } \
    602589    \
    603590    /* OK, at least one pixel is not valid - need to do it piecemeal */ \
    604591    \
    605     psF64 V0 = 0.0; \
     592    RETURNTYPE V0 = 0.0; \
    606593    psBool valid0 = true; \
    607594    if (valid00 && valid10) { \
    608         V0 = V00*(1-fracX)+V10*fracX; \
     595        V0 = V00*FRACFUNC(1-fracX)+V10*FRACFUNC(fracX); \
    609596    } else if (valid00) { \
    610597        V0 = V00; \
    … …  
    615602    } \
    616603    \
    617     psF64 V1 = 0.0; \
     604    RETURNTYPE V1 = 0.0; \
    618605    psBool valid1 = true; \
    619606    if (valid01 && valid11) { \
    620         V1 = V01*(1-fracX)+V11*fracX; \
     607        V1 = V01*FRACFUNC(1-fracX)+V11*FRACFUNC(fracX); \
    621608    } else if (valid01) { \
    622609        V1 = V01; \
    … …  
    628615    \
    629616    if (valid0 && valid1) { \
    630         return ( V0*(1-fracY) + V1*fracY ); \
     617        return V0*FRACFUNC(1-fracY) + V1*FRACFUNC(fracY); \
    631618    } else if (valid0) { \
    632619        return V0; \
    … …  
    638625}
    639626
    640 #define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(TYPE) \
    641 inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage* input, \
    642         float x, \
    643         float y, \
    644         const psImage* mask, \
    645         psU32 maskVal, \
    646         psC64 unexposedValue) \
    647 { \
    648     double floorX = floor((psF64)(x) - 0.5); \
    649     double floorY = floor((psF64)(y) - 0.5); \
    650     psF64 fracX = x - 0.5 - floorX; \
    651     psF64 fracY = y - 0.5 - floorY; \
    652     psS32 intFloorX = (psS32) floorX; \
    653     psS32 intFloorY = (psS32) floorY; \
    654     psS32 lastX = input->numCols - 1; \
    655     psS32 lastY = input->numRows - 1; \
    656     ps##TYPE V00 = 0; \
    657     ps##TYPE V01 = 0; \
    658     ps##TYPE V10 = 0; \
    659     ps##TYPE V11 = 0; \
    660     psBool valid00 = false; \
    661     psBool valid01 = false; \
    662     psBool valid10 = false; \
    663     psBool valid11 = false; \
    664     \
    665     if (intFloorY >= 0 && intFloorY <= lastY) { \
    666         if (intFloorX >= 0 && intFloorX <= lastX) { \
    667             V00 = input->data.TYPE[intFloorY][intFloorX]; \
    668             valid00 = (mask == NULL) || \
    669                       ((mask->data.PS_TYPE_MASK_DATA[intFloorY][intFloorX] & maskVal) == 0); \
    670         } \
    671         if (intFloorX >= -1 && intFloorX < lastX) { \
    672             V10 = input->data.TYPE[intFloorY][intFloorX+1]; \
    673             valid10 = (mask == NULL) || \
    674                       ((mask->data.PS_TYPE_MASK_DATA[intFloorY][intFloorX+1] & maskVal) == 0); \
    675         } \
    676     } \
    677     if (intFloorY >= -1 && intFloorY < lastY) { \
    678         if (intFloorX >= 0 && intFloorX <= lastX) { \
    679             V01 = input->data.TYPE[intFloorY+1][intFloorX]; \
    680             valid01 = (mask == NULL) || \
    681                       ((mask->data.PS_TYPE_MASK_DATA[intFloorY+1][intFloorX] & maskVal) == 0); \
    682         } \
    683         if (intFloorX >= -1 && intFloorX < lastX) { \
    684             V11 = input->data.TYPE[intFloorY+1][intFloorX+1]; \
    685             valid11 = (mask == NULL) || \
    686                       ((mask->data.PS_TYPE_MASK_DATA[intFloorY+1][intFloorX+1] & maskVal) == 0); \
    687         } \
    688     } \
    689     \
    690     /* cover likely case of all pixels being valid */  \
    691     if (valid00 && valid10 && valid01 && valid11) { \
    692         /* formula from the ADD */ \
    693         psC64 rx = V00 + (V10-V00)*fracX; \
    694         return (rx + (V01 + (V11 - V01) * fracX - rx) * fracY); \
    695     } \
    696     \
    697     /* OK, at least one pixel is not valid - need to do it piecemeal */ \
    698     \
    699     psC64 V0 = 0; \
    700     psBool valid0 = true; \
    701     if (valid00 && valid10) { \
    702         V0 = V00*(1-fracX)+V10*fracX; \
    703     } else if (valid00) { \
    704         V0 = V00; \
    705     } else if (valid10) { \
    706         V0 = V10; \
    707     } else { \
    708         valid0 = false; \
    709     } \
    710     \
    711     psC64 V1 = 0; \
    712     psBool valid1 = true; \
    713     if (valid01 && valid11) { \
    714         V0 = V01*(1-fracX)+V11*fracX; \
    715     } else if (valid01) { \
    716         V0 = V01; \
    717     } else if (valid11) { \
    718         V0 = V11; \
    719     } else { \
    720         valid1 = false; \
    721     } \
    722     \
    723     if (valid0 && valid1) { \
    724         return ( V0*(1-fracY) + V1*fracY ); \
    725     } else if (valid0) { \
    726         return V0; \
    727     } else if (valid1) { \
    728         return V1; \
    729     } \
    730     \
    731     return unexposedValue; \
    732 }
    733 
    734 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8)
    735 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16)
    736 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32)
    737 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64)
    738 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8)
    739 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16)
    740 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32)
    741 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64)
    742 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32)
    743 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64)
    744 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C32)
    745 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C64)
     627PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8,psF64,U8,)
     628PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16,psF64,U16,)
     629PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32,psF64,U32,)
     630PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64,psF64,U64,)
     631PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8,psF64,S8,)
     632PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16,psF64,S16,)
     633PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32,psF64,S32,)
     634PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64,psF64,S64,)
     635PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32,psF64,F32,)
     636PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64,psF64,F64,)
     637PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C32,psC64,C32,)
     638PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C64,psC64,C64,)
     639
     640// Variance Version
     641PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8,psF64,VARIANCE_U8,SQUARE)
     642PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16,psF64,VARIANCE_U16,SQUARE)
     643PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32,psF64,VARIANCE_U32,SQUARE)
     644PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64,psF64,VARIANCE_U64,SQUARE)
     645PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8,psF64,VARIANCE_S8,SQUARE)
     646PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16,psF64,VARIANCE_S16,SQUARE)
     647PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32,psF64,VARIANCE_S32,SQUARE)
     648PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64,psF64,VARIANCE_S64,SQUARE)
     649PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32,psF64,VARIANCE_F32,SQUARE)
     650PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64,psF64,VARIANCE_F64,SQUARE)
     651PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C32,psC64,VARIANCE_C32,SQUARE)
     652PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C64,psC64,VARIANCE_C64,SQUARE)

  • trunk/psLib/src/image/psImage.h

    r3442 r3446  
    1111 *  @author Ross Harman, MHPCC
    1212 *
    13  *  @version $Revision: 1.48 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2005-03-17 19:02:01 $
     13 *  @version $Revision: 1.49 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2005-03-18 02:35:14 $
    1515 *
    1616 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    191191);
    192192
    193 #define p_psImagePixelInterpolateFcns(TYPE) \
    194 inline psF64 p_psImagePixelInterpolateFLAT_##TYPE( \
     193#define PIXEL_INTERPOLATE_FCN_PROTOTYPE(SUFFIX, RETURNTYPE) \
     194inline RETURNTYPE p_psImagePixelInterpolate##SUFFIX( \
    195195        const psImage* input,          /**< input image for interpolation */ \
    196196        float x,                       /**< column location to derive value of */ \
    197197        float y,                       /**< row location ot derive value of */ \
    198198        const psImage* mask,           /**< if not NULL, the mask of the input image */ \
    199         psU32 maskVal,          /**< the mask value */ \
    200         psF64 unexposedValue           /**< return value if x,y location is not in image. */ \
    201                                                  ); \
    202 inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE( \
    203         const psImage* input,          /**< input image for interpolation */ \
    204         float x,                       /**< column location to derive value of */ \
    205         float y,                       /**< row location ot derive value of */ \
    206         const psImage* mask,           /**< if not NULL, the mask of the input image */ \
    207         psU32 maskVal,          /**< the mask value */ \
    208         psF64 unexposedValue           /**< return value if x,y location is not in image. */ \
    209                                                      );
    210 
    211 #define p_psImagePixelInterpolateComplexFcns(TYPE) \
    212 inline psC64 p_psImagePixelInterpolateFLAT_##TYPE( \
    213         const psImage* input,          /**< input image for interpolation */ \
    214         float x,                       /**< column location to derive value of */ \
    215         float y,                       /**< row location ot derive value of */ \
    216         const psImage* mask,           /**< if not NULL, the mask of the input image */ \
    217         psU32 maskVal,          /**< the mask value */ \
    218         psC64 unexposedValue           /**< return value if x,y location is not in image. */ \
    219                                                  ); \
    220 inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE( \
    221         const psImage* input,          /**< input image for interpolation */ \
    222         float x,                       /**< column location to derive value of */ \
    223         float y,                       /**< row location ot derive value of */ \
    224         const psImage* mask,           /**< if not NULL, the mask of the input image */ \
    225         psU32 maskVal,          /**< the mask value */ \
    226         psC64 unexposedValue           /**< return value if x,y location is not in image. */ \
    227                                                      );
     199        psU32 maskVal,                 /**< the mask value */ \
     200        RETURNTYPE unexposedValue      /**< return value if x,y location is not in image. */ \
     201                                                   );
     202
     203#define PIXEL_INTERPOLATE_FCNS(MODE) \
     204PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_U8,psF64)  \
     205PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_U16,psF64) \
     206PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_U32,psF64) \
     207PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_U64,psF64) \
     208PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_S8,psF64)  \
     209PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_S16,psF64) \
     210PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_S32,psF64) \
     211PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_S64,psF64) \
     212PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_F32,psF64) \
     213PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_F64,psF64) \
     214PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_C32,psC64) \
     215PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_C64,psC64)
     216
    228217#ifndef SWIG
    229 p_psImagePixelInterpolateFcns(U8)
    230 p_psImagePixelInterpolateFcns(U16)
    231 p_psImagePixelInterpolateFcns(U32)
    232 p_psImagePixelInterpolateFcns(U64)
    233 p_psImagePixelInterpolateFcns(S8)
    234 p_psImagePixelInterpolateFcns(S16)
    235 p_psImagePixelInterpolateFcns(S32)
    236 p_psImagePixelInterpolateFcns(S64)
    237 p_psImagePixelInterpolateFcns(F32)
    238 p_psImagePixelInterpolateFcns(F64)
    239 p_psImagePixelInterpolateComplexFcns(C32)
    240 p_psImagePixelInterpolateComplexFcns(C64)
     218PIXEL_INTERPOLATE_FCNS(FLAT)
     219PIXEL_INTERPOLATE_FCNS(BILINEAR)
     220PIXEL_INTERPOLATE_FCNS(BILINEAR_VARIANCE)
    241221#endif
    242222
     223#undef PIXEL_INTERPOLATE_FCN_PROTOTYPE
     224#undef PIXEL_INTERPOLATE_FCNS
     225
    243226/// @}
    244227

  • trunk/psLib/src/image/psImageManip.c

    r3264 r3446  
    1010 *  @author Ross Harman, MHPCC
    1111 *
    12  *  @version $Revision: 1.36 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2005-02-17 19:26:24 $
     12 *  @version $Revision: 1.37 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2005-03-18 02:35:14 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    941941            PSIMAGE_ROTATE_ARBITRARY_CASE(FLAT);
    942942            PSIMAGE_ROTATE_ARBITRARY_CASE(BILINEAR);
     943            PSIMAGE_ROTATE_ARBITRARY_CASE(BILINEAR_VARIANCE);
    943944        default:
    944945            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
    … …  
    10371038        PSIMAGE_SHIFT_ARBITRARY_CASE(FLAT);
    10381039        PSIMAGE_SHIFT_ARBITRARY_CASE(BILINEAR);
     1040        PSIMAGE_SHIFT_ARBITRARY_CASE(BILINEAR_VARIANCE);
    10391041    default:
    10401042        psError(PS_ERR_BAD_PARAMETER_VALUE, true,

  • trunk/psLib/src/mathtypes/psImage.c

    r3442 r3446  
    99 *  @author Ross Harman, MHPCC
    1010 *
    11  *  @version $Revision: 1.60 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2005-03-17 19:02:01 $
     11 *  @version $Revision: 1.61 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2005-03-18 02:35:14 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2626
    2727#include "psImageErrors.h"
     28
     29#define SQUARE(x) ((x)*(x))
     30#define MIN(x,y) (((x) > (y)) ? (y) : (x))
     31#define MAX(x,y) (((x) > (y)) ? (x) : (y))
    2832
    2933static void imageFree(psImage* image)
    … …  
    116120}
    117121
    118 
    119 
    120122psRegion* psRegionFromString(char* region)
    121123{
    … …  
    165167    return psStringCopy(tmpText);
    166168}
    167 
    168169
    169170psImage* psImageRecycle(psImage* old,
    … …  
    428429    }
    429430
    430     #define PSIMAGE_PIXEL_INTERPOLATE_CASE(TYPE)                     \
     431    #define PSIMAGE_PIXEL_INTERPOLATE_CASE(TYPE)                             \
    431432case PS_TYPE_##TYPE:                                                 \
    432433    switch (mode) {                                                  \
    … …  
    449450                unexposedValue);                                     \
    450451        break;                                                       \
     452    case PS_INTERPOLATE_BILINEAR_VARIANCE:                           \
     453        return p_psImagePixelInterpolateBILINEAR_VARIANCE_##TYPE(    \
     454                input,                                               \
     455                x,                                                   \
     456                y,                                                   \
     457                mask,                                                \
     458                maskVal,                                             \
     459                unexposedValue);                                     \
     460        break;                                                       \
    451461    default:                                                         \
    452462        psError(PS_ERR_BAD_PARAMETER_VALUE,true,                     \
    … …  
    454464                mode);                                               \
    455465    }                                                                \
    456     break
     466    break;
    457467
    458468    switch (input->type.type) {
    … …  
    481491}
    482492
    483 #define PSIMAGE_PIXEL_INTERPOLATE_FLAT(TYPE) \
    484 inline psF64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage* input, \
     493#define PSIMAGE_PIXEL_INTERPOLATE_FLAT(TYPE,RETURNTYPE) \
     494inline RETURNTYPE p_psImagePixelInterpolateFLAT_##TYPE( \
     495        const psImage* input, \
    485496        float x, \
    486497        float y, \
    487498        const psImage* mask, \
    488499        psU32 maskVal, \
    489         psF64 unexposedValue) \
     500        RETURNTYPE unexposedValue) \
    490501{ \
    491502    psS32 intX = (psS32) round((psF64)(x) - 0.5 + FLT_EPSILON); \
    … …  
    506517}
    507518
    508 #define PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(TYPE) \
    509 inline psC64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage* input, \
     519PSIMAGE_PIXEL_INTERPOLATE_FLAT(U8,psF64)
     520PSIMAGE_PIXEL_INTERPOLATE_FLAT(U16,psF64)
     521PSIMAGE_PIXEL_INTERPOLATE_FLAT(U32,psF64)
     522PSIMAGE_PIXEL_INTERPOLATE_FLAT(U64,psF64)
     523PSIMAGE_PIXEL_INTERPOLATE_FLAT(S8,psF64)
     524PSIMAGE_PIXEL_INTERPOLATE_FLAT(S16,psF64)
     525PSIMAGE_PIXEL_INTERPOLATE_FLAT(S32,psF64)
     526PSIMAGE_PIXEL_INTERPOLATE_FLAT(S64,psF64)
     527PSIMAGE_PIXEL_INTERPOLATE_FLAT(F32,psF64)
     528PSIMAGE_PIXEL_INTERPOLATE_FLAT(F64,psF64)
     529PSIMAGE_PIXEL_INTERPOLATE_FLAT(C32,psC64)
     530PSIMAGE_PIXEL_INTERPOLATE_FLAT(C64,psC64)
     531
     532#define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(TYPE, RETURNTYPE, SUFFIX, FRACFUNC) \
     533inline RETURNTYPE p_psImagePixelInterpolateBILINEAR_##SUFFIX( \
     534        const psImage* input, \
    510535        float x, \
    511536        float y, \
    512537        const psImage* mask, \
    513538        psU32 maskVal, \
    514         psC64 unexposedValue) \
    515 { \
    516     psS32 intX = (psS32) round((psF64)(x) - 0.5); \
    517     psS32 intY = (psS32) round((psF64)(y) - 0.5); \
    518     psS32 lastX = input->numCols - 1; \
    519     psS32 lastY = input->numRows - 1; \
    520     \
    521     if ((intX < 0) || \
    522             (intX > lastX) || \
    523             (intY < 0) || \
    524             (intY > lastY) || \
    525             ( (mask!=NULL) && \
    526               ((mask->data.PS_TYPE_MASK_DATA[intY][intX] & maskVal) != 0) ) ) { \
    527         return unexposedValue; \
    528     } \
    529     \
    530     return input->data.TYPE[intY][intX]; \
    531 }
    532 
    533 PSIMAGE_PIXEL_INTERPOLATE_FLAT(U8)
    534 PSIMAGE_PIXEL_INTERPOLATE_FLAT(U16)
    535 PSIMAGE_PIXEL_INTERPOLATE_FLAT(U32)
    536 PSIMAGE_PIXEL_INTERPOLATE_FLAT(U64)
    537 PSIMAGE_PIXEL_INTERPOLATE_FLAT(S8)
    538 PSIMAGE_PIXEL_INTERPOLATE_FLAT(S16)
    539 PSIMAGE_PIXEL_INTERPOLATE_FLAT(S32)
    540 PSIMAGE_PIXEL_INTERPOLATE_FLAT(S64)
    541 PSIMAGE_PIXEL_INTERPOLATE_FLAT(F32)
    542 PSIMAGE_PIXEL_INTERPOLATE_FLAT(F64)
    543 PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C32)
    544 PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C64)
    545 
    546 #define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(TYPE) \
    547 inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage* input, \
    548         float x, \
    549         float y, \
    550         const psImage* mask, \
    551         psU32 maskVal, \
    552         psF64 unexposedValue) \
     539        RETURNTYPE unexposedValue) \
    553540{ \
    554541    double floorX = floor((psF64)(x) - 0.5); \
    … …  
    597584    if (valid00 && valid10 && valid01 && valid11) { \
    598585        /* formula from the ADD */ \
    599         psF64 rx = V00 + (V10-V00)*fracX; \
    600         return (rx + (V01 + (V11 - V01) * fracX - rx) * fracY); \
     586        return V00*FRACFUNC((1.0-fracX)*(1.0-fracY)) + V10*FRACFUNC(fracX*(1.0-fracY)) + \
     587               V01*FRACFUNC(fracY*(1.0-fracX)) + V11*FRACFUNC(fracX*fracY); \
    601588    } \
    602589    \
    603590    /* OK, at least one pixel is not valid - need to do it piecemeal */ \
    604591    \
    605     psF64 V0 = 0.0; \
     592    RETURNTYPE V0 = 0.0; \
    606593    psBool valid0 = true; \
    607594    if (valid00 && valid10) { \
    608         V0 = V00*(1-fracX)+V10*fracX; \
     595        V0 = V00*FRACFUNC(1-fracX)+V10*FRACFUNC(fracX); \
    609596    } else if (valid00) { \
    610597        V0 = V00; \
    … …  
    615602    } \
    616603    \
    617     psF64 V1 = 0.0; \
     604    RETURNTYPE V1 = 0.0; \
    618605    psBool valid1 = true; \
    619606    if (valid01 && valid11) { \
    620         V1 = V01*(1-fracX)+V11*fracX; \
     607        V1 = V01*FRACFUNC(1-fracX)+V11*FRACFUNC(fracX); \
    621608    } else if (valid01) { \
    622609        V1 = V01; \
    … …  
    628615    \
    629616    if (valid0 && valid1) { \
    630         return ( V0*(1-fracY) + V1*fracY ); \
     617        return V0*FRACFUNC(1-fracY) + V1*FRACFUNC(fracY); \
    631618    } else if (valid0) { \
    632619        return V0; \
    … …  
    638625}
    639626
    640 #define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(TYPE) \
    641 inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage* input, \
    642         float x, \
    643         float y, \
    644         const psImage* mask, \
    645         psU32 maskVal, \
    646         psC64 unexposedValue) \
    647 { \
    648     double floorX = floor((psF64)(x) - 0.5); \
    649     double floorY = floor((psF64)(y) - 0.5); \
    650     psF64 fracX = x - 0.5 - floorX; \
    651     psF64 fracY = y - 0.5 - floorY; \
    652     psS32 intFloorX = (psS32) floorX; \
    653     psS32 intFloorY = (psS32) floorY; \
    654     psS32 lastX = input->numCols - 1; \
    655     psS32 lastY = input->numRows - 1; \
    656     ps##TYPE V00 = 0; \
    657     ps##TYPE V01 = 0; \
    658     ps##TYPE V10 = 0; \
    659     ps##TYPE V11 = 0; \
    660     psBool valid00 = false; \
    661     psBool valid01 = false; \
    662     psBool valid10 = false; \
    663     psBool valid11 = false; \
    664     \
    665     if (intFloorY >= 0 && intFloorY <= lastY) { \
    666         if (intFloorX >= 0 && intFloorX <= lastX) { \
    667             V00 = input->data.TYPE[intFloorY][intFloorX]; \
    668             valid00 = (mask == NULL) || \
    669                       ((mask->data.PS_TYPE_MASK_DATA[intFloorY][intFloorX] & maskVal) == 0); \
    670         } \
    671         if (intFloorX >= -1 && intFloorX < lastX) { \
    672             V10 = input->data.TYPE[intFloorY][intFloorX+1]; \
    673             valid10 = (mask == NULL) || \
    674                       ((mask->data.PS_TYPE_MASK_DATA[intFloorY][intFloorX+1] & maskVal) == 0); \
    675         } \
    676     } \
    677     if (intFloorY >= -1 && intFloorY < lastY) { \
    678         if (intFloorX >= 0 && intFloorX <= lastX) { \
    679             V01 = input->data.TYPE[intFloorY+1][intFloorX]; \
    680             valid01 = (mask == NULL) || \
    681                       ((mask->data.PS_TYPE_MASK_DATA[intFloorY+1][intFloorX] & maskVal) == 0); \
    682         } \
    683         if (intFloorX >= -1 && intFloorX < lastX) { \
    684             V11 = input->data.TYPE[intFloorY+1][intFloorX+1]; \
    685             valid11 = (mask == NULL) || \
    686                       ((mask->data.PS_TYPE_MASK_DATA[intFloorY+1][intFloorX+1] & maskVal) == 0); \
    687         } \
    688     } \
    689     \
    690     /* cover likely case of all pixels being valid */  \
    691     if (valid00 && valid10 && valid01 && valid11) { \
    692         /* formula from the ADD */ \
    693         psC64 rx = V00 + (V10-V00)*fracX; \
    694         return (rx + (V01 + (V11 - V01) * fracX - rx) * fracY); \
    695     } \
    696     \
    697     /* OK, at least one pixel is not valid - need to do it piecemeal */ \
    698     \
    699     psC64 V0 = 0; \
    700     psBool valid0 = true; \
    701     if (valid00 && valid10) { \
    702         V0 = V00*(1-fracX)+V10*fracX; \
    703     } else if (valid00) { \
    704         V0 = V00; \
    705     } else if (valid10) { \
    706         V0 = V10; \
    707     } else { \
    708         valid0 = false; \
    709     } \
    710     \
    711     psC64 V1 = 0; \
    712     psBool valid1 = true; \
    713     if (valid01 && valid11) { \
    714         V0 = V01*(1-fracX)+V11*fracX; \
    715     } else if (valid01) { \
    716         V0 = V01; \
    717     } else if (valid11) { \
    718         V0 = V11; \
    719     } else { \
    720         valid1 = false; \
    721     } \
    722     \
    723     if (valid0 && valid1) { \
    724         return ( V0*(1-fracY) + V1*fracY ); \
    725     } else if (valid0) { \
    726         return V0; \
    727     } else if (valid1) { \
    728         return V1; \
    729     } \
    730     \
    731     return unexposedValue; \
    732 }
    733 
    734 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8)
    735 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16)
    736 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32)
    737 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64)
    738 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8)
    739 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16)
    740 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32)
    741 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64)
    742 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32)
    743 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64)
    744 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C32)
    745 PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C64)
     627PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8,psF64,U8,)
     628PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16,psF64,U16,)
     629PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32,psF64,U32,)
     630PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64,psF64,U64,)
     631PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8,psF64,S8,)
     632PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16,psF64,S16,)
     633PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32,psF64,S32,)
     634PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64,psF64,S64,)
     635PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32,psF64,F32,)
     636PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64,psF64,F64,)
     637PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C32,psC64,C32,)
     638PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C64,psC64,C64,)
     639
     640// Variance Version
     641PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8,psF64,VARIANCE_U8,SQUARE)
     642PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16,psF64,VARIANCE_U16,SQUARE)
     643PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32,psF64,VARIANCE_U32,SQUARE)
     644PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64,psF64,VARIANCE_U64,SQUARE)
     645PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8,psF64,VARIANCE_S8,SQUARE)
     646PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16,psF64,VARIANCE_S16,SQUARE)
     647PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32,psF64,VARIANCE_S32,SQUARE)
     648PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64,psF64,VARIANCE_S64,SQUARE)
     649PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32,psF64,VARIANCE_F32,SQUARE)
     650PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64,psF64,VARIANCE_F64,SQUARE)
     651PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C32,psC64,VARIANCE_C32,SQUARE)
     652PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C64,psC64,VARIANCE_C64,SQUARE)

  • trunk/psLib/src/mathtypes/psImage.h

    r3442 r3446  
    1111 *  @author Ross Harman, MHPCC
    1212 *
    13  *  @version $Revision: 1.48 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2005-03-17 19:02:01 $
     13 *  @version $Revision: 1.49 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2005-03-18 02:35:14 $
    1515 *
    1616 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    191191);
    192192
    193 #define p_psImagePixelInterpolateFcns(TYPE) \
    194 inline psF64 p_psImagePixelInterpolateFLAT_##TYPE( \
     193#define PIXEL_INTERPOLATE_FCN_PROTOTYPE(SUFFIX, RETURNTYPE) \
     194inline RETURNTYPE p_psImagePixelInterpolate##SUFFIX( \
    195195        const psImage* input,          /**< input image for interpolation */ \
    196196        float x,                       /**< column location to derive value of */ \
    197197        float y,                       /**< row location ot derive value of */ \
    198198        const psImage* mask,           /**< if not NULL, the mask of the input image */ \
    199         psU32 maskVal,          /**< the mask value */ \
    200         psF64 unexposedValue           /**< return value if x,y location is not in image. */ \
    201                                                  ); \
    202 inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE( \
    203         const psImage* input,          /**< input image for interpolation */ \
    204         float x,                       /**< column location to derive value of */ \
    205         float y,                       /**< row location ot derive value of */ \
    206         const psImage* mask,           /**< if not NULL, the mask of the input image */ \
    207         psU32 maskVal,          /**< the mask value */ \
    208         psF64 unexposedValue           /**< return value if x,y location is not in image. */ \
    209                                                      );
    210 
    211 #define p_psImagePixelInterpolateComplexFcns(TYPE) \
    212 inline psC64 p_psImagePixelInterpolateFLAT_##TYPE( \
    213         const psImage* input,          /**< input image for interpolation */ \
    214         float x,                       /**< column location to derive value of */ \
    215         float y,                       /**< row location ot derive value of */ \
    216         const psImage* mask,           /**< if not NULL, the mask of the input image */ \
    217         psU32 maskVal,          /**< the mask value */ \
    218         psC64 unexposedValue           /**< return value if x,y location is not in image. */ \
    219                                                  ); \
    220 inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE( \
    221         const psImage* input,          /**< input image for interpolation */ \
    222         float x,                       /**< column location to derive value of */ \
    223         float y,                       /**< row location ot derive value of */ \
    224         const psImage* mask,           /**< if not NULL, the mask of the input image */ \
    225         psU32 maskVal,          /**< the mask value */ \
    226         psC64 unexposedValue           /**< return value if x,y location is not in image. */ \
    227                                                      );
     199        psU32 maskVal,                 /**< the mask value */ \
     200        RETURNTYPE unexposedValue      /**< return value if x,y location is not in image. */ \
     201                                                   );
     202
     203#define PIXEL_INTERPOLATE_FCNS(MODE) \
     204PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_U8,psF64)  \
     205PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_U16,psF64) \
     206PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_U32,psF64) \
     207PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_U64,psF64) \
     208PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_S8,psF64)  \
     209PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_S16,psF64) \
     210PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_S32,psF64) \
     211PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_S64,psF64) \
     212PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_F32,psF64) \
     213PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_F64,psF64) \
     214PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_C32,psC64) \
     215PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_C64,psC64)
     216
    228217#ifndef SWIG
    229 p_psImagePixelInterpolateFcns(U8)
    230 p_psImagePixelInterpolateFcns(U16)
    231 p_psImagePixelInterpolateFcns(U32)
    232 p_psImagePixelInterpolateFcns(U64)
    233 p_psImagePixelInterpolateFcns(S8)
    234 p_psImagePixelInterpolateFcns(S16)
    235 p_psImagePixelInterpolateFcns(S32)
    236 p_psImagePixelInterpolateFcns(S64)
    237 p_psImagePixelInterpolateFcns(F32)
    238 p_psImagePixelInterpolateFcns(F64)
    239 p_psImagePixelInterpolateComplexFcns(C32)
    240 p_psImagePixelInterpolateComplexFcns(C64)
     218PIXEL_INTERPOLATE_FCNS(FLAT)
     219PIXEL_INTERPOLATE_FCNS(BILINEAR)
     220PIXEL_INTERPOLATE_FCNS(BILINEAR_VARIANCE)
    241221#endif
    242222
     223#undef PIXEL_INTERPOLATE_FCN_PROTOTYPE
     224#undef PIXEL_INTERPOLATE_FCNS
     225
    243226/// @}
    244227

  • trunk/psLib/test/image/tst_psImageInterpolate.c

    r3264 r3446  
    55 * @author Eric Van Alst, MHPCC
    66 *
    7  * @version $Revision: 1.4 $
     7 * @version $Revision: 1.5 $
    88 *          $Name: not supported by cvs2svn $
    9  * @date $Date: 2005-02-17 19:26:25 $
     9 * @date $Date: 2005-03-18 02:35:15 $
    1010 *
    1111 * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2828val = (psF32)psImagePixelInterpolate(img,x,y,mask,maskval,exposed,PS_INTERPOLATE_##TYPE); \
    2929printf("returned = %.2f    expected = %.2f\n",val,expected); \
    30 if(val != expected) { \
     30if(fabsf(val-expected)>FLT_EPSILON) { \
    3131    psError(PS_ERR_UNKNOWN,true,"Return value is not as expected."); \
    3232    return 1; \

  • trunk/psLib/test/image/tst_psImageManip.c

    r3298 r3446  
    66 *  @author Robert DeSonia, MHPCC
    77 *
    8  *  @version $Revision: 1.39 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2005-02-22 19:25:53 $
     8 *  @version $Revision: 1.40 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2005-03-18 02:35:15 $
    1010 *
    1111 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    17711771    // verify that invalid interpolation mode is handled properly
    17721772    psErrorClear();
    1773     result = psImageResample(result,image,2,0);
     1773    result = psImageResample(result,image,2,-1);
    17741774
    17751775    if (result != NULL) {

  • trunk/psLib/test/image/verified/tst_psImageManip.stderr

    r3127 r3446  
    422422    Specified scale value, 0, must be a positive value.
    423423<DATE><TIME>|<HOST>|E|psImageResample (FILE:LINENO)
    424     Specified interpolation mode, 0, is unsupported.
     424    Specified interpolation mode, -1, is unsupported.
    425425<DATE><TIME>|<HOST>|E|psImageResample (FILE:LINENO)
    426426    Specified psImage type, psPtr, is not supported.
Note: See TracChangeset for help on using the changeset viewer.