Index: /trunk/psLib/src/image/psImage.c =================================================================== --- /trunk/psLib/src/image/psImage.c (revision 3445) +++ /trunk/psLib/src/image/psImage.c (revision 3446) @@ -9,6 +9,6 @@ * @author Ross Harman, MHPCC * - * @version $Revision: 1.60 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-03-17 19:02:01 $ + * @version $Revision: 1.61 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-03-18 02:35:14 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -26,4 +26,8 @@ #include "psImageErrors.h" + +#define SQUARE(x) ((x)*(x)) +#define MIN(x,y) (((x) > (y)) ? (y) : (x)) +#define MAX(x,y) (((x) > (y)) ? (x) : (y)) static void imageFree(psImage* image) @@ -116,6 +120,4 @@ } - - psRegion* psRegionFromString(char* region) { @@ -165,5 +167,4 @@ return psStringCopy(tmpText); } - psImage* psImageRecycle(psImage* old, @@ -428,5 +429,5 @@ } - #define PSIMAGE_PIXEL_INTERPOLATE_CASE(TYPE) \ + #define PSIMAGE_PIXEL_INTERPOLATE_CASE(TYPE) \ case PS_TYPE_##TYPE: \ switch (mode) { \ @@ -449,4 +450,13 @@ unexposedValue); \ break; \ + case PS_INTERPOLATE_BILINEAR_VARIANCE: \ + return p_psImagePixelInterpolateBILINEAR_VARIANCE_##TYPE( \ + input, \ + x, \ + y, \ + mask, \ + maskVal, \ + unexposedValue); \ + break; \ default: \ psError(PS_ERR_BAD_PARAMETER_VALUE,true, \ @@ -454,5 +464,5 @@ mode); \ } \ - break + break; switch (input->type.type) { @@ -481,11 +491,12 @@ } -#define PSIMAGE_PIXEL_INTERPOLATE_FLAT(TYPE) \ -inline psF64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage* input, \ +#define PSIMAGE_PIXEL_INTERPOLATE_FLAT(TYPE,RETURNTYPE) \ +inline RETURNTYPE p_psImagePixelInterpolateFLAT_##TYPE( \ + const psImage* input, \ float x, \ float y, \ const psImage* mask, \ psU32 maskVal, \ - psF64 unexposedValue) \ + RETURNTYPE unexposedValue) \ { \ psS32 intX = (psS32) round((psF64)(x) - 0.5 + FLT_EPSILON); \ @@ -506,49 +517,25 @@ } -#define PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(TYPE) \ -inline psC64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage* input, \ +PSIMAGE_PIXEL_INTERPOLATE_FLAT(U8,psF64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(U16,psF64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(U32,psF64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(U64,psF64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(S8,psF64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(S16,psF64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(S32,psF64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(S64,psF64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(F32,psF64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(F64,psF64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(C32,psC64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(C64,psC64) + +#define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(TYPE, RETURNTYPE, SUFFIX, FRACFUNC) \ +inline RETURNTYPE p_psImagePixelInterpolateBILINEAR_##SUFFIX( \ + const psImage* input, \ float x, \ float y, \ const psImage* mask, \ psU32 maskVal, \ - psC64 unexposedValue) \ -{ \ - psS32 intX = (psS32) round((psF64)(x) - 0.5); \ - psS32 intY = (psS32) round((psF64)(y) - 0.5); \ - psS32 lastX = input->numCols - 1; \ - psS32 lastY = input->numRows - 1; \ - \ - if ((intX < 0) || \ - (intX > lastX) || \ - (intY < 0) || \ - (intY > lastY) || \ - ( (mask!=NULL) && \ - ((mask->data.PS_TYPE_MASK_DATA[intY][intX] & maskVal) != 0) ) ) { \ - return unexposedValue; \ - } \ - \ - return input->data.TYPE[intY][intX]; \ -} - -PSIMAGE_PIXEL_INTERPOLATE_FLAT(U8) -PSIMAGE_PIXEL_INTERPOLATE_FLAT(U16) -PSIMAGE_PIXEL_INTERPOLATE_FLAT(U32) -PSIMAGE_PIXEL_INTERPOLATE_FLAT(U64) -PSIMAGE_PIXEL_INTERPOLATE_FLAT(S8) -PSIMAGE_PIXEL_INTERPOLATE_FLAT(S16) -PSIMAGE_PIXEL_INTERPOLATE_FLAT(S32) -PSIMAGE_PIXEL_INTERPOLATE_FLAT(S64) -PSIMAGE_PIXEL_INTERPOLATE_FLAT(F32) -PSIMAGE_PIXEL_INTERPOLATE_FLAT(F64) -PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C32) -PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C64) - -#define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(TYPE) \ -inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage* input, \ - float x, \ - float y, \ - const psImage* mask, \ - psU32 maskVal, \ - psF64 unexposedValue) \ + RETURNTYPE unexposedValue) \ { \ double floorX = floor((psF64)(x) - 0.5); \ @@ -597,14 +584,14 @@ if (valid00 && valid10 && valid01 && valid11) { \ /* formula from the ADD */ \ - psF64 rx = V00 + (V10-V00)*fracX; \ - return (rx + (V01 + (V11 - V01) * fracX - rx) * fracY); \ + return V00*FRACFUNC((1.0-fracX)*(1.0-fracY)) + V10*FRACFUNC(fracX*(1.0-fracY)) + \ + V01*FRACFUNC(fracY*(1.0-fracX)) + V11*FRACFUNC(fracX*fracY); \ } \ \ /* OK, at least one pixel is not valid - need to do it piecemeal */ \ \ - psF64 V0 = 0.0; \ + RETURNTYPE V0 = 0.0; \ psBool valid0 = true; \ if (valid00 && valid10) { \ - V0 = V00*(1-fracX)+V10*fracX; \ + V0 = V00*FRACFUNC(1-fracX)+V10*FRACFUNC(fracX); \ } else if (valid00) { \ V0 = V00; \ @@ -615,8 +602,8 @@ } \ \ - psF64 V1 = 0.0; \ + RETURNTYPE V1 = 0.0; \ psBool valid1 = true; \ if (valid01 && valid11) { \ - V1 = V01*(1-fracX)+V11*fracX; \ + V1 = V01*FRACFUNC(1-fracX)+V11*FRACFUNC(fracX); \ } else if (valid01) { \ V1 = V01; \ @@ -628,5 +615,5 @@ \ if (valid0 && valid1) { \ - return ( V0*(1-fracY) + V1*fracY ); \ + return V0*FRACFUNC(1-fracY) + V1*FRACFUNC(fracY); \ } else if (valid0) { \ return V0; \ @@ -638,108 +625,28 @@ } -#define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(TYPE) \ -inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage* input, \ - float x, \ - float y, \ - const psImage* mask, \ - psU32 maskVal, \ - psC64 unexposedValue) \ -{ \ - double floorX = floor((psF64)(x) - 0.5); \ - double floorY = floor((psF64)(y) - 0.5); \ - psF64 fracX = x - 0.5 - floorX; \ - psF64 fracY = y - 0.5 - floorY; \ - psS32 intFloorX = (psS32) floorX; \ - psS32 intFloorY = (psS32) floorY; \ - psS32 lastX = input->numCols - 1; \ - psS32 lastY = input->numRows - 1; \ - ps##TYPE V00 = 0; \ - ps##TYPE V01 = 0; \ - ps##TYPE V10 = 0; \ - ps##TYPE V11 = 0; \ - psBool valid00 = false; \ - psBool valid01 = false; \ - psBool valid10 = false; \ - psBool valid11 = false; \ - \ - if (intFloorY >= 0 && intFloorY <= lastY) { \ - if (intFloorX >= 0 && intFloorX <= lastX) { \ - V00 = input->data.TYPE[intFloorY][intFloorX]; \ - valid00 = (mask == NULL) || \ - ((mask->data.PS_TYPE_MASK_DATA[intFloorY][intFloorX] & maskVal) == 0); \ - } \ - if (intFloorX >= -1 && intFloorX < lastX) { \ - V10 = input->data.TYPE[intFloorY][intFloorX+1]; \ - valid10 = (mask == NULL) || \ - ((mask->data.PS_TYPE_MASK_DATA[intFloorY][intFloorX+1] & maskVal) == 0); \ - } \ - } \ - if (intFloorY >= -1 && intFloorY < lastY) { \ - if (intFloorX >= 0 && intFloorX <= lastX) { \ - V01 = input->data.TYPE[intFloorY+1][intFloorX]; \ - valid01 = (mask == NULL) || \ - ((mask->data.PS_TYPE_MASK_DATA[intFloorY+1][intFloorX] & maskVal) == 0); \ - } \ - if (intFloorX >= -1 && intFloorX < lastX) { \ - V11 = input->data.TYPE[intFloorY+1][intFloorX+1]; \ - valid11 = (mask == NULL) || \ - ((mask->data.PS_TYPE_MASK_DATA[intFloorY+1][intFloorX+1] & maskVal) == 0); \ - } \ - } \ - \ - /* cover likely case of all pixels being valid */ \ - if (valid00 && valid10 && valid01 && valid11) { \ - /* formula from the ADD */ \ - psC64 rx = V00 + (V10-V00)*fracX; \ - return (rx + (V01 + (V11 - V01) * fracX - rx) * fracY); \ - } \ - \ - /* OK, at least one pixel is not valid - need to do it piecemeal */ \ - \ - psC64 V0 = 0; \ - psBool valid0 = true; \ - if (valid00 && valid10) { \ - V0 = V00*(1-fracX)+V10*fracX; \ - } else if (valid00) { \ - V0 = V00; \ - } else if (valid10) { \ - V0 = V10; \ - } else { \ - valid0 = false; \ - } \ - \ - psC64 V1 = 0; \ - psBool valid1 = true; \ - if (valid01 && valid11) { \ - V0 = V01*(1-fracX)+V11*fracX; \ - } else if (valid01) { \ - V0 = V01; \ - } else if (valid11) { \ - V0 = V11; \ - } else { \ - valid1 = false; \ - } \ - \ - if (valid0 && valid1) { \ - return ( V0*(1-fracY) + V1*fracY ); \ - } else if (valid0) { \ - return V0; \ - } else if (valid1) { \ - return V1; \ - } \ - \ - return unexposedValue; \ -} - -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C32) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C64) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8,psF64,U8,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16,psF64,U16,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32,psF64,U32,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64,psF64,U64,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8,psF64,S8,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16,psF64,S16,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32,psF64,S32,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64,psF64,S64,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32,psF64,F32,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64,psF64,F64,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C32,psC64,C32,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C64,psC64,C64,) + +// Variance Version +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8,psF64,VARIANCE_U8,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16,psF64,VARIANCE_U16,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32,psF64,VARIANCE_U32,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64,psF64,VARIANCE_U64,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8,psF64,VARIANCE_S8,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16,psF64,VARIANCE_S16,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32,psF64,VARIANCE_S32,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64,psF64,VARIANCE_S64,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32,psF64,VARIANCE_F32,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64,psF64,VARIANCE_F64,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C32,psC64,VARIANCE_C32,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C64,psC64,VARIANCE_C64,SQUARE) Index: /trunk/psLib/src/image/psImage.h =================================================================== --- /trunk/psLib/src/image/psImage.h (revision 3445) +++ /trunk/psLib/src/image/psImage.h (revision 3446) @@ -11,6 +11,6 @@ * @author Ross Harman, MHPCC * - * @version $Revision: 1.48 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-03-17 19:02:01 $ + * @version $Revision: 1.49 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-03-18 02:35:14 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -191,54 +191,37 @@ ); -#define p_psImagePixelInterpolateFcns(TYPE) \ -inline psF64 p_psImagePixelInterpolateFLAT_##TYPE( \ +#define PIXEL_INTERPOLATE_FCN_PROTOTYPE(SUFFIX, RETURNTYPE) \ +inline RETURNTYPE p_psImagePixelInterpolate##SUFFIX( \ const psImage* input, /**< input image for interpolation */ \ float x, /**< column location to derive value of */ \ float y, /**< row location ot derive value of */ \ const psImage* mask, /**< if not NULL, the mask of the input image */ \ - psU32 maskVal, /**< the mask value */ \ - psF64 unexposedValue /**< return value if x,y location is not in image. */ \ - ); \ -inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE( \ - const psImage* input, /**< input image for interpolation */ \ - float x, /**< column location to derive value of */ \ - float y, /**< row location ot derive value of */ \ - const psImage* mask, /**< if not NULL, the mask of the input image */ \ - psU32 maskVal, /**< the mask value */ \ - psF64 unexposedValue /**< return value if x,y location is not in image. */ \ - ); - -#define p_psImagePixelInterpolateComplexFcns(TYPE) \ -inline psC64 p_psImagePixelInterpolateFLAT_##TYPE( \ - const psImage* input, /**< input image for interpolation */ \ - float x, /**< column location to derive value of */ \ - float y, /**< row location ot derive value of */ \ - const psImage* mask, /**< if not NULL, the mask of the input image */ \ - psU32 maskVal, /**< the mask value */ \ - psC64 unexposedValue /**< return value if x,y location is not in image. */ \ - ); \ -inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE( \ - const psImage* input, /**< input image for interpolation */ \ - float x, /**< column location to derive value of */ \ - float y, /**< row location ot derive value of */ \ - const psImage* mask, /**< if not NULL, the mask of the input image */ \ - psU32 maskVal, /**< the mask value */ \ - psC64 unexposedValue /**< return value if x,y location is not in image. */ \ - ); + psU32 maskVal, /**< the mask value */ \ + RETURNTYPE unexposedValue /**< return value if x,y location is not in image. */ \ + ); + +#define PIXEL_INTERPOLATE_FCNS(MODE) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_U8,psF64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_U16,psF64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_U32,psF64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_U64,psF64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_S8,psF64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_S16,psF64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_S32,psF64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_S64,psF64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_F32,psF64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_F64,psF64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_C32,psC64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_C64,psC64) + #ifndef SWIG -p_psImagePixelInterpolateFcns(U8) -p_psImagePixelInterpolateFcns(U16) -p_psImagePixelInterpolateFcns(U32) -p_psImagePixelInterpolateFcns(U64) -p_psImagePixelInterpolateFcns(S8) -p_psImagePixelInterpolateFcns(S16) -p_psImagePixelInterpolateFcns(S32) -p_psImagePixelInterpolateFcns(S64) -p_psImagePixelInterpolateFcns(F32) -p_psImagePixelInterpolateFcns(F64) -p_psImagePixelInterpolateComplexFcns(C32) -p_psImagePixelInterpolateComplexFcns(C64) +PIXEL_INTERPOLATE_FCNS(FLAT) +PIXEL_INTERPOLATE_FCNS(BILINEAR) +PIXEL_INTERPOLATE_FCNS(BILINEAR_VARIANCE) #endif +#undef PIXEL_INTERPOLATE_FCN_PROTOTYPE +#undef PIXEL_INTERPOLATE_FCNS + /// @} Index: /trunk/psLib/src/image/psImageManip.c =================================================================== --- /trunk/psLib/src/image/psImageManip.c (revision 3445) +++ /trunk/psLib/src/image/psImageManip.c (revision 3446) @@ -10,6 +10,6 @@ * @author Ross Harman, MHPCC * - * @version $Revision: 1.36 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-02-17 19:26:24 $ + * @version $Revision: 1.37 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-03-18 02:35:14 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -941,4 +941,5 @@ PSIMAGE_ROTATE_ARBITRARY_CASE(FLAT); PSIMAGE_ROTATE_ARBITRARY_CASE(BILINEAR); + PSIMAGE_ROTATE_ARBITRARY_CASE(BILINEAR_VARIANCE); default: psError(PS_ERR_BAD_PARAMETER_VALUE, true, @@ -1037,4 +1038,5 @@ PSIMAGE_SHIFT_ARBITRARY_CASE(FLAT); PSIMAGE_SHIFT_ARBITRARY_CASE(BILINEAR); + PSIMAGE_SHIFT_ARBITRARY_CASE(BILINEAR_VARIANCE); default: psError(PS_ERR_BAD_PARAMETER_VALUE, true, Index: /trunk/psLib/src/mathtypes/psImage.c =================================================================== --- /trunk/psLib/src/mathtypes/psImage.c (revision 3445) +++ /trunk/psLib/src/mathtypes/psImage.c (revision 3446) @@ -9,6 +9,6 @@ * @author Ross Harman, MHPCC * - * @version $Revision: 1.60 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-03-17 19:02:01 $ + * @version $Revision: 1.61 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-03-18 02:35:14 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -26,4 +26,8 @@ #include "psImageErrors.h" + +#define SQUARE(x) ((x)*(x)) +#define MIN(x,y) (((x) > (y)) ? (y) : (x)) +#define MAX(x,y) (((x) > (y)) ? (x) : (y)) static void imageFree(psImage* image) @@ -116,6 +120,4 @@ } - - psRegion* psRegionFromString(char* region) { @@ -165,5 +167,4 @@ return psStringCopy(tmpText); } - psImage* psImageRecycle(psImage* old, @@ -428,5 +429,5 @@ } - #define PSIMAGE_PIXEL_INTERPOLATE_CASE(TYPE) \ + #define PSIMAGE_PIXEL_INTERPOLATE_CASE(TYPE) \ case PS_TYPE_##TYPE: \ switch (mode) { \ @@ -449,4 +450,13 @@ unexposedValue); \ break; \ + case PS_INTERPOLATE_BILINEAR_VARIANCE: \ + return p_psImagePixelInterpolateBILINEAR_VARIANCE_##TYPE( \ + input, \ + x, \ + y, \ + mask, \ + maskVal, \ + unexposedValue); \ + break; \ default: \ psError(PS_ERR_BAD_PARAMETER_VALUE,true, \ @@ -454,5 +464,5 @@ mode); \ } \ - break + break; switch (input->type.type) { @@ -481,11 +491,12 @@ } -#define PSIMAGE_PIXEL_INTERPOLATE_FLAT(TYPE) \ -inline psF64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage* input, \ +#define PSIMAGE_PIXEL_INTERPOLATE_FLAT(TYPE,RETURNTYPE) \ +inline RETURNTYPE p_psImagePixelInterpolateFLAT_##TYPE( \ + const psImage* input, \ float x, \ float y, \ const psImage* mask, \ psU32 maskVal, \ - psF64 unexposedValue) \ + RETURNTYPE unexposedValue) \ { \ psS32 intX = (psS32) round((psF64)(x) - 0.5 + FLT_EPSILON); \ @@ -506,49 +517,25 @@ } -#define PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(TYPE) \ -inline psC64 p_psImagePixelInterpolateFLAT_##TYPE(const psImage* input, \ +PSIMAGE_PIXEL_INTERPOLATE_FLAT(U8,psF64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(U16,psF64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(U32,psF64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(U64,psF64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(S8,psF64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(S16,psF64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(S32,psF64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(S64,psF64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(F32,psF64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(F64,psF64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(C32,psC64) +PSIMAGE_PIXEL_INTERPOLATE_FLAT(C64,psC64) + +#define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(TYPE, RETURNTYPE, SUFFIX, FRACFUNC) \ +inline RETURNTYPE p_psImagePixelInterpolateBILINEAR_##SUFFIX( \ + const psImage* input, \ float x, \ float y, \ const psImage* mask, \ psU32 maskVal, \ - psC64 unexposedValue) \ -{ \ - psS32 intX = (psS32) round((psF64)(x) - 0.5); \ - psS32 intY = (psS32) round((psF64)(y) - 0.5); \ - psS32 lastX = input->numCols - 1; \ - psS32 lastY = input->numRows - 1; \ - \ - if ((intX < 0) || \ - (intX > lastX) || \ - (intY < 0) || \ - (intY > lastY) || \ - ( (mask!=NULL) && \ - ((mask->data.PS_TYPE_MASK_DATA[intY][intX] & maskVal) != 0) ) ) { \ - return unexposedValue; \ - } \ - \ - return input->data.TYPE[intY][intX]; \ -} - -PSIMAGE_PIXEL_INTERPOLATE_FLAT(U8) -PSIMAGE_PIXEL_INTERPOLATE_FLAT(U16) -PSIMAGE_PIXEL_INTERPOLATE_FLAT(U32) -PSIMAGE_PIXEL_INTERPOLATE_FLAT(U64) -PSIMAGE_PIXEL_INTERPOLATE_FLAT(S8) -PSIMAGE_PIXEL_INTERPOLATE_FLAT(S16) -PSIMAGE_PIXEL_INTERPOLATE_FLAT(S32) -PSIMAGE_PIXEL_INTERPOLATE_FLAT(S64) -PSIMAGE_PIXEL_INTERPOLATE_FLAT(F32) -PSIMAGE_PIXEL_INTERPOLATE_FLAT(F64) -PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C32) -PSIMAGE_PIXEL_INTERPOLATE_FLAT_COMPLEX(C64) - -#define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(TYPE) \ -inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage* input, \ - float x, \ - float y, \ - const psImage* mask, \ - psU32 maskVal, \ - psF64 unexposedValue) \ + RETURNTYPE unexposedValue) \ { \ double floorX = floor((psF64)(x) - 0.5); \ @@ -597,14 +584,14 @@ if (valid00 && valid10 && valid01 && valid11) { \ /* formula from the ADD */ \ - psF64 rx = V00 + (V10-V00)*fracX; \ - return (rx + (V01 + (V11 - V01) * fracX - rx) * fracY); \ + return V00*FRACFUNC((1.0-fracX)*(1.0-fracY)) + V10*FRACFUNC(fracX*(1.0-fracY)) + \ + V01*FRACFUNC(fracY*(1.0-fracX)) + V11*FRACFUNC(fracX*fracY); \ } \ \ /* OK, at least one pixel is not valid - need to do it piecemeal */ \ \ - psF64 V0 = 0.0; \ + RETURNTYPE V0 = 0.0; \ psBool valid0 = true; \ if (valid00 && valid10) { \ - V0 = V00*(1-fracX)+V10*fracX; \ + V0 = V00*FRACFUNC(1-fracX)+V10*FRACFUNC(fracX); \ } else if (valid00) { \ V0 = V00; \ @@ -615,8 +602,8 @@ } \ \ - psF64 V1 = 0.0; \ + RETURNTYPE V1 = 0.0; \ psBool valid1 = true; \ if (valid01 && valid11) { \ - V1 = V01*(1-fracX)+V11*fracX; \ + V1 = V01*FRACFUNC(1-fracX)+V11*FRACFUNC(fracX); \ } else if (valid01) { \ V1 = V01; \ @@ -628,5 +615,5 @@ \ if (valid0 && valid1) { \ - return ( V0*(1-fracY) + V1*fracY ); \ + return V0*FRACFUNC(1-fracY) + V1*FRACFUNC(fracY); \ } else if (valid0) { \ return V0; \ @@ -638,108 +625,28 @@ } -#define PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(TYPE) \ -inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE(const psImage* input, \ - float x, \ - float y, \ - const psImage* mask, \ - psU32 maskVal, \ - psC64 unexposedValue) \ -{ \ - double floorX = floor((psF64)(x) - 0.5); \ - double floorY = floor((psF64)(y) - 0.5); \ - psF64 fracX = x - 0.5 - floorX; \ - psF64 fracY = y - 0.5 - floorY; \ - psS32 intFloorX = (psS32) floorX; \ - psS32 intFloorY = (psS32) floorY; \ - psS32 lastX = input->numCols - 1; \ - psS32 lastY = input->numRows - 1; \ - ps##TYPE V00 = 0; \ - ps##TYPE V01 = 0; \ - ps##TYPE V10 = 0; \ - ps##TYPE V11 = 0; \ - psBool valid00 = false; \ - psBool valid01 = false; \ - psBool valid10 = false; \ - psBool valid11 = false; \ - \ - if (intFloorY >= 0 && intFloorY <= lastY) { \ - if (intFloorX >= 0 && intFloorX <= lastX) { \ - V00 = input->data.TYPE[intFloorY][intFloorX]; \ - valid00 = (mask == NULL) || \ - ((mask->data.PS_TYPE_MASK_DATA[intFloorY][intFloorX] & maskVal) == 0); \ - } \ - if (intFloorX >= -1 && intFloorX < lastX) { \ - V10 = input->data.TYPE[intFloorY][intFloorX+1]; \ - valid10 = (mask == NULL) || \ - ((mask->data.PS_TYPE_MASK_DATA[intFloorY][intFloorX+1] & maskVal) == 0); \ - } \ - } \ - if (intFloorY >= -1 && intFloorY < lastY) { \ - if (intFloorX >= 0 && intFloorX <= lastX) { \ - V01 = input->data.TYPE[intFloorY+1][intFloorX]; \ - valid01 = (mask == NULL) || \ - ((mask->data.PS_TYPE_MASK_DATA[intFloorY+1][intFloorX] & maskVal) == 0); \ - } \ - if (intFloorX >= -1 && intFloorX < lastX) { \ - V11 = input->data.TYPE[intFloorY+1][intFloorX+1]; \ - valid11 = (mask == NULL) || \ - ((mask->data.PS_TYPE_MASK_DATA[intFloorY+1][intFloorX+1] & maskVal) == 0); \ - } \ - } \ - \ - /* cover likely case of all pixels being valid */ \ - if (valid00 && valid10 && valid01 && valid11) { \ - /* formula from the ADD */ \ - psC64 rx = V00 + (V10-V00)*fracX; \ - return (rx + (V01 + (V11 - V01) * fracX - rx) * fracY); \ - } \ - \ - /* OK, at least one pixel is not valid - need to do it piecemeal */ \ - \ - psC64 V0 = 0; \ - psBool valid0 = true; \ - if (valid00 && valid10) { \ - V0 = V00*(1-fracX)+V10*fracX; \ - } else if (valid00) { \ - V0 = V00; \ - } else if (valid10) { \ - V0 = V10; \ - } else { \ - valid0 = false; \ - } \ - \ - psC64 V1 = 0; \ - psBool valid1 = true; \ - if (valid01 && valid11) { \ - V0 = V01*(1-fracX)+V11*fracX; \ - } else if (valid01) { \ - V0 = V01; \ - } else if (valid11) { \ - V0 = V11; \ - } else { \ - valid1 = false; \ - } \ - \ - if (valid0 && valid1) { \ - return ( V0*(1-fracY) + V1*fracY ); \ - } else if (valid0) { \ - return V0; \ - } else if (valid1) { \ - return V1; \ - } \ - \ - return unexposedValue; \ -} - -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C32) -PSIMAGE_PIXEL_INTERPOLATE_BILINEAR_COMPLEX(C64) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8,psF64,U8,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16,psF64,U16,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32,psF64,U32,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64,psF64,U64,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8,psF64,S8,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16,psF64,S16,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32,psF64,S32,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64,psF64,S64,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32,psF64,F32,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64,psF64,F64,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C32,psC64,C32,) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C64,psC64,C64,) + +// Variance Version +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8,psF64,VARIANCE_U8,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U16,psF64,VARIANCE_U16,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U32,psF64,VARIANCE_U32,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U64,psF64,VARIANCE_U64,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S8,psF64,VARIANCE_S8,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S16,psF64,VARIANCE_S16,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S32,psF64,VARIANCE_S32,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(S64,psF64,VARIANCE_S64,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F32,psF64,VARIANCE_F32,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(F64,psF64,VARIANCE_F64,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C32,psC64,VARIANCE_C32,SQUARE) +PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C64,psC64,VARIANCE_C64,SQUARE) Index: /trunk/psLib/src/mathtypes/psImage.h =================================================================== --- /trunk/psLib/src/mathtypes/psImage.h (revision 3445) +++ /trunk/psLib/src/mathtypes/psImage.h (revision 3446) @@ -11,6 +11,6 @@ * @author Ross Harman, MHPCC * - * @version $Revision: 1.48 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-03-17 19:02:01 $ + * @version $Revision: 1.49 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-03-18 02:35:14 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -191,54 +191,37 @@ ); -#define p_psImagePixelInterpolateFcns(TYPE) \ -inline psF64 p_psImagePixelInterpolateFLAT_##TYPE( \ +#define PIXEL_INTERPOLATE_FCN_PROTOTYPE(SUFFIX, RETURNTYPE) \ +inline RETURNTYPE p_psImagePixelInterpolate##SUFFIX( \ const psImage* input, /**< input image for interpolation */ \ float x, /**< column location to derive value of */ \ float y, /**< row location ot derive value of */ \ const psImage* mask, /**< if not NULL, the mask of the input image */ \ - psU32 maskVal, /**< the mask value */ \ - psF64 unexposedValue /**< return value if x,y location is not in image. */ \ - ); \ -inline psF64 p_psImagePixelInterpolateBILINEAR_##TYPE( \ - const psImage* input, /**< input image for interpolation */ \ - float x, /**< column location to derive value of */ \ - float y, /**< row location ot derive value of */ \ - const psImage* mask, /**< if not NULL, the mask of the input image */ \ - psU32 maskVal, /**< the mask value */ \ - psF64 unexposedValue /**< return value if x,y location is not in image. */ \ - ); - -#define p_psImagePixelInterpolateComplexFcns(TYPE) \ -inline psC64 p_psImagePixelInterpolateFLAT_##TYPE( \ - const psImage* input, /**< input image for interpolation */ \ - float x, /**< column location to derive value of */ \ - float y, /**< row location ot derive value of */ \ - const psImage* mask, /**< if not NULL, the mask of the input image */ \ - psU32 maskVal, /**< the mask value */ \ - psC64 unexposedValue /**< return value if x,y location is not in image. */ \ - ); \ -inline psC64 p_psImagePixelInterpolateBILINEAR_##TYPE( \ - const psImage* input, /**< input image for interpolation */ \ - float x, /**< column location to derive value of */ \ - float y, /**< row location ot derive value of */ \ - const psImage* mask, /**< if not NULL, the mask of the input image */ \ - psU32 maskVal, /**< the mask value */ \ - psC64 unexposedValue /**< return value if x,y location is not in image. */ \ - ); + psU32 maskVal, /**< the mask value */ \ + RETURNTYPE unexposedValue /**< return value if x,y location is not in image. */ \ + ); + +#define PIXEL_INTERPOLATE_FCNS(MODE) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_U8,psF64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_U16,psF64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_U32,psF64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_U64,psF64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_S8,psF64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_S16,psF64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_S32,psF64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_S64,psF64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_F32,psF64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_F64,psF64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_C32,psC64) \ +PIXEL_INTERPOLATE_FCN_PROTOTYPE(MODE##_C64,psC64) + #ifndef SWIG -p_psImagePixelInterpolateFcns(U8) -p_psImagePixelInterpolateFcns(U16) -p_psImagePixelInterpolateFcns(U32) -p_psImagePixelInterpolateFcns(U64) -p_psImagePixelInterpolateFcns(S8) -p_psImagePixelInterpolateFcns(S16) -p_psImagePixelInterpolateFcns(S32) -p_psImagePixelInterpolateFcns(S64) -p_psImagePixelInterpolateFcns(F32) -p_psImagePixelInterpolateFcns(F64) -p_psImagePixelInterpolateComplexFcns(C32) -p_psImagePixelInterpolateComplexFcns(C64) +PIXEL_INTERPOLATE_FCNS(FLAT) +PIXEL_INTERPOLATE_FCNS(BILINEAR) +PIXEL_INTERPOLATE_FCNS(BILINEAR_VARIANCE) #endif +#undef PIXEL_INTERPOLATE_FCN_PROTOTYPE +#undef PIXEL_INTERPOLATE_FCNS + /// @} Index: /trunk/psLib/test/image/tst_psImageInterpolate.c =================================================================== --- /trunk/psLib/test/image/tst_psImageInterpolate.c (revision 3445) +++ /trunk/psLib/test/image/tst_psImageInterpolate.c (revision 3446) @@ -5,7 +5,7 @@ * @author Eric Van Alst, MHPCC * - * @version $Revision: 1.4 $ + * @version $Revision: 1.5 $ * $Name: not supported by cvs2svn $ - * @date $Date: 2005-02-17 19:26:25 $ + * @date $Date: 2005-03-18 02:35:15 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -28,5 +28,5 @@ val = (psF32)psImagePixelInterpolate(img,x,y,mask,maskval,exposed,PS_INTERPOLATE_##TYPE); \ printf("returned = %.2f expected = %.2f\n",val,expected); \ -if(val != expected) { \ +if(fabsf(val-expected)>FLT_EPSILON) { \ psError(PS_ERR_UNKNOWN,true,"Return value is not as expected."); \ return 1; \ Index: /trunk/psLib/test/image/tst_psImageManip.c =================================================================== --- /trunk/psLib/test/image/tst_psImageManip.c (revision 3445) +++ /trunk/psLib/test/image/tst_psImageManip.c (revision 3446) @@ -6,6 +6,6 @@ * @author Robert DeSonia, MHPCC * - * @version $Revision: 1.39 $ $Name: not supported by cvs2svn $ - * @date $Date: 2005-02-22 19:25:53 $ + * @version $Revision: 1.40 $ $Name: not supported by cvs2svn $ + * @date $Date: 2005-03-18 02:35:15 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -1771,5 +1771,5 @@ // verify that invalid interpolation mode is handled properly psErrorClear(); - result = psImageResample(result,image,2,0); + result = psImageResample(result,image,2,-1); if (result != NULL) { Index: /trunk/psLib/test/image/verified/tst_psImageManip.stderr =================================================================== --- /trunk/psLib/test/image/verified/tst_psImageManip.stderr (revision 3445) +++ /trunk/psLib/test/image/verified/tst_psImageManip.stderr (revision 3446) @@ -422,5 +422,5 @@ Specified scale value, 0, must be a positive value.