Index: /trunk/psLib/src/astronomy/psAstrometry.c
===================================================================
--- /trunk/psLib/src/astronomy/psAstrometry.c	(revision 2066)
+++ /trunk/psLib/src/astronomy/psAstrometry.c	(revision 2067)
@@ -8,6 +8,6 @@
  *  @author George Gusciora, MHPCC
  *
- *  @version $Revision: 1.36 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-10-12 21:10:41 $
+ *  @version $Revision: 1.37 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-10-13 00:10:50 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -151,5 +151,4 @@
     if (chip != NULL) {
         psFree(chip->cells);
-        psFree(chip->parent);
         psFree(chip->metadata);
         psFree(chip->toFPA);
@@ -167,5 +166,4 @@
         psFree(cell->toFPA);
         psFree(cell->toTP);
-        psFree(cell->parent);
     }
 }
@@ -174,5 +172,4 @@
 {
     if (readout != NULL) {
-        psFree(readout->image);
         psFree(readout->mask);
         psFree(readout->objects);
@@ -407,5 +404,5 @@
     chip->fromFPA = NULL;
 
-    chip->parent = psMemIncrRefCounter(parentFPA);
+    chip->parent = parentFPA;
 
     p_psMemSetDeallocator(chip,(psFreeFcn)chipFree);
@@ -437,5 +434,5 @@
     cell->toTP = NULL;
 
-    cell->parent = psMemIncrRefCounter(parentChip);
+    cell->parent = parentChip;
 
     p_psMemSetDeallocator(cell,(psFreeFcn)cellFree);
@@ -457,5 +454,5 @@
     *(int*)&readout->row0 = row0;
 
-    readout->image = psMemIncrRefCounter((psImage*)image);
+    readout->image = (psImage*)image;
     readout->mask = NULL;
     readout->objects = NULL;
Index: /trunk/psLib/src/image/psImage.c
===================================================================
--- /trunk/psLib/src/image/psImage.c	(revision 2066)
+++ /trunk/psLib/src/image/psImage.c	(revision 2067)
@@ -10,6 +10,6 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.48 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-09-30 18:54:42 $
+ *  @version $Revision: 1.49 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-10-13 00:10:50 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -162,4 +162,171 @@
 
     return old;
+}
+
+psImage* psImageCopy(psImage* restrict output,
+                     const psImage* input,
+                     psElemType type)
+{
+    psElemType inDatatype;
+    int elementSize;
+    int elements;
+    int numRows;
+    int numCols;
+
+    if (input == NULL || input->data.V == NULL) {
+        psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
+                   PS_ERR_BAD_PARAMETER_NULL, true,
+                   PS_ERRORTEXT_psImage_IMAGE_NULL);
+        psFree(output);
+        return NULL;
+    }
+
+    if (input == output) {
+        psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
+                   PS_ERR_BAD_PARAMETER_NULL, true,
+                   PS_ERRORTEXT_psImage_INPLACE_NOTSUPPORTED);
+        psFree(output);
+        return NULL;
+    }
+
+    if (input->type.dimen != PS_DIMEN_IMAGE) {
+        psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
+                   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);
+
+    if (inDatatype == PS_TYPE_PTR || type == PS_TYPE_PTR) {
+        psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
+                   PS_ERR_BAD_PARAMETER_TYPE, true,
+                   PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                   PS_TYPE_PTR_NAME);
+        psFree(output);
+        return NULL;
+    }
+
+    output = psImageRecycle(output, numCols, numRows, type);
+
+    // cover the trival case of copy of the same
+    // datatype.
+    if (type == inDatatype) {
+        for (int 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(int row=0;row<numRows;row++) { \
+            in = IN->data.INTYPE[row]; \
+            out = OUT->data.OUTTYPE[row]; \
+            for (int 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);
+            psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
+                       PS_ERR_BAD_PARAMETER_TYPE, true,
+                       PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                       typeStr);
+            psFree(output);
+
+            break;
+        }
+    }
+    return output;
 }
 
Index: /trunk/psLib/src/image/psImage.h
===================================================================
--- /trunk/psLib/src/image/psImage.h	(revision 2066)
+++ /trunk/psLib/src/image/psImage.h	(revision 2067)
@@ -11,6 +11,6 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.39 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-09-30 21:01:09 $
+ *  @version $Revision: 1.40 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-10-13 00:10:50 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -100,4 +100,16 @@
 );
 
+/** Makes a copy of a psImage
+ *
+ * @return psImage* Copy of the input psImage.  This may not be equal to the
+ * output parameter
+ *
+ */
+psImage* psImageCopy(
+    psImage* restrict output,          ///< if not NULL, a psImage that could be recycled.
+    const psImage* input,              ///< the psImage to copy
+    psElemType type                    ///< the desired datatype of the returned copy
+);
+
 /** Frees all children of a psImage.
  *
Index: /trunk/psLib/src/image/psImageExtraction.c
===================================================================
--- /trunk/psLib/src/image/psImageExtraction.c	(revision 2066)
+++ /trunk/psLib/src/image/psImageExtraction.c	(revision 2067)
@@ -9,6 +9,6 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-10-05 22:23:04 $
+ *  @version $Revision: 1.22 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-10-13 00:10:50 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -23,5 +23,4 @@
 
 #include "psImageErrors.h"
-
 
 psImage* imageSubset(psImage* out,
@@ -236,171 +235,4 @@
 
     return (image);
-}
-
-psImage* psImageCopy(psImage* restrict output,
-                     const psImage* input,
-                     psElemType type)
-{
-    psElemType inDatatype;
-    int elementSize;
-    int elements;
-    int numRows;
-    int numCols;
-
-    if (input == NULL || input->data.V == NULL) {
-        psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
-                   PS_ERR_BAD_PARAMETER_NULL, true,
-                   PS_ERRORTEXT_psImage_IMAGE_NULL);
-        psFree(output);
-        return NULL;
-    }
-
-    if (input == output) {
-        psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
-                   PS_ERR_BAD_PARAMETER_NULL, true,
-                   PS_ERRORTEXT_psImage_INPLACE_NOTSUPPORTED);
-        psFree(output);
-        return NULL;
-    }
-
-    if (input->type.dimen != PS_DIMEN_IMAGE) {
-        psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
-                   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);
-
-    if (inDatatype == PS_TYPE_PTR || type == PS_TYPE_PTR) {
-        psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
-                   PS_ERR_BAD_PARAMETER_TYPE, true,
-                   PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
-                   PS_TYPE_PTR_NAME);
-        psFree(output);
-        return NULL;
-    }
-
-    output = psImageRecycle(output, numCols, numRows, type);
-
-    // cover the trival case of copy of the same
-    // datatype.
-    if (type == inDatatype) {
-        for (int 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(int row=0;row<numRows;row++) { \
-            in = IN->data.INTYPE[row]; \
-            out = OUT->data.OUTTYPE[row]; \
-            for (int 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);
-            psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
-                       PS_ERR_BAD_PARAMETER_TYPE, true,
-                       PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
-                       typeStr);
-            psFree(output);
-
-            break;
-        }
-    }
-    return output;
 }
 
Index: /trunk/psLib/src/image/psImageExtraction.h
===================================================================
--- /trunk/psLib/src/image/psImageExtraction.h	(revision 2066)
+++ /trunk/psLib/src/image/psImageExtraction.h	(revision 2067)
@@ -10,6 +10,6 @@
 *  @author Robert DeSonia, MHPCC
 *
-*  @version $Revision: 1.16 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-09-29 01:10:27 $
+*  @version $Revision: 1.17 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-10-13 00:10:50 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -98,17 +98,4 @@
     int row1                           ///< row of trim region's upper boundary
 );
-
-/** Makes a copy of a psImage
- *
- * @return psImage* Copy of the input psImage.  This may not be equal to the
- * output parameter
- *
- */
-psImage* psImageCopy(
-    psImage* restrict output,          ///< if not NULL, a psImage that could be recycled.
-    const psImage* input,              ///< the psImage to copy
-    psElemType type                    ///< the desired datatype of the returned copy
-);
-
 
 /** Extract pixels from rectlinear region to a vector (array of floats).
Index: /trunk/psLib/src/mathtypes/psImage.c
===================================================================
--- /trunk/psLib/src/mathtypes/psImage.c	(revision 2066)
+++ /trunk/psLib/src/mathtypes/psImage.c	(revision 2067)
@@ -10,6 +10,6 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.48 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-09-30 18:54:42 $
+ *  @version $Revision: 1.49 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-10-13 00:10:50 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -162,4 +162,171 @@
 
     return old;
+}
+
+psImage* psImageCopy(psImage* restrict output,
+                     const psImage* input,
+                     psElemType type)
+{
+    psElemType inDatatype;
+    int elementSize;
+    int elements;
+    int numRows;
+    int numCols;
+
+    if (input == NULL || input->data.V == NULL) {
+        psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
+                   PS_ERR_BAD_PARAMETER_NULL, true,
+                   PS_ERRORTEXT_psImage_IMAGE_NULL);
+        psFree(output);
+        return NULL;
+    }
+
+    if (input == output) {
+        psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
+                   PS_ERR_BAD_PARAMETER_NULL, true,
+                   PS_ERRORTEXT_psImage_INPLACE_NOTSUPPORTED);
+        psFree(output);
+        return NULL;
+    }
+
+    if (input->type.dimen != PS_DIMEN_IMAGE) {
+        psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
+                   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);
+
+    if (inDatatype == PS_TYPE_PTR || type == PS_TYPE_PTR) {
+        psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
+                   PS_ERR_BAD_PARAMETER_TYPE, true,
+                   PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                   PS_TYPE_PTR_NAME);
+        psFree(output);
+        return NULL;
+    }
+
+    output = psImageRecycle(output, numCols, numRows, type);
+
+    // cover the trival case of copy of the same
+    // datatype.
+    if (type == inDatatype) {
+        for (int 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(int row=0;row<numRows;row++) { \
+            in = IN->data.INTYPE[row]; \
+            out = OUT->data.OUTTYPE[row]; \
+            for (int 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);
+            psErrorMsg(PS_ERRORNAME_DOMAIN "psImageCopy",
+                       PS_ERR_BAD_PARAMETER_TYPE, true,
+                       PS_ERRORTEXT_psImage_IMAGE_TYPE_UNSUPPORTED,
+                       typeStr);
+            psFree(output);
+
+            break;
+        }
+    }
+    return output;
 }
 
Index: /trunk/psLib/src/mathtypes/psImage.h
===================================================================
--- /trunk/psLib/src/mathtypes/psImage.h	(revision 2066)
+++ /trunk/psLib/src/mathtypes/psImage.h	(revision 2067)
@@ -11,6 +11,6 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.39 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-09-30 21:01:09 $
+ *  @version $Revision: 1.40 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-10-13 00:10:50 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -100,4 +100,16 @@
 );
 
+/** Makes a copy of a psImage
+ *
+ * @return psImage* Copy of the input psImage.  This may not be equal to the
+ * output parameter
+ *
+ */
+psImage* psImageCopy(
+    psImage* restrict output,          ///< if not NULL, a psImage that could be recycled.
+    const psImage* input,              ///< the psImage to copy
+    psElemType type                    ///< the desired datatype of the returned copy
+);
+
 /** Frees all children of a psImage.
  *
Index: /trunk/psLib/test/astronomy/tst_psAstrometry.c
===================================================================
--- /trunk/psLib/test/astronomy/tst_psAstrometry.c	(revision 2066)
+++ /trunk/psLib/test/astronomy/tst_psAstrometry.c	(revision 2067)
@@ -5,6 +5,6 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-10-12 19:51:53 $
+ *  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-10-13 00:10:50 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -387,7 +387,7 @@
     }
 
-    if (psMemGetRefCounter(fpa) != 2) {
-        psLogMsg(__func__,PS_LOG_ERROR,
-                 "psChipAlloc did not increment reference counter for parent FPA.");
+    if (psMemGetRefCounter(fpa) != 1) {
+        psLogMsg(__func__,PS_LOG_ERROR,
+                 "psChipAlloc incremented reference counter for parent FPA.");
         return 5;
     }
@@ -439,7 +439,7 @@
     }
 
-    if (psMemGetRefCounter(fpa) != 3) {
-        psLogMsg(__func__,PS_LOG_ERROR,
-                 "psChipAlloc did not increment reference counter for parent FPA.");
+    if (psMemGetRefCounter(fpa) != 1) {
+        psLogMsg(__func__,PS_LOG_ERROR,
+                 "psChipAlloc incremented reference counter for parent FPA.");
         return 15;
     }
@@ -537,7 +537,7 @@
     }
 
-    if (psMemGetRefCounter(chip) != 2) {
-        psLogMsg(__func__,PS_LOG_ERROR,
-                 "psCellAlloc did not increment reference counter for parent.");
+    if (psMemGetRefCounter(chip) != 1) {
+        psLogMsg(__func__,PS_LOG_ERROR,
+                 "psCellAlloc incremented reference counter for parent.");
         return 5;
     }
@@ -603,7 +603,7 @@
     }
 
-    if (psMemGetRefCounter(chip) != 3) {
-        psLogMsg(__func__,PS_LOG_ERROR,
-                 "psCellAlloc did not increment reference counter for parent FPA.");
+    if (psMemGetRefCounter(chip) != 1) {
+        psLogMsg(__func__,PS_LOG_ERROR,
+                 "psCellAlloc incremented reference counter for parent FPA.");
         return 15;
     }
@@ -677,7 +677,7 @@
     }
 
-    if (psMemGetRefCounter(image) != 2) {
-        psLogMsg(__func__,PS_LOG_ERROR,
-                 "psReadoutAlloc did not increment reference counter for image.");
+    if (psMemGetRefCounter(image) != 1) {
+        psLogMsg(__func__,PS_LOG_ERROR,
+                 "psReadoutAlloc incremented reference counter for image.");
         return 5;
     }
Index: /trunk/psLib/test/astronomy/tst_psAstrometry03.c
===================================================================
--- /trunk/psLib/test/astronomy/tst_psAstrometry03.c	(revision 2066)
+++ /trunk/psLib/test/astronomy/tst_psAstrometry03.c	(revision 2067)
@@ -22,8 +22,4 @@
     }
 
-    for (i=0;i<NUM_CHIPS;i++) {
-        psArrayElementFree(chips[i]->cells);
-    }
-    psArrayElementFree(myFPA->chips);
     psFree(myFPA);
 
Index: /trunk/psLib/test/image/tst_psImageExtraction.c
===================================================================
--- /trunk/psLib/test/image/tst_psImageExtraction.c	(revision 2066)
+++ /trunk/psLib/test/image/tst_psImageExtraction.c	(revision 2067)
@@ -6,6 +6,6 @@
 *  @author Robert DeSonia, MHPCC
 *
-*  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-10-08 19:44:32 $
+*  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-10-13 00:10:50 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -21,4 +21,6 @@
 static int testImageSubset(void);
 static int testImageSubsection(void);
+static int testImageTrim(void);
+
 
 testDescription tests[] = {
@@ -27,4 +29,5 @@
                               {testImageSubsection,730,"psImageSubsection",0,false},
                               {testImageSlice, 552, "psImageSlice", 0, false},
+                              {testImageTrim, 744, "psImageTrim", 0, false},
                               {NULL}
                           };
@@ -743,2 +746,24 @@
     return 0;
 }
+
+static int testImageTrim(void)
+{
+    int r = 200;
+    int c = 300;
+    int quarterR = r/4;
+    int quarterC = c/4;
+    int halfR = r/2;
+    psImage* image = psImageAlloc(c,r,PS_TYPE_F32);
+    for (int row = 0; row < image->numRows; row++) {
+        for (int col = 0; col < image->numCols; col++) {
+            image->data.F32[row][col] = ((psF32)row+1.0f)/((psF32)col+1.0f);
+        }
+    }
+
+    psImage* image1 = psImageCopy(NULL,image,PS_TYPE_F32);
+    psImage* image2 = psImageTrim(image1,c/4,r/4,c*3/4,r*3/4);
+
+
+
+    return 0;
+}