Index: /trunk/psLib/src/imageops/psImageGeomManip.c =================================================================== --- /trunk/psLib/src/imageops/psImageGeomManip.c (revision 9862) +++ /trunk/psLib/src/imageops/psImageGeomManip.c (revision 9863) @@ -10,6 +10,6 @@ * @author Ross Harman, MHPCC * - * @version $Revision: 1.29 $ $Name: not supported by cvs2svn $ - * @date $Date: 2006-10-24 22:52:55 $ + * @version $Revision: 1.30 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-11-06 01:58:09 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -636,10 +636,12 @@ break; \ } \ + /* XXX output(i,j) = input(i+0.5-dx,j+0.5-dy) */ \ for (psS32 row=0;rowdata.TYPE[row]; \ - float y = dy+(float)row; \ + float y = row + 0.5 - dy; \ for (psS32 col=0;colnumCols - 1; \ psS32 lastY = input->numRows - 1; \ @@ -776,26 +783,26 @@ psBool valid11 = false; \ \ - if (intFloorY >= 0 && intFloorY <= lastY) { \ - if (intFloorX >= 0 && intFloorX <= lastX) { \ - V00 = input->data.TYPE[intFloorY][intFloorX]; \ + if (floorY >= 0 && floorY <= lastY) { \ + if (floorX >= 0 && floorX <= lastX) { \ + V00 = input->data.TYPE[floorY][floorX]; \ valid00 = (mask == NULL) || \ - ((mask->data.PS_TYPE_MASK_DATA[intFloorY][intFloorX] & maskVal) == 0); \ + ((mask->data.PS_TYPE_MASK_DATA[floorY][floorX] & maskVal) == 0); \ } \ - if (intFloorX >= -1 && intFloorX < lastX) { \ - V10 = input->data.TYPE[intFloorY][intFloorX+1]; \ + if (floorX >= -1 && floorX < lastX) { \ + V10 = input->data.TYPE[floorY][floorX+1]; \ valid10 = (mask == NULL) || \ - ((mask->data.PS_TYPE_MASK_DATA[intFloorY][intFloorX+1] & maskVal) == 0); \ + ((mask->data.PS_TYPE_MASK_DATA[floorY][floorX+1] & maskVal) == 0); \ } \ } \ - if (intFloorY >= -1 && intFloorY < lastY) { \ - if (intFloorX >= 0 && intFloorX <= lastX) { \ - V01 = input->data.TYPE[intFloorY+1][intFloorX]; \ + if (floorY >= -1 && floorY < lastY) { \ + if (floorX >= 0 && floorX <= lastX) { \ + V01 = input->data.TYPE[floorY+1][floorX]; \ valid01 = (mask == NULL) || \ - ((mask->data.PS_TYPE_MASK_DATA[intFloorY+1][intFloorX] & maskVal) == 0); \ + ((mask->data.PS_TYPE_MASK_DATA[floorY+1][floorX] & maskVal) == 0); \ } \ - if (intFloorX >= -1 && intFloorX < lastX) { \ - V11 = input->data.TYPE[intFloorY+1][intFloorX+1]; \ + if (floorX >= -1 && floorX < lastX) { \ + V11 = input->data.TYPE[floorY+1][floorX+1]; \ valid11 = (mask == NULL) || \ - ((mask->data.PS_TYPE_MASK_DATA[intFloorY+1][intFloorX+1] & maskVal) == 0); \ + ((mask->data.PS_TYPE_MASK_DATA[floorY+1][floorX+1] & maskVal) == 0); \ } \ } \ @@ -844,4 +851,66 @@ return unexposedValue; \ } + +#define PSIMAGE_PIXEL_INTERPOLATE_BICUBE(TYPE, RETURNTYPE, SUFFIX, FRACFUNC) \ +inline RETURNTYPE p_psImagePixelInterpolateBICUBE_##SUFFIX( \ + const psImage* input, \ + float x, \ + float y, \ + const psImage* mask, \ + psU32 maskVal, \ + RETURNTYPE unexposedValue) \ +{ \ + int floorX = floor(x); \ + int floorY = floor(y); \ + psF64 fracX = x - floorX - 0.5; \ + psF64 fracY = y - floorY - 0.5; \ + psS32 lastX = input->numCols - 1; \ + psS32 lastY = input->numRows - 1; \ + if (floorX < 1) return unexposedValue; \ + if (floorY < 1) return unexposedValue; \ + if (floorX >= lastX) return unexposedValue; \ + if (floorY >= lastY) return unexposedValue; \ + \ + /* XXX use care for masked and boundary pixels */ \ + psF64 Vmm = input->data.TYPE[floorY-1][floorX-1]; \ + psF64 Vom = input->data.TYPE[floorY-1][floorX+0]; \ + psF64 Vpm = input->data.TYPE[floorY-1][floorX+1]; \ + psF64 Vmo = input->data.TYPE[floorY+0][floorX-1]; \ + psF64 Voo = input->data.TYPE[floorY+0][floorX+0]; \ + psF64 Vpo = input->data.TYPE[floorY+0][floorX+1]; \ + psF64 Vmp = input->data.TYPE[floorY+1][floorX-1]; \ + psF64 Vop = input->data.TYPE[floorY+1][floorX+0]; \ + psF64 Vpp = input->data.TYPE[floorY+1][floorX+1]; \ + \ + psF64 Vxm = Vmm + Vmo + Vmp; \ + psF64 Vxp = Vpm + Vpo + Vpp; \ + psF64 Vym = Vmm + Vom + Vpm; \ + psF64 Vyp = Vmp + Vop + Vpp; \ + psF64 Vo = Vym + Vyp + Vmo + Voo + Vpo; \ + \ + psF64 Z_00 = Vo*(5.0/9.0) - (Vxp + Vxm)/3.0 - (Vyp + Vym)/3.0; \ + \ + psF64 Z_10 = (Vxp - Vxm)/6.0; \ + psF64 Z_01 = (Vyp - Vym)/6.0; \ + psF64 Z_20 = (Vxp + Vxm)/2.0 - Vo/3.0; \ + psF64 Z_02 = (Vyp + Vym)/2.0 - Vo/3.0; \ + psF64 Z_11 = (Vpp + Vmm - Vpm - Vmp)/4.0; \ + \ + psF64 value = Z_00 + Z_10*fracX + Z_01*fracY + Z_20*fracX*fracX + Z_11*fracX*fracY + Z_02*fracY*fracY; \ + return value; \ +} + +/* + fprintf (stderr, "fX: %f, fY: %f\n", fracX,fracY); \ + fprintf (stderr, "iX: %d, iY: %d\n", floorX,floorY); \ + fprintf (stderr, "Vmm: %f, Vom: %f, Vpm: %f\n", Vmm, Vom, Vpm); \ + fprintf (stderr, "Vmo: %f, Voo: %f, Vpo: %f\n", Vmo, Voo, Vpo); \ + fprintf (stderr, "Vmp: %f, Vop: %f, Vpp: %f\n", Vmp, Vop, Vpp); \ + fprintf (stderr, "Vxm: %f, Vxp: %f\n", Vxm, Vxp); \ + fprintf (stderr, "Vym: %f, Vyp: %f\n", Vym, Vyp); \ + fprintf (stderr, "Vo: %f\n", Vo); \ + fprintf (stderr, "Z_00: %f, Z_10: %f, Z_01: %f\n", Z_00, Z_10, Z_01); \ + fprintf (stderr, "Z_20: %f, Z_11: %f, Z_02: %f\n", Z_20, Z_11, Z_02); \ +*/ PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(U8,psF64,U8,) @@ -857,4 +926,17 @@ PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C32,psC64,C32,) PSIMAGE_PIXEL_INTERPOLATE_BILINEAR(C64,psC64,C64,) + +PSIMAGE_PIXEL_INTERPOLATE_BICUBE(U8,psF64,U8,) +PSIMAGE_PIXEL_INTERPOLATE_BICUBE(U16,psF64,U16,) +PSIMAGE_PIXEL_INTERPOLATE_BICUBE(U32,psF64,U32,) +PSIMAGE_PIXEL_INTERPOLATE_BICUBE(U64,psF64,U64,) +PSIMAGE_PIXEL_INTERPOLATE_BICUBE(S8,psF64,S8,) +PSIMAGE_PIXEL_INTERPOLATE_BICUBE(S16,psF64,S16,) +PSIMAGE_PIXEL_INTERPOLATE_BICUBE(S32,psF64,S32,) +PSIMAGE_PIXEL_INTERPOLATE_BICUBE(S64,psF64,S64,) +PSIMAGE_PIXEL_INTERPOLATE_BICUBE(F32,psF64,F32,) +PSIMAGE_PIXEL_INTERPOLATE_BICUBE(F64,psF64,F64,) +PSIMAGE_PIXEL_INTERPOLATE_BICUBE(C32,psC64,C32,) +PSIMAGE_PIXEL_INTERPOLATE_BICUBE(C64,psC64,C64,) // Variance Version Index: /trunk/psLib/src/mathtypes/psImage.h =================================================================== --- /trunk/psLib/src/mathtypes/psImage.h (revision 9862) +++ /trunk/psLib/src/mathtypes/psImage.h (revision 9863) @@ -11,6 +11,6 @@ * @author Ross Harman, MHPCC * - * @version $Revision: 1.80 $ $Name: not supported by cvs2svn $ - * @date $Date: 2006-06-30 02:20:06 $ + * @version $Revision: 1.81 $ $Name: not supported by cvs2svn $ + * @date $Date: 2006-11-06 01:58:10 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -34,4 +34,5 @@ PS_INTERPOLATE_FLAT, ///< 'flat' interpolation (nearest pixel) PS_INTERPOLATE_BILINEAR, ///< bi-linear interpolation + PS_INTERPOLATE_BICUBE, ///< bi-cubic interpolation with 3x3 region PS_INTERPOLATE_LANCZOS2, ///< Sinc interpolation with 4x4 pixel kernel PS_INTERPOLATE_LANCZOS3, ///< Sinc interpolation with 6x6 pixel kernel @@ -237,4 +238,5 @@ PIXEL_INTERPOLATE_FCNS(BILINEAR) PIXEL_INTERPOLATE_FCNS(BILINEAR_VARIANCE) +PIXEL_INTERPOLATE_FCNS(BICUBE) #endif // ! SWIG Index: /trunk/psLib/test/mathtypes/Makefile.am =================================================================== --- /trunk/psLib/test/mathtypes/Makefile.am (revision 9862) +++ /trunk/psLib/test/mathtypes/Makefile.am (revision 9863) @@ -1,2 +1,3 @@ + AM_CPPFLAGS = \ $(SRCINC) \ @@ -4,4 +5,5 @@ -I$(top_srcdir)/test/pstap/src \ $(PSLIB_CFLAGS) + AM_LDFLAGS = \ $(top_builddir)/src/libpslib.la \ @@ -11,5 +13,6 @@ TEST_PROGS = \ - tap_psVector + tap_psVector \ + tap_psImageInterpolate if BUILD_TESTS Index: /trunk/psLib/test/mathtypes/tap_psImageInterpolate.c =================================================================== --- /trunk/psLib/test/mathtypes/tap_psImageInterpolate.c (revision 9863) +++ /trunk/psLib/test/mathtypes/tap_psImageInterpolate.c (revision 9863) @@ -0,0 +1,235 @@ +#include +#include +#include + +#include "tap.h" +#include "pstap.h" + +int main (void) +{ + plan_tests(14); + + diag("psImageInterpolate() tests"); + + // very simple tests: no mask, bilinear mode, xramp image only + { + psMemId id = psMemGetId(); + + // generate simple image (x ramp) + psImage *image = psImageAlloc(32, 32, PS_TYPE_F32); + ok(image != NULL, "psImage successfully allocated"); + skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed"); + + for (int j = 0; j < image->numRows; j++) + { + for (int i = 0; i < image->numCols; i++) { + image->data.F32[j][i] = i + 0.5; + } + } + + // center of pixels is 0.5, 0.5 + float value; + + value = psImagePixelInterpolate (image, 2.5, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + ok_float (value, 2.5, "pixel center value - %f", value); + + value = psImagePixelInterpolate (image, 2.2, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + ok_float (value, 2.2, "coord: 2.2, 2.5, value: %f", value); + + value = psImagePixelInterpolate (image, 2.8, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + ok_float (value, 2.8, "coord: 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, 2.8, 2.2, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + ok_float (value, 2.8, "coord: 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, 2.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + ok_float (value, 2.8, "coord: 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, 0.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + ok_float (value, 0.8, "coord: 0.8, value: %f", value); + + // no extrapolation + value = psImagePixelInterpolate (image, 0.3, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + ok_float (value, 0.5, "coord: 0.3, value: %f", value); + + value = psImagePixelInterpolate (image, -0.2, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + ok_float (value, 0.5, "coord: -0.2, value: %f", value); + + skip_end(); + + psFree(image); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // very simple tests: no mask, bilinear mode, yramp image only + { + psMemId id = psMemGetId(); + + // generate simple image (x ramp) + psImage *image = psImageAlloc(32, 32, PS_TYPE_F32); + ok(image != NULL, "psImage successfully allocated"); + skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed"); + + for (int j = 0; j < image->numRows; j++) + { + for (int i = 0; i < image->numCols; i++) { + image->data.F32[j][i] = j + 0.5; + } + } + + // center of pixels is 0.5, 0.5 + float value; + + value = psImagePixelInterpolate (image, 2.5, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + ok_float (value, 2.5, "pixel center value - %f", value); + + value = psImagePixelInterpolate (image, 2.2, 2.2, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + ok_float (value, 2.2, "coord: 2.2, 2.5, value: %f", value); + + value = psImagePixelInterpolate (image, 2.5, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + ok_float (value, 2.8, "coord: 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, 2.2, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + ok_float (value, 2.8, "coord: 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, 2.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + ok_float (value, 2.8, "coord: 2.8, value: %f", value); + + skip_end(); + + psFree(image); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // very simple tests: no mask, bicube mode, xramp image only + { + psMemId id = psMemGetId(); + + // generate simple image (x ramp) + psImage *image = psImageAlloc(32, 32, PS_TYPE_F32); + ok(image != NULL, "psImage successfully allocated"); + skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed"); + + for (int j = 0; j < image->numRows; j++) + { + for (int i = 0; i < image->numCols; i++) { + image->data.F32[j][i] = i + 0.5; + } + } + + // center of pixels is 0.5, 0.5 + float value; + + value = psImagePixelInterpolate (image, 2.5, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + ok_float (value, 2.5, "coord; 2.5, 2.5, value - %f", value); + + value = psImagePixelInterpolate (image, 2.2, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + ok_float (value, 2.2, "coord: 2.2, 2.5, value: %f", value); + + value = psImagePixelInterpolate (image, 2.8, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + ok_float (value, 2.8, "coord: 2.8, 2.5, value: %f", value); + + value = psImagePixelInterpolate (image, 2.8, 2.2, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + ok_float (value, 2.8, "coord: 2.8, 2.2, value: %f", value); + + value = psImagePixelInterpolate (image, 2.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + ok_float (value, 2.8, "coord: 2.8, 2.8, value: %f", value); + + // no extrapolation: unsure of result + value = psImagePixelInterpolate (image, 0.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + ok_float (value, 0.8, "coord: 0.8, 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, 0.3, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + ok_float (value, 0.5, "coord: 0.3, 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, -0.2, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + ok_float (value, 0.5, "coord: -0.2, 2.8, value: %f", value); + + skip_end(); + + psFree(image); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // very simple tests: no mask, bilinear mode, yramp image only + { + psMemId id = psMemGetId(); + + // generate simple image (x ramp) + psImage *image = psImageAlloc(32, 32, PS_TYPE_F32); + ok(image != NULL, "psImage successfully allocated"); + skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed"); + + for (int j = 0; j < image->numRows; j++) + { + for (int i = 0; i < image->numCols; i++) { + image->data.F32[j][i] = j + 0.5; + } + } + + // center of pixels is 0.5, 0.5 + float value; + + value = psImagePixelInterpolate (image, 2.5, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + ok_float (value, 2.5, "pixel center value - %f", value); + + value = psImagePixelInterpolate (image, 2.2, 2.2, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + ok_float (value, 2.2, "coord: 2.2, 2.5, value: %f", value); + + value = psImagePixelInterpolate (image, 2.5, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + ok_float (value, 2.8, "coord: 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, 2.2, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + ok_float (value, 2.8, "coord: 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, 2.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + ok_float (value, 2.8, "coord: 2.8, value: %f", value); + + skip_end(); + + psFree(image); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // very simple tests: no mask, bilinear mode, x,y 2nd order shape + { + psMemId id = psMemGetId(); + + // generate simple image (x ramp) + psImage *image = psImageAlloc(32, 32, PS_TYPE_F32); + ok(image != NULL, "psImage successfully allocated"); + skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed"); + + for (int j = 0; j < image->numRows; j++) + { + for (int i = 0; i < image->numCols; i++) { + image->data.F32[j][i] = 0.25*PS_SQR(i + 0.5) + j + 0.5; + } + } + + // center of pixels is 0.5, 0.5 + float value; + + value = psImagePixelInterpolate (image, 2.5, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + ok_float (value, 4.0625, "pixel center value - %f", value); + + value = psImagePixelInterpolate (image, 2.2, 2.2, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + ok_float (value, 3.41, "coord: 2.2, 2.5, value: %f", value); + + value = psImagePixelInterpolate (image, 2.5, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + ok_float (value, 4.3625002, "coord: 2.5, 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, 2.2, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + ok_float (value, 4.010000229, "coord: 2.2, 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, 2.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + ok_float (value, 4.75999975, "coord: 2.8, 2.8, value: %f", value); + + skip_end(); + + psFree(image); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + return exit_status(); +}