Changeset 18146

Timestamp:

Jun 16, 2008, 11:59:43 AM (18 years ago)

Author:

Paul Price

Message:

Adding I/O functions for pmSubtractionKernels, so we can read/write the created kernels.

Location:

trunk/psModules/src

Files:

• imcombine/Makefile.am (modified) (2 diffs)
• imcombine/pmSubtractionIO.c (added)
• imcombine/pmSubtractionIO.h (added)
• imcombine/pmSubtractionKernels.c (modified) (1 diff)
• imcombine/pmSubtractionKernels.h (modified) (1 diff)
• psmodules.h (modified) (1 diff)

trunk/psModules/src/imcombine/Makefile.am

@@ -10 +10 @@
         pmSubtraction.c         \
         pmSubtractionEquation.c \
+        pmSubtractionIO.c       \
         pmSubtractionKernels.c  \
         pmSubtractionMask.c     \
@@ -24 +25 @@
         pmSubtraction.h         \
         pmSubtractionEquation.h \
+        pmSubtractionIO.h       \
         pmSubtractionKernels.h  \
         pmSubtractionMask.h     \

trunk/psModules/src/imcombine/pmSubtractionKernels.c

@@ -612 +612 @@
 
 
+// Intermediate string parsing functions required because of different APIs for strtol and strtof
+static inline int parseStringInt(const char *string)
+{
+    return strtol(string, NULL, 10);
+}
+static inline float parseStringFloat(const char *string)
+{
+    return strtof(string, NULL);
+}
+
+
+// Parse a string of a number, up to some delimiter, and advance past the delimiter
+#define PARSE_STRING_NUMBER(TARGET, STRING, DELIM, PARSEFUNC) { \
+    char *start = STRING;               /* Start of string */ \
+    char *end = strchr(STRING, DELIM);  /* End of string */ \
+    if (!end) { \
+        psAbort("End of string encountered"); \
+    } \
+    int stringSize = end - STRING;      /* Size of string with value, NOT including \0 */ \
+    char value[stringSize + 1];         /* String to parse */ \
+    strncpy(value, start, stringSize); \
+    value[stringSize] = '\0'; \
+    TARGET = PARSEFUNC(value); \
+    STRING += stringSize + 1;           /* Advance past delimiter */ \
+}
+
+
+pmSubtractionKernels *pmSubtractionKernelsFromDescription(const char *description, int bgOrder,
+                                                          pmSubtractionMode mode)
+{
+    PS_ASSERT_STRING_NON_EMPTY(description, NULL);
+
+    if (bgOrder != 0) {
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Background order %d is not yet supported.", bgOrder);
+        return false;
+    }
+
+    pmSubtractionKernelsType type = PM_SUBTRACTION_KERNEL_NONE; // Type of kernel
+    int size = 0;                       // Half-size of kernel
+    int spatialOrder = 0;               // Order of spatial variations
+    const psVector *fwhms = NULL;       // FWHM of Gaussians
+    const psVector *orders = NULL;      // Polynomial order for each FWHM
+    int inner = 0;                      // Size of inner region
+    int binning = 0;                    // Binning to use
+    int ringsOrder = 0;                 // Polynomial order for rings
+
+    if (strncmp(description, "ISIS", 4) == 0) {
+        // XXX Support for GUNK
+        if (strstr(description, "+POIS")) {
+            type = PM_SUBTRACTION_KERNEL_GUNK;
+            psAbort("Deciphering GUNK kernels (%s) is not currently supported.", description);
+        } else {
+            type = PM_SUBTRACTION_KERNEL_ISIS;
+            char *ptr = (char*)description + 5;    // Eat "ISIS("
+            PARSE_STRING_NUMBER(size, ptr, ',', parseStringInt);
+
+            // Count the number of Gaussians
+            int numGauss = 0;
+            for (char *string = ptr; string; string = strchr(string, '(')) {
+                numGauss++;
+            }
+
+            fwhms = psVectorAlloc(numGauss, PS_TYPE_F32);
+            orders = psVectorAlloc(numGauss, PS_TYPE_S32);
+
+            for (int i = 0; i < numGauss; i++) {
+                ptr++;                  // Eat the '('
+                PARSE_STRING_NUMBER(fwhms->data.F32[i], ptr, ',', parseStringFloat); // Eat "1.234,"
+                PARSE_STRING_NUMBER(orders->data.S32[i], ptr, ')', parseStringInt); // Eat "3)"
+            }
+
+            ptr++;                      // Eat ','
+            spatialOrder = parseStringInt(ptr);
+        }
+    } else if (strncmp(description, "RINGS", 5) == 0) {
+        type = PM_SUBTRACTION_KERNEL_RINGS;
+        char *ptr = (char*)description + 6;
+        PARSE_STRING_NUMBER(size, ptr, ',', parseStringInt);
+        PARSE_STRING_NUMBER(inner, ptr, ',', parseStringInt);
+        PARSE_STRING_NUMBER(ringsOrder, ptr, ',', parseStringInt);
+        PARSE_STRING_NUMBER(spatialOrder, ptr, ')', parseStringInt);
+    } else {
+        psAbort("Deciphering kernels other than ISIS and RINGS is not currently supported.");
+    }
+
+
+    return pmSubtractionKernelsGenerate(type, size, spatialOrder, fwhms, orders,
+                                        inner, binning, ringsOrder, mode);
+}
+
+
 pmSubtractionKernelsType pmSubtractionKernelsTypeFromString(const char *type)
 {

trunk/psModules/src/imcombine/pmSubtractionKernels.h

@@ -177 +177 @@
     );
 
+/// Generate a kernel using the description
+pmSubtractionKernels *pmSubtractionKernelsFromDescription(
+    const char *description,            ///< Description of kernel
+    int bgOrder,                        ///< Polynomial order for background fitting
+    pmSubtractionMode mode              ///< Mode for subtraction
+    );
+
 /// Return the appropriate type from a string
 pmSubtractionKernelsType pmSubtractionKernelsTypeFromString(const char *string // String name for kernel type

trunk/psModules/src/psmodules.h

@@ -86 +86 @@
 #include <pmSubtractionKernels.h>
 #include <pmSubtractionMatch.h>
+#include <pmSubtractionIO.h>
 #include <pmSubtractionParams.h>
 #include <pmSubtractionMask.h>