Index: trunk/psLib/src/image/psImage.c
===================================================================
--- trunk/psLib/src/image/psImage.c	(revision 3682)
+++ trunk/psLib/src/image/psImage.c	(revision 3702)
@@ -9,6 +9,6 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.63 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-04-07 20:27:41 $
+ *  @version $Revision: 1.64 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-04-15 00:12:08 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -197,5 +197,5 @@
 }
 
-psImage* psImageCopy(psImage* restrict output,
+psImage* psImageCopy(psImage* output,
                      const psImage* input,
                      psElemType type)
@@ -350,4 +350,142 @@
     return output;
 }
+
+bool p_psImageCopyToRawBuffer(void* buffer,
+                              const psImage* input,
+                              psElemType type)
+{
+    psElemType inDatatype;
+    psS32 numRows;
+    psS32 numCols;
+
+    if (input == NULL || input->data.V == NULL) {
+        psError(PS_ERR_BAD_PARAMETER_NULL, true,
+                PS_ERRORTEXT_psImage_IMAGE_NULL);
+        return false;
+    }
+
+    if (input->type.dimen != PS_DIMEN_IMAGE) {
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                PS_ERRORTEXT_psImage_NOT_AN_IMAGE);
+        return false;
+    }
+
+    inDatatype = input->type.type;
+    numRows = input->numRows;
+    numCols = input->numCols;
+
+    // cover the trival case of copy of the same
+    // datatype.
+    if (type == inDatatype) {
+        int rowSize = PSELEMTYPE_SIZEOF(inDatatype)*numCols;
+        for (psS32 row=0;row<numRows;row++) {
+            memcpy(&((psS8*)buffer)[row*rowSize], input->data.V[row], rowSize);
+        }
+        return true;
+    }
+
+    #define PSIMAGE_BUFFER_COPY(INTYPE,OUTTYPE) { \
+        ps##INTYPE *in; \
+        ps##OUTTYPE *out = buffer; \
+        for(psS32 row=0;row<numRows;row++) { \
+            in = input->data.INTYPE[row]; \
+            for (psS32 col=0;col<numCols;col++) { \
+                *(out++) = *(in++); \
+            } \
+        } \
+    }
+
+    #define PSIMAGE_BUFFER_COPY_CASE(OUT,OUTTYPE) { \
+        switch (inDatatype) { \
+        case PS_TYPE_S8: \
+            PSIMAGE_BUFFER_COPY(S8,OUTTYPE); \
+            break; \
+        case PS_TYPE_S16: \
+            PSIMAGE_BUFFER_COPY(S16,OUTTYPE); \
+            break; \
+        case PS_TYPE_S32: \
+            PSIMAGE_BUFFER_COPY(S32,OUTTYPE); \
+            break; \
+        case PS_TYPE_S64: \
+            PSIMAGE_BUFFER_COPY(S64,OUTTYPE); \
+            break; \
+        case PS_TYPE_U8: \
+            PSIMAGE_BUFFER_COPY(U8,OUTTYPE); \
+            break; \
+        case PS_TYPE_U16: \
+            PSIMAGE_BUFFER_COPY(U16,OUTTYPE); \
+            break; \
+        case PS_TYPE_U32: \
+            PSIMAGE_BUFFER_COPY(U32,OUTTYPE); \
+            break; \
+        case PS_TYPE_U64: \
+            PSIMAGE_BUFFER_COPY(U64,OUTTYPE); \
+            break; \
+        case PS_TYPE_F32: \
+            PSIMAGE_BUFFER_COPY(F32,OUTTYPE); \
+            break; \
+        case PS_TYPE_F64: \
+            PSIMAGE_BUFFER_COPY(F64,OUTTYPE); \
+            break; \
+        case PS_TYPE_C32: \
+            PSIMAGE_BUFFER_COPY(C32,OUTTYPE); \
+            break; \
+        case PS_TYPE_C64: \
+            PSIMAGE_BUFFER_COPY(C64,OUTTYPE); \
+            break; \
+        default: \
+            break; \
+        } \
+    }
+
+    switch (type) {
+    case PS_TYPE_S8:
+        PSIMAGE_BUFFER_COPY_CASE(output, S8);
+        break;
+    case PS_TYPE_S16:
+        PSIMAGE_BUFFER_COPY_CASE(output, S16);
+        break;
+    case PS_TYPE_S32:
+        PSIMAGE_BUFFER_COPY_CASE(output, S32);
+        break;
+    case PS_TYPE_S64:
+        PSIMAGE_BUFFER_COPY_CASE(output, S64);
+        break;
+    case PS_TYPE_U8:
+        PSIMAGE_BUFFER_COPY_CASE(output, U8);
+        break;
+    case PS_TYPE_U16:
+        PSIMAGE_BUFFER_COPY_CASE(output, U16);
+        break;
+    case PS_TYPE_U32:
+        PSIMAGE_BUFFER_COPY_CASE(output, U32);
+        break;
+    case PS_TYPE_U64:
+        PSIMAGE_BUFFER_COPY_CASE(output, U64);
+        break;
+    case PS_TYPE_F32:
+        PSIMAGE_BUFFER_COPY_CASE(output, F32);
+        break;
+    case PS_TYPE_F64:
+        PSIMAGE_BUFFER_COPY_CASE(output, F64);
+        break;
+    case PS_TYPE_C32:
+        PSIMAGE_BUFFER_COPY_CASE(output, C32);
+        break;
+    case PS_TYPE_C64:
+        PSIMAGE_BUFFER_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);
+            break;
+        }
+    }
+    return true;
+}
+
 
 psS32 psImageFreeChildren(psImage* image)