Changeset 29938

trunk/Ohana/src/addstar/Makefile

r27582	r29938
72	72	$(SRC)/replace_match.$(ARCH).o \
73	73	$(SRC)/resort_catalog.$(ARCH).o \
	74	$(SRC)/resort_threaded.$(ARCH).o \
	75	$(SRC)/resort_unthreaded.$(ARCH).o \
74	76	$(SRC)/StarOps.$(ARCH).o \
75	77	$(SRC)/ReadStarsFITS.$(ARCH).o \

trunk/Ohana/src/addstar/include/addstar.h

-              r29541
+              r29938
 float   ZPT_ERR_PHU;
+int     OLD_RESORT;
 // carries the mosaic into gstars
 …
 double MIN_FWHM_X;
 double MIN_FWHM_Y;
+int    NTHREADS;
 /* modify server behavior (make this an addstar cleanup mode?) */
 …
 Stars     *rd_gsc                 PROTO((char *filename, unsigned int *nstars));
 int        replace_match          PROTO((Average *average, Measure *measure, Stars *star));
+int        resort_threaded        PROTO((AddstarClientOptions *options, SkyTable *sky));
+int        resort_unthreaded      PROTO((AddstarClientOptions *options, SkyTable *sky));
 void       resort_catalog         PROTO((Catalog *catalog));
+void       resort_catalog_old     PROTO((Catalog *catalog));
 Stars     *ReadStarsFITS          PROTO((FILE *f, Header *header, Header *in_theader, unsigned int *nstars));
 Stars     *ReadStarsTEXT          PROTO((FILE *f, unsigned int *nstars));

trunk/Ohana/src/addstar/src/ReadStarsFITS.c

r29541	r29938
22	22
23	23	/* load the table data */
24		if (!gfits_fread_ftable_data (f, &table)) {
	24	if (!gfits_fread_ftable_data (f, &table, FALSE)) {
25	25	fprintf (stderr, "ERROR: can't read table header\n");
26	26	exit (1);

trunk/Ohana/src/addstar/src/ReadStarsSDSS.c

r28939	r29938
60	60
61	61	/* load the table data */
62		if (!gfits_fread_ftable_data (f, &table)) {
	62	if (!gfits_fread_ftable_data (f, &table, FALSE)) {
63	63	fprintf (stderr, "ERROR: can't read table header\n");
64	64	exit (1);

trunk/Ohana/src/addstar/src/addstar.c

-              r28241
+              r29938
   SkyTableSetFilenames (sky, CATDIR, "cpt");
+  if (options.mode == M_RESORT) {
+    if (NTHREADS == 0) {
+      resort_unthreaded (&options, sky);
+    } else {
+      resort_threaded (&options, sky);
+    }
+    exit (0);
+  }
   stars = NULL;
 …
+        }
+        resort_catalog (&catalog);
+        if (OLD_RESORT) {
+          resort_catalog_old (&catalog);
+        } else {
+          resort_catalog (&catalog);
+        }
         Nsubset = 1;
         break;

trunk/Ohana/src/addstar/src/args.c

-              r27392
+              r29938
     remove_argument (N, &argc, argv);
+  }
+  OLD_RESORT = FALSE;
+  if ((N = get_argument (argc, argv, "-old-resort"))) {
+    remove_argument (N, &argc, argv);
+    OLD_RESORT = TRUE;
+  }
   if ((N = get_argument (argc, argv, "-fakeimage"))) {
     options.mode = M_FAKEIMAGE;
 …
     remove_argument (N, &argc, argv);
     PMM_CCD_TABLE = strcreate (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  // number of worker threads for resort (must have at least one worker thread)
+  NTHREADS = 0;
+  if ((N = get_argument (argc, argv, "-threads"))) {
+    remove_argument (N, &argc, argv);
+    NTHREADS = MAX(0, atoi (argv[N]));
     remove_argument (N, &argc, argv);
+  }

trunk/Ohana/src/addstar/src/resort_catalog.c

-              r27435
+              r29938
 # include "addstar.h"
 void resort_catalog (Catalog *catalog) {
+void resort_catalog_old (Catalog *catalog) {
   off_t *next_meas;
 …
   return;
+}
+# define myAbort(MSG) { fprintf (stderr, "%s\n", MSG); abort(); }
+# define myAssert(LOGIC,MSG) { if (!(LOGIC)) { fprintf (stderr, "%s\n", MSG); abort(); } }
+// sort the measure Sequence based on the average Sequence entries
+void SortAveMeasMatch (off_t *MEAS, off_t *AVE, off_t N) {
+# define SWAPFUNC(A,B){ off_t tmp_meas; off_t tmp_ave;  \
+    tmp_meas = MEAS[A]; MEAS[A] = MEAS[B]; MEAS[B] = tmp_meas;          \
+    tmp_ave  = AVE[A];  AVE[A]  = AVE[B];  AVE[B]  = tmp_ave;           \
+  }
+# define COMPARE(A,B)(MEAS[A] < MEAS[B])
+  OHANA_SORT (N, COMPARE, SWAPFUNC);
+# undef SWAPFUNC
+# undef COMPARE
+}
+# define MARKTIME(MSG,...) { \
+  float dtime; \
+  gettimeofday (&stop, (void *) NULL); \
+  dtime = DTIME (stop, start); start = stop; \
+  fprintf (stderr, MSG, __VA_ARGS__); }
+// XXX : where is the time going?  perhaps the ALLOCATE?
+// XXX : I don't thnk his is getting the right answer yet.
+void resort_catalog (Catalog *catalog) {
+  off_t Naverage, Nmeasure;
+  Measure *measure;
+  Average *average;
+  off_t i, j, N, currentAve;
+  off_t *measureSeq = NULL;
+  off_t *averageSeq = NULL;
+  Measure *measureTMP = NULL;
+  if (catalog[0].sorted == TRUE) return;
+  // struct timeval start, stop;
+  // gettimeofday (&start, NULL);
+  /* internal counters */
+  Nmeasure = catalog[0].Nmeasure;
+  Naverage = catalog[0].Naverage;
+  measure = catalog[0].measure;
+  average = catalog[0].average;
+  // we have a table of average objects and an unsorted table of measurements.  each measurement
+  // has a reference to the average object sequence (as well as an ID)
+  // measure[i].averef -> average[averef]
+  // measure[i].objID = average[averef].objID
+  // measure[i].catID = average[averef].catID
+  // we want a sorted measure array with all averef entries in sequence
+  ALLOCATE (measureSeq, off_t,   Nmeasure);
+  ALLOCATE (averageSeq, off_t,   Nmeasure);
+  for (i = 0; i < Nmeasure; i++) {
+    measureSeq[i] = i;
+    averageSeq[i] = measure[i].averef;
+    myAssert(average[averageSeq[i]].objID == measure[measureSeq[i]].objID, "object / detection mismatch");
+    myAssert(average[averageSeq[i]].catID == measure[measureSeq[i]].catID, "object / detection mismatch");
+  }
+  SortAveMeasMatch(measureSeq, averageSeq, Nmeasure);
+  // MARKTIME("sort : %f sec\n", dtime);
+  // copy the measurements in the sorted order
+  ALLOCATE (measureTMP, Measure, Nmeasure);
+  for (i = 0; i < Nmeasure; i++) {
+    j = measureSeq[i];
+    measureTMP[i] = measure[j];
+  }
+  // MARKTIME("assign measure : %f sec\n", dtime);
+  // update the values of average.measureOffset and average.Nmeasure
+  FREE(measure);
+  catalog[0].measure = measureTMP;
+  N = 0;
+  currentAve = averageSeq[0];
+  average[currentAve].measureOffset = 0;
+  for (i = 0; i < Nmeasure; i++) {
+    if (averageSeq[i] != currentAve) {
+      average[currentAve].Nmeasure = N;
+      N = 0;
+      currentAve = averageSeq[i];
+      average[currentAve].measureOffset = i;
+    }
+    N++;
+  }
+  N++;
+  average[currentAve].Nmeasure = N;
+  // MARKTIME("update Nmeasure : %f sec\n", dtime);
+  // MARKTIME("  match time %9.4f sec for %7lld measures, %6lld average\n", dtime, (long long) Nmeasure, (long long) Naverage);
+  FREE (measureSeq);
+  FREE (averageSeq);
+  return;
+}

trunk/Ohana/src/addstar/test/dvomerge.dvo

-              r29001
+              r29938
 # create 2 populated catdirs, each with a couple of cmf files
 macro test.dvomerge.update
+macro test.dvomerge.continue
   tapPLAN 51
 …
   mkinput
+  exec mkcmf test.in.txt test.cmf -date 2008/1/1 -time 01:00:00 -radec 10.0 20.0
+  exec addstar -D CATDIR catdir.test1 -D CAMERA simtest test.cmf
+  exec mkcmf test.in.txt test.cmf -date 2008/1/1 -time 02:00:00 -radec 10.0 20.0
+  exec addstar -D CATDIR catdir.test1 -D CAMERA simtest test.cmf
+  exec mkcmf test.in.txt test.cmf -date 2008/1/1 -time 03:00:00 -radec 9.9 20.0
+  exec addstar -D CATDIR catdir.test2 -D CAMERA simtest test.cmf
+  exec mkcmf test.in.txt test.cmf -date 2008/1/1 -time 04:00:00 -radec 9.9 20.0
+  exec addstar -D CATDIR catdir.test2 -D CAMERA simtest test.cmf
+  exec mkcmf test.in.txt test.cmf -date 2008/1/1 -time 05:00:00 -radec 10.0 19.9
+  exec addstar -D CATDIR catdir.test1 -D CAMERA simtest test.cmf
+  exec mkcmf test.in.txt test.cmf -date 2008/1/1 -time 06:00:00 -radec 10.0 19.9
+  exec addstar -D CATDIR catdir.test1 -D CAMERA simtest test.cmf
+  exec mkcmf test.in.txt test.cmf -date 2008/1/1 -time 07:00:00 -radec 9.9 19.9
+  exec addstar -D CATDIR catdir.test2 -D CAMERA simtest test.cmf
+  exec mkcmf test.in.txt test.cmf -date 2008/1/1 -time 08:00:00 -radec 9.9 19.9
+  exec addstar -D CATDIR catdir.test2 -D CAMERA simtest test.cmf
+  break
+  exec rsync -auc catdir.test2/ catdir.test3/
+  date -var t1 -seconds -reftime 1276000000
+  exec dvomerge catdir.test1 into catdir.test3
+  date -var t2 -seconds -reftime 1276000000
+  echo "merge time: {$t2 - $t1}"
+  catdir catdir.test3
+  skyregion {$RA-1} {$RA+1} {$DEC-1} {$DEC+1}
+  mextract ra dec mag
+  create n 0 ra[]
+  subset r0 = ra if (n % 4 == 0)
+  subset r1 = ra if (n % 4 == 1)
+  subset r2 = ra if (n % 4 == 2)
+  subset r3 = ra if (n % 4 == 3)
+  catdir catdir.test1/
+  mextract RA DEC MAG
+  create N 0 RA[]
+  subset R0 = RA if (N % 2 == 0)
+  subset R1 = RA if (N % 2 == 1)
+  set dr0 = r0 - R0
+  vstat -q dr0
+  tapOK {abs($MEAN)  < 0.001} "ra (in - 0) vs ra (out - 0) (MEAN)"
+  tapOK {abs($SIGMA) < 0.001} "ra (in - 0) vs ra (out - 0) (SIGMA)"
+  set dr1 = r1 - R1
+  vstat -q dr1
+  tapOK {abs($MEAN)  < 0.001} "ra (in - 0) vs ra (out - 0) (MEAN)"
+  tapOK {abs($SIGMA) < 0.001} "ra (in - 0) vs ra (out - 0) (SIGMA)"
+  catdir catdir.test2/
+  mextract RA DEC MAG
+  create N 0 RA[]
+  subset R2 = RA if (N % 2 == 0)
+  subset R3 = RA if (N % 2 == 1)
+  set dr2 = r2 - R2
+  vstat -q dr2
+  tapOK {abs($MEAN)  < 0.001} "ra (in - 0) vs ra (out - 0) (MEAN)"
+  tapOK {abs($SIGMA) < 0.001} "ra (in - 0) vs ra (out - 0) (SIGMA)"
+  set dr3 = r3 - R3
+  vstat -q dr3
+  tapOK {abs($MEAN)  < 0.001} "ra (in - 0) vs ra (out - 0) (MEAN)"
+  tapOK {abs($SIGMA) < 0.001} "ra (in - 0) vs ra (out - 0) (SIGMA)"
+  # check on updates to imageID
+  catdir catdir.test3
+  imextract imageID
+  sort imageID
+  tapOK {imageID[]  == 4} "image IDs exist"
+  tapOK {imageID[0] == 1} "updated image IDs"
+  tapOK {imageID[1] == 2} "updated image IDs"
+  tapOK {imageID[2] == 3} "updated image IDs"
+  tapOK {imageID[3] == 4} "updated image IDs"
+  catdir catdir.test3
+  mextract imageID, time
+  set id = imageID
+  set t = time
+  imextract imageID, time
+  for i 0 time[]
+    subset T = t if (id == imageID[$i])
+    set dT = T - time[$i]
+    vstat dT
+    tapOK {abs($MEAN)  < 0.00001} "time for measure ID $i (MEAN)"
+    tapOK {abs($SIGMA) < 0.00001} "time for measure ID $i (SIGMA)"
+  end
+  # exec rm test.in.txt test.cmf
+  # exec rm -rf catdir.test1
+  # exec rm -rf catdir.test2
+  # exec rm -rf catdir.test3
+  tapDONE
+end
+# create 2 populated catdirs, each with a couple of cmf files
+macro test.dvomerge.update
+  tapPLAN 51
+  exec rm -rf catdir.test1
+  exec rm -rf catdir.test2
+  exec rm -rf catdir.test3
+  $RA = 10.0
+  $DEC = 20.0
+  mkinput
   exec mkcmf test.in.txt test.cmf -date 2008/1/1 -time 01:00:00 -radec $RA $DEC
   exec addstar -D CATDIR catdir.test1 -D CAMERA simtest test.cmf
 …
   exec mkcmf test.in.txt test.cmf -date 2008/1/1 -time 04:00:00 -radec $RA $DEC
   exec addstar -D CATDIR catdir.test2 -D CAMERA simtest test.cmf
+  break
   exec rsync -auc catdir.test2/ catdir.test3/

trunk/Ohana/src/dvomerge/Makefile

-              r29001
+              r29938
 all: dvomerge dvoconvert dvosecfilt
+#  $(SRC)/dvomergeContinue.$(ARCH).o
 DVOMERGE = \
 $(SRC)/dvomerge.$(ARCH).o \
 $(SRC)/dvomergeUpdate.$(ARCH).o \
 $(SRC)/dvomergeCreate.$(ARCH).o \
+$(SRC)/dvomergeUpdate_threaded.$(ARCH).o \
+$(SRC)/dvomergeFromList.$(ARCH).o \
+$(SRC)/dvomergeImageIDs.$(ARCH).o \
 $(SRC)/dvo_image_merge_dbs.$(ARCH).o \
 $(SRC)/SetSignals.$(ARCH).o \
 …
 $(BIN)/dvosecfilt.$(ARCH) : $(DVOSECFILT)
+INSTALL = dvomerge dvoconvert dvosecfilt
+DVOREPAIR = \
+$(SRC)/dvorepair.$(ARCH).o \
+$(SRC)/dvorepairFixCPT.$(ARCH).o \
+$(SRC)/dvorepairImagesVsMeasures.$(ARCH).o \
+$(SRC)/dvorepairDeleteImageList.$(ARCH).o \
+$(SRC)/dvorepairFixImages.$(ARCH).o \
+$(SRC)/psps_ids.$(ARCH).o \
+$(SRC)/LoadImages.$(ARCH).o \
+$(SRC)/ReadDeleteList.$(ARCH).o \
+$(SRC)/match_image.$(ARCH).o \
+$(SRC)/help.$(ARCH).o \
+$(SRC)/ImageOps.$(ARCH).o
+$(DVOREPAIR)  : $(INC)/dvomerge.h
+$(BIN)/dvorepair.$(ARCH) : $(DVOREPAIR)
+DVOVERIFY = \
+$(SRC)/dvoverify.$(ARCH).o
+$(DVOVERIFY)  : $(INC)/dvomerge.h
+$(BIN)/dvoverify.$(ARCH) : $(DVOVERIFY)
+INSTALL = dvomerge dvoconvert dvosecfilt dvorepair dvoverify
 # dependancy rules for binary code #########################

trunk/Ohana/src/dvomerge/include/dvomerge.h

-              r29001
+              r29938
 # include <glob.h>
+# define myAbort(MSG) { fprintf (stderr, "%s\n", MSG); abort(); }
+# define myAssert(LOGIC,MSG) { if (!(LOGIC)) { fprintf (stderr, "%s\n", MSG); abort(); } }
 int    VERBOSE;
 char   CATDIR[256];
 …
 float  RADIUS;
 int    SKY_DEPTH;
+int    NTHREADS;
 char   *ALTERNATE_PHOTCODE_FILE;
 …
 SkyList   *SkyTablePopulatedList_old  PROTO((SkyTable *sky, off_t Ns, off_t Ne));
 int        LoadCatalog            PROTO((Catalog *catalog, SkyRegion *region, char *filename, char *mode));
+int        LoadCatalog            PROTO((Catalog *catalog, SkyRegion *region, char *filename, char *mode, int Nsecfilt));
 int        merge_catalogs_new     PROTO((SkyRegion *region, Catalog *output, Catalog *input, int *secflitMap));
 …
 off_t      dvo_map_image_ID       PROTO((IDmapType *IDmap, off_t oldID));
 int        dvo_update_image_IDs   PROTO((IDmapType *IDmap, Catalog *catalog));
+// dvorepair prototypes
+Image     *LoadImages             PROTO((FITS_DB *db, char *filename, off_t *Nimage));
+Image     *MatchImage             PROTO((Image *image, off_t Nimage, unsigned int time, short int source, unsigned int imageID));
+off_t      match_image            PROTO((Image *image, off_t Nimage, unsigned int T, short int S));
+int        SaveImages             PROTO((FITS_DB *oldDB, char *filename, Image *imagesOut, off_t Nout));
+int        dvorepairFixCPT        PROTO((int argc, char **argv));
+int        dvorepairImagesVsMeasures PROTO((int argc, char **argv));
+int        dvorepairDeleteImageList PROTO((int argc, char **argv));
+int        dvorepairFixImages     PROTO((int argc, char **argv));
+int       *ReadDeleteList         PROTO((char *filename, int *nindex));
+int        RepairTableCPT         PROTO((char *cptFilenameSrc, char *cptFilenameTgt, char *cpsFilenameSrc, char *cpsFilenameTgt, Measure *measure, off_t Nmeasure, Image *image, off_t Nimage, char catformat));
+void       dvorepair_help         PROTO((int argc, char **argv));
+off_t      getTgtIndex            PROTO((e_time start, e_time stop, short photcode, off_t *TgtIndex, e_time *TgtTimes, short *TgtCodes, off_t NimagesTgt));
+void       SortTgtByTimes         PROTO((e_time *S, off_t *I, short *C, off_t N));
+int        dvo_image_match_dbs    PROTO((IDmapType *IDmap, FITS_DB *tgt, FITS_DB *src));
+int        dvomergeImagesGetMap   PROTO((IDmapType *IDmap, char *input, char *output));
+int        dvomergeFromList       PROTO((int argc, char **argv));
+int        dvomergeUpdate_threaded PROTO((int argc, char **argv));

trunk/Ohana/src/dvomerge/src/LoadCatalog.c

-              r28329
+              r29938
 # include "dvomerge.h"
 int LoadCatalog (Catalog *catalog, SkyRegion *region, char *filename, char *mode) {
+int LoadCatalog (Catalog *catalog, SkyRegion *region, char *filename, char *mode, int Nsecfilt) {
     // set the parameters which guide catalog open/load/create
     catalog[0].filename  = filename;
     catalog[0].Nsecfilt  = GetPhotcodeNsecfilt ();
+    catalog[0].Nsecfilt  = Nsecfilt;
     // always load all of the data (if any exists)

trunk/Ohana/src/dvomerge/src/args.c

-              r29001
+              r29938
     remove_argument (N, argc, argv);
     ALTERNATE_PHOTCODE_FILE = strdup(argv[N]);
+    remove_argument (N, argc, argv);
+  }
+  NTHREADS = 0;
+  if ((N = get_argument (*argc, argv, "-threads"))) {
+    remove_argument (N, argc, argv);
+    NTHREADS = MAX(0, atoi(argv[N]));
     remove_argument (N, argc, argv);
+  }
 …
+  }
   if ((*argc != 6) && (*argc != 4)) dvomerge_usage();
+  if ((*argc < 4) || (*argc > 6)) dvomerge_usage();
   return TRUE;
+}

trunk/Ohana/src/dvomerge/src/dvo_image_merge_dbs.c

-              r29001
+              r29938
 void sort_IDmap (IDmapType *IDmap);
+off_t getTgtIndex (e_time start, e_time stop, short photcode, off_t *TgtIndex, e_time *TgtTimes, short *TgtCodes, off_t NimagesTgt) {
+  // use bisection to find the starting entry by time
+  off_t Nlo, Nhi, N;
+  // find the last TGT before start
+  Nlo = 0; Nhi = NimagesTgt;
+  while (Nhi - Nlo > 10) {
+    N = 0.5*(Nlo + Nhi);
+    if (TgtTimes[N] < start) {
+      Nlo = MAX(N, 0);
+    } else {
+      Nhi = MIN(N + 1, NimagesTgt);
+    }
+  }
+  // check for the matched mosaic starting from Nlo
+  // we may have to go much beyond Nlo since stop is not sorted
+  // can we use a sorted version of stop to check when we are beyond the valid range??
+  for (N = Nlo; N < NimagesTgt; N++) {
+    if (TgtTimes[N] < start) continue;
+    if (TgtTimes[N] > stop) return (-1);
+    if (TgtCodes[N] != photcode) continue;
+    return (TgtIndex[N]);
+  }
+  return (-1);
+}
+// sort two times vectors and an index by first time vector
+void SortTgtByTimes (e_time *S, off_t *I, short *C, off_t N) {
+# define SWAPFUNC(A,B){ e_time tmp_t; off_t tmp_i; short tmp_c;         \
+  tmp_t = S[A]; S[A] = S[B]; S[B] = tmp_t; \
+  tmp_i = I[A]; I[A] = I[B]; I[B] = tmp_i; \
+  tmp_c = C[A]; C[A] = C[B]; C[B] = tmp_c; \
+}
+# define COMPARE(A,B)(S[A] < S[B])
+  OHANA_SORT (N, COMPARE, SWAPFUNC);
+# undef SWAPFUNC
+# undef COMPARE
+}
+// we have two tables; 'tgt' contains some exposures from 'src' : find them and match a map
+int dvo_image_match_dbs (IDmapType *IDmap, FITS_DB *tgt, FITS_DB *src) {
+  Image *imagesSrc, *imagesTgt;
+  off_t NimagesSrc, NimagesTgt;
+  off_t iSrc, iTgt;
+  off_t  *TgtIndex;
+  e_time *TgtTimes;
+  short  *TgtCodes;
+  imagesSrc = gfits_table_get_Image (&src[0].ftable, &NimagesSrc, &src[0].swapped);
+  if (!imagesSrc) {
+    fprintf (stderr, "ERROR: failed to read images from src\n");
+    exit (2);
+  }
+  imagesTgt = gfits_table_get_Image (&tgt[0].ftable, &NimagesTgt, &tgt[0].swapped);
+  if (!imagesTgt) {
+    fprintf (stderr, "ERROR: failed to read images from tgt\n");
+    exit (2);
+  }
+  ALLOCATE (IDmap->old, off_t, NimagesSrc);
+  ALLOCATE (IDmap->new, off_t, NimagesSrc);
+  IDmap->Nmap = NimagesSrc;
+  // match by time and photcode
+  ALLOCATE (TgtIndex, off_t,  NimagesTgt);
+  ALLOCATE (TgtTimes, e_time, NimagesTgt);
+  ALLOCATE (TgtCodes, short,  NimagesTgt);
+  // save the Index, Times, Codes for all TGT images
+  for (iTgt = 0; iTgt < NimagesTgt; iTgt++) {
+    TgtIndex[iTgt] = iTgt;
+    TgtTimes[iTgt] = imagesTgt[iTgt].tzero;
+    TgtCodes[iTgt] = imagesTgt[iTgt].photcode;
+  }
+  // sort the index, start, and stop by the start times:
+  SortTgtByTimes (TgtTimes, TgtIndex, TgtCodes, NimagesTgt);
+  for (iSrc = 0; iSrc < NimagesSrc; iSrc++) {
+    iTgt = getTgtIndex (imagesSrc[iSrc].tzero, imagesSrc[iSrc].tzero + (int) imagesSrc[iSrc].exptime, imagesSrc[iSrc].photcode, TgtIndex, TgtTimes, TgtCodes, NimagesTgt);
+    if (iTgt < 0) Shutdown ("failure to match images: %s\n", imagesSrc[iSrc].name);
+    IDmap[0].old[iSrc] = imagesSrc[iSrc].imageID;
+    IDmap[0].new[iSrc] = imagesTgt[iTgt].imageID;
+  }
+  FREE(TgtIndex);
+  FREE(TgtTimes);
+  FREE(TgtCodes);
+  // sort IDmap->old,new on the basis of IDmap->old:
+  sort_IDmap (IDmap);
+  return TRUE;
+}
 // merge db2 into db1

trunk/Ohana/src/dvomerge/src/dvoconvert.c

-              r29001
+              r29938
   char filename[256], *input, *output;
   int depth;
+  int depth, Nsecfilt;
   off_t i, j, Ns, Ne;
   SkyTable *outsky, *insky;
 …
       exit (1);
+    }
+    Nsecfilt = GetPhotcodeNsecfilt();
     // save the photcodes in the output catdir
     sprintf (filename, "%s/Photcodes.dat", output);
 …
     // load / create output catalog
     LoadCatalog (&outcatalog, &outsky[0].regions[i], outsky[0].filename[i], "w");
+    LoadCatalog (&outcatalog, &outsky[0].regions[i], outsky[0].filename[i], "w", Nsecfilt);
     // combine only tables at equal or larger depth
 …
       // load input catalog
       LoadCatalog (&incatalog, inlist[0].regions[j], inlist[0].filename[j], "r");
+      LoadCatalog (&incatalog, inlist[0].regions[j], inlist[0].filename[j], "r", Nsecfilt);
       // skip empty input catalogs

trunk/Ohana/src/dvomerge/src/dvomerge.c

-              r28327
+              r29938
   dvomerge_args (&argc, argv);
+  // XXX require both inputs to be sorted?
+  if (argc == 6) dvomergeCreate (argc, argv);
+  if (argc == 4) dvomergeUpdate (argc, argv);
+  if (argc == 6) {
+    if (!strcasecmp (argv[2], "and")) {
+      dvomergeCreate (argc, argv);
+    } else {
+      dvomergeFromList (argc, argv);
+    }
+  }
+  if ((argc == 4) || (argc == 5)) {
+    if (NTHREADS) {
+      dvomergeUpdate_threaded (argc, argv);
+    } else {
+      dvomergeUpdate (argc, argv);
+    }
+  }
   dvomerge_usage();
   exit (2); // cannot reach here.
 …
 /* we have two possible modes of operation:
+   Create : dvomerge (in1) and (in2) to (out) -- create a new db from two input dbs
+   Update : dvomerge (in) into (out)          -- merge a new db into an existing db
+   Create   : dvomerge (in1) and (in2) to (out) -- create a new db from two input dbs
+   Update   : dvomerge (in) into (out)          -- merge a new db into an existing db
+   Continue : dvomerge (in) into (out) continue -- merge a new db into an existing db
 */

trunk/Ohana/src/dvomerge/src/dvomergeCreate.c

-              r28855
+              r29938
   char *input1, *input2, *output;
   IDmapType IDmap1, IDmap2;
+  int NsecfiltInput1, NsecfiltInput2, NsecfiltOutput;
   if (strcasecmp (argv[2], "and")) dvomerge_usage();
 …
+  }
   input1Photcodes = GetPhotcodeTable();
+  NsecfiltInput1 = GetPhotcodeNsecfilt();
   // Read the input2 photcodes
 …
+  }
   input2Photcodes = GetPhotcodeTable();
+  NsecfiltInput2 = GetPhotcodeNsecfilt();
   if (ALTERNATE_PHOTCODE_FILE) {
 …
+    }
     outputPhotcodes = GetPhotcodeTable();
+    NsecfiltOutput = GetPhotcodeNsecfilt();
     secfiltMap1 = GetSecFiltMap(outputPhotcodes, input1Photcodes);
 …
     outputPhotcodes = input1Photcodes;
     codesFilename = filename1;
+    NsecfiltOutput = NsecfiltInput1;
     // secfitMap1 can remain NULL since input1 defines the set of codes
+  }
 …
+  }
+  // trigger any dependencies, if any
+  SetPhotcodeTable(NULL);
   // save the output photcodes in the output catdir
   SetPhotcodeTable(outputPhotcodes);
+  // SetPhotcodeTable(outputPhotcodes);
   sprintf (filename, "%s/Photcodes.dat", output);
   if (!check_file_access (filename, TRUE, TRUE, VERBOSE)) {
 …
     if (VERBOSE) fprintf (stderr, "output: %s\n", outsky[0].regions[i].name);
     if (outputPhotcodes) {
         SetPhotcodeTable(outputPhotcodes);
+    }
+    // if (outputPhotcodes) {
+    //     SetPhotcodeTable(outputPhotcodes);
+    // }
     // load / create output catalog
     LoadCatalog (&outcatalog, &outsky[0].regions[i], outsky[0].filename[i], "w");
     if (input1Photcodes) {
         SetPhotcodeTable(input1Photcodes);
+    }
+    LoadCatalog (&outcatalog, &outsky[0].regions[i], outsky[0].filename[i], "w", NsecfiltOutput);
+    // if (input1Photcodes) {
+    // SetPhotcodeTable(input1Photcodes);
+    // }
     // combine only tables at equal or larger depth
 …
       // load input catalog (1)
       LoadCatalog (&incatalog, inlist[0].regions[j], inlist[0].filename[j], "r");
+      LoadCatalog (&incatalog, inlist[0].regions[j], inlist[0].filename[j], "r", NsecfiltInput1);
       // skip empty input catalogs
 …
     SkyListFree (inlist);
     if (input2Photcodes) {
       SetPhotcodeTable(input2Photcodes);
+    }
+    // if (input2Photcodes) {
+    //   SetPhotcodeTable(input2Photcodes);
+    // }
     // load in all of the tables from input2 for this region
 …
       // load input catalog (2)
       LoadCatalog (&incatalog, inlist[0].regions[j], inlist[0].filename[j], "r");
+      LoadCatalog (&incatalog, inlist[0].regions[j], inlist[0].filename[j], "r", NsecfiltInput2);
       // skip empty input catalogs

trunk/Ohana/src/dvomerge/src/dvomergeUpdate.c

-              r29001
+              r29938
 int dvomergeUpdate (int argc, char **argv) {
   int depth;
+  int depth, CONTINUE;
   off_t i, j, Ns, Ne;
   SkyTable *outsky, *insky;
 …
   PhotCodeData *outputPhotcodes;
   int *secfiltMap = NULL;
+  int NsecfiltInput, NsecfiltOutput;
+  double dtime;
+  struct timeval start, stop;
+  gettimeofday (&start, NULL);
+  CONTINUE = FALSE;
   if (strcasecmp (argv[2], "into")) dvomerge_usage();
+  if (argc == 5) {
+    if (strcasecmp (argv[4], "continue")) dvomerge_usage();
+    CONTINUE = TRUE;
+  }
   input  = argv[1];
 …
+  }
   inputPhotcodes = GetPhotcodeTable();
+  NsecfiltInput = GetPhotcodeNsecfilt();
   // since we are merging the input db into the output db, the output defines the photcode
 …
     outputPhotcodes = GetPhotcodeTable();
+    NsecfiltOutput = GetPhotcodeNsecfilt();
     secfiltMap = GetSecFiltMap(outputPhotcodes, inputPhotcodes);
 …
     fprintf(stderr, "%s not found using photcodes from %s/Photcodes.dat\n", filename, input);
     outputPhotcodes = inputPhotcodes;
+    NsecfiltOutput = NsecfiltInput;
     if (!check_dir_access (output, VERBOSE)) {
       fprintf (stderr, "error creating output database directory %s\n", output);
 …
+  }
+  dvomergeImagesUpdate (&IDmap, input, output);
+  if (CONTINUE) {
+    // need to determine the mapping from the input to the output images
+    dvomergeImagesGetMap (&IDmap, input, output);
+  } else {
+    dvomergeImagesUpdate (&IDmap, input, output);
+  }
   // load the sky table for the existing database
 …
   depth = inlist[0].regions[Ns][0].depth;
+  SetPhotcodeTable(NULL);
   // loop over the populated input regions
   for (i = 0; i < inlist[0].Nregions; i++) {
 …
     if (VERBOSE) fprintf (stderr, "input: %s\n", inlist[0].regions[i][0].name);
-    SetPhotcodeTable(inputPhotcodes);
     // load / create output catalog (if catalog does not exist, it will be created)
     LoadCatalog (&incatalog, &inlist[0].regions[i][0], inlist[0].filename[i], "r");
+    LoadCatalog (&incatalog, &inlist[0].regions[i][0], inlist[0].filename[i], "r", NsecfiltInput);
     // skip empty input catalogs
     if (!incatalog.Naves_disk) {
 …
       // load input catalog
+      SetPhotcodeTable(outputPhotcodes);
+      LoadCatalog (&outcatalog, outlist[0].regions[j], outlist[0].filename[j], "w");
+      LoadCatalog (&outcatalog, outlist[0].regions[j], outlist[0].filename[j], "w", NsecfiltOutput);
       dvo_update_image_IDs (&IDmap, &incatalog);
 …
       // if we receive a signal which would cause us to exit, wait until the full catalog is written
       SetProtect (TRUE);
+      dvo_catalog_save (&outcatalog, VERBOSE);
+      if (!dvo_catalog_save (&outcatalog, VERBOSE)) {
+        fprintf (stderr, "ERROR: failed to save catalog %s\n", outlist[0].filename[j]);
+        exit (1);
+      }
       SetProtect (FALSE);
 …
+  }
+  gettimeofday (&stop, NULL);
+  dtime = DTIME (stop, start);
+  fprintf (stderr, "SUCCESS: elapsed time %9.4f sec\n", dtime);
   exit (0);
+}
-/*** update the image table ***/
-int dvomergeImagesUpdate (IDmapType *IDmap, char *input, char *output) {
-  FITS_DB inDB;
-  FITS_DB outDB;
-  int    status;
-  /*** load input1/Images.dat ***/
-  sprintf (ImageCat, "%s/Images.dat", input);
-  inDB.mode   = dvo_catalog_catmode (CATMODE);
-  inDB.format = dvo_catalog_catformat (CATFORMAT);
-  status       = dvo_image_lock (&inDB, ImageCat, 3600.0, LCK_XCLD);  // shorter timeout?
-  if (!status) Shutdown ("ERROR: failure to lock image catalog %s", inDB.filename);
-  // load the image table
-  if (inDB.dbstate == LCK_EMPTY) {
-    // Shutdown ("can't find input image catalog %s", inDB.filename);
-    IDmap->Nmap = 0;
-    return TRUE;
+  }
-  if (!dvo_image_load (&inDB, VERBOSE, TRUE)) {
-    Shutdown ("can't read input image catalog %s", inDB.filename);
+  }
-  /*** load output/Images.dat ***/
-  sprintf (ImageCat, "%s/Images.dat", output);
-  outDB.mode   = dvo_catalog_catmode (CATMODE);
-  outDB.format = dvo_catalog_catformat (CATFORMAT);
-  status       = dvo_image_lock (&outDB, ImageCat, 3600.0, LCK_XCLD);  // shorter timeout?
-  if (!status) Shutdown ("ERROR: failure to lock image catalog %s", outDB.filename);
-  /* load the image table */
-  if (outDB.dbstate == LCK_EMPTY) {
-    dvo_image_create (&outDB, GetZeroPoint());
-  } else {
-    if (!dvo_image_load (&outDB, VERBOSE, TRUE)) {
-      Shutdown ("can't read output image catalog %s", outDB.filename);
+    }
+  }
-  // convert database table to internal structure & add to output image db
-  dvo_image_merge_dbs(IDmap, &outDB, &inDB);
-  dvo_image_unlock (&inDB); // unlock input
-  SetProtect (TRUE);
-  dvo_image_save (&outDB, VERBOSE);
-  SetProtect (FALSE);
-  dvo_image_unlock (&outDB); // unlock output
-  return TRUE;
+}

trunk/Ohana/src/dvomerge/src/dvoverify.c

-              r29001
+              r29938
 */
+int VerifyTableFile (char *filename);
+# define DEBUG 0
 int main (int argc, char **argv) {
   char filename[256], *input, *output;
   int depth;
   off_t i, j, Ns, Ne;
   SkyTable *outsky, *insky;
+  char filename[1024];
+  int N, Nbad;
+  off_t i;
+  SkyTable *insky;
   SkyList *inlist;
+  Catalog incatalog, outcatalog;
+  SetSignals ();
+  dvoconvert_help (argc, argv);
+  ConfigInit (&argc, argv);
+  dvoconvert_args (&argc, argv);
+  if (strcasecmp (argv[2], "to")) dvoconvert_usage();
+  input = argv[1];
+  output = argv[3];
+  // load input images, save to output images
+  dvoConvert_copy_images (input, output);
+  // copy photcode table
+  {
+    // the first input defines the photcode table & db layout
+    sprintf (filename, "%s/Photcodes.dat", input);
+    if (!LoadPhotcodes (filename, NULL, FALSE)) {
+      fprintf (stderr, "error loading photcode table %s\n", filename);
+      exit (1);
+    }
+    // save the photcodes in the output catdir
+    sprintf (filename, "%s/Photcodes.dat", output);
+    if (!check_file_access (filename, TRUE, TRUE, VERBOSE)) {
+      fprintf (stderr, "error creating output catdir %s\n", output);
+      exit (1);
+    }
+    if (!SavePhotcodesFITS (filename)) {
+      fprintf (stderr, "error saving photcode table %s\n", filename);
+      exit (1);
+    }
+  }
+  // copy skytable
+  {
+    // load the sky table for the existing database
+    insky = SkyTableLoadOptimal (input, NULL, NULL, FALSE, SKY_DEPTH_HST, VERBOSE);
+    SkyTableSetFilenames (insky, input, "cpt");
+    // generate an output table populated at the desired depth
+    // XXX force this to match the input?
+    outsky = SkyTableLoadOptimal (output, NULL, GSCFILE, TRUE, SKY_DEPTH, VERBOSE);
+    SkyTableSetFilenames (outsky, output, "cpt");
+    SkyTablePopulatedRange (&Ns, &Ne, insky, 0);
+    depth = insky[0].regions[Ns].depth;
+    // XXX this seems to imply that insky is a uniform depth...
+  }
+  // loop over all input catalogs, save to output catalogs
+  // loop over the populatable output regions
+  for (i = 0; i < outsky[0].Nregions; i++) {
+    if (!outsky[0].regions[i].table) continue;
+    if (VERBOSE) fprintf (stderr, "output: %s\n", outsky[0].regions[i].name);
+    // load / create output catalog
+    LoadCatalog (&outcatalog, &outsky[0].regions[i], outsky[0].filename[i], "w");
+    // combine only tables at equal or larger depth
+    // load in all of the tables from input for this region
+    inlist = SkyListByBounds (insky, depth, outsky[0].regions[i].Rmin, outsky[0].regions[i].Rmax, outsky[0].regions[i].Dmin, outsky[0].regions[i].Dmax);
+    for (j = 0; j < inlist[0].Nregions; j++) {
+      if (VERBOSE) fprintf (stderr, "input : %s\n", inlist[0].regions[j][0].name);
+      // load input catalog
+      LoadCatalog (&incatalog, inlist[0].regions[j], inlist[0].filename[j], "r");
+      // skip empty input catalogs
+      if (!incatalog.Naves_disk) {
+        dvo_catalog_unlock (&incatalog);
+        dvo_catalog_free (&incatalog);
+        continue;
+      }
+      merge_catalogs_new (&outsky[0].regions[i], &outcatalog, &incatalog);
+      dvo_catalog_unlock (&incatalog);
+      dvo_catalog_free (&incatalog);
+    }
+    SkyListFree (inlist);
+    outcatalog.catflags = LOAD_AVES | LOAD_MEAS | LOAD_MISS | LOAD_SECF;
+    dvo_catalog_save (&outcatalog, VERBOSE);
+    dvo_catalog_unlock (&outcatalog);
+    dvo_catalog_free (&outcatalog);
+  }
+  // save the output sky table copy
+  sprintf (filename, "%s/SkyTable.fits", output);
+  check_file_access (filename, TRUE, TRUE, VERBOSE);
+  if (!SkyTableSave (outsky, filename)) {
+    fprintf (stderr, "ERROR: failed to save sky table for %s\n", output);
+  SkyRegion UserPatch;
+  // Catalog catalog;
+  // restrict to a portion of the sky
+  UserPatch.Rmin = 0;
+  UserPatch.Rmax = 360;
+  UserPatch.Dmin = -90;
+  UserPatch.Dmax = +90;
+  if ((N = get_argument (argc, argv, "-region"))) {
+    remove_argument (N, &argc, argv);
+    UserPatch.Rmin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    UserPatch.Rmax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    UserPatch.Dmin = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+    UserPatch.Dmax = atof (argv[N]);
+    remove_argument (N, &argc, argv);
+  }
+  if (argc != 2) {
+    fprintf (stderr, "USAGE: dvoverify (catdir) [-region Rmin Rmax Dmin Dmax]\n");
+    fprintf (stderr, "  catdir : database of interest\n");
+    exit (2);
+  }
+  char *catdir = argv[1];
+  Nbad = 0;
+  // XXX make this step optional
+  if (1) {
+    // check the photcode table
+    sprintf (filename, "%s/Photcodes.dat", catdir);
+    if (!VerifyTableFile (filename)) {
+      Nbad ++;
+    }
+    // check the skytable
+    sprintf (filename, "%s/SkyTable.fits", catdir);
+    if (!VerifyTableFile (filename)) {
+      Nbad ++;
+    }
+    // check the image table
+    sprintf (filename, "%s/Images.dat", catdir);
+    if (!VerifyTableFile (filename)) {
+      Nbad ++;
+    }
+  }
+  // load the sky table for the existing database
+  insky = SkyTableLoadOptimal (catdir, NULL, NULL, FALSE, SKY_DEPTH_HST, VERBOSE);
+  myAssert(insky, "can't read SkyTable");
+  SkyTableSetFilenames (insky, catdir, "cpt");
+  inlist = SkyListByPatch (insky, -1, &UserPatch);
+  // loop over all catalogs, save to output catalogs
+  for (i = 0; i < inlist[0].Nregions; i++) {
+    if (!inlist[0].regions[i][0].table) continue;
+    if (i % 1000 == 0) fprintf (stderr, ".");
+    sprintf (filename, "%s/%s.cpt", catdir, inlist[0].regions[i][0].name);
+    if (!VerifyTableFile (filename)) {
+      Nbad ++;
+    }
+    sprintf (filename, "%s/%s.cps", catdir, inlist[0].regions[i][0].name);
+    if (!VerifyTableFile (filename)) {
+      Nbad ++;
+    }
+    sprintf (filename, "%s/%s.cpm", catdir, inlist[0].regions[i][0].name);
+    if (!VerifyTableFile (filename)) {
+      Nbad ++;
+    }
+  }
+  if (Nbad > 0) {
+    fprintf (stderr, "ERROR: %d files are bad\n", Nbad);
     exit (1);
+  }
+  fprintf (stderr, "SUCCESS: no files are bad\n");
   exit (0);
+}
+int dvoConvert_copy_images (char *input, char *output) {
+  FITS_DB inDB;
+  FITS_DB outDB;
+  int    status;
+  Image *images;
+  off_t Nimages;
+  off_t ID;
+  /*** load output/Images.dat ***/
+  sprintf (ImageCat, "%s/Images.dat", output);
+  outDB.mode   = dvo_catalog_catmode (CATMODE);
+  outDB.format = dvo_catalog_catformat (CATFORMAT);
+  status       = dvo_image_lock (&outDB, ImageCat, 3600.0, LCK_XCLD);  // shorter timeout?
+  if (!status) Shutdown ("ERROR: failure to lock image catalog %s", outDB.filename);
+  // output image table should not already exist
+  if (outDB.dbstate != LCK_EMPTY) {
+    Shutdown ("ERROR: image table %s already exists", outDB.filename);
+  }
+  dvo_image_create (&outDB, GetZeroPoint());
+  /*** load input/Images.dat ***/
+  sprintf (ImageCat, "%s/Images.dat", input);
+  // inDB.mode   = dvo_catalog_catmode (CATMODE);
+  // inDB.format = dvo_catalog_catformat (CATFORMAT);
+  status       = dvo_image_lock (&inDB, ImageCat, 3600.0, LCK_XCLD);  // shorter timeout?
+  if (!status) Shutdown ("ERROR: failure to lock image catalog %s", inDB.filename);
+  // load the image table
+  if (inDB.dbstate == LCK_EMPTY) {
+    Shutdown ("can't find input image catalog %s", inDB.filename);
+  }
+  if (!dvo_image_load (&inDB, VERBOSE, TRUE)) {
+    Shutdown ("can't read input image catalog %s", inDB.filename);
+  }
+  // convert the raw image table to Image type (byteswap if needed)
+  images = gfits_table_get_Image (&inDB.ftable, &Nimages, &inDB.swapped);
+  if (!images) {
+    fprintf (stderr, "ERROR: failed to read images\n");
+    exit (2);
+  }
+  // update additional metadata
+  gfits_scan (&inDB.header, "IMAGEID", OFF_T_FMT, 1,  &ID);
+  gfits_modify (&outDB.header, "NIMAGES", OFF_T_FMT, 1,  Nimages);
+  gfits_modify (&outDB.header, "IMAGEID", OFF_T_FMT, 1,  ID);
+  // copy input rows to output table
+  gfits_add_rows (&outDB.ftable, (char *) images, Nimages, sizeof(Image));
+  // write out the image table to disk
+  SetProtect (TRUE);
+  dvo_image_save (&outDB, VERBOSE);
+  SetProtect (FALSE);
+  dvo_image_unlock (&outDB); // unlock output
+  dvo_image_unlock (&inDB); // unlock input1
+// is this file a consistent FITS file?
+int VerifyTableFile (char *filename) {
+  int status;
+  off_t Nbytes;
+  Header header;
+  struct stat fileStats;
+  FILE *file;
+  // does the file exist?
+  status = stat (filename, &fileStats);
+  if (status) {
+    // some error accessing the file.  there is only one acceptable error: file not found
+    switch (errno) {
+      case ENOENT:
+        if (DEBUG) fprintf (stderr, "file does not exist, skipping %s\n", filename);
+        return TRUE;
+      case ENOMEM:
+        fprintf (stderr, "Out of memory: %s\n", filename);
+        return TRUE;
+      case EACCES:
+        fprintf (stderr, "Permission error on %s\n", filename);
+        return FALSE;
+      case EFAULT:
+        fprintf (stderr, "Bad address: %s\n", filename);
+        return FALSE;
+      case ELOOP:
+        fprintf (stderr, "Too many symbolic links encountered while traversing the path: %s\n", filename);
+        return FALSE;
+      case ENAMETOOLONG:
+        fprintf (stderr, "File name too long: %s\n", filename);
+        return FALSE;
+      case ENOTDIR:
+        fprintf (stderr, "A component of the path is not a directory: %s\n", filename);
+        return FALSE;
+      case EOVERFLOW:
+        fprintf (stderr, "file too large for program version: %s\n", filename);
+        return FALSE;
+      default:
+        fprintf (stderr, "unknown error: %s\n", filename);
+        return FALSE;
+    }
+  }
+  // does it have any data?
+  if (fileStats.st_size == 0) {
+    fprintf (stderr, "file is empty: %s\n", filename);
+    return FALSE;
+  }
+  // can we open it?
+  file = fopen(filename, "r");
+  if (!file) {
+    fprintf (stderr, "unable to open valid file: %s\n", filename);
+    return FALSE;
+  }
+  // scan all extentions
+  Nbytes = 0;
+  if (DEBUG) fprintf (stderr, "sizes: ("OFF_T_FMT" vs "OFF_T_FMT")\n", Nbytes, fileStats.st_size);
+  while (Nbytes < fileStats.st_size) {
+    // Check on the PHU
+    if (!gfits_fread_header (file, &header)) {
+      fprintf (stderr, "unable to read PHU header for %s\n", filename);
+      fclose(file);
+      return (FALSE);
+    }
+    // move to TBL header
+    Nbytes += header.datasize + gfits_data_size (&header);
+    if (DEBUG) fprintf (stderr, "sizes: ("OFF_T_FMT" vs "OFF_T_FMT")\n", Nbytes, fileStats.st_size);
+    if (Nbytes > fileStats.st_size) {
+      fprintf (stderr, "file is short ("OFF_T_FMT" vs "OFF_T_FMT"): %s\n", Nbytes, fileStats.st_size, filename);
+      gfits_free_header(&header);
+      fclose (file);
+      return FALSE;
+    }
+    gfits_free_header(&header);
+    status = fseeko (file, Nbytes, SEEK_SET);
+    if (status) {
+      switch (errno) {
+        case EBADF:
+          fprintf (stderr, "something wrong with file handle: %s\n", filename);
+          fclose (file);
+          return FALSE;
+        case EINVAL:
+          fprintf (stderr, "invalid offset: %s\n", filename);
+          fclose (file);
+          return FALSE;
+        default:
+          fprintf (stderr, "other error in fseeko: %s\n", filename);
+          fclose (file);
+          return FALSE;
+      }
+    }
+  }
+  if (DEBUG) fprintf (stderr, "file is good: %s\n", filename);
+  fclose (file);
   return TRUE;
+}
+  // gfits_scan(&cpmHeaderTBL, "NAXIS1", "%d", 1, &NbytesPerRow);
+  // gfits_scan(&cpmHeaderTBL, "NAXIS2", "%d", 1, &Nrows);

trunk/Ohana/src/dvomerge/src/help.c

-              r29001
+              r29938
   fprintf (stderr, "USAGE: dvomerge (input1) and (input2) to (output)\n");
   fprintf (stderr, "   OR: dvomerge (input) into (output)\n");
+  fprintf (stderr, "   OR: dvomerge (input) into (output) continue\n");
+  fprintf (stderr, "   OR: dvomerge (input) into (output) from (list)\n");
   fprintf (stderr, "   [-region Rmin Rmax Dmin Dmax]\n");
   exit (2);
 …
 void dvosecfilt_usage(void) {
   fprintf (stderr, "USAGE: dvosecfilt (input) -photcodes (photcodes.txt)\n");
+  fprintf (stderr, "USAGE: dvosecfilt (catdir) (Nsecfilt)\n");
   exit (2);
 …
   fprintf (stderr, "USAGE\n");
   fprintf (stderr, "  dvomerge (input1) and (input2) to (output)\n");
+  fprintf (stderr, "  dvomerge (input) into (output)\n\n");
+  fprintf (stderr, "  dvomerge (input) into (output)\n");
+  fprintf (stderr, "  dvomerge (input) into (output) continue\n\n");
+  fprintf (stderr, "  dvomerge (input) into (output) from (list)\n\n");
   fprintf (stderr, "  merge DVO databases\n");
   fprintf (stderr, "  optional flags:\n");
 …
   fprintf (stderr, "  -help                       : this list\n");
   fprintf (stderr, "  -h                          : this list\n\n");
+  fprintf (stderr, "  -region Rmin Rmax Dmin Dmax : region to merge\n\n");
   exit (2);
+}
 …
   fprintf (stderr, "USAGE\n");
   fprintf (stderr, "  dvosecfilt (input) (Nsecfilt)\n\n");
+  fprintf (stderr, "  dvosecfilt (catdir) (Nsecfilt)\n\n");
+  fprintf (stderr, "  change number of secfilt entries in photcode table (updates secfilt tables only)\n");
+  fprintf (stderr, "  change number of secfilt entries in photcode table (updates secfilt tables (cps), NSECFILT in cpt files)\n");
+  fprintf (stderr, "  NOTE: the user must change the photcode table to reflect the change (use photcode-table -export / -import)\n");
   fprintf (stderr, "  optional flags:\n");
 …
+}
+void dvorepair_help (int argc, char **argv) {
+  /* check for help request */
+  if (!argv) goto show_help;
+  if (get_argument (argc, argv, "-help")) goto show_help;
+  if (get_argument (argc, argv, "-h"))    goto show_help;
+  if (argc < 2) goto show_help;
+  return;
+show_help:
+  fprintf (stderr, "USAGE\n");
+  fprintf (stderr, "  dvorepair -fix-cpt (images) (rootlist) - regenerate cpt & cps files from the cpm files\n");
+  fprintf (stderr, "  dvorepair -images-vs-measures (catdir) (Ntol) - find images with too many missing detections\n");
+  fprintf (stderr, "  dvorepair -delete-image-list (catdir) (deleteList) - delete a set of images based on image IDs (output from -images-vs-measures)\n");
+  fprintf (stderr, "  dvorepair -fix-images (catdir) (deleteList) - delete a set of images based on image IDs (output from -images-vs-measures)\n");
+  fprintf (stderr, "\n");
+  fprintf (stderr, "  optional flags:\n");
+  fprintf (stderr, "  -help                       : this list\n");
+  fprintf (stderr, "  -h                          : this list\n\n");
+  exit (2);
+}

trunk/Ohana/src/dvomerge/src/merge_catalogs_old.c

-              r29181
+              r29938
   unsigned int objID, catID;
   Coords tcoords;
   // struct timeval start, stop;
   // gettimeofday (&start, (void *) NULL);
 …
     } else {
       for (k = 0; k < NsecfiltIn; k++) {
+        if (secfiltMap[k] < 0) continue;  // skip secfilt entries from input that are not in the output
         // index for this entry in output's secfilt list
         int outputIndex = n * NsecfiltOut + secfiltMap[k];
 …
     i++;
+  }
   // MARKTIME("find matched stars: %f sec for "OFF_T_FMT","OFF_T_FMT" stars\n", dtime, Nstars, Nave);
+  // MARKTIME("find matched stars: %f sec for "OFF_T_FMT","OFF_T_FMT" stars ("OFF_T_FMT" meas)\n", dtime, Nstars, Nave, Nmeas);
   /** incorporate unmatched image stars, if this star is in field of this catalog **/

trunk/Ohana/src/imregister/imphot/rfits.c

r7080	r29938
17	17	return (FALSE);
18	18	}
19		if (!gfits_fread_ftable_data (db[0].f, &db[0].ftable)) {
	19	if (!gfits_fread_ftable_data (db[0].f, &db[0].ftable, FALSE)) {
20	20	fprintf (stderr, "can't read table data");
21	21	return (FALSE);

trunk/Ohana/src/kapa2/Makefile

r25757	r29938
42	42	$(SRC)/bDrawObjects.$(ARCH).o $(SRC)/bDrawFrame.$(ARCH).o \
43	43	$(SRC)/bDrawLabels.$(ARCH).o $(SRC)/bDrawIt.$(ARCH).o \
	44	$(SRC)/bDrawImage.$(ARCH).o \
44	45	$(SRC)/PNGit.$(ARCH).o $(SRC)/PPMit.$(ARCH).o \
45	46	$(SRC)/PSit.$(ARCH).o $(SRC)/CrossHairs.$(ARCH).o \

trunk/Ohana/src/kapa2/include/prototypes.h

-              r29539
+              r29938
 void          DrawYErrors         PROTO((KapaGraphWidget *graph, Gobjects *objects));
 void          DrawTick            PROTO((Graphic *graphic, Axis *axis, int P, TickMarkData *tick, int naxis));
 void          AxisTickScale       PROTO((Axis *axis, double *major, double *minor));
+void          AxisTickScale       PROTO((Axis *axis, double *major, double *minor, int *nsignif));
 TickMarkData *CreateAxisTicks     PROTO((Axis *axis, int *nticks));
 int           PrintTick           PROTO((char *string, double value, double min, double max));
+int           PrintTick           PROTO((char *string, double value, double min, double max, int nsignif));
 /* EventLoop */
 int           PScommand           PROTO((int sock));
+int           PNGcommand          PROTO((int sock));
 int           CheckPipe           PROTO((void));
 int           Reconfig            PROTO((XEvent *event));
 …
 /* CheckPipe */
 int           PNGit               PROTO((int sock));
+int           PNGit               PROTO((char *filename));
 int           PPMit               PROTO((int sock));
 int           LoadFrame           PROTO((int sock));
 …
 int           MoveSection         PROTO((int sock));
 int           DefineSection       PROTO((int sock));
+int           DefineSectionByImage PROTO((int sock));
 int           SetFont             PROTO((int sock));
 int           EraseCurrentPlot    PROTO((void));
 …
 /* kapa bDraw Functions */
+int           bDrawFrame          PROTO((KapaGraphWidget *graph));
+int           bDrawObjects        PROTO((KapaGraphWidget *graph));
+void          bDrawLabels         PROTO((KapaGraphWidget *graph));
+void          bDrawTextlines      PROTO((KapaGraphWidget *graph));
+void          bDrawConnect        PROTO((KapaGraphWidget *graph, Gobjects *object));
+void          bDrawHistogram      PROTO((KapaGraphWidget *graph, Gobjects *object));
+void          bDrawPoints         PROTO((KapaGraphWidget *graph, Gobjects *object));
+void          bDrawXErrors        PROTO((KapaGraphWidget *graph, Gobjects *object));
+void          bDrawYErrors        PROTO((KapaGraphWidget *graph, Gobjects *object));
+void          bDrawTick           PROTO((Axis *axis, int P, TickMarkData *tick, int naxis));
+void          bDrawClipLine       PROTO((double x0, double y0, double x1, double y1, double X0, double Y1, double X1, double Y0));
+bDrawBuffer  *bDrawIt             PROTO((void));
+void          bDrawGraph          PROTO((KapaGraphWidget *graph));
+int           bDrawFrame          PROTO((bDrawBuffer *buffer, KapaGraphWidget *graph));
+int           bDrawObjects        PROTO((bDrawBuffer *buffer, KapaGraphWidget *graph));
+void          bDrawLabels         PROTO((bDrawBuffer *buffer, KapaGraphWidget *graph));
+void          bDrawTextlines      PROTO((bDrawBuffer *buffer, KapaGraphWidget *graph));
+void          bDrawConnect        PROTO((bDrawBuffer *buffer, KapaGraphWidget *graph, Gobjects *object));
+void          bDrawHistogram      PROTO((bDrawBuffer *buffer, KapaGraphWidget *graph, Gobjects *object));
+void          bDrawPoints         PROTO((bDrawBuffer *buffer, KapaGraphWidget *graph, Gobjects *object));
+void          bDrawXErrors        PROTO((bDrawBuffer *buffer, KapaGraphWidget *graph, Gobjects *object));
+void          bDrawYErrors        PROTO((bDrawBuffer *buffer, KapaGraphWidget *graph, Gobjects *object));
+void          bDrawTick           PROTO((bDrawBuffer *buffer, Axis *axis, int P, TickMarkData *tick, int naxis));
+void          bDrawClipLine       PROTO((bDrawBuffer *buffer, double x0, double y0, double x1, double y1, double X0, double Y1, double X1, double Y0));
+void          bDrawGraph          PROTO((bDrawBuffer *buffer, KapaGraphWidget *graph));
+int           bDrawImage          PROTO((bDrawBuffer *buffer, KapaImageWidget *image, Graphic *graphic));
+bDrawBuffer  *bDrawIt             PROTO((png_color *palette, int Npalette, int Nbyte));
 /* misc support */
 …
 int           Overlay3            PROTO((Graphic *graphic, KapaImageWidget *image));
 int           PSfunction          PROTO((Graphic *graphic, KapaImageWidget *image));
+int           PNGfunction         PROTO((Graphic *graphic, KapaImageWidget *image));
+int           JPEGfunction        PROTO((Graphic *graphic, KapaImageWidget *image));
 /* misc functions */
 …
 int           SaveOverlay  (int sock);
 int           CSaveOverlay (int sock);
+int           JPEGit24     (int sock);
+int           JPEGit24     (char *filename);
+int           JPEGcommand  (int sock);
 int           UpdatePointer (Graphic *graphic, XMotionEvent *event);
 …
 int           GetActiveSocket (void);
 void          InvertButton (Graphic *graphic, Button *button);
 void          bDrawOverlay (KapaImageWidget *image, int N);
+void          bDrawOverlay (bDrawBuffer *buffer, KapaImageWidget *image, int N);
 /* color cube tools */
 …
 int SetColorScale3D_CC (Graphic *graphic, KapaImageWidget *image);
 int SetColorCubeHistogram (void);
+int GetGraphBoundary (Section *section, double *x0, double *y0, double *x1, double *y1, int *dXm, int *dXp, int *dYm, int *dYp);
+int ResizeByImage (int sock);

trunk/Ohana/src/kapa2/include/structures.h

r29539	r29938
148	148	int IsMajor;
149	149	int IsLabel;
	150	int nsignif;
150	151	} TickMarkData;
151	152

trunk/Ohana/src/kapa2/src/ButtonFunctions.c

-              r29539
+              r29938
   status = PSit ("kapa.ps", "default", TRUE, KAPA_PS_NEWPLOT);
+  return (status);
+}
+int PNGfunction (Graphic *graphic, KapaImageWidget *image) {
+  int status;
+  status = PNGit ("kapa.png");
+  return (status);
+}
+int JPEGfunction (Graphic *graphic, KapaImageWidget *image) {
+  int status;
+  status = JPEGit24 ("kapa.jpg");
   return (status);
+}

trunk/Ohana/src/kapa2/src/CheckPipe.c

-              r27790
+              r29938
   if (!strcmp (word, "PNGF")) {
+    status = PNGit (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (status);
+  }
+    status = PNGcommand (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (status);
+  }
+  if (!strcmp (word, "JPEG")) {
+    status = JPEGcommand (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (status);
+  }
   if (!strcmp (word, "PPMF")) {
     status = PPMit (sock);
 …
+  }
+  if (!strcmp (word, "ISIZ")) {
+    status = ResizeByImage (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (TRUE);
+  }
   if (!strcmp (word, "MOVE")) {
     status = Relocate (sock);
 …
   if (!strcmp (word, "DSEC")) {
     status = DefineSection (sock);
+    KiiSendCommand (sock, 4, "DONE");
+    FINISHED (TRUE);
+  }
+  if (!strcmp (word, "ISEC")) {
+    status = DefineSectionByImage (sock);
     KiiSendCommand (sock, 4, "DONE");
     FINISHED (TRUE);
 …
   if (!strcmp (word, "CSVE")) {
     status = CSaveOverlay (sock);
-    KiiSendCommand (sock, 4, "DONE");
-    FINISHED (status);
+  }
-  if (!strcmp (word, "JPEG")) {
-    status = JPEGit24 (sock);
     KiiSendCommand (sock, 4, "DONE");
     FINISHED (status);

trunk/Ohana/src/kapa2/src/DefineSection.c

-              r27790
+              r29938
   return (TRUE);
+}
+// define the section, but do not create a graph or image
+int DefineSectionByImage (int sock) {
+  int N, bg;
+  char name[128];
+  double x, y, dx, dy;
+  int dXm, dXp, dYm, dYp;
+  double x0, y0, x1, y1, expand;
+  Section *section;
+  Graphic *graphic;
+  KapaImageWidget *image;
+  KiiScanMessage (sock, "%s %lf %lf %d", name, &x, &y, &bg);
+  N = GetSectionByName (name);
+  section = GetSectionByNumber (N);
+  image = section->image;
+  if (!image) {
+    fprintf (stderr, "no image to define section\n");
+    return (TRUE);
+  }
+  SetActiveSectionByNumber (N);
+  graphic = GetGraphic ();
+  GetGraphBoundary (section, &x0, &y0, &x1, &y1, &dXm, &dXp, &dYm, &dYp);
+  expand = 1.0;
+  if (image[0].picture.expand > 0) {
+    expand = image[0].picture.expand;
+  }
+  if (image[0].picture.expand < 0) {
+    expand = 1.0 / fabs((double)image[0].picture.expand);
+  }
+  // pixel dimensions of the imaging region + boundary
+  dx = image[0].image[0].matrix.Naxis[0]*expand + x1;
+  dy = image[0].image[0].matrix.Naxis[1]*expand + y1;
+  section[0].x = x;
+  section[0].y = y;
+  section[0].bg = bg;
+  section[0].dx = dx / graphic[0].dx;
+  section[0].dy = dy / graphic[0].dy;
+  // if (section[0].x != x)   MoveSection = TRUE;
+  // if (section[0].y != y)   MoveSection = TRUE;
+  // if (section[0].dx != dx) MoveSection = TRUE;
+  // if (section[0].dy != dy) MoveSection = TRUE;
+  SetSectionSizes (section);
+  Refresh ();
+  return (TRUE);
+}

trunk/Ohana/src/kapa2/src/DrawFrame.c

-              r29539
+              r29938
 int DrawFrame (KapaGraphWidget *graph) {
   int i, j, Nticks, P;
   double fx, fy, dfx, dfy, lweight;
+  int i, j, Nticks, P, doffset;
+  double fx, fy, dfx, dfy, dx, dy, lweight;
   Graphic *graphic;
   TickMarkData *ticks;
 …
   /* each axis is drawn independently, but ticks and labels are placed according to perpendicular distance. */
   for (i = 0; i < 4; i++) {
-    fx  = graph[0].axis[i].fx;
-    fy  = graph[0].axis[i].fy;
-    dfx = graph[0].axis[i].dfx;
-    dfy = graph[0].axis[i].dfy;
-    P = hypot (graph[0].axis[(i+1)%2].dfx, graph[0].axis[(i+1)%2].dfy);
     lweight = MAX (0, MIN (10, graph[0].axis[i].lweight));
     color = MAX (0, MIN (15, graph[0].axis[i].color));
+    /* temporarily assume rectilinear axes */
+    doffset = ((int)(lweight) % 2) ? 0.5*(lweight - 1) : 0.5*lweight;
+    if (i == 0) { dx = doffset; dy = 0.0; }
+    if (i == 2) { dx = doffset; dy = 0.0; }
+    if (i == 1) { dx = 0.0; dy = doffset; }
+    if (i == 3) { dx = 0.0; dy = doffset; }
+    fx  = graph[0].axis[i].fx - dx;
+    fy  = graph[0].axis[i].fy - dy;
+    dfx = graph[0].axis[i].dfx + 2*dx;
+    dfy = graph[0].axis[i].dfy + 2*dy;
+    P = hypot (graph[0].axis[(i+1)%2].dfx, graph[0].axis[(i+1)%2].dfy);
+    P *= (1 + 0.25*lweight);
     XSetLineAttributes (graphic->display, graphic->gc, lweight, LineSolid, CapNotLast, JoinMiter);
 …
+}
 int PrintTick (char *string, double value, double min, double max) {
+int PrintTick (char *string, double value, double min, double max, int nsignif) {
   int Nexp = 0;
 …
+  }
+  double lvalue = log10(fabs(value));
+  if (isfinite(lvalue)) {
+    Nexp = fabs(lvalue);
+  } else {
+    Nexp = 0;
+  }
+//   double lvalue = log10(fabs(value));
+//   if (isfinite(lvalue)) {
+//     Nexp = fabs(lvalue);
+//   } else {
+//     Nexp = 0;
+//   }
+  Nexp = abs(nsignif);
   if (Nexp > 3) {
     Nchar = sprintf (string, "%.1e", value);
   } else {
+    Nchar = sprintf (string, "%.1f", value);
+    if (nsignif < 0) {
+      char format[16];
+      snprintf (format, 16, "%%.%df", -1 * nsignif);
+      Nchar = sprintf (string, format, value);
+    } else {
+      Nchar = sprintf (string, "%.1f", value);
+    }
+  }
   return Nchar;
 …
     yt = fy + (value-min)*dfy/(max - min) + dy;
     PrintTick (string, value, min, max);
+    PrintTick (string, value, min, max, tick->nsignif);
     DrawRotText (xt, yt, string, pos, 0.0);
+  }
 …
 # define MIN_RANGE 1e-10
 void AxisTickScale (Axis *axis, double *major, double *minor) {
+void AxisTickScale (Axis *axis, double *major, double *minor, int *nsignif) {
   double range, lrange, factor, mantis, fmantis, power;
 …
+  }
+  // how many significant digits are needed?
   power = MAX(pow(10.0, factor), MIN_RANGE);
   fmantis = pow(10.0, mantis);
 …
     *major = 0.5 * power;
     *minor = 0.1 * power;
+    *nsignif = factor - 1;
     if (axis[0].areticks == 1) {
       *major = 0.25 * power;
       *minor = 0.05 * power;
+      *nsignif = factor - 2;
+    }
+  }
 …
     *major = 1.0 * power;
     *minor = 0.2 * power;
+    *nsignif = factor;
     if (axis[0].areticks == 1) {
       *major = 0.5 * power;
       *minor = 0.1 * power;
+      *nsignif = factor - 1;
+    }
+  }
 …
     *major = 1.0 * power;
     *minor = 0.5 * power;
+    *nsignif = factor;
     if (axis[0].areticks == 1) {
       *major = 1.0 * power;
       *minor = 0.2 * power;
+      *nsignif = factor;
+    }
+  }
 …
     *major = 2.0 * power;
     *minor = 0.5 * power;
+    *nsignif = factor;
     if (axis[0].areticks == 1) {
       *major = 1.0 * power;
       *minor = 0.5 * power;
+      *nsignif = factor;
+    }
+  }
 …
     *major = 2.5 * power;
     *minor = 0.5 * power;
+      *nsignif = factor - 1;
     if (axis[0].areticks == 1) {
       *major = 2.0 * power;
       *minor = 0.5 * power;
+      *nsignif = factor;
+    }
+  }
 …
   TickMarkData *ticks;
   double range, major, minor, first, value, dPixels, overshoot;
   int i, NTICKS, nPixels, done, ifirst;
+  int i, NTICKS, nPixels, done, ifirst, nsignif;
   *nticks = 0;
 …
   dPixels = nPixels / range; // axis pixel-scale
   AxisTickScale (axis, &major, &minor);
+  AxisTickScale (axis, &major, &minor, &nsignif);
   // be a little generous
 …
     ticks[i].IsLabel = (ticks[i].IsMajor && axis->islabel);
     ticks[i].value = value;
+    ticks[i].nsignif = nsignif;
     if (range > 0)
       value += minor;

trunk/Ohana/src/kapa2/src/Image.c

-              r29539
+              r29938
   InitButtonSize (&image[0].PS_button, PS_width, PS_height, PS_bits);
+  InitButtonFunc (&image[0].PS_button, PSfunction);
+  // InitButtonFunc (&image[0].PS_button, PSfunction);
+  image->PS_button.function_1 = PSfunction;
+  image->PS_button.function_2 = PNGfunction;
+  image->PS_button.function_3 = JPEGfunction;
   InitButtonSize (&image[0].grey_button, grey_width, grey_height, grey_bits);

trunk/Ohana/src/kapa2/src/JPEGit24.c

-              r27601
+              r29938
 # define WHITE_B 255
+int JPEGcommand (int sock) {
+  int status;
+  char filename[1024];
+  KiiScanMessage (sock, "%s", filename);
+  status = JPEGit24 (filename);
+  return (status);
+}
 // XXX this currently writes out the jpeg for just the active image
 int JPEGit24 (int sock) {
+int JPEGit24 (char *filename) {
   struct jpeg_compress_struct cinfo;
 …
   unsigned short *in_pix, *in_pix_ref;
   unsigned char *pixel1, *pixel2, *pixel3;
-  char filename[1024];
   FILE *f;
-  /* expect a line telling the number of bytes and a filename */
-  KiiScanMessage (sock, "%s", filename);
   graphic = GetGraphic();
 …
     palette = KapaPNGPalette (&Npalette);
+    buffer = bDrawBufferCreate (dx, dy);
+    bDrawSetBuffer (buffer);
+    buffer = bDrawBufferCreate (dx, dy, 1, palette, Npalette);
     for (i = 0; i < NOVERLAYS; i++) {
       if (image[i].overlay[i].active) bDrawOverlay (image, i);
+      if (image[0].overlay[i].active) bDrawOverlay (buffer, image, i);
+    }

trunk/Ohana/src/kapa2/src/PNGit.c

-              r29408
+              r29938
 */
+bDrawBuffer *bDrawBufferCreate8bitRGB (int Nx, int Ny);
+int bDrawImage (bDrawBuffer *buffer, Graphic *graphic);
+int PNGcommand (int sock) {
+int PNGit (int sock) {
+  int status;
+  char filename[1024];
+  KiiScanMessage (sock, "%s", filename);
+  status = PNGit (filename);
+  return (status);
+}
+int PNGit (char *filename) {
   FILE *f;
   png_structp png_ptr;
   png_infop info_ptr;
+  int status, Npalette;
+  char filename[1024];
+  int i, status, Npalette, Nsection;
   bDrawBuffer *buffer = NULL;
   Graphic *graphic = NULL;
   png_color *palette = NULL;
+  Section *section;
   graphic = GetGraphic();
-  /* expect a line telling the number of bytes and a filename */
-  KiiScanMessage (sock, "%s", filename);
   f = fopen (filename, "w");
 …
   png_init_io (png_ptr, f);
+  palette = KapaPNGPalette (&Npalette);
+  // do we have an image in any of the sections?
+  Nsection = GetNumberOfSections ();
+  int haveImage = FALSE;
+  for (i = 0; !haveImage && (i < Nsection); i++) {
+    section = GetSectionByNumber (i);
+    haveImage = (section->image != NULL);
+  }
   /* see docs for write-row-callback to provide progress info */
+# define PALETTE 1
+  if (PALETTE) {
+    png_set_IHDR (png_ptr, info_ptr, graphic->dx, graphic->dy, 8, PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+    palette = KapaPNGPalette (&Npalette);
+    png_set_PLTE (png_ptr, info_ptr, palette, Npalette);
+  } else {
+  if (haveImage) {
     // png_set_IHDR (png_ptr, info_ptr, graphic->dx, graphic->dy, 16, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
     png_set_IHDR (png_ptr, info_ptr, graphic->dx, graphic->dy, 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
     png_set_sRGB (png_ptr, info_ptr, PNG_sRGB_INTENT_ABSOLUTE);
+  } else {
+    png_set_IHDR (png_ptr, info_ptr, graphic->dx, graphic->dy, 8, PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+    png_set_PLTE (png_ptr, info_ptr, palette, Npalette);
+  }
 …
   png_write_info (png_ptr, info_ptr);
+  if (PALETTE) {
+    buffer = bDrawIt ();
+  if (haveImage) {
+    buffer = bDrawIt (palette, Npalette, 3);
+    // bDrawImage (buffer, graphic);
   } else {
+    buffer = bDrawBufferCreate8bitRGB(graphic->dx, graphic->dy);
+    bDrawImage (buffer, graphic);
+    buffer = bDrawIt (palette, Npalette, 1);
+  }
 …
   bDrawBufferFree (buffer);
-  free (palette);
   fclose (f);
   return (TRUE);
+}
-/* For color images, I need to define the relationship between the drawing colors and the RGB values? */
-bDrawBuffer *bDrawBufferCreate8bitRGB (int Nx, int Ny) {
-  int i, j;
-  bDrawBuffer *buffer;
-  ALLOCATE (buffer, bDrawBuffer, 1);
-  buffer[0].Nx = Nx;
-  buffer[0].Ny = Ny;
-  ALLOCATE (buffer[0].pixels, bDrawColor *, Ny);
-  for (i = 0; i < Ny; i++) {
-    ALLOCATE (buffer[0].pixels[i], bDrawColor, 3*Nx);
-    for (j = 0; j < 3*Nx; j+=3) {
-      buffer[0].pixels[i][j+0] = 0xff;
-      buffer[0].pixels[i][j+1] = 0xff;
-      buffer[0].pixels[i][j+2] = 0xff;
+    }
+  }
-  return (buffer);
+}
-# define WHITE_R 255
-# define WHITE_G 255
-# define WHITE_B 255
-# define MY_SWAP_INT(A,B) { int tmp; tmp = A; A = B; B = tmp; }
-int bDrawImage (bDrawBuffer *buffer, Graphic *graphic) {
-  Section *section;
-  KapaImageWidget *image;
-  int ii, i, j;
-  int i_start, i_end, j_start, j_end;
-  int I_start, J_start;
-  int dropback;  /* this is a bit of a kludge... */
-  int dx, dy, DX, DY, inDX, inDY;
-  int expand_in, expand_out;
-  double expand, Ix, Iy;
-  unsigned char *out_pix;
-  unsigned short *in_pix, *in_pix_ref;
-  unsigned char *pixel1, *pixel2, *pixel3;
-  bDrawColor *line_buffer;
-  section = GetActiveSection();
-  image   = section->image;
-  if (image == NULL) return (TRUE);
-  ALLOCATE (pixel1, unsigned char, graphic[0].Npixels);
-  ALLOCATE (pixel2, unsigned char, graphic[0].Npixels);
-  ALLOCATE (pixel3, unsigned char, graphic[0].Npixels);
-  /** cmap[i].pixel must be defined even if X is not used **/
-  for (i = 0; i < graphic[0].Npixels; i++) { /* set up pixel array */
-    pixel1[i] = graphic[0].cmap[i].red >> 8;
-    pixel2[i] = graphic[0].cmap[i].green >> 8;
-    pixel3[i] = graphic[0].cmap[i].blue >> 8;
+  }
-  assert ((image[0].picture.expand >= 1) || (image[0].picture.expand <= -2));
-  expand = expand_in = expand_out = 1.0;
-  if (image[0].picture.expand > 0) {
-    expand = 1 / (1.0*image[0].picture.expand);
-    expand_out = image[0].picture.expand;
-    expand_in  = 1;
+  }
-  if (image[0].picture.expand < 0) {
-    expand = fabs((double)image[0].picture.expand);
-    expand_out = 1;
-    expand_in  = -image[0].picture.expand;
+  }
-  dx = image[0].picture.dx;
-  dy = image[0].picture.dy;
-  DX = image[0].image[0].matrix.Naxis[0];
-  DY = image[0].image[0].matrix.Naxis[1];
-  // i_start, j_start are the closest lit screen pixel to 0,0
-  // I_start, J_start are the image pixel corresponding to i_start, j_start
-  Picture_Lower (&i_start, &j_start, &I_start, &J_start, &image[0].image[0].matrix, &image[0].picture);
-  // i_end, j_end are the closest lit screen pixel to dx, dy
-  // I_end, J_end are the image pixel corresponding to i_end, j_end
-  Picture_Upper (&i_end, &j_end, i_start, j_start, &image[0].image[0].matrix, &image[0].picture);
-  assert (i_start <= i_end);
-  assert (j_start <= j_end);
-  Ix = image[0].picture.flipx ? I_start - 1 : I_start;
-  Iy = image[0].picture.flipy ? J_start - 1 : J_start;
-  inDX = image[0].picture.flipx ? -1 : +1;
-  inDY = image[0].picture.flipy ? -1 : +1;
-  dropback = expand_out - (i_end - i_start) % expand_out;
-  if ((i_end - i_start) % expand_out == 0) dropback = 0;
-  ALLOCATE (line_buffer, bDrawColor, 3*dx);
-  in_pix_ref  = &image[0].pixmap[DX*(int)MAX(Iy,0) + (int)MAX(Ix,0)];
-  /********** below we do the mapping from buffer pixels (in) to picture pixels (out) **********/
-  /**** fill in bottom area ****/
-  out_pix = line_buffer;
-  for (i = 0; i < dx; i++, out_pix+=3) {
-    out_pix[0] = WHITE_R;
-    out_pix[1] = WHITE_G;
-    out_pix[2] = WHITE_B;
+  }
-  for (j = 0; j < j_start; j++) {
-    memcpy (buffer[0].pixels[j], line_buffer, 3*dx);
+  }
-  /*** fill in the image data region ***/
-  for (j = j_start; j < j_end; j+= expand_out, in_pix_ref += inDY*expand_in*DX) {
-    /* create one output image line */
-    in_pix = in_pix_ref;
-    out_pix = line_buffer;
-    /**** fill in area to the left of the picture ****/
-    for (i = 0; i < i_start; i++, out_pix+=3) {
-      out_pix[0] = WHITE_R;
-      out_pix[1] = WHITE_G;
-      out_pix[2] = WHITE_B;
+    }
-    /*** fill in the picture region ***/
-    for (i = i_start; i < i_end; i+=expand_out, in_pix += inDX*expand_in) {
-      for (ii = 0; ii < expand_out; ii++, out_pix+=3) {
-        out_pix[0] = pixel1[*in_pix];
-        out_pix[1] = pixel2[*in_pix];
-        out_pix[2] = pixel3[*in_pix];
+      }
+    }
-    /**** fill in area to the right of the picture ****/
-    for (i = i_end; i < dx; i++, out_pix+=3) {
-      out_pix[0] = WHITE_R;
-      out_pix[1] = WHITE_G;
-      out_pix[2] = WHITE_B;
+    }
-    /* write out the image line expand_out times */
-    for (i = 0; i < expand_out; i++) {
-      memcpy (buffer[0].pixels[j + i], line_buffer, 3*dx);
+    }
+  }
-  /**** fill in top area ****/
-  out_pix = line_buffer;
-  for (i = 0; i < dx; i++, out_pix+=3) {
-    out_pix[0] = WHITE_R;
-    out_pix[1] = WHITE_G;
-    out_pix[2] = WHITE_B;
+  }
-  for (j = j_end; j < dy; j++) {
-    memcpy (buffer[0].pixels[j], line_buffer, 3*dx);
+  }
-  free (pixel1);
-  free (pixel2);
-  free (pixel3);
-  free (line_buffer);
-  return (TRUE);
+}
-# if (0)
-  /* I need to write the overlay objects on the jpeg image.
-     if i can write / overwrite data in jpeg buffer, then do it here,
-     otherwise i need to create a temporary image buffer, then write the
-     scanlines to that buffer */
+  {
-    int Npalette;
-    png_color *palette;
-    bDrawColor white, color;
-    bDrawBuffer *buffer;
-    palette = KapaPNGPalette (&Npalette);
-    buffer = bDrawBufferCreate (dx, dy);
-    bDrawSetBuffer (buffer);
-    for (i = 0; i < NOVERLAYS; i++) {
-      if (image[i].overlay[i].active) bDrawOverlay (image, i);
+    }
-    white = KapaColorByName ("white");
-    for (j = 0; j < dy; j++) {
-      for (i = 0; i < dx; i++) {
-        color = buffer[0].pixels[j][i];
-        if (color == white) continue;
-        image_buffer[j*3*dx + 3*i + 0] = palette[color].red;
-        image_buffer[j*3*dx + 3*i + 1] = palette[color].green;
-        image_buffer[j*3*dx + 3*i + 2] = palette[color].blue;
+      }
+    }
-    bDrawBufferFree (buffer);
+  }
-# endif

trunk/Ohana/src/kapa2/src/PPMit.c

-              r27435
+              r29938
   fprintf (f, "255\n");
   buffer = bDrawIt ();
+  buffer = bDrawIt (palette, Npalette, 1);
   ALLOCATE (line, char, 3*dx);
 …
   bDrawBufferFree (buffer);
   return (TRUE);
+}

trunk/Ohana/src/kapa2/src/PSFrame.c

-              r29539
+              r29938
 int PSFrame (KapaGraphWidget *graph, FILE *f) {
   int i, j, Nticks, P;
   double fx, fy, dfx, dfy, lweight;
+  int i, j, Nticks, P, doffset;
+  double fx, fy, dfx, dfy, dx, dy, lweight;
   Graphic *graphic;
   TickMarkData *ticks;
 …
   fprintf (f, "1 setlinewidth\n");
   for (i = 0; i < 4; i++) {
-    fx  = graph[0].axis[i].fx;
-    fy  = graphic->dy - graph[0].axis[i].fy;
-    dfx = graph[0].axis[i].dfx;
-    dfy = -graph[0].axis[i].dfy;
-    P = hypot (graph[0].axis[(i+1)%2].dfx, graph[0].axis[(i+1)%2].dfy);
     lweight = MAX (0, MIN (10, graph[0].axis[i].lweight));
     color = MAX (0, MIN (15, graph[0].axis[i].color));
+    /* temporarily assume rectilinear axes */
+    doffset = ((int)(lweight) % 2) ? 0.5*(lweight - 1) : 0.5*lweight;
+    if (i == 0) { dx = doffset; dy = 0.0; }
+    if (i == 2) { dx = doffset; dy = 0.0; }
+    if (i == 1) { dx = 0.0; dy = doffset; }
+    if (i == 3) { dx = 0.0; dy = doffset; }
+    fx  = graph[0].axis[i].fx - dx;
+    fy  = graphic->dy - graph[0].axis[i].fy - dy;
+    dfx = graph[0].axis[i].dfx + 2*dx;
+    dfy = -graph[0].axis[i].dfy + 2*dy;
+    P = hypot (graph[0].axis[(i+1)%2].dfx, graph[0].axis[(i+1)%2].dfy);
+    P *= (1 + 0.25*lweight);
     fprintf (f, "%.1f setlinewidth\n", lweight);
 …
     yt = fy + (value-min)*dfy/(max - min) + dy;
     PrintTick (string, value, min, max);
+    PrintTick (string, value, min, max, tick->nsignif);
     PSRotText (f, xt, yt, string, pos, 0.0);
+  }

trunk/Ohana/src/kapa2/src/PSimage.c

-              r14913
+              r29938
   graphic = GetGraphic();
+  fprintf (f, " newpath 0 0 moveto %d 0 lineto %d %d lineto 0 %d lineto closepath clip\n\n",
+           image[0].picture.dx, image[0].picture.dx, image[0].picture.dy, image[0].picture.dy);
+  fprintf (f, " newpath %d %d moveto %d %d lineto %d %d lineto %d %d lineto closepath\n\n",
+           (int) image[0].picture.x,                       graphic->dy - (int) image[0].picture.y,
+           (int) image[0].picture.x + image[0].picture.dx, graphic->dy - (int) image[0].picture.y,
+           (int) image[0].picture.x + image[0].picture.dx, graphic->dy - (int) image[0].picture.y - image[0].picture.dy,
+           (int) image[0].picture.x,                       graphic->dy - (int) image[0].picture.y - image[0].picture.dy);
   fprintf (f, "gsave %% encloses image\n");
+  fprintf (f, "%d %d translate\n", (int) image[0].picture.x, graphic->dy - (int) image[0].picture.y - image[0].picture.dy);
   fprintf (f, "%d %d 8\n", image[0].picture.dx, image[0].picture.dy);
   fprintf (f, "[1 0 0 1 0 0]\n");

trunk/Ohana/src/kapa2/src/PSit.c

-              r13479
+              r29938
   for (i = 0; i < Nsection; i++) {
     section = GetSectionByNumber (i);
+    if (section->image) {
+      PSimage (section->image, f);
+    }
     if (section->graph) {
       PSFrame (section->graph, f);
 …
       PSLabels (section->graph, f);
       PSTextlines (section->graph, f);
+    }
-    if (section->image) {
-      PSimage (section->image, f);
+    }
+  }

trunk/Ohana/src/kapa2/src/Resize.c

-              r26891
+              r29938
   return (TRUE);
+}
+// resise the window so the image in the currently active window fills its section
+int ResizeByImage (int sock) {
+  int i, Nsection;
+  unsigned int NX, NY;
+  double dx, dy;
+  int dXm, dXp, dYm, dYp;
+  double x0, y0, x1, y1, expand;
+  Section *section;
+  Graphic *graphic;
+  KapaImageWidget *image;
+  graphic = GetGraphic();
+  section = GetActiveSection();
+  image = section->image;
+  if (!image) {
+    fprintf (stderr, "no image to define size\n");
+    return (TRUE);
+  }
+  GetGraphBoundary (section, &x0, &y0, &x1, &y1, &dXm, &dXp, &dYm, &dYp);
+  expand = 1.0;
+  if (image[0].picture.expand > 0) {
+    expand = image[0].picture.expand;
+  }
+  if (image[0].picture.expand < 0) {
+    expand = 1.0 / fabs((double)image[0].picture.expand);
+  }
+  // pixel dimensions of the imaging region + boundary
+  dx = image[0].image[0].matrix.Naxis[0]*expand + x1;
+  dy = image[0].image[0].matrix.Naxis[1]*expand + y1;
+  NX = dx / section[0].dx;
+  NY = dy / section[0].dy;
+  NX = MAX(NX, MIN_WIDTH);
+  NY = MAX(NY, MIN_HEIGHT);
+  // if the new size is the same as the old size, do nothing.
+  if ((graphic->dx == NX) && (graphic->dy == NY)) return (TRUE);
+  // set the new window size
+  graphic->dx = NX;
+  graphic->dy = NY;
+  if (USE_XWINDOW) XResizeWindow (graphic->display, graphic->window, NX, NY);
+  // reset the sizes for all sections
+  Nsection = GetNumberOfSections ();
+  for (i = 0; i < Nsection; i++) {
+      section = GetSectionByNumber (i);
+      SetSectionSizes (section);
+  }
+  if (USE_XWINDOW) XClearWindow (graphic->display, graphic->window);
+  Refresh ();
+  return (TRUE);
+}

trunk/Ohana/src/kapa2/src/SetGraphSize.c

-              r29539
+              r29938
 void SetGraphSize (Section *section) {
+  int dXm, dXp, dYm, dYp;
+  double x0, y0, x1, y1;
+  KapaGraphWidget *graph;
+  Graphic *graphic;
+  GetGraphBoundary(section, &x0, &y0, &x1, &y1, &dXm, &dXp, &dYm, &dYp);
+  if (section == NULL) return;
+  graph = section->graph;
+  if (graph == NULL) return;
+  graphic = GetGraphic ();
+  double X0 = graphic[0].dx * section[0].x  + x0;
+  double Y0 = graphic[0].dy * section[0].y  + y0;
+  double dX = graphic[0].dx * section[0].dx - x1;
+  double dY = graphic[0].dy * section[0].dy - y1;
+  /* define locations of coordinate axes */
+  graph[0].axis[0].fx  = X0;
+  graph[0].axis[0].fy  = graphic->dy - Y0;
+  graph[0].axis[0].dfx = dX;
+  graph[0].axis[0].dfy = 0;
+  graph[0].axis[1].fx  = X0;
+  graph[0].axis[1].fy  = graphic->dy - Y0;
+  graph[0].axis[1].dfx = 0;
+  graph[0].axis[1].dfy = -dY;
+  graph[0].axis[2].fx  = X0;
+  graph[0].axis[2].fy  = graphic->dy - Y0 - dY;
+  graph[0].axis[2].dfx = dX;
+  graph[0].axis[2].dfy = 0;
+  graph[0].axis[3].fx  = X0 + dX;
+  graph[0].axis[3].fy  = graphic->dy - Y0;
+  graph[0].axis[3].dfx = 0;
+  graph[0].axis[3].dfy = -dY;
+  /* define locations of axis labels */
+  graph[0].label[LABELLL].x = graph[0].axis[0].fx;
+  graph[0].label[LABELLL].y = graph[0].axis[0].fy + dXm;
+  graph[0].label[LABELX0].x = graph[0].axis[0].fx + 0.5*graph[0].axis[0].dfx;
+  graph[0].label[LABELX0].y = graph[0].axis[0].fy + dXm;
+  graph[0].label[LABELLR].x = graph[0].axis[0].fx + graph[0].axis[0].dfx;
+  graph[0].label[LABELLR].y = graph[0].axis[0].fy + dXm;
+  graph[0].label[LABELUL].x = graph[0].axis[2].fx;
+  graph[0].label[LABELUL].y = graph[0].axis[2].fy - dXp;
+  graph[0].label[LABELX1].x = graph[0].axis[2].fx + 0.5*graph[0].axis[2].dfx;
+  graph[0].label[LABELX1].y = graph[0].axis[2].fy - dXp;
+  graph[0].label[LABELUR].x = graph[0].axis[2].fx + graph[0].axis[2].dfx;
+  graph[0].label[LABELUR].y = graph[0].axis[2].fy - dXp;
+  graph[0].label[LABELY0].y = graph[0].axis[1].fy + 0.5*graph[0].axis[1].dfy;
+  graph[0].label[LABELY0].x = graph[0].axis[1].fx - dYm;
+  graph[0].label[LABELY1].y = graph[0].axis[3].fy + 0.5*graph[0].axis[3].dfy;
+  graph[0].label[LABELY1].x = graph[0].axis[3].fx + dYp;
+  return;
+}
+int GetGraphBoundary (Section *section, double *x0, double *y0, double *x1, double *y1, int *dXm, int *dXp, int *dYm, int *dYp) {
   int i, Nticks;
   int fontsize, Nc = 0;
   int textpad, textdY, WdY;
-  int dXm, dXp, dYm, dYp;
   double padXm, padXp, padYm, padYp;
   double minPADx, maxPADx, minPADy;
   double minPAD, maxPAD;
-  double X0, Y0, dX, dY;
   char string[64], *fontname;
   KapaGraphWidget *graph;
 …
   TickMarkData *ticks;
+  if (section == NULL) return;
+  *x0 = 0.0;
+  *y0 = 0.0;
+  *x1 = 0.0;
+  *y1 = 0.0;
+  *dXm = 0;
+  *dXp = 0;
+  *dYm = 0;
+  *dYp = 0;
+  if (section == NULL) return FALSE;
   graph = section->graph;
   if (graph == NULL) return;
+  if (graph == NULL) return FALSE;
   graphic = GetGraphic ();
 …
   // these depend on (a) existence of tick labels and (b) auto-offset or not
   if (isnan(graph[0].axis[0].labelPad)) {
     dXm = (graph[0].axis[0].islabel) ? maxPAD  : minPAD;
   } else {
     dXm = graph[0].axis[0].labelPad * fontsize;
+    *dXm = (graph[0].axis[0].islabel) ? maxPAD  : minPAD;
+  } else {
+    *dXm = graph[0].axis[0].labelPad * fontsize;
+  }
   if (isnan(graph[0].axis[0].pad)) {
 …
   // these depend on (a) existence of tick labels and (b) auto-offset or not
   if (isnan(graph[0].axis[2].labelPad)) {
     dXp = (graph[0].axis[2].islabel) ? maxPAD : minPAD;
   } else {
     dXp = graph[0].axis[2].labelPad * fontsize;
+    *dXp = (graph[0].axis[2].islabel) ? maxPAD : minPAD;
+  } else {
+    *dXp = graph[0].axis[2].labelPad * fontsize;
+  }
   if (isnan(graph[0].axis[2].pad)) {
 …
       if (!ticks[i].IsMajor) continue;
       int Nchar = PrintTick (string, ticks[i].value, graph[0].axis[1].min, graph[0].axis[1].max);
+      int Nchar = PrintTick (string, ticks[i].value, graph[0].axis[1].min, graph[0].axis[1].max, ticks[i].nsignif);
       Nc = MAX (Nc, Nchar);
 …
+  }
   if (isnan(graph[0].axis[1].labelPad)) {
     dYm = (graph[0].axis[1].islabel) ? (0.7*(Nc + 1.5)*fontsize) : minPAD;
   } else {
     dYm = graph[0].axis[1].labelPad * fontsize;
+    *dYm = (graph[0].axis[1].islabel) ? (0.7*(Nc + 1.5)*fontsize) : minPAD;
+  } else {
+    *dYm = graph[0].axis[1].labelPad * fontsize;
+  }
   if (isnan(graph[0].axis[1].pad)) {
 …
     for (i = 0; i < Nticks; i++) {
       if (!ticks[i].IsMajor) continue;
       int Nchar = PrintTick (string, ticks[i].value, graph[0].axis[3].min, graph[0].axis[3].max);
+      int Nchar = PrintTick (string, ticks[i].value, graph[0].axis[3].min, graph[0].axis[3].max, ticks[i].nsignif);
       Nc = MAX (Nc, Nchar);
+    }
 …
+  }
   if (isnan(graph[0].axis[3].labelPad)) {
     dYp = (graph[0].axis[3].islabel) ? (0.7*(Nc + 1.5)*fontsize) : minPAD;
   } else {
     dYp = graph[0].axis[3].labelPad * fontsize;
+    *dYp = (graph[0].axis[3].islabel) ? (0.7*(Nc + 1.5)*fontsize) : minPAD;
+  } else {
+    *dYp = graph[0].axis[3].labelPad * fontsize;
+  }
   if (isnan(graph[0].axis[3].pad)) {
 …
   /* basic size of the graph in Xwindow coordinates, but measured from lower-left corner */
   X0 = graphic[0].dx * section[0].x + padYm;
   Y0 = graphic[0].dy * section[0].y + padXm;
   dX = graphic[0].dx * section[0].dx - padYm - padYp;
   dY = graphic[0].dy * section[0].dy - padXm - padXp;
+  *x0 = padYm;
+  *y0 = padXm;
+  *x1 = padYm + padYp;
+  *y1 = padXm + padXp;
   // if we are tied to an image, make mods as needed
 …
     switch (section->image->location) {
       case 0:
-        // no changes?
         break;
       case 1:
         Y0 = graphic[0].dy * section[0].y  + padXm         + 2*PAD1 + WdY + 2;
         dY = graphic[0].dy * section[0].dy - padXm - padXp - 4*PAD1 - 1 - WdY - COLORPAD;
+        *y0 = padXm + 2*PAD1 + WdY + 2;
+        *y1 = padXm + padXp + 4*PAD1 + 1 + WdY + COLORPAD;
         break;
       case 3:
         dY = graphic[0].dy * section[0].dy - padXm - padXp - 4*PAD1 - 1 - WdY - COLORPAD;
+        *y1 = padXm + padXp + 4*PAD1 + 1 + WdY + COLORPAD;
         break;
       case 2:
         X0 = graphic[0].dx * section[0].x  + padYm         + 2*PAD1 + ZOOM_X;
         dX = graphic[0].dx * section[0].dx - padYm - padYp - 3*PAD1 - ZOOM_X;
         dY = graphic[0].dy * section[0].dy - padXm - padXp - 2*PAD1 - COLORPAD;
+        *x0 = padYm + 2*PAD1 + ZOOM_X;
+        *x1 = padYm + padYp + 3*PAD1 + ZOOM_X;
+        *y1 = padXm + padXp + 2*PAD1 + COLORPAD;
         break;
       case 4:
         dX = graphic[0].dx * section[0].dx - padYm - padYp - 3*PAD1 - ZOOM_X;
         dY = graphic[0].dy * section[0].dy - padXm - padXp - 2*PAD1 - COLORPAD;
+        *x1 = padYm + padYp + 3*PAD1 + ZOOM_X;
+        *y1 = padXm + padXp + 2*PAD1 + COLORPAD;
         break;
+    }
+  }
+  /* define locations of coordinate axes */
+  graph[0].axis[0].fx  = X0;
+  graph[0].axis[0].fy  = graphic->dy - Y0;
+  graph[0].axis[0].dfx = dX;
+  graph[0].axis[0].dfy = 0;
+  graph[0].axis[1].fx  = X0;
+  graph[0].axis[1].fy  = graphic->dy - Y0;
+  graph[0].axis[1].dfx = 0;
+  graph[0].axis[1].dfy = -dY;
+  graph[0].axis[2].fx  = X0;
+  graph[0].axis[2].fy  = graphic->dy - Y0 - dY;
+  graph[0].axis[2].dfx = dX;
+  graph[0].axis[2].dfy = 0;
+  graph[0].axis[3].fx  = X0 + dX;
+  graph[0].axis[3].fy  = graphic->dy - Y0;
+  graph[0].axis[3].dfx = 0;
+  graph[0].axis[3].dfy = -dY;
+  /* define locations of axis labels */
+  graph[0].label[LABELLL].x = graph[0].axis[0].fx;
+  graph[0].label[LABELLL].y = graph[0].axis[0].fy + dXm;
+  graph[0].label[LABELX0].x = graph[0].axis[0].fx + 0.5*graph[0].axis[0].dfx;
+  graph[0].label[LABELX0].y = graph[0].axis[0].fy + dXm;
+  graph[0].label[LABELLR].x = graph[0].axis[0].fx + graph[0].axis[0].dfx;
+  graph[0].label[LABELLR].y = graph[0].axis[0].fy + dXm;
+  graph[0].label[LABELUL].x = graph[0].axis[2].fx;
+  graph[0].label[LABELUL].y = graph[0].axis[2].fy - dXp;
+  graph[0].label[LABELX1].x = graph[0].axis[2].fx + 0.5*graph[0].axis[2].dfx;
+  graph[0].label[LABELX1].y = graph[0].axis[2].fy - dXp;
+  graph[0].label[LABELUR].x = graph[0].axis[2].fx + graph[0].axis[2].dfx;
+  graph[0].label[LABELUR].y = graph[0].axis[2].fy - dXp;
+  graph[0].label[LABELY0].y = graph[0].axis[1].fy + 0.5*graph[0].axis[1].dfy;
+  graph[0].label[LABELY0].x = graph[0].axis[1].fx - dYm;
+  graph[0].label[LABELY1].y = graph[0].axis[3].fy + 0.5*graph[0].axis[3].dfy;
+  graph[0].label[LABELY1].x = graph[0].axis[3].fx + dYp;
+  // fprintf (stderr, "section %s, %f,%f : %f,%f\n", section->name, X0, Y0, dX, dY);
+  /* these are wrong and have to be adjusted to sit in the corners */
+  return (TRUE);
+}

trunk/Ohana/src/kapa2/src/bDrawFrame.c

-              r29539
+              r29938
 // bDrawLine is a function, not a macro like DrawLine
 int bDrawFrame (KapaGraphWidget *graph) {
+int bDrawFrame (bDrawBuffer *buffer, KapaGraphWidget *graph) {
   int i, j, Nticks, P;
   double fx, fy, dfx, dfy, lweight;
+  int i, j, Nticks, P, doffset;
+  double fx, fy, dfx, dfy, lweight, dx, dy;
   // Graphic graphic; is not needed
   TickMarkData *ticks;
 …
   /* each axis is drawn independently */
   for (i = 0; i < 4; i++) {
-    fx  = graph[0].axis[i].fx;
-    fy  = graph[0].axis[i].fy;
-    dfx = graph[0].axis[i].dfx;
-    dfy = graph[0].axis[i].dfy;
-    P = hypot (graph[0].axis[(i+1)%2].dfx, graph[0].axis[(i+1)%2].dfy);
     lweight = MAX (0, MIN (10, graph[0].axis[i].lweight));
     color = MAX (0, MIN (15, graph[0].axis[i].color));
+    bDrawSetStyle (color, lweight, 0);
+    // function about sets solor and weight
+    /* temporarily assume rectilinear axes */
+    doffset = ((int)(lweight) % 2) ? 0.5*(lweight - 1) : 0.5*lweight;
+    if (i == 0) { dx = doffset; dy = 0.0; }
+    if (i == 2) { dx = doffset; dy = 0.0; }
+    if (i == 1) { dx = 0.0; dy = doffset; }
+    if (i == 3) { dx = 0.0; dy = doffset; }
+    fx  = graph[0].axis[i].fx - dx;
+    fy  = graph[0].axis[i].fy - dy;
+    dfx = graph[0].axis[i].dfx + 2*dx;
+    dfy = graph[0].axis[i].dfy + 2*dy;
+    P = hypot (graph[0].axis[(i+1)%2].dfx, graph[0].axis[(i+1)%2].dfy);
+    P *= (1 + 0.25*lweight);
+    bDrawSetStyle (buffer, color, lweight, 0);
+    // function about sets color and weight
     // bDrawRotTextInit does not exist
     if (graph[0].axis[i].isaxis) {
       bDrawLine (fx, fy, fx+dfx, fy+dfy);
+      bDrawLine (buffer, fx, fy, fx+dfx, fy+dfy);
+    }
 …
       ticks = CreateAxisTicks (&graph[0].axis[i], &Nticks);
       for (j = 0; j < Nticks; j++) {
+        bDrawTick (&graph[0].axis[i], P, &ticks[j], i);
+        bDrawTick (buffer, &graph[0].axis[i], P, &ticks[j], i);
+        // XXX DrawTick sets the style to (color, 0, 0) for the font
+        // should the font weight stay the same?
+        // XXX probably not needed now:
+        // bDrawSetStyle (buffer, color, lweight, 0);
+      }
       FREE (ticks);
 …
+}
 void bDrawTick (Axis *axis, int P, TickMarkData *tick, int naxis) {
+void bDrawTick (bDrawBuffer *buffer, Axis *axis, int P, TickMarkData *tick, int naxis) {
   double x, y, dx, dy;
 …
   dy = dir*size*dfx*n;
   bDrawLine (x, y, x+dx, y+dy);
+  bDrawLine (buffer, x, y, x+dx, y+dy);
   if (tick->IsLabel) {
 …
     yt = fy + (value-min)*dfy/(max - min) + dy;
     PrintTick (string, value, min, max);
     bDrawRotText (xt, yt, string, pos, 0.0);
+    PrintTick (string, value, min, max, tick->nsignif);
+    bDrawRotText (buffer, xt, yt, string, pos, 0.0);
+  }
+}

trunk/Ohana/src/kapa2/src/bDrawIt.c

-              r13479
+              r29938
 # include "Ximage.h"
 bDrawBuffer *bDrawIt () {
+bDrawBuffer *bDrawIt (png_color *palette, int Npalette, int Nbyte) {
   int i, Nsection;
 …
   black = KapaColorByName ("black");
+  buffer = bDrawBufferCreate (graphic->dx, graphic->dy);
+  bDrawSetBuffer (buffer);
+  bDrawSetStyle (black, 0, 0);
+  buffer = bDrawBufferCreate (graphic->dx, graphic->dy, Nbyte, palette, Npalette);
+  bDrawSetStyle (buffer, black, 0, 0);
   // reset the sizes for all sections
 …
   for (i = 0; i < Nsection; i++) {
       section = GetSectionByNumber (i);
       bDrawGraph (section->graph);
       // bDrawImage (section->image);
+      bDrawImage (buffer, section->image, graphic);
+      bDrawGraph (buffer, section->graph);
+  }
 …
+}
 void bDrawGraph (KapaGraphWidget *graph) {
+void bDrawGraph (bDrawBuffer *buffer, KapaGraphWidget *graph) {
   if (graph == NULL) return;
   bDrawFrame (graph);
   bDrawObjects (graph);
   bDrawLabels (graph);
   bDrawTextlines (graph);
+  bDrawFrame (buffer, graph);
+  bDrawObjects (buffer, graph);
+  bDrawLabels (buffer, graph);
+  bDrawTextlines (buffer, graph);
+}

trunk/Ohana/src/kapa2/src/bDrawLabels.c

r13320	r29938
1	1	# include "Ximage.h"
2	2
3		void bDrawLabels (KapaGraphWidget *graph) {
	3	void bDrawLabels (bDrawBuffer buffer, KapaGraphWidget graph) {
4	4
5	5	int i, pos, x, y, size;
…	…
25	25	y = graph[0].label[i].y;
26	26	SetRotFont (graph[0].label[i].font, graph[0].label[i].size);
27		bDrawRotText (x, y, graph[0].label[i].text, pos, angle);
	27	bDrawRotText (buffer, x, y, graph[0].label[i].text, pos, angle);
28	28	}
29	29	}
…	…
31	31	}
32	32
33		void bDrawTextlines (KapaGraphWidget *graph) {
	33	void bDrawTextlines (bDrawBuffer buffer, KapaGraphWidget graph) {
34	34
35	35	int i, x, y, size;
…	…
44	44	y = graph[0].textline[i].y;
45	45	SetRotFont (graph[0].textline[i].font, graph[0].textline[i].size);
46		bDrawRotText (x, y, graph[0].textline[i].text, 5, angle);
	46	bDrawRotText (buffer, x, y, graph[0].textline[i].text, 5, angle);
47	47	}
48	48	}

trunk/Ohana/src/kapa2/src/bDrawObjects.c

r27530	r29938
1	1	# include "Ximage.h"
2	2
3		# define DrawLine(~~X1,Y1,X2,Y2) (bDrawLine (~~(X1), (Y1), (X2), (Y2)))
4		# define DrawCircle(~~X1,Y1,R) (bDrawCircle (~~(X1), (Y1), (R)))
5		# define DrawRectangle(~~X,Y,dX,dY) (bDrawRectOpen (~~(X-0.5dX), (Y-0.5dY), (X+0.5dX), (Y+0.5dY)))
6		# define FillRectangle(~~X,Y,dX,dY) (bDrawRectFill (~~(X-0.5dX), (Y-0.5dY), (X+0.5dX), (Y+0.5dY)))
7		# define FillTriangle(~~X1,Y1,X2,Y2,X3,Y3) (bDrawTriFill (~~(X1), (Y1), (X2), (Y2), (X3), (Y3)))
8		# define OpenTriangle(~~X1,Y1,X2,Y2,X3,Y3) (bDrawTriOpen (~~(X1), (Y1), (X2), (Y2), (X3), (Y3)))
	3	# define DrawLine(BUF,X1,Y1,X2,Y2) (bDrawLine (BUF, (X1), (Y1), (X2), (Y2)))
	4	# define DrawCircle(BUF,X1,Y1,R) (bDrawCircle (BUF, (X1), (Y1), (R)))
	5	# define DrawRectangle(BUF,X,Y,dX,dY) (bDrawRectOpen (BUF, (X-0.5dX), (Y-0.5dY), (X+0.5dX), (Y+0.5dY)))
	6	# define FillRectangle(BUF,X,Y,dX,dY) (bDrawRectFill (BUF, (X-0.5dX), (Y-0.5dY), (X+0.5dX), (Y+0.5dY)))
	7	# define FillTriangle(BUF,X1,Y1,X2,Y2,X3,Y3) (bDrawTriFill (BUF, (X1), (Y1), (X2), (Y2), (X3), (Y3)))
	8	# define OpenTriangle(BUF,X1,Y1,X2,Y2,X3,Y3) (bDrawTriOpen (BUF, (X1), (Y1), (X2), (Y2), (X3), (Y3)))
9	9
10	10	# define CONNECT 0
…	…
14	14	static Graphic *graphic;
15	15
16		int bDrawObjects (KapaGraphWidget *graph) {
	16	int bDrawObjects (bDrawBuffer buffer, KapaGraphWidget graph) {
17	17
18	18	int i;
…	…
30	30	type = graph[0].objects[i].ltype;
31	31	color = graph[0].objects[i].color;
32		bDrawSetStyle (color, weight, type);
	32	bDrawSetStyle (buffer, color, weight, type);
33	33
34	34	switch (graph[0].objects[i].style) {
35	35	case CONNECT:
36		bDrawConnect (graph, &graph[0].objects[i]);
	36	bDrawConnect (buffer, graph, &graph[0].objects[i]);
37	37	break;
38	38	case HISTOGRAM:
39		bDrawHistogram (graph, &graph[0].objects[i]);
	39	bDrawHistogram (buffer, graph, &graph[0].objects[i]);
40	40	break;
41	41	case POINTS:
42		bDrawPoints (graph, &graph[0].objects[i]);
	42	bDrawPoints (buffer, graph, &graph[0].objects[i]);
43	43	break;
44	44	}
45	45
46	46	if (graph[0].objects[i].etype & 0x01) {
47		bDrawYErrors (graph, &graph[0].objects[i]);
	47	bDrawYErrors (buffer, graph, &graph[0].objects[i]);
48	48	}
49	49	if (graph[0].objects[i].etype & 0x02) {
50		bDrawXErrors (graph, &graph[0].objects[i]);
51		}
52		}
53		bDrawSetStyle (black, 0, 0);
	50	bDrawXErrors (buffer, graph, &graph[0].objects[i]);
	51	}
	52	}
	53	bDrawSetStyle (buffer, black, 0, 0);
54	54	return (TRUE);
55	55	}
56	56
57		void bDrawConnect (KapaGraphWidget graph, Gobjects object) {
	57	void bDrawConnect (bDrawBuffer buffer, KapaGraphWidget graph, Gobjects *object) {
58	58
59	59	int i;
…	…
91	91	sx1 = x[i]mxi + y[i]mxj + bx;
92	92	sy1 = x[i]myi + y[i]myj + by;
93		bDrawClipLine (sx0, sy0, sx1, sy1, X0, Y0, X1, Y1);
	93	bDrawClipLine (buffer, sx0, sy0, sx1, sy1, X0, Y0, X1, Y1);
94	94	sx0 = sx1; sy0 = sy1;
95	95	}
96	96	}
97	97
98		void bDrawClipLine (double x0, double y0, double x1, double y1, double X0, double Y1, double X1, double Y0) {
	98	void bDrawClipLine (bDrawBuffer *buffer, double x0, double y0, double x1, double y1, double X0, double Y1, double X1, double Y0) {
99	99
100	100	/* skip line segement if both points are beyond box */
…	…
145	145	y1 = Y1;
146	146	}
147		DrawLine (x0, y0, x1, y1);
	147	DrawLine (buffer, x0, y0, x1, y1);
148	148	}
149	149
150	150	/*******/
151		void bDrawHistogram (KapaGraphWidget graph, Gobjects object) {
	151	void bDrawHistogram (bDrawBuffer buffer, KapaGraphWidget graph, Gobjects *object) {
152	152
153	153	int i;
…	…
192	192	sy1 = MAX (MIN (sy1, Y0), Y1);
193	193	sxa = 0.5*(sx0 + sx1);
194		DrawLine (sx0, sy0, sxa, sy0);
195		DrawLine (sxa, sy0, sxa, sy1);
196		DrawLine (sxa, sy1, sx1, sy1);
	194	DrawLine (buffer, sx0, sy0, sxa, sy0);
	195	DrawLine (buffer, sxa, sy0, sxa, sy1);
	196	DrawLine (buffer, sxa, sy1, sx1, sy1);
197	197	sx0 = sx1; sy0 = sy1;
198	198	}
…	…
200	200
201	201	/*******/
202		void bDrawPoints (KapaGraphWidget graph, Gobjects object) {
	202	void bDrawPoints (bDrawBuffer buffer, KapaGraphWidget graph, Gobjects *object) {
203	203
204	204	int i;
…	…
233	233	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
234	234	{
235		FillRectangle (sx, sy, 2dz[i], 2dz[i]);
	235	FillRectangle (buffer, sx, sy, 2dz[i], 2dz[i]);
236	236	}
237	237	}
…	…
245	245	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
246	246	{
247		DrawRectangle (sx, sy, 2dz[i], 2dz[i]);
	247	DrawRectangle (buffer, sx, sy, 2dz[i], 2dz[i]);
248	248	}
249	249	}
…	…
257	257	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
258	258	{
259		DrawLine (sx - dz[i], sy, sx + dz[i], sy);
260		DrawLine (sx, sy - dz[i], sx, sy + dz[i]);
	259	DrawLine (buffer, sx - dz[i], sy, sx + dz[i], sy);
	260	DrawLine (buffer, sx, sy - dz[i], sx, sy + dz[i]);
261	261	}
262	262	}
…	…
270	270	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
271	271	{
272		DrawLine (sx + dz[i], sy - dz[i], sx - dz[i], sy + dz[i]);
273		DrawLine (sx - dz[i], sy - dz[i], sx + dz[i], sy + dz[i]);
	272	DrawLine (buffer, sx + dz[i], sy - dz[i], sx - dz[i], sy + dz[i]);
	273	DrawLine (buffer, sx - dz[i], sy - dz[i], sx + dz[i], sy + dz[i]);
274	274	}
275	275	}
…	…
283	283	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
284	284	{
285		FillTriangle (sx - dz[i], sy - 0.58dz[i], sx + dz[i], sy - 0.58dz[i], sx, sy + 1.15dz[i]);
	285	FillTriangle (buffer, sx - dz[i], sy - 0.58dz[i], sx + dz[i], sy - 0.58dz[i], sx, sy + 1.15dz[i]);
286	286	}
287	287	}
…	…
295	295	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
296	296	{
297		OpenTriangle (sx - dz[i], sy + 0.58dz[i], sx, sy - 1.15dz[i], sx + dz[i], sy + 0.58dz[i]);
	297	OpenTriangle (buffer, sx - dz[i], sy + 0.58dz[i], sx, sy - 1.15dz[i], sx + dz[i], sy + 0.58dz[i]);
298	298	}
299	299	}
…	…
307	307	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
308	308	{
309		DrawLine (sx, sy, sx - dz[i], sy + 0.58d*z[i]);
310		DrawLine (sx, sy, sx + dz[i], sy + 0.58d*z[i]);
311		DrawLine (sx, sy, sx, sy - 1.15dz[i]);
	309	DrawLine (buffer, sx, sy, sx - dz[i], sy + 0.58d*z[i]);
	310	DrawLine (buffer, sx, sy, sx + dz[i], sy + 0.58d*z[i]);
	311	DrawLine (buffer, sx, sy, sx, sy - 1.15dz[i]);
312	312	}
313	313	}
…	…
321	321	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
322	322	{
323		DrawCircle (sx, sy, d*z[i]);
	323	DrawCircle (buffer, sx, sy, d*z[i]);
324	324	}
325	325	}
…	…
333	333	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
334	334	{
335		DrawLine (sx + 0.00dz[i], sy - 1.00dz[i], sx + 0.95dz[i], sy - 0.31dz[i]);
336		DrawLine (sx + 0.95dz[i], sy - 0.31dz[i], sx + 0.58dz[i], sy + 0.81dz[i]);
337		DrawLine (sx + 0.58dz[i], sy + 0.81dz[i], sx - 0.58dz[i], sy + 0.81dz[i]);
338		DrawLine (sx - 0.58dz[i], sy + 0.81dz[i], sx - 0.95dz[i], sy - 0.31dz[i]);
339		DrawLine (sx - 0.95dz[i], sy - 0.31dz[i], sx + 0.00dz[i], sy - 1.00dz[i]);
	335	DrawLine (buffer, sx + 0.00dz[i], sy - 1.00dz[i], sx + 0.95dz[i], sy - 0.31dz[i]);
	336	DrawLine (buffer, sx + 0.95dz[i], sy - 0.31dz[i], sx + 0.58dz[i], sy + 0.81dz[i]);
	337	DrawLine (buffer, sx + 0.58dz[i], sy + 0.81dz[i], sx - 0.58dz[i], sy + 0.81dz[i]);
	338	DrawLine (buffer, sx - 0.58dz[i], sy + 0.81dz[i], sx - 0.95dz[i], sy - 0.31dz[i]);
	339	DrawLine (buffer, sx - 0.95dz[i], sy - 0.31dz[i], sx + 0.00dz[i], sy - 1.00dz[i]);
340	340	}
341	341	}
…	…
349	349	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
350	350	{
351		DrawLine (sx - dz[i], sy, sx - 0.50dz[i], sy + 0.87d*z[i]);
352		DrawLine (sx - 0.50dz[i], sy + 0.87dz[i], sx + 0.50dz[i], sy + 0.87dz[i]);
353		DrawLine (sx + 0.50dz[i], sy + 0.87dz[i], sx + d*z[i], sy);
354
355		DrawLine (sx + dz[i], sy, sx + 0.50dz[i], sy - 0.87d*z[i]);
356		DrawLine (sx + 0.50dz[i], sy - 0.87dz[i], sx - 0.50dz[i], sy - 0.87dz[i]);
357		DrawLine (sx - 0.50dz[i], sy - 0.87dz[i], sx - d*z[i], sy);
	351	DrawLine (buffer, sx - dz[i], sy, sx - 0.50dz[i], sy + 0.87d*z[i]);
	352	DrawLine (buffer, sx - 0.50dz[i], sy + 0.87dz[i], sx + 0.50dz[i], sy + 0.87dz[i]);
	353	DrawLine (buffer, sx + 0.50dz[i], sy + 0.87dz[i], sx + d*z[i], sy);
	354
	355	DrawLine (buffer, sx + dz[i], sy, sx + 0.50dz[i], sy - 0.87d*z[i]);
	356	DrawLine (buffer, sx + 0.50dz[i], sy - 0.87dz[i], sx - 0.50dz[i], sy - 0.87dz[i]);
	357	DrawLine (buffer, sx - 0.50dz[i], sy - 0.87dz[i], sx - d*z[i], sy);
358	358	}
359	359	}
…	…
366	366	sx2 = x[i+1]mxi + y[i+1]mxj + bx;
367	367	sy2 = x[i+1]myi + y[i+1]myj + by;
368		DrawLine (sx1, sy1, sx2, sy2);
	368	DrawLine (buffer, sx1, sy1, sx2, sy2);
369	369	}
370	370	}
…	…
380	380	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
381	381	{
382		FillRectangle (sx, sy, 2d, 2d);
	382	FillRectangle (buffer, sx, sy, 2d, 2d);
383	383	}
384	384	}
…	…
392	392	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
393	393	{
394		DrawRectangle (sx, sy, 2d, 2d);
	394	DrawRectangle (buffer, sx, sy, 2d, 2d);
395	395	}
396	396	}
…	…
404	404	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
405	405	{
406		DrawLine (sx - d, sy, sx + d, sy);
407		DrawLine (sx, sy - d, sx, sy + d);
	406	DrawLine (buffer, sx - d, sy, sx + d, sy);
	407	DrawLine (buffer, sx, sy - d, sx, sy + d);
408	408	}
409	409	}
…	…
417	417	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
418	418	{
419		DrawLine (sx + d, sy - d, sx - d, sy + d);
420		DrawLine (sx - d, sy - d, sx + d, sy + d);
	419	DrawLine (buffer, sx + d, sy - d, sx - d, sy + d);
	420	DrawLine (buffer, sx - d, sy - d, sx + d, sy + d);
421	421	}
422	422	}
…	…
430	430	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
431	431	{
432		FillTriangle (sx - d, sy - 0.58d, sx + d, sy - 0.58d, sx, sy + 1.15*d);
	432	FillTriangle (buffer, sx - d, sy - 0.58d, sx + d, sy - 0.58d, sx, sy + 1.15*d);
433	433	}
434	434	}
…	…
442	442	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
443	443	{
444		OpenTriangle (sx - d, sy + 0.58d, sx + d, sy + 0.58d, sx, sy - 1.15*d);
	444	OpenTriangle (buffer, sx - d, sy + 0.58d, sx + d, sy + 0.58d, sx, sy - 1.15*d);
445	445	}
446	446	}
…	…
454	454	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
455	455	{
456		DrawLine (sx, sy, sx - d, sy - 0.58*d);
457		DrawLine (sx, sy, sx + d, sy - 0.58*d);
458		DrawLine (sx, sy, sx, sy + 1.15*d);
	456	DrawLine (buffer, sx, sy, sx - d, sy - 0.58*d);
	457	DrawLine (buffer, sx, sy, sx + d, sy - 0.58*d);
	458	DrawLine (buffer, sx, sy, sx, sy + 1.15*d);
459	459	}
460	460	}
…	…
468	468	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
469	469	{
470		DrawCircle (sx, sy, d);
	470	DrawCircle (buffer, sx, sy, d);
471	471	}
472	472	}
…	…
480	480	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
481	481	{
482		DrawLine (sx + 0.00d, sy - 1.00d, sx + 0.95d, sy - 0.31d);
483		DrawLine (sx + 0.95d, sy - 0.31d, sx + 0.58d, sy + 0.81d);
484		DrawLine (sx + 0.58d, sy + 0.81d, sx - 0.58d, sy + 0.81d);
485		DrawLine (sx - 0.58d, sy + 0.81d, sx - 0.95d, sy - 0.31d);
486		DrawLine (sx - 0.95d, sy - 0.31d, sx + 0.00d, sy - 1.00d);
	482	DrawLine (buffer, sx + 0.00d, sy - 1.00d, sx + 0.95d, sy - 0.31d);
	483	DrawLine (buffer, sx + 0.95d, sy - 0.31d, sx + 0.58d, sy + 0.81d);
	484	DrawLine (buffer, sx + 0.58d, sy + 0.81d, sx - 0.58d, sy + 0.81d);
	485	DrawLine (buffer, sx - 0.58d, sy + 0.81d, sx - 0.95d, sy - 0.31d);
	486	DrawLine (buffer, sx - 0.95d, sy - 0.31d, sx + 0.00d, sy - 1.00d);
487	487	}
488	488	}
…	…
496	496	(sy < graph[0].axis[1].fy) && (sy > graph[0].axis[1].fy + graph[0].axis[1].dfy))
497	497	{
498		DrawLine (sx - 1.00d, sy + 0.00d, sx - 0.50d, sy + 0.87d);
499		DrawLine (sx - 0.50d, sy + 0.87d, sx + 0.50d, sy + 0.87d);
500		DrawLine (sx + 0.50d, sy + 0.87d, sx + 1.00d, sy + 0.00d);
501		DrawLine (sx + 1.00d, sy + 0.00d, sx + 0.50d, sy - 0.87d);
502		DrawLine (sx + 0.50d, sy - 0.87d, sx - 0.50d, sy - 0.87d);
503		DrawLine (sx - 0.50d, sy - 0.87d, sx - 1.00d, sy + 0.00d);
	498	DrawLine (buffer, sx - 1.00d, sy + 0.00d, sx - 0.50d, sy + 0.87d);
	499	DrawLine (buffer, sx - 0.50d, sy + 0.87d, sx + 0.50d, sy + 0.87d);
	500	DrawLine (buffer, sx + 0.50d, sy + 0.87d, sx + 1.00d, sy + 0.00d);
	501	DrawLine (buffer, sx + 1.00d, sy + 0.00d, sx + 0.50d, sy - 0.87d);
	502	DrawLine (buffer, sx + 0.50d, sy - 0.87d, sx - 0.50d, sy - 0.87d);
	503	DrawLine (buffer, sx - 0.50d, sy - 0.87d, sx - 1.00d, sy + 0.00d);
504	504	}
505	505	}
…	…
512	512	sx2 = x[i+1]mxi + y[i+1]mxj + bx;
513	513	sy2 = x[i+1]myi + y[i+1]myj + by;
514		DrawLine (sx1, sy1, sx2, sy2);
	514	DrawLine (buffer, sx1, sy1, sx2, sy2);
515	515	}
516	516	}
…	…
519	519
520	520	/*******/
521		void bDrawXErrors (KapaGraphWidget graph, Gobjects object) {
	521	void bDrawXErrors (bDrawBuffer buffer, KapaGraphWidget graph, Gobjects *object) {
522	522
523	523	int i, bar;
…	…
553	553	(sy1 < graph[0].axis[1].fy) && (sy1 > graph[0].axis[1].fy + graph[0].axis[1].dfy)))
554	554	{
555		DrawLine (sx0, sy0, sx1, sy1);
	555	DrawLine (buffer, sx0, sy0, sx1, sy1);
556	556	if (bar) {
557	557	sx10 = sy1 - sz;
558	558	sx11 = sy1 + sz;
559		DrawLine (sx1, sx10, sx1, sx11);
	559	DrawLine (buffer, sx1, sx10, sx1, sx11);
560	560	}
561	561	}
…	…
570	570	(sy1 < graph[0].axis[1].fy) && (sy1 > graph[0].axis[1].fy + graph[0].axis[1].dfy)))
571	571	{
572		DrawLine (sx0, sy0, sx1, sy1);
	572	DrawLine (buffer, sx0, sy0, sx1, sy1);
573	573	if (bar) {
574	574	sx10 = sy1 - sz;
575	575	sx11 = sy1 + sz;
576		DrawLine (sx1, sx10, sx1, sx11);
	576	DrawLine (buffer, sx1, sx10, sx1, sx11);
577	577	}
578	578	}
…	…
581	581
582	582	/*******/
583		void bDrawYErrors (KapaGraphWidget graph, Gobjects object) {
	583	void bDrawYErrors (bDrawBuffer buffer, KapaGraphWidget graph, Gobjects *object) {
584	584
585	585	int i, bar;
…	…
615	615	(sy1 < graph[0].axis[1].fy) && (sy1 > graph[0].axis[1].fy + graph[0].axis[1].dfy)))
616	616	{
617		DrawLine (sx0, sy0, sx1, sy1);
	617	DrawLine (buffer, sx0, sy0, sx1, sy1);
618	618	if (bar) {
619	619	sx10 = sx1 - sz;
620	620	sx11 = sx1 + sz;
621		DrawLine (sx10, sy1, sx11, sy1);
	621	DrawLine (buffer, sx10, sy1, sx11, sy1);
622	622	}
623	623	}
…	…
632	632	(sy1 < graph[0].axis[1].fy) && (sy1 > graph[0].axis[1].fy + graph[0].axis[1].dfy)))
633	633	{
634		DrawLine (sx0, sy0, sx1, sy1);
	634	DrawLine (buffer, sx0, sy0, sx1, sy1);
635	635	if (bar) {
636	636	sx10 = sx1 - sz;
637	637	sx11 = sx1 + sz;
638		DrawLine (sx10, sy1, sx11, sy1);
	638	DrawLine (buffer, sx10, sy1, sx11, sy1);
639	639	}
640	640	}

trunk/Ohana/src/kapa2/src/bDrawOverlay.c

-              r25757
+              r29938
 static char name[4][16] = {"red", "green", "blue", "yellow"};
 void bDrawOverlay (KapaImageWidget *image, int N) {
+void bDrawOverlay (bDrawBuffer *buffer, KapaImageWidget *image, int N) {
   int i;
 …
   /* translate color to bDrawColors : image[0].overlay[N].color */
   color = KapaColorByName (name[N]);
   bDrawSetStyle (color, 0, 0);
+  bDrawSetStyle (buffer, color, 0, 0);
   expand = 1.0;
 …
     switch (image[0].overlay[N].objects[i].type) {
       case KII_OVERLAY_LINE:
         bDrawLine (X, Y, (X+dX), (Y+dY));
+        bDrawLine (buffer, X, Y, (X+dX), (Y+dY));
         break;
       case KII_OVERLAY_TEXT:
         bDrawRotText (X, Y, image[0].overlay[N].objects[i].text, 8, 0.0);
+        bDrawRotText (buffer, X, Y, image[0].overlay[N].objects[i].text, 8, 0.0);
         break;
       case KII_OVERLAY_BOX:
         dx = MAX (abs(dX),2) / 2;
         dy = MAX (abs(dY),2) / 2;
         bDrawRectOpen ((X-dx), (Y-dy), (X+dx), (Y+dy));
         // bDrawRectOpen ((X-dx), (Y-dy), (X), (Y));
+        bDrawRectOpen (buffer, (X-dx), (Y-dy), (X+dx), (Y+dy));
+        // bDrawRectOpen (buffer, (X-dx), (Y-dy), (X), (Y));
         break;
       case KII_OVERLAY_CIRCLE:
 …
         dy = MAX (abs(dY),2);
         if (image[0].overlay[N].objects[i].angle == 0.0) {
           bDrawArc (X, Y, dx, dy, 0, 360);
+          bDrawArc (buffer, X, Y, dx, dy, 0, 360);
         } else {
           // moderately-stupid rotated ellipse drawing:
 …
             x1 = X + pX*dx*cos(t)*cs - pX*dy*sin(t)*sn;
             y1 = Y + pY*dx*cos(t)*sn + pY*dy*sin(t)*cs;
             bDrawLine (x0, y0, x1, y1);
+            bDrawLine (buffer, x0, y0, x1, y1);
             x0 = x1;
             y0 = y1;
 …
   /* translate color to bDrawColors : image[0].overlay[N].color */
   bDrawSetStyle (color, 0, 0);
+  bDrawSetStyle (buffer, color, 0, 0);
+}

trunk/Ohana/src/libdvo/include/dvo.h

-              r29001
+              r29938
 // these are used as NAN for types of int values
 typedef enum {
     NAN_S_CHAR  = 0x7f,
     NAN_U_CHAR  = 0xff,   // was NO_ERR
     NAN_S_SHORT = 0x7fff, // was NO_MAG
     NAN_U_SHORT = 0xffff,
     NAN_S_INT   = 0x7fffffff,
     NAN_U_INT   = 0xffffffff,
+  NAN_S_CHAR  = 0x7f,
+  NAN_U_CHAR  = 0xff,   // was NO_ERR
+  NAN_S_SHORT = 0x7fff, // was NO_MAG
+  NAN_U_SHORT = 0xffff,
+  NAN_S_INT   = 0x7fffffff,
+  NAN_U_INT   = (signed int) 0xffffffff,
 } DVO_INT_NAN;
 …
 /* Average.code values -- these values are 32 bit (as of PS1_V1) */
 typedef enum {
   ID_STAR_FEW     = 0x00000001, // used within relphot: skip star
   ID_STAR_POOR    = 0x00000002, // used within relphot: skip star
   ID_PROPER       = 0x00000400, // star with large proper motion
   ID_TRANSIENT    = 0x00001000, // is this mutually exclusive with USNO?
   ID_VARIABLE     = 0x00002000, // not currently set?
   ID_ASTEROID     = 0x00002000, // identified with an asteroid
   ID_BAD_OBJECT   = 0x00004000, // if all measurements are bad, set this bit
+  ID_STAR_FEW     = 0x00000001, // used within relphot: skip star
+  ID_STAR_POOR    = 0x00000002, // used within relphot: skip star
+  ID_PROPER       = 0x00000400, // star with large proper motion
+  ID_TRANSIENT    = 0x00001000, // is this mutually exclusive with USNO?
+  ID_VARIABLE     = 0x00002000, // not currently set?
+  ID_ASTEROID     = 0x00002000, // identified with an asteroid
+  ID_BAD_OBJECT   = 0x00004000, // if all measurements are bad, set this bit
   ID_MOVING       = 0x00008000, // is a moving object
   ID_ROCK         = 0x0000a000, // 0x8000 + 0x2000
   ID_GHOST        = 0x0000c001, // 0x8000 + 0x4000 + 0x0001
   ID_TRAIL        = 0x0000c002, // 0x8000 + 0x4000 + 0x0002
   ID_BLEED        = 0x0000c003, // 0x8000 + 0x4000 + 0x0003
   ID_COSMIC       = 0x0000c004, // 0x8000 + 0x4000 + 0x0004
+  ID_ROCK         = 0x0000a000, // 0x8000 + 0x2000
+  ID_GHOST        = 0x0000c001, // 0x8000 + 0x4000 + 0x0001
+  ID_TRAIL        = 0x0000c002, // 0x8000 + 0x4000 + 0x0002
+  ID_BLEED        = 0x0000c003, // 0x8000 + 0x4000 + 0x0003
+  ID_COSMIC       = 0x0000c004, // 0x8000 + 0x4000 + 0x0004
   ID_STAR_FIT_AVE = 0x00010000, // average position fitted
   ID_STAR_FIT_PM  = 0x00020000, // proper motion fitted
 …
   ID_OBJ_EXT      = 0x01000000, // extended in our data (eg, PS)
   ID_OBJ_EXT_ALT  = 0x02000000, // extended in external data (eg, 2MASS)
   ID_OBJ_GOOD     = 0x04000000, // good-quality measurement in our data (eg, PS)
   ID_OBJ_GOOD_ALT = 0x08000000, // good-quality measurement in external data (eg, 2MASS)
+  ID_OBJ_GOOD     = 0x04000000, // good-quality measurement in our data (eg,PS)
+  ID_OBJ_GOOD_ALT = 0x08000000, // good-quality measurement in  external data (eg, 2MASS)
 } DVOAverageFlags;
 …
      *** that is just silly, and bad: convert to using Nsec_mem, Nsec_disk, Nsec_off.
      *** unless we always require the secfilt and average entries to be loaded sychronously.
    */
+     */
   /* pointers to split data files */
 …
 int isRegisteredMosaic (void);
 off_t GetRegisteredMosaic (void);
+off_t *GetChipMatch (void);
 int GetMosaicCoords (Coords *coords);
 int FindMosaicForImage (Image *images, off_t Nimages, off_t entry);

trunk/Ohana/src/libdvo/src/dvo_catalog.c

-              r27580
+              r29938
 int dvo_catalog_save (Catalog *catalog, char VERBOSE) {
+  int status = FALSE;
   // set the 'sorted' header keyword
   gfits_modify_alt (&catalog[0].header, "SORTED",  "%t", 1, catalog[0].sorted);
 …
   switch (catalog[0].catmode) {
     case DVO_MODE_RAW:
       dvo_catalog_save_raw (catalog, VERBOSE);
+      status = dvo_catalog_save_raw (catalog, VERBOSE);
       break;
     case DVO_MODE_MEF:
       dvo_catalog_save_mef (catalog, VERBOSE);
+      status = dvo_catalog_save_mef (catalog, VERBOSE);
       break;
     case DVO_MODE_SPLIT:
       dvo_catalog_save_split (catalog, VERBOSE);
+      status = dvo_catalog_save_split (catalog, VERBOSE);
       break;
     default:
 …
       exit (2);
+  }
   return (TRUE);
+  return (status);
+}

trunk/Ohana/src/libdvo/src/dvo_catalog_mef.c

-              r29001
+              r29938
   /* read Average table data (or skip) */
   if (catalog[0].catflags & LOAD_AVES) {
     if (!gfits_fread_ftable_data (f, &ftable)) {
+    if (!gfits_fread_ftable_data (f, &ftable, FALSE)) {
       if (VERBOSE) fprintf (stderr, "can't read table average data");
       return (FALSE);
 …
   /* read Measure table data */
   if (catalog[0].catflags & LOAD_MEAS) {
     if (!gfits_fread_ftable_data (f, &ftable)) {
+    if (!gfits_fread_ftable_data (f, &ftable, FALSE)) {
       if (VERBOSE) fprintf (stderr, "can't read table measure data");
       return (FALSE);
 …
   /* read Missing table data */
   if (catalog[0].catflags & LOAD_MISS) {
     if (!gfits_fread_ftable_data (f, &ftable)) {
+    if (!gfits_fread_ftable_data (f, &ftable, FALSE)) {
       if (VERBOSE) fprintf (stderr, "can't read table missing data");
       return (FALSE);
 …
   /* read secfilt table data */
   if (catalog[0].catflags & LOAD_SECF) {
     if (!gfits_fread_ftable_data (f, &ftable)) {
+    if (!gfits_fread_ftable_data (f, &ftable, FALSE)) {
       if (VERBOSE) fprintf (stderr, "can't read table secfilt data");
       return (FALSE);

trunk/Ohana/src/libdvo/src/dvo_catalog_split.c

-              r29001
+              r29938
+    }
     /* read Average table data : format is irrelevant here */
     if (!gfits_fread_ftable_data (catalog[0].f, &ftable)) {
+    if (!gfits_fread_ftable_data (catalog[0].f, &ftable, FALSE)) {
       if (VERBOSE) fprintf (stderr, "can't read table average data");
       return (FALSE);
 …
     // XXX this allows an empty Measure catalog with non-empty Average catalog : is that OK?
     /* read Measure table data */
     if (!gfits_fread_ftable_data (catalog[0].measure_catalog[0].f, &ftable)) {
+    if (!gfits_fread_ftable_data (catalog[0].measure_catalog[0].f, &ftable, FALSE)) {
       if (VERBOSE) fprintf (stderr, "can't read table measure data\n");
       return (FALSE);
 …
   if ((status != DVO_CAT_OPEN_EMPTY) && (catalog[0].catflags & LOAD_MISS)) {
     /* read Missing table data */
     if (!gfits_fread_ftable_data (catalog[0].missing_catalog[0].f, &ftable)) {
+    if (!gfits_fread_ftable_data (catalog[0].missing_catalog[0].f, &ftable, FALSE)) {
       if (VERBOSE) fprintf (stderr, "can't read table missing data\n");
       return (FALSE);
 …
   if ((status != DVO_CAT_OPEN_EMPTY) && (catalog[0].catflags & LOAD_SECF)) {
     /* read secfilt table data */
     if (!gfits_fread_ftable_data (catalog[0].secfilt_catalog[0].f, &ftable)) {
+    if (!gfits_fread_ftable_data (catalog[0].secfilt_catalog[0].f, &ftable, FALSE)) {
       if (VERBOSE) fprintf (stderr, "can't read table secfilt data\n");
       return (FALSE);

trunk/Ohana/src/libdvo/src/dvo_photcode_ops.c

-              r29182
+              r29938
+      }
+    }
+    if (entry == -1) {
+      // entry is missing fail (no printfs in this file)
+      free(map);
+      return(FALSE);
+    }
+    // if (entry == -1) {
+    //   // entry is missing fail (no printfs in this file)
+    //   free(map);
+    //   return(FALSE);
+    // }
+    // if entry is still -1, we will skip this one (not map into the output db)
     map[i] = entry;
+  }

trunk/Ohana/src/libdvo/src/fits_db.c

r28246	r29938
83	83	return (FALSE);
84	84	}
85		if (!gfits_fread_ftable_data (db[0].f, &db[0].ftable)) {
	85	if (!gfits_fread_ftable_data (db[0].f, &db[0].ftable, FALSE)) {
86	86	fprintf (stderr, "can't read table data");
87	87	gfits_db_free (db);

trunk/Ohana/src/libdvo/src/mosaic_astrom.c

-              r27435
+              r29938
+}
+/* what is the currently registered mosaic image? */
+off_t *GetChipMatch () {
+  return (ChipMatch);
+}
 /* given an image array and a current entry of type WRP, find matching DIS & Register it */
 int FindMosaicForImage (Image *images, off_t Nimages, off_t entry) {
 …
   if (strcmp(&images[entry].coords.ctype[4], "-WRP")) {
     /* not a wrp image, do nothing */
     return (TRUE); /* error or not */
+    return (entry + 1); /* error or not */
+  }
 …
     RegisterMosaic (&images[i].coords);
     iDIS = i;
     return (TRUE);
+    return (i + 1);
+  }
 …
     RegisterMosaic (&images[i].coords);
     iDIS = i;
     return (TRUE);
+    return (i + 1);
+  }
   return (FALSE);
 …
   if (strcmp(&images[entry].coords.ctype[4], "-WRP")) {
     /* not a wrp image, do nothing */
     return (TRUE); /* error or not? */
+    return (entry + 1); /* error or not? */
+  }
 …
   RegisterMosaic (&images[N].coords);
   iDIS = N;
   return (TRUE);
+  return (N + 1);
+}
 …
   SortDISindex (DIStzero, DISentry, Ndis);
+  // ChipMatch has a few possible values:
+  // -3 : image is a mosaic (DIS)
+  // -2 : image is an unassigned WRP image
+  // -1 : image is not a WRP or DIS images
+  // >= 0 : value is the mosaic seq number for this WRP image
   /* find all matched WRP images */
   ALLOCATE (ChipMatch, off_t, Nimages);
   for (i = 0; i < Nimages; i++) {
     ChipMatch[i] = -1;
+    if (!strcmp(&images[i].coords.ctype[4], "-DIS")) {
+      ChipMatch[i] = -3;
+      continue;
+    }
     if (strcmp(&images[i].coords.ctype[4], "-WRP")) continue;

trunk/Ohana/src/libfits/include/gfitsio.h

-              r29537
+              r29938
   char                   *buffer;
   off_t                   datasize;
+  off_t                   validsize;
 } FTable;
 …
 int     gfits_define_table_column      PROTO((Header *header, char *format, char *label, char *comment, char *unit));
 int     gfits_fread_ftable             PROTO((FILE *f, FTable *ftable, char *extname));
 int     gfits_fread_ftable_data        PROTO((FILE *f, FTable *ftable));
+int     gfits_fread_ftable_data        PROTO((FILE *f, FTable *ftable, int padIfShort));
 int     gfits_fread_ftable_range       PROTO((FILE *f, FTable *ftable, off_t start, off_t Nrows));
 int     gfits_fread_vtable             PROTO((FILE *f, VTable *vtable, char *extname, off_t Nrow, off_t *row));

trunk/Ohana/src/libfits/table/F_read_T.c

-              r28241
+              r29938
     gfits_scan (header, "EXTNAME", "%s", 1, tname);
     if (!strcmp (tname, extname)) {
       if (gfits_fread_ftable_data (f, table)) return (TRUE);
+      if (gfits_fread_ftable_data (f, table, FALSE)) return (TRUE);
       gfits_free_header (header);
       return (FALSE);
 …
 /*********************** fits read ftable data ***********************************/
 int gfits_fread_ftable_data (FILE *f, FTable *table) {
+int gfits_fread_ftable_data (FILE *f, FTable *table, int padIfShort) {
   off_t Nbytes, Nread;
 …
     if (Nread < gfits_data_min_size (table[0].header)) {
       fprintf (stderr, "error: fits read error in %s, read "OFF_T_FMT", need "OFF_T_FMT"\n", __func__,  Nread,  gfits_data_min_size (table[0].header));
+      gfits_free_table  (table);
+      return (FALSE);
+      if (padIfShort) {
+        memset (&table[0].buffer[Nread], 0, Nbytes - Nread);
+        fprintf (stderr, "warning: file missing data, padding with zeros: USE AT YOUR OWN RISK!\n");
+        table[0].validsize = Nread;
+        table[0].datasize = Nbytes;
+        return (TRUE);
+      } else {
+        gfits_free_table  (table);
+        return (FALSE);
+      }
+    }
     fprintf (stderr, "warning: file missing pad\n");
+  }
+  table[0].validsize = Nread;
   table[0].datasize = Nbytes;
   return (TRUE);

trunk/Ohana/src/libkapa/include/kapa.h

-              r29537
+              r29938
 typedef struct {
   int Nx, Ny;
+  int Nx, Ny, Nbyte;
   bDrawColor **pixels;
+  png_color *palette;
+  int Npalette;
+  // current drawing values:
+  int bWeight;
+  int bType;
+  bDrawColor bColor;
+  bDrawColor bColor_R;
+  bDrawColor bColor_G;
+  bDrawColor bColor_B;
 } bDrawBuffer;
 …
 /* KapaWindow.c */
 int KiiResize (int fd, int Nx, int Ny);
+int KiiResizeByImage (int fd);
 int KiiRelocate (int fd, int x, int y);
 int KiiCenter (int fd, double x, double y, int zoom);
 …
 int KapaGetLimits (int fd, float *dx, float *dy);
 int KapaSetSection (int fd, KapaSection *section);
+int KapaSetSectionByImage (int fd, KapaSection *section);
 int KapaSelectSection (int fd, char *name);
 int KapaGetSection (int fd, char *name);
 …
 /* bDrawFuncs.c */
 bDrawBuffer *bDrawBufferCreate (int Nx, int Ny);
+bDrawBuffer *bDrawBufferCreate (int Nx, int Ny, int Nbyte, png_color *palette, int Npalette);
 void bDrawBufferFree (bDrawBuffer *buffer);
 void bDrawSetBuffer (bDrawBuffer *buffer);
 void bDrawSetStyle (bDrawColor color, int lw, int lt);
 void bDrawPoint (int x, int y);
 void bDrawPointf (float x, float y);
 void bDrawArc (double Xc, double Yc, double Xr, double Yr, double Ts, double Te);
 void bDrawCircle (double Xc, double Yc, double radius);
 void bDrawCircleFill (double xc, double yc, double radius);
 void bDrawLine (double x1, double y1, double x2, double y2);
 void bDrawLineWeight (int X1, int Y1, int X2, int Y2, int swapcoords);
 void bDrawLineBresen (int X1, int Y1, int X2, int Y2, int swapcoords);
 void bDrawLineHorizontal (int X1, int X2, int Y);
 void bDrawLineVertical (int X, int Y1, int Y2);
 void bDrawRectOpen (double x1, double y1, double x2, double y2);
 void bDrawRectFill (double x1, double y1, double x2, double y2);
 void bDrawTriOpen (double x1, double y1, double x2, double y2, double x3, double y3);
 void bDrawTriFill (double x1, double y1, double x2, double y2, double x3, double y3);
+void bDrawSetStyle (bDrawBuffer *buffer, bDrawColor color, int lw, int lt);
+void bDrawPoint (bDrawBuffer *buffer, int x, int y);
+void bDrawPointf (bDrawBuffer *buffer, float x, float y);
+void bDrawArc (bDrawBuffer *buffer, double Xc, double Yc, double Xr, double Yr, double Ts, double Te);
+void bDrawCircle (bDrawBuffer *buffer, double Xc, double Yc, double radius);
+void bDrawCircleFill (bDrawBuffer *buffer, double xc, double yc, double radius);
+void bDrawLine (bDrawBuffer *buffer, double x1, double y1, double x2, double y2);
+void bDrawLineWeight (bDrawBuffer *buffer, int X1, int Y1, int X2, int Y2, int swapcoords);
+void bDrawLineBresen (bDrawBuffer *buffer, int X1, int Y1, int X2, int Y2, int swapcoords);
+void bDrawLineHorizontal (bDrawBuffer *buffer, int X1, int X2, int Y);
+void bDrawLineVertical (bDrawBuffer *buffer, int X, int Y1, int Y2);
+void bDrawRectOpen (bDrawBuffer *buffer, double x1, double y1, double x2, double y2);
+void bDrawRectFill (bDrawBuffer *buffer, double x1, double y1, double x2, double y2);
+void bDrawTriOpen  (bDrawBuffer *buffer, double x1, double y1, double x2, double y2, double x3, double y3);
+void bDrawTriFill  (bDrawBuffer *buffer, double x1, double y1, double x2, double y2, double x3, double y3);
 /* bDrawRotFont.c */
 int bDrawRotText (int x, int y, char *string, int pos, double angle);
 int bDrawRotBitmap (int x, int y, int dx, int dy, unsigned char *bitmap, int mode, double angle, double scale);
+int bDrawRotText (bDrawBuffer *buffer, int x, int y, char *string, int pos, double angle);
+int bDrawRotBitmap (bDrawBuffer *buffer, int x, int y, int dx, int dy, unsigned char *bitmap, int mode, double angle, double scale);
 /* Kapa Socket functions */

trunk/Ohana/src/libkapa/src/KapaWindow.c

-              r27790
+              r29938
   KiiSendCommand (fd, 4, "RSIZ");
   KiiSendMessage (fd, "%d %d", Nx, Ny);
+  KiiWaitAnswer (fd, "DONE");
+  return (TRUE);
+}
+int KiiResizeByImage (int fd) {
+  KiiSendCommand (fd, 4, "ISIZ");
   KiiWaitAnswer (fd, "DONE");
   return (TRUE);
 …
+}
+int KapaSetSectionByImage (int fd, KapaSection *section) {
+  KiiSendCommand (fd, 4, "ISEC");
+  KiiSendMessage (fd, "%s %6.3f %6.3f %3d",
+                  section[0].name,
+                  section[0].x,
+                  section[0].y,
+                  section[0].bg);
+  KiiWaitAnswer (fd, "DONE");
+  return (TRUE);
+}
 int KapaSectionBG (int fd, char *name, int bg) {

trunk/Ohana/src/libkapa/src/bDrawFuncs.c

-              r29537
+              r29938
 # include <kapa_internal.h>
+// XXX we can get rid of these static vars by making them elements of the bDrawBuffer
+//
+static int bWeight;
+static int bType;
+static bDrawColor bColor;
+static bDrawBuffer *bBuffer;
+void bDrawCircleSingle (double xc, double yc, double radius);
+bDrawBuffer *bDrawBufferCreate (int Nx, int Ny) {
+# define myAssert(LOGIC,MSG) { if (!(LOGIC)) { fprintf (stderr, "%s\n", MSG); abort (); } }
+// move these to the bDrawBuffer type
+// static int bWeight;
+// static int bType;
+// static bDrawColor bColor;
+// static bDrawColor bColor_R;
+// static bDrawColor bColor_G;
+// static bDrawColor bColor_B;
+// static bDrawBuffer *bBuffer;
+void bDrawCircleSingle (bDrawBuffer *buffer, double xc, double yc, double radius);
+// create a drawing buffer with either 1 or 3 byte colors
+bDrawBuffer *bDrawBufferCreate (int Nx, int Ny, int Nbyte, png_color *palette, int Npalette) {
   int i, j;
   bDrawColor white;
+  bDrawColor white, white_R, white_G, white_B;
   bDrawBuffer *buffer;
+  myAssert((Nbyte == 1) || (Nbyte == 3), "invalid depth");
+  myAssert(palette, "missing palette");
   white = KapaColorByName ("white");
+  white_R = palette[white].red;
+  white_G = palette[white].green;
+  white_B = palette[white].blue;
   ALLOCATE (buffer, bDrawBuffer, 1);
   buffer[0].Nx = Nx;
   buffer[0].Ny = Ny;
+  buffer[0].Nbyte = Nbyte;
+  buffer[0].palette = palette;
+  buffer[0].Npalette = Npalette;
   ALLOCATE (buffer[0].pixels, bDrawColor *, Ny);
   for (i = 0; i < Ny; i++) {
     ALLOCATE (buffer[0].pixels[i], bDrawColor, Nx);
+    ALLOCATE (buffer[0].pixels[i], bDrawColor, Nbyte*Nx);
     for (j = 0; j < Nx; j++) {
+      buffer[0].pixels[i][j] = white;
+    }
+  }
+      if (Nbyte == 1) {
+        buffer[0].pixels[i][j] = white;
+      } else {
+        buffer[0].pixels[i][3*j+0] = white_R;
+        buffer[0].pixels[i][3*j+1] = white_G;
+        buffer[0].pixels[i][3*j+2] = white_B;
+      }
+    }
+  }
+  buffer[0].bWeight = 0;
+  buffer[0].bType = 0;
+  buffer[0].bColor = white;
+  buffer[0].bColor_R = white_R;
+  buffer[0].bColor_G = white_G;
+  buffer[0].bColor_B = white_B;
   return (buffer);
+}
 …
+  }
   free (buffer[0].pixels);
+  free (buffer[0].palette);
   free (buffer);
   return;
+}
+void bDrawSetBuffer (bDrawBuffer *buffer) {
+  bBuffer = buffer;
+  return;
+}
+void bDrawSetStyle (bDrawColor color, int lw, int lt) {
+  bColor = color;
+  bWeight = lw;
+  bType = lt;
+// void bDrawSetBuffer (bDrawBuffer *buffer) {
+//   myAssert(buffer[0].Nbyte == 1, "invalid depth");
+//   bBuffer = buffer;
+//   return;
+// }
+void bDrawSetStyle (bDrawBuffer *buffer, bDrawColor color, int lw, int lt) {
+  buffer->bColor = color;
+  buffer->bColor_R = buffer->palette[color].red;
+  buffer->bColor_G = buffer->palette[color].green;
+  buffer->bColor_B = buffer->palette[color].blue;
+  buffer->bWeight = lw;
+  buffer->bType = lt;
   return;
+}
 // draw a point in the current color
+void bDrawPoint (int x, int y) {
+void bDrawPoint (bDrawBuffer *buffer, int x, int y) {
+  // myAssert(buffer[0].Nbyte == 1, "invalid depth");
   if (x < 0) return;
   if (y < 0) return;
+  if (x >= bBuffer[0].Nx) return;
+  if (y >= bBuffer[0].Ny) return;
+  bBuffer[0].pixels[y][x] = bColor;
+  if (x >= buffer[0].Nx) return;
+  if (y >= buffer[0].Ny) return;
+  if (buffer[0].Nbyte == 1) {
+    buffer[0].pixels[y][x] = buffer->bColor;
+  } else {
+    buffer[0].pixels[y][3*x+0] = buffer->bColor_R;
+    buffer[0].pixels[y][3*x+1] = buffer->bColor_G;
+    buffer[0].pixels[y][3*x+2] = buffer->bColor_B;
+  }
   return;
+}
 // draw a point in the current color
 void bDrawPointf (float x, float y) {
   bDrawPoint (ROUND(x), ROUND(y));
   return;
+}
 void bDrawTriOpen (double x1, double y1, double x2, double y2, double x3, double y3) {
   bDrawLine (x1, y1, x2, y2);
   bDrawLine (x2, y2, x3, y3);
   bDrawLine (x3, y3, x1, y1);
   return;
+}
 void bDrawRectOpen (double x1, double y1, double x2, double y2) {
+void bDrawPointf (bDrawBuffer *buffer, float x, float y) {
+  bDrawPoint (buffer, ROUND(x), ROUND(y));
+  return;
+}
+void bDrawTriOpen (bDrawBuffer *buffer, double x1, double y1, double x2, double y2, double x3, double y3) {
+  bDrawLine (buffer, x1, y1, x2, y2);
+  bDrawLine (buffer, x2, y2, x3, y3);
+  bDrawLine (buffer, x3, y3, x1, y1);
+  return;
+}
+void bDrawRectOpen (bDrawBuffer *buffer, double x1, double y1, double x2, double y2) {
   int X1, Y1, X2, Y2;
 …
   if (y1 > y2) SWAP (y1, y2);
   X1 = MIN (MAX (ROUND (x1), 0), bBuffer[0].Nx - 1);
   X2 = MIN (MAX (ROUND (x2), 1), bBuffer[0].Nx);
   Y1 = MIN (MAX (ROUND (y1), 0), bBuffer[0].Ny - 1);
   Y2 = MIN (MAX (ROUND (y2), 1), bBuffer[0].Ny);
   bDrawLineHorizontal (X1, X2, Y1);
   bDrawLineHorizontal (X1, X2, Y2);
   bDrawLineVertical (X1, Y1, Y2);
   bDrawLineVertical (X2, Y1, Y2);
   return;
+}
 void bDrawRectFill (double x1, double y1, double x2, double y2) {
+  X1 = MIN (MAX (ROUND (x1), 0), buffer[0].Nx - 1);
+  X2 = MIN (MAX (ROUND (x2), 1), buffer[0].Nx - 1);
+  Y1 = MIN (MAX (ROUND (y1), 0), buffer[0].Ny - 1);
+  Y2 = MIN (MAX (ROUND (y2), 1), buffer[0].Ny - 1);
+  bDrawLineHorizontal (buffer, X1, X2, Y1);
+  bDrawLineHorizontal (buffer, X1, X2, Y2);
+  bDrawLineVertical   (buffer, X1, Y1, Y2);
+  bDrawLineVertical   (buffer, X2, Y1, Y2);
+  return;
+}
+void bDrawRectFill (bDrawBuffer *buffer, double x1, double y1, double x2, double y2) {
   int i;
 …
   if (y1 > y2) SWAP (y1, y2);
   X1 = MIN (MAX (ROUND (x1), 0), bBuffer[0].Nx - 1);
   X2 = MIN (MAX (ROUND (x2), 1), bBuffer[0].Nx);
   Y1 = MIN (MAX (ROUND (y1), 0), bBuffer[0].Ny - 1);
   Y2 = MIN (MAX (ROUND (y2), 0), bBuffer[0].Ny);
+  X1 = MIN (MAX (ROUND (x1), 0), buffer[0].Nx - 1);
+  X2 = MIN (MAX (ROUND (x2), 1), buffer[0].Nx - 1);
+  Y1 = MIN (MAX (ROUND (y1), 0), buffer[0].Ny - 1);
+  Y2 = MIN (MAX (ROUND (y2), 0), buffer[0].Ny - 1);
   for (i = Y1; i < Y2; i++) {
     bDrawLineHorizontal (X1, X2, i);
+    bDrawLineHorizontal (buffer, X1, X2, i);
+  }
   return;
 …
 // identify the quadrant and draw the correct line
 void bDrawLine (double x1, double y1, double x2, double y2) {
+void bDrawLine (bDrawBuffer *buffer, double x1, double y1, double x2, double y2) {
   int FlipDirect, FlipCoords;
 …
   FlipDirect = FlipCoords ? (y1 > y2) : (x1 > x2);
   if (!FlipDirect && !FlipCoords) bDrawLineWeight (X1, Y1, X2, Y2, FALSE);
   if ( FlipDirect && !FlipCoords) bDrawLineWeight (X2, Y2, X1, Y1, FALSE);
   if (!FlipDirect &&  FlipCoords) bDrawLineWeight (Y1, X1, Y2, X2, TRUE);
   if ( FlipDirect &&  FlipCoords) bDrawLineWeight (Y2, X2, Y1, X1, TRUE);
+  if (!FlipDirect && !FlipCoords) bDrawLineWeight (buffer, X1, Y1, X2, Y2, FALSE);
+  if ( FlipDirect && !FlipCoords) bDrawLineWeight (buffer, X2, Y2, X1, Y1, FALSE);
+  if (!FlipDirect &&  FlipCoords) bDrawLineWeight (buffer, Y1, X1, Y2, X2, TRUE);
+  if ( FlipDirect &&  FlipCoords) bDrawLineWeight (buffer, Y2, X2, Y1, X1, TRUE);
   return;
 …
 // draw a series of lines to give the line weight
 void bDrawLineWeight (int X1, int Y1, int X2, int Y2, int swapcoords) {
+void bDrawLineWeight (bDrawBuffer *buffer, int X1, int Y1, int X2, int Y2, int swapcoords) {
   int dN, dNs, dNe;
   dNs = -0.5*(bWeight - 1);
+  dNs = -0.5*(buffer->bWeight - 1);
   /* 0, 0, 0, -1, -1, -2, -2 */
   dNe = +0.5*bWeight + 1;
+  dNe = +0.5*buffer->bWeight + 1;
   /* 1, 1, 2, 2, 2, 3, 3 */
   for (dN = dNs; dN < dNe; dN++) {
     bDrawLineBresen (X1, Y1 + dN, X2, Y2 + dN, swapcoords);
+    bDrawLineBresen (buffer, X1, Y1 + dN, X2, Y2 + dN, swapcoords);
+  }
   return;
 …
 // use the Bresenham line drawing technique
 // integer-only Bresenham line-draw version which is fast
 void bDrawLineBresen (int X1, int Y1, int X2, int Y2, int swapcoords) {
+void bDrawLineBresen (bDrawBuffer *buffer, int X1, int Y1, int X2, int Y2, int swapcoords) {
   int X, Y, dX, dY;
 …
   e = 0;
   for (X = X1, N = 0; X <= X2; X++, N++) {
     if (bType == 1) { DashOn = (N % 10) < 5; }
     if (bType == 2) { DashOn = (N % 6) < 3; }
+    if (buffer->bType == 1) { DashOn = (N % 10) < 5; }
+    if (buffer->bType == 2) { DashOn = (N % 6) < 3; }
     if (swapcoords) {
       if (DashOn) bDrawPoint (Y,X);
+      if (DashOn) bDrawPoint (buffer, Y,X);
     } else {
       if (DashOn) bDrawPoint (X,Y);
+      if (DashOn) bDrawPoint (buffer, X,Y);
+    }
     e += dY;
 …
+}
 void bDrawLineHorizontal (int X1, int X2, int Y) {
+void bDrawLineHorizontal (bDrawBuffer *buffer, int X1, int X2, int Y) {
   int i;
   for (i = X1; i < X2; i++) {
+    bBuffer[0].pixels[Y][i] = bColor;
+  }
+  return;
+}
+void bDrawLineVertical (int X, int Y1, int Y2) {
+    if (buffer[0].Nbyte == 1) {
+      buffer[0].pixels[Y][i] = buffer->bColor;
+    } else {
+      buffer[0].pixels[Y][3*i+0] = buffer->bColor_R;
+      buffer[0].pixels[Y][3*i+1] = buffer->bColor_G;
+      buffer[0].pixels[Y][3*i+2] = buffer->bColor_B;
+    }
+  }
+  return;
+}
+void bDrawLineVertical (bDrawBuffer *buffer, int X, int Y1, int Y2) {
   int i;
   for (i = Y1; i < Y2; i++) {
+    bBuffer[0].pixels[i][X] = bColor;
+  }
+  return;
+}
+void bDrawTriFill (double x1, double y1, double x2, double y2, double x3, double y3) {
+  bDrawTriOpen (x1, y1, x2, y2, x3, y3);
+  return;
+}
+void bDrawArc (double Xc, double Yc, double Xr, double Yr, double Ts, double Te) {
+    if (buffer[0].Nbyte == 1) {
+      buffer[0].pixels[i][X] = buffer->bColor;
+    } else {
+      buffer[0].pixels[i][3*X+0] = buffer->bColor_R;
+      buffer[0].pixels[i][3*X+1] = buffer->bColor_G;
+      buffer[0].pixels[i][3*X+2] = buffer->bColor_B;
+    }
+  }
+  return;
+}
+void bDrawTriFill (bDrawBuffer *buffer, double x1, double y1, double x2, double y2, double x3, double y3) {
+  bDrawTriOpen (buffer, x1, y1, x2, y2, x3, y3);
+  return;
+}
+void bDrawArc (bDrawBuffer *buffer, double Xc, double Yc, double Xr, double Yr, double Ts, double Te) {
   float t, dt;
 …
     /* we could use the value of MAX(dy/dt,dx/dt) to set dt */
     bDrawPoint (x,y);
+    bDrawPoint (buffer, x,y);
     dt = MAX (fabs(Xr * sin(t)), fabs(Yr * cos(t)));
 …
 // draw a series of circles to give line weight
 void bDrawCircle (double xc, double yc, double radius) {
+void bDrawCircle (bDrawBuffer *buffer, double xc, double yc, double radius) {
   int dN, dNs, dNe;
   dNs = -0.5*(bWeight - 1);
+  dNs = -0.5*(buffer->bWeight - 1);
   /* 0, 0, 0, -1, -1, -2, -2 */
   dNe = +0.5*bWeight + 1;
+  dNe = +0.5*buffer->bWeight + 1;
   /* 1, 1, 2, 2, 2, 3, 3 */
   for (dN = dNs; dN < dNe; dN++) {
     bDrawCircleSingle (xc, yc, radius + dN);
+    bDrawCircleSingle (buffer, xc, yc, radius + dN);
+  }
   return;
 …
 // draw a pure circle
 void bDrawCircleSingle (double xc, double yc, double radius) {
+void bDrawCircleSingle (bDrawBuffer *buffer, double xc, double yc, double radius) {
   int Xc, Yc, Radius;
 …
   while (x <= y) {
     bDrawPoint (Xc+x, Yc+y);
     bDrawPoint (Xc+x, Yc-y);
     bDrawPoint (Xc-x, Yc+y);
     bDrawPoint (Xc-x, Yc-y);
     bDrawPoint (Xc+y, Yc+x);
     bDrawPoint (Xc+y, Yc-x);
     bDrawPoint (Xc-y, Yc+x);
     bDrawPoint (Xc-y, Yc-x);
+    bDrawPoint (buffer, Xc+x, Yc+y);
+    bDrawPoint (buffer, Xc+x, Yc-y);
+    bDrawPoint (buffer, Xc-x, Yc+y);
+    bDrawPoint (buffer, Xc-x, Yc-y);
+    bDrawPoint (buffer, Xc+y, Yc+x);
+    bDrawPoint (buffer, Xc+y, Yc-x);
+    bDrawPoint (buffer, Xc-y, Yc+x);
+    bDrawPoint (buffer, Xc-y, Yc-x);
     if (d < 0) {
 …
 // draw a pure circle
 void bDrawCircleFill (double xc, double yc, double radius) {
+void bDrawCircleFill (bDrawBuffer *buffer, double xc, double yc, double radius) {
   int Xc, Yc, Radius;
 …
   while (x <= y) {
     bDrawLineHorizontal (Xc-x, Xc+x, Yc+y);
     bDrawLineHorizontal (Xc-x, Xc+x, Yc-y);
     bDrawLineHorizontal (Xc-y, Xc+y, Yc+x);
     bDrawLineHorizontal (Xc-y, Xc+y, Yc-x);
+    bDrawLineHorizontal (buffer, Xc-x, Xc+x, Yc+y);
+    bDrawLineHorizontal (buffer, Xc-x, Xc+x, Yc-y);
+    bDrawLineHorizontal (buffer, Xc-y, Xc+y, Yc+x);
+    bDrawLineHorizontal (buffer, Xc-y, Xc+y, Yc-x);
     if (d < 0) {

trunk/Ohana/src/libkapa/src/bDrawRotFont.c

-              r12332
+              r29938
 # define NEARINT(x) ((x < 0) ? ((int)(x - 0.5)) : ((int)(x + 0.5)))
+static bDrawColor black;
+static bDrawColor white;
+int bDrawRotText (int x, int y, char *string, int pos, double angle) {
+// XXX need to pass the rot text color here
+// static bDrawColor black;
+// static bDrawColor white;
+int bDrawRotText (bDrawBuffer *buffer, int x, int y, char *string, int pos, double angle) {
   unsigned char *bitmap;
 …
   RotFont *currentfont;
   white = KapaColorByName ("white");
   black = KapaColorByName ("black");
+  // white = KapaColorByName ("white");
+  // black = KapaColorByName ("black");
   currentname = GetRotFont (&currentsize);
 …
     X = x + (int)(Xoff*cs - Yoff*sn) + (int)(currentscale*currentfont[N].ascent*sn);
     Y = y + (int)(Xoff*sn + Yoff*cs) - (int)(currentscale*currentfont[N].ascent*cs);
     bDrawRotBitmap (X, Y, dx, dy, bitmap, TRUE, angle, currentscale);
+    bDrawRotBitmap (buffer, X, Y, dx, dy, bitmap, TRUE, angle, currentscale);
     Xoff += 1 + (int)(currentscale*dx + 0.5);
+  }
 …
+}
 int bDrawRotBitmap (int x, int y, int dx, int dy, unsigned char *bitmap, int mode, double angle, double scale) {
+int bDrawRotBitmap (bDrawBuffer *buffer, int x, int y, int dx, int dy, unsigned char *bitmap, int mode, double angle, double scale) {
   int ii, jj, byte_line, byte, bit, flag;
-  bDrawColor color;
   double i, j, cs, sn, rscale, tmp;
   int X, Y, X0, X1, X2, Y0, Y1, Y2, x0, y0;
   /* this mode option is nort actually used... */
   if (mode) {
     color = black;
   } else {
     color = white;
+  }
+  // if (mode) {
+  //   color = black;
+  // } else {
+  //   color = white;
+  // }
   byte_line = (int) ((dx + 7) / 8);
 …
   Y = YPROC (dx,0);
 # ifdef DRAWBOXES
   bDrawLine (x+X, y+Y, x+X1, y+Y1);
+  bDrawLine (buffer, x+X, y+Y, x+X1, y+Y1);
   Xt = X;
   Yt = Y;
 …
   Y = YPROC (dx,dy);
 # ifdef DRAWBOXES
   bDrawLine (x+X, y+Y, x+Xt, y+Yt);
+  bDrawLine (buffer, x+X, y+Y, x+Xt, y+Yt);
   Xt = X;
   Yt = Y;
 …
   Y = YPROC (0,dy);
 # ifdef DRAWBOXES
   bDrawLine (x+X, y+Y, x+Xt, y+Yt);
+  bDrawLine (buffer, x+X, y+Y, x+Xt, y+Yt);
   Xt = X;
   Yt = Y;
 …
   X2 = MAX (X, X2);
   bDrawSetStyle (color, 0, 0);
+  // bDrawSetStyle (color, 0, 0);
   if (scale > 1) {
     for (i = X1; i <= X2; i+=1) {
 …
         bit = ii % 8;
         flag = 0x01 & (bitmap[byte] >> bit);
         if (flag) bDrawPointf (x + i, y + j);
+        if (flag) bDrawPointf (buffer, x + i, y + j);
+      }
+    }
 …
         bit = ii % 8;
         flag = 0x01 & (bitmap[byte] >> bit);
         if (flag) bDrawPointf (x + i, y + j);
+        if (flag) bDrawPointf (buffer, x + i, y + j);
+      }
+    }
+  }
   bDrawSetStyle (black, 0, 0);
+  // bDrawSetStyle (black, 0, 0);
   return (TRUE);
+}

trunk/Ohana/src/opihi/cmd.astro/region.c

r27435	r29938
55	55	if ((argc != 4) && (argc != 5)) {
56	56	gprint (GP_ERR, "USAGE: region Ra Dec Radius [projection] [orientation]\n");
	57	gprint (GP_ERR, " [-image] [-ew] [+ew] [-ns] [+ns] [-no-clear]\n");
57	58	gprint (GP_ERR, " current: %f %f (%f x %f) (%s)\n",
58	59	graphmode.coords.crval1, graphmode.coords.crval2,

trunk/Ohana/src/opihi/cmd.data/Makefile

r29540	r29938
36	36	$(SRC)/cut.$(ARCH).o \
37	37	$(SRC)/delete.$(ARCH).o \
	38	$(SRC)/densify.$(ARCH).o \
38	39	$(SRC)/device.$(ARCH).o \
39	40	$(SRC)/dimendown.$(ARCH).o \

trunk/Ohana/src/opihi/cmd.data/init.c

-              r29540
+              r29938
 int dbselect         PROTO((int, char **));
 int delete           PROTO((int, char **));
+int densify          PROTO((int, char **));
 int device           PROTO((int, char **));
 int dimendown        PROTO((int, char **));
 …
   {1, "dbselect",     dbselect,         "extract vectors from mysql database table"},
   {1, "delete",       delete,           "delete vectors or images"},
+  {1, "densify",      densify,          "create an image histogram from a set of vectors"},
   {1, "device",       device,           "set / get current graphics device"},
   {1, "dimendown",    dimendown,        "convert image to vector"},

trunk/Ohana/src/opihi/cmd.data/rd.c

r28241	r29938
184	184	ftable.header[0].buffer = NULL;
185	185	gfits_copy_header (&buf[0].header, ftable.header);
186		status = gfits_fread_ftable_data (f, &ftable); // this just reads the bytes (not even a SWAP)
	186	status = gfits_fread_ftable_data (f, &ftable, FALSE); // this just reads the bytes (not even a SWAP)
187	187	status = gfits_uncompress_image (&buf[0].header, &buf[0].matrix, &ftable);
188	188	// uncompressing the image leaves the format as an extension

trunk/Ohana/src/opihi/cmd.data/read_vectors.c

-              r29540
+              r29938
   off_t Nbytes;
   int i, j, k, N, Nextend, Ny, Binary, vecType;
+  int i, j, k, N, Nextend, Ny, Binary, vecType, padIfShort;
   char type[16], ID[80], *CCDKeyword;
   FTable table;
 …
     CCDKeyword = strcreate (argv[N]);
     remove_argument (N, &argc, argv);
+  }
+  padIfShort = FALSE;
+  if ((N = get_argument (argc, argv, "-pad-if-short"))) {
+    remove_argument (N, &argc, argv);
+    padIfShort = TRUE;
+  }
 …
+    }
     if (!gfits_load_header (f, &header)) ESCAPE ("error reading header for extension");
     if (!gfits_fread_ftable_data (f, &table)) ESCAPE ("error reading table for extension");
+    if (!gfits_fread_ftable_data (f, &table, padIfShort)) ESCAPE ("error reading table for extension");
   } else {
 …
         continue;
+      }
       if (!gfits_fread_ftable_data (f, &table)) ESCAPE ("error reading table for extension");
+      if (!gfits_fread_ftable_data (f, &table, padIfShort)) ESCAPE ("error reading table for extension");
       break;
+    }

trunk/Ohana/src/opihi/cmd.data/resize.c

-              r13479
+              r29938
   if (!GetImage (NULL, &kapa, name)) return (FALSE);
   FREE (name);
+  if ((N = get_argument (argc, argv, "-by-image"))) {
+    remove_argument (N, &argc, argv);
+    KiiResizeByImage (kapa);
+    return (TRUE);
+  }
   if (argc != 3) {

trunk/Ohana/src/opihi/cmd.data/section.c

-              r27790
+              r29938
 # include "data.h"
 enum {NONE, LIST, UP, DOWN, TOP, BOTTOM, TOOL, BG};
+enum {NONE, LIST, UP, DOWN, TOP, BOTTOM, TOOL, BG, IMAGE};
 int section (int argc, char **argv) {
 …
     remove_argument (N, &argc, argv);
     action = BG;
+  }
+  if ((N = get_argument (argc, argv, "-image"))) {
+    remove_argument (N, &argc, argv);
+    action = IMAGE;
+  }
 …
+  }
+  if (argc == 4) {
+    /* set section */
+    section.name = argv[1];
+    section.x = atof (argv[2]);
+    section.y = atof (argv[3]);
+    section.bg = background;
+    KapaSetSectionByImage (kapa, &section);
+    return (TRUE);
+  }
   if (argc == 6) {
     /* set section */
 …
+  }
   gprint (GP_ERR, "USAGE: section name [x y dx dy]\n");
+  gprint (GP_ERR, "USAGE: section name [-image x y] : width based on current image\n");
   gprint (GP_ERR, "USAGE: section name [-list] [-up] [-down] [-top] [-bottom]\n");
   return (FALSE);

trunk/Ohana/src/opihi/cmd.data/vgauss.c

r29001	r29938
45	45	CastVector (yvec, OPIHI_FLT);
46	46	CastVector (svec, OPIHI_FLT);
	47	// XXX Cast is failing.
	48
47	49
48	50	Npts = xvec[0].Nelements;

trunk/Ohana/src/opihi/dvo/images.c

-              r28958
+              r29938
 int images (int argc, char **argv) {
   off_t i, Nimage;
+  off_t i, Nimage, Nmosaic;
   int j, status, InPic, leftside, *plist, TimeSelect, ByName;
   int WITH_MOSAIC, SOLO_MOSAIC, HIDDEN;
   time_t tzero, tend;
   int N, NPTS, n, npts, Npts, kapa;
+  int N, NPTS, n, npts, Npts, kapa, *foundMosaic;
   Vector Xvec, Yvec;
   double r[8], d[8], x[8], y[8], Rmin, Rmax, Rmid, trange, Radius;
 …
   SOLO_MOSAIC = FALSE;
+  foundMosaic = NULL;
   if ((N = get_argument (argc, argv, "-mosaic"))) {
     remove_argument (N, &argc, argv);
 …
   BuildChipMatch (image, Nimage);
+  if (SOLO_MOSAIC && photcode) {
+    ALLOCATE(foundMosaic, int, Nimage);
+    memset(foundMosaic, 0, Nimage*sizeof(int));
+  }
   Rmin = graphmode.coords.crval1 - 180.0;
   Rmax = graphmode.coords.crval1 + 180.0;
 …
   int DistortImage = wordhash ("-DIS");
+  int ChipImage    = wordhash ("-WRP");
   int TriangleUp   = wordhash ("TRP-");
   int TriangleDn   = wordhash ("TRM-");
 …
     if (ByName && strncmp (image[i].name, name, strlen(name))) continue;
     if (TimeSelect && ((image[i].tzero < tzero) || (image[i].tzero+image[i].trate*image[i].NY > tzero + trange))) continue;
+    if (!FindMosaicForImage (image, Nimage, i)) continue;
+    if (!(Nmosaic = FindMosaicForImage (image, Nimage, i))) continue;
+    Nmosaic --; // XXX kind of a hack: FindMosaicForImage returns 0 or the mosaic seq number + 1
     if (photcode) {
       if ( photcodeEquiv && (photcode[0].code != GetPhotcodeEquivCodebyCode(image[i].photcode))) continue;
 …
     typehash = wordhash (&image[i].coords.ctype[4]);
+    if (photcode && SOLO_MOSAIC) {
+      // mosaic (DIS) images are not currently given a photcode : plot these via the WRP entries
+      /* DIS images represent a field, not a chip */
+      if (typehash != ChipImage) continue;
+      if (foundMosaic[Nmosaic]) continue;
+      x[0] = -0.5*image[Nmosaic].NX; y[0] = -0.5*image[Nmosaic].NY;
+      x[1] = +0.5*image[Nmosaic].NX; y[1] = -0.5*image[Nmosaic].NY;
+      x[2] = +0.5*image[Nmosaic].NX; y[2] = +0.5*image[Nmosaic].NY;
+      x[3] = -0.5*image[Nmosaic].NX; y[3] = +0.5*image[Nmosaic].NY;
+      for (j = 0; j < Npts; j++) {
+        status = XY_to_RD (&r[j], &d[j], x[j], y[j], &image[Nmosaic].coords);
+        if (!status) break;
+        r[j] = ohana_normalize_angle (r[j]);
+        while (r[j] < Rmin) { r[j] += 360.0; }
+        while (r[j] > Rmax) { r[j] -= 360.0; }
+        if (j == 0) {
+          leftside = (r[j] < Rmid);
+        }
+        if (j > 0) {
+          if ( leftside && (r[j] > Rmid + 90)) { r[j] -= 360.0; }
+          if (!leftside && (r[j] < Rmid - 90)) { r[j] += 360.0; }
+        }
+      }
+      foundMosaic[Nmosaic] = TRUE;
+      goto plot_points;
+    }
     /* DIS images represent a field, not a chip */
 …
     if (Npts == 0) continue;
+  plot_points:
     status = FALSE;
     for (j = 0; j < Npts; j++) {
 …
   free (Yvec.elements.Flt);
   FreeImages (image);
+  FREE (foundMosaic);
   return (TRUE);

trunk/Ohana/src/opihi/dvo/imlist.c

r29540	r29938
104	104	XY_to_RD (&r, &d, 0.5image[i].NX, 0.5image[i].NY, &image[i].coords);
105	105	}
106		gprint (GP_LOG, "%3lld %s %8.4f %8.4f %f %5d %2d %4.2f %5.3f %5.3f\n",
107		(long long) i, image[i].name, r, d, t, image[i].nstar, image[i].photcode, image[i].secz, image[i].Mcal, image[i].dMcal);
	106	gprint (GP_LOG, "%3lld %s %8lld %8.4f %8.4f %f %5d %2d %4.2f %5.3f %5.3f\n",
	107	(long long) i, image[i].name, (long long) image[i].imageID, r, d, t, image[i].nstar, image[i].photcode, image[i].secz, image[i].Mcal, image[i].dMcal);
108	108	}
109	109

trunk/Ohana/src/opihi/lib.data/starfuncs.c

-              r20936
+              r29938
   double *ring;
   double x, y, x2, y2, xy, I, sky, FWHMx, FWHMy, value, mag, Sxy;
   int i, j, n, Npix2, Nring, Nmax;
+  int i, j, n, Radius, Nring, Nmax;
   double Npts, gain, dsky2, dmag, peak, offset;
   char *string;
 …
   Nborder = MIN (1000, Nborder);
   Npix2 = (int)(0.5*Npix);
   Npix = 2 * Npix2 + 1;
+  Radius = (int)(0.5*Npix);
+  Npix = 2 * Radius + 1;
   Nring = 4*Nborder*(Nborder + Npix);
   ALLOCATE (ring, double, Nring);
 …
   n = 0;
   for (j = 0; j < Nborder; j++) {
     for (i = X - Npix2 - Nborder; i < X + Npix2 + Nborder + 1; i++, n+=2) {
       ring[n]   = gfits_get_matrix_value (matrix, i, (int)(Y - Npix2 - j));
       ring[n+1] = gfits_get_matrix_value (matrix, i, (int)(Y + Npix2 + j));
+    }
     for (i = Y - Npix2; i < Y + Npix2 + 1; i++, n+=2) {
       ring[n]   = gfits_get_matrix_value (matrix, (int)(X - Npix2 - j), i);
       ring[n+1] = gfits_get_matrix_value (matrix, (int)(X + Npix2 + j), i);
+    for (i = X - Radius - Nborder; i < X + Radius + Nborder + 1; i++, n+=2) {
+      ring[n]   = gfits_get_matrix_value (matrix, i, (int)(Y - Radius - j));
+      ring[n+1] = gfits_get_matrix_value (matrix, i, (int)(Y + Radius + j));
+    }
+    for (i = Y - Radius; i < Y + Radius + 1; i++, n+=2) {
+      ring[n]   = gfits_get_matrix_value (matrix, (int)(X - Radius - j), i);
+      ring[n+1] = gfits_get_matrix_value (matrix, (int)(X + Radius + j), i);
+    }
+  }
 …
   Npts = Nmax = 0;
   x = y = x2 = y2 = xy = I = 0;
+  for (i = X - Npix2; i < X + Npix2 + 1; i++) {
+    for (j = Y - Npix2; j < Y + Npix2 + 1; j++) {
+  for (i = X - Radius; i < X + Radius + 1; i++) {
+    for (j = Y - Radius; j < Y + Radius + 1; j++) {
+      if (hypot((i-X), (j-Y)) > Radius) continue;
       value = gfits_get_matrix_value (matrix, i, j);
       offset = value - sky;
 …
   set_variable ("Zpk", peak);
   set_int_variable ("Nsat", Nmax);
+  set_int_variable ("Npts", Npts);
   gprint (GP_LOG, "%f %f %f %f %f %f %f %f\n", x, y, FWHMx, FWHMy, sky, I, mag, dmag);

trunk/Ohana/src/photdbc/include/photdbc.h

r28331	r29938
114	114	int SetSignals (void);
115	115	int copy_images (char *outdir);
	116	void usage();

trunk/Ohana/src/photdbc/src/args.c

-              r8630
+              r29938
+  }
+  if (argc != 2) {
+    fprintf (stderr, "USAGE: photdbc (output)\n");
+    exit (2);
+  }
+  if (argc != 2) usage();
   if ((REGION.Rmin == 0) && (REGION.Rmax == 360) && (REGION.Dmin == -90) && (REGION.Dmax == +90)) {
 …
+}
+/**
+void usage() {
+ this program takes an existing DVO database and makes a copy, applying a number of optional
+ filters in the process.
+ photdbc (output)
+ allowed filters / restrictions include:
+ -region ra dec ra dec : limit operation to the specified region
+ -join                 : join measurements between stars using JOIN_RADIUS
+ -ccdregion X Y X Y    : only keep detections within the specified detector region
+                         (can this be limited to specific photcodes? cameras? detectors?)
+ -photcode_limits code Mmin Mmax : allow multiples of these
+ SIGMA_MAX
+ NMEAS_MIN
+ INST_MAG_MAX
+ INST_MAG_MIN
+**/
+  fprintf (stderr, "USAGE: photdbc (output)\n\n");
+  fprintf (stderr, " this program takes an existing DVO database and makes a copy, applying a number of optional\n");
+  fprintf (stderr, " filters in the process.  \n");
+  fprintf (stderr, "\n");
+  fprintf (stderr, " photdbc (output)\n");
+  fprintf (stderr, "\n");
+  fprintf (stderr, " allowed filters / restrictions include:\n");
+  fprintf (stderr, "\n");
+  fprintf (stderr, " -region Rmin Rmax Dmin Dmax : limit operation to the specified region \n");
+  fprintf (stderr, " -join                 : join measurements between stars using JOIN_RADIUS\n");
+  fprintf (stderr, " -ccdregion X Y X Y    : only keep detections within the specified detector region\n");
+  fprintf (stderr, "                         (can this be limited to specific photcodes? cameras? detectors?)\n");
+  fprintf (stderr, " -photcode_limits code Mmin Mmax : allow multiples of these\n");
+  fprintf (stderr, "\n");
+  fprintf (stderr, " SIGMA_MAX\n");
+  fprintf (stderr, " NMEAS_MIN\n");
+  fprintf (stderr, " INST_MAG_MAX\n");
+  fprintf (stderr, " INST_MAG_MIN\n");
+  exit (2);
+}

trunk/Ohana/src/photdbc/src/initialize.c

-              r4808
+              r29938
   /* are these set correctly? */
+  if (get_argument (argc, argv, "-h")) usage();
+  if (get_argument (argc, argv, "--h")) usage();
+  if (get_argument (argc, argv, "-help")) usage();
+  if (get_argument (argc, argv, "--help")) usage();
   ConfigInit (&argc, argv);
   args (argc, argv);

trunk/Ohana/src/photdbc/src/join_stars.c

r28306	r29938
32	32
33	33	/* reference for coords is this region */
	34	Ncurr = 0;
34	35	Naves = 0;
35	36	Rmid = Dmid = 0;

trunk/Ohana/src/relastro/src/GetAstromError.c

-              r27581
+              r29938
 float GetAstromError (Measure *measure, int mode) {
+  //BIG HACKXXXXXXXX
+  return 0.1;
   PhotCode *code;
   float dPobs, dPsys, dPtotal, dM, AS, MS;
   switch (mode) {
     case ERROR_MODE_RA:
 …
       abort();
+  }
   /* the astrometric errors are not being carried yet (but should be!) */
   /* we use the photometric mag error as a weighting term */
 …
   dPsys = code[0].astromErrSys;
   dM    = measure[0].dM;
   dPtotal = sqrt(SQ(dPsys) + AS*SQ(dPobs) + MS*SQ(dM));
 …
   dPtotal = MAX (dPtotal, MIN_ERROR);
   return (dPtotal);
+}

trunk/Ohana/src/relastro/src/UpdateObjects.c

-              r28241
+              r29938
   memset (&fitPM,  0, sizeof(fitPM));
   memset (&fitPAR, 0, sizeof(fitPAR));
   initObjectData (catalog, Ncatalog);
 …
   // use J2000 as a reference time
   T2000 = ohana_date_to_sec ("2000/01/01");
   // XXX in the future, use catalog[0].Nsecfilt only?  allow catalogs to have variable Nsecfilt?
   Nsecfilt = GetPhotcodeNsecfilt ();
 …
       N = 0;
       m = catalog[i].average[j].measureOffset;
       Tmin = Tmax = (catalog[i].measure[m].t - T2000) / (86400*365.25);
       mode = FIT_MODE;
 …
         // dX, dY : error in arcsec --
+        dX[N] = GetAstromError (&catalog[i].measure[m], ERROR_MODE_RA);
+        dY[N] = GetAstromError (&catalog[i].measure[m], ERROR_MODE_DEC);
+        // dX[N] = GetAstromError (&catalog[i].measure[m], ERROR_MODE_RA);
+        // dY[N] = GetAstromError (&catalog[i].measure[m], ERROR_MODE_DEC);
+        dX[N] = 0.1;
+        dY[N] = 0.1;
         dT[N] = catalog[i].measure[m].dt;
 …
         // non-circular errors (different values for X and Y), then dR and dD will be
         // incorrect: they would need to be rotated to take out the position angle
         dR[k] = dX[k] / 3600.0;
         dD[k] = dY[k] / 3600.0;
+        dR[N] = dX[N] / 3600.0;
+        dD[N] = dY[N] / 3600.0;
         N++;
 …
         FitPM (&fitPM, X, dX, Y, dY, T, N);
         if (XVERB) fprintf (stderr, "fitted:  %f - %f : %f %f : %f %f : %f vs %f\n", Tmin, Tmax, fitPM.Ro, fitPM.Do, fitPM.uR, fitPM.uD, fitPM.chisq, fitAve.chisq);
 …
       switch (result) {
+        case FIT_AVERAGE:
+          catalog[i].average[j].flags |= ID_STAR_USE_AVE;
+          fit = fitAve;
+          break;
+        case FIT_PM_ONLY:
+          catalog[i].average[j].flags |= ID_STAR_USE_PM;
+          fit = fitPM;
+          break;
+        case FIT_PM_AND_PAR:
+          catalog[i].average[j].flags |= ID_STAR_USE_PAR;
+          fit = fitPAR;
+          break;
+      }
+      if (XVERB) fprintf (stderr, "%f %f -> %f %f (%f,%f)\n",
+      case FIT_AVERAGE:
+        catalog[i].average[j].flags |= ID_STAR_USE_AVE;
+        fit = fitAve;
+        break;
+      case FIT_PM_ONLY:
+        catalog[i].average[j].flags |= ID_STAR_USE_PM;
+        fit = fitPM;
+        break;
+      case FIT_PM_AND_PAR:
+        catalog[i].average[j].flags |= ID_STAR_USE_PAR;
+        fit = fitPAR;
+        break;
+      }
+      if (XVERB) fprintf (stderr, "A%f %f -> %f %f (%f,%f) pm=(%f %f)\n",
                           catalog[i].average[j].R,
                           catalog[i].average[j].D,
                           fit.Ro, fit.Do,
 *(catalog[i].average[j].R - fit.Ro),
+*(catalog[i].average[j].D - fit.Do));
+*(catalog[i].average[j].D - fit.Do),
+                          fit.uR,
+                          fit.uD);
       //make sure that the fit succeeded
+      status  = finite(fit.Ro);
+      status = TRUE;
+      status &= finite(fit.Ro);
       status &= finite(fit.Do);
       status &= finite(fit.dRo);
 …
       catalog[i].average[j].Trange = (Trange * 86400 * 365.26);
       catalog[i].average[j].Npos = fit.Nfit;
+      if (XVERB) fprintf (stderr, "%f %f -> %f %f (%f,%f) pm=(%f %f)\n",
+                          catalog[i].average[j].R,
+                          catalog[i].average[j].D,
+                          fit.Ro, fit.Do,
+*(catalog[i].average[j].R - fit.Ro),
+*(catalog[i].average[j].D - fit.Do),
+                          catalog[i].average[j].uR,
+                          catalog[i].average[j].uD);
+    }

trunk/Ohana/src/relastro/src/high_speed_objects.c

-              r28811
+              r29938
   // XXX seems silly to require region here just to find the catalog bounds / center
   off_t i, j, m, J, ni, nj, *N1, Nslow, Ninvalid, NgroupA, NgroupB, NgroupAbad, NgroupBbad;
   int *slowMoving, *groupA, *groupB, status, foundA, foundB, Nmatch, valid;
+  off_t i, j, m, J, ni, nj, *N1, Nslow, Ninvalid, NgroupA, NgroupB, NgroupAbad, NgroupBbad,l,i1,Noff,Nmeasure,Naverage, NAVERAGE, NMEASURE;
+  int *slowMoving, *groupA, *groupB, status, foundA, foundB, Nmatch, valid,Nmatchmeas,Nepoch,nv[2],Nmatchmeasobj;
   double *X1, *Y1;
   double dX, dY, dR, RADIUS2, yJ;
+  double dX, dY, dR, RADIUS2;
   Coords tcoords;
+  Catalog catalog1;
   int zcode, zNsec, ycode, yNsec, jcode, jNsec, hcode, hNsec, kcode, kNsec, USNO_R, USNO_N, Nsecfilt;
+  char filename[1024];
+  char outdir[]="/data/ipp022.0/ndeacon/hispeedzy";
+  Noff = strlen(CATDIR);
+  sprintf (filename, "%s/%s", outdir, &catalog[0].filename[Noff]);
+  dvo_catalog_init(&catalog1, TRUE); /*initialise new catalogue*/
+  catalog1.filename = strcreate(filename);
+  SIGMA_LIM = 0.0;
   Nsecfilt = GetPhotcodeNsecfilt();
+  Naverage=catalog[0].Naverage;
+  Nmeasure=catalog[0].Nmeasure;
+  // ALLOCATE (catalog1.average, Average,Naverage);
+  // ALLOCATE (catalog1.measure, Measure,Nmeasure);
+  // ALLOCATE(catalog1.secfilt, SecFilt,catalog[0].Naverage*Nsecfilt);
+  catalog1.filename = filename; // based on the input name, need to keep everything below the catdir portion
+  catalog1.Nsecfilt  = Nsecfilt;
+  // always load all of the data (if any exists)
+  catalog1.catflags = LOAD_AVES | LOAD_MEAS | LOAD_MISS | LOAD_SECF;
+  catalog1.catformat = dvo_catalog_catformat (CATFORMAT);  // set the default catformat from config data
+  catalog1.catmode   = dvo_catalog_catmode (CATMODE);      // set the default catmode from config data
+  if (!dvo_catalog_open (&catalog1, region, VERBOSE,"w")) {
+    fprintf (stderr, "ERROR: failure to open catalog file %s\n",
+             filename);
+    exit (2);
+  }
+  NAVERAGE = 1000;
+  NMEASURE = 10000;
+  REALLOCATE (catalog1.average, Average, NAVERAGE);
+  REALLOCATE (catalog1.measure, Measure, NMEASURE);
+  REALLOCATE(catalog1.secfilt, SecFilt, NAVERAGE*Nsecfilt);
   ycode = GetPhotcodeCodebyName("y");
 …
   NgroupBbad = 0;
   fprintf (stdout, "#      RA_A  DEC_A              RA_B  DEC_B      :     pmx     pmy      dR  :    z      dz       y      dy       J      dJ       H      dH       K      dK\n");
+  fprintf (stdout, "#      RA_A  DEC_A              RA_B  DEC_B      :     pmx     pmy      dR  dt:    z      dz       y      dy       J      dJ       H      dH       K      dK\n");
   //................270.2346670  20.2471540  270.2170434  20.2717396 :  -59.11   88.78   106.66 :   0.000  0.000   19.582  0.112   16.041  0.110   15.388  0.098   14.858  0.001
 …
     foundA = FALSE;
     for (j = 0; !foundA && (j < catalog[0].average[i].Nmeasure); j++, m++) {
+      if((catalog[0].average[i].R>204.1923)&&(catalog[0].average[i].R<204.1924)&&(catalog[0].average[i].D>11.376)&&(catalog[0].average[i].D<11.377))
+        {
+          printf("Hello");
+        }
       if (MeasMatchesPhotcode(&catalog[0].measure[m], photcodesGroupA, NphotcodesGroupA)) {
         foundA = TRUE;
 …
     foundB = FALSE;
     for (j = 0; !foundB && (j < catalog[0].average[i].Nmeasure); j++, m++) {
+      if((catalog[0].average[i].R>204.192)&&(catalog[0].average[i].R<204.1925)&&(catalog[0].average[i].D>11.376)&&(catalog[0].average[i].D<11.377))
+        {
+          printf("Hello");
+        }
       if (MeasMatchesPhotcode(&catalog[0].measure[m], photcodesGroupB, NphotcodesGroupB)) {
         foundB = TRUE;
 …
     if (foundA && !foundB) {
       // average-based tests:
+      if((catalog[0].average[i].R>204.1923)&&(catalog[0].average[i].R<204.1924)&&(catalog[0].average[i].D>11.376)&&(catalog[0].average[i].D<11.377))
+        {
+          printf("Hello");
+        }
       valid = TRUE;
       valid &= ((catalog[0].average[i].flags & 0x40000) == 0);
       valid &= ((catalog[0].average[i].flags & 0x80000)  > 0);
       valid &= (catalog[0].secfilt[i*Nsecfilt + yNsec].M < 1.0);
       valid &= (catalog[0].secfilt[i*Nsecfilt + zNsec].M < 1.0);
+      valid &= ((catalog[0].average[i].flags & 0x02000000) == 0);
+      valid &= ((catalog[0].average[i].flags & 0x08000000)  > 0);
+      valid &= ((catalog[0].secfilt[i*Nsecfilt + yNsec].M < 1.0)||(isnan(catalog[0].secfilt[i*Nsecfilt + yNsec].M)));
+      valid &= (((catalog[0].secfilt[i*Nsecfilt + zNsec].M < 1.0))||(isnan(catalog[0].secfilt[i*Nsecfilt + zNsec].M)));
       // XXX color restrictions are applied in the pair-wise matching below
       // measure-based tests:
       m = catalog[0].average[i].measureOffset;
+      /*      m = catalog[0].average[i].measureOffset;
       for (j = 0; valid && (j < catalog[0].average[i].Nmeasure); j++, m++) {
         if (catalog[0].measure[m].photcode == USNO_R) {
 …
           valid &= ((catalog[0].measure[m].M > 18.0) || isnan(catalog[0].measure[m].M));
+        }
+      }
+        }*/
       // ((objflags & 524288) == 524288) &&
 …
       // average-based tests:
+      if((catalog[0].average[i].R>204.192)&&(catalog[0].average[i].R<204.193)&&(catalog[0].average[i].D>11.372)&&(catalog[0].average[i].D<11.373))
+        {
+          printf("Hello");
+        }
       valid = TRUE;
+      valid &= ((catalog[0].average[i].flags & 0x10000) == 0);
+      valid &= ((catalog[0].average[i].flags & 0x20000)  > 0);
+      valid &= (catalog[0].secfilt[i*Nsecfilt + jNsec].M < 1.0);
+      valid &= ((catalog[0].average[i].flags & 0x01000000) == 0);
+      valid &= ((catalog[0].average[i].flags & 0x04000000)  > 0);
+      valid &= ((catalog[0].secfilt[i*Nsecfilt + jNsec].M < 1.0)||(isnan(catalog[0].secfilt[i*Nsecfilt + jNsec].M)));
       valid &= (catalog[0].secfilt[i*Nsecfilt + yNsec].Nused > 1);
       valid &= (catalog[0].secfilt[i*Nsecfilt + yNsec].dM < 0.2);
       if ((catalog[0].secfilt[i*Nsecfilt + zNsec].M < 1.0) || (catalog[0].secfilt[i*Nsecfilt + zNsec].Nused == 1)) {
+      /*if ((catalog[0].secfilt[i*Nsecfilt + zNsec].M < 1.0) || (catalog[0].secfilt[i*Nsecfilt + zNsec].Nused == 1)) {
         valid &= TRUE;
       } else {
         valid &= ((catalog[0].secfilt[i*Nsecfilt + zNsec].M - catalog[0].secfilt[i*Nsecfilt + yNsec].M) > 0.2);
+      }
+        }*/
       // measure-based tests:
       m = catalog[0].average[i].measureOffset;
+      /*m = catalog[0].average[i].measureOffset;
       for (j = 0; valid && (j < catalog[0].average[i].Nmeasure); j++, m++) {
         if (catalog[0].measure[m].photcode == USNO_R) {
 …
           valid &= ((catalog[0].measure[m].M > 18.5) || isnan(catalog[0].measure[m].M));
+        }
+      }
+        }*/
       // (abs(glat)>15.0) &&
 …
   Nmatch = 0;
+  Nmatchmeas = 0;
   RADIUS2 = SQ(RADIUS);
 …
     ni = N1[i];
     nj = N1[j];
     // if (ni == 131030) {
     //   fprintf (stderr, "got 2mass\n");
 …
     // within match range; look for valid matches
     for (J = j; (dX > -1.02*RADIUS) && (J < catalog[0].Naverage); J++) {
+    for (J = j; (dX > -1.02*RADIUS) && (J < catalog[0].Naverage); J++) {
       if (J == i) continue;  // avoid auto-matches
 …
       // y_groupA - J_groupB
+      yJ = catalog[0].secfilt[nj*Nsecfilt + yNsec].M - catalog[0].secfilt[ni*Nsecfilt + jNsec].M;
+      /*      yJ = catalog[0].secfilt[nj*Nsecfilt + yNsec].M - catalog[0].secfilt[ni*Nsecfilt + jNsec].M;
       if (yJ < 1.25) continue;
       if (yJ > 5.0) continue;
+      if (yJ > 5.0) continue;*/
       /*** a match is found (just print it for the moment) ***/
+      /*Define a vector of matched indices and set averages in new catalogue*/
+      Nepoch=2;
+      FIT_MODE = FIT_PM_ONLY;
+/*nv=(int *)malloc(Nepoch*sizeof(int));*/
+      nv[0]=ni; /*THESE SHOULD BE CHANGED FOR MULTIPLE EPOCHS AS SHOULD nv*/
+      nv[1]=nj;
+      catalog1.average[Nmatch]=catalog[0].average[nv[0]];
+      /*Loop over index values and set measurements in new catalogue*/
+      Nmatchmeasobj=0;
+      catalog1.average[Nmatch].measureOffset=Nmatchmeas;
+      for(l=0;l<Nepoch;l++) {
+          m = catalog[0].average[nv[l]].measureOffset;
+          for(i1=0;i1<catalog[0].average[nv[l]].Nmeasure;i1++) {
+              catalog1.measure[Nmatchmeas]=catalog[0].measure[m+i1];
+              /*Set offset RA and Dec wrt correct average value*/
+              catalog1.measure[Nmatchmeas].dR=catalog[0].measure[m+i1].dR+3600.0*(catalog[0].average[nv[0]].R-catalog[0].average[nv[l]].R);
+              catalog1.measure[Nmatchmeas].dD=catalog[0].measure[m+i1].dD+3600.0*(catalog[0].average[nv[0]].D-catalog[0].average[nv[l]].D);
+              catalog1.measure[Nmatchmeas].averef = Nmatch;
+              Nmatchmeasobj++;
+              Nmatchmeas++;
+              if (Nmatchmeas == NMEASURE - 1) {
+                NMEASURE += 10000;
+                REALLOCATE (catalog1.measure, Measure, NMEASURE);
+              }
+          }
+      }
+      catalog1.average[Nmatch].Nmeasure=Nmatchmeasobj;
       Nmatch ++;
+      if (Nmatch == NAVERAGE - 1) {
+        NAVERAGE += 1000;
+        REALLOCATE (catalog1.average, Average, NAVERAGE);
+        REALLOCATE(catalog1.secfilt, SecFilt, NAVERAGE*Nsecfilt);
+      }
       // for the moment, just write the matches to stdout:
       float pmx = -dX; // proper-motion displacement in ra  direction (B - A) [arcsec]
       float pmy = -dY; // proper-motion displacement in dec direction (B - A) [arcsec]
       fprintf (stdout, "%11.7f %11.7f  %11.7f %11.7f : %7.2f %7.2f  %7.2f : %7.3f %6.3f  %7.3f %6.3f  %7.3f %6.3f  %7.3f %6.3f  %7.3f %6.3f\n",
+      //float pmx = -dX; // proper-motion displacement in ra  direction (B - A) [arcsec]
+      //float pmy = -dY; // proper-motion displacement in dec direction (B - A) [arcsec]
+      /*           fprintf (stdout, "%11.7f %11.7f  %11.7f %11.7f : %7.2f %7.2f  %7.2f: %7.3f %6.3f  %7.3f %6.3f  %7.3f %6.3f  %7.3f %6.3f  %7.3f %6.3f\n",
                catalog[0].average[ni].R, catalog[0].average[ni].D,
                catalog[0].average[nj].R, catalog[0].average[nj].D,
                pmx, pmy, sqrt(dR),
+               dX, dY, sqrt(dR),
                catalog[0].secfilt[nj*Nsecfilt + zNsec].M,
                catalog[0].secfilt[nj*Nsecfilt + zNsec].dM,
 …
                catalog[0].secfilt[ni*Nsecfilt + hNsec].dM,
                catalog[0].secfilt[ni*Nsecfilt + kNsec].M,
                catalog[0].secfilt[ni*Nsecfilt + kNsec].dM);
+               catalog[0].secfilt[ni*Nsecfilt + kNsec].dM);*/
+    }
     i++;
+  }
+  catalog1.Naverage=Nmatch;
+  catalog1.Nmeasure=Nmatchmeas;
+  catalog1.Nsecfilt=Nsecfilt;
+  catalog1.Nsecf_mem=Nmatch*Nsecfilt;
+  UpdateObjects(&catalog1, 1);
   fprintf (stderr, "found %d matches\n", Nmatch);
+  dvo_catalog_save (&catalog1, VERBOSE);
+  dvo_catalog_unlock (&catalog1);
+  dvo_catalog_free (&catalog1);
   free (slowMoving);
   free (groupA);

trunk/Ohana/src/tools/Makefile

r20983	r29938
17	17	PROGRAMS = gconfig fhead ftable fields list_astro glockfile \
18	18	radec mktemp precess csystem fits_insert \
19		medianfilter mefhead ckfits
	19	medianfilter mefhead ckfits roc
20	20
21	21	all tools: $(PROGRAMS)

Context Navigation

Legend:

Download in other formats: