Changeset 25027 for branches/pap/psastro/src/psastroMaskUpdates.c

Timestamp:

Aug 7, 2009, 4:08:25 PM (17 years ago)

Author:

Paul Price

Message:

Merging trunk (r25026) to get up-to-date on old branch.

Location:

branches/pap

Files:

• . (modified) (1 prop)
• psastro (modified) (1 prop)
• psastro/src/psastroMaskUpdates.c (modified) (5 diffs)

branches/pap/psastro/src/psastroMaskUpdates.c

@@ -28 +28 @@
     pmCell *cell = NULL;
     pmReadout *readout = NULL;
-    float zeropt, exptime;
+    float zeropt, exptime, GHOST_MAX_MAG;
 
     psImageMaskType ghostMaskValue = pmConfigMaskGet("GHOST", config); // Mask value for ghost pixels
+    psImageMaskType glintMaskValue = pmConfigMaskGet("GHOST", config); // Mask value for glint pixels (overload ghost)
     psImageMaskType spikeMaskValue = pmConfigMaskGet("SPIKE", config); // Mask value for ghost pixels
     psImageMaskType starMaskValue  = pmConfigMaskGet("STARCORE", config); // Mask value for ghost pixels
@@ -53 +54 @@
     }
     bool COUNT_GHOSTS = psMetadataLookupF32 (&status, recipe, "REFSTAR_COUNT_GHOSTS");
-    double GHOST_MAX_MAG = psMetadataLookupF32 (&status, recipe, "GHOST_MAX_MAG");
     int nGhosts = 0;
+
+    // convert star positions to glint positions and add to the fpa->analysis data
+    if (!psastroLoadGlints (config)) {
+        psError(PSASTRO_ERR_CONFIG, false, "Error loading glints");
+        return false;
+    }
 
     psLogMsg ("psastro", PS_LOG_INFO, "generating a bright-star mask");
@@ -79 +85 @@
 
     // really error-out here?  or just skip?
-    if (!psastroZeroPointFromRecipe (&zeropt, &exptime, fpa, recipe)) {
+    if (!psastroZeroPointFromRecipe (&zeropt, &exptime, &GHOST_MAX_MAG, fpa, recipe)) {
         psLogMsg ("psastro", PS_LOG_INFO, "failed to load zeropt data from recipe");
         return false;
@@ -221 +227 @@
                     }
 
+                    // This masking option was needed for persistent charge trails in GPC1; it
+                    // has since been replaced with 'burntool', which is applied upon readout
+                    // by the camera software, and therefore is aware of the image sequence.
                     if (REFSTAR_MASK_BLEED) {
-
                         // convert x,y chip coordinates to cells in maskChip
                         pmCell *refCell = pmCellInChip (refChip, ref->chip->x, ref->chip->y);
@@ -245 +253 @@
                 }
 
-                // select the raw objects for this readout (loaded in psastroExtract.c)
+                // select the ghost object for this readout (loaded in psastroExtractGhosts.c).
+                // These differ from the reference stars since the star position is not
+                // contained by the readout; instead, the ghost position is predicted based on
+                // the ghost model, and the ghost positions associated with a given readout are
+                // supplied here.
                 psArray *ghosts = psMetadataLookupPtr (&status, readout->analysis, "PSASTRO.GHOSTS");
-                if (ghosts == NULL) { continue; }
-
-                // identify the bright stars of interest
-                for (int i = 0; i < ghosts->n; i++) {
-                    psastroGhost *ghost = ghosts->data[i];
-                    // XXX bright vs faint ghost bits? (OR with SUSPECT) 
-                    psastroMaskEllipticalAnnulus (readoutMask->mask, ghostMaskValue, ghost->chip->x, ghost->chip->y, ghost->inner, ghost->outer);
-                }
-
-                // select the raw objects for this readout, flag is they fall in a mask
-                psArray *rawstars = psMetadataLookupPtr (&status, readout->analysis, "PSASTRO.RAWSTARS");
-                if (rawstars == NULL) return false;
+                if (ghosts) { 
+                    // mask the ghosts on this readout
+                    for (int i = 0; i < ghosts->n; i++) {
+                        psastroGhost *ghost = ghosts->data[i];
+                        // XXX bright vs faint ghost bits? (OR with SUSPECT) 
+                        psastroMaskEllipticalAnnulus (readoutMask->mask, ghostMaskValue, ghost->chip->x, ghost->chip->y, ghost->inner, ghost->outer);
+                    }
+                }
+
+                // Select the glint mask regions for this readout (loaded in
+                // psastroExtractGlints.c).  These glint regions are defined as rectangular
+                // boxes and are generated for each chip based on the position of the bright
+                // stars beyond the edge of the focal plane.  This masking is currently very
+                // GPC1-specific
+                psArray *glints = psMetadataLookupPtr (&status, readout->analysis, "PSASTRO.GLINTS");
+                if (glints) {
+                    // mask the glints on this readout
+                    for (int i = 0; i < glints->n; i++) {
+                        psRegion *glint = glints->data[i];
+                        psastroMaskRectangle (readoutMask->mask, glintMaskValue, glint->x0, glint->y0, glint->x1, glint->y1);
+                    }
+                }
+
+                // this probably should move into a function of its own:
+                {
+                    // select the raw objects for this readout, flag is they fall in a mask
+                    psArray *inSources = psMetadataLookupPtr (&status, readout->analysis, "PSPHOT.SOURCES");
+                    if (inSources == NULL) continue;
                 
-                // XXX finish this:
-                for (int i = 0; i < rawstars->n; i++) {
-                    pmAstromObj *raw = rawstars->data[i];
-                    psImageMaskType value = readoutMask->mask->data.PS_TYPE_IMAGE_MASK_DATA[(int)(raw->chip->x)][(int)(raw->chip->y)];
-                    if (value) continue;
+                    // create a replacement output array:
+                    // psArray *outSources = psAllocArrayEmpty(100);
+
+                    // XXX finish this: raise a bit for stars that land on certain types of masks;
+                    // others (eg, bright star core) should be ignored.
+                    for (int i = 0; i < inSources->n; i++) {
+                        pmSource *source = inSources->data[i];
+
+                        int xChip = source->peak->x;
+                        int yChip = source->peak->y;
+
+                        bool onChip = true;
+                        onChip &= (xChip >= 0);
+                        onChip &= (xChip < readoutMask->mask->numCols);
+                        onChip &= (yChip >= 0);
+                        onChip &= (yChip < readoutMask->mask->numRows);
+                        if (!onChip) {
+                            // if the source is off the edge of the chip, raise a different bit?
+                            source->mode |= PM_SOURCE_MODE_OFF_CHIP;
+                            continue;
+                        }
+
+                        psImageMaskType value = readoutMask->mask->data.PS_TYPE_IMAGE_MASK_DATA[yChip][xChip];
+                        if (value & ghostMaskValue) {
+                            source->mode |= PM_SOURCE_MODE_ON_GHOST;
+                        }
+                        // XXX note that for now, glint and ghost are identical
+                        pmSourceMode PM_SOURCE_MODE_ON_GLINT = PM_SOURCE_MODE_ON_GHOST;
+                        if (value & glintMaskValue) {
+                            source->mode |= PM_SOURCE_MODE_ON_GLINT;
+                        }
+                        if (value & spikeMaskValue) {
+                            source->mode |= PM_SOURCE_MODE_ON_SPIKE;
+                        }
+                    }
                 }
             }