Changeset 6874

Timestamp:

Apr 17, 2006, 12:00:35 PM (20 years ago)

Author:

magnier

Message:

variety of small changes related to inconsistencies between psModules and psLib

Location:

trunk

Files:

• psLib/src/astro/psCoord.h (modified) (2 diffs)
• psLib/src/fits/psFitsImage.c (modified) (9 diffs)
• psLib/src/fits/psFitsImage.h (modified) (3 diffs)
• psLib/src/imageops/psImageStats.c (modified) (3 diffs)
• psLib/src/imageops/psImageStats.h (modified) (2 diffs)
• psLib/src/imageops/psImageStructManip.h (modified) (2 diffs)
• psLib/src/math/Makefile.am (modified) (2 diffs)
• psLib/src/math/psRegion.c (added)
• psLib/src/math/psRegion.h (added)
• psLib/src/math/psRegionForImage.c (added)
• psLib/src/math/psRegionForImage.h (added)
• psLib/src/mathtypes/psImage.c (modified) (4 diffs)
• psLib/src/mathtypes/psImage.h (modified) (5 diffs)
• psLib/src/psErrorText_en.dat (modified) (1 diff)
• psLib/src/pslib_strict.h (modified) (2 diffs)
• psLib/src/sys/psString.c (modified) (2 diffs)
• psLib/src/sys/psString.h (modified) (2 diffs)
• psLib/src/sys/psType.h (modified) (2 diffs)
• psLib/src/types/psMetadata.c (modified) (8 diffs)
• psLib/src/types/psMetadata.h (modified) (4 diffs)
• psLib/src/types/psPixels.h (modified) (3 diffs)
• psModules/src/astrom/pmFPAConstruct.c (modified) (1 diff)
• psModules/src/objects/psEllipse.c (deleted)
• psModules/src/objects/psEllipse.h (deleted)
• psModules/src/pslib/psMetadataItemParse.c (modified) (6 diffs)

trunk/psLib/src/astro/psCoord.h

@@ -11 +11 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.50 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-01-28 01:31:44 $
+ *  @version $Revision: 1.51 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-04-17 22:00:03 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -26 +26 @@
 #include "psPolynomial.h"
 #include "psPixels.h"
+#include "psRegion.h"
 //#include "psTime.h"
 

trunk/psLib/src/fits/psFitsImage.c

@@ -7 +7 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-04-04 19:52:42 $
+ *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-04-17 22:00:03 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -120 +120 @@
 }
 
-psImage* psFitsReadImage(psImage* output, // a psImage to recycle.
-                         const psFits* fits,    // the psFits object
+psImage* psFitsReadImage(const psFits* fits,    // the psFits object
                          psRegion region, // the region in the FITS image to read
                          int z)           // the z-plane in the FITS image cube to read
@@ -140 +139 @@
         psError(PS_ERR_BAD_PARAMETER_NULL, true,
                 PS_ERRORTEXT_psFits_NULL);
-        psFree(output);
         return NULL;
     }
@@ -166 +164 @@
                 PS_ERRORTEXT_psFits_DATATYPE_UNKNOWN,
                 fitsErr);
-        psFree(output);
         return NULL;
     }
@@ -176 +173 @@
                 PS_ERRORTEXT_psFits_IMAGE_DIM_UNKNOWN,
                 fitsErr);
-        psFree(output);
         return NULL;
     }
@@ -185 +181 @@
                 PS_ERRORTEXT_psFits_IMAGE_DIMENSION_UNSUPPORTED,
                 nAxis);
-        psFree(output);
         return NULL;
     }
@@ -195 +190 @@
                 PS_ERRORTEXT_psFits_IMAGE_SIZE_UNKNOWN,
                 fitsErr);
-        psFree(output);
         return NULL;
     }
@@ -260 +254 @@
                 PS_ERRORTEXT_psFits_FITS_TYPE_UNSUPPORTED,
                 bitPix);
-        psFree(output);
-        return NULL;
-    }
-
-    output = psImageRecycle(output,
-                            lastPixel[0]-firstPixel[0]+1,
-                            lastPixel[1]-firstPixel[1]+1,
-                            datatype);
-
-    if (output == NULL) {
-        psError(PS_ERR_UNKNOWN, false,
-                "Failed to allocate a properly sized image.");
-        return false;
-    }
+        return NULL;
+    }
+
+    psImage *output = psImageAlloc(lastPixel[0]-firstPixel[0]+1,
+                                   lastPixel[1]-firstPixel[1]+1,
+                                   datatype);
 
     // n.b., this assumes contiguous image buffer
@@ -532 +518 @@
 }
 
+psArray *psFitsReadImageCube(const psFits *fits, psRegion region)
+{
+    int nAxis = 0;                      // Number of axes
+    long nAxes[3];                      // Number of pixels on each axis
+    int status = 0;                     // cfitsio status value
+    char fitsErr[80] = "";              // CFITSIO error message string
+
+    if (fits == NULL) {
+        psError(PS_ERR_BAD_PARAMETER_NULL, true,
+                PS_ERRORTEXT_psFits_NULL);
+        return NULL;
+    }
+
+    // Some of this replicates what is in psFitsReadImage, so it's a little inefficient.  But it saves
+    // code replication, and should be sufficient for our needs.
+
+    if (fits_get_img_dim(fits->fd, &nAxis, &status) != 0) {
+        (void)fits_get_errstatus(status, fitsErr);
+        psError(PS_ERR_IO, true,
+                PS_ERRORTEXT_psFits_IMAGE_DIM_UNKNOWN,
+                fitsErr);
+        return NULL;
+    }
+
+    if (nAxis == 2) {
+        psArray *images = psArrayAlloc(1); // Single image plane
+        images->data[0] = psFitsReadImage(fits, region, 0);
+        return images;
+    }
+    if (nAxis == 3) {
+        if (fits_get_img_size(fits->fd, nAxis, nAxes, &status) != 0) {
+            (void)fits_get_errstatus(status, fitsErr);
+            psError(PS_ERR_IO, true,
+                    PS_ERRORTEXT_psFits_IMAGE_SIZE_UNKNOWN,
+                    fitsErr);
+            return NULL;
+        }
+
+        psArray *images = psArrayAlloc(nAxes[2]); // Array of image planes
+        for (int i = 0; i < nAxes[2]; i++) {
+            images->data[i] = psFitsReadImage(fits, region, i);
+        }
+
+        return images;
+    }
+
+    // Bad dimensionality
+    psError(PS_ERR_IO, true, PS_ERRORTEXT_psFits_IMAGE_DIMENSION_UNSUPPORTED, nAxis);
+    return NULL;
+}
+
+bool psFitsWriteImageCube(psFits *fits, psMetadata *header, const psArray *input, const char *extname)
+{
+    if (fits == NULL) {
+        psError(PS_ERR_BAD_PARAMETER_NULL, true,
+                PS_ERRORTEXT_psFits_NULL);
+        return false;
+    }
+
+    if (input == NULL) {
+        psError(PS_ERR_BAD_PARAMETER_NULL, true,
+                PS_ERRORTEXT_psFits_IMAGE_NULL);
+        return false;
+    }
+
+    if (input->n == 0) {
+        psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psFits_ARRAY_EMPTY);
+        return false;
+    }
+
+    if (input->n == 1) {
+        // The problem reduces to one already solved
+        return psFitsWriteImage(fits, header, input->data[0], 1, extname);
+    }
+
+    // Check that all images are of the same size
+    psImage *testImage = input->data[0];// First image off the array
+    int numCols = testImage->numCols;   // Number of columns
+    int numRows = testImage->numRows;   // Number of rows
+    for (int i = 1; i < input->n; i++) {
+        testImage = input->data[i];
+        if (testImage->numCols != numCols || testImage->numRows != numRows) {
+            psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psFits_ARRAY_SIZE_DIFFER);
+            return false;
+        }
+    }
+
+    // Need to check the header to make sure NAXIS and NAXIS[1-3] are correct
+    psMetadata *headerCopy = NULL;      // Copy of header
+    if (header) {
+        headerCopy = psMemIncrRefCounter(header);
+    } else {
+        headerCopy = psMetadataAlloc();
+    }
+    bool update = psMetadataAddS32(headerCopy, PS_LIST_HEAD, "NAXIS", PS_META_REPLACE, "Dimensionality", 3) &&
+                  psMetadataAddS32(headerCopy, PS_LIST_HEAD, "NAXIS1", PS_META_REPLACE, "Number of columns", numCols) &&
+                  psMetadataAddS32(headerCopy, PS_LIST_HEAD, "NAXIS2", PS_META_REPLACE, "Number of rows", numRows) &&
+                  psMetadataAddS32(headerCopy, PS_LIST_HEAD, "NAXIS3", PS_META_REPLACE, "Number of image planes",
+                                   input->n);
+    if (! update) {
+        psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psFits_METADATA_ADD_FAILED,
+                "NAXIS, NAXIS1, NAXIS2, NAXIS3");
+        psFree(headerCopy);
+        return false;
+    }
+
+    // Now we can safely write the images out.
+    // The first is an psFitsImageWrite to create the extension.
+    // The next are psFitsImageUpdate to write into the extension.
+    if (! psFitsWriteImage(fits, headerCopy, input->data[0], input->n, extname)) {
+        psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psFits_WRITE_PLANE_FAILED, 0);
+        psFree(headerCopy);
+        return false;
+    }
+    psFree(headerCopy);                 // Free, or drop reference
+
+    for (int i = 1; i < input->n; i++) {
+        if (! psFitsUpdateImage(fits, input->data[i], 0, 0, i)) {
+            psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psFits_WRITE_PLANE_FAILED, i);
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool psFitsUpdateImageCube(psFits *fits, const psArray *input, int x0, int y0)
+{
+    if (fits == NULL) {
+        psError(PS_ERR_BAD_PARAMETER_NULL, true,
+                PS_ERRORTEXT_psFits_NULL);
+        return false;
+    }
+
+    if (input == NULL) {
+        psError(PS_ERR_BAD_PARAMETER_NULL, true,
+                PS_ERRORTEXT_psFits_IMAGE_NULL);
+        return false;
+    }
+
+    if (input->n == 0) {
+        psError(PS_ERR_BAD_PARAMETER_SIZE, true, PS_ERRORTEXT_psFits_ARRAY_EMPTY);
+        return false;
+    }
+
+    for (int i = 0; i < input->n; i++) {
+        if (! psFitsUpdateImage(fits, input->data[i], x0, y0, i)) {
+            psError(PS_ERR_UNKNOWN, false, PS_ERRORTEXT_psFits_UPDATE_PLANE_FAILED, i);
+            return false;
+        }
+    }
+
+    return true;
+}
+

trunk/psLib/src/fits/psFitsImage.h

@@ -7 +7 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-04-04 19:52:42 $
+ *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-04-17 22:00:03 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -32 +32 @@
  */
 psImage* psFitsReadImage(
-    psImage* out,                      ///< a psImage to recycle.
     const psFits* fits,                ///< the psFits object
     psRegion region,                   ///< the region in the FITS image to read
@@ -78 +77 @@
 );
 
+psArray *psFitsReadImageCube(const psFits *fits, psRegion region);
+bool psFitsWriteImageCube(psFits *fits, psMetadata *header, const psArray *input, const char *extname);
+bool psFitsUpdateImageCube(psFits *fits, const psArray *input, int x0, int y0);
+
 /// @}
 

trunk/psLib/src/imageops/psImageStats.c

@@ -9 +9 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.92 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-04-05 01:49:40 $
+ *  @version $Revision: 1.93 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-04-17 22:00:03 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -31 +31 @@
 #include "psConstants.h"
 #include "psErrorText.h"
+#include "psRegion.h"
+#include "psRegionForImage.h"
 
 /// This routine must determine the various statistics for the image.
@@ -748 +750 @@
         return -1;
     }/* else if (col0 == col1 && row0 == row1) {
-                psError(PS_ERR_BAD_PARAMETER_VALUE, true,
-                        "Invalid psRegion specified.  Region contains only 1 pixel.\n");
-                return -1;
-            }
-        */
+                    psError(PS_ERR_BAD_PARAMETER_VALUE, true,
+                            "Invalid psRegion specified.  Region contains only 1 pixel.\n");
+                    return -1;
+                }
+            */
     x0 = col0;
     x1 = col1;

trunk/psLib/src/imageops/psImageStats.h

@@ -9 +9 @@
 *  @author GLG, MHPCC
 *
-*  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-09-26 22:35:53 $
+*  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-04-17 22:00:03 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -22 +22 @@
 #include "psStats.h"
 #include "psPolynomial.h"
+#include "psRegion.h"
 
 /// @addtogroup ImageStats

trunk/psLib/src/imageops/psImageStructManip.h

@@ -8 +8 @@
 *  @author Robert DeSonia, MHPCC
 *
-*  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-06-08 23:40:45 $
+*  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-04-17 22:00:03 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -18 +18 @@
 
 #include "psImage.h"
+#include "psRegion.h"
 
 /// @addtogroup Image

trunk/psLib/src/math/Makefile.am

@@ -13 +13 @@
         psMinimizePolyFit.c \
         psRandom.c \
+        psRegion.c \
+        psRegionForImage.c \
         psPolynomial.c \
         psSpline.c \
@@ -31 +33 @@
         psMinimizePolyFit.h \
         psRandom.h \
+        psRegion.h \
+        psRegionForImage.h \
         psPolynomial.h \
         psSpline.h \

trunk/psLib/src/mathtypes/psImage.c

@@ -9 +9 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.101 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-04-05 01:49:41 $
+ *  @version $Revision: 1.102 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-04-17 22:00:03 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -104 +104 @@
 
 
+// XXX these have been moved to psRegion* in src/math/
+# if 0
 psRegion psRegionSet(float x0,
                      float x1,
@@ -160 +162 @@
     return psStringCopy(tmpText);
 }
-
 
 // set actual region based on image parameters:
@@ -227 +228 @@
     return (region);
 }
+# endif /* commented-out psRegion functions */
 
 bool psImageInit (psImage *image,...)

trunk/psLib/src/mathtypes/psImage.h

@@ -11 +11 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.74 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-01-28 01:12:14 $
+ *  @version $Revision: 1.75 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-04-17 22:00:03 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -84 +84 @@
                 #define P_PSIMAGE_SET_TYPE(img,t) *(psMathType*)&img->type = t
 
+                        // XXX moved to psRegion.h in src/math
+                        # if 0
                         /** Basic image region structure.
                          *
@@ -97 +99 @@
                         }
                         psRegion;
+# endif
 
 /** Create an image of the specified size and type.
@@ -124 +127 @@
 
 
+// XXX these have been moved to psRegion* in src/math
+# if 0
 /** Create a psRegion with the specified attributes.
  *
@@ -184 +189 @@
     double radius                       ///< radius of square
 );
+# endif /* commented-out psRegions */
 
 /** Initializes the image with the given value.

trunk/psLib/src/psErrorText_en.dat

@@ -147 +147 @@
 psFits_METADATA_ADD_FAILED             Failed to add metadata item, %s.
 psFits_WRITE_FAILED                    Could not write data to file.\nCFITSIO Error: %s
+psFits_WRITE_PLANE_FAILED              Could not write image plane %d.
+psFits_UPDATE_PLANE_FAILED             Could not update image plane %d.
 psFits_IMAGE_NULL                      The input psImage was NULL.  Need a non-NULL psImage for operation to be performed.
+psFits_ARRAY_EMPTY                     The input array was empty.
+psFits_ARRAY_SIZE_DIFFER               The sizes of images in the array differ.
 psFits_METADATA_NULL                   The input psMetadata was NULL.  Need a non-NULL psMetadata for operation to be performed.
 psFits_METADATA_PTYPE_UNSUPPORTED      A metadata item's primative type, %d, is not supported.

trunk/psLib/src/pslib_strict.h

@@ -9 +9 @@
 *  @author Eric Van Alst, MHPCC
 *
-*  @version $Revision: 1.15 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2006-02-28 20:03:22 $
+*  @version $Revision: 1.16 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-04-17 22:00:03 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -58 +58 @@
 #include "psMinimizePolyFit.h"
 #include "psRandom.h"
+#include "psRegion.h"
+#include "psRegionForImage.h"
 #include "psPolynomial.h"
 #include "psSpline.h"

trunk/psLib/src/sys/psString.c

@@ -13 +13 @@
  *  @author David Robbins, MHPCC
  *
- *  @version $Revision: 1.24 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-02-01 20:40:56 $
+ *  @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-04-17 22:00:03 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -214 +214 @@
 }
 
+// given the input string, search for all copies of the key, and replace with the replacement value
+// the input string may be freed if not needed
+char *psStringSubstitute (char *input, char *replace, char *key)
+{
+
+    char *p;
+
+    if (key == NULL)
+        return input;
+    if (strlen(key) == 0)
+        return input;
+
+    while (true) {
+        p = strstr (input, key);
+        if (p == NULL)
+            return input;
+
+        // we have input = xxxkeyxxx
+        // we want output = xxxreplacexxx
+
+        // this is safe since we will subtract strlen(key) elements from input
+        char *output = psAlloc(strlen(input) + strlen(replace) + 1);
+        int Nc = p - input;
+
+        // copy the first segement into 'output'
+        strncpy (output, input, Nc);
+
+        // copy the key replacement to the start of the key
+
+        strcpy (&output[Nc], replace);
+        Nc += strlen (replace);
+
+        // copy the remainder to the end of the replacement
+        strcpy (&output[Nc], p + strlen(key));
+
+        psFree (input);
+        input = output;
+    }
+    return input;
+}
+

trunk/psLib/src/sys/psString.h

@@ -14 +14 @@
  *  @author David Robbins, MHPCC
  *
- *  @version $Revision: 1.18 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-02-01 20:40:56 $
+ *  @version $Revision: 1.19 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-04-17 22:00:03 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -103 +103 @@
 );
 
+// given the input string, search for all copies of the key, and replace with the replacement value
+// the input string may be freed if not needed
+char *psStringSubstitute (
+    char *input,    ///< input string to be modified
+    char *replace,    ///< replacement value
+    char *key    ///< string to be replaced in input
+);
+
 /** @} */// Doxygen - End of SystemGroup Functions
 

trunk/psLib/src/sys/psType.h

@@ -10 +10 @@
 *  @author Ross Harman, MHPCC
 *
-*  @version $Revision: 1.46 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2006-02-08 00:00:35 $
+*  @version $Revision: 1.47 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-04-17 22:00:03 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -130 +130 @@
     PS_DATA_POLYNOMIAL4D,              ///< psPolynomial4D
     PS_DATA_PROJECTION,                ///< psProjection
+    PS_DATA_REGION,                    ///< psRegion
     PS_DATA_SCALAR,                    ///< psScalar
     PS_DATA_SPHERE,                    ///< psSphere

trunk/psLib/src/types/psMetadata.c

@@ -12 +12 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.101 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-03-08 21:09:16 $
+ *  @version $Revision: 1.102 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-04-17 22:00:03 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -293 +293 @@
     case     PS_DATA_POLYNOMIAL4D:              // psPolynomial4D
     case     PS_DATA_PROJECTION:                // psProjection
+    case     PS_DATA_REGION:                  // psRegion
     case     PS_DATA_SCALAR:                    // psScalar
     case     PS_DATA_SPHERE:                    // psSphere
@@ -341 +342 @@
 }
 
+
+psMetadataItem *psMetadataItemCopy(const psMetadataItem *in
+                                  )
+{
+    PS_ASSERT_PTR_NON_NULL(in,NULL);
+
+    psMetadataItem *newItem = NULL;     // New metadata item, to be returned
+
+    #define PS_METADATA_ITEM_COPY_CASE(NAME,TYPE) \
+case PS_DATA_##NAME: \
+    newItem = psMetadataItemAlloc(in->name, PS_DATA_##NAME, in->comment, in->data.TYPE); \
+    break; \
+
+    switch (in->type) {
+        // Simple types
+        PS_METADATA_ITEM_COPY_CASE(BOOL,B);
+        PS_METADATA_ITEM_COPY_CASE(S8,S8);
+        PS_METADATA_ITEM_COPY_CASE(S16,S16);
+        PS_METADATA_ITEM_COPY_CASE(S32,S32);
+        PS_METADATA_ITEM_COPY_CASE(U8,U8);
+        PS_METADATA_ITEM_COPY_CASE(U16,U16);
+        PS_METADATA_ITEM_COPY_CASE(U32,U32);
+        PS_METADATA_ITEM_COPY_CASE(F32,F32);
+        PS_METADATA_ITEM_COPY_CASE(F64,F64);
+        PS_METADATA_ITEM_COPY_CASE(STRING,V); // This will copy the string, not point at it.
+    case PS_DATA_VECTOR: {
+            psVector *vecCopy = psVectorCopy(NULL, (psVector*)(in->data.V),
+                                             ((psVector*)(in->data.V))->type.type);
+            if (vecCopy == NULL) {
+                psError(PS_ERR_BAD_PARAMETER_NULL, false,
+                        "Error copying vector.  Vector skipped.\n");
+            } else {
+                newItem = psMetadataItemAlloc(in->name, PS_DATA_VECTOR, in->comment, vecCopy);
+                psFree(vecCopy);    // Drop reference
+            }
+            break;
+        }
+    case PS_DATA_TIME: {
+            psTime *timeCopy = p_psTimeCopy( (psTime*)(in->data.V) );
+            if (timeCopy == NULL) {
+                psError(PS_ERR_BAD_PARAMETER_NULL, false,
+                        "Error copying time.  Time skipped.\n");
+            } else {
+                newItem = psMetadataItemAlloc(in->name, PS_DATA_TIME, in->comment, timeCopy);
+                psFree(timeCopy);   // Drop reference
+            }
+            break;
+        }
+    case PS_DATA_METADATA: {
+            // Metadata: copy the next level and stuff that in too
+            psMetadata *metadata = psMetadataCopy(NULL, in->data.md);
+            newItem = psMetadataItemAlloc(in->name, PS_DATA_METADATA, in->comment, metadata);
+            psFree(metadata);       // Drop reference
+            break;
+        }
+    case PS_DATA_REGION: {
+            psRegion *region = in->data.V; // The region
+            psRegion *new = psRegionAlloc(region->x0, region->x1, region->y0, region->y1); // Copy of the region
+            newItem = psMetadataItemAlloc(in->name, PS_DATA_REGION, in->comment, new);
+            psFree(new);                  // Drop reference
+            break;
+        }
+    default:
+        // Other kinds of pointers
+        psLogMsg(__func__, PS_LOG_WARN, "Copying a pointer in the metadata item: %x\n", in->type);
+        newItem = psMetadataItemAlloc(in->name, in->type, in->comment, in->data.V);
+        break;
+    }
+
+    return newItem;
+}
+
 psMetadata *psMetadataCopy(psMetadata *out,
                            const psMetadata *in)
@@ -349 +422 @@
         out = psMetadataAlloc();
     }
-    //    psMetadataItem *item = NULL;
-    psMetadataIterator *iter = NULL;
-    iter = psMetadataIteratorAlloc(*(psMetadata**)&in, PS_LIST_HEAD, NULL);
-    /*
-        item = psMetadataGetAndIncrement(iter);
-        while (item != NULL) {
-            psMetadataAddItem(out, item, PS_LIST_TAIL, 0);
-            item = psMetadataGetAndIncrement(iter);
-        }
-        psFree(item);
-        psFree(iter);
-        return out;
-    */
+    psMetadataIterator *iter = psMetadataIteratorAlloc(*(psMetadata**)&in, PS_LIST_HEAD, NULL);
     psMetadataItem *inItem = NULL;
-    unsigned long numPointers = 0;      // Number of pointers we were forced to copy
     while ((inItem = psMetadataGetAndIncrement(iter))) {
         // Need to look for MULTI, which won't be picked up using the iterator.
@@ -370 +430 @@
         if (multiCheckItem->type == PS_DATA_METADATA_MULTI) {
             psTrace(__func__, 10, "MULTI: %s (%s)\n", inItem->name, inItem->comment);
-            flag = PS_DATA_METADATA_MULTI;
+            flag = PS_META_DUPLICATE_OK;
         }
         psTrace(__func__, 5, "Copying %s (%s)...\n", inItem->name, inItem->comment);
 
-
-        //        case PS_TYPE_##NAME:
-        #define PS_METADATA_COPY_CASE(NAME,TYPE) \
-    case PS_DATA_##NAME: \
-        if (! psMetadataAdd(out, PS_LIST_TAIL, inItem->name, \
-                            PS_DATA_##NAME | flag, inItem->comment, inItem->data.TYPE)) { \
-            psErrorStackPrint(stderr, "Error copying %s (%s) in the metadata\n", \
-                              inItem->name, inItem->comment); \
-        } \
-        break;
-
-        switch (inItem->type) {
-            // Numerical types
-            PS_METADATA_COPY_CASE(BOOL,B);
-            PS_METADATA_COPY_CASE(S8,S8);
-            PS_METADATA_COPY_CASE(S16,S16);
-            PS_METADATA_COPY_CASE(S32,S32);
-            PS_METADATA_COPY_CASE(U8,U8);
-            PS_METADATA_COPY_CASE(U16,U16);
-            PS_METADATA_COPY_CASE(U32,U32);
-            PS_METADATA_COPY_CASE(F32,F32);
-            PS_METADATA_COPY_CASE(F64,F64);
-
-        case PS_DATA_VECTOR: {
-                psVector *vecCopy = psVectorCopy(NULL, (psVector*)(inItem->data.V),
-                                                 ((psVector*)(inItem->data.V))->type.type);
-                if (vecCopy == NULL) {
-                    psError(PS_ERR_BAD_PARAMETER_NULL, false,
-                            "Error copying vector.  Vector skipped.\n");
-                } else {
-                    psMetadataAddVector(out, PS_LIST_TAIL, inItem->name, flag,
-                                        inItem->comment, vecCopy);
-                    psFree(vecCopy);
-                }
-                break;
-            }
-        case PS_DATA_TIME: {
-                psTime *timeCopy = p_psTimeCopy( (psTime*)(inItem->data.V) );
-                if (timeCopy == NULL) {
-                    psError(PS_ERR_BAD_PARAMETER_NULL, false,
-                            "Error copying time.  Time skipped.\n");
-                } else {
-                    psMetadataAddTime(out, PS_LIST_TAIL, inItem->name, flag,
-                                      inItem->comment, timeCopy);
-                    psFree(timeCopy);
-                }
-                break;
-            }
-            // String: relying on the fact that this will copy the string, not point at it.
-        case PS_DATA_STRING:
-            psMetadataAdd(out, PS_LIST_TAIL, inItem->name, PS_DATA_STRING |
-                          flag, inItem->comment, inItem->data.V);
-            break;
-            // Metadata: copy the next level and stuff that in too
-        case PS_DATA_METADATA: {
-                psMetadata *metadata = psMetadataCopy(NULL, inItem->data.md);
-                psMetadataAdd(out, PS_LIST_TAIL, inItem->name,
-                              PS_DATA_METADATA | flag, inItem->comment, metadata);
-                psFree(metadata);
-                break;
-            }
-            // Other kinds of pointers
-        default:
-            numPointers++;
-            psTrace(__func__, 10, "Copying a pointer in the metadata: %x\n", inItem->type);
-            psMetadataAdd(out, PS_LIST_TAIL, inItem->name, inItem->type | flag,
-                          inItem->comment, inItem->data.V);
-            break;
-        }
+        // Copy the item and add it on
+        psMetadataItem *newItem = psMetadataItemCopy(inItem); // Copied item
+        if (!psMetadataAddItem(out, newItem, PS_LIST_TAIL, flag)) {
+            psErrorStackPrint(stderr, "Error copying %s (%s) in the metadata\n", inItem->name,
+                              inItem->comment);
+        }
+        psFree(newItem);                // Drop reference
     }
     psFree(iter);
-
-    if (numPointers > 0) {
-        psLogMsg(__func__, PS_LOG_WARN,
-                 "Forced to copy %d pointers when copying metadata.  Updating the "
-                 "copied psMetadata will affect the original!\n", numPointers);
-    }
 
     return out;
@@ -528 +520 @@
         } else {
             // default is to error on duplicate entry.
+            if ((flags & PS_META_NO_REPLACE) != 0) {
+                return true;
+            }
             psError(PS_ERR_BAD_PARAMETER_VALUE, true,
                     PS_ERRORTEXT_psMetadata_DUPLICATE_NOT_ALLOWED);
@@ -554 +549 @@
                    const char *name,
                    int format,
-                   const char *comment,
-                   ...)
+                   const char *comment,...)
 {
     PS_ASSERT_PTR_NON_NULL(md,false);
@@ -1140 +1134 @@
             psMetadataPrint(item->data.V, level + 1);
             break;
+        case PS_DATA_REGION: {
+                psString region = psRegionToString(*(psRegion*)item->data.V);
+                printf("%s", region);
+                psFree(region);
+                break;
+            }
+        case PS_DATA_LIST:
+            printf("<a list of unknown contents>");
+            break;
+        case PS_DATA_TIME: {
+                psString time = psTimeToISO(item->data.V);
+                printf("%s", time);
+                psFree(time);
+                break;
+            }
         default:
+            printf("\n");
             psError(PS_ERR_IO, false, "Non-printable metadata type: %x\n", item->type);
         }

trunk/psLib/src/types/psMetadata.h

@@ -11 +11 @@
 *  @author Ross Harman, MHPCC
 *
-*  @version $Revision: 1.74 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2006-01-30 20:28:33 $
+*  @version $Revision: 1.75 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2006-04-17 22:00:03 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -59 +59 @@
     PS_META_DEFAULT = 0,               ///< default behaviour (duplicate entry is an error)
     PS_META_REPLACE = 0x1000000,       ///< allow entry to be replaced
-    PS_META_DUPLICATE_OK = 0x2000000,  ///< allow duplicate entries
-    PS_META_NULL = 0x4000000           ///< psMetadataItem.data is a NULL value
+    PS_META_NO_REPLACE = 0x2000000,    ///< duplicate entry is silently skipped
+    PS_META_DUPLICATE_OK = 0x4000000,  ///< allow duplicate entries
+    PS_META_NULL = 0x8000000           ///< psMetadataItem.data is a NULL value
 } psMetadataFlags;
 
@@ -342 +343 @@
 );
 
+/** Creates a new copy of a psMetadataItem.
+ *
+ * @return psMetadataItem*: the copy of the psMetadataItem
+ */
+psMetadataItem *psMetadataItemCopy(const psMetadataItem *in ///< metadata item to be copied
+                                  );
+
+
 /** Creates a new copy of all the psMetadataItems in the psMetadata collection, in, and
  *  returns them in out, or creates a new container if out is NULL.
@@ -939 +948 @@
 
 
+psPolynomial2D *psPolynomial2DfromMD (psMetadata *folder);
+bool psPolynomial2DtoMD (psMetadata *md, psPolynomial2D *poly, char *format, ...);
+
+psPolynomial3D *psPolynomial3DfromMD (psMetadata *folder);
+bool psPolynomial3DtoMD (psMetadata *md, psPolynomial3D *poly, char *format, ...);
+
+psPolynomial4D *psPolynomial4DfromMD (psMetadata *folder);
+bool psPolynomial4DtoMD (psMetadata *md, psPolynomial4D *poly, char *format, ...);
+
+
 /// @}
 

trunk/psLib/src/types/psPixels.h

@@ -7 +7 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.19 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2006-02-28 02:53:03 $
+ *  @version $Revision: 1.20 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2006-04-17 22:00:03 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -17 +17 @@
 #include "psImage.h"
 #include "psVector.h"
+#include "psRegion.h"
 
 /// @addtogroup Image
@@ -125 +126 @@
  *
  *  psMaskToPixels shall return a psPixels consisting of the coordinates in
- *  the mask that match the maskVal. The out pixel list shall be modified if
+ *  the mask that match the maskVal. The out pixel list shall be modified if
  *  supplied, or allocated and returned if NULL. In hte event that mask is
  *  NULL, the function shall generate an error and return NULL.

trunk/psModules/src/astrom/pmFPAConstruct.c

@@ -104 +104 @@
         return NULL;
     }
+    // XXX EAM test
+    fprintf (stderr, "phu name: %s == %s\n", keyword, name);
     return psMetadataItemParseString(resultItem);
 }

trunk/psModules/src/pslib/psMetadataItemParse.c

@@ -1 +1 @@
 #include <stdio.h>
 #include "pslib.h"
+
+# define PS_METADATA_ITEM_PARSE_NUMBER(INTYPE,OUTTYPE) \
+case PS_DATA_##INTYPE: { \
+    return (ps##OUTTYPE)(item->data.INTYPE); } \
 
 psF32 psMetadataItemParseF32(psMetadataItem *item
@@ -6 +10 @@
 {
     switch (item->type) {
-    case PS_DATA_F32:
-        return item->data.F32;
-    case PS_DATA_F64:
-        // Assume it's OK to truncate to floating point from double
-        return (float)item->data.F64;
-    case PS_DATA_S32:
-        // Promote to float
-        return (float)item->data.S32;
+        PS_METADATA_ITEM_PARSE_NUMBER (F32, F32);
+        PS_METADATA_ITEM_PARSE_NUMBER (F64, F32);
+        PS_METADATA_ITEM_PARSE_NUMBER (S8,  F32);
+        PS_METADATA_ITEM_PARSE_NUMBER (S16, F32);
+        PS_METADATA_ITEM_PARSE_NUMBER (S32, F32);
+        PS_METADATA_ITEM_PARSE_NUMBER (U8,  F32);
+        PS_METADATA_ITEM_PARSE_NUMBER (U16, F32);
+        PS_METADATA_ITEM_PARSE_NUMBER (U32, F32);
     default:
         psError(PS_ERR_IO, true, "Item %s (%s) is not of floating point type (%x) --- treating as NaN.\n",
@@ -25 +29 @@
 {
     switch (item->type) {
-    case PS_TYPE_F64:
-        return item->data.F64;
-    case PS_TYPE_F32:
-        // Promote to double
-        return (double)item->data.F32;
-    case PS_TYPE_S32:
-        // Promote to double
-        return (double)item->data.S32;
+        PS_METADATA_ITEM_PARSE_NUMBER (F32, F64);
+        PS_METADATA_ITEM_PARSE_NUMBER (F64, F64);
+        PS_METADATA_ITEM_PARSE_NUMBER (S8,  F64);
+        PS_METADATA_ITEM_PARSE_NUMBER (S16, F64);
+        PS_METADATA_ITEM_PARSE_NUMBER (S32, F64);
+        PS_METADATA_ITEM_PARSE_NUMBER (U8,  F64);
+        PS_METADATA_ITEM_PARSE_NUMBER (U16, F64);
+        PS_METADATA_ITEM_PARSE_NUMBER (U32, F64);
     default:
         psError(PS_ERR_IO, true, "Item %s (%s) is not of double-precision floating point type (%x) "
@@ -61 +65 @@
 }
 
+# define PS_METADATA_ITEM_PARSE_STRING(TYPE,MODE) \
+case PS_DATA_##TYPE: { \
+    psString value = NULL; \
+    psStringAppend(&value, MODE, item->data.TYPE); \
+    return value; } \
+
 psString psMetadataItemParseString(psMetadataItem *item
                                   )
@@ -67 +77 @@
     case PS_DATA_STRING:
         return psMemIncrRefCounter(item->data.V);
-    case PS_DATA_F32: {
-            psString value = NULL;    // String to return
-            psStringAppend(&value, "%f", item->data.F32);
-            return value;
-        }
-    case PS_DATA_S32: {
-            psString value = NULL;    // String to return
-            psStringAppend(&value, "%d", item->data.S32);
-            return value;
-        }
+
+        PS_METADATA_ITEM_PARSE_STRING(F32, "%f");
+        PS_METADATA_ITEM_PARSE_STRING(F64, "%f");
+        PS_METADATA_ITEM_PARSE_STRING(S8,  "%d");
+        PS_METADATA_ITEM_PARSE_STRING(S16, "%d");
+        PS_METADATA_ITEM_PARSE_STRING(S32, "%d");
+        PS_METADATA_ITEM_PARSE_STRING(U8,  "%d");
+        PS_METADATA_ITEM_PARSE_STRING(U16, "%d");
+        PS_METADATA_ITEM_PARSE_STRING(U32, "%d");
+
     default:
         psError(PS_ERR_IO, true, "Item %s (%s) is not of string type (%x) --- treating as "
@@ -84 +94 @@
 }
 
+
+# if 0
+case PS_DATA_F32:
+{
+psString value = NULL;    // String to return
+psStringAppend(&value, "%f", item->data.F32);
+    return value;
+}
+case PS_DATA_S32:
+{
+    psString value = NULL;    // String to return
+    psStringAppend(&value, "%d", item->data.S32);
+    return value;
+}
+# endif