IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 5448


Ignore:
Timestamp:
Oct 27, 2005, 10:38:30 AM (21 years ago)
Author:
eugene
Message:

implementing SkyRegions in all DVO programs

Location:
trunk/Ohana/src
Files:
35 edited

Legend:

Unmodified
Added
Removed

  • trunk/Ohana/src/addstar/doc/notes.txt

    r5445 r5448  
    2121  with .cpm, .cpn, .cps as needed.
    2222
    23  
     23  *** I need to fix the name method: common function to set it once
     24  in the dvo functions.  perhaps a pointer in the SkyRegion structure.
     25  This needs some 32/64 bit care, though.  use a long long (or other
     26  type guaranteed to be 64 bit), and case to the appropriate type (size_t)
     27  when it is used?  also needs to be freed.
    2428
    2529todo:

  • trunk/Ohana/src/addstar/src/SkyRegionUtils.c

    r5445 r5448  
    1515  /* match the basename against the GSCRegion file names */
    1616  for (i = 0; i < input[0].Nregions; i++) {
    17     sprintf (filename, "%s/%s.cpt", path, input[0].regions[i][0].name);
    18     status = stat (filename, &filestats);
     17    status = stat (input[0].regions[i][0].filename, &filestats);
    1918    if ((status == -1) && (errno == ENOENT)) continue;
    2019    /* give an error for other conditions? */
    … …  
    2625  }
    2726  return (subset);
    28 }
    29 
    30 int SkyListSetPath (SkyList *list, char *path) {
    31 
    32   int i;
    33   char line[256];
    34 
    35   for (i = 0; i < list[0].Nregions; i++) {
    36     fprintf (stderr, "region: %s\n", list[0].regions[i][0].name);
    37     sprintf (line, "%s/%s", path, list[0].regions[i][0].name);
    38     fprintf (stderr, "line: %s\n", line);
    39     strcpy (list[0].regions[i][0].name, line);
    40     fprintf (stderr, "catalog: %s\n", list[0].regions[i][0].name);
    41   }
    42 
    43   return (TRUE);
    4427}
    4528
    … …  
    5437}
    5538
    56 SkyTable *SkyTableLoadOptimal () {
    57 
    58   char filename[256];
    59   struct stat filestat;
    60   SkyTable *sky;
    61   int status;
    62 
    63   /* first option: CATDIR/SkyTable.fits */
    64   sprintf (filename, "%s/SkyTable.fits", CATDIR);
    65   check_permissions (filename);
    66 
    67   /* check for file existance */
    68   status = stat (filename, &filestat);
    69   if (status == 0) { /* file exists, are permissions OK? */
    70     sky = SkyTableLoad (filename, VERBOSE);
    71     if (sky == NULL) {
    72       fprintf (stderr, "error loading sky table\n");
    73       exit (1);
    74     }
    75     return (sky);
    76   }
    77 
    78   /* first option: SKY_TABLE */
    79   if (SKY_TABLE[0]) {
    80     status = stat (SKY_TABLE, &filestat);
    81     if (status == 0) { /* file exists, are permissions OK? */
    82       sky = SkyTableLoad (SKY_TABLE, VERBOSE);
    83       if (sky == NULL) {
    84         fprintf (stderr, "error loading sky table\n");
    85         exit (1);
    86       }
    87       SkyTableSetDepth (sky, SKY_DEPTH);
    88 
    89       /* write CATDIR copy */
    90       sprintf (filename, "%s/SkyTable.fits", CATDIR);
    91       check_permissions (filename);
    92       SkyTableSave (sky, filename);
    93       fits_convert_SkyRegion (sky[0].regions, sizeof (SkyTable), sky[0].Nregions);
    94       return (sky);
    95     }
    96   }
    97 
    98   sky = SkyTableFromGSC (GSCFILE, SKY_DEPTH, VERBOSE);
    99   if (sky == NULL) {
    100     fprintf (stderr, "error loading sky table\n");
    101     exit (1);
    102   }
    103 
    104   /* write CATDIR copy */
    105   sprintf (filename, "%s/SkyTable.fits", CATDIR);
    106   check_permissions (filename);
    107   SkyTableSave (sky, filename);
    108   fits_convert_SkyRegion (sky[0].regions, sizeof (SkyRegion), sky[0].Nregions);
    109 
    110   return (sky);
    111 }

  • trunk/Ohana/src/addstar/src/UpdateDatabase_Image.c

    r5445 r5448  
    4444
    4545  /* find correpsonding regions for image */
    46   skylist = SkyListByImage (ServerSky, -1, image, mosaic);
     46  RegisterMosaic (mosaic);
     47  skylist = SkyListByImage (ServerSky, -1, image);
    4748
    4849  /* reduce regions to existing subset, if necessary */
    49   SkyListSetPath (skylist, CATDIR);
    5050  if (options[0].only_match || options[0].existing_regions) {
    5151    SkyList *tmp;

  • trunk/Ohana/src/addstar/src/UpdateDatabase_Refcat.c

    r5445 r5448  
    66  Catalog catalog;
    77  Stars *stars, **subset;
    8   // SkyTable *sky;
    98  SkyList *skylist;
    10 
    11   /* this should be loaded by addstard on start -- keep static? */
    12   /* need to load the correct sky table (GSC default or local verison) */
    13   /* XXX EAM : check on memory usage */
    14   // sky = SkyTableFromGSC (GSCFILE, SKY_DEPTH, VERBOSE);
    159
    1610  if (options[0].update) {
    … …  
    4842
    4943  /* reduce regions to existing subset, if necessary */
    50   SkyListSetPath (skylist, CATDIR);
    5144  if (options[0].only_match || options[0].existing_regions) {
    5245    SkyList *tmp;

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

    r5445 r5448  
    2323  options = args (argc, argv, options);
    2424
    25   sky = SkyTableLoadOptimal ();
     25  sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, SKY_DEPTH, VERBOSE);
     26  SkyTableSetFilenames (sky, CATDIR, "cpt");
    2627 
    2728  stars = NULL;
    … …  
    4445    stars = gstars (argv[1], &Nstars, options.photcode, &image);
    4546    if ((DUMP != NULL) && !strcmp (DUMP, "rawstars")) dump_rawstars (stars, Nstars);
    46     skylist = SkyListByImage (sky, -1, &image, MOSAIC);
     47    RegisterMosaic (MOSAIC);
     48    skylist = SkyListByImage (sky, -1, &image);
    4749    overlap = gimages (&db, &image, MOSAIC, &Noverlap);
    4850    break;

  • trunk/Ohana/src/addstar/src/addstard.c

    r5445 r5448  
    1111  args_server (argc, argv);
    1212
    13   /* store the sky table in a global? */
    14   ServerSky = SkyTableLoadOptimal ();
     13  /* store the sky table in a global for internal use */
     14  ServerSky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, SKY_DEPTH, VERBOSE);
     15  SkyTableSetFilename (ServerSky, CATDIR, "cpt");
    1516
    1617  /* if we separate the incoming data from db update, spawn db thread here */

  • trunk/Ohana/src/addstar/src/get2mass.c

    r5443 r5448  
    5656
    5757  int Nregions, NREGIONS;
    58   char accelfile[1024], line[256], filename[128];
     58  char accelfile[1024], line[256], filename[128], datafile[256];
    5959  FILE *f;
    6060  double Rs, Re, Ds, De;
    … …  
    8383    if (Ds > patch[0].Dmax) continue;
    8484    if (De < patch[0].Dmin) continue;
    85     sprintf (regions[Nregions].name, "%s/%s", path, filename);
     85    sprintf (datafile, "%s/%s", path, filename);
     86    regions[Nregions].filename = strcreate (datafile);
    8687    regions[Nregions].Rmin = Rs;
    8788    regions[Nregions].Rmax = Re;

  • trunk/Ohana/src/addstar/src/get2mass_as.c

    r5443 r5448  
    5151  if (!FilterSkip) Shutdown ("invalid photcode %s", GetPhotcodeNamebyCode(photcode));
    5252
    53   filename = region[0].name;
     53  filename = region[0].filename;
    5454  gf = gzopen (filename, "rb");
    5555  if (gf == NULL) Shutdown ("can't read 2mass data file: %s", filename);

  • trunk/Ohana/src/addstar/src/get2mass_dr2.c

    r5443 r5448  
    2727  fprintf (stderr, "overlap: %f - %f, %f - %f\n", RA0, RA1, DEC0, DEC1);
    2828
    29   filename = region[0].name;
     29  filename = region[0].filename;
    3030  gf = gzopen (filename, "rb");
    3131  if (gf == NULL) Shutdown ("can't read 2mass data file: %s", filename);

  • trunk/Ohana/src/addstar/src/getgsc.c

    r5445 r5448  
    1818  /* load regions from GSC table, restrict to patch */
    1919  sky = SkyTableFromGSC (GSCFILE, 2, VERBOSE);
     20  SkyTableSetPath (sky, GSCDIR, "cpt");
    2021  skylist = SkyListByPatch (sky, -1, patch);
    21   SkyListSetPath (skylist, GSCDIR);
    2222 
    2323  Nstars = 0;
    … …  
    2525 
    2626  for (i = 0; i < skylist[0].Nregions; i++) {
    27     gsc = rd_gsc (skylist[0].regions[i][0].name, &Ngsc);
     27    gsc = rd_gsc (skylist[0].regions[i][0].filename, &Ngsc);
    2828
    2929    REALLOCATE (stars, Stars, MAX (1, Nstars + Ngsc));
    … …  
    3434  }
    3535 
     36  SkyTableFree (sky);
    3637  if (VERBOSE) fprintf (stderr, "%d stars from HST GSC\n", Nstars);
    3738  *NSTARS = Nstars;

  • trunk/Ohana/src/addstar/src/load_pt_catalog.c

    r5445 r5448  
    55  char filename[256];
    66
    7   sprintf (filename, "%s/%s.cpt", path, region[0].name);
     7  catalog[0].filename = region[0].filename;
    88
    9   check_permissions (filename);
    10   if (VERBOSE) fprintf (stderr, "adding to %s\n", filename);
    11 
    12   catalog[0].filename = strcreate (filename);
     9  check_permissions (catalog[0].filename);
     10  if (VERBOSE) fprintf (stderr, "adding to %s\n", catalog[0].filename);
    1311   
    1412  switch (lock_catalog (catalog, LCK_XCLD)) {

  • trunk/Ohana/src/delstar/src/delete_imagefile.c

    r4864 r5448  
    88  time_t start, stop;
    99  Image *image;
    10   GSCRegion *region;
    1110  Catalog catalog;
     11  SkyList *skylist;
     12  SkyTable *sky;
     13
     14  /* load sky from correct table */
     15  sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, SKY_DEPTH, VERBOSE);
     16  SkyTableSetFilenames (sky, CATDIR, "cpt");
    1217
    1318  /* load information about file - time/photcode */
    1419  image = gimages (filename);
    1520 
     21  /* need to define method to get the mosaic (look up from table) */
    1622  if (VERBOSE) fprintf (stderr, "deleting %s\n", image[0].name);
    17   region = gregion_image (image, &Nregions);
    1823
    19   for (i = 0; i < Nregions; i++) {
    20     if (VERBOSE) fprintf (stderr, "deleting from %s\n", region[i].filename);
    21     catalog.filename = region[i].filename;  /* don't free region before catalog! */
     24  for (i = 0; i < skylist[0].Nregions; i++) {
     25    if (VERBOSE) fprintf (stderr, "deleting from %s\n", skylist[0].region[i][0].filename);
     26    catalog.filename = skylist[0].region[i][0].filename;  /* don't free region before catalog! */
    2227    switch (lock_catalog (&catalog, LCK_XCLD)) {
    2328      case 0:
    … …  
    4651
    4752  /* find and delete matching images */
     53  // XXX EAM : load image data above, find mosaic?
    4854  imlist = find_images_data (db, image, &Nimlist);
    4955  if (!Nimlist) Shutdown ("image %s not found in db", filename);

  • trunk/Ohana/src/delstar/src/delete_imagename.c

    r4864 r5448  
    44
    55  int i, j, k;
    6   int Nregions, Nimlist, Nimage;
     6  int Nimlist, Nimage;
    77  int *imlist;
    88  double trange;
    99  time_t start, stop;
    1010  Image *image;
    11   GSCRegion *region;
    1211  Catalog catalog;
     12  SkyList *skylist;
     13  SkyTable *sky;
     14
     15  /* load sky from correct table */
     16  sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, SKY_DEPTH, VERBOSE);
     17  SkyTableSetFilenames (sky, CATDIR, "cpt");
    1318
    1419  image = fits_table_get_Image (&db[0].ftable, &Nimage, &db[0].swapped);
    … …  
    2227    j = imlist[k];
    2328    if (VERBOSE) fprintf (stderr, "deleting %s\n", image[j].name);
    24     region = gregion_image (&image[j], &Nregions);
     29   
     30    // XXX EAM : need to handle failure
     31    FindMosaicForImage (image, Nimage, j);
     32    skylist = SkyListByImage (sky, -1, &image[j]);
    2533
    26     for (i = 0; i < Nregions; i++) {
    27       if (VERBOSE) fprintf (stderr, "deleting from %s\n", region[i].filename);
    28       catalog.filename = region[i].filename;  /* don't free region before catalog! */
     34    for (i = 0; i < skylist[0].Nregions; i++) {
     35      if (VERBOSE) fprintf (stderr, "deleting from %s\n", skylist[0].region[i][0].filename);
     36      catalog.filename = skylist[0].region[i][0].filename;  /* don't free region before catalog! */
    2937      switch (lock_catalog (&catalog, LCK_XCLD)) {
    3038        case 0:

  • trunk/Ohana/src/delstar/src/delete_times.c

    r4864 r5448  
    77  int Ntregions, Nregions, NREGIONS;
    88  int *imlist;
    9   GSCRegion *region, *tregion;
     9  SkyList *skylist, *skyset;
     10  SkyTable *sky;
    1011  Image *image;
    1112  Catalog catalog;
    … …  
    1314  code = (PHOTCODE == NULL) ? -1 : PHOTCODE[0].code;
    1415
     16  /* load sky from correct table */
     17  sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, SKY_DEPTH, VERBOSE);
     18  SkyTableSetFilenames (sky, CATDIR, "cpt");
     19
    1520  Nregions = 0;
    1621  NREGIONS = 10;
    17   ALLOCATE (region, GSCRegion, NREGIONS);
     22  ALLOCATE (skylist, SkyList, 1);
     23  ALLOCATE (skylist[0].regions, SkyRegions *, NREGIONS);
    1824
    1925  image = fits_table_get_Image (&db[0].ftable, &Nimage, &db[0].swapped);
    … …  
    2733    if (VERBOSE) fprintf (stderr, "finding regions for %s\n", image[j].name);
    2834
    29     tregion = gregion_image (&image[j], &Ntregions);
    30     for (i = 0; i < Ntregions; i++) {
     35    // XXX EAM : need to handle failure
     36    FindMosaicForImage (image, Nimage, j);
     37    skyset = SkyListByImage (sky, -1, &image[j]);
     38
     39    // tregion = gregion_image (&image[j], &Ntregions);
     40    for (i = 0; i < skyset[0].Nregions; i++) {
    3141      found = FALSE;
    32       for (k = 0; (k < Nregions) && !found; k++) {
    33         found = !strcmp (region[k].filename, tregion[i].filename);
     42      for (k = 0; (k < skylist[0].Nregions) && !found; k++) {
     43        found = !strcmp (skylist[0].region[k][0].name, skyset[0].region[i][0].name);
    3444      }
    35       if (!found) {
    36         strcpy (region[Nregions].filename, tregion[i].filename);
    37         region[Nregions].RA[0] = tregion[i].RA[0];
    38         region[Nregions].RA[1] = tregion[i].RA[1];
    39         region[Nregions].DEC[0] = tregion[i].DEC[0];
    40         region[Nregions].DEC[1] = tregion[i].DEC[1];
    41         Nregions ++;
    42         if (Nregions >= NREGIONS) {
    43           NREGIONS += 10;
    44           REALLOCATE (region, GSCRegion, NREGIONS);
    45         }
    46       }
     45      if (found) continue;
     46      skylist[0].regions[Nregions] = skyset[0].regions[i];
     47      Nregions ++;
     48      CHECK_REALLOCATE (skylist[0].regions, SkyRegions *, NREGIONS, Nregions, 10);
    4749    }
    48     free (tregion);
     50    SkyListFree (skyset);
    4951  }
    5052
    5153  /* delete from all identified regions */
    52   for (i = 0; i < Nregions; i++) {
    53     if (VERBOSE) fprintf (stderr, "deleting from %s\n", region[i].filename);
    54     catalog.filename = region[i].filename;  /* don't free region before catalog! */
     54  for (i = 0; i < skylist[0].Nregions; i++) {
     55    if (VERBOSE) fprintf (stderr, "deleting from %s\n", skylist[0].region[i][0].filename);
     56    catalog.filename = skylist[0].region[i][0].filename;  /* don't free region before catalog! */
    5557    switch (lock_catalog (&catalog, LCK_XCLD)) {
    5658      case 0:

  • trunk/Ohana/src/libautocode/def/SkyRegion.d

    r5445 r5448  
    22EXTNAME SKY_REGION
    33TYPE    BINTABLE
    4 SIZE    56
     4SIZE    64
    55
    66FIELD   Rmin,      R_MIN,          float,
    … …  
    1616FIELD   table,     TABLE,          char,          does this entry have a table?
    1717FIELD   name,      NAME,           char[21],      name / filename
     18FIELD   filename,  FILENAME,       e_void,        filename pointer

  • trunk/Ohana/src/libautocode/generate

    r5014 r5448  
    119119        if ($type eq "unsigned int")  { $pt1 = "J"; }
    120120        if ($type eq "e_time")        { $pt1 = "J"; }
     121        if ($type eq "e_void")        { $pt1 = "L"; }
     122        # e_void is a 64 bit pointer, cast to size_t
    121123        if ($type eq "float")         { $pt1 = "E"; }
    122124        if ($type eq "double")        { $pt1 = "D"; }
    … …  
    188190        if ($type eq "unsigned int")  { $pt1 = sprintf "I%s", $length; }
    189191        if ($type eq "e_time")        { $pt1 = sprintf "I%s", $length; }
     192        if ($type eq "e_void")        { $pt1 = sprintf "I%s", $length; }
    190193        if ($type eq "float")         { $pt1 = sprintf "F%s", $length; }
    191194        if ($type eq "double")        { $pt1 = sprintf "F%s", $length; }
    … …  
    255258        if ($type eq "unsigned int")  { $T = "WORD"; $n = 4; }
    256259        if ($type eq "e_time")        { $T = "WORD"; $n = 4; }
     260        if ($type eq "e_void")        { $T = "DBLE"; $n = 8; }
    257261        if ($type eq "float")         { $T = "WORD"; $n = 4; }
    258262        if ($type eq "double")        { $T = "DBLE"; $n = 8; }
    … …  
    285289        if ($type eq "unsigned int")   { $Nbytes += 4*$Np; $valid = 1; }
    286290        if ($type eq "e_time")         { $Nbytes += 4*$Np; $valid = 1; }
     291        if ($type eq "e_void")         { $Nbytes += 8*$Np; $valid = 1; }
    287292        if ($type eq "float")          { $Nbytes += 4*$Np; $valid = 1; }
    288293        if ($type eq "double")         { $Nbytes += 8*$Np; $valid = 1; }

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

    r5441 r5448  
    338338SkyTable *SkyTableLoad (char *filename, int VERBOSE);
    339339SkyTable *SkyTableFromGSC (char *filename, int depth, int VERBOSE);
     340SkyTable *SkyTableLoadOptimal (char *catdir, char *SKY_TABLE, char *GSCFILE, int VERBOSE);
    340341SkyRegion *SkyRegionByPoint (SkyTable *table, int depth, double ra, double dec);
    341342SkyList *SkyListByPoint (SkyTable *table, double ra, double dec);

  • trunk/Ohana/src/libdvo/src/skyregion_gsc.c

    r5441 r5448  
    5656  regions[Nr].Dmin      = -90;
    5757  regions[Nr].Dmax      = +90;
    58   regions[Nr].index  =  0;
    59   regions[Nr].depth  =  0;
    60   regions[Nr].parent = -1;
    61   regions[Nr].child  =  TRUE;
    62   regions[Nr].table  =  (depth == 0);
     58  regions[Nr].index     =  0;
     59  regions[Nr].depth     =  0;
     60  regions[Nr].parent    = -1;
     61  regions[Nr].child     =  TRUE;
     62  regions[Nr].table     =  (depth == 0);
     63  regions[Nr].filename  =  NULL;
    6364  strcpy (regions[Nr].name, "fullsky");
     65 
    6466 
    6567  No = Nr;
    … …  
    7072  /* first north */
    7173  for (i = 0; i < 12; i++, Nr++) {
    72     regions[Nr].Rmin   =   0;
    73     regions[Nr].Rmax   = 360;
    74     regions[Nr].Dmin   = DecBands[i];
    75     regions[Nr].Dmax   = DecBands[i+1];
    76     regions[Nr].index  =  i+1;
    77     regions[Nr].depth  =  1;
    78     regions[Nr].parent =  0;
    79     regions[Nr].child  =  TRUE;
    80     regions[Nr].table  =  (depth == 1);
     74    regions[Nr].Rmin      =   0;
     75    regions[Nr].Rmax      = 360;
     76    regions[Nr].Dmin      = DecBands[i];
     77    regions[Nr].Dmax      = DecBands[i+1];
     78    regions[Nr].index     =  i+1;
     79    regions[Nr].depth     =  1;
     80    regions[Nr].parent    =  0;
     81    regions[Nr].child     =  TRUE;
     82    regions[Nr].table     =  (depth == 1);
     83    regions[Nr].filename  =  NULL;
    8184    strcpy (regions[Nr].name, DecNames[i]);
    8285  }
    8386  /* now south */
    8487  for (i = 0; i < 12; i++, Nr++) {
    85     regions[Nr].Rmin   =   0;
    86     regions[Nr].Rmax   = 360;
    87     regions[Nr].Dmin   = DecBands[i+14];
    88     regions[Nr].Dmax   = DecBands[i+13];
    89     regions[Nr].index  =  i+1;
    90     regions[Nr].depth  =  1;
    91     regions[Nr].parent =  0;
    92     regions[Nr].child  =  TRUE;
    93     regions[Nr].table  =  (depth == 1);
     88    regions[Nr].Rmin      =   0;
     89    regions[Nr].Rmax      = 360;
     90    regions[Nr].Dmin      = DecBands[i+14];
     91    regions[Nr].Dmax      = DecBands[i+13];
     92    regions[Nr].index     =  i+1;
     93    regions[Nr].depth     =  1;
     94    regions[Nr].parent    =  0;
     95    regions[Nr].child     =  TRUE;
     96    regions[Nr].table     =  (depth == 1);
     97    regions[Nr].filename  =  NULL;
    9498    strcpy (regions[Nr].name, DecNames[i+13]);
    9599  }
    … …  
    134138      regions[Nr].Rmax = RA1;
    135139
    136       regions[Nr].index  =  Nr;
    137       regions[Nr].depth  =  2;
    138       regions[Nr].parent =  No;
    139       regions[Nr].child  =  TRUE;
    140       regions[Nr].table  =  (depth == 2);
    141       regions[Nr].childS =  0;
    142       regions[Nr].childE =  0;
     140      regions[Nr].index    =  Nr;
     141      regions[Nr].depth    =  2;
     142      regions[Nr].parent   =  No;
     143      regions[Nr].child    =  TRUE;
     144      regions[Nr].table    =  (depth == 2);
     145      regions[Nr].filename =  NULL;
     146      regions[Nr].childS   =  0;
     147      regions[Nr].childE   =  0;
    143148
    144149      temp[5] = 0;
    … …  
    166171    for (ny = 0; ny < NDIV; ny ++) {
    167172      for (nx = 0; nx < NDIV; nx ++) {
    168         regions[Nr].Rmin = RA0  + (nx + 0)*dR;
    169         regions[Nr].Rmax = RA0  + (nx + 1)*dR;
    170         regions[Nr].Dmin = DEC0 + (ny + 0)*dD;
    171         regions[Nr].Dmax = DEC0 + (ny + 1)*dD;
    172 
    173         regions[Nr].index  =  Nr;
    174         regions[Nr].depth  =  3;
    175         regions[Nr].parent =  i;
    176         regions[Nr].child  =  FALSE;
    177         regions[Nr].table  =  (depth == 3);
    178         regions[Nr].childS =  0;
    179         regions[Nr].childE =  0;
     173        regions[Nr].Rmin     = RA0  + (nx + 0)*dR;
     174        regions[Nr].Rmax     = RA0  + (nx + 1)*dR;
     175        regions[Nr].Dmin     = DEC0 + (ny + 0)*dD;
     176        regions[Nr].Dmax     = DEC0 + (ny + 1)*dD;
     177
     178        regions[Nr].index    =  Nr;
     179        regions[Nr].depth    =  3;
     180        regions[Nr].parent   =  i;
     181        regions[Nr].child    =  FALSE;
     182        regions[Nr].table    =  (depth == 3);
     183        regions[Nr].filename =  NULL;
     184        regions[Nr].childS   =  0;
     185        regions[Nr].childE   =  0;
    180186
    181187        temp[5] = 0;

  • trunk/Ohana/src/libdvo/src/skyregion_io.c

    r5445 r5448  
    3939  ALLOCATE (skytable, SkyTable, 1);
    4040  skytable[0].regions = fits_table_get_SkyRegion (&ftable, &skytable[0].Nregions, NULL);
     41  for (i = 0; i < skytable[0].Nregions; i++) {
     42    skytable[0].regions[i].filename = NULL;
     43  }
    4144 
    4245  fits_free_header (&header);
    … …  
    7982}
    8083
     84SkyTable *SkyTableLoadOptimal (char *catdir, char *SKY_TABLE, char *GSCFILE, int SKY_DEPTH, int VERBOSE) {
     85
     86  char filename[256];
     87  struct stat filestat;
     88  SkyTable *sky;
     89  int status;
     90
     91  /* first option: CATDIR/SkyTable.fits */
     92  sprintf (filename, "%s/SkyTable.fits", CATDIR);
     93  check_permissions (filename);
     94
     95  /* check for file existence */
     96  status = stat (filename, &filestat);
     97  if (status == 0) { /* file exists, are permissions OK? */
     98    sky = SkyTableLoad (filename, VERBOSE);
     99    if (sky == NULL) {
     100      fprintf (stderr, "error loading sky table\n");
     101      exit (1);
     102    }
     103    return (sky);
     104  }
     105
     106  /* first option: SKY_TABLE */
     107  if ((SKY_TABLE != NULL) && (SKY_TABLE[0] != 0)) {
     108    status = stat (SKY_TABLE, &filestat);
     109    if (status == 0) { /* file exists, are permissions OK? */
     110      sky = SkyTableLoad (SKY_TABLE, VERBOSE);
     111      if (sky == NULL) {
     112        fprintf (stderr, "error loading sky table\n");
     113        exit (1);
     114      }
     115      SkyTableSetDepth (sky, SKY_DEPTH);
     116
     117      /* write CATDIR copy */
     118      sprintf (filename, "%s/SkyTable.fits", CATDIR);
     119      check_permissions (filename);
     120      SkyTableSave (sky, filename);
     121      fits_convert_SkyRegion (sky[0].regions, sizeof (SkyTable), sky[0].Nregions);
     122      return (sky);
     123    }
     124  }
     125
     126  sky = SkyTableFromGSC (GSCFILE, SKY_DEPTH, VERBOSE);
     127  if (sky == NULL) {
     128    fprintf (stderr, "error loading sky table\n");
     129    exit (1);
     130  }
     131
     132  /* write CATDIR copy */
     133  sprintf (filename, "%s/SkyTable.fits", CATDIR);
     134  check_permissions (filename);
     135  SkyTableSave (sky, filename);
     136  fits_convert_SkyRegion (sky[0].regions, sizeof (SkyRegion), sky[0].Nregions);
     137
     138  return (sky);
     139}
     140
     141int SkyListSetFilenames (SkyList *list, char *path, char *ext) {
     142
     143  int i;
     144  char line[256];
     145
     146  // this generates the names, be sure to free when not needed
     147  for (i = 0; i < list[0].Nregions; i++) {
     148    sprintf (line, "%s/%s.%s", path, list[0].regions[i][0].name, ext);
     149    list[0].regions[i][0].filename = strcreate (line);
     150  }
     151
     152  return (TRUE);
     153}
     154

  • trunk/Ohana/src/libdvo/src/skyregion_ops.c

    r5441 r5448  
    119119
    120120/* user must be careful about mosaic registration */
    121 SkyList *SkyListByImage (SkyTable *table, int depth, Image *image, Coords *mosaic) {
     121SkyList *SkyListByImage (SkyTable *table, int depth, Image *image) {
    122122
    123123  int i, j;
    … …  
    126126  double Rmin, Rmax, Dmin, Dmax;
    127127 
    128   RegisterMosaic (mosaic);
     128  // XXX EAM : image/mosaic MUST be registered (if WRP)
    129129  SetImageCorners (X, Y, image);
    130130
    … …  
    269269  if (table == NULL) return (TRUE);
    270270  if (table[0].regions != NULL) {
     271    for (i = 0; i < table[0].Nregions; i++) {
     272      if (table[0].regions[i].filename != NULL) {
     273        free (table[0].regions[i].filename);
     274      }
     275    }
    271276    free (table[0].regions);
    272277  }

  • trunk/Ohana/src/opihi/dvo/catalog.c

    r5320 r5448  
    99# define MISSCALE 2
    1010
     11// XXX EAM : should this function be dropped?
    1112int catlog (int argc, char **argv) {
    1213 

  • trunk/Ohana/src/opihi/dvo/dmt.c

    r5320 r5448  
    44int dmt (int argc, char **argv) {
    55 
    6   int i, m, k, N, Nregions, Ngraph, SaveVectors;
     6  int i, m, k, N, Ngraph, SaveVectors;
    77  int Ns, Nsec, NPTS;
    88  char catdir[256], filename[256];
    … …  
    1313  Catalog catalog;
    1414  Graphdata graphmode, graphsky;
    15   RegionFile *regions;
     15  SkyTable *sky;
     16  SkyList *skylist;
    1617  Vector Xvec, Yvec, Zvec, Rvec, Dvec;
    1718  Vector *vec1, *vec2, *vec3, *vec4, *vec5;
    … …  
    5354  Ns = GetPhotcodeNsec (code[0].code);
    5455
     56  /* load sky from correct table */
     57  sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, -1, VERBOSE);
     58  SkyTableSetFilenames (sky, CATDIR, "cpt");
     59
    5560  Radius = MAX (fabs(graphsky.xmax), fabs(graphsky.ymax));
    56   regions = find_regions (graphsky.coords.crval1, graphsky.coords.crval2, Radius, &Nregions);
     61  skylist = SkyListByRadius (sky, -1, graphsky.coords.crval1, graphsky.coords.crval2, Radius);
    5762 
    5863  N = 0;
    … …  
    6671  }
    6772
    68   for (k = 0; k < Nregions; k++) {
     73  for (k = 0; k < skylist[0].Nregions; k++) {
    6974
    70     sprintf (filename, "%s/%s", catdir, regions[k].name);
    7175    /* lock, load, unlock catalog */
    72     catalog.filename = filename;
     76    catalog.filename = skylist[0].regions[k][0].filename;
    7377    switch (lock_catalog (&catalog, LCK_SOFT)) {
    7478    case 2:

  • trunk/Ohana/src/opihi/dvo/extract.c

    r5320 r5448  
    11# include "dvo1.h"
     2// XXX EAM : this function is deprecated
    23
    34enum {ZERO, RA, DEC, MAG, dMAG, Xm, Xp, NMEAS, NMISS, REF, TYPE, NPHOT, NCODE, FLAG};

  • trunk/Ohana/src/opihi/dvo/gcat.c

    r3462 r5448  
    33int gcat (int argc, char **argv) {
    44 
    5   int i, Nregions;
    6   RegionFile *regions;
    7   char filename[128];
     5  int i;
    86  struct stat filestat;
    97  double Ra, Dec, Radius;
     8  SkyTable *sky;
     9  SkyList *skylist;
    1010  char catdir[256];
    1111
    … …  
    1717  }
    1818
     19  /* load sky from correct table */
     20  sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, -1, VERBOSE);
     21  SkyTableSetFilenames (sky, CATDIR, "cpt");
     22
    1923  Ra = atof (argv[1]);
    2024  Dec = atof (argv[2]);
    … …  
    2428    Radius = 0.0001;
    2529
    26   regions = find_regions (Ra, Dec, Radius, &Nregions);
     30  skylist = SkyListByRadius (sky, -1, Ra, Dec, Radius);
    2731
    28   for (i = 0; i < Nregions; i++) {
    29     sprintf (filename, "%s/%s", catdir, regions[i].name);
    30     if (stat (filename, &filestat) != -1) {
     32  for (i = 0; i < skylist[0].Nregions; i++) {
     33    if (stat (skylist[0].regions[i][0].filename, &filestat) != -1) {
    3134      fprintf (stderr, "%3d %s *\n", i, regions[i].name);
    3235    } else {
    … …  
    3740
    3841  return (TRUE);
    39   free (regions);
    40 
     42  SkyListFree (regions);
    4143}
    42 

  • trunk/Ohana/src/opihi/dvo/gstar.c

    r5320 r5448  
    99  double Mcat, Mrel;
    1010  float *RA, *DEC;
    11   int i, j, k, m, N, *N1, Nregions, Nsec, NPTS;
     11  int i, j, k, m, N, *N1, Nsec, NPTS;
    1212  int Nstars, found, GetMeasures, Nlo, Nhi;
    1313  int SaveVectors;
    1414  Vector *vec1, *vec2, *vec3, *vec4;
    15   RegionFile *regions;
     15  SkyTable *sky;
     16  SkyList *skylist;
    1617  Catalog catalog;
    1718  PhotCode *code;
    … …  
    5253  while (Ra > 360.0) Ra -= 360.0;
    5354 
    54   regions = find_regions (Ra, Dec, Radius, &Nregions);
    55 
    56   if (Nregions > 1) {
     55  /* load sky from correct table */
     56  sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, -1, VERBOSE);
     57  SkyTableSetFilenames (sky, CATDIR, "cpt");
     58  skylist = SkyListByRadius (sky, -1, Ra, Dec, Radius);
     59
     60  if (skylist[0].Nregions > 1) {
    5761    fprintf (stderr, "warning, radius overlaps region boundary, not yet implemented\n");
    5862  }
    5963
    60   /* set filename, read in header */
    61   sprintf (filename, "%s/%s", catdir, regions[0].name);
    6264  /* lock, load, unlock catalog */
    63   catalog.filename = filename;
     65  catalog.filename = skylist[0].regions[0][0].filename;
    6466  switch (lock_catalog (&catalog, LCK_SOFT)) {
    6567  case 2:

  • trunk/Ohana/src/opihi/dvo/imdata.c

    r5320 r5448  
    11# include "dvo1.h"
    2 void copy_region (GSCRegion *in, GSCRegion *out);
    32
    43int imdata (int argc, char **argv) {
    … …  
    1312  Image *image;
    1413  Catalog catalog;
    15   GSCRegion *region, *tregion;
     14  SkyTable *sky;
     15  SkyList *skylist, *skyset;
    1616  Vector *vec;
    1717
    … …  
    8080  GetTimeFormat (&TimeReference, &TimeFormat);
    8181
     82  /* load sky from correct table */
     83  sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, -1, VERBOSE);
     84  SkyTableSetFilenames (sky, CATDIR, "cpt");
     85
     86  Nregions = 0;
     87  NREGIONS = 10;
     88  ALLOCATE (skylist, SkyList, 1);
     89  ALLOCATE (skylist[0].regions, SkyRegions *, NREGIONS);
     90
    8291  /* for each image of interest, find the appropriate region files */
    83   Nregion = 0;
    84   ALLOCATE (region, GSCRegion, 1);
    8592  for (i = 0; i < Nsubset; i++) {
    8693    I = subset[i];
     94
    8795    if (!FindMosaicForImage (image, Nimage, I)) continue;
    88     tregion = get_regions (&image[I], &Ntregion);
    89     REALLOCATE (region, GSCRegion, MAX (1, Nregion + Ntregion));
    90     for (j = 0; j < Ntregion; j++) {
    91       skip = FALSE;
    92       for (k = 0; (k < Nregion) && !skip; k++) {
    93         if (!strcmp (region[k].filename, tregion[j].filename)) skip = TRUE;
    94       }
    95       if (!skip) {
    96         copy_region (&tregion[j], &region[Nregion]);
    97         Nregion ++;
    98       }
    99     }
    100     free (tregion);
     96    skyset = SkyListByImage (table, -1, &image[I]);
     97
     98    for (j = 0; j < skyset[0].Nregions; j++) {
     99      found = FALSE;
     100      for (k = 0; (k < skylist[0].Nregion) && !found; k++) {
     101        found = !strcmp (skylist[0].regions[k].name, skyset[0].regions[j].name);
     102      }
     103      if (found) continue;
     104      skylist[0].regions[Nregions] = skyset[0].regions[j];
     105      Nregions ++;
     106      CHECK_REALLOCATE (skylist[0].regions, SkyRegions *, NREGIONS, Nregions, 10);
     107    }
     108    SkyListFree (skyset);
    101109  }     
    102110  free (subset);
    103   for (i = 0; i < Nregion; i++) {
    104     fprintf (stderr, "try %s\n", region[i].filename);
     111  for (i = 0; i < skylist[0].Nregions; i++) {
     112    fprintf (stderr, "try %s\n", skylist[0].regions[i][0].name);
    105113  }
    106114 
    … …  
    111119
    112120  /* for each region file, extract the data of interest in the right time range */
    113   for (j = 0; j < Nregion; j++) {
     121  for (j = 0; j < skylist[0].Nregions; j++) {
    114122
    115123    /* get file name and open */
    116     strcpy (filename, region[j].filename);
    117     catalog.filename = filename;
     124    catalog.filename = skylist[0].regions[j][0].filename;
    118125    switch (lock_catalog (&catalog, LCK_SOFT)) {
    119126    case 2:
    … …  
    210217  return (TRUE);
    211218}
    212 
    213 
    214 void copy_region (GSCRegion *in, GSCRegion *out) {
    215    
    216   out[0].RA[0]  = in[0].RA[0];
    217   out[0].RA[1]  = in[0].RA[1];
    218   out[0].DEC[0] = in[0].DEC[0];
    219   out[0].DEC[1] = in[0].DEC[1];
    220   strcpy (out[0].filename, in[0].filename);
    221 }
    222 

  • trunk/Ohana/src/opihi/dvo/init.c

    r5442 r5448  
    5353  {"addxtra",     addxtra,      "add extra data to object"},
    5454  {"getxtra",     getxtra,      "get extra data from object"},
     55  {"catalog",     catlog,       "plot catalog stars"},
    5556*/
    5657
    … …  
    6061  {"calextract",  calextract,   "extract photometry calibration"},
    6162  {"calmextract", calmextract,  "extract photometry calibration"},
    62   {"catalog",     catlog,       "plot catalog stars"},
    6363  {"ccd",         ccd,          "plot color-color diagram"},
    6464  {"cmatch",      cmatch,       "match two catalogs"},
    … …  
    9191  {"lightcurve",  lightcurve,   "extract lightcurve for a star"},
    9292  {"mextract",    mextract,     "extract measure data values"},
    93   {"pcat",        pcat,         "plot catalog boundaries"},
     93  {"pcat",        skycat,       "plot catalog boundaries"},
    9494  {"photcodes",   photcodes,    "list photometry codes"},
    9595  {"pmeasure",    pmeasure,     "plot individual measurements"},

  • trunk/Ohana/src/opihi/dvo/lcat.c

    r4689 r5448  
    55  double Radius;
    66  int i, N, Nregions, ShowAll;
    7   RegionFile *regions;
    87  char filename[128], exists;
    98  struct stat filestat;
    … …  
    1110  Graphdata graphmode;
    1211  int Ngraph;
     12  SkyTable *sky;
     13  SkyList *skylist;
    1314
    1415  Ngraph = 0;
    … …  
    1617
    1718  VarConfig ("CATDIR", "%s", catdir);
     19
     20  /* load sky from correct table */
     21  sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, -1, VERBOSE);
     22  SkyTableSetFilenames (sky, CATDIR, "cpt");
    1823
    1924  ShowAll = FALSE;
    … …  
    2833
    2934  Radius = MAX (fabs(graphmode.xmax), fabs(graphmode.ymax));
    30   regions = find_regions (graphmode.coords.crval1, graphmode.coords.crval2, Radius, &Nregions);
     35  skylist = SkyListByRadius (sky, -1, graphmode.coords.crval1, graphmode.coords.crval2, Radius);
    3136
    32   for (i = 0; i < Nregions; i++) {
    33     sprintf (filename, "%s/%s", catdir, regions[i].name);
     37  for (i = 0; i < skylist[0].Nregions; i++) {
    3438    exists = 'Y';
    35     if (stat (filename, &filestat) == -1) exists = 'N';
     39    if (stat (skylist[0].regions[i][0].filename, &filestat) == -1) exists = 'N';
    3640    if (ShowAll) {
    37       fprintf (stderr, "%3d %s  %c\n", i, regions[i].name, exists);
     41      fprintf (stderr, "%3d %s  %c\n", i, skylist[0].regions[i][0].name, exists);
    3842    } else {
    3943      if (exists == 'Y') {
    40         fprintf (stderr, "%3d %s\n", i, regions[i].name);
     44        fprintf (stderr, "%3d %s\n", i, skylist[0].regions[i][0].name);
    4145      }
    4246    }
    … …  
    4448
    4549  return (TRUE);
    46 
    47   free (regions);
    48 
     50  SkyListFree (regions);
    4951}
    5052

  • trunk/Ohana/src/opihi/dvo/lcurve.c

    r5320 r5448  
    88  int Ngraph, Xgraph, TimeFormat;
    99  int Nstars, found, AutoLimits, ErrorBars, GalMag, AbsPhot, SaveVectors;
    10   int i, j, m, N, NPTS, *N1, Nregions;
     10  int i, j, m, N, NPTS, *N1;
    1111  time_t TimeReference;
    1212  struct tm *timeptr;
    13   RegionFile *regions;
    1413  Vector *xvec, *yvec;
    1514  Vector Xvec, Yvec, dYvec;
    1615  Catalog catalog;
    1716  Graphdata graphmode;
     17  SkyTable *sky;
     18  SkyList *skylist;
    1819
    1920  VarConfig ("CATDIR", "%s", catdir);
    … …  
    6970  }
    7071 
     72  /* load sky from correct table */
     73  sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, -1, VERBOSE);
     74  SkyTableSetFilenames (sky, CATDIR, "cpt");
     75
    7176  Ra = atof (argv[1]);
    7277  Dec = atof (argv[2]);
    7378  Radius = atof (argv[3]);
    7479
    75   regions = find_regions (Ra, Dec, Radius, &Nregions);
    76 
    77   if (Nregions > 1) {
     80  skylist = SkyListByRadius (sky, -1, Ra, Dec, Radius);
     81
     82  if (skylist[0].Nregions > 1) {
    7883    fprintf (stderr, "warning, radius overlaps region boundary, not yet implemented\n");
    7984  }
    8085
    8186  /* set filename, read in header */
    82   sprintf (filename, "%s/%s", catdir, regions[0].name);
    83   catalog.filename = filename;
     87  catalog.filename = skylist[0].regions[0][0].filename;
    8488  switch (lock_catalog (&catalog, LCK_SOFT)) {
    8589  case 2:
    … …  
    198202  if (catalog.measure != 0) free (catalog.measure);
    199203 
     204  SkyListFree (skylist);
    200205  return (TRUE);
    201 
    202206}

  • trunk/Ohana/src/opihi/dvo/lightcurve.c

    r5320 r5448  
    77  float *RA, *DEC;
    88  int Nstars, found, PhotCodeSelect;
    9   int i, j, k, m, N, NPTS, Nsec, RELPHOT, *N1, Nregions, TimeFormat;
     9  int i, j, k, m, N, NPTS, Nsec, RELPHOT, *N1, TimeFormat;
    1010  time_t TimeReference;
    11   RegionFile *regions;
    1211  Vector *tvec, *mvec, *dmvec;
    1312  Catalog catalog;
    … …  
    5049  Radius = atof (argv[3]);
    5150
    52   regions = find_regions (Ra, Dec, Radius, &Nregions);
     51  sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, -1, VERBOSE);
     52  SkyTableSetFilenames (sky, CATDIR, "cpt");
     53  skylist = SkyListByRadius (sky, -1, Ra, Dec, Radius);
    5354
    54   if (Nregions > 1) {
     55  if (skylist[0].Nregions > 1) {
    5556    fprintf (stderr, "warning, radius overlaps region boundary, not yet implemented\n");
    5657  }
    5758
    5859  /* set filename, read in header */
    59   sprintf (filename, "%s/%s", catdir, regions[0].name);
    60   catalog.filename = filename;
     60  catalog.filename = skylist[0].regions[0][0].filename;
    6161  switch (lock_catalog (&catalog, LCK_SOFT)) {
    6262  case 2:
    … …  
    148148  if (catalog.secfilt != 0) free (catalog.secfilt);
    149149 
     150  SkyListFree (skylist);
    150151  return (TRUE);
    151 
    152152}

  • trunk/Ohana/src/opihi/dvo/pcat.c

    r5442 r5448  
    22int RD_to_XYpic (double *x, double *y, double r, double d, Coords *coords, double Rmin, double Rmax, double Rmid, int *leftside);
    33
     4// XXX EAM : this function is deprecated (now points at skycat)
    45int pcat (int argc, char **argv) {
    56 

  • trunk/Ohana/src/opihi/dvo/pmeasure.c

    r5320 r5448  
    55  FILE *f;
    66  int i, j, k, m, N;
    7   int InRegion, Nregions, Ngraph;
     7  int Ngraph;
    88  char filename[128], catdir[256];
    99  double Mz, Mr, mag;
    … …  
    1313  int PhotcodeClip;
    1414
     15  SkyTable *sky;
     16  SkyList *skylist;
    1517  Catalog catalog;
    16   RegionFile *regions;
    1718  Graphdata graphmode;
    1819  Vector Xvec, Yvec, Zvec;
    … …  
    2324  if (VarConfig ("CATDIR", "%s", catdir) == NULL) return (FALSE);
    2425
    25   regions = (RegionFile *) NULL;
    2626  f = (FILE *) NULL;
    2727  Mz = 17.0;
    … …  
    6868  }
    6969
    70   InRegion = FALSE;
    71   if ((N = get_argument (argc, argv, "-all"))) {
    72     remove_argument (N, &argc, argv);
    73     InRegion = TRUE;
    74   }
    75 
    76   if ((InRegion || (argc != 2)) && (!InRegion || (argc != 1))) {
    77     fprintf (stderr, "USAGE: catalog (filename / -all) [-m M M] [-n N N] [-g] [-a RA DEC MAG] \n");
     70  if (argc != 2) {
     71    fprintf (stderr, "USAGE: pmeasure (-all) [-m M M] [-p photcode] [-ID ID] [-flag value] [-x]\n");
    7872    return (FALSE);
    7973  }
    8074 
    81   if (InRegion) {
    82     Radius = MAX (fabs(graphmode.xmax), fabs(graphmode.ymax));
    83     regions = find_regions (graphmode.coords.crval1, graphmode.coords.crval2, Radius, &Nregions);
    84   } else {
    85     Nregions = 1;
    86   }
     75  Radius = MAX (fabs(graphmode.xmax), fabs(graphmode.ymax));
     76
     77  /* load sky from correct table */
     78  sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, -1, VERBOSE);
     79  SkyTableSetFilenames (sky, CATDIR, "cpt");
     80  skylist = SkyListByRadius (sky, -1, graphmode.coords.crval1, graphmode.coords.crval2, Radius);
    8781 
    88   for (j = 0; j < Nregions; j++) {
     82  for (j = 0; j < skylist[0].Nregions; j++) {
    8983    catalog.average = 0;
    9084   
    91     if (InRegion) {
    92       sprintf (filename, "%s/%s", catdir, regions[j].name);
    93     } else {
    94       sprintf (filename, "%s/%s", catdir, argv[1]);
    95     }
    96    
    9785    /* lock, load, unlock catalog */
    98     catalog.filename = filename;
     86    catalog.filename = skylist[0].regions[j][0].filename;
    9987    switch (lock_catalog (&catalog, LCK_SOFT)) {
    10088    case 2:

  • trunk/Ohana/src/opihi/dvo/region_list.c

    r4689 r5448  
    11# include "dvo1.h"
     2
     3/* XXX note : for RegionName or RegionList, we need to free the skylist
     4   elements, but not in the case of radius selection - this implies
     5   information carried back up */
    26
    37static int RegionSelect;
    … …  
    4246}
    4347
    44 RegionFile *SelectRegions (char *RegionName, char *RegionList, int *nregions) {
     48SkyList *SelectRegions (char *RegionName, char *RegionList) {
    4549
    4650  double Radius;
    4751  int Ngraph;
    4852  Graphdata graphsky;
    49   RegionFile *regions;
     53  SkyTable *sky;
     54  SkyList *skylist;
    5055
    5156  /* determine region-file names */
    5257  if (RegionName != NULL) {
    53     *nregions = 1;
    54     ALLOCATE (regions, RegionFile, 1);
    55     strcpy (regions[0].name, RegionName);
     58    ALLOCATE (skylist, SkyList, 1);
     59    ALLOCATE (skylist[0].regions[0], SkyRegion *, 1);
     60    ALLOCATE (skylist[0].regions[0][0], SkyRegion, 1);
     61    strcpy (skylist[0].regions[0][0].name, RegionName);
     62    sprintf (filename, "%s/%s.cpt", CATDIR, RegionName);
     63    skylist[0].regions[0][0].filename = strcreate (filename);
    5664    free (RegionName);
    5765    RegionName = NULL;
    58     return (regions);
     66    return (skylist);
    5967  }
    6068  if (RegionList != NULL) {
    61     regions = region_list (RegionList, nregions);
     69    skylist = SkyListLoadFile (RegionList);
    6270    free (RegionList);
    6371    RegionList = NULL;
    64     return (regions);
     72    return (skylist);
    6573  }
    6674
    … …  
    7280
    7381  Radius = MAX (fabs(graphsky.xmax), fabs(graphsky.ymax));
    74   regions = find_regions (graphsky.coords.crval1, graphsky.coords.crval2, Radius, nregions);
    75   return (regions);
     82
     83  /* load sky from correct table */
     84  sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, -1, VERBOSE);
     85  SkyTableSetFilenames (sky, CATDIR, "cpt");
     86  skylist = SkyListByRadius (sky, -1, graphmode.coords.crval1, graphmode.coords.crval2, Radius);
     87
     88  return (skylist);
    7689}
    7790
     91/* XXX EAM this should perhaps return a skytable? */
    7892/* returns a list of region files names from file */
    79 RegionFile *region_list (char *filename, int *Nregions) {
     93SkyList *SkyListFromFile (char *filename) {
    8094 
     95  FILE *f;
    8196  int NREGIONS, nregion;
    82   RegionFile *regions;
    83   FILE *f;
     97  SkyList *skylist;
     98
     99  ALLOCATE (skylist, SkyList, 1);
    84100
    85101  f = fopen (filename, "r");
    86102  if (f == NULL) {
    87103    fprintf (stderr, "ERROR: can't find region list file %s\n", filename);
    88     *Nregions = 0;
    89     return (NULL);
     104    skylist[0].Nregions = 0;
     105    skylist[0].regions = NULL;
     106    return (skylist);
    90107  }
    91108 
     109  Nregions = 0;
    92110  NREGIONS = 50;
    93   ALLOCATE (regions, RegionFile, NREGIONS);
    94   nregion = 0;
     111  ALLOCATE (skylist[0].regions, SkyRegion *, NREGIONS);
    95112
    96   while (fscanf (f, "%s", regions[nregion].name) != EOF) {
    97     nregion ++;
    98     if (nregion == NREGIONS) {
    99       NREGIONS += 50;
    100       REALLOCATE (regions, RegionFile, NREGIONS);
     113  while (fscanf (f, "%s", filename) != EOF) {
     114    ALLOCATE (skylist[0].regions[Nregions], SkyRegion, 1);
     115    strcpy (skylist[0].regions[Nregions][0].name, filename);
     116    sprintf (filename, "%s/%s.cpt", CATDIR, skylist[0].regions[Nregions][0].name);
     117    skylist[0].regions[Nregions][0].filename = strcreate (filename);
     118    Nregions ++;
     119    CHECK_REALLOCATE (skylist[0].regions, SkyRegion *, NREGIONS, Nregions, 50);
    101120    }
    102121  }

  • trunk/Ohana/src/opihi/dvo/subpix.c

    r5320 r5448  
    55int subpix (int argc, char **argv) {
    66 
    7   int i, j, I, Nlo, Nhi, Nentry, Nstars, Nregions, Nimage, Nmeasure;
     7  int i, j, I, Nlo, Nhi, Nentry, Nstars, Nimage, Nmeasure;
    88  int *index, *entry;
    99  int Nmin, Nsub, NSUB, status;
    … …  
    1717  Measure *measure;
    1818  Image *image;
    19   RegionFile *regions;
    2019  Catalog catalog;
    2120
    … …  
    3534  Radius = atof (argv[3]);
    3635
     36  /* load sky from correct table */
     37  sky = SkyTableLoadOptimal (CATDIR, SKY_TABLE, GSCFILE, -1, VERBOSE);
     38  SkyTableSetFilenames (sky, CATDIR, "cpt");
     39
    3740  /* load star nearest position */
    38   regions = find_regions (Ra, Dec, Radius, &Nregions);
    39   if (Nregions > 1) {
     41  skylist = SkyListByRadius (sky, -1, Ra, Dec, Radius);
     42  if (skylist[0].Nregions > 1) {
    4043    fprintf (stderr, "warning, radius overlaps region boundary, not yet implemented\n");
    4144  }
    4245
    4346  /* lock, load, unlock catalog */
    44   sprintf (filename, "%s/%s", catdir, regions[0].name);
    45   catalog.filename = filename;
     47  catalog.filename = skylist[0].regions[0][0].filename;
    4648  switch (lock_catalog (&catalog, LCK_SOFT)) {
    4749  case 2:
    … …  
    9294    if (catalog.average != 0) free (catalog.average);
    9395    if (catalog.measure != 0) free (catalog.measure);
    94     free (regions);
     96    SkyListFree (skylist);
    9597    return (TRUE);
    9698  }
    … …  
    158160  free (image);
    159161  free (index);
    160   free (regions);
     162  SkyListFree (regions);
    161163
    162164  return (TRUE);

  • trunk/Ohana/src/relphot/src/relphot.c

    r4864 r5448  
    1616
    1717  /* load regions and images based on seed region */
     18  // XXX EAM : load images and regions based on bounds, not name
    1819  region = load_images (&db, argv[1], &Ncatalog, &fullregion);
    1920
Note: See TracChangeset for help on using the changeset viewer.