IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 25299 for trunk/extsrc


Ignore:
Timestamp:
Sep 8, 2009, 5:32:55 PM (17 years ago)
Author:
watersc1
Message:

Merge my branch back into the trunk. This includes:

ipp_cleanup.pl : and associated edits to allow cleanup to work
burntool : updated to newest version, ipp_apply_burntool.pl modified to use persist=t options
ppImageBurntoolMask.c : masks region burntool identifies
psastro : allow selection of wcs header format
addtool : splits addstar step off from the camera stage

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk

  • trunk/extsrc/gpcsw/gpcsrc/fits/burntool/burnparams.h

    r23924 r25299  
    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_ */

  • trunk/extsrc/gpcsw/gpcsrc/fits/burntool/burntool.c

    r24391 r25299  
    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 */

  • trunk/extsrc/gpcsw/gpcsrc/fits/burntool/man/burntool.1

    r24391 r25299  
    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:

  • trunk/extsrc/gpcsw/gpcsrc/fits/burntool/persist_fits.c

    r23924 r25299  
    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++)

  • trunk/extsrc/gpcsw/gpcsrc/fits/burntool/persistio.c

    r23924 r25299  
    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;

  • trunk/extsrc/gpcsw/gpcsrc/fits/burntool/trailfit.c

    r25070 r25299  
    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);

  • trunk/extsrc/gpcsw/gpcsrc/fits/libfh/fh.c

    r24391 r25299  
    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)

  • trunk/extsrc/gpcsw/gpcsrc/fits/libfh/fh.h

    r23924 r25299  
    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 */
Note: See TracChangeset for help on using the changeset viewer.