IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 39308 for trunk


Ignore:
Timestamp:
Jan 13, 2016, 4:18:52 PM (11 years ago)
Author:
eugene
Message:

add options for image corners from imextract; fix save_complete to match basic save; fix HostTable check on file existence

Location:
trunk/Ohana/src/libdvo
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r39269 r39308  
    404404      IMAGE_Y_UL_FP,
    405405      IMAGE_Y_UR_FP,
     406      IMAGE_R_LL,
     407      IMAGE_R_LR,
     408      IMAGE_R_UL,
     409      IMAGE_R_UR,
     410      IMAGE_D_LL,
     411      IMAGE_D_LR,
     412      IMAGE_D_UL,
     413      IMAGE_D_UR,
    406414      IMAGE_X_ERR_SYS,
    407415      IMAGE_Y_ERR_SYS,

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

    r39293 r39308  
    6363
    6464  // can I access the file for read? (not backup, not readwrite, not verbose)
    65   int status = check_file_access (filename, FALSE, FALSE, FALSE);
    66   return status;
     65  if (!check_file_access (filename, FALSE, FALSE, FALSE)) {
     66    free (filename);
     67    return FALSE;
     68  }
     69
     70  /* check permission to read file */
     71  struct stat filestat;
     72
     73  int status = stat (filename, &filestat);
     74  if (status == 0) { /* file exists, are permissions OK? */
     75    uid_t uid = getuid();
     76    gid_t gid = getgid();
     77
     78    if (uid == filestat.st_uid) {
     79      if (filestat.st_mode & S_IRUSR) return TRUE;
     80    }
     81    if (gid == filestat.st_gid) {
     82      if (filestat.st_mode & S_IRGRP) return TRUE;
     83    }
     84    if (filestat.st_mode & S_IROTH) return TRUE;
     85  }
     86
     87  return FALSE;
    6788}
    6889

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

    r38986 r39308  
    348348      break;
    349349
     350    case IMAGE_R_LL:
     351    case IMAGE_D_LL:
     352      XY_to_RD (&x, &y, 0.0, 0.0, &image[N].coords);
     353      value.Flt = (field->ID == IMAGE_R_LL) ? x : y;
     354      break;
     355    case IMAGE_R_LR:
     356    case IMAGE_D_LR:
     357      XY_to_RD (&x, &y, image[N].NX, 0.0, &image[N].coords);
     358      value.Flt = (field->ID == IMAGE_R_LR) ? x : y;
     359      break;
     360    case IMAGE_R_UL:
     361    case IMAGE_D_UL:
     362      XY_to_RD (&x, &y, 0.0, image[N].NY, &image[N].coords);
     363      value.Flt = (field->ID == IMAGE_R_UL) ? x : y;
     364      break;
     365    case IMAGE_R_UR:
     366    case IMAGE_D_UR:
     367      XY_to_RD (&x, &y, image[N].NX, image[N].NY, &image[N].coords);
     368      value.Flt = (field->ID == IMAGE_R_UR) ? x : y;
     369      break;
     370
    350371    case IMAGE_X_ERR_SYS:
    351372      value.Flt = image[N].dXpixSys;

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

    r39269 r39308  
    867867  if (!strcasecmp (fieldName, "Y_UR_FP"  )) ESCAPE (IMAGE_Y_UR_FP,   OPIHI_FLT);
    868868
     869  if (!strcasecmp (fieldName, "R_LL"  )) ESCAPE (IMAGE_R_LL,   OPIHI_FLT);
     870  if (!strcasecmp (fieldName, "R_LR"  )) ESCAPE (IMAGE_R_LR,   OPIHI_FLT);
     871  if (!strcasecmp (fieldName, "R_UL"  )) ESCAPE (IMAGE_R_UL,   OPIHI_FLT);
     872  if (!strcasecmp (fieldName, "R_UR"  )) ESCAPE (IMAGE_R_UR,   OPIHI_FLT);
     873  if (!strcasecmp (fieldName, "D_LL"  )) ESCAPE (IMAGE_D_LL,   OPIHI_FLT);
     874  if (!strcasecmp (fieldName, "D_LR"  )) ESCAPE (IMAGE_D_LR,   OPIHI_FLT);
     875  if (!strcasecmp (fieldName, "D_UL"  )) ESCAPE (IMAGE_D_UL,   OPIHI_FLT);
     876  if (!strcasecmp (fieldName, "D_UR"  )) ESCAPE (IMAGE_D_UR,   OPIHI_FLT);
     877
    869878  if (!strcasecmp (fieldName, "dX_SYS"  )) ESCAPE (IMAGE_X_ERR_SYS,  OPIHI_FLT);
    870879  if (!strcasecmp (fieldName, "dY_SYS"  )) ESCAPE (IMAGE_Y_ERR_SYS,  OPIHI_FLT);

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

    r38986 r39308  
    815815
    816816/* save_catalog_split writes all data currently in memory to disk */
     817// this function cannot shrink the output file sizes
    817818int dvo_catalog_save_split (Catalog *catalog, char VERBOSE) {
    818819
    … …  
    862863  gfits_modify (&catalog[0].header, "NMEAS",     OFF_T_FMT, 1,  Nmeasure_disk_new);
    863864  gfits_modify (&catalog[0].header, "NMISS",     OFF_T_FMT, 1,  Nmissing_disk_new);
    864   gfits_modify (&catalog[0].header, "NSECFILT",  "%d",      1,  Nsecfilt);
     865  gfits_modify (&catalog[0].header, "NSECFILT",       "%d", 1,  Nsecfilt);
    865866  gfits_modify (&catalog[0].header, "NLENSING",  OFF_T_FMT, 1,  Nlensing_disk_new);
    866867  gfits_modify (&catalog[0].header, "NLENSOBJ",  OFF_T_FMT, 1,  Nlensobj_disk_new);
    867868  gfits_modify (&catalog[0].header, "NSTARPAR",  OFF_T_FMT, 1,  Nstarpar_disk_new);
    868   gfits_modify (&catalog[0].header, "NGALPHOT", OFF_T_FMT, 1,  Ngalphot_disk_new);
     869  gfits_modify (&catalog[0].header, "NGALPHOT",  OFF_T_FMT, 1,  Ngalphot_disk_new);
    869870
    870871  gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
    … …  
    956957    }
    957958    if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
    958 
    959959
    960960    gfits_free_header (&header);
    … …  
    14841484  int Nsecfilt;
    14851485  off_t Naverage_disk_new, Nmeasure_disk_new, Nmissing_disk_new, Nsecfilt_disk_new, Nlensing_disk_new, Nlensobj_disk_new, Nstarpar_disk_new, Ngalphot_disk_new;
    1486   off_t first, start, Nrows;
    14871486
    14881487  ftable.header = &header;
    … …  
    14911490  primary = NULL;
    14921491 
    1493   // skip empty catalogs: it is illegal to have Measures without corresponding Averages
     1492  // it is illegal to use this function in a partial load mode
    14941493  if (catalog[0].Naverage_off > 0) {
    14951494    fprintf (stderr, "ERROR: only partial catalog (Average) was loaded\n");
    … …  
    15251524  }
    15261525
     1526  // skip empty catalogs: it is illegal to have Measures without corresponding Averages
    15271527  Naverage_disk_new = catalog[0].Naverage;
    15281528  if (Naverage_disk_new == 0) {
    … …  
    15451545  }
    15461546
     1547  if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
     1548
    15471549  Nmeasure_disk_new = catalog[0].Nmeasure;
    15481550  Nmissing_disk_new = catalog[0].Nmissing;
    … …  
    15541556
    15551557  /* make sure header is consistent with data */
    1556   gfits_modify (&catalog[0].header, "NSTARS",   OFF_T_FMT, 1,  Naverage_disk_new);
    1557   gfits_modify (&catalog[0].header, "NMEAS",    OFF_T_FMT, 1,  Nmeasure_disk_new);
    1558   gfits_modify (&catalog[0].header, "NMISS",    OFF_T_FMT, 1,  Nmissing_disk_new);
    1559   gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
    1560   gfits_modify (&catalog[0].header, "NLENSING", OFF_T_FMT, 1,  Nlensing_disk_new);
    1561   gfits_modify (&catalog[0].header, "NLENSOBJ", OFF_T_FMT, 1,  Nlensobj_disk_new);
    1562   gfits_modify (&catalog[0].header, "NSTARPAR", OFF_T_FMT, 1,  Nstarpar_disk_new);
    1563   gfits_modify (&catalog[0].header, "NGALPHOT", OFF_T_FMT, 1, Ngalphot_disk_new);
     1558  gfits_modify (&catalog[0].header, "NSTARS",    OFF_T_FMT, 1,  Naverage_disk_new);
     1559  gfits_modify (&catalog[0].header, "NMEAS",     OFF_T_FMT, 1,  Nmeasure_disk_new);
     1560  gfits_modify (&catalog[0].header, "NMISS",     OFF_T_FMT, 1,  Nmissing_disk_new);
     1561  gfits_modify (&catalog[0].header, "NSECFILT",       "%d", 1,  Nsecfilt);
     1562  gfits_modify (&catalog[0].header, "NLENSING",  OFF_T_FMT, 1,  Nlensing_disk_new);
     1563  gfits_modify (&catalog[0].header, "NLENSOBJ",  OFF_T_FMT, 1,  Nlensobj_disk_new);
     1564  gfits_modify (&catalog[0].header, "NSTARPAR",  OFF_T_FMT, 1,  Nstarpar_disk_new);
     1565  gfits_modify (&catalog[0].header, "NGALPHOT",  OFF_T_FMT, 1,  Ngalphot_disk_new);
     1566
    15641567  gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
    15651568  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    15661569
    1567   /* in split mode, we can save only part of the data */
     1570  /* in split mode, we can save only part of the data, but not using this function (use e.g., dvo_catalog_update_split) */
     1571
     1572  if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
    15681573
    15691574  /*** Average Table ***/
    15701575  if ((catalog[0].catflags & DVO_LOAD_AVERAGE) && (catalog[0].average != NULL)) {
    15711576
    1572     first  = 0;                    // first row in memory to write
    1573     start  = catalog[0].Naverage_off; // first disk row to write
    1574     Nrows  = catalog[0].Naverage - first;
     1577    off_t first  = 0;                    // first row in memory to write
     1578    off_t start  = catalog[0].Naverage_off; // first disk row to write
     1579    off_t Nrows  = catalog[0].Naverage - first;
    15751580
    15761581    assert (Nrows >= 0);
    … …  
    15791584    assert (catalog[0].Naverage_disk >= catalog[0].Naverage_off);
    15801585
     1586    /* convert internal to external format : also results in a byte-swapped, scaled output
     1587       table.  Note that ftable is newly allocated.
     1588    */
     1589   
     1590    // if we are going to compress, we need to receive unswapped data --
     1591    int swapFromNative = !output_is_compressed (start, Nrows, Naverage_disk_new, catalog->catcompress);
     1592
    15811593    /* convert internal to external format */
    1582     if (!AverageToFtable (&ftable, &catalog[0].average[first], Nrows, catalog[0].catformat, primary, TRUE)) {
    1583       fprintf (stderr, "trouble converting format\n");
    1584       goto failure;
    1585     }
     1594    if (!AverageToFtable (&ftable, &catalog[0].average[first], Nrows, catalog[0].catformat, primary, swapFromNative)) {
     1595      fprintf (stderr, "trouble converting format\n");
     1596      goto failure;
     1597    }
     1598
     1599    if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
    15861600
    15871601    if (!dvo_catalog_save_subcat (catalog, &ftable, start, Nrows, catalog[0].Naverage_disk, Naverage_disk_new)) {
    … …  
    15891603      goto failure;
    15901604    }
     1605
     1606    if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
     1607
    15911608    gfits_free_header (&header);
    15921609    gfits_free_table (&ftable);
    … …  
    16021619      goto failure;
    16031620    }
    1604   }
     1621   }
    16051622
    16061623  /*** Measure Table ***/
    1607   if (catalog[0].measure != NULL) {
    1608 
    1609     first  = catalog[0].Nmeasure_disk - catalog[0].Nmeasure_off;  // first row in memory to write
    1610     start  = catalog[0].Nmeasure_disk; // first disk row to write
    1611     Nrows  = catalog[0].Nmeasure - first;
     1624  if ((catalog[0].catflags & DVO_LOAD_MEASURE) && (catalog[0].measure != NULL)) {
     1625
     1626    off_t first  = 0;                    // first row in memory to write
     1627    off_t start  = catalog[0].Nmeasure_off; // first disk row to write
     1628    off_t Nrows  = catalog[0].Nmeasure - first;
    16121629
    16131630    assert (Nrows >= 0);
    … …  
    16161633    assert (catalog[0].Nmeasure_disk >= catalog[0].Nmeasure_off);
    16171634
     1635    if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
     1636
     1637    // if we are going to compress, we need to receive unswapped data --
     1638    int swapFromNative = !output_is_compressed (start, Nrows, Nmeasure_disk_new, catalog->catcompress);
     1639
    16181640    // convert to external table format
    16191641    // XXX does catalog.measure have averef correctly set up?
    1620     if (!MeasureToFtable (&ftable, catalog[0].average, &catalog[0].measure[first], Nrows, catalog[0].catformat, TRUE)) {
    1621       fprintf (stderr, "trouble converting format\n");
    1622       goto failure;
    1623     }
     1642    if (!MeasureToFtable (&ftable, catalog[0].average, &catalog[0].measure[first], Nrows, catalog[0].catformat, swapFromNative)) {
     1643      fprintf (stderr, "trouble converting format\n");
     1644      goto failure;
     1645    }
     1646
     1647    if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
    16241648
    16251649    // write out Measure table
     1650    catalog->measure_catalog->catcompress = catalog->catcompress; // XXX this is a bit of a hack, should be done in an api
    16261651    if (!dvo_catalog_save_subcat (catalog[0].measure_catalog, &ftable, start, Nrows, catalog[0].Nmeasure_disk, Nmeasure_disk_new)) {
    16271652      fprintf (stderr, "trouble writing Measure table\n");
    16281653      goto failure;
    16291654    }
     1655    if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
     1656
    16301657    gfits_free_header (&header);
    16311658    gfits_free_table (&ftable);
    … …  
    16361663
    16371664  /*** Missing Table ***/
    1638 
    1639   if (catalog[0].missing != NULL) {
     1665  if ((catalog[0].catflags & DVO_LOAD_MISSING) && (catalog[0].missing != NULL)) {
    16401666
    16411667    if (catalog[0].Nmissing_off != 0) {
    … …  
    16441670    }
    16451671
     1672    // if we are going to compress, we need to receive unswapped data --
     1673    int swapFromNative = !output_is_compressed (catalog[0].Nmissing_off, catalog[0].Nmissing, Nmissing_disk_new, catalog->catcompress);
     1674
    16461675    // convert to external table format
    1647     if (!gfits_table_set_Missing (&ftable, catalog[0].missing, catalog[0].Nmissing, TRUE)) {
     1676    if (!gfits_table_set_Missing (&ftable, catalog[0].missing, catalog[0].Nmissing, swapFromNative)) {
    16481677      fprintf (stderr, "trouble converting format\n");
    16491678      goto failure;
    … …  
    16511680
    16521681    // write out Missing table (must write out entire table)
     1682    catalog->missing_catalog->catcompress = catalog->catcompress; // XXX this is a bit of a hack, should be done in an api
    16531683    if (!dvo_catalog_save_subcat (catalog[0].missing_catalog, &ftable, 0, catalog[0].Nmissing, catalog[0].Nmissing, catalog[0].Nmissing)) {
    16541684      fprintf (stderr, "trouble writing Missing Table\n");
    … …  
    16601690
    16611691  /*** Secfilt Table ***/
    1662   if (catalog[0].secfilt != NULL) {
    1663 
    1664     first  = catalog[0].Nsecfilt_disk - catalog[0].Nsecfilt_off;  // first row in memory to write
    1665     start  = catalog[0].Nsecfilt_disk; // first disk row to write
    1666     Nrows  = catalog[0].Nsecfilt_mem - first;
    1667 
    1668     assert (Nrows >= 0);
    1669     assert (first >= 0);
     1692  if ((catalog[0].catflags & DVO_LOAD_SECFILT) && (catalog[0].secfilt != NULL)) {
     1693
     1694    off_t first  = 0;                    // first row in memory to write
     1695    off_t start  = catalog[0].Nsecfilt_off; // first disk row to write
     1696    off_t Nitems = catalog[0].Naverage*Nsecfilt;
     1697    off_t Nrows  = Nitems - first;
     1698
     1699    assert (Nrows >= 0);
     1700    assert (first >= 0);
     1701    assert (first <= Nitems);
    16701702    assert (catalog[0].Nsecfilt_disk >= catalog[0].Nsecfilt_off);
     1703    // XXX check these for consistency...
     1704
     1705    // if we are going to compress, we need to receive unswapped data --
     1706    int swapFromNative = !output_is_compressed (start, Nrows, Nsecfilt_disk_new, catalog->catcompress);
     1707
     1708    if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
    16711709
    16721710    // convert to external table format
    1673     if (!SecFiltToFtable (&ftable, &secfilt[first], Nrows, catalog[0].catformat, TRUE)) {
    1674       fprintf (stderr, "trouble converting format\n");
    1675       goto failure;
    1676     }
     1711    if (!SecFiltToFtable (&ftable, &secfilt[first], Nrows, catalog[0].catformat, swapFromNative)) {
     1712      fprintf (stderr, "trouble converting format\n");
     1713      goto failure;
     1714    }
     1715
     1716    if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
    16771717
    16781718    // write out SecFilt table
     1719    catalog->secfilt_catalog->catcompress = catalog->catcompress; // XXX this is a bit of a hack, should be done in an api
    16791720    if (!dvo_catalog_save_subcat (catalog[0].secfilt_catalog, &ftable, start, Nrows, catalog[0].Nsecfilt_disk, Nsecfilt_disk_new)) {
    16801721      fprintf (stderr, "failure writing SecFilt table\n");
    … …  
    16861727
    16871728  /*** Lensing Table ***/
    1688   if (catalog[0].lensing != NULL) {
    1689 
    1690     first  = catalog[0].Nlensing_disk - catalog[0].Nlensing_off;  // first row in memory to write
    1691     start  = catalog[0].Nlensing_disk; // first disk row to write
    1692     Nrows  = catalog[0].Nlensing - first;
     1729  if ((catalog[0].catflags & DVO_LOAD_LENSING) && catalog[0].lensing && Nlensing_disk_new) {
     1730
     1731    off_t first  = 0;                    // first row in memory to write
     1732    off_t start  = catalog[0].Nlensing_off; // first disk row to write
     1733    off_t Nrows  = catalog[0].Nlensing - first;
    16931734
    16941735    assert (Nrows >= 0);
    … …  
    16971738    assert (catalog[0].Nlensing_disk >= catalog[0].Nlensing_off);
    16981739
     1740    // if we are going to compress, we need to receive unswapped data --
     1741    int swapFromNative = !output_is_compressed (start, Nrows, Nlensing_disk_new, catalog->catcompress);
     1742
    16991743    // convert to external table format
    1700     // XXX does catalog.lensing have averef correctly set up?
    1701     if (!LensingToFtable (&ftable, &catalog[0].lensing[first], Nrows, catalog[0].catformat, TRUE)) {
     1744    if (!LensingToFtable (&ftable, &catalog[0].lensing[first], Nrows, catalog[0].catformat, swapFromNative)) {
    17021745      fprintf (stderr, "trouble converting format\n");
    17031746      goto failure;
    … …  
    17051748
    17061749    // write out Lensing table
     1750    catalog->lensing_catalog->catcompress = catalog->catcompress; // XXX this is a bit of a hack, should be done in an api
    17071751    if (!dvo_catalog_save_subcat (catalog[0].lensing_catalog, &ftable, start, Nrows, catalog[0].Nlensing_disk, Nlensing_disk_new)) {
    17081752      fprintf (stderr, "trouble writing Lensing table\n");
    … …  
    17141758
    17151759  /*** Lensobj Table ***/
    1716   if (catalog[0].lensobj != NULL) {
    1717 
    1718     first  = catalog[0].Nlensobj_disk - catalog[0].Nlensobj_off;  // first row in memory to write
    1719     start  = catalog[0].Nlensobj_disk; // first disk row to write
    1720     Nrows  = catalog[0].Nlensobj - first;
     1760  if ((catalog[0].catflags & DVO_LOAD_LENSOBJ) && catalog[0].lensobj && Nlensobj_disk_new) {
     1761
     1762    off_t first  = 0;                    // first row in memory to write
     1763    off_t start  = catalog[0].Nlensobj_off; // first disk row to write
     1764    off_t Nrows  = catalog[0].Nlensobj - first;
    17211765
    17221766    assert (Nrows >= 0);
    … …  
    17251769    assert (catalog[0].Nlensobj_disk >= catalog[0].Nlensobj_off);
    17261770
     1771    // if we are going to compress, we need to receive unswapped data --
     1772    int swapFromNative = !output_is_compressed (start, Nrows, Nlensobj_disk_new, catalog->catcompress);
     1773
    17271774    // convert to external table format
    1728     // XXX does catalog.lensobj have averef correctly set up?
    1729     if (!LensobjToFtable (&ftable, &catalog[0].lensobj[first], Nrows, catalog[0].catformat, TRUE)) {
     1775    if (!LensobjToFtable (&ftable, &catalog[0].lensobj[first], Nrows, catalog[0].catformat, swapFromNative)) {
    17301776      fprintf (stderr, "trouble converting format\n");
    17311777      goto failure;
    … …  
    17331779
    17341780    // write out Lensobj table
     1781    catalog->lensobj_catalog->catcompress = catalog->catcompress; // XXX this is a bit of a hack, should be done in an api
    17351782    if (!dvo_catalog_save_subcat (catalog[0].lensobj_catalog, &ftable, start, Nrows, catalog[0].Nlensobj_disk, Nlensobj_disk_new)) {
    17361783      fprintf (stderr, "trouble writing Lensobj table\n");
    … …  
    17421789
    17431790  /*** StarPar Table ***/
    1744   if (catalog[0].starpar != NULL) {
    1745 
    1746     first  = catalog[0].Nstarpar_disk - catalog[0].Nstarpar_off;  // first row in memory to write
    1747     start  = catalog[0].Nstarpar_disk; // first disk row to write
    1748     Nrows  = catalog[0].Nstarpar - first;
     1791  if ((catalog[0].catflags & DVO_LOAD_STARPAR) && catalog[0].starpar && Nstarpar_disk_new) {
     1792
     1793    off_t first  = 0;                    // first row in memory to write
     1794    off_t start  = catalog[0].Nstarpar_off; // first disk row to write
     1795    off_t Nrows  = catalog[0].Nstarpar - first;
    17491796
    17501797    assert (Nrows >= 0);
    … …  
    17531800    assert (catalog[0].Nstarpar_disk >= catalog[0].Nstarpar_off);
    17541801
     1802    // if we are going to compress, we need to receive unswapped data --
     1803    int swapFromNative = !output_is_compressed (start, Nrows, Nstarpar_disk_new, catalog->catcompress);
     1804
    17551805    // convert to external table format
    1756     // XXX does catalog.starpar have averef correctly set up?
    1757     if (!StarParToFtable (&ftable, &catalog[0].starpar[first], Nrows, catalog[0].catformat, TRUE)) {
     1806    if (!StarParToFtable (&ftable, &catalog[0].starpar[first], Nrows, catalog[0].catformat, swapFromNative)) {
    17581807      fprintf (stderr, "trouble converting format\n");
    17591808      goto failure;
    … …  
    17611810
    17621811    // write out StarPar table
     1812    catalog->starpar_catalog->catcompress = catalog->catcompress; // XXX this is a bit of a hack, should be done in an api
    17631813    if (!dvo_catalog_save_subcat (catalog[0].starpar_catalog, &ftable, start, Nrows, catalog[0].Nstarpar_disk, Nstarpar_disk_new)) {
    17641814      fprintf (stderr, "trouble writing StarPar table\n");
    … …  
    17701820
    17711821  /*** GalPhot Table ***/
    1772   if (catalog[0].galphot != NULL) {
    1773 
    1774     first  = catalog[0].Ngalphot_disk - catalog[0].Ngalphot_off;  // first row in memory to write
    1775     start  = catalog[0].Ngalphot_disk; // first disk row to write
    1776     Nrows  = catalog[0].Ngalphot - first;
     1822  if ((catalog[0].catflags & DVO_LOAD_GALPHOT) && catalog[0].galphot && Ngalphot_disk_new) {
     1823
     1824    off_t first  = 0;                    // first row in memory to write
     1825    off_t start  = catalog[0].Ngalphot_off; // first disk row to write
     1826    off_t Nrows  = catalog[0].Ngalphot - first;
    17771827
    17781828    assert (Nrows >= 0);
    … …  
    17811831    assert (catalog[0].Ngalphot_disk >= catalog[0].Ngalphot_off);
    17821832
     1833    // if we are going to compress, we need to receive unswapped data --
     1834    int swapFromNative = !output_is_compressed (start, Nrows, Ngalphot_disk_new, catalog->catcompress);
     1835
    17831836    // convert to external table format
    1784     // XXX does catalog.galphot have averef correctly set up?
    1785     if (!GalPhotToFtable (&ftable, &catalog[0].galphot[first], Nrows, catalog[0].catformat, TRUE)) {
     1837    if (!GalPhotToFtable (&ftable, &catalog[0].galphot[first], Nrows, catalog[0].catformat, swapFromNative)) {
    17861838      fprintf (stderr, "trouble converting format\n");
    17871839      goto failure;
    … …  
    17891841
    17901842    // write out GalPhot table
     1843    catalog->galphot_catalog->catcompress = catalog->catcompress; // XXX this is a bit of a hack, should be done in an api
    17911844    if (!dvo_catalog_save_subcat (catalog[0].galphot_catalog, &ftable, start, Nrows, catalog[0].Ngalphot_disk, Ngalphot_disk_new)) {
    17921845      fprintf (stderr, "trouble writing GalPhot table\n");
    … …  
    18071860 failure:
    18081861  /* free temp storage */
     1862  gfits_free_header (&header);
     1863  gfits_free_table (&ftable);
    18091864  if (primary != NULL) {
    18101865    free (primary);
Note: See TracChangeset for help on using the changeset viewer.