Changeset 26197

Timestamp:

Nov 19, 2009, 11:32:06 AM (17 years ago)

Author:

eugene

Message:

add function to reduce matches to best unique set

Location:

branches/eam_branches/20091113

Files:

• psModules/src/astrom/pmAstrometryObjects.c (modified) (1 diff)
• psModules/src/astrom/pmAstrometryObjects.h (modified) (2 diffs)
• psastro/doc/outline.txt (added)
• psastro/src/psastroMosaicSetMatch.c (modified) (2 diffs)
• psastro/src/psastroOneChipFit.c (modified) (1 diff)

branches/eam_branches/20091113/psModules/src/astrom/pmAstrometryObjects.c

@@ -973 +973 @@
 */
 
+/*****************************************************************************/
+static void pmAstromMatchInfoFree (pmAstromMatchInfo *info)
+{
+    if (info == NULL) return;
+    return;
+}
+
+
+/*****************************************************************************/
+pmAstromMatchInfo *pmAstromMatchInfoAlloc()
+{
+    pmAstromMatchInfo *info = psAlloc (sizeof(pmAstromMatchInfo));
+    psMemSetDeallocator(info, (psFreeFunc) pmAstromMatchInfoFree);
+
+    info->match = NULL;
+    info->radius = NAN;
+
+    return (info);
+}
+
+// generate a unique set of matches (choose closest match)
+psArray *pmAstromRadiusMatchUniq (psArray *rawstars, psArray *refstars, psArray *matches) {
+
+    // I have the matches between the refstars and the rawstars.  
+    // For each refstar, find the single match which has the smallest radius and reject
+    // all others.  
+
+    // create an array of refstars->n arrays, each containing all of the matches for the
+    // given refstar.  
+
+    psArray *refstarMatches = psArrayAlloc (refstars->n);
+
+    for (int i = 0; i < matches->n; i++) {
+
+        pmAstromMatch *match = matches->data[i];
+        
+        // accumulate this refstar match on the array for this refstar (create if needed)
+        psArray *refSet = refstarMatches->data[match->ref];
+        if (!refSet) {
+            refstarMatches->data[match->ref] = psArrayAllocEmpty (8);
+            refSet = refstarMatches->data[match->ref];
+        }
+
+        pmAstromMatchInfo *matchInfo = pmAstromMatchInfoAlloc();
+
+        pmAstromObj *refStar = refstars->data[match->ref];
+        pmAstromObj *rawStar = rawstars->data[match->raw];
+        
+        matchInfo->match = match; // reference to the match of interest
+        matchInfo->radius = hypot (refStar->FP->x - rawStar->FP->x, refStar->FP->y - rawStar->FP->y);
+
+        psArrayAdd (refSet, 8, matchInfo); // matchInfo->match is just a reference
+        psFree (matchInfo);
+    }
+
+    // we now have a set of matches for each refstar and their distances; create a new set
+    // keeping only the closest entry for each match
+
+    psArray *unique = psArrayAllocEmpty (PS_MAX(16, matches->n / 2));
+    for (int i = 0; i < refstars->n; i++) {
+
+        psArray *refSet = refstarMatches->data[i];
+        if (!refSet) continue;
+        if (refSet->n == 0) continue; // not certain how this can happen...
+
+        if (refSet->n == 1) {
+            pmAstromMatchInfo *matchInfo = refSet->data[0];
+            psArrayAdd (unique, 32, matchInfo->match);
+            continue;
+        }
+
+        pmAstromMatchInfo *matchInfo = refSet->data[0];
+        float minRadius = matchInfo->radius;
+        pmAstromMatch *minMatch = matchInfo->match;
+        for (int j = 1; j < refSet->n; j++) {
+            pmAstromMatchInfo *matchInfo = refSet->data[j];
+            if (minRadius < matchInfo->radius) continue;
+            minMatch = matchInfo->match;
+            minRadius = matchInfo->radius;
+        }
+        
+        psArrayAdd (unique, 32, minMatch); // minMatch is just a reference to a match on matches,
+    }
+
+    psLogMsg ("psastro", 3, "generate unique matches to reference stars: %ld matches -> %ld matches\n", matches->n, unique->n);
+    psFree (refstarMatches);
+
+    return unique;
+}

branches/eam_branches/20091113/psModules/src/astrom/pmAstrometryObjects.h

@@ -54 +54 @@
 typedef struct
 {
-    int raw;                             ///< What is this?
-    int ref;                             ///< What is this?
+    int raw;                             ///< reference to the rawstar entry
+    int ref;                             ///< reference to the refstar entry
 }
 pmAstromMatch;
+
+
+/*
+ * The pmAstromMatchInfo structure is used to generate a unique set of matches
+ */
+typedef struct
+{
+    pmAstromMatch *match;               ///< reference to the match
+    float radius;                       ///< distance between the object
+}
+pmAstromMatchInfo;
 
 
@@ -121 +132 @@
 );
 
+psArray *pmAstromRadiusMatchUniq (psArray *refstars, psArray *rawstars, psArray *matches);
 
 pmAstromStats *pmAstromStatsAlloc(void);

branches/eam_branches/20091113/psastro/src/psastroMosaicSetMatch.c

@@ -26 +26 @@
     double RADIUS = psMetadataLookupF32 (&status, recipe, radiusWord);
     if (!status) {
-        psError(PS_ERR_IO, false, "Failed to lookup matching radius: %s", radiusWord);
-        psFree (view);
-        return false;
+        psAbort("Failed to lookup matching radius: %s", radiusWord);
+    }
+
+    int uniqIter = psMetadataLookupS32 (&status, recipe, "PSASTRO.MOSAIC.UNIQ.ITER");
+    if (!status) {
+        psAbort("Failed to lookup matching PSASTRO.MOSAIC.UNIQ.ITER");
     }
 
@@ -69 +72 @@
                 psTrace ("psastro", 4, "Matched %ld refstars\n", matches->n);
 
+                if (iteration >= uniqIter) {
+                    psArray *unique = pmAstromRadiusMatchUniq (rawstars, refstars, matches);
+                    if (!unique) {
+                        psLogMsg ("psastro", 3, "failed to generate a uniq set of matched sources\n");
+                        return false;
+                    }
+                    psFree (matches);
+                    matches = unique;
+                }
+
                 pmAstromVisualPlotMosaicMatches(rawstars, refstars, matches, iteration, recipe);
 

branches/eam_branches/20091113/psastro/src/psastroOneChipFit.c

@@ -66 +66 @@
 
         if (iter >= uniqIter) {
-          if (!pmAstromRadiusMatchUniq (rawstars, refstars, match)) {
-            psLogMsg ("psastro", 3, "failed to generate a uniq find radius-matched sources\n");
-            return false;
-          }
+            psArray *unique = pmAstromRadiusMatchUniq (rawstars, refstars, match);
+            if (!unique) {
+                psLogMsg ("psastro", 3, "failed to generate a uniq set of matched sources\n");
+                return false;
+            }
+            psFree (match);
+            match = unique;
         }