IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 25210


Ignore:
Timestamp:
Aug 26, 2009, 4:56:14 PM (17 years ago)
Author:
watersc1
Message:

alterations to ppImage to allow masking of burntool remnants by ppImage.

Location:
branches/czw_branch/cleanup
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • branches/czw_branch/cleanup/extsrc/gpcsw/gpcsrc/fits/burntool/burnparams.h

    r23924 r25210  
    5555EXTERN int EXPIRE_TRAIL_TIME;   /* Expire trails after this interval */
    5656
     57EXTERN int PERSIST_RETAIN;      /* Retain bad-slope persistence fits */
     58
    5759#endif /* _INCLUDED_burnparams_ */

  • branches/czw_branch/cleanup/extsrc/gpcsw/gpcsrc/fits/burntool/burntool.c

    r24391 r25210  
    100100   EXPIRE_TRAIL_TIME = 2000;    /* Expire a persist after this [sec] */
    101101
     102   PERSIST_RETAIN = 0;          /* Retain persists with bad slopes? */
     103
    102104/* Parse the args */
    103105   cellxy = -1;
    … …  
    174176      } else if(strncmp(argv[i], "infits=", 7) == 0) { /* infits=fname */
    175177         persistfitsfile = argv[i] + 7;
     178
     179/* Keep persistence streaks which had a bad slope? */
     180      } else if(strncmp(argv[i], "persist=", 8) == 0) {/* persist={t|f} */
     181         PERSIST_RETAIN = argv[i][8] == 'y' || argv[i][8] == '1' || argv[i][8] == 't';
    176182
    177183/* Output file for PSF gallery */

  • branches/czw_branch/cleanup/extsrc/gpcsw/gpcsrc/fits/burntool/man/burntool.1

    r24391 r25210  
    5353        power laws; downward burns as exponentials.
    5454       
     55        The fit to downward, persistence burns may have an unreasonable "slope"
     56        (meaning exponential sign), increasing away from the burn origin.
     57        These are discarded unless "persist=t" is invoked.  It is possible
     58        for the fit to be fooled by uncataloged stars, so the persistence
     59        can be kept in the output file with "persist=t" (although no fit
     60        correction is applied) and they will propagate from input to output
     61        until they finally achieve a legal fit with negligible amplitude.
     62
    5563        Burntool also identifies really blasted areas which are saturated from
    5664        top to bottom.  These cannot be fitted, but are carried along for
    … …  
    231239                'in' takes precedence.
    232240
     241        persist={t|f}
     242                Retain persistence streaks whose fit slope turned out to be
     243                unreasonable.
     244
    233245        out=fname     
    234246                Output file for burn streaks
    … …  
    332344BUGS:
    333345        090224: Still in development
     346        090810: Squished a few memory bugs
    334347
    335348SEE ALSO:

  • branches/czw_branch/cleanup/extsrc/gpcsw/gpcsrc/fits/burntool/persist_fits.c

    r23924 r25210  
    222222      for(k=0; k<cell[j].npersist; k++)
    223223      {
    224          if(cell[j].persist[k].fiterr) continue;
    225          if(cell[j].persist[k].nfit <= 0) continue;
     224         if(PERSIST_RETAIN) {
     225/* Keep fits which have a dubious slope */
     226            if(cell[j].persist[k].fiterr != FIT_SLOPE_ERROR) {
     227               if(cell[j].persist[k].fiterr) continue;
     228               if(cell[j].persist[k].nfit <= 0) continue;
     229            }
     230         } else {
     231            if(cell[j].persist[k].fiterr) continue;
     232            if(cell[j].persist[k].nfit <= 0) continue;
     233         }
    226234         num_areas++;
    227235         num_fits += cell[j].persist[k].nfit;
    … …  
    232240      {
    233241         if(!cell[j].burn[k].burned) continue;
    234          if(cell[j].burn[k].fiterr &&
    235             cell[j].burn[k].fiterr != FIT_TOP_ERROR) continue;
    236          if(cell[j].burn[k].nfit <= 0) continue;
     242         if(PERSIST_RETAIN) {
     243/* Keep fits which have a dubious slope */
     244            if(cell[j].burn[k].fiterr != FIT_SLOPE_ERROR) {
     245               if(cell[j].burn[k].fiterr &&
     246                  cell[j].burn[k].fiterr != FIT_TOP_ERROR) continue;
     247               if(cell[j].burn[k].nfit <= 0) continue;
     248            }
     249         } else {
     250            if(cell[j].burn[k].fiterr &&
     251               cell[j].burn[k].fiterr != FIT_TOP_ERROR) continue;
     252            if(cell[j].burn[k].nfit <= 0) continue;
     253         }
    237254         num_areas++;
    238255         num_fits += cell[j].burn[k].nfit;
    … …  
    329346      for(k=0; k<cell[j].npersist; k++)
    330347      {
    331          if(cell[j].persist[k].fiterr) continue;
    332          if(cell[j].persist[k].nfit <= 0) continue;     
     348         if(PERSIST_RETAIN) {
     349/* Keep fits which have a dubious slope */
     350            if(cell[j].persist[k].fiterr != FIT_SLOPE_ERROR) {
     351               if(cell[j].persist[k].fiterr) continue;
     352               if(cell[j].persist[k].nfit <= 0) continue;     
     353            }
     354         } else {
     355            if(cell[j].persist[k].fiterr) continue;
     356            if(cell[j].persist[k].nfit <= 0) continue;     
     357         }
    333358
    334359         result = write_area_row(hu, data, table, row++, &(cell[j].persist[k]));
    … …  
    340365      {
    341366         if(!cell[j].burn[k].burned) continue;
    342          if(cell[j].burn[k].fiterr &&
    343             cell[j].burn[k].fiterr != FIT_TOP_ERROR) continue;
    344          if(cell[j].burn[k].nfit <= 0) continue;
     367         if(PERSIST_RETAIN) {
     368/* Keep fits which have a dubious slope */
     369            if(cell[j].burn[k].fiterr != FIT_SLOPE_ERROR) {
     370               if(cell[j].burn[k].fiterr &&
     371                  cell[j].burn[k].fiterr != FIT_TOP_ERROR) continue;
     372               if(cell[j].burn[k].nfit <= 0) continue;
     373            }
     374         } else {
     375            if(cell[j].burn[k].fiterr &&
     376               cell[j].burn[k].fiterr != FIT_TOP_ERROR) continue;
     377            if(cell[j].burn[k].nfit <= 0) continue;
     378         }
    345379
    346380         result = write_area_row(hu, data, table, row++, &(cell[j].burn[k]));
    … …  
    426460      for(k=0; k<cell[j].npersist; k++)
    427461      {
    428          if(cell[j].persist[k].fiterr) continue;
     462         if(PERSIST_RETAIN) {
     463/* Keep fits which have a dubious slope */
     464            if(cell[j].persist[k].fiterr != FIT_SLOPE_ERROR) {
     465               if(cell[j].persist[k].fiterr) continue;
     466            }
     467         } else {
     468            if(cell[j].persist[k].fiterr) continue;
     469         }
    429470         for(i=0; i<cell[j].persist[k].nfit; i++)
    430471         {
    … …  
    441482      {
    442483         if(!cell[j].burn[k].burned) continue;
    443          if(cell[j].burn[k].fiterr &&
    444             cell[j].burn[k].fiterr != FIT_TOP_ERROR) continue;
     484         if(PERSIST_RETAIN) {
     485/* Keep fits which have a dubious slope */
     486            if(cell[j].burn[k].fiterr != FIT_SLOPE_ERROR) {
     487               if(cell[j].burn[k].fiterr &&
     488                  cell[j].burn[k].fiterr != FIT_TOP_ERROR) continue;
     489            }
     490         } else {
     491            if(cell[j].burn[k].fiterr &&
     492               cell[j].burn[k].fiterr != FIT_TOP_ERROR) continue;
     493         }
    445494
    446495         for(i=0; i<cell[j].burn[k].nfit; i++)

  • branches/czw_branch/cleanup/extsrc/gpcsw/gpcsrc/fits/burntool/persistio.c

    r23924 r25210  
    5151             &boxbuf[nbox].slope, &boxbuf[nbox].nfit,
    5252             &boxbuf[nbox].sxfit, &boxbuf[nbox].exfit);
    53       if(boxbuf[nbox].nfit <= 0) continue;
    54       boxbuf[nbox].zero = (double *)calloc(boxbuf[nbox].nfit, sizeof(double));
    55       boxbuf[nbox].xfit = (int *)calloc(boxbuf[nbox].nfit, sizeof(int));
    56       boxbuf[nbox].yfit = (int *)calloc(boxbuf[nbox].nfit, sizeof(int));
    57       for(i=0; i<boxbuf[nbox].nfit; i++) {
    58          if(fgets(line, 1024, fp) == NULL) {
    59             fprintf(stderr, "\rerror: short read of burn lines\n");
    60             return(-1);
    61          }
    62          sscanf(line, "%d %d %lf\n", &boxbuf[nbox].xfit[i],
    63                 &boxbuf[nbox].yfit[i], &boxbuf[nbox].zero[i]);
     53      if(boxbuf[nbox].nfit > 0) {
     54         boxbuf[nbox].zero = (double *)calloc(boxbuf[nbox].nfit, sizeof(double));
     55         boxbuf[nbox].xfit = (int *)calloc(boxbuf[nbox].nfit, sizeof(int));
     56         boxbuf[nbox].yfit = (int *)calloc(boxbuf[nbox].nfit, sizeof(int));
     57         for(i=0; i<boxbuf[nbox].nfit; i++) {
     58            if(fgets(line, 1024, fp) == NULL) {
     59               fprintf(stderr, "\rerror: short read of burn lines\n");
     60               return(-1);
     61            }
     62            sscanf(line, "%d %d %lf\n", &boxbuf[nbox].xfit[i],
     63                   &boxbuf[nbox].yfit[i], &boxbuf[nbox].zero[i]);
     64         }
    6465      }
    6566      boxbuf[nbox].fiterr = 0;
    … …  
    147148      for(kp=0; kp<n; kp++) {
    148149         k = boxid[kp];
    149          zk = box[k].zero[box[k].nfit/2];
     150         zk = 0.0;
     151         if(box[k].nfit > 0) zk = box[k].zero[box[k].nfit/2];
    150152         for(jp=kp+1; jp<n; jp++) {
    151153            j = boxid[jp];
    152             zj = box[j].zero[box[j].nfit/2];
     154            zj = 0.0;
     155            if(box[j].nfit > 0) zj = box[j].zero[box[j].nfit/2];
    153156            if(ABS(yctr[jp]-yctr[kp]) > DIFFERENT_STREAK) {
    154157/* Trim back the feebler streak */
    … …  
    238241/* First: patched up persists */
    239242      for(k=0; k<cell[j].npersist; k++) {
    240          if(cell[j].persist[k].fiterr) continue;
    241          if(cell[j].persist[k].nfit <= 0) continue;
     243
     244         if(PERSIST_RETAIN) {
     245/* Keep fits which have a dubious slope */
     246            if(cell[j].persist[k].fiterr != FIT_SLOPE_ERROR) {
     247               if(cell[j].persist[k].fiterr) continue;
     248               if(cell[j].persist[k].nfit <= 0) continue;
     249            }
     250         } else {
     251            if(cell[j].persist[k].fiterr) continue;
     252            if(cell[j].persist[k].nfit <= 0) continue;
     253         }
    242254         fprintf(fp, "%3d %7d  %3d %3d %5d %3d  %3d %3d  %3d %3d  %3d %3d %3d %3d %3d %3d %3d %3d  %1d %1d %9.6f %3d %3d %3d\n",
    243255                 j, cell[j].persist[k].time,
    … …  
    262274      for(k=0; k<cell[j].nburn; k++) {
    263275         if(!cell[j].burn[k].burned) continue;
    264          if(cell[j].burn[k].fiterr &&
    265             cell[j].burn[k].fiterr != FIT_TOP_ERROR) continue;
    266          if(cell[j].burn[k].nfit <= 0) continue;
     276         if(PERSIST_RETAIN) {
     277/* Keep fits which have a dubious slope */
     278            if(cell[j].burn[k].fiterr != FIT_SLOPE_ERROR) {
     279               if(cell[j].burn[k].fiterr &&
     280                  cell[j].burn[k].fiterr != FIT_TOP_ERROR) continue;
     281               if(cell[j].burn[k].nfit <= 0) continue;
     282            }
     283         } else {
     284            if(cell[j].burn[k].fiterr &&
     285               cell[j].burn[k].fiterr != FIT_TOP_ERROR) continue;
     286            if(cell[j].burn[k].nfit <= 0) continue;
     287         }
    267288
    268289         i = (cell[j].burn[k].ex - cell[j].burn[k].sx + 1) / 2;

  • branches/czw_branch/cleanup/extsrc/gpcsw/gpcsrc/fits/burntool/trailfit.c

    r25145 r25210  
    226226/* FIXME: sanity check fits */
    227227   if(slope >= FIT_MAX_SLOPE || slope < FIT_MIN_SLOPE) {
     228      box->slope = slope;
     229      box->nfit = 0;
    228230      box->fiterr = FIT_SLOPE_ERROR;
    229231      return(-1);

  • branches/czw_branch/cleanup/extsrc/gpcsw/gpcsrc/fits/libfh/fh.c

    r24391 r25210  
    10391039         newval[strlen(newval) - 1] = '\0';
    10401040         fh_set_str(hu, idx, name, newval, comment);
     1041         free(newval);
    10411042         return;
    10421043      }
    … …  
    15191520      i++;
    15201521   }
     1522   return FH_SUCCESS;
     1523}
     1524
     1525static void
     1526pad_header(HeaderUnit hu, int n)
     1527{
     1528   int i;
     1529   double idx = 900000000;
     1530
     1531   for (i = 0; i < n; i++)
     1532   {
     1533      fh_set_card(hu, idx++, FH_RESERVE);
     1534   }
     1535}
     1536
     1537fh_result
     1538fh_copy(HeaderUnit hu, const HeaderUnit source_)
     1539{
     1540   fh_result result;
     1541   int reserve;
     1542
     1543   result = fh_merge(hu, source_);
     1544   if (result != FH_SUCCESS) return result;
     1545   reserve = fh_get_reserve(source_);
     1546   if (reserve) pad_header(hu, reserve);
    15211547   return FH_SUCCESS;
    15221548}
    … …  
    17571783}
    17581784
     1785int
     1786fh_get_reserve(HeaderUnit hu)
     1787{
     1788   HeaderUnitStruct* list = FH_HU(hu);
     1789
     1790   if (!list)
     1791   {
     1792      log_error("invalid argument to fh_get_reserve()");
     1793      return -1;
     1794   }
     1795
     1796   if (list->reserve)
     1797      return list->reserve;
     1798   else
     1799      return list->reserve_found;
     1800}
     1801
    17591802fh_result
    17601803fh_rewrite(HeaderUnit hu)

  • branches/czw_branch/cleanup/extsrc/gpcsw/gpcsrc/fits/libfh/fh.h

    r23924 r25210  
    174174 * is used to create a new FITS header.  NOT for use with fh_rewrite().
    175175 */
     176int fh_get_reserve(HeaderUnit hu);
     177/*
     178 * Get the current setting or the number of reserve cards found in
     179 * a header unit.  Returns -1 if hu is invalid.
     180 */
    176181fh_result fh_validate(HeaderUnit hu); /* fh_validate.c; for use by fhtool.c */
    177182
    … …  
    386391double fh_idx(HeaderUnit hu); /* idx of the last card returned by fh_next */
    387392fh_result fh_merge(HeaderUnit hu, const HeaderUnit source); /* source unchanged */
     393fh_result fh_copy(HeaderUnit hu, const HeaderUnit source); /* fh_merge+keep reserve */
    388394
    389395/* ---------------------------------------------------------
    … …  
    459465 */
    460466
    461 
    462467#endif /* _INCLUDED_fh */

  • branches/czw_branch/cleanup/ippTools/src/pxchip.c

    r25149 r25210  
    6969    psMetadataAddF64(md,  PS_LIST_TAIL, "-posang_min",         0, "search by min rotator position angle", NAN);
    7070    psMetadataAddF64(md,  PS_LIST_TAIL, "-posang_max",         0, "search by max rotator position angle", NAN);
    71 <<<<<<< .mine
    72 =======
    7371    psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_min",         0, "search by min solar angle", NAN);
    7472    psMetadataAddF32(md,  PS_LIST_TAIL, "-sun_angle_max",         0, "search by max solar angle", NAN);
    75     psMetadataAddStr(md,  PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
    76 >>>>>>> .r25099
    7773    psMetadataAddStr(md,  PS_LIST_TAIL, "-object",             0, "search by exposure object", NULL);
    7874    psMetadataAddStr(md,  PS_LIST_TAIL, "-comment",            0, "search by comment field (LIKE comparison)", NULL);

  • branches/czw_branch/cleanup/ippconfig/recipes/masks.16bit.config

    r23498 r25210  
    2020
    2121# Mask values which represent non-astronomical structures
     22BURNTOOL        U16     0x0080          # Pixel may contain uncorrected streak.
    2223CR              U16     0x0100          # Pixel contains a cosmic ray
    2324SPIKE           U16     0x0200          # Pixel contains a diffraction spike

  • branches/czw_branch/cleanup/ippconfig/recipes/ppImage.config

    r24951 r25210  
    1616MASK.SATURATED     BOOL    TRUE            # Mask the saturated pixels
    1717MASK.LOW           BOOL    TRUE            # Mask pixels below valid range
     18MASK.BURNTOOL      BOOL    TRUE            # Mask potential burntool trails
    1819VARIANCE.BUILD     BOOL    FALSE           # Build internal variance image
    1920PATTERN            BOOL    FALSE           # Fit and remove pattern noise?
    … …  
    5455## if we use multithreaded detrending, detrend this number of rows per thread
    5556SCAN.ROWS        S32     100
     57
     58BURNTOOL.TRAILS U16 0x01
    5659
    5760# Non-linearity correction

  • branches/czw_branch/cleanup/ppImage/src/ppImage.h

    r24951 r25210  
    2626    bool doMaskBuild;                   // Build internal mask
    2727    bool doVarianceBuild;               // Build internal variance map
     28    bool doMaskBurntool;                // mask potential burntool trails
    2829    bool doMaskSat;                     // mask saturated pixels
    2930    bool doMaskLow;                     // mask low pixels
    … …  
    7475    psImageMaskType darkMask;           // Mask value to give bad dark pixels
    7576    psImageMaskType blankMask;          // Mask value to give blank pixels
    76 
     77    psImageMaskType burntoolMask;       // Suspect pixels that fall where a burntool trail is expected.
    7778    // non-linear correction parameters
    7879    psDataType nonLinearType;
    … …  
    8283    // options for the analysis
    8384    pmOverscanOptions *overscan;        // Overscan options
    84 
     85    int burntoolTrails;
    8586    // binning parameters
    8687    int xBin1;                          // x-binning, scale 1
    … …  
    156157bool ppImageCheckCTE(pmConfig *config, ppImageOptions *options, pmFPAview *view);
    157158
     159bool ppImageBurntoolMask(pmConfig *config, ppImageOptions *options, pmFPAview *view, pmReadout *mask);
     160
    158161// Record which detrend file was used for the detrending
    159162bool ppImageDetrendRecord(

  • branches/czw_branch/cleanup/ppImage/src/ppImageBurntoolMask.c

    r25159 r25210  
    33#endif
    44
     5#define PPIMAGE_BURNTOOL_DEBUG 1
     6
    57#include "ppImage.h"
    68
    7 bool ppImageBurntoolMask (pmConfig *config, ppImageOptions *options, pmFPAview *view) {
    8 
     9bool ppImageBurntoolMask (pmConfig *config, ppImageOptions *options, pmFPAview *view,pmReadout *mask) {
    910  bool status = true;
     11  int burntool_cell;
     12  /* Find input filename */
    1013  pmFPAfile *inputFile = psMetadataLookupPtr(&status , config->files, "PPIMAGE.INPUT");
    1114  if (!status) {
    … …  
    1316    return(false);
    1417  }
    15 
    1618  psFits *fits = inputFile->fits;
    1719
     20  /* Read input header, and find the burntool data table. */
     21  psMetadata *phu = psFitsReadHeader(NULL, fits);
     22 
    1823  if (!psFitsMoveExtName(fits,"burntool_areas")) {
    1924    psError(PS_ERR_IO,false, "Unable to find extension burntool_areas");
    … …  
    2126  }
    2227  long Nrows = psFitsTableSize(fits); 
     28
    2329  long row = 0;
    24  
    25   pmFPAview *detview = pmFPAviewAlloc(0);
    26   *detview = *view;
    27   detview->readout = 0;
    28   pmReadout *mask = pmFPAfileThisReadout(config->files,detview,"PPIMAGE.MASK");
     30
     31  psLogMsg ("ppImageBurntoolMask", 4, "Inside burntool mask %ld", Nrows);
     32
     33  /* Redirects and Memory juggling. */
     34  view->readout = 0;
    2935  psImage *image = mask->mask;
    3036
    31   psImageMaskType maskValue = psMetadataLookupS32(&status,config->files,"PPIMAGE.BURNTOOL_MASK");
    3237 
     38  /* Set the maskValue from the recipes. */
     39  psImageMaskType maskValue = options->burntoolMask;
     40#ifdef PPIMAGE_BURNTOOL_DEBUG
     41  psLogMsg("ppImageBurntoolMask", 4, "Status: %ld %d\n",Nrows,maskValue);
     42#endif
     43
     44  burntool_cell = view->cell;
     45  burntool_cell = (view->cell % 8) * 8 + (view->cell - (view->cell % 8)) / 8;
     46  psLogMsg("ppImageBurntoolMask", 4, "Cell mapping: %d %d %d\n",view->cell,burntool_cell,-1);
    3347  for (row = 0; row < Nrows; row++) {
    3448    psMetadata *rowMD = psFitsReadTableRow(fits,row);
    3549
    36     if (psMetadataLookupS32(&status,rowMD,"cell") == detview->cell) {
    37 
    38       if (psMetadataLookupS32(&status,rowMD,"func") != -1) { // This should be an actual check
    39 
     50    if (psMetadataLookupS32(&status,rowMD,"cell") == burntool_cell) {
     51      if (((options->burntoolTrails & 0x01)&&(psMetadataLookupS32(&status,rowMD,"nfit") == 0))||
     52          ((options->burntoolTrails & 0x02)&&(psMetadataLookupS32(&status,rowMD,"up") == 1))||
     53          ((options->burntoolTrails & 0x04)&&(psMetadataLookupS32(&status,rowMD,"up") == 0))) {
     54        /*       If the fit fails, burntool reports zero here.  This
     55                 signifies that it expected to see a trail (else why
     56                 fit) but did not find it when it attempted to
     57                 correct. */
     58#ifdef PPIMAGE_BURNTOOL_DEBUG
     59        psLogMsg ("ppImageBurntoolMask", 4, "Masking! %d (%d %d %d) %d %d",
     60                  psMetadataLookupS32(&status,rowMD,"cell"),
     61                  ((options->burntoolTrails & 0x0001)&&(psMetadataLookupS32(&status,rowMD,"nfit") == 0)),
     62                  ((options->burntoolTrails & 0x02)&&(psMetadataLookupS32(&status,rowMD,"up") == 1)),
     63                  ((options->burntoolTrails & 0x04)&&(psMetadataLookupS32(&status,rowMD,"up") == 0)),
     64                  options->burntoolTrails,
     65                  maskValue
     66                  );
     67#endif
    4068        for (int i = psMetadataLookupS32(&status,rowMD,"sxfit");
    4169             i <= psMetadataLookupS32(&status,rowMD,"exfit");
    … …  
    4472          if (psMetadataLookupS32(&status,rowMD,"up") == 0) {
    4573            for (int j = 0; j <= psMetadataLookupS32(&status,rowMD,"y1p"); j++) {
     74/* #ifdef PPIMAGE_BURNTOOL_DEBUG */
     75/*            psLogMsg("ppImageBurntoolMask", 4, "Noisy!: %d %d %d %d\n", */
     76/*                     i,j,image->data.PS_TYPE_IMAGE_MASK_DATA[j][i],maskValue); */
     77/* #endif */
    4678              image->data.PS_TYPE_IMAGE_MASK_DATA[j][i] |= maskValue;
    4779            }
    … …  
    4981          else {
    5082            for (int j = psMetadataLookupS32(&status,rowMD,"y1m"); j < image->numRows ; j++) {
     83/* #ifdef PPIMAGE_BURNTOOL_DEBUG */
     84/*            psLogMsg("ppImageBurntoolMask", 4, "Noisy!: %d %d %d %d\n", */
     85/*                     i,j,image->data.PS_TYPE_IMAGE_MASK_DATA[j][i],maskValue); */
     86/* #endif */
    5187              image->data.PS_TYPE_IMAGE_MASK_DATA[j][i] |= maskValue;
    5288            }
    … …  
    5692      }
    5793    }
     94    psFree(rowMD);
    5895  }
    59 
     96  psFree(phu);
    6097  return(status);
    6198}

  • branches/czw_branch/cleanup/ppImage/src/ppImageDetrendReadout.c

    r24951 r25210  
    2626        pmMaskBadPixels(input, mask, options->maskValue);
    2727    }
     28    if (options->doMaskBurntool) {
     29      ppImageBurntoolMask(config,options,view,input);
     30    }
     31
    2832
    2933# if 0

  • branches/czw_branch/cleanup/ppImage/src/ppImageOptions.c

    r24951 r25210  
    2121    options->doMaskSat       = false;   // mask saturated pixels
    2222    options->doMaskLow       = false;   // mask low pixels
     23    options->doMaskBurntool  = false;   // mask potential burntool trails
    2324    options->doVarianceBuild = false;   // Build internal variance
    2425    options->doMask          = false;   // Mask bad pixels
    … …  
    6465    options->blankMask       = 0x00;    // Blank (no data, cell gap) pixels (supplied to pmChipMosaic, pmFPAMosaic)
    6566    options->markValue       = 0x00;    // A safe bit for internal marking
    66 
     67    options->burntoolMask    = 0x00;    // Suspect pixels that fall where a burntool trail is expected.
     68    options->burntoolTrails  = 0x00;    // Which types of burntool areas to mask.
    6769    // crosstalk options
    6870    options->doCrosstalkMeasure = false;   // measure crosstalk
    … …  
    219221    options->doMaskSat   = psMetadataLookupBool(NULL, recipe, "MASK.SATURATED");
    220222    options->doMaskLow   = psMetadataLookupBool(NULL, recipe, "MASK.LOW");
     223    options->doMaskBurntool = psMetadataLookupBool(NULL, recipe, "MASK.BURNTOOL");
    221224    options->doVarianceBuild = psMetadataLookupBool(NULL, recipe, "VARIANCE.BUILD");
    222225
    … …  
    245248    options->applyParity = psMetadataLookupBool(NULL, recipe, "APPLY.CELL.PARITY");
    246249
     250    options->burntoolTrails = psMetadataLookupU16(&status, recipe, "BURNTOOL.TRAILS");
     251    if (!status) {
     252      psWarning("BURNTOOL.TRAILS not found in recipe: setting to default value.\n");
     253    }
     254   
    247255    // binned image options
    248256    options->xBin1 = psMetadataLookupS32(&status, recipe, "BIN1.XBIN");
    249257    if (!status) {
    250258        psWarning("BIN1.XBIN not found in recipe: setting to default value.\n");
     259        options->xBin1 = 4;
    251260    }
    252261    options->yBin1 = psMetadataLookupS32(&status, recipe, "BIN1.YBIN");
    253262    if (!status) {
    254263        psWarning("BIN1.YBIN not found in recipe: setting to default value.\n");
    255         options->yBin1 = 16;
     264        options->yBin1 = 4;
    256265    }
    257266

  • branches/czw_branch/cleanup/ppImage/src/ppImageSetMaskBits.c

    r24079 r25210  
    3838    psAssert (options->lowMask, "low mask not set");
    3939
     40    // mask for suspect regions due to burntool
     41    options->burntoolMask = pmConfigMaskGet("BURNTOOL",config);
     42    psAssert (options->burntoolMask, "burntool mask not set");
     43   
    4044    // save MASK and MARK on the PSPHOT recipe
    4145    psMetadata *recipe = psMetadataLookupPtr (NULL, config->recipes, PSPHOT_RECIPE);
Note: See TracChangeset for help on using the changeset viewer.