Changeset 6815

Timestamp:

Apr 7, 2006, 5:05:28 PM (20 years ago)

Author:

Paul Price

Message:

Working on pmFPACopy for lris blue

Location:

branches/rel10_ifa/psModules/src/astrom

Files:

• pmConcepts.c (modified) (1 diff)
• pmConceptsStandard.c (modified) (2 diffs)
• pmConceptsStandard.h (modified) (1 diff)
• pmConceptsWrite.c (modified) (5 diffs)
• pmFPAConstruct.c (modified) (1 diff)
• pmHDU.c (modified) (1 diff)

branches/rel10_ifa/psModules/src/astrom/pmConcepts.c

@@ -434 +434 @@
             psFree(trimsec);
             pmConceptRegister(cellTrimsec, (pmConceptParseFunc)pmConceptParse_CELL_TRIMSEC,
-                              #if 0
-                              (pmConceptFormatFunc)pmConceptFormat_CELL_TRIMSEC,
-                              #else
-                              NULL,
-                              #endif
-                              PM_CONCEPT_LEVEL_CELL);
+                              (pmConceptFormatFunc)pmConceptFormat_CELL_TRIMSEC, PM_CONCEPT_LEVEL_CELL);
             psFree(cellTrimsec);
         }

branches/rel10_ifa/psModules/src/astrom/pmConceptsStandard.c

@@ -434 +434 @@
 
 
-#if 0
 psMetadataItem *pmConceptFormat_CELL_TRIMSEC(psMetadataItem *concept, psMetadata *cameraFormat, pmFPA *fpa, pmChip *chip, pmCell *cell)
 {
@@ -446 +445 @@
     return formatted;
 }
-#endif
 
 psMetadataItem *pmConceptFormat_CELL_BIASSEC(psMetadataItem *concept, psMetadata *cameraFormat, pmFPA *fpa, pmChip *chip, pmCell *cell)

branches/rel10_ifa/psModules/src/astrom/pmConceptsStandard.h

@@ -14 +14 @@
 psMetadataItem *pmConceptParse_CELL_TIME(psMetadataItem *concept, psMetadataItem *pattern, psMetadata *cameraFormat, pmFPA *fpa, pmChip *chip, pmCell *cell);
 psMetadataItem *pmConceptParse_CELL_Positions(psMetadataItem *concept, psMetadataItem *pattern, psMetadata *cameraFormat, pmFPA *fpa, pmChip *chip, pmCell *cell);
-#if 0
 psMetadataItem *pmConceptFormat_CELL_TRIMSEC(psMetadataItem *concept, psMetadata *cameraFormat, pmFPA *fpa, pmChip *chip, pmCell *cell);
-#endif
 psMetadataItem *pmConceptFormat_CELL_BIASSEC(psMetadataItem *concept, psMetadata *cameraFormat, pmFPA *fpa, pmChip *chip, pmCell *cell);
 psMetadataItem *pmConceptFormat_CELL_XBIN(psMetadataItem *concept, psMetadata *cameraFormat, pmFPA *fpa, pmChip *chip, pmCell *cell);

branches/rel10_ifa/psModules/src/astrom/pmConceptsWrite.c

@@ -14 +14 @@
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-static bool compareConcepts(psMetadataItem *item1, // First item to compare
-                            psMetadataItem *item2 // Second item to compare
+static bool compareConcepts(psMetadataItem *compare, // Item to compare
+                            psMetadataItem *standard // Standard for comparison
                            )
 {
     // First order checks
-    if (! item1 || ! item2) {
-        return false;
-    }
-    if (strcasecmp(item1->name, item2->name) != 0) {
+    if (! compare || ! standard) {
+        return false;
+    }
+    if (strcasecmp(compare->name, standard->name) != 0) {
         return false;
     }
 
     // Check the more boring types
-    switch (item1->type) {
+    switch (compare->type) {
     case PS_TYPE_S32:
-        switch (item2->type) {
+        switch (standard->type) {
         case PS_TYPE_S32:
-            psTrace(__func__, 10, "Comparing %d and %d...\n", item1->data.S32, item2->data.S32);
-            return (item1->data.S32 == item2->data.S32) ? true : false;
+            psTrace(__func__, 10, "Comparing %d and %d...\n", compare->data.S32, standard->data.S32);
+            return (compare->data.S32 == standard->data.S32) ? true : false;
         case PS_TYPE_F32:
-            psTrace(__func__, 10, "Comparing %d and %d...\n", item1->data.S32, (int)item2->data.F32);
-            return (item1->data.S32 == (int)item2->data.F32) ? true : false;
+            psTrace(__func__, 10, "Comparing %d and %d...\n", compare->data.S32, (int)standard->data.F32);
+            return (compare->data.S32 == (int)standard->data.F32) ? true : false;
         case PS_TYPE_F64:
-            psTrace(__func__, 10, "Comparing %d and %d...\n", item1->data.S32, (int)item2->data.F64);
-            return (item1->data.S32 == (int)item2->data.F64) ? true : false;
+            psTrace(__func__, 10, "Comparing %d and %d...\n", compare->data.S32, (int)standard->data.F64);
+            return (compare->data.S32 == (int)standard->data.F64) ? true : false;
         default:
             return false;
         }
     case PS_TYPE_F32:
-        switch (item2->type) {
+        switch (standard->type) {
         case PS_TYPE_S32:
-            psTrace(__func__, 10, "Comparing %f and %f...\n", item1->data.F32, (float)item2->data.S32);
-            return (item1->data.F32 == (float)item2->data.S32) ? true : false;
+            psTrace(__func__, 10, "Comparing %f and %f...\n", compare->data.F32, (float)standard->data.S32);
+            return (compare->data.F32 == (float)standard->data.S32) ? true : false;
         case PS_TYPE_F32:
-            psTrace(__func__, 10, "Comparing %f and %f...\n", item1->data.F32, item2->data.F32);
-            return (item1->data.F32 == item2->data.F32) ? true : false;
+            psTrace(__func__, 10, "Comparing %f and %f...\n", compare->data.F32, standard->data.F32);
+            return (compare->data.F32 == standard->data.F32) ? true : false;
         case PS_TYPE_F64:
-            psTrace(__func__, 10, "Comparing %f and %f...\n", item1->data.F32, (float)item2->data.F64);
-            return (item1->data.F32 == (float)item2->data.F64) ? true : false;
+            psTrace(__func__, 10, "Comparing %f and %f...\n", compare->data.F32, (float)standard->data.F64);
+            return (compare->data.F32 == (float)standard->data.F64) ? true : false;
         default:
             return false;
         }
     case PS_TYPE_F64:
-        switch (item2->type) {
+        switch (standard->type) {
         case PS_TYPE_S32:
-            psTrace(__func__, 10, "Comparing %f and %f...\n", item1->data.F32, (double)item2->data.S32);
-            return (item1->data.F64 == (double)item2->data.S32) ? true : false;
+            psTrace(__func__, 10, "Comparing %f and %f...\n", compare->data.F32, (double)standard->data.S32);
+            return (compare->data.F64 == (double)standard->data.S32) ? true : false;
         case PS_TYPE_F32:
-            psTrace(__func__, 10, "Comparing %f and %f...\n", item1->data.F32, (double)item2->data.F32);
-            return (item1->data.F64 == (double)item2->data.F32) ? true : false;
+            psTrace(__func__, 10, "Comparing %f and %f...\n", compare->data.F32, (double)standard->data.F32);
+            return (compare->data.F64 == (double)standard->data.F32) ? true : false;
         case PS_TYPE_F64:
-            psTrace(__func__, 10, "Comparing %f and %f...\n", item1->data.F32, item2->data.F64);
-            return (item1->data.F64 == item2->data.F64) ? true : false;
+            psTrace(__func__, 10, "Comparing %f and %f...\n", compare->data.F32, standard->data.F64);
+            return (compare->data.F64 == standard->data.F64) ? true : false;
         default:
             return false;
         }
-        return (item1->data.F64 == item2->data.F64) ? true : false;
+        return (compare->data.F64 == standard->data.F64) ? true : false;
     case PS_DATA_STRING:
-        if (item2->type != PS_DATA_STRING) {
+        if (standard->type != PS_DATA_STRING) {
             return false;
         }
-        psTrace(__func__, 10, "Comparing '%s' and '%s'\n", item1->data.V, item2->data.V);
-        return (strcasecmp(item1->data.V, item2->data.V) == 0) ? true : false;
+        psTrace(__func__, 10, "Comparing '%s' and '%s'\n", compare->data.V, standard->data.V);
+        return (strcasecmp(compare->data.V, standard->data.V) == 0) ? true : false;
+    case PS_DATA_LIST: {              // A list of strings
+            // "compare" contains a list of psMetadataItems
+            // "standard" likely contains just a string (but it might possibly be a list of strings)
+            psList *cList = compare->data.V; // The list from comparison item
+            psList *sList = NULL;         // The list from standard item
+            switch (standard->type) {
+            case PS_DATA_STRING:
+                sList = psStringSplit(standard->data.V, " ;");
+                break;
+            case PS_DATA_LIST:
+                sList = psMemIncrRefCounter(standard->data.V);
+                break;
+            default:
+                return false;
+            }
+            if (cList->n != sList->n) {
+                psFree(sList);
+                return false;
+            }
+            psVector *match = psVectorAlloc(cList->n, PS_TYPE_U8); // Array indicating which values match
+            psVectorInit(match, 0);
+            psListIterator *cIter = psListIteratorAlloc(cList, PS_LIST_HEAD, false); // compare iterator
+            psListIterator *sIter = psListIteratorAlloc(sList, PS_LIST_HEAD, false); // standard iterator
+            psMetadataItem *cItem = NULL; // Item from compare list
+            while ((cItem = psListGetAndIncrement(cIter))) {
+                if (cItem->type != PS_DATA_STRING) {
+                    psLogMsg(__func__, PS_LOG_WARN, "psMetadataItem from list is of type %x instead of "
+                             "%x (PS_DATA_STRING) --- can't interpret.\n", cItem->type, PS_DATA_STRING);
+                    psFree(cIter);
+                    psFree(sIter);
+                    psFree(match);
+                    psFree(sList);
+                    return false;
+                }
+                psString cString = cItem->data.V; // String from compare list
+                psListIteratorSet(sIter, PS_LIST_HEAD);
+                int index = 0;            // Index for list
+                bool found = false;       // Found a match?
+                for (psString sString = NULL; (sString = psListGetAndIncrement(sIter)) && !found; index++) {
+                    if (strcasecmp(cString, sString) == 0) {
+                        match->data.U8[index]++;
+                        found = true;
+                    }
+                }
+                if (! found) {
+                    // Can give up immediately
+                    psFree(cIter);
+                    psFree(sIter);
+                    psFree(match);
+                    psFree(sList);
+                    return false;
+                }
+            }
+            // Make sure we got 100% matches in both directions
+            bool allMatch = true;         // Did all of them match?
+            for (int i = 0; i < match->n && allMatch; i++) {
+                if (!match->data.U8[i]) {
+                    allMatch = false;
+                }
+            }
+            psFree(cIter);
+            psFree(sIter);
+            psFree(sList);
+            psFree(match);
+            return allMatch;
+        }
     default:
         return false;
@@ -82 +148 @@
     psAbort(__func__, "Should never get here.\n");
 }
+
 
 // Format a single concept
@@ -216 +283 @@
                     } else if (strcasecmp(source, "VALUE") == 0) {
                         psTrace(__func__, 8, "Checking %s against camera format.\n", name);
-                        if (! compareConcepts(cameraItem, formatted)) {
+                        if (! compareConcepts(formatted, cameraItem)) {
                             psLogMsg(__func__, PS_LOG_WARN, "Concept %s is specified by value in the camera "
                                      "format, but the values don't match.\n", name);
@@ -224 +291 @@
                                  "write\n", nameSource);
                     }
-                } else if (! compareConcepts(cameraItem, formatted)) {
+                } else if (! compareConcepts(formatted, cameraItem)) {
                     // Assume it's specified by value
                     psLogMsg(__func__, PS_LOG_WARN, "Concept %s is specified by value in the camera "
@@ -290 +357 @@
                     continue;
                 }
-                if (! compareConcepts(defaultItem, formatted)) {
+                if (! compareConcepts(formatted, defaultItem)) {
                     psLogMsg(__func__, PS_LOG_WARN, "Concept %s is specified by the DEFAULTS in the camera "
                              "format, but the values don't match.\n", name);

branches/rel10_ifa/psModules/src/astrom/pmFPAConstruct.c

@@ -579 +579 @@
             psTrace(__func__, 2, "---> NO PIXELS read in for extension %s\n", fpa->hdu->extname);
         }
+        if (fpa->hdu->header && header) {
+            psTrace(__func__, 2, "---> Header:\n");
+            psMetadataPrint(fpa->hdu->header, 8);
+        }
     }
     if (concepts) {

branches/rel10_ifa/psModules/src/astrom/pmHDU.c

@@ -145 +145 @@
     }
 
-    if (!hdu->images && !psFitsWriteHeader(hdu->header, fits)) {
-        psError(PS_ERR_IO, false, "Unable to write header for extension %s\n", extname);
+    // Only a header
+    if (!hdu->images && !hdu->table) {
+        // Tell CFITSIO there's nothing there
+        psMetadataItem *naxis = psMetadataLookup(hdu->header, "NAXIS");
+        naxis->data.S32 = 0;
+
+        if (!psFitsWriteHeader(hdu->header, fits)) {
+            psError(PS_ERR_IO, false, "Unable to write header for extension %s\n", extname);
+        }
     }