Index: trunk/psLib/src/imageops/psImageGeomManip.c =================================================================== --- trunk/psLib/src/imageops/psImageGeomManip.c (revision 12431) +++ trunk/psLib/src/imageops/psImageGeomManip.c (revision 12741) @@ -10,6 +10,6 @@ * @author Ross Harman, MHPCC * - * @version $Revision: 1.38 $ $Name: not supported by cvs2svn $ - * @date $Date: 2007-03-14 00:39:50 $ + * @version $Revision: 1.39 $ $Name: not supported by cvs2svn $ + * @date $Date: 2007-04-04 22:42:02 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -33,5 +33,5 @@ #include "psMemory.h" #include "psAssert.h" - +#include "psImageInterpolate.h" #include "psCoord.h" @@ -200,12 +200,4 @@ } - if (mode > PS_INTERPOLATE_LANCZOS4_VARIANCE ) { - psError(PS_ERR_BAD_PARAMETER_VALUE, true, - _("Specified interpolation mode, %d, is unsupported."), - mode); - psFree(out); - return NULL; - } - // create an output image of the same size // and type @@ -213,4 +205,7 @@ outCols = in->numCols * scale; invScale = 1.0f / (float)scale; + + psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(mode, in, NULL, NULL, 0, + NAN, NAN, 0, 0, 0); #define PSIMAGE_RESAMPLE_CASE(TYPE) \ @@ -221,5 +216,12 @@ float inRow = (float)row * invScale; \ for (psS32 col=0;col PS_MAX_##TYPE || \ @@ -515,67 +523,44 @@ outRow = out->data.TYPE[y]; \ for (psS32 x = 0; x < outCols; x++) { \ - outRow[x] = p_psImagePixelInterpolate##MODE##_##TYPE(input,inX,inY,NULL,0,exposed); \ + double value; \ + if (!psImageInterpolate(&value, NULL, NULL, inX, inY, interp)) { \ + psError(PS_ERR_UNKNOWN, false, "Unable to interpolate image."); \ + psFree(out); \ + psFree(interp); \ + return NULL; \ + } \ + outRow[x] = value; \ inX += cosT; \ inY -= sinT; \ } \ } \ - } - - #define PSIMAGE_ROTATE_ARBITRARY_CASE(MODE) \ - case PS_INTERPOLATE_##MODE: \ - switch (type) { \ - case PS_TYPE_U8: \ - PSIMAGE_ROTATE_ARBITRARY_LOOP(U8,MODE); \ break; \ - case PS_TYPE_U16: \ - PSIMAGE_ROTATE_ARBITRARY_LOOP(U16,MODE); \ - break; \ - case PS_TYPE_U32: /* Not a requirement */ \ - PSIMAGE_ROTATE_ARBITRARY_LOOP(U32,MODE); \ - break; \ - case PS_TYPE_U64: /* Not a requirement */ \ - PSIMAGE_ROTATE_ARBITRARY_LOOP(U64,MODE); \ - break; \ - case PS_TYPE_S8: \ - PSIMAGE_ROTATE_ARBITRARY_LOOP(S8,MODE); \ - break; \ - case PS_TYPE_S16: \ - PSIMAGE_ROTATE_ARBITRARY_LOOP(S16,MODE); \ - break; \ - case PS_TYPE_S32: /* Not a requirement */ \ - PSIMAGE_ROTATE_ARBITRARY_LOOP(S32,MODE); \ - break; \ - case PS_TYPE_S64: /* Not a requirement */ \ - PSIMAGE_ROTATE_ARBITRARY_LOOP(S64,MODE); \ - break; \ - case PS_TYPE_F32: \ - PSIMAGE_ROTATE_ARBITRARY_LOOP(F32,MODE); \ - break; \ - case PS_TYPE_F64: \ - PSIMAGE_ROTATE_ARBITRARY_LOOP(F64,MODE); \ - break; \ - default: { \ - char* typeStr; \ - PS_TYPE_NAME(typeStr,type); \ - psError(PS_ERR_BAD_PARAMETER_TYPE, true, \ - _("Specified psImage type, %s, is not supported."), \ - typeStr); \ - psFree(out); \ - out = NULL; \ - } \ - } \ - break; - - switch (mode) { - PSIMAGE_ROTATE_ARBITRARY_CASE(FLAT); - PSIMAGE_ROTATE_ARBITRARY_CASE(BILINEAR); - PSIMAGE_ROTATE_ARBITRARY_CASE(BILINEAR_VARIANCE); - default: - psError(PS_ERR_BAD_PARAMETER_VALUE, true, - _("Specified interpolation mode, %d, is unsupported."), - mode); - psFree(out); - out = NULL; - } + } + + switch (type) { + PSIMAGE_ROTATE_ARBITRARY_LOOP(U8); + PSIMAGE_ROTATE_ARBITRARY_LOOP(U16); + PSIMAGE_ROTATE_ARBITRARY_LOOP(U32); + PSIMAGE_ROTATE_ARBITRARY_LOOP(U64); + PSIMAGE_ROTATE_ARBITRARY_LOOP(S8); + PSIMAGE_ROTATE_ARBITRARY_LOOP(S16); + PSIMAGE_ROTATE_ARBITRARY_LOOP(S32); + PSIMAGE_ROTATE_ARBITRARY_LOOP(S64); + PSIMAGE_ROTATE_ARBITRARY_LOOP(F32); + PSIMAGE_ROTATE_ARBITRARY_LOOP(F64); + default: { + char* typeStr; + PS_TYPE_NAME(typeStr,type); + psError(PS_ERR_BAD_PARAMETER_TYPE, true, + _("Specified psImage type, %s, is not supported."), + typeStr); + psFree(out); + psFree(interp); + out = NULL; + } + } + + psFree(interp); + } @@ -695,5 +680,8 @@ out = psImageRecycle(out, outCols, outRows, type); - #define PSIMAGE_SHIFT_CASE(MODE,TYPE) \ + psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(mode, input, NULL, NULL, 0, + exposed, NAN, 0, 0, 0.0); + + #define PSIMAGE_SHIFT_CASE(TYPE) \ case PS_TYPE_##TYPE: \ if (exposed < PS_MIN_##TYPE || \ @@ -719,50 +707,39 @@ for (psS32 col=0;coltype.type) { \ - PSIMAGE_SHIFT_CASE(MODE,U8); \ - PSIMAGE_SHIFT_CASE(MODE,U16); \ - PSIMAGE_SHIFT_CASE(MODE,U32); /* Not a requirement */ \ - PSIMAGE_SHIFT_CASE(MODE,U64); /* Not a requirement */ \ - PSIMAGE_SHIFT_CASE(MODE,S8); \ - PSIMAGE_SHIFT_CASE(MODE,S16); \ - PSIMAGE_SHIFT_CASE(MODE,S32); /* Not a requirement */ \ - PSIMAGE_SHIFT_CASE(MODE,S64); /* Not a requirement */ \ - PSIMAGE_SHIFT_CASE(MODE,F32); \ - PSIMAGE_SHIFT_CASE(MODE,F64); \ - \ - default: { \ - char* typeStr; \ - PS_TYPE_NAME(typeStr,type); \ - psError(PS_ERR_BAD_PARAMETER_TYPE, true, \ - _("Specified psImage type, %s, is not supported."), \ - typeStr); \ - psFree(out); \ - out = NULL; \ - } \ - } \ - break; - - // EAM: added BICUBE - switch (mode) { - PSIMAGE_SHIFT_ARBITRARY_CASE(FLAT); - PSIMAGE_SHIFT_ARBITRARY_CASE(BILINEAR); - PSIMAGE_SHIFT_ARBITRARY_CASE(BILINEAR_VARIANCE); - PSIMAGE_SHIFT_ARBITRARY_CASE(BICUBE); - default: - psError(PS_ERR_BAD_PARAMETER_VALUE, true, - _("Specified interpolation mode, %d, is unsupported."), - mode); - psFree(out); - out = NULL; - } - + switch (input->type.type) { + PSIMAGE_SHIFT_CASE(U8); + PSIMAGE_SHIFT_CASE(U16); + PSIMAGE_SHIFT_CASE(U32); + PSIMAGE_SHIFT_CASE(U64); + PSIMAGE_SHIFT_CASE(S8); + PSIMAGE_SHIFT_CASE(S16); + PSIMAGE_SHIFT_CASE(S32); + PSIMAGE_SHIFT_CASE(S64); + PSIMAGE_SHIFT_CASE(F32); + PSIMAGE_SHIFT_CASE(F64); + default: { + char* typeStr; + PS_TYPE_NAME(typeStr,type); + psError(PS_ERR_BAD_PARAMETER_TYPE, true, _("Specified psImage type, %s, is not supported."), + typeStr); + psFree(out); + psFree(interp); + return NULL; + } + } + + psFree(interp); return out; } @@ -866,10 +843,14 @@ // loop through the output image using the domain above and transform - // each output pixel to input coordinates and use psImagePixelInterpolate + // each output pixel to input coordinates and use psImageInterpolate // to determine the pixel value. psPlane outPosition; psPlane* inPosition = NULL; - #define PSIMAGE_TRANSFORM_DOTRANSFORM(TYPE,MODE) \ + psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(mode, input, NULL, inputMask, + inputMaskVal, NAN, NAN, 0, 0, 0.0); + + + #define PSIMAGE_TRANSFORM_DOTRANSFORM(TYPE) \ /* apply the transform to get the position in the input image */ \ inPosition = psPlaneTransformApply(inPosition, outToIn, &outPosition); \ @@ -882,7 +863,11 @@ } \ /* interpolate the cooresponding input pixel to get the output pixel value. */ \ - ps##TYPE value = p_psImagePixelInterpolate##MODE##_##TYPE(input, \ - inPosition->x, inPosition->y, \ - inputMask, inputMaskVal, NAN); \ + double value; \ + if (!psImageInterpolate(&value, NULL, NULL, inPosition->x, inPosition->y, interp)) { \ + psError(PS_ERR_UNKNOWN, false, "Unable to interpolate image."); \ + psFree(output); \ + psFree(interp); \ + return NULL; \ + } \ /* psFree(inPosition); */\ if (isnan(value)) { \ @@ -893,5 +878,6 @@ } \ - #define PSIMAGE_TRANSFORM_LOOP(TYPE, MODE) { \ + #define PSIMAGE_TRANSFORM_CASE(TYPE) \ + case PS_TYPE_##TYPE: { \ for (int row = 0; row < numRows; row++) { \ outPosition.y = row+row0; \ @@ -899,55 +885,23 @@ for (int col = 0; col < numCols; col++) { \ outPosition.x = col+col0; \ - PSIMAGE_TRANSFORM_DOTRANSFORM(TYPE,MODE) \ + PSIMAGE_TRANSFORM_DOTRANSFORM(TYPE) \ outputData[col] = value; \ } \ } \ - } - - #define PSIMAGE_TRANSFORM_FROMLIST(TYPE, MODE) { \ - int n = pixels->n; \ - for (int i= 0; i < n; i++) { \ - int x = pixels->data[i].x; \ - int y = pixels->data[i].y; \ - if (x >= col0 && x < col1 && y >= row0 && y < row1) { \ - outPosition.x = x; \ - outPosition.y = y; \ - PSIMAGE_TRANSFORM_DOTRANSFORM(TYPE,MODE) \ - output->data.TYPE[y][x] = value; \ - } \ - } \ - } - - #define PSIMAGE_TRANSFORM_CASE(MODE) \ -case PS_INTERPOLATE_##MODE: \ - switch (type) { \ - case PS_TYPE_F32: \ - PSIMAGE_TRANSFORM_LOOP(F32,MODE); \ break; \ - case PS_TYPE_F64: \ - PSIMAGE_TRANSFORM_LOOP(F64,MODE); \ - break; \ - default: { \ - char* typeStr; \ - PS_TYPE_NAME(typeStr,type); \ - psError(PS_ERR_BAD_PARAMETER_TYPE, true, \ - _("Specified psImage type, %s, is not supported."), \ - typeStr); \ - psFree(output); \ - return NULL; \ - } \ - } \ - break; - - switch (mode) { - PSIMAGE_TRANSFORM_CASE(FLAT); - PSIMAGE_TRANSFORM_CASE(BILINEAR); - PSIMAGE_TRANSFORM_CASE(BILINEAR_VARIANCE); - default: - psError(PS_ERR_BAD_PARAMETER_VALUE, true, - _("Specified interpolation mode, %d, is unsupported."), - mode); - psFree(output); - return NULL; + } + + switch (type) { + PSIMAGE_TRANSFORM_CASE(F32); + PSIMAGE_TRANSFORM_CASE(F64); + default: { + char* typeStr; + PS_TYPE_NAME(typeStr,type); + psError(PS_ERR_BAD_PARAMETER_TYPE, true, _("Specified psImage type, %s, is not supported."), + typeStr); + psFree(output); + psFree(inPosition); + return NULL; + } }