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 <stdio.h>
+#include <string.h>
+#include <pslib.h>
+
+#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();
+}