Index: trunk/psLib/src/image/psImage.c
===================================================================
--- trunk/psLib/src/image/psImage.c	(revision 3786)
+++ trunk/psLib/src/image/psImage.c	(revision 3977)
@@ -9,6 +9,6 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.65 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-04-29 02:25:10 $
+ *  @version $Revision: 1.66 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-05-19 05:18:20 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -91,20 +91,20 @@
 }
 
-psRegion* psRegionAlloc(psF32 x0,
-                        psF32 x1,
-                        psF32 y0,
-                        psF32 y1)
-{
-    psRegion* out = psAlloc(sizeof(psRegion));
-
-    out->x0 = x0;
-    out->y0 = y0;
-    out->x1 = x1;
-    out->y1 = y1;
+psRegion psRegionSet(psF32 x0,
+                     psF32 x1,
+                     psF32 y0,
+                     psF32 y1)
+{
+    psRegion out;
+
+    out.x0 = x0;
+    out.y0 = y0;
+    out.x1 = x1;
+    out.y1 = y1;
 
     return out;
 }
 
-psRegion* psRegionFromString(char* region)
+psRegion psRegionFromString(char* region)
 {
     psS32 col0;
@@ -117,5 +117,5 @@
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
                 PS_ERRORTEXT_psImage_SUBSECTION_NULL);
-        return NULL;
+        return psRegionSet(NAN,NAN,NAN,NAN);
     }
 
@@ -124,5 +124,5 @@
                 PS_ERRORTEXT_psImage_SUBSECTION_INVALID,
                 region);
-        return NULL;
+        return psRegionSet(NAN,NAN,NAN,NAN);
     }
 
@@ -131,23 +131,17 @@
                 PS_ERRORTEXT_psImage_SUBSET_RANGE_MALFORMED,
                 col0,col1,row0,row1);
-        return NULL;
-    }
-
-    return psRegionAlloc(col0,col1,row0,row1);
-}
-
-char* psRegionToString(psRegion* region)
+        return psRegionSet(NAN,NAN,NAN,NAN);
+    }
+
+    return psRegionSet(col0,col1,row0,row1);
+}
+
+char* psRegionToString(psRegion region)
 {
     char tmpText[256]; // big enough to store any region as text
 
-    if (region == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_REGION_NULL);
-        return NULL;
-    }
-
     snprintf(tmpText,256,"[%g:%g,%g:%g]",
-             region->x0, region->x1,
-             region->y0, region->y1);
+             region.x0, region.x1,
+             region.y0, region.y1);
 
     return psStringCopy(tmpText);
@@ -195,158 +189,4 @@
 
     return old;
-}
-
-psImage* psImageCopy(psImage* output,
-                     const psImage* input,
-                     psElemType type)
-{
-    psElemType inDatatype;
-    psS32 elementSize;
-    psS32 elements;
-    psS32 numRows;
-    psS32 numCols;
-
-    if (input == NULL || input->data.V == NULL) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_IMAGE_NULL);
-        psFree(output);
-        return NULL;
-    }
-
-    if (input == output) {
-        psError(PS_ERR_BAD_PARAMETER_NULL, true,
-                PS_ERRORTEXT_psImage_INPLACE_NOTSUPPORTED);
-        psFree(output);
-        return NULL;
-    }
-
-    if (input->type.dimen != PS_DIMEN_IMAGE) {
-        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psImage_NOT_AN_IMAGE);
-        psFree(output);
-        return NULL;
-    }
-
-    inDatatype = input->type.type;
-    numRows = input->numRows;
-    numCols = input->numCols;
-    elements = numRows * numCols;
-    elementSize = PSELEMTYPE_SIZEOF(inDatatype);
-
-    output = psImageRecycle(output, numCols, numRows, type);
-
-    // cover the trival case of copy of the same
-    // datatype.
-    if (type == inDatatype) {
-        for (psS32 row=0;row<numRows;row++) {
-            memcpy(output->data.V[row], input->data.V[row], elementSize * numCols);
-        }
-        return output;
-    }
-
-    #define PSIMAGE_ELEMENT_COPY(IN,INTYPE,OUT,OUTTYPE,ELEMENTS) { \
-        ps##INTYPE *in; \
-        ps##OUTTYPE *out; \
-        for(psS32 row=0;row<numRows;row++) { \
-            in = IN->data.INTYPE[row]; \
-            out = OUT->data.OUTTYPE[row]; \
-            for (psS32 col=0;col<numCols;col++) { \
-                *(out++) = *(in++); \
-            } \
-        } \
-    }
-
-    #define PSIMAGE_COPY_CASE(OUT,OUTTYPE) { \
-        switch (inDatatype) { \
-        case PS_TYPE_S8: \
-            PSIMAGE_ELEMENT_COPY(input,S8,OUT,OUTTYPE,elements); \
-            break; \
-        case PS_TYPE_S16: \
-            PSIMAGE_ELEMENT_COPY(input,S16,OUT,OUTTYPE,elements); \
-            break; \
-        case PS_TYPE_S32: \
-            PSIMAGE_ELEMENT_COPY(input,S32,OUT,OUTTYPE,elements); \
-            break; \
-        case PS_TYPE_S64: \
-            PSIMAGE_ELEMENT_COPY(input,S64,OUT,OUTTYPE,elements); \
-            break; \
-        case PS_TYPE_U8: \
-            PSIMAGE_ELEMENT_COPY(input,U8,OUT,OUTTYPE,elements); \
-            break; \
-        case PS_TYPE_U16: \
-            PSIMAGE_ELEMENT_COPY(input,U16,OUT,OUTTYPE,elements); \
-            break; \
-        case PS_TYPE_U32: \
-            PSIMAGE_ELEMENT_COPY(input,U32,OUT,OUTTYPE,elements); \
-            break; \
-        case PS_TYPE_U64: \
-            PSIMAGE_ELEMENT_COPY(input,U64,OUT,OUTTYPE,elements); \
-            break; \
-        case PS_TYPE_F32: \
-            PSIMAGE_ELEMENT_COPY(input,F32,OUT,OUTTYPE,elements); \
-            break; \
-        case PS_TYPE_F64: \
-            PSIMAGE_ELEMENT_COPY(input,F64,OUT,OUTTYPE,elements); \
-            break; \
-        case PS_TYPE_C32: \
-            PSIMAGE_ELEMENT_COPY(input,C32,OUT,OUTTYPE,elements); \
-            break; \
-        case PS_TYPE_C64: \
-            PSIMAGE_ELEMENT_COPY(input,C64,OUT,OUTTYPE,elements); \
-            break; \
-        default: \
-            break; \
-        } \
-    }
-
-    switch (type) {
-    case PS_TYPE_S8:
-        PSIMAGE_COPY_CASE(output, S8);
-        break;
-    case PS_TYPE_S16:
-        PSIMAGE_COPY_CASE(output, S16);
-        break;
-    case PS_TYPE_S32:
-        PSIMAGE_COPY_CASE(output, S32);
-        break;
-    case PS_TYPE_S64:
-        PSIMAGE_COPY_CASE(output, S64);
-        break;
-    case PS_TYPE_U8:
-        PSIMAGE_COPY_CASE(output, U8);
-        break;
-    case PS_TYPE_U16:
-        PSIMAGE_COPY_CASE(output, U16);
-        break;
-    case PS_TYPE_U32:
-        PSIMAGE_COPY_CASE(output, U32);
-        break;
-    case PS_TYPE_U64:
-        PSIMAGE_COPY_CASE(output, U64);
-        break;
-    case PS_TYPE_F32:
-        PSIMAGE_COPY_CASE(output, F32);
-        break;
-    case PS_TYPE_F64:
-        PSIMAGE_COPY_CASE(output, F64);
-        break;
-    case PS_TYPE_C32:
-        PSIMAGE_COPY_CASE(output, C32);
-        break;
-    case PS_TYPE_C64:
-        PSIMAGE_COPY_CASE(output, C64);
-        break;
-    default: {
-            char* typeStr;
-            PS_TYPE_NAME(typeStr,type);
-            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                    PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
-                    typeStr);
-            psFree(output);
-
-            break;
-        }
-    }
-    return output;
 }