IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 27435 for trunk/Ohana/src


Ignore:
Timestamp:
Mar 24, 2010, 11:22:25 AM (16 years ago)
Author:
eugene
Message:

large update merging in changes for Ohana to support large files

Location:
trunk/Ohana
Files:
8 deleted
410 edited
12 copied

Legend:

Unmodified
Added
Removed

  • trunk/Ohana

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

    r27392 r27435  
    4444
    4545typedef struct {
    46   int Nstars;
     46  unsigned int Nstars;
    4747  Stars *stars;
    48   int Nimages;
     48  off_t Nimages;
    4949  Image *images;
    5050  Coords *mosaic;
    … …  
    7676char   PASSWORD[80];
    7777char   HOSTNAME[80];
    78 int    NVALID, *VALID_IP;
     78int    NVALID_IP, *VALID_IP;
    7979char   SKY_TABLE[256];
    8080int    SKY_DEPTH;  /** XXX EAM : depth of catalog tables, fix usage */
    … …  
    152152AddstarClientOptions args         PROTO((int argc, char **argv, AddstarClientOptions options));
    153153
    154 void       AddToCalibration       PROTO((Average *average, SecFilt *secfilt, Measure *measure, Measure *new, int *next, int Nstar));
     154void       AddToCalibration       PROTO((Average *average, SecFilt *secfilt, Measure *measure, Measure *new, off_t *next, off_t Nstar));
    155155void       FindCalibration        PROTO((Image *image));
    156156FILE      *GetDB                  PROTO((int *state));
    157157void       InitCalibration        PROTO((int mode));
    158 void       SaveCalibration        PROTO((float Mo, float dMo, float Mr, float dMr, float Mi, int N));
     158void       SaveCalibration        PROTO((float Mo, float dMo, float Mr, float dMr, float Mi, off_t N));
    159159void       SetProtect             PROTO((int mode));
    160160int        SetSignals             PROTO((void));
    161 int        Shutdown               PROTO((char *message, ...));
     161int        Shutdown               PROTO((char *message, ...)) OHANA_FORMAT(printf, 1, 2);
    162162void       TrapSignal             PROTO((int sig));
    163163float      airmass                PROTO((float secz_image, double ra, double dec, double st, double latitude));
    … …  
    166166SkyTable  *SkyTableFromTychoIndex PROTO((char *filename, int VERBOSE));
    167167void       check_permissions      PROTO((char *basefile));
    168 int        dump_rawstars          PROTO((Stars *stars, int Nstars));
     168int        dump_rawstars          PROTO((Stars *stars, unsigned int Nstars));
    169169int        edge_check             PROTO((double *x1, double *y1, double *x2, double *y2));
    170 Image     *fakeimage              PROTO((char *rootname, int *Nimage, int photcode));
    171 
    172 int        find_matches           PROTO((SkyRegion *region, Stars *stars, int Nstars, Catalog *catalog, AddstarClientOptions options));
    173 int        find_matches_closest   PROTO((SkyRegion *region, Stars *stars, int Nstars, Catalog *catalog, AddstarClientOptions options));
    174 int        find_matches_refstars  PROTO((SkyRegion *region, Stars **stars, int Nstars, Catalog *catalog, AddstarClientOptions options));
    175 int        find_matches_closest_refstars  PROTO((SkyRegion *region, Stars **stars, int Nstars, Catalog *catalog, AddstarClientOptions options));
    176 
    177 Stars    **find_subset            PROTO((SkyRegion *region, Stars *stars, int Nstars, int *NSTARS));
     170Image     *fakeimage              PROTO((char *rootname, off_t *Nimage, int photcode));
     171
     172int        find_matches                  PROTO((SkyRegion *region, Stars *stars,  unsigned int Nstars, Catalog *catalog, AddstarClientOptions options));
     173int        find_matches_closest          PROTO((SkyRegion *region, Stars *stars,  unsigned int Nstars, Catalog *catalog, AddstarClientOptions options));
     174int        find_matches_refstars         PROTO((SkyRegion *region, Stars **stars, unsigned int Nstars, Catalog *catalog, AddstarClientOptions options));
     175int        find_matches_closest_refstars PROTO((SkyRegion *region, Stars **stars, unsigned int Nstars, Catalog *catalog, AddstarClientOptions options));
     176
     177Stars    **find_subset            PROTO((SkyRegion *region, Stars *stars, unsigned int Nstars, unsigned int *NSTARS));
    178178int        gcatalog               PROTO((Catalog *catalog));
    179 Stars     *get2mass               PROTO((SkyRegion *patch, int photcode, int mode, int *NSTARS));
     179Stars     *get2mass               PROTO((SkyRegion *patch, int photcode, int mode, unsigned int *NSTARS));
    180180double     get_subpix             PROTO((double x, double y));
    181181
    182 Stars     *greference             PROTO((char *Refcat, SkyRegion *catstats, int photcode, int *nstars));
    183 Stars     *getgsc                 PROTO((SkyRegion *patch, int *NSTARS));
    184 Stars     *gettycho               PROTO((SkyRegion *catstats, int photcode, int *Nstars));
    185 Stars     *getusno                PROTO((SkyRegion *catstats, int photcode, int *Nstars));
    186 Stars     *getusnob               PROTO((SkyRegion *catstats, int photcode, int *Nstars));
     182Stars     *greference             PROTO((char *Refcat, SkyRegion *catstats, int photcode, unsigned int *nstars));
     183Stars     *getgsc                 PROTO((SkyRegion *patch, unsigned int *NSTARS));
     184Stars     *gettycho               PROTO((SkyRegion *catstats, int photcode, unsigned int *Nstars));
     185Stars     *getusno                PROTO((SkyRegion *catstats, int photcode, unsigned int *Nstars));
     186Stars     *getusnob               PROTO((SkyRegion *catstats, int photcode, unsigned int *Nstars));
    187187
    188188// load text-based stars (REF only in the sense of REF photcodes)
    189 Stars     *grefstars              PROTO((char *file, int photcode, int *Nstars));
    190 
    191 Stars     *LoadStars              PROTO((char *file, int *Nstars, Image **images, int *Nimages, AddstarClientOptions *options));
     189Stars     *grefstars              PROTO((char *file, int photcode, unsigned int *Nstars));
     190
     191Stars     *LoadStars              PROTO((char *file, unsigned int *Nstars, Image **images, off_t *Nimages, AddstarClientOptions *options));
    192192Header   **LoadHeaders            PROTO((FILE *f, int *mode, int *Nheader));
    193 HeaderSet *MatchHeaders           PROTO((int **extsize, int *nimage, int mode, Header **headers, int Nheaders));
    194 int        LoadData               PROTO((FILE *f, char *file, Image **images, int *nvalid, Stars **stars, int *Nstars, Header **headers, int *extsize, HeaderSet *headerSets, int NheaderSets, AddstarClientOptions *options));
    195 int        GetZeroPointExposure   PROTO((Header **headers, HeaderSet *headerSets, int Nimages));
     193HeaderSet *MatchHeaders           PROTO((off_t **extsize, off_t *nimage, int mode, Header **headers, int Nheaders));
     194int        LoadData               PROTO((FILE *f, char *file, Image **images, off_t *nvalid, Stars **stars, unsigned int *Nstars, Header **headers, off_t *extsize, HeaderSet *headerSets, int NheaderSets, AddstarClientOptions *options));
     195int        GetZeroPointExposure   PROTO((Header **headers, HeaderSet *headerSets, off_t Nimages));
    196196
    197197int        in_image               PROTO((double r, double d, Image *image));
    … …  
    200200void       lock_image_db          PROTO((FITS_DB *db, char *filename));
    201201int        main                   PROTO((int argc, char **argv));
    202 void       make_backup            PROTO((char *filename));
    203 int        match_refstars         PROTO((Stars *stars, int Nstars));
    204 void       mkcatalog              PROTO((SkyRegion *region, Catalog *catalog));
    205202double     opening_angle          PROTO((double x1, double y1, double x2, double y2, double x3, double y3));
    206203int        parse_time             PROTO((Header *header));
    207 Stars     *rd_gsc                 PROTO((char *filename, int *nstars));
     204Stars     *rd_gsc                 PROTO((char *filename, unsigned int *nstars));
    208205int        replace_match          PROTO((Average *average, Measure *measure, Stars *star));
    209206void       resort_catalog         PROTO((Catalog *catalog));
    210 Stars     *rfits                  PROTO((FILE *f, unsigned int *nstars));
    211 Stars     *rtext                  PROTO((FILE *f, unsigned int *nstars));
    212207Stars     *ReadStarsFITS          PROTO((FILE *f, Header *header, Header *in_theader, unsigned int *nstars));
    213208Stars     *ReadStarsTEXT          PROTO((FILE *f, unsigned int *nstars));
    214 Stars     *ReadStarsSDSS          PROTO((FILE *f, char *name, Header *header, Header *in_theader, Image *images, int *nimages, unsigned int *nstars));
     209Stars     *ReadStarsSDSS          PROTO((FILE *f, char *name, Header *header, Header *in_theader, Image *images, off_t *nimages, unsigned int *nstars));
    215210int        ReadImageHeader        PROTO((Header *header, Image *image, int photcode));
    216211Stars     *FilterStars            PROTO((Stars *instars, Image *image, unsigned int imageID));
    217 Stars     *MergeStars             PROTO((Stars *stars, int *Nstars, Stars *instars, int Ninstars));
    218 void       save_pt_catalog        PROTO((Catalog *catalog));  /*** choose new name ***/
     212Stars     *MergeStars             PROTO((Stars *stars, unsigned int *Nstars, Stars *instars, unsigned int Ninstars));
    219213double     scat_subpix            PROTO((double x, double y));
    220 time_t     short_date_to_sec      PROTO((char *date));
    221 void       sort_lists             PROTO((float *X, float *Y, int *S, int N));
    222 void       sort_stars             PROTO((Stars *stars, int N));
    223 int        str_to_radec           PROTO((double *ra, double *dec, char *str1, char *str2));
    224 void       unlock_image_db        PROTO((FITS_DB *db));
    225 void       update_coords          PROTO((Average *average, Measure *measure, int *next));
    226 void       wcatalog               PROTO((Catalog *catalog));
    227 void       free_catalog           PROTO((Catalog *catalog));
    228 void       wimage                 PROTO((FITS_DB *db, Image *image));
    229 void       create_image_db        PROTO((FITS_DB *db));
    230 void       set_db                 PROTO((FITS_DB *in));
    231 void       uppercase              PROTO((char *string));
    232 void       fsort                  PROTO((float *X, int N));
    233 void       fsort2                 PROTO((float *X, float *Y, int N));
    234 int       *init_measure_links     PROTO((Average *average, int Naverage, Measure *measure, int Nmeasure));
    235 int       *init_missing_links     PROTO((Average *average, int Naverage, Missing *missing, int Nmissing));
    236 int        add_meas_link          PROTO((Average *average, int *next, int Nmeasure, int NMEASURE));
    237 int        add_miss_link          PROTO((Average *average, int *next, int Nmissing));
    238 int       *build_measure_links    PROTO((Average *average, int Naverage, Measure *measure, int Nmeasure));
    239 Measure   *sort_measure           PROTO((Average *average, int Naverage, Measure *measure, int Nmeasure, int *next));
    240 Missing   *sort_missing           PROTO((Average *average, int Naverage, Missing *missing, int Nmissing, int *next_miss));
    241 int        ImageOptions           PROTO((AddstarClientOptions *options, Image *images, int Nimages));
     214void       update_coords          PROTO((Average *average, Measure *measure, off_t *next));
     215off_t     *init_measure_links     PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure));
     216off_t     *init_missing_links     PROTO((Average *average, off_t Naverage, Missing *missing, off_t Nmissing));
     217off_t      add_meas_link          PROTO((Average *average, off_t *next_meas, off_t Nmeasure, off_t NMEASURE));
     218off_t      add_miss_link          PROTO((Average *average, off_t *next_miss, off_t Nmissing));
     219off_t     *build_measure_links    PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure));
     220Measure   *sort_measure           PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure, off_t *next_meas));
     221Missing   *sort_missing           PROTO((Average *average, off_t Naverage, Missing *missing, off_t Nmissing, off_t *next_miss));
     222int        ImageOptions           PROTO((AddstarClientOptions *options, Image *images, off_t Nimages));
    242223int        GetFileMode            PROTO((Header *header));
    243224AddstarClientOptions args_client  PROTO((int argc, char **argv, AddstarClientOptions options));
    … …  
    252233int        WaitServerSocket       PROTO((int InitSocket, SockAddress *Address, int *validIP, int Nvalid));
    253234int        GetClientSocket        PROTO((char *hostname));
    254 int        UpdateDatabase_Image   PROTO((AddstarClientOptions *options, Image *images, int Nimages, Coords *mosaic, Stars *stars, int Nstars));
    255 int        UpdateDatabase_Reflist PROTO((AddstarClientOptions *options, Stars *stars, int Nstars));
     235int        UpdateDatabase_Image   PROTO((AddstarClientOptions *options, Image *images, off_t Nimages, Coords *mosaic, Stars *stars, unsigned int Nstars));
     236int        UpdateDatabase_Reflist PROTO((AddstarClientOptions *options, Stars *stars, unsigned int Nstars));
    256237int        UpdateDatabase_Refcat  PROTO((AddstarClientOptions *options, SkyRegion *UserPatch, char *refcat));
    257 SkyList   *SkyListForStars        PROTO((SkyTable *table, int depth, Stars *stars, int Nstars));
     238SkyList   *SkyListForStars        PROTO((SkyTable *table, int depth, Stars *stars, unsigned int Nstars));
    258239SkyList   *SkyListExistingSubset  PROTO((SkyList *input, char *path));
    259240int        SkyListSetPath         PROTO((SkyList *list, char *path));
    … …  
    266247int        NewReflist_Thread      PROTO((int BindSocket));
    267248
    268 Stars     *Convert_SMPDATA        PROTO((FTable *table, int *nstars));
    269 Stars     *Convert_PS1_DEV_0      PROTO((FTable *table, int *nstars));
    270 Stars     *Convert_PS1_DEV_1      PROTO((FTable *table, int *nstars));
    271 Stars     *Convert_PS1_V1         PROTO((FTable *table, int *nstars));
    272 Stars     *Convert_PS1_V1_Alt     PROTO((FTable *table, int *nstars));
    273 Stars     *Convert_PS1_V2         PROTO((FTable *table, int *nstars));
     249Stars     *Convert_SMPDATA        PROTO((FTable *table, unsigned int *nstars));
     250Stars     *Convert_PS1_DEV_0      PROTO((FTable *table, unsigned int *nstars));
     251Stars     *Convert_PS1_DEV_1      PROTO((FTable *table, unsigned int *nstars));
     252Stars     *Convert_PS1_V1         PROTO((FTable *table, unsigned int *nstars));
     253Stars     *Convert_PS1_V1_Alt     PROTO((FTable *table, unsigned int *nstars));
     254Stars     *Convert_PS1_V2         PROTO((FTable *table, unsigned int *nstars));
    274255
    275256int        InitStar               PROTO((Stars *star));
    … …  
    279260int args_skycells (int argc, char **argv);
    280261int ConfigInit_skycells (int *argc, char **argv);
    281 int UpdateImageIDs (Stars *stars, int Nstars, Image *images, int Nimages);
    282 int LoadDataSDSS (FILE *f, char *file, Image **images, int *nvalid, Stars **stars, int *Nstars, Header **headers, int *extsize, HeaderSet *headerSets, int Nimages);
    283 int altaz (double *alt, double *az, double ha, double dec, double latitude);
    284 
    285 int LoadDataPMM (FILE *f, char *file, Image **images, int *nvalid, Stars **stars, int *Nstars);
     262int UpdateImageIDs (Stars *stars, unsigned int Nstars, Image *images, off_t Nimages);
     263
     264int LoadDataSDSS (FILE *f, char *file, Image **images, off_t *nvalid, Stars **stars, unsigned int *Nstars, Header **headers, off_t *extsize, HeaderSet *headerSets, off_t Nimages);
     265int LoadDataPMM (FILE *f, char *file, Image **images, off_t *nvalid, Stars **stars, unsigned int *Nstars);
     266
    286267PhotCode *LoadMetadataPMM (char *datafile, Image *image);
    287268time_t pmm_date_to_sec (char *date, char *time);
    … …  
    293274uint64_t CreatePSPSDetectionID(double tobs, int ccdid, int detID);
    294275uint64_t CreatePSPSObjectID(double ra, double dec);
     276
     277int altaz (double *alt, double *az, double ha, double dec, double latitude);
    295278
    296279// this is a gnu extension?? caution!

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

    r23914 r27435  
    7878void         SetProtect                     PROTO((int mode));
    7979int          SetSignals                     PROTO((void));
    80 int          Shutdown                       PROTO((char *message, ...); )
     80int          Shutdown                       PROTO((char *message, ...)) OHANA_FORMAT(printf, 1, 2);
    8181void         TrapSignal                     PROTO((int sig));
    8282

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

    r25757 r27435  
    130130  /* load valid ip list */
    131131  {
    132     int i, Nvalid, ip1, ip2, ip3, ip4, test, status;
     132    int i, Nvalid_IP, ip1, ip2, ip3, ip4, test, status;
    133133    char string[80];
    134134
    135     Nvalid = 0;
    136     NVALID = 10;
    137     ALLOCATE (VALID_IP, int, NVALID);
     135    Nvalid_IP = 0;
     136    NVALID_IP = 10;
     137    ALLOCATE (VALID_IP, int, NVALID_IP);
    138138    for (i = 0; ScanConfig (config, "VALID_IP", "%s", i, string) != NULL; i++) {
    139139      status = sscanf (string, "%d.%d.%d.%d", &ip1, &ip2, &ip3, &ip4);
    … …  
    148148        exit (2);
    149149      }
    150       VALID_IP[Nvalid] = ip1 | (ip2 << 8) | (ip3 << 16) | (ip4 << 24);
    151       Nvalid ++;
    152       CHECK_REALLOCATE (VALID_IP, int, NVALID, Nvalid, 10);
    153     }
    154     NVALID = Nvalid;
    155     REALLOCATE (VALID_IP, int, NVALID);
    156     if (NVALID == 0) {
     150      VALID_IP[Nvalid_IP] = ip1 | (ip2 << 8) | (ip3 << 16) | (ip4 << 24);
     151      Nvalid_IP ++;
     152      CHECK_REALLOCATE (VALID_IP, int, NVALID_IP, Nvalid_IP, 10);
     153    }
     154    NVALID_IP = Nvalid_IP;
     155    REALLOCATE (VALID_IP, int, NVALID_IP);
     156    if (NVALID_IP == 0) {
    157157      free (VALID_IP);
    158158      VALID_IP = NULL;
    … …  
    172172  } else {
    173173    options.radius = atof (RadiusWord);
     174    if (options.radius < 1e-6) {
     175      fprintf (stderr, "non-sensical correlation radius %f\n", options.radius);
     176      exit (1);
     177    }
    174178  }
    175179

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

    r26384 r27435  
    109109}
    110110
    111 Stars *MergeStars (Stars *stars, int *Nstars, Stars *instars, int Ninstars) {
     111Stars *MergeStars (Stars *stars, unsigned int *Nstars, Stars *instars, unsigned int Ninstars) {
    112112
    113113  int i, j;

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

    r21508 r27435  
    44int GetFileMode (Header *header) {
    55
    6   char ctype[80];
     6  char ctype[80], ctmp;
    77  int Naxis;
    88  int simple, extend, haveNaxis, haveCTYPE;
    9   int tmp, havePHOT_VER, haveTARG_VER;
     9  int havePHOT_VER, haveTARG_VER;
    1010
    11   gfits_scan (header, "SIMPLE", "%t", 1, &simple);
     11  gfits_scan_alt (header, "SIMPLE", "%t", 1, &simple);
    1212  haveNaxis = gfits_scan (header, "NAXIS",  "%d", 1, &Naxis);
    1313  haveCTYPE = gfits_scan (header, "CTYPE1", "%s", 1, ctype);
    1414
    15   gfits_scan (header, "EXTEND", "%t", 1, &extend);
     15  gfits_scan_alt (header, "EXTEND", "%t", 1, &extend);
    1616   
    1717  // SDSS tsObj files have a version number for the PHOTO and
    1818  // TS (target selection) pipelines present as header keywords
    19   havePHOT_VER = gfits_scan (header, "PHOT_VER", "%s", 1, &tmp);
    20   haveTARG_VER = gfits_scan (header, "TARG_VER", "%s", 1, &tmp);
     19  havePHOT_VER = gfits_scan (header, "PHOT_VER", "%s", 1, &ctmp);
     20  haveTARG_VER = gfits_scan (header, "TARG_VER", "%s", 1, &ctmp);
    2121  if (havePHOT_VER && haveTARG_VER) return SDSS_OBJ;
    2222

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

    r25908 r27435  
    2121// offset in ReadImageHeader based on the per-chip zero points in the photcode database
    2222
    23 int GetZeroPointExposure (Header **headers, HeaderSet *headerSets, int Nimages) {
     23int GetZeroPointExposure (Header **headers, HeaderSet *headerSets, off_t Nimages) {
    2424
    2525    // the zero point correction is not applied
    … …  
    3737    // the zero point correction is measured here and applied in ReadImageHeader
    3838    if (!strcasecmp(ZERO_POINT_OPTION, "CHIP_AVERAGE")) {
     39
    3940        int i, Nzpt, Nmid, Nhead;
    4041        float *zpt, ZPT_OBS;

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

    r16810 r27435  
    22
    33/* set specific options based on the image collection */
    4 int ImageOptions (AddstarClientOptions *options, Image *images, int Nimages) {
     4int ImageOptions (AddstarClientOptions *options, Image *images, off_t Nimages) {
    55
    6   int i, equivPhotcode, consistent;
     6  off_t i;
     7  int equivPhotcode, consistent;
    78  float maxError;
    89  PhotCode *photcode;

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

    r6674 r27435  
    1414
    1515    /* wait for clients to make connection */
    16     BindSocket = WaitServerSocket (InitSocket, &Address, VALID_IP, NVALID);
     16    BindSocket = WaitServerSocket (InitSocket, &Address, VALID_IP, NVALID_IP);
    1717    if (BindSocket == -1) continue;
    1818

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

    r26390 r27435  
    66
    77// examine the header sets and set the Image entries for the the valid images
    8 int LoadData (FILE *f, char *file, Image **images, int *nvalid, Stars **stars, int *Nstars, Header **headers, int *extsize, HeaderSet *headerSets, int Nimages, AddstarClientOptions *options) {
     8int LoadData (FILE *f, char *file, Image **images, off_t *nvalid, Stars **stars, unsigned int *Nstars, Header **headers, off_t *extsize, HeaderSet *headerSets, int Nimages, AddstarClientOptions *options) {
    99
    1010  char *name;
    11   int i, j, Nvalid, Nhead, Ndata, Nskip;
     11  off_t Nskip, Nvalid, NVALID;
     12  int i, j, Nhead, Ndata;
    1213  uint32_t parentID = UINT32_MAX;
    1314  Stars *inStars;
    … …  
    7677      Nskip += extsize[j];
    7778    }
    78     fseek (f, Nskip, SEEK_SET);
     79    fseeko (f, Nskip, SEEK_SET);
    7980         
    8081    inStars = ReadStarsFITS (f, headers[Nhead], headers[Ndata], &images[0][Nvalid].nstar);

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

    r21508 r27435  
    1616# define MAG_INDEX_ASC 22
    1717
    18 int LoadDataPMM (FILE *f, char *file, Image **images, int *nvalid, Stars **stars, int *Nstars) {
    19 
     18int LoadDataPMM (FILE *f, char *file, Image **images, off_t *nvalid, Stars **stars, unsigned int *Nstars) {
     19
     20  off_t Nvalid, NVALID;
    2021  char *name, *buffer;
    21   int i, fd, Nbyte, Nline, Nvalid, code;
     22  int i, fd, Nbyte, Nline, code;
    2223  double ra, dec, mag, airmass, az, ZeroPoint, ZeroPt;
    2324  unsigned int Ninstars, NINSTARS;

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

    r16967 r27435  
    44// there should only be a single data set (phu + table) in this file
    55// each SDSS data set corresponds to 5 images (ugriz)
    6 int LoadDataSDSS (FILE *f, char *file, Image **images, int *nvalid, Stars **stars, int *Nstars, Header **headers, int *extsize, HeaderSet *headerSets, int Nimages) {
     6int LoadDataSDSS (FILE *f, char *file, Image **images, off_t *nvalid, Stars **stars, unsigned int *Nstars, Header **headers, off_t *extsize, HeaderSet *headerSets, off_t Nimages) {
    77
     8  off_t Nskip, Nvalid, NVALID;
    89  char *name;
    9   int j, Nvalid, Nhead, Ndata, Nskip;
     10  int j, Nhead, Ndata;
    1011  unsigned int Ninstars;
    1112  Stars *inStars;
    … …  
    3637    Nskip += extsize[j];
    3738  }
    38   fseek (f, Nskip, SEEK_SET);
     39  fseeko (f, Nskip, SEEK_SET);
    3940         
    4041  // XXX I think this is an error?  should this be &images[0][Nvalid] ??

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

    r16810 r27435  
    44Header **LoadHeaders (FILE *f, int *mode, int *Nheaders) {
    55
    6   int i, status, Nskip, NHEADERS;
     6  off_t Nskip;
     7  int i, status, NHEADERS;
    78  Header **headers;
    89
    … …  
    3132    // advance to the next header
    3233    Nskip = gfits_data_size (headers[i]);
    33     fseek (f, Nskip, SEEK_CUR);
     34    fseeko (f, Nskip, SEEK_CUR);
    3435    if (i == NHEADERS - 1) {
    3536      NHEADERS += 10;

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

    r26286 r27435  
    11# include "addstar.h"
    22
    3 Stars *LoadStars (char *filename, int *Nstars, Image **images, int *Nimages, AddstarClientOptions *options) {
     3Stars *LoadStars (char *filename, unsigned int *Nstars, Image **images, off_t *Nimages, AddstarClientOptions *options) {
    44
    5   int i, Nfile, NFILE, Nheaders, NheaderSets, mode, *extsize;
     5  off_t *extsize, NheaderSets;
     6  int i, Nfile, NFILE, Nheaders, mode;
    67  char **file, line[1024];
    78  FILE *f;
    … …  
    8081      continue;
    8182    }
    82     if (VERBOSE) fprintf (stderr, "file %s has %d headers, including %d images\n", file[i], Nheaders, NheaderSets);
     83    if (VERBOSE) fprintf (stderr, "file %s has %d headers, including %lld images\n", file[i], Nheaders, (long long) NheaderSets);
    8384
    8485    /* supplied photcode is incompatible with multi-chip images */

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

    r26258 r27435  
    33// XXX largely psphot specific
    44
    5 HeaderSet *MatchHeaders (int **extsize, int *nimage, int mode, Header **headers, int Nheaders) {
     5HeaderSet *MatchHeaders (off_t **extsize, off_t *nimage, int mode, Header **headers, int Nheaders) {
    66
    77  int i, j, Nimage, NIMAGE;
    … …  
    99  HeaderSet *headerSets;
    1010
    11   ALLOCATE (extsize[0], int, Nheaders);
     11  ALLOCATE (extsize[0], off_t, Nheaders);
    1212
    1313  Nimage = 0;
    … …  
    3434    headerSets[0].extnum_head = 0;
    3535    headerSets[0].extnum_data = 1;
    36     extsize[0][0] = headers[0][0].size;
     36    extsize[0][0] = headers[0][0].datasize;
    3737    *nimage = 1;
    3838    return headerSets;
    … …  
    4242  for (i = 0; i < Nheaders; i++) {
    4343    if (mode == SIMPLE_CMP) {
    44       extsize[0][i] = headers[i][0].size;
     44      extsize[0][i] = headers[i][0].datasize;
    4545    } else {
    46       extsize[0][i] = headers[i][0].size + gfits_data_size (headers[i]);
     46      extsize[0][i] = headers[i][0].datasize + gfits_data_size (headers[i]);
    4747    }
    4848
    … …  
    9292  // extension matched to the header in the PHU
    9393  if (Nimage == 0) {
    94     extsize[0][0] = headers[0][0].size + gfits_data_size (headers[0]);
    95     extsize[0][1] = headers[1][0].size + gfits_data_size (headers[1]);
     94    extsize[0][0] = headers[0][0].datasize + gfits_data_size (headers[0]);
     95    extsize[0][1] = headers[1][0].datasize + gfits_data_size (headers[1]);
    9696    gfits_scan (headers[1], ExtnameKeyword, "%s", 1, extname);
    9797    if (!strcmp (extname, "SMPFILE")) {

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

    r27369 r27435  
    181181    // RULE: ccdnum is the value of the first string of digits in CCDNumKeyword
    182182    // For example: ccdnum(XY42.hdr) = 42, ccdnum(XY01.hdr) = 1
     183    // if no digits occur, then we assume there is only one ccd
    183184    char *p = ccdnum;
    184185    // get rid of any leading non-digit characters
    185186    while (*p && !isdigit(*p)) p++;
    186187    if (*p) {
    187         image[0].ccdnum = atoi(p);
     188      image[0].ccdnum = atoi(p);
    188189    } else {
    189         image[0].ccdnum = 0;
     190      image[0].ccdnum = 0;
    190191    }
    191192  }

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

    r24400 r27435  
    55Stars *ReadStarsFITS (FILE *f, Header *header, Header *in_theader, unsigned int *nstars) {
    66
    7   int Nskip, Nstars;
     7  off_t Nskip;
     8  unsigned int Nstars;
    89  char type[80];
    910  Header theader;
    … …  
    1617  } else {
    1718    table.header = in_theader;
    18     Nskip = in_theader[0].size;
    19     fseek (f, Nskip, SEEK_CUR);
     19    Nskip = in_theader[0].datasize;
     20    fseeko (f, Nskip, SEEK_CUR);
    2021  }
    2122
    … …  
    5758}
    5859
    59 Stars *Convert_SMPDATA (FTable *table, int *nstars) {
    60 
    61   int i, Nstars, swapped;
     60Stars *Convert_SMPDATA (FTable *table, unsigned int *nstars) {
     61
     62  off_t Nstars;
     63  unsigned int i;
     64  char swapped;
    6265  double ZeroPt;
    6366  Stars *stars = NULL;
    … …  
    9699}
    97100
    98 Stars *Convert_PS1_DEV_0 (FTable *table, int *nstars) {
    99 
    100   int i, Nstars;
     101Stars *Convert_PS1_DEV_0 (FTable *table, unsigned int *nstars) {
     102
     103  off_t Nstars;
     104  unsigned int i;
    101105  double ZeroPt;
    102106  Stars *stars;
    … …  
    140144// XXX I need to make the IPP I/O functions and these functions
    141145// consistent wrt ZERO_POINT....
    142 Stars *Convert_PS1_DEV_1 (FTable *table, int *nstars) {
    143 
    144   int i, Nstars;
     146Stars *Convert_PS1_DEV_1 (FTable *table, unsigned int *nstars) {
     147
     148  off_t Nstars;
     149  unsigned int i;
    145150  double ZeroPt;
    146151  Stars *stars;
    … …  
    185190}
    186191
    187 Stars *Convert_PS1_V1 (FTable *table, int *nstars) {
    188 
    189   int i, Nstars;
     192Stars *Convert_PS1_V1 (FTable *table, unsigned int *nstars) {
     193
     194  off_t Nstars;
     195  unsigned int i;
    190196  double ZeroPt;
    191197  Stars *stars;
    … …  
    261267}
    262268
    263 Stars *Convert_PS1_V1_Alt (FTable *table, int *nstars) {
    264 
    265   int i, Nstars;
     269Stars *Convert_PS1_V1_Alt (FTable *table, unsigned int *nstars) {
     270
     271  off_t Nstars;
     272  unsigned int i;
    266273  double ZeroPt;
    267274  Stars *stars;
    … …  
    332339}
    333340
    334 Stars *Convert_PS1_V2 (FTable *table, int *nstars) {
    335 
    336   int i, Nstars;
     341Stars *Convert_PS1_V2 (FTable *table, unsigned int *nstars) {
     342
     343  off_t Nstars;
     344  unsigned int i;
    337345  double ZeroPt;
    338346  Stars *stars;

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

    r27392 r27435  
    3131// given a file with the pointer at the start of the table block and the
    3232// corresponding image header, load the stars from the table
    33 Stars *ReadStarsSDSS (FILE *f, char *name, Header *header, Header *in_theader, Image *images, int *nimages, unsigned int *nstars) {
    34 
    35   int i, j, N, Nskip, Nstars, camcol;
     33Stars *ReadStarsSDSS (FILE *f, char *name, Header *header, Header *in_theader, Image *images, off_t *nimages, unsigned int *nstars) {
     34
     35  off_t Nskip, Nrow;
     36  int i, j, N, Nstars, camcol;
    3637  char type[80];
    3738  Header theader;
    … …  
    4344  char filtname[16][5];
    4445  int photcode[5];
    45   int Nrow, Ncol; // used in the GET_COLUMN_1,5 macros above
     46  int Ncol; // used in the GET_COLUMN_1,5 macros above
    4647 
    4748  if (in_theader == NULL) {
    … …  
    5051  } else {
    5152    table.header = in_theader;
    52     Nskip = in_theader[0].size;
    53     fseek (f, Nskip, SEEK_CUR);
     53    Nskip = in_theader[0].datasize;
     54    fseeko (f, Nskip, SEEK_CUR);
    5455  }
    5556

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

    r21508 r27435  
    1313}
    1414
    15 SkyList *SkyListForStars (SkyTable *table, int depth, Stars *stars, int Nstars) {
     15SkyList *SkyListForStars (SkyTable *table, int depth, Stars *stars, unsigned int Nstars) {
    1616 
    1717  int i, j, Nr, NR;

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

    r15036 r27435  
    147147    skytable[0].filename[i] = NULL;
    148148  }
    149   if (VERBOSE) fprintf (stderr, "loaded %d tables from tycho index\n", skytable[0].Nregions);
     149  if (VERBOSE) fprintf (stderr, "loaded %lld tables from tycho index\n", (long long) skytable[0].Nregions);
    150150
    151151  return (skytable);

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

    r15743 r27435  
    11# include "addstar.h"
    22
    3 int UpdateDatabase_Image (AddstarClientOptions *options, Image *images, int Nimages, Coords *mosaic, Stars *stars, int Nstars) {
     3int UpdateDatabase_Image (AddstarClientOptions *options, Image *images, int Nimages, Coords *mosaic, Stars *stars, unsigned int Nstars) {
    44
    55  int i, status;

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

    r15743 r27435  
    11# include "addstar.h"
    22
    3 int UpdateDatabase_Reflist (AddstarClientOptions *options, Stars *stars, int Nstars) {
     3int UpdateDatabase_Reflist (AddstarClientOptions *options, Stars *stars, unsigned int Nstars) {
    44
    55  int i, Nsubset;

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

    r26390 r27435  
    11# include "addstar.h"
    22
    3 int UpdateImageIDs (Stars *stars, int Nstars, Image *images, int Nimages) {
     3int UpdateImageIDs (Stars *stars, unsigned int Nstars, Image *images, off_t Nimages) {
    44
    55  int i, status, isEmpty;

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

    r26280 r27435  
    11# include "addstar.h"
    22
     3// LARGEFILES: this program currently limits Nstars (input file) to < 2^31
    34int main (int argc, char **argv) {
    45
     6  unsigned int Nstars, Nsubset;
    57  int Nmatch, status, loadObjects;
    6   int i, Nstars, Nimages, Nsubset;
    7   unsigned long long Naverage, Nmeasure;
     8  off_t i, Nimages;
     9  off_t Naverage, Nmeasure;
    810  Stars *stars, **subset;
    911  Image *images;
    … …  
    4648        newlist = SkyListByImage (sky, -1, &images[i]);
    4749        SkyListMerge (&skylist, newlist);
    48         if (VERBOSE) fprintf (stderr, "added %d regions to yield %d total\n", newlist[0].Nregions, skylist[0].Nregions);
     50        if (VERBOSE) fprintf (stderr, "added %lld regions to yield %lld total\n", (long long) newlist[0].Nregions, (long long) skylist[0].Nregions);
    4951        SkyListFree (newlist);
    5052      }
    … …  
    7880    skylist = tmp;
    7981  }
    80   if (VERBOSE) fprintf (stderr, "writing to %d regions\n", skylist[0].Nregions);
     82  if (VERBOSE) fprintf (stderr, "writing to %lld regions\n", (long long) skylist[0].Nregions);
    8183
    8284  /* don't load the object tables for only_images, unless we are getting the calibration. */
    … …  
    147149      case M_RESORT:
    148150        if (options.nosort == 3) catalog.sorted = FALSE;
     151
     152        // no need to resort empty catalogs
     153        if (catalog.Naves_disk == 0) {
     154          dvo_catalog_unlock (&catalog);
     155          dvo_catalog_free (&catalog);
     156          continue;
     157        }
     158
    149159        resort_catalog (&catalog);
    150160        Nsubset = 1;
    … …  
    203213  gettimeofday (&stop, NULL);
    204214  dtime = DTIME (stop, start);
    205   fprintf (stderr, "SUCCESS: elapsed time %9.4f sec for %5d stars (%5d matches), %6lld average, %7lld measure\n", dtime, Nstars, Nmatch, Naverage, Nmeasure);
     215  fprintf (stderr, "SUCCESS: elapsed time %9.4f sec for %5d stars (%5d matches), %6lld average, %7lld measure\n", dtime, Nstars, Nmatch, (long long) Naverage, (long long) Nmeasure);
    206216
    207217  exit (0);

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

    r25757 r27435  
    2323
    2424    /* wait for clients to make connection */
    25     BindSocket = WaitServerSocket (InitSocket, &Address, VALID_IP, NVALID);
     25    BindSocket = WaitServerSocket (InitSocket, &Address, VALID_IP, NVALID_ID);
    2626    if (BindSocket == -1) continue;
    2727

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

    r26399 r27435  
    2626/* build the initial links assuming the table is sorted,
    2727   not partial, and has a correct set of average[].measureOffset,Nmeasure values */
    28 int *init_measure_links (Average *average, int Naverage, Measure *measure, int Nmeasure) {
    29 
    30   int i, j, N;
    31   int *next;
     28off_t *init_measure_links (Average *average, off_t Naverage, Measure *measure, off_t Nmeasure) {
     29
     30  off_t i, j, N;
     31  off_t *next_meas;
    3232
    3333  N = 0;
    3434
    35   ALLOCATE (next, int, Nmeasure);
     35  ALLOCATE (next_meas, off_t, Nmeasure);
    3636  for (i = 0; i < Naverage; i++, N++) {
    3737    for (j = 0; j < average[i].Nmeasure - 1; j++, N++) {
    38       next[N] = N + 1;
     38      next_meas[N] = N + 1;
    3939      if (N >= Nmeasure) {
    4040        fprintf (stderr, "WARNING: N out of bounds (1)\n");
    4141      }
    4242    }
    43     next[N] = -1;
     43    next_meas[N] = -1;
    4444    if (N >= Nmeasure) {
    4545      fprintf (stderr, "WARNING: N out of bounds (2)\n");
    … …  
    5151    }
    5252  }
    53   return (next);
     53  return (next_meas);
    5454}
    5555
    … …  
    6161 */
    6262
    63 int *build_measure_links (Average *average, int Naverage, Measure *measure, int Nmeasure) {
    64 
    65   int i, m, k, Nm, averef;
    66   int *next;
    67 
    68   ALLOCATE (next, int, Nmeasure);
     63off_t *build_measure_links (Average *average, off_t Naverage, Measure *measure, off_t Nmeasure) {
     64
     65  off_t i, m, k, Nm, averef;
     66  off_t *next_meas;
     67
     68  ALLOCATE (next_meas, off_t, Nmeasure);
    6969
    7070  /* reset the Nm, offset values for average */
    … …  
    7777    averef = measure[Nm].averef;
    7878    m = average[averef].measureOffset; 
    79     next[Nm] = -1;
     79    next_meas[Nm] = -1;
    8080
    8181    if (m == -1) { /* no links yet for source */
    … …  
    8585    }
    8686
    87     for (k = 0; next[m] != -1; k++) {
    88       m = next[m];
     87    for (k = 0; next_meas[m] != -1; k++) {
     88      m = next_meas[m];
    8989      if (m >= Nmeasure) {
    9090        fprintf (stderr, "WARNING: m out of bounds (1)\n");
    … …  
    9393
    9494    average[averef].Nmeasure = k + 2;
    95     next[m] = Nm;
     95    next_meas[m] = Nm;
    9696    if (m >= Nmeasure) {
    9797      fprintf (stderr, "WARNING: m out of bounds (2)\n");
    9898    }
    9999  }
    100   return (next);
     100  return (next_meas);
    101101}
    102102
    103103/* average[].measureOffset, average[].Nmeasure are valid within an addstar run */
    104 int add_meas_link (Average *average, int *next, int Nmeasure, int NMEASURE) {
    105 
    106   int k, m;
    107 
    108   /* if we have trouble, check validity of next[m] : m < Nmeasure */
     104off_t add_meas_link (Average *average, off_t *next_meas, off_t Nmeasure, off_t NMEASURE) {
     105
     106  off_t k, m;
     107
     108  /* if we have trouble, check validity of next_meas[m] : m < Nmeasure */
    109109  m = average[0].measureOffset; 
    110110
    111111  for (k = 0; k < average[0].Nmeasure - 1; k++)  {
    112     m = next[m];
     112    m = next_meas[m];
    113113    if (m >= NMEASURE) {
    114114      fprintf (stderr, "WARNING: m out of bounds (3)\n");
    … …  
    117117
    118118  /* set up references */
    119   next[Nmeasure] = -1;
     119  next_meas[Nmeasure] = -1;
    120120  if (Nmeasure >= NMEASURE) {
    121121    fprintf (stderr, "WARNING: Nmeasure out of bounds (1)\n");
    … …  
    125125    average[0].measureOffset = Nmeasure;
    126126  } else {
    127     next[m] = Nmeasure;
     127    next_meas[m] = Nmeasure;
    128128    if (m >= NMEASURE) {
    129129      fprintf (stderr, "WARNING: m out of bounds (4)\n");
    … …  
    137137   we must always save the missing table, if it exists */
    138138
    139 Measure *sort_measure (Average *average, int Naverage, Measure *measure, int Nmeasure, int *next) {
    140 
    141   int i, k, n, N;
     139Measure *sort_measure (Average *average, off_t Naverage, Measure *measure, off_t Nmeasure, off_t *next_meas) {
     140
     141  off_t i, k, n, N;
    142142  Measure *tmpmeasure;
    143143
    … …  
    153153      if (measure[n].averef != i) abort();
    154154      tmpmeasure[N].averef = i;
    155       n = next[n];
     155      n = next_meas[n];
    156156    }
    157157  }
    … …  
    161161
    162162/* build the initial links assuming the table is sorted */
    163 int *init_missing_links (Average *average, int Naverage, Missing *missing, int Nmissing) {
    164 
    165   int i, j, N;
    166   int *next;
     163off_t *init_missing_links (Average *average, off_t Naverage, Missing *missing, off_t Nmissing) {
     164
     165  off_t i, j, N;
     166  off_t *next_miss;
    167167
    168168  N = 0;
    169169
    170   ALLOCATE (next, int, Nmissing);
     170  ALLOCATE (next_miss, off_t, Nmissing);
    171171  for (i = 0; i < Naverage; i++) {
    172172    for (j = 0; j < average[i].Nmissing - 1; j++, N++) {
    173       next[N] = N + 1;
     173      next_miss[N] = N + 1;
    174174    }
    175175    if (average[i].Nmissing > 0) {
    176       next[N] = -1;
     176      next_miss[N] = -1;
    177177      if (N >= Nmissing) {
    178178        fprintf (stderr, "overflow in init_missing_links");
    … …  
    183183
    184184  }
    185   return (next);
    186 }
    187 
    188 int add_miss_link (Average *average, int *next, int Nmissing) {
    189 
    190   int k, m;
     185  return (next_miss);
     186}
     187
     188off_t add_miss_link (Average *average, off_t *next_miss, off_t Nmissing) {
     189
     190  off_t k, m;
    191191
    192192  /* there may be 0 Nmiss; this is not true for Nmeas */
    193193  if (average[0].Nmissing < 1) {
    194194    average[0].missingOffset = Nmissing;
    195     next[Nmissing] = -1;
     195    next_miss[Nmissing] = -1;
    196196    return (TRUE);
    197197  }
    198198
    199199  m = average[0].missingOffset; 
    200   for (k = 0; k < average[0].Nmissing - 1; k++) m = next[m];
     200  for (k = 0; k < average[0].Nmissing - 1; k++) m = next_miss[m];
    201201  /* set up references */
    202   next[Nmissing] = -1;
    203   next[m] = Nmissing;
     202  next_miss[Nmissing] = -1;
     203  next_miss[m] = Nmissing;
    204204  return (TRUE);
    205205}
    206206
    207 Missing *sort_missing (Average *average, int Naverage, Missing *missing, int Nmissing, int *next) {
    208 
    209   int i, k, n, N;
     207Missing *sort_missing (Average *average, off_t Naverage, Missing *missing, off_t Nmissing, off_t *next_miss) {
     208
     209  off_t i, k, n, N;
    210210  Missing *tmpmissing;
    211211
    … …  
    218218    for (k = 0; k < average[i].Nmissing; k++, N++) {
    219219      tmpmissing[N] = missing[n];
    220       n = next[n];
     220      n = next_miss[n];
    221221    }
    222222  }

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

    r16810 r27435  
    22
    33static int InternalCal;
    4 static int Ncal, NCAL, *Nstar;
     4static int Ncal, NCAL;
     5static off_t *Nstar;
    56static float *Mobs, *dMobs, *Mref, *dMref, *Minst;
    67
    … …  
    1314  NCAL = 1000;
    1415  ALLOCATE (Mobs,  float,  NCAL);
    15   ALLOCATE (dMobs, float, NCAL);
     16  ALLOCATE (dMobs, float,  NCAL);
    1617  ALLOCATE (Mref,  float,  NCAL);
    1718  ALLOCATE (dMref, float,  NCAL);
    1819  ALLOCATE (Minst, float,  NCAL);
    19   ALLOCATE (Nstar, int, NCAL);
     20  ALLOCATE (Nstar, off_t, NCAL);
    2021}
    2122 
    22 void SaveCalibration (float Mo, float dMo, float Mr, float dMr, float Mi, int N) {
     23void SaveCalibration (float Mo, float dMo, float Mr, float dMr, float Mi, off_t N) {
    2324
    2425  Mobs[Ncal]  = Mo;
    … …  
    3738    REALLOCATE (dMref, float, NCAL);
    3839    REALLOCATE (Minst, float, NCAL);
    39     REALLOCATE (Nstar, int,  NCAL);
     40    REALLOCATE (Nstar, off_t, NCAL);
    4041  }
    4142}
    4243
    4344/* use the linked list to navigate the measures; safe for unsorted measures */
    44 void AddToCalibration (Average *average, SecFilt *secfilt, Measure *measure, Measure *new, int *next, int Nstar) {
     45void AddToCalibration (Average *average, SecFilt *secfilt, Measure *measure, Measure *new, off_t *next, off_t Nstar) {
    4546
    4647  int i, j, m, Nsec, found0, found1, found2;

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

    r21508 r27435  
    11# include "addstar.h"
    22
    3 int dump_rawstars (Stars *stars, int Nstars) {
     3int dump_rawstars (Stars *stars, unsigned int Nstars) {
    44
    5   int i;
     5  unsigned int i;
    66  FILE *f;
    77

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

    r21508 r27435  
    11# include "addstar.h"
    22
    3 Image *fakeimage (char *rootname, int *Nimage, int photcode) {
     3Image *fakeimage (char *rootname, off_t *Nimage, int photcode) {
    44
    55  int i, j, Nx, Ny, Nchips;

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

    r27392 r27435  
    11# include "addstar.h"
    22
    3 int find_matches (SkyRegion *region, Stars *stars, int NstarsIn, Catalog *catalog, AddstarClientOptions options) {
    4 
    5   int i, j, n, N, J, status, Nstars;
     3int find_matches (SkyRegion *region, Stars *stars, unsigned int NstarsIn, Catalog *catalog, AddstarClientOptions options) {
     4
     5  off_t i, j, n, N, J, status, Nstars;
    66  double RADIUS, RADIUS2;
    77  double *X1, *Y1, *X2, *Y2;
    88  double dX, dY, dR;
    9   int *N1, *N2, *next_meas;
    10   int Nave, NAVE, Nmeas, NMEAS, Nmatch;
     9  off_t *N1, *N2, *next_meas;
     10  off_t Nave, NAVE, Nmeas, NMEAS, Nmatch;
    1111  int Nsecfilt, Nsec;
    1212  unsigned int objID, catID;
    … …  
    2929  ALLOCATE (X1, double, NstarsIn);
    3030  ALLOCATE (Y1, double, NstarsIn);
    31   ALLOCATE (N1, int,    NstarsIn);
     31  ALLOCATE (N1, off_t,  NstarsIn);
    3232
    3333  /** allocate local arrays (catalog) **/
    … …  
    3535  ALLOCATE (X2, double, NAVE);
    3636  ALLOCATE (Y2, double, NAVE);
    37   ALLOCATE (N2, int,   NAVE);
    38   ALLOCATE (catalog[0].found, int, NAVE);
     37  ALLOCATE (N2, off_t,  NAVE);
     38  ALLOCATE (catalog[0].found, off_t, NAVE);
    3939  /* for secfilt j and star i, secfilt[i*Nsecfilt+j] */
    4040
    … …  
    146146      if (Nmeas >= NMEAS) {
    147147        NMEAS = Nmeas + 1000;
    148         REALLOCATE (next_meas, int, NMEAS);
     148        REALLOCATE (next_meas, off_t, NMEAS);
    149149
    150150        REALLOCATE (catalog[0].measure, Measure, NMEAS);
    … …  
    238238    if (Nmeas >= NMEAS - NSTAR_GROUP) {
    239239      NMEAS = Nmeas + 1000;
    240       REALLOCATE (next_meas, int, NMEAS);
     240      REALLOCATE (next_meas, off_t, NMEAS);
    241241      REALLOCATE (catalog[0].measure, Measure, NMEAS);
    242242    }
    … …  
    352352  catalog[0].Nmeasure = Nmeas;
    353353  catalog[0].Nsecf_mem = Nave*Nsecfilt;
    354   if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: %d %d %d, (%d matches)\n", Nstars, Nave, Nmeas, Nmatch);
     354  if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: %lld %lld %lld, (%lld matches)\n", (long long) Nstars, (long long) Nave, (long long) Nmeas, (long long) Nmatch);
    355355
    356356  free (catalog[0].found);

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

    r27392 r27435  
    11# include "addstar.h"
    22
    3 int find_matches_closest (SkyRegion *region, Stars *stars, int NstarsIn, Catalog *catalog, AddstarClientOptions options) {
    4 
    5   int i, j, n, N, J, Jmin, status, Nstars;
     3int find_matches_closest (SkyRegion *region, Stars *stars, unsigned int NstarsIn, Catalog *catalog, AddstarClientOptions options) {
     4 
     5  off_t i, j, n, N, J, Jmin, status, Nstars;
    66  double RADIUS, RADIUS2, Rmin;
    77  double *X1, *Y1, *X2, *Y2;
    88  double dX, dY, dR;
    9   int *N1, *N2, *next_meas;
    10   int Nave, NAVE, Nmeas, NMEAS, Nmatch;
     9  off_t *N1, *N2, *next_meas;
     10  off_t Nave, NAVE, Nmeas, NMEAS, Nmatch;
    1111  int Nsecfilt, Nsec;
    1212  unsigned int objID, catID;
    … …  
    2929  ALLOCATE (X1, double, NstarsIn);
    3030  ALLOCATE (Y1, double, NstarsIn);
    31   ALLOCATE (N1, int,    NstarsIn);
     31  ALLOCATE (N1, off_t,  NstarsIn);
    3232
    3333  /** allocate local arrays (catalog) **/
    … …  
    3535  ALLOCATE (X2, double, NAVE);
    3636  ALLOCATE (Y2, double, NAVE);
    37   ALLOCATE (N2, int,   NAVE);
    38   ALLOCATE (catalog[0].found, int, NAVE);
     37  ALLOCATE (N2, off_t,  NAVE);
     38  ALLOCATE (catalog[0].found, off_t, NAVE);
    3939  /* for secfilt j and star i, secfilt[i*Nsecfilt+j] */
    4040
    … …  
    161161    if (Nmeas >= NMEAS) {
    162162      NMEAS = Nmeas + 1000;
    163       REALLOCATE (next_meas, int, NMEAS);
     163      REALLOCATE (next_meas, off_t, NMEAS);
    164164      REALLOCATE (catalog[0].measure, Measure, NMEAS);
    165165    }
    … …  
    198198               X1[i], X2[Jmin],
    199199               Y1[i], Y2[Jmin]);
     200        // XXX abort on this? -- this is a bad failure...
    200201    }
    201202
    … …  
    232233    if (Nmeas >= NMEAS - NSTAR_GROUP) {
    233234      NMEAS = Nmeas + 1000;
    234       REALLOCATE (next_meas, int, NMEAS);
     235      REALLOCATE (next_meas, off_t, NMEAS);
    235236      REALLOCATE (catalog[0].measure, Measure, NMEAS);
    236237    }
    … …  
    273274    catalog[0].average[Nave].flags         = 0;
    274275    if (PSPS_ID) {
    275         catalog[0].average[Nave].extID = CreatePSPSObjectID(catalog[0].average[Nave].R,
    276                                                             catalog[0].average[Nave].D);
     276        catalog[0].average[Nave].extID = CreatePSPSObjectID(catalog[0].average[Nave].R, catalog[0].average[Nave].D);
    277277    } else {
    278         catalog[0].average[Nave].extID         = 0;
    279     }
    280 
     278        catalog[0].average[Nave].extID = 0;
     279    }
    281280
    282281    objID ++;
    … …  
    347346  catalog[0].Nmeasure = Nmeas;
    348347  catalog[0].Nsecf_mem = Nave*Nsecfilt;
    349   if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: %d %d %d, (%d matches)\n", Nstars, Nave, Nmeas, Nmatch);
     348  if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: %lld %lld %lld, (%lld matches)\n", (long long) Nstars, (long long) Nave, (long long) Nmeas, (long long) Nmatch);
    350349
    351350  free (catalog[0].found);

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

    r26384 r27435  
    11# include "addstar.h"
    22
    3 int find_matches_closest_refstars (SkyRegion *region, Stars **stars, int NstarsIn, Catalog *catalog, AddstarClientOptions options) {
    4 
    5   int i, j, n, N, J, Jmin, status;
     3int find_matches_closest_refstars (SkyRegion *region, Stars **stars, unsigned int NstarsIn, Catalog *catalog, AddstarClientOptions options) {
     4
     5  off_t i, j, n, N, J, Jmin, status;
    66  double RADIUS, RADIUS2, Rmin;
    77  double *X1, *Y1, *X2, *Y2;
    88  double dX, dY, dR;
    9   int *N1, *N2, *next_meas;
    10   int Nave, NAVE, Nmeas, NMEAS, Nstars, Nmatch;
     9  off_t *N1, *N2, *next_meas;
     10  off_t Nave, NAVE, Nmeas, NMEAS, Nstars, Nmatch;
    1111  unsigned int objID, catID;
    1212  Coords tcoords;
    … …  
    2424  ALLOCATE (X1, double, NstarsIn);
    2525  ALLOCATE (Y1, double, NstarsIn);
    26   ALLOCATE (N1, int,    NstarsIn);
     26  ALLOCATE (N1, off_t,  NstarsIn);
    2727
    2828  /** allocate local arrays (catalog) **/
    … …  
    3030  ALLOCATE (X2, double, NAVE);
    3131  ALLOCATE (Y2, double, NAVE);
    32   ALLOCATE (N2, int, NAVE);
    33   ALLOCATE (catalog[0].found, int, NAVE);
     32  ALLOCATE (N2, off_t, NAVE);
     33  ALLOCATE (catalog[0].found, off_t, NAVE);
    3434  /* for secfilt j and star i, secfilt[i*Nsecfilt+j] */
    3535
    … …  
    164164    if (Nmeas >= NMEAS) {
    165165      NMEAS = Nmeas + 1000;
    166       REALLOCATE (next_meas, int, NMEAS);
     166      REALLOCATE (next_meas, off_t, NMEAS);
    167167      REALLOCATE (catalog[0].measure, Measure, NMEAS);
    168168    }
    … …  
    239239    if (Nmeas >= NMEAS - NREFSTAR_GROUP) {
    240240      NMEAS = Nmeas + 1000;
    241       REALLOCATE (next_meas, int, NMEAS);
     241      REALLOCATE (next_meas, off_t, NMEAS);
    242242      REALLOCATE (catalog[0].measure, Measure, NMEAS);
    243243    }
    … …  
    329329      Nmeas ++;
    330330    }
     331    for (j = 0; j < NREFSTAR_GROUP - 1; j++) {
     332        next_meas[Nmeas - NREFSTAR_GROUP + j] = Nmeas - NREFSTAR_GROUP + j + 1;
     333    }
    331334    Nave ++;
    332335  }
    … …  
    351354  catalog[0].Nmeasure = Nmeas;
    352355  catalog[0].Nsecf_mem = Nave*Nsecfilt;
    353   if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: %d %d %d, (%d matches)\n", Nstars, Nave, Nmeas, Nmatch);
     356  if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: %lld %lld %lld, (%lld matches)\n", (long long) Nstars, (long long) Nave, (long long) Nmeas, (long long) Nmatch);
    354357
    355358  free (catalog[0].found);

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

    r26400 r27435  
    11# include "addstar.h"
    22
    3 int find_matches_refstars (SkyRegion *region, Stars **stars, int Nstars, Catalog *catalog, AddstarClientOptions options) {
    4 
    5   int i, j, n, N, J;
     3int find_matches_refstars (SkyRegion *region, Stars **stars, unsigned int Nstars, Catalog *catalog, AddstarClientOptions options) {
     4
     5  off_t i, j, n, N, J;
    66  double RADIUS, RADIUS2;
    77  double *X1, *Y1, *X2, *Y2;
    88  double dX, dY, dR;
    9   int *N1, *N2,  *next_meas;
    10   int Nave, NAVE, Nmeas, NMEAS, Nmatch;
     9  off_t *N1, *N2,  *next_meas;
     10  off_t Nave, NAVE, Nmeas, NMEAS, Nmatch;
    1111  unsigned int objID, catID;
    1212  Coords tcoords;
    … …  
    2424  ALLOCATE (X1, double, Nstars);
    2525  ALLOCATE (Y1, double, Nstars);
    26   ALLOCATE (N1, int,   Nstars);
     26  ALLOCATE (N1, off_t,  Nstars);
    2727
    2828  /** allocate local arrays (catalog) **/
    … …  
    3131  ALLOCATE (X2, double, NAVE);
    3232  ALLOCATE (Y2, double, NAVE);
    33   ALLOCATE (N2, int, NAVE);
    34   ALLOCATE (catalog[0].found, int, NAVE);
     33  ALLOCATE (N2, off_t, NAVE);
     34  ALLOCATE (catalog[0].found, off_t, NAVE);
    3535  REALLOCATE (catalog[0].average, Average, NAVE);
    3636  REALLOCATE (catalog[0].secfilt, SecFilt, NAVE*catalog[0].Nsecfilt);
    … …  
    124124      if (Nmeas == NMEAS) {
    125125        NMEAS = Nmeas + 1000;
    126         REALLOCATE (next_meas, int, NMEAS);
     126        REALLOCATE (next_meas, off_t, NMEAS);
    127127        REALLOCATE (catalog[0].measure, Measure, NMEAS);
    128128      }
    … …  
    209209    if (Nmeas >= NMEAS - NREFSTAR_GROUP) {
    210210      NMEAS = Nmeas + 1000;
    211       REALLOCATE (next_meas, int, NMEAS);
     211      REALLOCATE (next_meas, off_t, NMEAS);
    212212      REALLOCATE (catalog[0].measure, Measure, NMEAS);
    213213    }
    … …  
    325325  catalog[0].Nmeasure = Nmeas;
    326326  catalog[0].Nsecf_mem = Nave*Nsecfilt;
    327   if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: %d %d %d, (%d matches)\n", Nstars, Nave, Nmeas, Nmatch);
     327  if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: %lld %lld %lld, (%lld matches)\n", (long long) Nstars, (long long) Nave, (long long) Nmeas, (long long) Nmatch);
    328328
    329329  free (catalog[0].found);

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

    r21508 r27435  
    22
    33/* find stars within this region */
    4 Stars **find_subset (SkyRegion *region, Stars *stars, int Nstars, int *Nsubset) {
     4Stars **find_subset (SkyRegion *region, Stars *stars, unsigned int Nstars, unsigned int *Nsubset) {
    55
    66  int i, N, NSUBSET;

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

    r17439 r27435  
    22# include "2mass.h"
    33
    4 Stars *get2mass (SkyRegion *patch, int photcode, int mode, int *NSTARS) {
     4Stars *get2mass (SkyRegion *patch, int photcode, int mode, unsigned int *NSTARS) {
    55 
    66  char *path;

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

    r21508 r27435  
    77static SkyTable *sky = NULL;
    88
    9 Stars *getgsc (SkyRegion *patch, int *NSTARS) {
     9Stars *getgsc (SkyRegion *patch, unsigned int *NSTARS) {
    1010 
    11   int i, Ngsc, Nstars;
     11  unsigned int i, Ngsc, Nstars;
    1212  Stars *gsc;
    1313  Stars *stars;
    … …  
    4545} 
    4646
    47 Stars *rd_gsc (char *filename, int *nstars) {
     47Stars *rd_gsc (char *filename, unsigned int *nstars) {
    4848 
    4949  int i, NSTARS, Nstars, Nbytes, nbytes, Nline, Nbyte;

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

    r21508 r27435  
    66static SkyTable *tychoTable = NULL;
    77
    8 Stars *gettycho (SkyRegion *catstats, int photcode, int *nstars) {
     8Stars *gettycho (SkyRegion *catstats, int photcode, unsigned int *nstars) {
    99
    1010  int i, j, nitems;
    … …  
    1313  FILE *f;
    1414  int NTYCHO, Ntycho;
    15   int firstRow, firstByte;
     15  off_t firstRow, firstByte;
    1616  short int TYCHO_B, TYCHO_V;
    1717  e_time TychoEpoch;
    … …  
    6060                          region[0].Rmin, region[0].Rmax, region[0].Dmin, region[0].Dmax);
    6161
    62     firstRow  = atoi (region[0].name);
     62    firstRow  = strtol (region[0].name, NULL, 0);
    6363    firstByte = firstRow * NBYTE;
    64     fseek (f, firstByte, SEEK_SET);
     64    fseeko (f, firstByte, SEEK_SET);
    6565
    6666    while (1) {

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

    r21508 r27435  
    44# define NELEM  3
    55
    6 Stars *getusno (SkyRegion *catstats, int photcode, int *nstars) {
     6Stars *getusno (SkyRegion *catstats, int photcode, unsigned int *nstars) {
    77
    8   long int offset;
     8  off_t offset;
    99  int i, bin, first, last, nitems, Nitems, Nbins, Nstars;
    1010  float hours[100];
    … …  
    8484    /* advance file pointer to first slice */
    8585    offset = NELEM*NBYTE*(start[first] - 1);
    86     fseek (f, offset, SEEK_SET);
     86    fseeko (f, offset, SEEK_SET);
    8787
    8888    /* sum the number of stars in data segment of interest */

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

    r26280 r27435  
    33# define NELEM  20
    44
    5 Stars *getusnob (SkyRegion *catstats, int photcode, int *nstars) {
     5Stars *getusnob (SkyRegion *catstats, int photcode, unsigned int *nstars) {
    66
    7   long int offset;
     7  off_t offset;
    88  int i, bin, first, last, nitems, Nitems, Nbins, Nitemsum;
    99  float hours[100];
    … …  
    9393    /* advance file pointer to first slice */
    9494    offset = NELEM*NBYTE*(start[first] - 1);
    95     fseek (f, offset, SEEK_SET);
     95    fseeko (f, offset, SEEK_SET);
    9696
    9797    /* sum the number of stars in data segment of interest */

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

    r21508 r27435  
    33# define LOAD_DR2    1
    44
    5 Stars *greference (char *Refcat, SkyRegion *region, int photcode, int *nstars) {
     5Stars *greference (char *Refcat, SkyRegion *region, int photcode, unsigned int *nstars) {
    66
    7   int Nstars;
     7  unsigned int Nstars;
    88  Stars *stars;
    99

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

    r21508 r27435  
    22
    33/* read ASCII file with ref star data */
    4 Stars *grefstars (char *file, int photcode, int *Nstars) {
     4Stars *grefstars (char *file, int photcode, unsigned int *Nstars) {
    55
    66  FILE *f;

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

    r3376 r27435  
    55main (int argc, char **argv) {
    66
    7   int N, Nread, Nseek, Nback;
     7  off_t Nseek, Nback;
     8  int N, Nread;
    89  char *filename, *buffer;
    910  gzFile gf;
    … …  
    6667
    6768    gettimeofday (&start, NULL);
    68     N = fseek (f, Nseek, SEEK_SET);
     69    N = fseeko (f, Nseek, SEEK_SET);
    6970    gettimeofday (&stop, NULL);
    7071    if (N) {
    … …  
    8485
    8586    gettimeofday (&start, NULL);
    86     N = fseek (f, Nback, SEEK_CUR);
     87    N = fseeko (f, Nback, SEEK_CUR);
    8788    gettimeofday (&stop, NULL);
    8889    if (N) {

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

    r20936 r27435  
    1919  // load a text table with X,Y,Mag (instrumental?)
    2020
    21   int i, N, Nstars, NSTARS;
     21  int i, N, Nstars, NSTARS, found;
    2222  double *X, *Y, *M;
    2323  double Xmax, Ymax;
    … …  
    5656  }
    5757
     58  // add support for all cmf types
     59  static char *type = "PS1_DEV_1";
     60  if ((N = get_argument (argc, argv, "-type"))) {
     61    remove_argument (N, &argc, argv);
     62    type = strcreate (argv[N]);
     63    remove_argument (N, &argc, argv);
     64    fprintf (stderr, "support for other types is broken: see comment at line 97\n");
     65    exit (1);
     66  }
     67
    5868  if (argc != 3) {
    59     fprintf (stderr, "USAGE mkcmf (input) (output) [-date date] [-time time] [-radec ra dec]\n");
     69    fprintf (stderr, "USAGE mkcmf (input) (output) [-date date] [-time time] [-radec ra dec] [-cmftype type]\n");
    6070    exit (2);
    6171  }
    … …  
    8696
    8797  // XXX add gaussian-distributed noise based on counts
     98  // this needs to make different output 'stars' entries depending on the desired type
    8899  ALLOCATE (stars, PS1_DEV_1, Nstars);
    89100  gauss_init (2048);
    … …  
    162173
    163174  ftable.header = &theader;
    164   gfits_table_set_PS1_DEV_1 (&ftable, stars, Nstars);
     175
     176  // set up desired CMF type:
     177  found = FALSE;
     178# if 0
     179  if (!strcmp(type, "PS1_DEV_0")) {
     180    gfits_table_set_PS1_DEV_0 (&ftable, stars, Nstars);
     181    gfits_modify (&theader, "EXTTYPE",   "%s", 1, "PS1_DEV_0");
     182    found = TRUE;
     183  }
     184# endif
     185  if (!strcmp(type, "PS1_DEV_1")) {
     186    gfits_table_set_PS1_DEV_1 (&ftable, stars, Nstars);
     187    gfits_modify (&theader, "EXTTYPE",   "%s", 1, "PS1_DEV_1");
     188    found = TRUE;
     189  }
     190# if 0
     191  if (!strcmp(type, "PS1_V1")) {
     192    gfits_table_set_CMF_PS1_V1 (&ftable, stars, Nstars);
     193    gfits_modify (&theader, "EXTTYPE",   "%s", 1, "PS1_V1");
     194    found = TRUE;
     195  }
     196  if (!strcmp(type, "PS1_V2")) {
     197    gfits_table_set_CMF_PS1_V2 (&ftable, stars, Nstars);
     198    gfits_modify (&theader, "EXTTYPE",   "%s", 1, "PS1_V2");
     199    found = TRUE;
     200  }
     201# endif
     202  if (!found) {
     203    fprintf (stderr, "ERROR: unknown CMF type %s\n", type);
     204    exit (1);
     205  }
     206
     207  gfits_modify (&theader, "EXTHEAD",   "%s", 1, "Chip.hdr");
    165208  gfits_modify (&theader, "EXTNAME",   "%s", 1, "Chip.psf");
    166   gfits_modify (&theader, "EXTTYPE",   "%s", 1, "PS1_DEV_1");
    167   gfits_modify (&theader, "EXTHEAD",   "%s", 1, "Chip.hdr");
    168209
    169210  fits = fopen (argv[2], "w");

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

    • Property svn:mergeinfo changed (with no actual effect on merging)

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

    r7039 r27435  
    33void resort_catalog (Catalog *catalog) {
    44
    5   int *next_meas;
    6   int Naves, Nmeas;
     5  off_t *next_meas;
     6  off_t Naves, Nmeas;
    77  double dtime;
    88  struct timeval start, stop;
    … …  
    2424  gettimeofday (&stop, NULL);
    2525  dtime = DTIME (stop, start);
    26   fprintf (stderr, "  match time %9.4f sec for %7d measures, %6d average\n", dtime, Nmeas, Naves);
     26  fprintf (stderr, "  match time %9.4f sec for %7lld measures, %6lld average\n", dtime, (long long) Nmeas, (long long) Naves);
    2727
    2828  return;

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

    r23914 r27435  
    947947  }
    948948  REALLOCATE (db[0].vtable.buffer, char *, 1);
    949   REALLOCATE (db[0].vtable.row, int, 1);
     949  REALLOCATE (db[0].vtable.row, off_t, 1);
    950950  db[0].vtable.Nrow   = 0;
    951951
    952952  // reset db[0].theader(NAXIS1) to match Image
    953   gfits_modify (&db[0].theader, "NAXIS1", "%d", 1, sizeof(Image));
     953  gfits_modify (&db[0].theader, "NAXIS1", "%lld", 1, (long long) sizeof(Image));
    954954  db[0].theader.Naxis[0] = sizeof(Image);
    955955

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

    r16810 r27435  
    22
    33/* find the average and scatter for R and D - no outlier rejection */
    4 void update_coords (Average *average, Measure *measure, int *next) {
     4void update_coords (Average *average, Measure *measure, off_t *next) {
    55
    6   int i, m, Npt;
     6  off_t i, m, Npt;
    77  double R, D, r, d;
    88  double r2, d2, dR2, dD2;

  • trunk/Ohana/src/delstar/include/delstar.h

    r21153 r27435  
    4040int        FindDecBand            PROTO((double dec, double *DEC0, double *DEC1));
    4141FILE      *GetDB                  PROTO((int *state));
    42 Image     *GetImages              PROTO((int *nimage));
    43 int        SetImages              PROTO((Image *new, int Nnew));
     42Image     *GetImages              PROTO((off_t *nimage));
     43int        SetImages              PROTO((Image *new, off_t Nnew));
    4444void       SetProtect             PROTO((int mode));
    4545int        SetSignals             PROTO((void));
    46 int        Shutdown               PROTO((char *format, ...));
     46int        Shutdown               PROTO((char *format, ...)) OHANA_FORMAT(printf, 1, 2);
    4747void       TrapSignal             PROTO((int sig));
    4848int        args                   PROTO((int *argc, char **argv));
    … …  
    5252void       delete_times           PROTO((FITS_DB *db));
    5353int        edge_check             PROTO((double *x1, double *y1, double *x2, double *y2));
    54 int       *find_images_data       PROTO((FITS_DB *db, Image *timage, int *nlist));
    55 int       *find_images_name       PROTO((FITS_DB *db, char *filename, int *nlist));
    56 int       *find_images_time       PROTO((FITS_DB *db, time_t start, time_t end, PhotCode *code, int *nlist));
    57 void       find_matches           PROTO((Catalog *catalog, int photcode, int start, int end));
     54off_t     *find_images_data       PROTO((FITS_DB *db, Image *timage, off_t *nlist));
     55off_t     *find_images_name       PROTO((FITS_DB *db, char *filename, off_t *nlist));
     56off_t     *find_images_time       PROTO((FITS_DB *db, e_time start, e_time end, PhotCode *code, off_t *nlist));
     57void       find_matches           PROTO((Catalog *catalog, int photcode, e_time start, e_time end));
    5858int        gcatalog               PROTO((Catalog *catalog));
    5959Image     *gimages                PROTO((char *filename));
    60 Image     *gtimes                 PROTO((int *NIMAGE));
     60Image     *gtimes                 PROTO((off_t *NIMAGE));
    6161void       help                   PROTO((void));
    6262int        load_image_db          PROTO((FITS_DB *db));
    6363void       lock_image_db          PROTO((FITS_DB *db, char *filename));
    64 void       match_images           PROTO((Catalog *catalog, Image *image, int Nimage));
     64void       match_images           PROTO((Catalog *catalog, Image *image, off_t Nimage));
    6565double     opening_angle          PROTO((double x1, double y1, double x2, double y2, double x3, double y3));
    66 int        parse_time             PROTO((Header *header));
     66e_time     parse_time             PROTO((Header *header));
    6767int        save_image_db          PROTO((void));
    6868void       sort_lists             PROTO((float *X, float *Y, int *S, int N));

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

    r25757 r27435  
    33void delete_imagefile (FITS_DB *db, char *filename) {
    44
    5   int i, Nimlist;
    6   int *imlist;
     5  off_t i, Nimlist;
     6  off_t *imlist;
    77  double trange;
    8   time_t start, stop;
     8  e_time start, stop;
    99  Image *image;
    1010  Catalog catalog;

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

    r25757 r27435  
    33void delete_imagename (FITS_DB *db, char *name) {
    44
    5   int i, j, k;
    6   int Nimlist, Nimage, Noutimage;
    7   int *imlist;
     5  off_t i, j, k;
     6  off_t Nimlist, Nimage, Noutimage;
     7  off_t *imlist;
    88  double trange;
    99  time_t start, stop;
    … …  
    7777  Noutimage = Nimage - Nimlist;
    7878 
    79   if (VERBOSE) fprintf (stderr, "removing %d images (leaving %d of %d)\n", Nimlist, Noutimage, Nimage);
     79  if (VERBOSE) fprintf (stderr, "removing %lld images (leaving %lld of %lld)\n", (long long) Nimlist, (long long) Noutimage, (long long) Nimage);
    8080  // gfits_table_set_Image (&db[0].ftable, outimage, Noutimage);
    8181
    82   gfits_modify (&db[0].theader, "NAXIS2", "%d", 1, Noutimage);
    83   gfits_modify (&db[0].header, "NIMAGES", "%d", 1, Noutimage);
     82  gfits_modify (&db[0].theader, "NAXIS2", "%lld", 1, (long long) Noutimage);
     83  gfits_modify (&db[0].header, "NIMAGES", "%lld", 1, (long long) Noutimage);
    8484  db[0].theader.Naxis[1] = Noutimage;
    8585  db[0].ftable.buffer = (char *) outimage;

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

    r4680 r27435  
    55delete_missed (Catalog *catalog) {
    66
    7   int i;
    8   int Nave, Nmeas, Nmiss;
     7  off_t i, Nave, Nmeas, Nmiss;
    98
    109  Nave = catalog[0].Naverage;
    … …  
    1211  Nmiss = catalog[0].Nmissing;
    1312 
    14   if (VERBOSE) fprintf (stderr, "starting with Nave, Nmeas, Nmiss: %d %d %d\n", Nave, Nmeas, Nmiss);
     13  if (VERBOSE) fprintf (stderr, "starting with Nave, Nmeas, Nmiss: %lld %lld %lld\n", (long long) Nave, (long long) Nmeas, (long long) Nmiss);
    1514
    1615  /* set up references for missing to average */
    … …  
    2019  REALLOCATE (catalog[0].missing, Missing, 1);
    2120  catalog[0].Nmissing = 0;
    22   if (VERBOSE) fprintf (stderr, "  ending with Nave, Nmeas, Nmiss: %d %d %d\n", Nave, Nmeas, Nmiss);
     21  if (VERBOSE) fprintf (stderr, "  ending with Nave, Nmeas, Nmiss: %lld %lld %lld\n", (long long) Nave, (long long) Nmeas, (long long) Nmiss);
    2322}
    2423

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

    r17198 r27435  
    33delete_orphans (char *name) {
    44
    5   int i, j, k, n, m, N, M, found;
    6   int *N1, *N2,  *next, *next_miss, *ave_miss, last, last_miss;
    7   int Nave, NAVE, Nmeas, NMEAS, Nmiss, NMISS, Nmatch;
    8   int start, end, Nmeasfound, Nsecfilt;
     5  off_t i, j, k, n, m, Nmeasfound, Nsecfilt, N, M, found;
     6  off_t *next_meas, *next_miss, *ave_miss, last, last_miss;
     7  off_t Nave, NAVE, Nmeas, NMEAS, Nmiss, NMISS, Nmatch;
     8  e_time start, end;
    99  unsigned int flags;
    1010  Measure *tmpmeasure;
    … …  
    2626
    2727  Nmeas = catalog.Nmeasure;
    28   ALLOCATE (next, int, Nmeas);
     28  ALLOCATE (next_meas, int, Nmeas);
    2929 
    3030  Nmiss = catalog.Nmissing;
    … …  
    3636  /* set up pointers for linked list of measure */
    3737  for (i = 0; i < Nmeas - 1; i++) {
    38     next[i] = i+1;
    39   }
    40   next[i] = -1;
     38    next_meas[i] = i+1;
     39  }
     40  next_meas[i] = -1;
    4141  last = i;
    4242  /* set up pointers for linked list of missing */
    … …  
    6060      /* this star is an orphan */
    6161      Nmeasfound ++;
    62       next[i] = -2; /* we delete this one */
     62      next_meas[i] = -2; /* we delete this one */
    6363      /* fix the list links: connect the previous valid link to the next valid link */
    64       for (j = i; (j >= 0) && (next[j] == -2); j--); /* find previous entry to fix link */
     64      for (j = i; (j >= 0) && (next_meas[j] == -2); j--); /* find previous entry to fix link */
    6565      if (j >= 0) { /* if j < 0, there is no previous valid link, ignore this step */
    66         if (next[j] != i) {
     66        if (next_meas[j] != i) {
    6767          fprintf (stderr, "error?  this link seems to have been lost\n");
    6868          exit (1);
    6969        }
    7070        /* find next valid entry to fix link */
    71         for (k = i; (k < Nmeas) && (next[k] == -2); k++);
     71        for (k = i; (k < Nmeas) && (next_meas[k] == -2); k++);
    7272        if (k < Nmeas)
    73           next[j] = k;
     73          next_meas[j] = k;
    7474        else
    75           next[j] = -1;  /* last link in list gets a -1 */
     75          next_meas[j] = -1;  /* last link in list gets a -1 */
    7676      }
    7777     
    … …  
    111111        m = catalog.average[n].offset;
    112112        /* find next valid entry -- notice lack of error checking... */
    113         for (j = 0; (j < Nmeas) && (next[m+j] == -2); j++);
     113        for (j = 0; (j < Nmeas) && (next_meas[m+j] == -2); j++);
    114114        catalog.average[n].offset = m + j;
    115115      }
    … …  
    218218      tmpmeasure[N] = catalog.measure[n];
    219219      tmpmeasure[N].averef = i;
    220       n = next[n];
     220      n = next_meas[n];
    221221    }
    222222  }

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

    r25757 r27435  
    33void delete_times (FITS_DB *db) {
    44
    5   int i, j, k, n;
    6   int Nimage, Nimlist, found, code;
    7   int Nregions, NREGIONS;
    8   int *imlist;
     5  int found, code;
     6  off_t i, j, k, n;
     7  off_t Nimage, Nimlist;
     8  off_t Nregions, NREGIONS;
     9  off_t *imlist;
    910  SkyList *skylist, *skyset;
    1011  SkyTable *sky;

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

    r16810 r27435  
    11# include "delstar.h"
    22
    3 int *find_images_name (FITS_DB *db, char *filename, int *nlist) {
     3off_t *find_images_name (FITS_DB *db, char *filename, off_t *nlist) {
    44
    5   int i, Nimage, Nlist, NLIST;
    6   int *list;
     5  off_t i, Nimage, Nlist, NLIST;
     6  off_t *list;
    77  char *p, *name;
    88  Image *image;
    … …  
    2020  Nlist = 0;
    2121  NLIST = 100;
    22   ALLOCATE (list, int, NLIST);
     22  ALLOCATE (list, off_t, NLIST);
    2323
    2424  for (i = 0; i < Nimage; i++) {
    … …  
    2626    list[Nlist] = i;
    2727    Nlist ++;
    28     CHECK_REALLOCATE (list, int, NLIST, Nlist, 100);
     28    CHECK_REALLOCATE (list, off_t, NLIST, Nlist, 100);
    2929  }
    3030
    … …  
    3434
    3535/* find images in db by image data (time/photcode) */
    36 int *find_images_data (FITS_DB *db, Image *timage, int *nlist) {
     36off_t *find_images_data (FITS_DB *db, Image *timage, off_t *nlist) {
    3737
    38   int i, Nimage, Nlist, NLIST;
    39   int *list;
     38  off_t i, Nimage, Nlist, NLIST;
     39  off_t *list;
    4040  Image *image;
    4141  time_t start, stop;
    … …  
    5050  Nlist = 0;
    5151  NLIST = 100;
    52   ALLOCATE (list, int, NLIST);
     52  ALLOCATE (list, off_t, NLIST);
    5353
    5454  for (i = 0; i < Nimage; i++) {
    … …  
    5858    list[Nlist] = i;
    5959    Nlist ++;
    60     CHECK_REALLOCATE (list, int, NLIST, Nlist, 100);
     60    CHECK_REALLOCATE (list, off_t, NLIST, Nlist, 100);
    6161  }
    6262
    … …  
    6666
    6767/* find images in db by image data (time/photcode) */
    68 int *find_images_time (FITS_DB *db, time_t start, time_t end, PhotCode *code, int *nlist) {
     68off_t *find_images_time (FITS_DB *db, e_time start, e_time end, PhotCode *code, off_t *nlist) {
    6969
    70   int i, Nimage, Nlist, NLIST;
    71   int *list;
     70  off_t i, Nimage, Nlist, NLIST;
     71  off_t *list;
    7272  Image *image;
    7373
    … …  
    7676  Nlist = 0;
    7777  NLIST = 100;
    78   ALLOCATE (list, int, NLIST);
     78  ALLOCATE (list, off_t, NLIST);
    7979
    8080  for (i = 0; i < Nimage; i++) {
    … …  
    8686    list[Nlist] = i;
    8787    Nlist ++;
    88     CHECK_REALLOCATE (list, int, NLIST, Nlist, 100);
     88    CHECK_REALLOCATE (list, off_t, NLIST, Nlist, 100);
    8989  }
    9090

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

    r17244 r27435  
    11# include "delstar.h"
    22
    3 void find_matches (Catalog *catalog, int photcode, int start, int end) {
    4 
    5   int i, j, k, n, m, N, M, drop, averef;
    6   int *next, *next_miss, *ave_miss, last, last_miss;
    7   int Nave, Nmeas, NMEAS, Nmiss;
    8   int Nmeasfound, Nsecfilt;
    9   int this, prev;
     3void find_matches (Catalog *catalog, int photcode, e_time start, e_time end) {
     4
     5  int drop;
     6  off_t i, j, k, n, m, N, M, averef;
     7  off_t *next_meas, *next_miss, *ave_miss, last, last_miss;
     8  off_t Nave, Nmeas, NMEAS, Nmiss;
     9  off_t Nmeasfound, Nsecfilt;
     10  off_t this, prev;
    1011  Measure *tmpmeasure;
    1112  Missing *tmpmissing;
    … …  
    1516
    1617  Nmeas = catalog[0].Nmeasure;
    17   ALLOCATE (next, int, MAX(Nmeas,1));
     18  ALLOCATE (next_meas, off_t, MAX(Nmeas,1));
    1819 
    1920  Nmiss = catalog[0].Nmissing;
    20   ALLOCATE (next_miss, int, MAX(Nmiss,1));
    21   ALLOCATE (ave_miss, int, MAX(Nmiss,1));
     21  ALLOCATE (next_miss, off_t, MAX(Nmiss,1));
     22  ALLOCATE (ave_miss, off_t, MAX(Nmiss,1));
    2223 
    23   if (VERBOSE) fprintf (stderr, "starting with Nave, Nmeas, Nmiss: %d %d %d\n", Nave, Nmeas, Nmiss);
     24  if (VERBOSE) fprintf (stderr, "starting with Nave, Nmeas, Nmiss: %lld %lld %lld\n", (long long) Nave, (long long) Nmeas, (long long) Nmiss);
    2425
    2526  /* set up pointers for linked list of measure */
    2627  for (i = 0; i < Nmeas - 1; i++) {
    27     next[i] = i+1;
    28   }
    29   next[i] = -1;
     28    next_meas[i] = i+1;
     29  }
     30  next_meas[i] = -1;
    3031  last = i;
    3132  /* set up pointers for linked list of missing */
    … …  
    6364
    6465    /* this star is in this image */
    65     this = next[i];
    66     next[i] = -2; /* we delete this one */
    67     if (prev != -1) { next[prev] = this; }
     66    this = next_meas[i];
     67    next_meas[i] = -2; /* we delete this one */
     68    if (prev != -1) { next_meas[prev] = this; }
    6869
    6970# if (0)
    7071    /* why is this section disabled? */
    7172    /* fix the list links: connect the previous valid link to the next valid link */
    72     for (j = i; (j >= 0) && (next[j] == -2); j--); /* find previous entry to fix link */
     73    for (j = i; (j >= 0) && (next_meas[j] == -2); j--); /* find previous entry to fix link */
    7374    if (j >= 0) { /* if j < 0, there is no previous valid link, ignore this step */
    74       if (next[j] != i) {
     75      if (next_meas[j] != i) {
    7576        fprintf (stderr, "error? (1)  this link seems to have been lost\n");
    76         fprintf (stderr, "j: %d, next[j]: %d, i: %d\n", j, next[j], i);
     77        fprintf (stderr, "j: %lld, next_meas[j]: %lld, i: %lld\n", (long long) j, (long long) next_meas[j], (long long) i);
    7778        exit (1);
    7879      }
    7980      /* find next valid entry to fix link */
    80       for (k = i; (k < Nmeas) && (next[k] == -2); k++);
     81      for (k = i; (k < Nmeas) && (next_meas[k] == -2); k++);
    8182      if (k < Nmeas)
    82         next[j] = k;
     83        next_meas[j] = k;
    8384      else
    84         next[j] = -1;  /* last link in list gets a -1 */
     85        next_meas[j] = -1;  /* last link in list gets a -1 */
    8586    }
    8687# endif     
    … …  
    107108        if (next_miss[j] != m) {
    108109          fprintf (stderr, "error? (2) this link seems to have been lost\n");
    109           fprintf (stderr, "j: %d, next_miss[j]: %d, i: %d\n", j, next_miss[j], i);
     110          fprintf (stderr, "j: %lld, next_miss[j]: %lld, i: %lld\n", (long long) j, (long long) next_miss[j], (long long) i);
    110111          exit (1);
    111112        }
    … …  
    122123      m = catalog[0].average[n].measureOffset;
    123124      /* find next valid entry -- notice lack of error checking... */
    124       for (j = 0; (j < Nmeas) && (next[m+j] == -2); j++);
     125      for (j = 0; (j < Nmeas) && (next_meas[m+j] == -2); j++);
    125126      if (catalog[0].measure[m+j].averef != n) {
    126127        fprintf (stderr, "error? measure.averef and average.measureOffset are mismatched\n");
    … …  
    130131    }
    131132  }
    132   fprintf (stderr, "found %d meas to remove\n", Nmeasfound);
     133  fprintf (stderr, "found %lld meas to remove\n", (long long) Nmeasfound);
    133134
    134135  if (VERBOSE) fprintf (stderr, "fixing missing...");
    … …  
    145146      if (next_miss[j] != i) {
    146147        fprintf (stderr, "error? (3) this link seems to have been lost\n");
    147         fprintf (stderr, "j: %d, next_miss[j]: %d, i: %d\n", j, next_miss[j], i);
     148        fprintf (stderr, "j: %lld, next_miss[j]: %lld, i: %lld\n", (long long) j, (long long) next_miss[j], (long long) i);
    148149        exit (1);
    149150      }
    … …  
    209210      tmpmeasure[N] = catalog[0].measure[n];
    210211      tmpmeasure[N].averef = i;
    211       n = next[n];
     212      n = next_meas[n];
    212213      CHECK_REALLOCATE (tmpmeasure, Measure, NMEAS, N, 10000);
    213214    }
    … …  
    248249  catalog[0].Nsecf_mem = Nave*Nsecfilt;
    249250
    250   if (VERBOSE) fprintf (stderr, "  ending with Nave, Nmeas, Nmiss: %d %d %d\n", Nave, Nmeas, Nmiss);
    251 
    252   free (next);
     251  if (VERBOSE) fprintf (stderr, "  ending with Nave, Nmeas, Nmiss: %lld %lld %lld\n", (long long) Nave, (long long) Nmeas, (long long) Nmiss);
     252
     253  free (next_meas);
    253254  free (next_miss);
    254255  free (ave_miss);

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

    r20184 r27435  
    2525    Shutdown ("ERROR: can't find data file %s", filename);
    2626  }
    27   fseek (f, header.size, SEEK_SET);
     27  fseeko (f, header.datasize, SEEK_SET);
    2828
    2929  /* add file name to image structure */
    … …  
    5353  }     
    5454  if (!haveNx && !haveNy) {
    55       haveNx = gfits_scan (&header, "ZNAXIS1",   "%d", 1, &image[0].NX);
    56       haveNy = gfits_scan (&header, "ZNAXIS2",   "%d", 1, &image[0].NY);
     55      haveNx = gfits_scan (&header, "ZNAXIS1",   "%hd", 1, &image[0].NX);
     56      haveNy = gfits_scan (&header, "ZNAXIS2",   "%hd", 1, &image[0].NY);
    5757  }
    5858  if (!haveNx || !haveNy) {

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

    r16810 r27435  
    11# include "delstar.h"
    22
    3 void match_images (Catalog *catalog, Image *image, int Nimage) {
     3void match_images (Catalog *catalog, Image *image, off_t Nimage) {
    44 
    5   int j, k, found;
    6   unsigned int *start, *stop;
     5  off_t j, k, found;
     6  e_time *start, *stop;
    77
    88  /* this must be allocated so future free will not fail */

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

    r20936 r27435  
    11# include "delstar.h"
    22
    3 int parse_time (Header *header) {
     3e_time parse_time (Header *header) {
    44
    55  double jd;

  • trunk/Ohana/src/dvomerge/Makefile

    r24745 r27435  
    2222DVOMERGE = \
    2323$(SRC)/dvomerge.$(ARCH).o \
     24$(SRC)/dvomergeUpdate.$(ARCH).o \
     25$(SRC)/dvomergeCreate.$(ARCH).o \
     26$(SRC)/dvo_image_merge_dbs.$(ARCH).o \
    2427$(SRC)/SetSignals.$(ARCH).o \
    2528$(SRC)/ConfigInit.$(ARCH).o \
    2629$(SRC)/Shutdown.$(ARCH).o \
    27 $(SRC)/usage.$(ARCH).o \
     30$(SRC)/help.$(ARCH).o \
     31$(SRC)/args.$(ARCH).o \
     32$(SRC)/psps_ids.$(ARCH).o \
    2833$(SRC)/SkyTablePopulatedRange.$(ARCH).o \
    2934$(SRC)/LoadCatalog.$(ARCH).o \

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

    r24745 r27435  
    2222char   CATMODE[16];    /* raw, mef, split, mysql */
    2323char   CATFORMAT[16];  /* internal, elixir, loneos, panstarrs */
     24char   ImageCat[256];
    2425float  RADIUS;
    2526int    SKY_DEPTH;
    … …  
    2728SkyRegion UserPatch;  // used by MODE CAT
    2829
     30typedef struct {
     31  off_t Nmap;
     32  off_t *old;
     33  off_t *new;
     34} IDmapType;
     35
    2936int        main                   PROTO((int argc, char **argv));
     37int        dvomergeCreate         PROTO((int argc, char **argv));
     38int        dvomergeUpdate         PROTO((int argc, char **argv));
    3039
    3140int        ConfigInit             PROTO((int *argc, char **argv));
    … …  
    3544void       SetProtect             PROTO((int mode));
    3645void       TrapSignal             PROTO((int sig));
    37 int        Shutdown               PROTO((char *format, ...));
     46int        Shutdown               PROTO((char *format, ...)) OHANA_FORMAT(printf, 1, 2);
    3847
    3948void       usage                  PROTO((void));
    40 int        SkyTablePopulatedRange PROTO((int *ns, int *ne, SkyTable *sky, int Nstart));
     49void       help                   PROTO((int argc, char **argv));
     50int        args                   PROTO((int *argc, char **argv));
     51
     52int        SkyTablePopulatedRange PROTO((off_t *ns, off_t *ne, SkyTable *sky, off_t Nstart));
    4153
    4254SkyList   *SkyTablePopulatedList  PROTO((SkyTable *sky));
    43 SkyList   *SkyTablePopulatedList_old  PROTO((SkyTable *sky, int Ns, int Ne));
     55SkyList   *SkyTablePopulatedList_old  PROTO((SkyTable *sky, off_t Ns, off_t Ne));
    4456
    4557int        LoadCatalog            PROTO((Catalog *catalog, SkyRegion *region, char *filename, char *mode));
    … …  
    4860int        merge_catalogs_old     PROTO((SkyRegion *region, Catalog *output, Catalog *input, double RADIUS));
    4961
    50 int       *init_measure_links     PROTO((Average *average, int Naverage, Measure *measure, int Nmeasure));
    51 int       *init_missing_links     PROTO((Average *average, int Naverage, Missing *missing, int Nmissing));
    52 int       *build_measure_links    PROTO((Average *average, int Naverage, Measure *measure, int Nmeasure));
    53 int        add_meas_link          PROTO((Average *average, int *next, int Nmeasure, int NMEASURE));
    54 int        add_miss_link          PROTO((Average *average, int *next, int Nmissing));
    55 Measure   *sort_measure           PROTO((Average *average, int Naverage, Measure *measure, int Nmeasure, int *next));
    56 Missing   *sort_missing           PROTO((Average *average, int Naverage, Missing *missing, int Nmissing, int *next_miss));
     62off_t     *init_measure_links     PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure));
     63off_t     *init_missing_links     PROTO((Average *average, off_t Naverage, Missing *missing, off_t Nmissing));
     64off_t     *build_measure_links    PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure));
     65int        add_meas_link          PROTO((Average *average, off_t *next, off_t Nmeasure, off_t NMEASURE));
     66int        add_miss_link          PROTO((Average *average, off_t *next, off_t Nmissing));
     67Measure   *sort_measure           PROTO((Average *average, off_t Naverage, Measure *measure, off_t Nmeasure, off_t *next));
     68Missing   *sort_missing           PROTO((Average *average, off_t Naverage, Missing *missing, off_t Nmissing, off_t *next_miss));
     69
     70uint64_t   CreatePSPSDetectionID  PROTO((double tobs, int ccdid, int detID));
     71uint64_t   CreatePSPSObjectID     PROTO((double ra, double dec));
     72
     73int        dvomergeImagesCreate   PROTO((IDmapType *IDmap1, char *input1, IDmapType *IDmap2, char *input2, char *output));
     74int        dvomergeImagesUpdate   PROTO((IDmapType *IDmap, char *input, char *output));
     75int        dvo_image_merge_dbs    PROTO((IDmapType *IDmap, FITS_DB *out, FITS_DB *in));
     76off_t      dvo_map_image_ID       PROTO((IDmapType *IDmap, off_t oldID));
     77int        dvo_update_image_IDs   PROTO((IDmapType *IDmap, Catalog *catalog));

  • trunk/Ohana/src/dvomerge/src/ConfigInit.c

    r24750 r27435  
    44
    55  double ZERO_POINT;
     6  char RadiusWord[80];
    67  char *config, *file;
    7   char CatdirPhotcodeFile[256];
    8   char MasterPhotcodeFile[256];
    98
    109  /*** load configuration info ***/
    1110  file = SelectConfigFile (argc, argv, "ptolemy");
     11
    1212  config = LoadConfigFile (file);
    1313  if (config == (char *) NULL) {
    … …  
    1818  if (VERBOSE) fprintf (stderr, "loaded config file: %s\n", file);
    1919
    20   GetConfig (config, "PHOTCODE_FILE",           "%s",  0, MasterPhotcodeFile);
     20
    2121  GetConfig (config, "GSCFILE",                 "%s",  0, GSCFILE);
    2222  ScanConfig (config, "CATMODE",                "%s",  0, CATMODE);
    2323  ScanConfig (config, "CATFORMAT",              "%s",  0, CATFORMAT);
    24   ScanConfig (config, "RADIUS",                 "%f",  0, &RADIUS);
    2524  GetConfig (config, "SKY_DEPTH",              "%d",  0, &SKY_DEPTH);
    2625  if (SKY_DEPTH > 4) {
    … …  
    3635  SetZeroPoint (ZERO_POINT);
    3736
     37  /* set the default search radius */
     38  if (!ScanConfig (config, "ADDSTAR_RADIUS", "%s", 0, RadiusWord)) {
     39    GetConfig (config, "RADIUS", "%s", 0, RadiusWord);
     40  }
     41  RADIUS = atof (RadiusWord);
    3842  if (RADIUS < 1e-6) {
    3943      fprintf (stderr, "non-sensical correlation radius %f\n", RADIUS);

  • trunk/Ohana/src/dvomerge/src/SkyTablePopulatedRange.c

    r24745 r27435  
    11# include "dvomerge.h"
    22
    3 int SkyTablePopulatedRange (int *ns, int *ne, SkyTable *sky, int Nstart) {
     3int SkyTablePopulatedRange (off_t *ns, off_t *ne, SkyTable *sky, off_t Nstart) {
    44
    5   int Ns, Ne;
     5  off_t Ns, Ne;
    66
    77  // given the starting sky region, find the populated range at or below this region
    … …  
    2626SkyList *SkyTablePopulatedList (SkyTable *sky) {
    2727
    28   int i, N, NREGIONS;
    29   SkyList *list, *subset;
     28  off_t i, N, NREGIONS;
     29  SkyList *list;
    3030
    3131  N = 0;
    … …  
    5454}
    5555
    56 SkyList *SkyTablePopulatedList_old (SkyTable *sky, int Ns, int Ne) {
     56SkyList *SkyTablePopulatedList_old (SkyTable *sky, off_t Ns, off_t Ne) {
    5757
    58   int i, ns, ne, N, NREGIONS;
     58  off_t i, ns, ne, N, NREGIONS;
    5959  SkyList *list, *subset;
    6060

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

    r24745 r27435  
    11# include "dvomerge.h"
    2 static void help (void);
    32
    4 int args (int argc, char **argv) {
     3/*** check for command line options ***/
     4int args (int *argc, char **argv) {
    55 
    6   int i, N, CONFIRM;
    7 
    8   /* check for help request */
    9   if (get_argument (argc, argv, "-help") ||
    10       get_argument (argc, argv, "-h")) {
    11     help ();
    12   }
    13 
    14   /*** check for command line options ***/
     6  int N, CONFIRM;
    157
    168  /*** provide additional data ***/
    … …  
    2113  UserPatch.Dmax = +90;
    2214  CONFIRM = TRUE;
    23   if ((N = get_argument (argc, argv, "-region"))) {
    24     remove_argument (N, &argc, argv);
     15  if ((N = get_argument (*argc, argv, "-region"))) {
     16    remove_argument (N, argc, argv);
    2517    UserPatch.Rmin = atof (argv[N]);
    26     remove_argument (N, &argc, argv);
     18    remove_argument (N, argc, argv);
    2719    UserPatch.Rmax = atof (argv[N]);
    28     remove_argument (N, &argc, argv);
     20    remove_argument (N, argc, argv);
    2921    UserPatch.Dmin = atof (argv[N]);
    30     remove_argument (N, &argc, argv);
     22    remove_argument (N, argc, argv);
    3123    UserPatch.Dmax = atof (argv[N]);
    32     remove_argument (N, &argc, argv);
     24    remove_argument (N, argc, argv);
    3325    CONFIRM = FALSE;
    3426  }
    … …  
    3628  /* extra error messages */
    3729  VERBOSE = FALSE;
    38   if ((N = get_argument (argc, argv, "-v"))) {
     30  if ((N = get_argument (*argc, argv, "-v"))) {
    3931    VERBOSE = TRUE;
    40     remove_argument (N, &argc, argv);
     32    remove_argument (N, argc, argv);
    4133  }
    4234
    43   if (argc == 2) {
    44     if (CONFIRM) {
    45       fprintf (stderr, "you are splitting the entire sky in one pass\n");
    46       fprintf (stderr, "this could be a time consuming operation.  type Ctrl-C within 5 seconds to cancel\n");
    47       for (i = 5; i > 0; i--) {
    48         fprintf (stderr, "%d.. ", i);
    49         usleep (1000000);
    50       }
    51       fprintf (stderr, "\n");
    52     }   
    53     return (TRUE);
    54   }
    55 
    56   fprintf (stderr, "USAGE: dvosplit (newlevel) [-region (Rmin) (Rmax) (Dmin) (Dmax)]\n");
    57   exit (2);
     35  if ((*argc != 6) && (*argc != 4)) usage();
     36  return TRUE;
    5837}
    59 
    60 static void help () {
    61 
    62   fprintf (stderr, "USAGE\n");
    63   fprintf (stderr, "  dvosplit (newlevel)\n\n");
    64   fprintf (stderr, "  optional flags:\n");
    65   fprintf (stderr, "  -region ra ra dec dec       : migrate catalogs in specified region\n");
    66   fprintf (stderr, "  -v                          : verbose mode\n");
    67   fprintf (stderr, "  -help                       : this list\n");
    68   fprintf (stderr, "  -h                          : this list\n\n");
    69   exit (2);
    70 }
    71 
    72 /** addstar modes:
    73  
    74     addstar (image.smp)  - add cmp/smp image data to db
    75     addstar -ref (file.dat) (photcode)
    76     addstar -cat (USNO/2MASS/GSC) -region (ra dec - ra dec)
    77 
    78     -replace : ref/cat - replace existing match (photcode/time)
    79     -match   : ref/cat - only add measures to existing averages
    80 
    81     ref types:
    82     ASCII - RA,DEC,M,dM in a table
    83 
    84     addstar
    85 
    86 **/
    87 

  • trunk/Ohana/src/dvomerge/src/build_links.c

    r24745 r27435  
    33/* build the initial links assuming the table is sorted,
    44   not partial, and has a correct set of average[].measureOffset,Nmeasure values */
    5 int *init_measure_links (Average *average, int Naverage, Measure *measure, int Nmeasure) {
    6 
    7   int i, j, N;
    8   int *next;
     5off_t *init_measure_links (Average *average, off_t Naverage, Measure *measure, off_t Nmeasure) {
     6
     7  off_t i, j, N;
     8  off_t *next;
    99
    1010  N = 0;
    1111
    12   ALLOCATE (next, int, Nmeasure);
     12  ALLOCATE (next, off_t, Nmeasure);
    1313  for (i = 0; i < Naverage; i++, N++) {
    1414    for (j = 0; j < average[i].Nmeasure - 1; j++, N++) {
    … …  
    3131}
    3232
     33/* average[].measureOffset, average[].Nmeasure are valid within an addstar run */
     34int add_meas_link (Average *average, off_t *next, off_t Nmeasure, off_t NMEASURE) {
     35
     36  off_t k, m;
     37
     38  /* if we have trouble, check validity of next[m] : m < Nmeasure */
     39  m = average[0].measureOffset; 
     40
     41  for (k = 0; k < average[0].Nmeasure - 1; k++)  {
     42    m = next[m];
     43    if (m >= NMEASURE) {
     44      fprintf (stderr, "WARNING: m out of bounds (3)\n");
     45    }
     46  }
     47
     48  /* set up references */
     49  next[Nmeasure] = -1;
     50  if (Nmeasure >= NMEASURE) {
     51    fprintf (stderr, "WARNING: Nmeasure out of bounds (1)\n");
     52  }
     53
     54  if (m == -1) {
     55    average[0].measureOffset = Nmeasure;
     56  } else {
     57    next[m] = Nmeasure;
     58    if (m >= NMEASURE) {
     59      fprintf (stderr, "WARNING: m out of bounds (4)\n");
     60    }
     61  }
     62
     63  return (TRUE);
     64}
     65
     66Measure *sort_measure (Average *average, off_t Naverage, Measure *measure, off_t Nmeasure, off_t *next) {
     67
     68  off_t i, k, n, N;
     69  Measure *tmpmeasure;
     70
     71  /* fix order of Measure (memory intensive, but fast) */
     72  N = 0;
     73  ALLOCATE (tmpmeasure, Measure, Nmeasure);
     74  for (i = 0; i < Naverage; i++) {
     75    n = average[i].measureOffset;
     76    average[i].measureOffset = N;
     77    for (k = 0; k < average[i].Nmeasure; k++, N++) {
     78      tmpmeasure[N] = measure[n];
     79      tmpmeasure[N].averef = i;
     80      n = next[n];
     81    }
     82  }
     83  free (measure);
     84  return (tmpmeasure);
     85}
     86
     87/* construct measure links which are valid FOR THIS LOAD
     88 * - if we have a full load, we will get links which can
     89 *   be used by other programs (eg, relphot, etc)
     90 * - if we have a partial load, the links are only valid
     91 *   for that partial load
     92 */
     93
     94off_t *build_measure_links (Average *average, off_t Naverage, Measure *measure, off_t Nmeasure) {
     95
     96  off_t i, m, k, Nm, averef;
     97  off_t *next;
     98
     99  ALLOCATE (next, off_t, Nmeasure);
     100
     101  /* reset the Nm, offset values for average */
     102  for (i = 0; i < Naverage; i++) {
     103    average[i].measureOffset = -1;
     104    average[i].Nmeasure     =  0;
     105  }
     106
     107  for (Nm = 0; Nm < Nmeasure; Nm++) {
     108    averef = measure[Nm].averef;
     109    m = average[averef].measureOffset; 
     110    next[Nm] = -1;
     111
     112    if (m == -1) { /* no links yet for source */
     113      average[averef].measureOffset = Nm;
     114      average[averef].Nmeasure     = 1;
     115      continue;
     116    }
     117
     118    for (k = 0; next[m] != -1; k++) {
     119      m = next[m];
     120      if (m >= Nmeasure) {
     121        fprintf (stderr, "WARNING: m out of bounds (1)\n");
     122      }
     123    }
     124
     125    average[averef].Nmeasure = k + 2;
     126    next[m] = Nm;
     127    if (m >= Nmeasure) {
     128      fprintf (stderr, "WARNING: m out of bounds (2)\n");
     129    }
     130  }
     131  return (next);
     132}
     133
    33134/* build the initial links assuming the table is sorted */
    34 int *init_missing_links (Average *average, int Naverage, Missing *missing, int Nmissing) {
    35 
    36   int i, j, N;
    37   int *next;
     135off_t *init_missing_links (Average *average, off_t Naverage, Missing *missing, off_t Nmissing) {
     136
     137  off_t i, j, N;
     138  off_t *next;
    38139
    39140  N = 0;
    40141
    41   ALLOCATE (next, int, Nmissing);
     142  ALLOCATE (next, off_t, Nmissing);
    42143  for (i = 0; i < Naverage; i++) {
    43144    for (j = 0; j < average[i].Nmissing - 1; j++, N++) {
    … …  
    57158}
    58159
    59 /* average[].measureOffset, average[].Nmeasure are valid within an addstar run */
    60 int add_meas_link (Average *average, int *next, int Nmeasure, int NMEASURE) {
    61 
    62   int k, m;
    63 
    64   /* if we have trouble, check validity of next[m] : m < Nmeasure */
    65   m = average[0].measureOffset; 
    66 
    67   for (k = 0; k < average[0].Nmeasure - 1; k++)  {
    68     m = next[m];
    69     if (m >= NMEASURE) {
    70       fprintf (stderr, "WARNING: m out of bounds (3)\n");
    71     }
    72   }
    73 
    74   /* set up references */
    75   next[Nmeasure] = -1;
    76   if (Nmeasure >= NMEASURE) {
    77     fprintf (stderr, "WARNING: Nmeasure out of bounds (1)\n");
    78   }
    79 
    80   if (m == -1) {
    81     average[0].measureOffset = Nmeasure;
    82   } else {
    83     next[m] = Nmeasure;
    84     if (m >= NMEASURE) {
    85       fprintf (stderr, "WARNING: m out of bounds (4)\n");
    86     }
    87   }
    88 
    89   return (TRUE);
    90 }
    91 
    92 int add_miss_link (Average *average, int *next, int Nmissing) {
    93 
    94   int k, m;
     160int add_miss_link (Average *average, off_t *next, off_t Nmissing) {
     161
     162  off_t k, m;
    95163
    96164  /* there may be 0 Nmiss; this is not true for Nmeas */
    … …  
    109177}
    110178
    111 /* construct measure links which are valid FOR THIS LOAD
    112  * - if we have a full load, we will get links which can
    113  *   be used by other programs (eg, relphot, etc)
    114  * - if we have a partial load, the links are only valid
    115  *   for that partial load
    116  */
    117 
    118 int *build_measure_links (Average *average, int Naverage, Measure *measure, int Nmeasure) {
    119 
    120   int i, m, k, Nm, averef;
    121   int *next;
    122 
    123   ALLOCATE (next, int, Nmeasure);
    124 
    125   /* reset the Nm, offset values for average */
    126   for (i = 0; i < Naverage; i++) {
    127     average[i].measureOffset = -1;
    128     average[i].Nmeasure     =  0;
    129   }
    130 
    131   for (Nm = 0; Nm < Nmeasure; Nm++) {
    132     averef = measure[Nm].averef;
    133     m = average[averef].measureOffset; 
    134     next[Nm] = -1;
    135 
    136     if (m == -1) { /* no links yet for source */
    137       average[averef].measureOffset = Nm;
    138       average[averef].Nmeasure     = 1;
    139       continue;
    140     }
    141 
    142     for (k = 0; next[m] != -1; k++) {
    143       m = next[m];
    144       if (m >= Nmeasure) {
    145         fprintf (stderr, "WARNING: m out of bounds (1)\n");
    146       }
    147     }
    148 
    149     average[averef].Nmeasure = k + 2;
    150     next[m] = Nm;
    151     if (m >= Nmeasure) {
    152       fprintf (stderr, "WARNING: m out of bounds (2)\n");
    153     }
    154   }
    155   return (next);
    156 }
    157 
    158179/* Missing does not carry enough information to reconstruct the links
    159180   we must always save the missing table, if it exists */
    160181
    161 Measure *sort_measure (Average *average, int Naverage, Measure *measure, int Nmeasure, int *next) {
    162 
    163   int i, k, n, N;
    164   Measure *tmpmeasure;
    165 
    166   /* fix order of Measure (memory intensive, but fast) */
    167   N = 0;
    168   ALLOCATE (tmpmeasure, Measure, Nmeasure);
    169   for (i = 0; i < Naverage; i++) {
    170     n = average[i].measureOffset;
    171     average[i].measureOffset = N;
    172     for (k = 0; k < average[i].Nmeasure; k++, N++) {
    173       tmpmeasure[N] = measure[n];
    174       tmpmeasure[N].averef = i;
    175       n = next[n];
    176     }
    177   }
    178   free (measure);
    179   return (tmpmeasure);
    180 }
    181 
    182 Missing *sort_missing (Average *average, int Naverage, Missing *missing, int Nmissing, int *next) {
    183 
    184   int i, k, n, N;
     182Missing *sort_missing (Average *average, off_t Naverage, Missing *missing, off_t Nmissing, off_t *next) {
     183
     184  off_t i, k, n, N;
    185185  Missing *tmpmissing;
    186186

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

    r25757 r27435  
    11# include "dvomerge.h"
    22
    3 // dvomerge (catdir.in1) and (catdir.in2) to (catdir.output) [-region Rmin Rmax Dmin Dmax] [
    4 // merge sources from (catdir.from) into (catdir.to)
    53int main (int argc, char **argv) {
    64
    7   int i, j, Ns, Ne, depth1, depth2;
    8   SkyTable *outsky, *insky1, *insky2;
    9   SkyList *inlist;
    10   Catalog incatalog, outcatalog;
    11   char filename[256], *input1, *input2, *output;
     5  SetSignals ();
     6  help (argc, argv);
     7  ConfigInit (&argc, argv);
     8  args (&argc, argv);
    129
    13   SetSignals ();
    14   ConfigInit (&argc, argv);
    15 
    16   if (argc != 6) usage();
    17   if (strcasecmp (argv[2], "and")) usage();
    18   if (strcasecmp (argv[4], "to")) usage();
    19 
    20   input1 = argv[1];
    21   input2 = argv[3];
    22   output = argv[5];
    23 
    24   // the first input define the photcode table & db layout
    25   sprintf (filename, "%s/Photcodes.dat", input1);
    26   if (!LoadPhotcodes (filename, NULL, FALSE)) {
    27     fprintf (stderr, "error loading photcode table %s\n", filename);
    28     exit (1);
    29   }
    30   // save the photcodes in the output catdir
    31   sprintf (filename, "%s/Photcodes.dat", output);
    32   if (!check_file_access (filename, TRUE, TRUE, TRUE)) {
    33     fprintf (stderr, "error creating output catdir %s\n", output);
    34     exit (1);
    35   }
    36   if (!SavePhotcodesFITS (filename)) {
    37     fprintf (stderr, "error saving photcode table %s\n", filename);
    38     exit (1);
    39   }
    40 
    41   // load the sky table for the existing database
    42   insky1 = SkyTableLoadOptimal (input1, NULL, NULL, FALSE, SKY_DEPTH_HST, VERBOSE);
    43   SkyTableSetFilenames (insky1, input1, "cpt");
    44 
    45   insky2 = SkyTableLoadOptimal (input2, NULL, NULL, FALSE, SKY_DEPTH_HST, VERBOSE);
    46   SkyTableSetFilenames (insky2, input2, "cpt");
    47 
    48   // generate an output table populated at the desired depth
    49   outsky = SkyTableLoadOptimal (output, NULL, GSCFILE, TRUE, SKY_DEPTH, VERBOSE);
    50   SkyTableSetFilenames (outsky, output, "cpt");
    51 
    52   // loop over the populatable output tables; check for data in input1 and/or input2
    53   // in the corresponding regions
    54 
    55   SkyTablePopulatedRange (&Ns, &Ne, insky1, 0);
    56   depth1 = insky1[0].regions[Ns].depth;
    57  
    58   SkyTablePopulatedRange (&Ns, &Ne, insky2, 0);
    59   depth2 = insky2[0].regions[Ns].depth;
    60 
    61   // loop over the populatable output regions
    62   for (i = 0; i < outsky[0].Nregions; i++) {
    63     if (!outsky[0].regions[i].table) continue;
    64     fprintf (stderr, "output: %s\n", outsky[0].regions[i].name);
    65 
    66     // load / create output catalog
    67     LoadCatalog (&outcatalog, &outsky[0].regions[i], outsky[0].filename[i], "w");
    68 
    69     // combine only tables at equal or larger depth
    70      
    71     // load in all of the tables from input1 for this region
    72     inlist = SkyListByBounds (insky1, depth1, outsky[0].regions[i].Rmin, outsky[0].regions[i].Rmax, outsky[0].regions[i].Dmin, outsky[0].regions[i].Dmax);
    73     for (j = 0; j < inlist[0].Nregions; j++) {
    74       fprintf (stderr, "input 1: %s\n", inlist[0].regions[j][0].name);
    75 
    76       // load input catalog (1)
    77       LoadCatalog (&incatalog, inlist[0].regions[j], inlist[0].filename[j], "r");
    78 
    79       // skip empty input catalogs
    80       if (!incatalog.Naves_disk) {
    81         dvo_catalog_unlock (&incatalog);
    82         dvo_catalog_free (&incatalog);
    83         continue;
    84       }
    85       merge_catalogs_new (&outsky[0].regions[i], &outcatalog, &incatalog);
    86       dvo_catalog_unlock (&incatalog);
    87       dvo_catalog_free (&incatalog);
    88     }
    89     SkyListFree (inlist);
    90 
    91     // load in all of the tables from input2 for this region
    92     inlist = SkyListByBounds (insky2, depth2, outsky[0].regions[i].Rmin, outsky[0].regions[i].Rmax, outsky[0].regions[i].Dmin, outsky[0].regions[i].Dmax);
    93     for (j = 0; j < inlist[0].Nregions; j++) {
    94       fprintf (stderr, "input 2: %s\n", inlist[0].regions[j][0].name);
    95 
    96       // load input catalog (1)
    97       LoadCatalog (&incatalog, inlist[0].regions[j], inlist[0].filename[j], "r");
    98 
    99       // skip empty input catalogs
    100       if (!incatalog.Naves_disk) {
    101         dvo_catalog_unlock (&incatalog);
    102         dvo_catalog_free (&incatalog);
    103         continue;
    104       }
    105       merge_catalogs_old (&outsky[0].regions[i], &outcatalog, &incatalog, RADIUS);
    106       dvo_catalog_unlock (&incatalog);
    107       dvo_catalog_free (&incatalog);
    108     }
    109     SkyListFree (inlist);
    110 
    111     outcatalog.catflags = LOAD_AVES | LOAD_MEAS | LOAD_MISS | LOAD_SECF;
    112     dvo_catalog_save (&outcatalog, VERBOSE);
    113     dvo_catalog_unlock (&outcatalog);
    114     dvo_catalog_free (&outcatalog);
    115   }
    116 
    117   // save the output sky table copy
    118   sprintf (filename, "%s/SkyTable.fits", output);
    119   check_file_access (filename, TRUE, TRUE, VERBOSE);
    120   if (!SkyTableSave (outsky, filename)) {
    121     fprintf (stderr, "ERROR: failed to save sky table for %s\n", output);
    122     exit (1);
    123   }
    124 
    125   exit (0);
     10  if (argc == 6) dvomergeCreate (argc, argv);
     11  if (argc == 4) dvomergeUpdate (argc, argv);
     12  usage();
     13  exit (2); // cannot reach here.
    12614}
    12715
    128 /*
     16/* we have two possible modes of operation:
    12917
    130    for the upgrade of the synth database, at a minimum I need to use an output format that uses
    131    doubles for the astrometry.  Optionally I should merge in the 2MASS photometry measurements, since that
    132    would be quite useful for comparison. 
     18   Create : dvomerge (in1) and (in2) to (out) -- create a new db from two input dbs
     19   Update : dvomerge (in) into (out)          -- merge a new db into an existing db
    13320
    134    generality questions:
    135    * optional
    136 
    137 
    138 
    139    */
    140 
     21*/

  • trunk/Ohana/src/dvomerge/src/merge_catalogs.c

    r24745 r27435  
    55int merge_catalogs_new (Catalog *output, Catalog *input) {
    66 
    7   int i, j, offset;
    8   int NAVERAGE, NMEASURE, Naverage, Nmeasure, Nsecfilt, Nm;
     7  off_t i, j, offset;
     8  off_t NAVERAGE, NMEASURE, Naverage, Nmeasure, Nsecfilt, Nm;
    99
    1010  Naverage = output[0].Naverage;

  • trunk/Ohana/src/dvomerge/src/merge_catalogs_new.c

    r24745 r27435  
    99int merge_catalogs_new (SkyRegion *region, Catalog *output, Catalog *input) {
    1010 
    11   int i, j, offset;
    12   int NAVERAGE, NMEASURE, Naverage, Nmeasure, Nsecfilt, Nm;
     11  off_t i, j, offset;
     12  off_t NAVERAGE, NMEASURE, Naverage, Nmeasure, Nsecfilt, Nm;
    1313
    1414  Naverage = output[0].Naverage;
    … …  
    6464  output[0].Nmeasure = Nmeasure;
    6565  output[0].Nsecf_mem = Naverage * Nsecfilt;
     66
     67  // If we are using dvomergeCreate to split an existing catalog, then the max objID in
     68  // each of the new subdivisions of the original catalog is the max objID of the original
     69  // catalog.  It is not allowed to use dvomerge to unify catalogs to a lower-resolution
     70  // partition.
     71  output[0].objID = input[0].objID; // new max value, save on catalog close
    6672 
    6773  if (VERBOSE) {
    68       fprintf (stderr, "%d: using %d stars (%d measures) for catalog\n", i,
    69                output[0].Naverage, output[0].Nmeasure);
     74      fprintf (stderr, "%lld: using %lld stars (%lld measures) for catalog\n",
     75               (long long) i,
     76               (long long) output[0].Naverage,
     77               (long long) output[0].Nmeasure);
    7078  }
    7179  return (TRUE);

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

    r24750 r27435  
    11# include "dvomerge.h"
     2# define PSPS_ID TRUE
    23
    34# define IN_REGION(R,D) ( \
    … …  
    910int merge_catalogs_old (SkyRegion *region, Catalog *output, Catalog *input, double RADIUS) {
    1011
    11   int i, j, n, N, Nin, offset, J, Jmin, status, Nstars;
     12  off_t i, j, n, N, Nin, offset, J, Jmin, status, Nstars;
    1213  double RADIUS2, Rmin, Rin, Din;
    1314  double *X1, *Y1, *X2, *Y2;
    1415  double dX, dY, dR;
    15   int *N1, *N2,  *next_meas;
    16   int Nave, NAVE, Nmeas, NMEAS, Nmatch;
     16  off_t *N1, *N2,  *next_meas;
     17  off_t Nave, NAVE, Nmeas, NMEAS, Nmatch;
    1718  int Nsecfilt;
    1819  unsigned int objID, catID;
    … …  
    2425  ALLOCATE (X1, double, input[0].Naverage);
    2526  ALLOCATE (Y1, double, input[0].Naverage);
    26   ALLOCATE (N1, int,    input[0].Naverage);
    27   ALLOCATE (input[0].found, int, input[0].Naverage);
     27  ALLOCATE (N1, off_t,  input[0].Naverage);
     28  ALLOCATE (input[0].found, off_t, input[0].Naverage);
    2829
    2930  /** allocate local arrays (catalog) **/
    … …  
    3132  ALLOCATE (X2, double, NAVE);
    3233  ALLOCATE (Y2, double, NAVE);
    33   ALLOCATE (N2, int,    NAVE);
    34   ALLOCATE (output[0].found, int, NAVE);
     34  ALLOCATE (N2, off_t,    NAVE);
     35  ALLOCATE (output[0].found, off_t, NAVE);
    3536  /* for secfilt j and star i, secfilt[i*Nsecfilt+j] */
    3637
    … …  
    119120    /* negative dX: j is too large */
    120121    dX = X1[i] - X2[j];
    121     if (dX <= -2*RADIUS) {
     122    if (dX <= -1.02*RADIUS) {
    122123      i++;
    123124      continue;
    124125    }
    125126    /* positive dX, i is too large */
    126     if (dX >= 2*RADIUS) {
     127    if (dX >= 1.02*RADIUS) {
    127128      j++;
    128129      continue;
    … …  
    131132    Jmin = -1;
    132133    Rmin = RADIUS2;
    133     for (J = j; (dX > -2*RADIUS) && (J < Nave); J++) {
     134    for (J = j; (dX > -1.02*RADIUS) && (J < Nave); J++) {
    134135      /* find closest match for this detection */
    135136      dX = X1[i] - X2[J];
    … …  
    157158    if (Nmeas + input[0].average[N].Nmeasure >= NMEAS) {
    158159      NMEAS = Nmeas + input[0].average[N].Nmeasure + 1000;
    159       REALLOCATE (next_meas, int, NMEAS);
     160      REALLOCATE (next_meas, off_t, NMEAS);
    160161      REALLOCATE (output[0].measure, Measure, NMEAS);
    161162    }
    162163
    163     /** add measurements for this input average object **/
     164    /** add ALL measurements for this input average object **/
    164165    for (Nin = 0; Nin < input[0].average[N].Nmeasure; Nin ++) {
    165166      offset = input[0].average[N].measureOffset + Nin;
    … …  
    169170       
    170171      // set the new measurements
    171       output[0].measure[Nmeas]          = input[0].measure[offset];
     172      output[0].measure[Nmeas] = input[0].measure[offset];
    172173
    173174      Rin = input[0].average[N].R - input[0].measure[offset].dR / 3600.0;
    … …  
    177178      output[0].measure[Nmeas].dR       = 3600.0*(output[0].average[n].R - Rin);  // XXX update these based on choice of astromety
    178179      output[0].measure[Nmeas].dD       = 3600.0*(output[0].average[n].D - Din);  // XXX update these based on choice of astromety
    179       output[0].measure[Nmeas].dbFlags  = 0;
     180      output[0].measure[Nmeas].dbFlags  = 0;  // XXX why reset these?
    180181      output[0].measure[Nmeas].averef   = n;
    181182      output[0].measure[Nmeas].objID    = output[0].average[n].objID;
    182183      output[0].measure[Nmeas].catID    = output[0].catID;
     184
     185      // fprintf (stderr, "Nave : %lld, Nmeas : %lld, dR: %f, dD: %f, catID: %d\n", (long long) n, (long long) Nmeas, output[0].measure[Nmeas].dR, output[0].measure[Nmeas].dD, output[0].measure[i].catID);
    183186
    184187      // rationalize dR
    … …  
    197200                 output[0].average[n].R, output[0].average[n].D, Rin, Din,
    198201                 X1[i], X2[Jmin], Y1[i], Y2[Jmin]);
     202        // XXX abort on this? -- this is a bad failure...
    199203      }
    200204      input[0].found[N] = Nmeas;
     205      output[0].average[n].Nmeasure ++;
    201206      Nmeas ++;
    202207    }
    … …  
    205210       Nm is recalculated in build_meas_links if loaded table is not sorted */
    206211    output[0].found[n] = Nmeas;
    207     output[0].average[n].Nmeasure ++;
    208212    i++;
    209213  }
     214
     215# if (0)
     216  fprintf (stderr, "--- 1 ---\n");
     217  for (i = 0; i < Nmeas; i++) {
     218    fprintf (stderr, "Nave : %d, Nmeas : %lld, dR: %f, dD: %f, catID: %d\n", output[0].measure[i].averef, (long long) i, output[0].measure[i].dR, output[0].measure[i].dD, output[0].measure[i].catID);
     219  }
     220# endif
    210221
    211222  /** incorporate unmatched image stars, if this star is in field of this catalog **/
    212223  /* these new entries are all written out in UPDATE mode */
    213224  for (i = 0; i < Nstars; i++) {
    214 
    215     N = N1[i];
    216     if (input[0].found[N] >= 0) continue;
    217     if (!IN_REGION (input[0].average[N].R, input[0].average[N].D)) continue;
    218 
    219225    /* make sure there is space for next entry */
    220226    if (Nmeas + input[0].average[N].Nmeasure >= NMEAS) {
    221227      NMEAS = Nmeas + input[0].average[N].Nmeasure + 1000;
    222       REALLOCATE (next_meas, int, NMEAS);
     228      REALLOCATE (next_meas, off_t, NMEAS);
    223229      REALLOCATE (output[0].measure, Measure, NMEAS);
    224230    }
    … …  
    229235    }
    230236
     237    N = N1[i];
     238    if (input[0].found[N] >= 0) continue;
     239    if (!IN_REGION (input[0].average[N].R, input[0].average[N].D)) continue;
     240
    231241    output[0].average[Nave].R              = input[0].average[N].R;
    232242    output[0].average[Nave].D              = input[0].average[N].D;
    … …  
    238248    output[0].average[Nave].Nextend        = 0;
    239249
    240     output[0].average[Nave].measureOffset = Nmeas;
    241     output[0].average[Nave].missingOffset = -1;
    242     output[0].average[Nave].extendOffset  = -1;
     250    output[0].average[Nave].measureOffset  = Nmeas;
     251    output[0].average[Nave].missingOffset  = -1;
     252    output[0].average[Nave].extendOffset   = -1;
    243253
    244254    output[0].average[Nave].uR             = 0;
    … …  
    253263    output[0].average[Nave].Npos           = 0;
    254264
    255     output[0].average[Nave].objID          = objID;
    256     output[0].average[Nave].catID          = catID;
    257     output[0].average[Nave].flags         = 0;
     265    output[0].average[Nave].objID          = objID; // we create objID values in the context of the output db
     266    output[0].average[Nave].catID          = catID; // we create catID values in the context of the output db
     267    output[0].average[Nave].flags          = 0;  // XXX why reset these?
     268    if (PSPS_ID) {
     269      output[0].average[Nave].extID = CreatePSPSObjectID(output[0].average[Nave].R, output[0].average[Nave].D);
     270    } else {
     271      output[0].average[Nave].extID = 0;
     272    }
    258273
    259274    objID ++;
    … …  
    288303      Nmeas ++;
    289304    }
     305    int Ngroup = input[0].average[N].Nmeasure;
     306    for (j = 0; j < Ngroup - 1; j++) {
     307        next_meas[Nmeas - Ngroup + j] = Nmeas - Ngroup + j + 1;
     308    }
    290309    Nave ++;
    291310  }
    … …  
    294313  REALLOCATE (output[0].measure, Measure, Nmeas);
    295314 
    296 # define NOSORT TRUE
     315# if (0)
     316  fprintf (stderr, "--- 2 ---\n");
     317  for (i = 0; i < Nmeas; i++) {
     318    fprintf (stderr, "Nave : %d, Nmeas : %lld, dR: %f, dD: %f, catID: %d\n", output[0].measure[i].averef, (long long) i, output[0].measure[i].dR, output[0].measure[i].dD, output[0].measure[i].catID);
     319  }
     320# endif
     321
     322# define NOSORT FALSE
    297323  if (NOSORT) {
    298324    output[0].sorted = FALSE;
    … …  
    301327    output[0].measure = sort_measure (output[0].average, Nave, output[0].measure, Nmeas, next_meas);
    302328  }
     329
     330# if (0)
     331  fprintf (stderr, "--- 3 ---\n");
     332  for (i = 0; i < Nmeas; i++) {
     333    fprintf (stderr, "Nave : %d, Nmeas : %lld, dR: %f, dD: %f, catID: %d\n", output[0].measure[i].averef, (long long) i, output[0].measure[i].dR, output[0].measure[i].dD, output[0].measure[i].catID);
     334  }
     335# endif
    303336
    304337  /* note stars which have been found in this catalog */
    … …  
    316349  output[0].Nmeasure = Nmeas;
    317350  output[0].Nsecf_mem = Nave*Nsecfilt;
    318   if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: %d %d %d, (%d matches)\n", Nstars, Nave, Nmeas, Nmatch);
     351  if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: %lld %lld %lld, (%lld matches)\n", (long long) Nstars, (long long) Nave, (long long) Nmeas, (long long) Nmatch);
    319352
    320353  free (next_meas);

  • trunk/Ohana/src/dvosplit/include/dvosplit.h

    r24753 r27435  
    3535void       SetProtect             PROTO((int mode));
    3636void       TrapSignal             PROTO((int sig));
    37 int        Shutdown               PROTO((char *format, ...));
     37int        Shutdown               PROTO((char *format, ...) OHANA_FORMAT(printf, 1, 2));
    3838int        args                   PROTO((int argc, char **argv));
    3939

  • trunk/Ohana/src/elixir/src/DumpStatus.c

    r10336 r27435  
    1818    f = fsetlockfile (filename, 0.1, LCK_XCLD, &state);
    1919    if (f == NULL) return (2);
    20     fseek (f, 0, SEEK_END);
     20    fseeko (f, 0, SEEK_END);
    2121  } 
    2222 

  • trunk/Ohana/src/elixir/src/MachineOps.c

    r10336 r27435  
    454454    f = fsetlockfile (filename, 0.1, LCK_XCLD, &state);
    455455    if (f == NULL) return (2);
    456     fseek (f, 0, SEEK_END);
     456    fseeko (f, 0, SEEK_END);
    457457  } 
    458458

  • trunk/Ohana/src/elixir/src/MsgOps.c

    r10336 r27435  
    9999
    100100  /* write message to end of file */
    101   fseek (f, 0, SEEK_END);
     101  fseeko (f, 0, SEEK_END);
    102102  fprintf (f, "%s\n", message);
    103103

  • trunk/Ohana/src/elixir/src/ProcessOps.c

    r10336 r27435  
    203203  switch (Nterms) {
    204204  case 0:
    205     sprintf (line, format);
     205    sprintf (line, "%s", format);
    206206    break;
    207207  case 1:

  • trunk/Ohana/src/fixcat/src/aregion.c

    r19823 r27435  
    7979    NLINES += NDecLines[i];
    8080  }
    81   fseek (f, 5*2880 + 48*NLINES, SEEK_SET);
     81  fseeko (f, 5*2880 + 48*NLINES, SEEK_SET);
    8282     
    8383  done = FALSE;

  • trunk/Ohana/src/fixcat/src/find_bright_stars.c

    r16040 r27435  
    66{
    77
    8   int i, j, n, m, first_j, Nave, Ngsc;
     8  int j, n, m, first_j, Ngsc;
    99  Catalog GSCdata;
    1010  double MinRA, MinDEC, MaxRA, MaxDEC, RaCenter, DecCenter;
    1111  Coords *tcoords;
    1212  double *X1, *Y1, *X2, *Y2;
    13   int *N1, *N2;
     13  off_t i, Nave;
     14  off_t *N1, *N2;
    1415  char *mark;
    1516  double dX, dY, dR, MaxDist, MaxDist1, MaxRadius, radius, radius2;
    … …  
    2728  ALLOCATE (X1, double, Ngsc);
    2829  ALLOCATE (Y1, double, Ngsc);
    29   ALLOCATE (N1, int, Ngsc);
     30  ALLOCATE (N1, off_t, Ngsc);
    3031  ALLOCATE (mark, char, Nave);
    3132  bzero (mark, Nave);

  • trunk/Ohana/src/fixcat/src/find_images.c

    r7080 r27435  
    7373    exit (0);
    7474  }
    75   fseek (f, header.size, SEEK_SET);
     75  fseeko (f, header.datasize, SEEK_SET);
    7676
    7777  /* set up buffers for images, temporary storage */

  • trunk/Ohana/src/fixcat/src/find_matches.c

    r16040 r27435  
    1111  double *X1, *Y1, *X2, *Y2;
    1212  double dX, dY, dR;
    13   int *N1, *N2;
     13  off_t *N1, *N2;
    1414  int Nstar, Nghost, Ng;
    1515  unsigned int flags;
    … …  
    2929  ALLOCATE (X1, double, Nghost);
    3030  ALLOCATE (Y1, double, Nghost);
    31   ALLOCATE (N1, int, Nghost);
     31  ALLOCATE (N1, off_t, Nghost);
    3232
    3333  /* project ghosts to the frame of the catalog */

  • trunk/Ohana/src/fixcat/src/gcatalog.c

    r7080 r27435  
    2828    exit (0);
    2929  }
    30   fseek (f, catalog[0].header.size, SEEK_SET);
     30  fseeko (f, catalog[0].header.datasize, SEEK_SET);
    3131
    3232  /** find number of stars, measurements **/

  • trunk/Ohana/src/fixcat/src/gcatstats.c

    r16040 r27435  
    66{
    77
    8   int i;
     8  off_t i;
    99  double RaCenter, DecCenter;
    1010  double MinRA, MaxRA, MinDEC, MaxDEC;
    1111  double *X1, *Y1;
    12   int *N1;
    1312  Coords tcoords;
    1413 

  • trunk/Ohana/src/fixcat/src/wcatalog.c

    r7080 r27435  
    11# include "markstar.h"
    22
    3 wcatalog (catname, catalog)
    4 char *catname;
    5 Catalog catalog[];
    6 {
     3int wcatalog (char *catname, catalog *catalog) {
    74 
    8   int i, Nitems, nitems, status, mode;
     5  int status, mode;
     6  off_t i, Nitems, nitems;
    97  char filename[128], line[256];
    108  FILE *f;
    … …  
    3634  chmod (filename, mode);
    3735 
    38   gfits_modify (&catalog[0].header, "NSTARS", "%d", 1, catalog[0].Naverage);
    39   gfits_modify (&catalog[0].header, "NMEAS", "%d", 1, catalog[0].Nmeasure);
    40   gfits_modify (&catalog[0].header, "NMISS", "%d", 1, catalog[0].Nmissing);
     36  gfits_modify (&catalog[0].header, "NSTARS", "%lld", 1, catalog[0].Naverage);
     37  gfits_modify (&catalog[0].header, "NMEAS",  "%lld", 1, catalog[0].Nmeasure);
     38  gfits_modify (&catalog[0].header, "NMISS",  "%lld", 1, catalog[0].Nmissing);
    4139
    42   gfits_modify (&catalog[0].header, "MARKSTAR", "%t", 1, TRUE);
     40  gfits_modify_alt (&catalog[0].header, "MARKSTAR", "%t", 1, TRUE);
    4341
    44   nitems = Fwrite (catalog[0].header.buffer, 1, catalog[0].header.size, f, "char");
     42  nitems = Fwrite (catalog[0].header.buffer, 1, catalog[0].header.datasize, f, "char");
    4543  if (nitems != catalog[0].header.size) {
    4644    fprintf (stderr, "ERROR: failed to write header\n");
    … …  
    7169  fclose (f);
    7270
     71  return TRUE;
    7372}
    74 

  • trunk/Ohana/src/gastro/src/getusno.c

    r2435 r27435  
    1111USNOdata *getusno (USNOstats *usnostats, CatStats *catstats, int *Nusno) {
    1212
    13   long int offset;
     13  off_t offset;
    1414  int i, bin, first, last, nitems, Nitems, Nbins;
    1515  float hours[100];
    … …  
    9191    /* advance file pointer to first slice */
    9292    offset = 3*sizeof(int)*(start[first] - 1);
    93     fseek (f, offset, SEEK_SET);
     93    fseeko (f, offset, SEEK_SET);
    9494    /* on each loop, load data from an RA slice of the catalog */
    9595    for (bin = first; bin < last; bin++) {

  • trunk/Ohana/src/gastro/src/gfit.c

    r19823 r27435  
    77int gfit (SStars *stars1, SStars *stars2, int N1, int N2, Coords *coords, int NX, int NY, double *Radius, double *DR, int *Nmatch, int mode) {
    88 
    9   int i, j, iteration, Niter, last, halt, first_j, *Nextra, extras;
    10   int *tmpN1, *tmpN2;
     9  int i, j, iteration, Niter, last, halt, first_j, extras;
     10  off_t *tmpN1, *tmpN2;
    1111  double X_O, X_X, X_Y, dX;
    1212  double Y_O, Y_X, Y_Y, dY;
    … …  
    4242  ALLOCATE (tmpX1, double, N1);
    4343  ALLOCATE (tmpY1, double, N1);
    44   ALLOCATE (tmpN1, int, N1);
     44  ALLOCATE (tmpN1, off_t, N1);
    4545 
    4646  ALLOCATE (tmpX2, double, N2);
    4747  ALLOCATE (tmpY2, double, N2);
    48   ALLOCATE (tmpN2, int, N2);
    49   ALLOCATE (Nextra, int, N2);
    50   bzero (Nextra, sizeof(int) * N2);
     48  ALLOCATE (tmpN2, off_t, N2);
    5149
    5250  dX = dY = N = 0;

  • trunk/Ohana/src/gastro/src/gfitpoly.c

    r19823 r27435  
    55  int i, j, m, n, M, N;
    66  int first_j, last;
    7   int *tmpN1, *tmpN2;
     7  off_t *tmpN1, *tmpN2;
    88  int NORDER, NTERM, NPARS, NPOWR;
    99  double **sum, **xsum, **ysum;
    … …  
    5252  ALLOCATE (tmpX1, double, N1);
    5353  ALLOCATE (tmpY1, double, N1);
    54   ALLOCATE (tmpN1, int, N1);
     54  ALLOCATE (tmpN1, off_t, N1);
    5555
    5656  ALLOCATE (tmpX2, double, N2);
    5757  ALLOCATE (tmpY2, double, N2);
    58   ALLOCATE (tmpN2, int, N2);
     58  ALLOCATE (tmpN2, off_t, N2);
    5959
    6060  /* assign and sort list */

  • trunk/Ohana/src/gastro/src/gheader.c

    r12332 r27435  
    55  Header header;
    66  FILE *f, *g;
    7   int i, oldsize, nbytes, status;
     7  off_t i, oldsize, nbytes, status;
    88  char line[1024];
    99
    … …  
    1212    exit(0);
    1313  }
    14   oldsize = header.size;
     14  oldsize = header.datasize;
    1515
    1616  /* validating the photcode name should be the job of DVO/addstar */
    … …  
    2222  if (Nmatch < 2) {
    2323    gfits_modify (&header, "NASTRO", "%d", 1, 0);
    24     gfits_modify (&header, "NASTRO", "%C", 1, "number of stars used for astrometry");
     24    gfits_modify_alt (&header, "NASTRO", "%C", 1, "number of stars used for astrometry");
    2525    goto skipstuff;
    2626  }
    2727 
    2828  gfits_modify (&header, "NASTRO", "%d", 1, Nmatch);
    29   gfits_modify (&header, "NASTRO", "%C", 1, "number of stars used for astrometry");
     29  gfits_modify_alt (&header, "NASTRO", "%C", 1, "number of stars used for astrometry");
    3030
    3131  /*** use PutCoords to update header ***/
    … …  
    7373  }
    7474  gfits_modify (&header, "CERROR", "%lf", 1, dR);
    75   gfits_modify (&header, "CERROR", "%C", 1, "scatter in astrometry soln (arcsec)");
     75  gfits_modify_alt (&header, "CERROR", "%C", 1, "scatter in astrometry soln (arcsec)");
    7676  gfits_modify (&header, "CPRECISE", "%lf", 1, dR / sqrt(1.0*Nmatch));
    77   gfits_modify (&header, "CPRECISE", "%C", 1, "precision of astrometry soln (arcsec)");
     77  gfits_modify_alt (&header, "CPRECISE", "%C", 1, "precision of astrometry soln (arcsec)");
    7878  gfits_modify (&header, "EQUINOX", "%lf", 1, 2000.0);
    7979  /* we force equinox to be 2000.0 for all images */
    8080
    8181skipstuff:
    82   if (header.size > oldsize) {
     82  if (header.datasize > oldsize) {
    8383    if (VERBOSE) fprintf (stderr, "header expanded, creating new copy\n");
    8484    sprintf (line, "mv %s %s~", file, file);
    … …  
    9999      exit(0);
    100100    }
    101     nbytes = fwrite (header.buffer, 1, header.size, g);
    102     fseek (f, oldsize, SEEK_SET);
    103     for (i = 0; (nbytes = fread (header.buffer, 1, header.size, f)) > 0; i++) {
     101    nbytes = fwrite (header.buffer, 1, header.datasize, g);
     102    fseeko (f, oldsize, SEEK_SET);
     103    for (i = 0; (nbytes = fread (header.buffer, 1, header.datasize, f)) > 0; i++) {
    104104      if (nbytes != fwrite (header.buffer, 1, nbytes, g)) {
    105105        fprintf (stderr, "ERROR: failure writing output data file\n");
    … …  
    116116    }
    117117   
    118     fseek (f, 0, SEEK_SET);
    119     nbytes = fwrite (header.buffer, 1, header.size, f);
     118    fseeko (f, 0, SEEK_SET);
     119    nbytes = fwrite (header.buffer, 1, header.datasize, f);
    120120   
    121121    fclose (f);

  • trunk/Ohana/src/gastro/src/gstars.c

    r19823 r27435  
    162162    exit(0);
    163163  }
    164   fseek (f, header.size, SEEK_SET);
     164  fseeko (f, header.datasize, SEEK_SET);
    165165
    166166  N = nstar = 0;

  • trunk/Ohana/src/gastro2/src/getusno.c

    r8496 r27435  
    1111int getusno (CatStats *catstats, RefCatalog *Ref) {
    1212
    13   long int offset;
     13  off_t offset;
    1414  int i, bin, first, last, nitems, Nitems, Nbins;
    1515  float hours[100];
    … …  
    8686    /* advance file pointer to first slice */
    8787    offset = 3*sizeof(int)*(start[first] - 1);
    88     fseek (f, offset, SEEK_SET);
     88    fseeko (f, offset, SEEK_SET);
    8989    /* on each loop, load data from an RA slice of the catalog */
    9090    for (bin = first; bin < last; bin++) {

  • trunk/Ohana/src/gastro2/src/getusnob.c

    r8513 r27435  
    55int getusnob (CatStats *catstats, RefCatalog *Ref, double epoch) {
    66
    7   long int offset;
     7  off_t offset;
    88  int i, bin, first, last, nitems, Nitems, Nbins;
    99  float hours[100];
    … …  
    7676    /* advance file pointer to first slice */
    7777    offset = NELEM*NBYTE*(start[first] - 1);
    78     fseek (f, offset, SEEK_SET);
     78    fseeko (f, offset, SEEK_SET);
    7979
    8080    /* sum the number of stars in data segment of interest */

  • trunk/Ohana/src/gastro2/src/gheader2.c

    r8300 r27435  
    66  Header header;
    77  FILE *f, *g;
    8   int i, oldsize, nbytes, status;
     8  off_t i, oldsize, nbytes, status;
    99  char line[1024];
    1010
    … …  
    1313    exit(0);
    1414  }
    15   oldsize = header.size;
     15  oldsize = header.datasize;
    1616
    1717  /* check for insufficient number of stars */
    … …  
    2121      if (Target[0].answer.N < 6) {
    2222        gfits_modify (&header, "NASTRO", "%d", 1, 0);
    23         gfits_modify (&header, "NASTRO", "%C", 1, "number of stars used for astrometry");
     23        gfits_modify_alt (&header, "NASTRO", "%C", 1, "number of stars used for astrometry");
    2424        goto skipstuff;
    2525      }
    … …  
    2828      if (Target[0].answer.N < 12) {
    2929        gfits_modify (&header, "NASTRO", "%d", 1, 0);
    30         gfits_modify (&header, "NASTRO", "%C", 1, "number of stars used for astrometry");
     30        gfits_modify_alt (&header, "NASTRO", "%C", 1, "number of stars used for astrometry");
    3131        goto skipstuff;
    3232      }
    … …  
    3535      if (Target[0].answer.N < 20) {
    3636        gfits_modify (&header, "NASTRO", "%d", 1, 0);
    37         gfits_modify (&header, "NASTRO", "%C", 1, "number of stars used for astrometry");
     37        gfits_modify_alt (&header, "NASTRO", "%C", 1, "number of stars used for astrometry");
    3838        goto skipstuff;
    3939      }
    … …  
    4545 
    4646  gfits_modify (&header, "NASTRO", "%d", 1, Target[0].answer.N);
    47   gfits_modify (&header, "NASTRO", "%C", 1, "number of stars used for astrometry");
     47  gfits_modify_alt (&header, "NASTRO", "%C", 1, "number of stars used for astrometry");
    4848
    4949  /*** use PutCoords to update header ***/
    … …  
    5252  dR = fabs (Target[0].answer.dR*Target[0].coords.cdelt1*3600.0);
    5353  gfits_modify (&header, "CERROR", "%lf", 1, dR);
    54   gfits_modify (&header, "CERROR", "%C", 1, "scatter in astrometry soln (arcsec)");
     54  gfits_modify_alt (&header, "CERROR", "%C", 1, "scatter in astrometry soln (arcsec)");
    5555  gfits_modify (&header, "CPRECISE", "%lf", 1, dR / sqrt(1.0*Target[0].answer.N));
    56   gfits_modify (&header, "CPRECISE", "%C", 1, "precision of astrometry soln (arcsec)");
     56  gfits_modify_alt (&header, "CPRECISE", "%C", 1, "precision of astrometry soln (arcsec)");
    5757  gfits_modify (&header, "EQUINOX", "%lf", 1, 2000.0);
    5858  /* we force equinox to be 2000.0 for all images */
    5959
    6060skipstuff:
    61   if (header.size > oldsize) {
     61  if (header.datasize > oldsize) {
    6262    if (VERBOSE) fprintf (stderr, "header expanded, creating new copy\n");
    6363    sprintf (line, "mv %s %s~", file, file);
    … …  
    7878      exit(0);
    7979    }
    80     nbytes = fwrite (header.buffer, 1, header.size, g);
    81     fseek (f, oldsize, SEEK_SET);
    82     for (i = 0; (nbytes = fread (header.buffer, 1, header.size, f)) > 0; i++) {
     80    nbytes = fwrite (header.buffer, 1, header.datasize, g);
     81    fseeko (f, oldsize, SEEK_SET);
     82    for (i = 0; (nbytes = fread (header.buffer, 1, header.datasize, f)) > 0; i++) {
    8383      if (nbytes != fwrite (header.buffer, 1, nbytes, g)) {
    8484        fprintf (stderr, "ERROR: failure writing output data file\n");
    … …  
    9595    }
    9696   
    97     fseek (f, 0, SEEK_SET);
    98     nbytes = fwrite (header.buffer, 1, header.size, f);
     97    fseeko (f, 0, SEEK_SET);
     98    nbytes = fwrite (header.buffer, 1, header.datasize, f);
    9999   
    100100    fclose (f);

  • trunk/Ohana/src/gastro2/src/gstars2.c

    r19823 r27435  
    66  char line[80];
    77  double det;
    8   int NX, NY, Nskip, FoundAstrom, extend, naxis;
     8  off_t Nskip;
     9  int NX, NY, FoundAstrom, extend, naxis;
    910  StarData *stars;
    1011  FILE *f;
    … …  
    2122  }
    2223  /* this line should not be needed */
    23   fseek (f, Target[0].header.size, SEEK_SET);
     24  fseeko (f, Target[0].header.datasize, SEEK_SET);
    2425
    2526  NX = Target[0].header.Naxis[0];
    … …  
    125126  /* Is NAXIS == 0 a better test?? */
    126127  extend = FALSE;
    127   gfits_scan (&Target[0].header, "NAXIS",  "%t", 1, &naxis);
     128  gfits_scan_alt (&Target[0].header, "NAXIS",  "%t", 1, &naxis);
    128129  if ((naxis == 0) && !TEXTMODE) {
    129130    Nskip = gfits_data_size (&Target[0].header);
    130     fseek (f, Nskip, SEEK_CUR);
     131    fseeko (f, Nskip, SEEK_CUR);
    131132    stars = rfits (f, &Nstars);
    132133  } else {

  • trunk/Ohana/src/gastro2/src/rfits.c

    r7080 r27435  
    33StarData *rfits (FILE *f, int *nstars) {
    44
    5   int i, N, Nstars;
     5  int N;
     6  off_t i, Nstars;
    67  Header theader;
    78  FTable table;

  • trunk/Ohana/src/getstar/include/dvoImageExtract.h

    r21153 r27435  
    2121int  args_extract        PROTO((int argc, char **argv));
    2222int  ConfigInit_extract  PROTO((int *argc, char **argv));
    23 int  Shutdown            PROTO((char *format, ...));
     23int  Shutdown            PROTO((char *format, ...)) OHANA_FORMAT(printf, 1, 2);
    2424void TrapSignal          PROTO((int sig));
    2525void SetProtect          PROTO((int mode));
    … …  
    3030
    3131int  WriteImageFITS (FILE *f, Image *image);
    32 int  WriteImages (char *filename, Image *images, int Nimages, int *matches, int Nmatches);
    33 int *SelectImages (char *filename, Image *dbImages, int NdbImages, int *Nmatch);
     32int  WriteImages (char *filename, Image *images, off_t Nimages, off_t *matches, off_t Nmatches);
     33off_t *SelectImages (char *filename, Image *dbImages, off_t NdbImages, off_t *Nmatch);

  • trunk/Ohana/src/getstar/include/dvoImageOverlaps.h

    r21153 r27435  
    2424int  args_overlaps       PROTO((int argc, char **argv));
    2525int  ConfigInit_overlaps PROTO((int *argc, char **argv));
    26 int  Shutdown         PROTO((char *format, ...));
     26int  Shutdown         PROTO((char *format, ...) OHANA_FORMAT(printf, 1, 2));
    2727void TrapSignal       PROTO((int sig));
    2828void SetProtect       PROTO((int mode));
    2929int  SetSignals       PROTO((void));
    3030
    31 Image *ReadImageFiles (char *filename, int *Nimages);
     31Image *ReadImageFiles (char *filename, off_t *Nimages);
    3232int ReadImageHeader (Header *header, Image *image);
    33 int *MatchImage (Image *dbImages, int NdbImages, Image *image, int *Nmatch);
    34 int ListImageOverlaps (Image *dbImages, Image *image, int *matches, int Nmatches);
     33off_t *MatchImage (Image *dbImages, off_t NdbImages, Image *image, off_t *Nmatch);
     34int ListImageOverlaps (Image *dbImages, Image *image, off_t *matches, off_t Nmatches);
    3535
    3636int GetFileMode (Header *header);

  • trunk/Ohana/src/getstar/include/dvoImagesAtCoords.h

    r26288 r27435  
    3939int  args_coords         PROTO((int argc, char **argv));
    4040int  ConfigInit_coords PROTO((int *argc, char **argv));
    41 int  Shutdown         PROTO((char *format, ...));
     41int  Shutdown         PROTO((char *format, ...) OHANA_FORMAT(printf, 1, 2));
    4242void TrapSignal       PROTO((int sig));
    4343void SetProtect       PROTO((int mode));
    4444int  SetSignals       PROTO((void));
    4545
    46 Image *ReadImageFiles (char *filename, int *Nimages);
     46Image *ReadImageFiles (char *filename, off_t *Nimages);
    4747int ReadImageHeader (Header *header, Image *image);
    48 int MatchCoords(Image *, int, Point *, int);
     48off_t MatchCoords (Image *dbImages, off_t NdbImages, Point *points, int Npoints);
    4949
    5050int GetFileMode (Header *header);

  • trunk/Ohana/src/getstar/include/getstar.h

    r21153 r27435  
    3737int  args                    PROTO((int argc, char **argv));
    3838int  ConfigInit              PROTO((int *argc, char **argv));
    39 int  Shutdown                PROTO((char *format, ...));
     39int  Shutdown                PROTO((char *format, ...)) OHANA_FORMAT(printf, 1, 2);
    4040int  load_pt_catalog         PROTO((Catalog *catalog, SkyRegion *region));
    4141int  select_by_region        PROTO((Catalog *output, Catalog *catalog, SkyRegion *region, int start, int end));

  • trunk/Ohana/src/getstar/src/ConfigInit_coords.c

    r27142 r27435  
    44
    55  char *config, *file;
    6   char CatdirPhotcodeFile[256];
    7   char MasterPhotcodeFile[256];
    86
    97  /*** load configuration info ***/
    … …  
    2119  ScanConfig (config, "CATMODE",                "%s",  0, CATMODE);
    2220  ScanConfig (config, "CATFORMAT",              "%s",  0, CATFORMAT);
    23   ScanConfig (config, "PHOTCODE_FILE",          "%s",  0, MasterPhotcodeFile);
    2421  if (!ScanConfig (config, "SKY_DEPTH",         "%d",  0, &SKY_DEPTH)) {
    2522    SKY_DEPTH = 2;

  • trunk/Ohana/src/getstar/src/ConfigInit_extract.c

    r25757 r27435  
    44
    55  char *config, *file;
    6   char CatdirPhotcodeFile[256];
    7   char MasterPhotcodeFile[256];
    86
    97  /*** load configuration info ***/
    … …  
    2119  ScanConfig (config, "CATMODE",                "%s",  0, CATMODE);
    2220  ScanConfig (config, "CATFORMAT",              "%s",  0, CATFORMAT);
    23   ScanConfig (config, "PHOTCODE_FILE",          "%s",  0, MasterPhotcodeFile);
    2421  if (!ScanConfig (config, "SKY_DEPTH",         "%d",  0, &SKY_DEPTH)) {
    2522    SKY_DEPTH = 2;
    … …  
    3330  if (*CATFORMAT == 0) strcpy (CATFORMAT, "ELIXIR");
    3431
    35   /* XXX this does not yet write out the master photcode table */
    36   sprintf (CatdirPhotcodeFile, "%s/Photcodes.dat", CATDIR);
    37   if (!LoadPhotcodes (CatdirPhotcodeFile, MasterPhotcodeFile, TRUE)) {
    38     fprintf (stderr, "error loading photcode table %s or master file %s\n", CatdirPhotcodeFile, MasterPhotcodeFile);
    39     exit (1);
    40   }
    41 
    4232  free (config);
    4333  free (file);

  • trunk/Ohana/src/getstar/src/ConfigInit_overlaps.c

    r25757 r27435  
    44
    55  char *config, *file;
    6   char CatdirPhotcodeFile[256];
    7   char MasterPhotcodeFile[256];
    86
    97  /*** load configuration info ***/
    … …  
    2119  ScanConfig (config, "CATMODE",                "%s",  0, CATMODE);
    2220  ScanConfig (config, "CATFORMAT",              "%s",  0, CATFORMAT);
    23   ScanConfig (config, "PHOTCODE_FILE",          "%s",  0, MasterPhotcodeFile);
    2421  if (!ScanConfig (config, "SKY_DEPTH",         "%d",  0, &SKY_DEPTH)) {
    2522    SKY_DEPTH = 2;
    … …  
    3330  if (*CATFORMAT == 0) strcpy (CATFORMAT, "ELIXIR");
    3431
    35   /* XXX this does not yet write out the master photcode table */
    36   sprintf (CatdirPhotcodeFile, "%s/Photcodes.dat", CATDIR);
    37   if (!LoadPhotcodes (CatdirPhotcodeFile, MasterPhotcodeFile, FALSE)) {
    38     fprintf (stderr, "error loading photcode table %s or master file %s\n", CatdirPhotcodeFile, MasterPhotcodeFile);
    39     exit (1);
    40   }
    41 
    4232  free (config);
    4333  free (file);

  • trunk/Ohana/src/getstar/src/GetFileMode.c

    r19065 r27435  
    88  int simple, extend, haveNaxis, haveCTYPE;
    99
    10   gfits_scan (header, "SIMPLE", "%t", 1, &simple);
     10  gfits_scan_alt (header, "SIMPLE", "%t", 1, &simple);
    1111  haveNaxis = gfits_scan (header, "NAXIS",  "%d", 1, &Naxis);
    1212  haveCTYPE = gfits_scan (header, "CTYPE1", "%s", 1, ctype);
    1313
    14   gfits_scan (header, "EXTEND", "%t", 1, &extend);
     14  gfits_scan_alt (header, "EXTEND", "%t", 1, &extend);
    1515   
    1616  if ((Naxis == 2) || !simple) {

  • trunk/Ohana/src/getstar/src/ListImageOverlaps.c

    r12774 r27435  
    22
    33/* given image, find catalog images which overlap it */
    4 int ListImageOverlaps (Image *dbImages, Image *image, int *matches, int Nmatches) {
     4int ListImageOverlaps (Image *dbImages, Image *image, off_t *matches, off_t Nmatches) {
    55 
    6   int i, N;
     6  off_t i, N;
    77
    88  for (i = 0; i < Nmatches; i++) {

  • trunk/Ohana/src/getstar/src/MatchCoords.c

    r26142 r27435  
    55
    66/* given coordinate, find images in list that contain the point */
    7 int MatchCoords (Image *dbImages, int NdbImages, Point *points, int Npoints) {
     7off_t MatchCoords (Image *dbImages, off_t NdbImages, Point *points, int Npoints) {
    88 
    9   int i, j, N;
     9  off_t i;
     10  int j;
    1011  int totalMatches = 0;
    11   Coords tcoords;
    12   double r, d;
    13   double Xi[4], Yi[4], Xo[4], Yo[4];  /* image and original corners */
    14   double Xmin, Xmax, Ymin, Ymax;
     12  double Xi[4], Yi[4];  /* image and original corners */
    1513  double xmin, xmax, ymin, ymax;
    1614

  • trunk/Ohana/src/getstar/src/MatchImages.c

    r14590 r27435  
    55
    66/* given image, find catalog images which overlap it */
    7 int *MatchImage (Image *dbImages, int NdbImages, Image *image, int *Nmatch) {
     7off_t *MatchImage (Image *dbImages, off_t NdbImages, Image *image, off_t *Nmatch) {
    88 
    9   int i, j, N, addtolist, status;
    10   int NMATCH, nmatch, *match;
     9  off_t i, NMATCH, nmatch, *match;
     10  int j, N, addtolist, status;
    1111  Coords tcoords;
    1212  double r, d;
    … …  
    6464  nmatch = 0;
    6565  NMATCH = 20;
    66   ALLOCATE (match, int, NMATCH);
     66  ALLOCATE (match, off_t, NMATCH);
    6767
    6868  /* setup links for mosaic WRP and DIS entries */
    … …  
    128128    if (nmatch == NMATCH) {
    129129      NMATCH += 20;
    130       REALLOCATE (match, int, NMATCH);
     130      REALLOCATE (match, off_t, NMATCH);
    131131    }
    132132  }
    133133 
    134   if (VERBOSE) fprintf (stderr, "found %d overlapping images\n", nmatch);
     134  if (VERBOSE) fprintf (stderr, "found %lld overlapping images\n", (long long) nmatch);
    135135
    136136  *Nmatch = nmatch;

  • trunk/Ohana/src/getstar/src/ReadImageFiles.c

    r24418 r27435  
    22# define DVO_IMAGE_NAME_LEN 128
    33
    4 Image *ReadImageFiles (char *filename, int *Nimages) {
    5 
    6   int i, j, N, Nfile, Nheader, NHEADER, Nimage, NIMAGE;
    7   int Nskip, Nhead, Ndata, done, status, mode;
     4Image *ReadImageFiles (char *filename, off_t *Nimages) {
     5
     6  off_t Nskip, *extsize;
     7  int i, j, N, Nfile, Nheader, Nimage, NHEADER, NIMAGE;
     8  int Nhead, Ndata, done, status, mode;
    89  char **file, *name;
    910  FILE *f;
    1011  glob_t globList;
    1112  char **exthead, **extdata, **exttype, tmpword[80];
    12   int *extnum_head, *extnum_data, *extsize;
     13  int *extnum_head, *extnum_data;
    1314  Header *header, **headers;
    1415  Image *image;
    … …  
    8990  headers[0] = header;
    9091  Nskip = gfits_data_size (header);
    91   fseek (f, Nskip, SEEK_CUR);
     92  fseeko (f, Nskip, SEEK_CUR);
    9293
    9394  // load all headers into memory
    … …  
    118119  ALLOCATE (extnum_head, int, NIMAGE);
    119120  ALLOCATE (extnum_data, int, NIMAGE);
    120   ALLOCATE (extsize, int, Nheader);
     121  ALLOCATE (extsize, off_t, Nheader);
    121122
    122123  if (mode == MOSAIC_MEF) {
    … …  
    130131  // now examine the headers, count the table entries, find corresponding headers
    131132  for (i = 0; i < Nheader; i++) {
    132       extsize[i] = headers[i][0].size + gfits_data_size (headers[i]);
     133      extsize[i] = headers[i][0].datasize + gfits_data_size (headers[i]);
    133134      gfits_scan (headers[i], "EXTTYPE", "%s", 1, tmpword);
    134135
    … …  
    166167  // extension matched to the header in the PHU
    167168  if (Nimage == 0) {
    168       extsize[0] = headers[0][0].size + gfits_data_size (headers[0]);
    169       extsize[1] = headers[1][0].size + gfits_data_size (headers[1]);
     169      extsize[0] = headers[0][0].datasize + gfits_data_size (headers[0]);
     170      extsize[1] = headers[1][0].datasize + gfits_data_size (headers[1]);
    170171      gfits_scan (headers[1], "EXTNAME", "%s", 1, tmpword);
    171172      if (!strcmp (tmpword, "SMPFILE")) {

  • trunk/Ohana/src/getstar/src/SelectImages.c

    r14590 r27435  
    22
    33/* given image, find catalog images which overlap it */
    4 int *SelectImages (char *filename, Image *images, int Nimages, int *Nmatch) {
     4off_t *SelectImages (char *filename, Image *images, off_t Nimages, off_t *Nmatch) {
    55 
    6   int i, Nchar;
    7   int NMATCH, nmatch, *match;
     6  int Nchar;
     7  off_t i, NMATCH, nmatch, *match;
    88
    99  /* matches here are only based on string comparisons */
    … …  
    1212  nmatch = 0;
    1313  NMATCH = 20;
    14   ALLOCATE (match, int, NMATCH);
     14  ALLOCATE (match, off_t, NMATCH);
    1515
    1616  /* setup links for mosaic WRP and DIS entries */
    … …  
    2727    if (nmatch == NMATCH) {
    2828      NMATCH += 20;
    29       REALLOCATE (match, int, NMATCH);
     29      REALLOCATE (match, off_t, NMATCH);
    3030    }
    3131  } 
    3232
    33   if (VERBOSE) fprintf (stderr, "found %d matching images\n", nmatch);
     33  if (VERBOSE) fprintf (stderr, "found %lld matching images\n", (long long) nmatch);
    3434
    3535  *Nmatch = nmatch;

  • trunk/Ohana/src/getstar/src/WriteImages.c

    r14590 r27435  
    22
    33/* given image, find catalog images which overlap it */
    4 int WriteImages (char *filename, Image *images, int Nimages, int *matches, int Nmatches) {
     4int WriteImages (char *filename, Image *images, off_t Nimages, off_t *matches, off_t Nmatches) {
    55 
    66  int i, N;

  • trunk/Ohana/src/getstar/src/dvoImageExtract.c

    r14590 r27435  
    33int main (int argc, char **argv) {
    44
    5   int Nimages, status;
    6   int Nmatches, *matches;
     5  off_t Nimages, Nmatches, *matches;
     6  int status;
    77  Image *images;
    88  FITS_DB db;

  • trunk/Ohana/src/getstar/src/dvoImageOverlaps.c

    r14590 r27435  
    33int main (int argc, char **argv) {
    44
    5   int i, Nimages, NdbImages, status;
    6   int Nmatches, *matches;
     5  off_t NdbImages, Nimages;
     6  int status;
     7  off_t i, Nmatches, *matches;
    78  Image *images, *dbImages;
    89  FITS_DB db;

  • trunk/Ohana/src/getstar/src/dvoImagesAtCoords.c

    r26288 r27435  
    1212int main (int argc, char **argv) {
    1313
    14   int i, Nimages, NdbImages, status;
    15   int Nmatches, *matches;
     14  off_t NdbImages;
     15  int status;
    1616  Image *dbImages;
    1717  int Npoints;

  • trunk/Ohana/src/getstar/src/select_by_region.c

    r20266 r27435  
    156156  output[0].Nsecf_mem = Nave*Nsecfilt;
    157157
    158   fprintf (stderr, "output catalog has %d stars (%d measures, %d secfilt)\n",
    159            output[0].Naverage, output[0].Nmeasure, output[0].Nsecfilt);
     158  fprintf (stderr, "output catalog has %lld stars (%lld measures, %d secfilt)\n",
     159           (long long) output[0].Naverage, (long long) output[0].Nmeasure, output[0].Nsecfilt);
    160160  return (TRUE);
    161161}

  • trunk/Ohana/src/gophot/src/gophot.c

    r20652 r27435  
    2626  /* convert to float, set up noise array and axes */
    2727  gfits_convert_format (&header, &matrix, -32, 1.0, 0.0, 0xffff, 0);
    28   ALLOCATE (noise, float, matrix.size);
     28  ALLOCATE (noise, float, matrix.datasize);
    2929  big = (float *) matrix.buffer;
    3030  nfast = matrix.Naxis[0];

  • trunk/Ohana/src/imclean/src/wfits.c

    r7080 r27435  
    1010  header[0].Naxes = 0;
    1111  gfits_modify (header, "NAXIS",   "%d", 1, 0);
    12   gfits_modify (header, "EXTEND",  "%t", 1, TRUE);
     12  gfits_modify_alt (header, "EXTEND",  "%t", 1, TRUE);
    1313  gfits_modify (header, "NEXTEND", "%d", 1, 1);
    1414

  • trunk/Ohana/src/imclean/src/wstars.c

    r3519 r27435  
    1414  }
    1515
    16   fwrite (header[0].buffer, 1, header[0].size, g);
     16  fwrite (header[0].buffer, 1, header[0].datasize, g);
    1717
    1818  for (i = 0; i < Nstars; i++) {

  • trunk/Ohana/src/imregister/base/WriteFIFO.c

    r3648 r27435  
    1212  }
    1313
    14   fseek (f, 0, SEEK_END);
     14  fseeko (f, 0LL, SEEK_END);
    1515  fprintf (f, "%s\n", line);
    1616

  • trunk/Ohana/src/imregister/detrend/altpath.c

    r7080 r27435  
    22# include "detrend.h"
    33
    4 int SetAltpath (FITS_DB *db, DetReg *image, int Nimage, Match *match, int Nmatch) {
     4int SetAltpath (FITS_DB *db, DetReg *image, off_t Nimage, Match *match, off_t Nmatch) {
    55 
    6   int i, j, n, found, status, Nlist;
    7   int *list, *current;
     6  int status, found;
     7  off_t i, j, n, Nlist;
     8  off_t *list, *current;
    89  char *dBPath, infile[256], outfile[256], line[1024];
    910  struct stat statbuf;
    1011
    11   ALLOCATE (current, int, Nimage);
    12   ALLOCATE (list, int, Nimage);
     12  ALLOCATE (current, off_t, Nimage);
     13  ALLOCATE (list, off_t, Nimage);
    1314  Nlist = 0;
    1415

  • trunk/Ohana/src/imregister/detrend/criteria.c

    r3593 r27435  
    6060*/
    6161
    62 Match *ExptimeCriteria (DetReg *image, int Nimage, Match *match, int *nmatch) {
    63 
    64   int i, j, Nmatch, Nnew, NNEW, entry;
     62Match *ExptimeCriteria (DetReg *image, off_t Nimage, Match *match, off_t *nmatch) {
     63
     64  off_t i, j, Nmatch, Nnew, NNEW, entry;
    6565  unsigned long dtime;
    6666  float Chi, ChiMin;
    … …  
    132132}
    133133
    134 Match *CloseCriteria (DetReg *image, int Nimage, Match *match, int *nmatch) {
    135 
    136   int i, j, Nmatch, Nnew, NNEW, Ngood, entry;
     134Match *CloseCriteria (DetReg *image, off_t Nimage, Match *match, off_t *nmatch) {
     135
     136  off_t i, j, Nmatch, Nnew, NNEW, Ngood, entry;
    137137  unsigned long dmin, dtime;
    138138  Match *new;

  • trunk/Ohana/src/imregister/detrend/delete.c

    r7080 r27435  
    22# include "detrend.h"
    33
    4 void DeleteSubset (FITS_DB *db, DetReg *image, int Nimage, Match *match, int Nmatch) {
     4void DeleteSubset (FITS_DB *db, DetReg *image, off_t Nimage, Match *match, off_t Nmatch) {
    55
    6   int i, j;
    7   int *keep, Ndel, Nsubset;
     6  off_t i, j;
     7  off_t *keep, Ndel, Nsubset;
    88  DetReg *subset;
    99
    10   ALLOCATE (keep, int, MAX (Nimage, 1));
     10  ALLOCATE (keep, off_t, MAX (Nimage, 1));
    1111  for (i = 0; i < Nimage; i++) keep[i] = TRUE;
    12   fprintf (stderr, "total of %d detrend images\n", Nimage);
     12  fprintf (stderr, "total of %lld detrend images\n", (long long) Nimage);
    1313
    1414  Ndel = 0;
    … …  
    2020    delete_image (&image[i]);
    2121  }
    22   fprintf (stderr, "delete %d images\n", Ndel);
     22  fprintf (stderr, "delete %lld images\n", (long long) Ndel);
    2323  if (Ndel == 0) {
    2424    fprintf (stderr, "SUCCESS\n");
    … …  
    3030  Nsubset = Nimage - Ndel;
    3131  ALLOCATE (subset, DetReg, MAX (1, Nsubset));
    32   fprintf (stderr, "keeping %d images\n", Nsubset);
     32  fprintf (stderr, "keeping %lld images\n", (long long) Nsubset);
    3333  for (j = i = 0; i < Nimage; i++) {
    3434    if (!keep[i]) continue;

  • trunk/Ohana/src/imregister/detrend/imdef.c

    r14590 r27435  
    4343  descriptor[0].mode = M_SPLIT;
    4444  Extend = FALSE;
    45   gfits_scan (&header, "EXTEND", "%t", 1, &Extend);
     45  gfits_scan_alt (&header, "EXTEND", "%t", 1, &Extend);
    4646  if (Extend) {
    4747    descriptor[0].mode      = M_MEF;

  • trunk/Ohana/src/imregister/detrend/match.c

    r3593 r27435  
    22# include "detrend.h"
    33
    4 Match *MatchCriteria (DetReg *image, int Nimage, int *nmatch) {
     4Match *MatchCriteria (DetReg *image, off_t Nimage, off_t *nmatch) {
    55
    6   int i;
    7   int Nmatch, NMATCH;
     6  off_t i;
     7  off_t Nmatch, NMATCH;
    88  Match result, *match;
    99

  • trunk/Ohana/src/imregister/detrend/modify.c

    r7080 r27435  
    22# include "detrend.h"
    33
    4 int ModifySubset (FITS_DB *db, DetReg *image, int Nimage, Match *match, int Nmatch) {
     4int ModifySubset (FITS_DB *db, DetReg *image, off_t Nimage, Match *match, off_t Nmatch) {
    55 
    6   int i, j, value;
    7   int *list;
     6  off_t i, j, value;
     7  off_t *list;
    88 
    99  value = M_UNDEF;
    1010
    11   ALLOCATE (list, int, Nimage);
     11  ALLOCATE (list, off_t, Nimage);
    1212  if (!strcasecmp (output.ModifyEntry, "mode")) {
    1313    value = get_image_mode (output.ModifyValue);

  • trunk/Ohana/src/imregister/detrend/output.c

    r14590 r27435  
    55extern double drand48();
    66
    7 int OutputSubset (DetReg *image, int Nimage, Match *match, int Nmatch) {
     7int OutputSubset (DetReg *image, off_t Nimage, Match *match, off_t Nmatch) {
    88
    99  if (output.table != (char *) NULL) {
    … …  
    1919
    2020/* write out complete binary FITS table in format of db */
    21 int DumpFitsBintable (char *filename, DetReg *image, Match *match, int Nmatch) {
    22 
    23   int i, j;
     21int DumpFitsBintable (char *filename, DetReg *image, Match *match, off_t Nmatch) {
     22
     23  off_t i, j;
    2424  FILE *f;
    2525  Header header;
    … …  
    6060}
    6161
    62 int DumpFitsTable (char *filename, DetReg *detdata, Match *match, int Nmatch) {
     62int DumpFitsTable (char *filename, DetReg *detdata, Match *match, off_t Nmatch) {
    6363 
    6464  Header header, theader;
    … …  
    6969  char *startstr, *stopstr, *regstr, *line, key[33], ccdinfo[16];
    7070  char *filtstr, *typestr, *modestr, *ccdstr, *datestr, *p;
    71   int i;
     71  off_t i;
    7272  time_t tsecond;
    7373
    … …  
    191191
    192192/* Select, TimeMode are global */
    193 int PrintSubset (DetReg *detdata, Match *match, int Nmatch) {
     193int PrintSubset (DetReg *detdata, Match *match, off_t Nmatch) {
    194194 
    195195  char *dBPath, *Path, *typestr, *filtstr, filename[128];
    196196  char *timestr, *modestr, *ccdstr, ccdinfo[16], ccdformat[16];
    197   int i, j, Nc;
     197  off_t i, j;
     198  int Nc;
    198199  struct timeval now;
    199200  long A;

  • trunk/Ohana/src/imregister/detrend/select.c

    r3606 r27435  
    22# include "detrend.h"
    33
    4 Match SelectEntry (DetReg *image, int Nimage, Match *list, int Nlist, Criteria *crit) {
     4Match SelectEntry (DetReg *image, off_t Nimage, Match *list, off_t Nlist, Criteria *crit) {
    55
    66  /* force a single selection */
    … …  
    1515  */
    1616
    17   int i, j, entry, order, matchnum;
    18   int nmatch, Nmatch;
     17  off_t i, j, entry, order, matchnum;
     18  off_t nmatch, Nmatch;
    1919  unsigned int tstart;
    2020  Match *match, *tmatch, answer;

  • trunk/Ohana/src/imregister/detrend/unique.c

    r3606 r27435  
    33
    44/* define a list of best images which have unique properties */
    5 Match *UniqueSubset (DetReg *image, int Nimage, Match *match, int *nmatch) {
     5Match *UniqueSubset (DetReg *image, off_t Nimage, Match *match, off_t *nmatch) {
    66
    7   int Nsubset, Nunique, Ncrit, NCRIT;
    8   int i, j, N, Nmatch, found;
     7  int found;
     8  off_t Nsubset, Nunique, Ncrit, NCRIT;
     9  off_t i, j, N, Nmatch;
    910  Criteria *crit;
    1011  Match *subset, *unique, *local;

  • trunk/Ohana/src/imregister/imphot/dumpfits.c

    r14590 r27435  
    33
    44/* write out complete binary FITS table in format of db */
    5 int DumpFitsBintable (char *filename, Image *image, int *match, int Nmatch) {
     5int DumpFitsBintable (char *filename, Image *image, off_t *match, off_t Nmatch) {
    66
    7   int i, j;
     7  off_t i, j;
    88  FILE *f;
    99  Header header;
    … …  
    4444}
    4545
    46 int DumpFitsTable (char *filename, Image *image, int *match, int Nmatch) {
     46int DumpFitsTable (char *filename, Image *image, off_t *match, off_t Nmatch) {
    4747 
    4848  Header header;
    … …  
    5353  FILE *f;
    5454  char *startstr, *filtstr, *datestr, *line;
    55   int i;
     55  off_t i;
    5656  double zp, dzp, ra, dec, airmass, sky;
    5757  time_t tsecond;

  • trunk/Ohana/src/imregister/imphot/modify.c

    r21508 r27435  
    22# include "imphot.h"
    33
    4 void ModifySubset (FITS_DB *db, Image *image, int Nimage, int *match, int Nmatch) {
     4void ModifySubset (FITS_DB *db, Image *image, off_t Nimage, off_t *match, off_t Nmatch) {
    55
    6   int i, j;
     6  off_t i, j;
    77
    88  /* modify the selected entries */

  • trunk/Ohana/src/imregister/imphot/output.c

    r21508 r27435  
    22# include "imphot.h"
    33
    4 int output (Image *image, int *match, int Nmatch) {
     4int output (Image *image, off_t *match, off_t Nmatch) {
    55
    66  int status;
    … …  
    2222}
    2323
    24 int PrintSubset (Image *image, int *match, int Nmatch) {
     24int PrintSubset (Image *image, off_t *match, off_t Nmatch) {
    2525
    26   int i, j;
     26  off_t i, j;
    2727  char *timestr, *photstr;
    2828  static char PhotError[] = "unknown";

  • trunk/Ohana/src/imregister/imphot/rtext.c

    r15487 r27435  
    44int rtext (FITS_DB *db) {
    55
    6   int Nimage, size, nimage;
     6  off_t Nimage, size, nimage;
    77  struct stat filestatus;
    88  Image *image;
    … …  
    1010  /* check that file size makes sense */
    1111  Nimage = 0;
    12   gfits_scan (&db[0].header, "NIMAGES", "%d", 1, &Nimage);
     12  gfits_scan (&db[0].header, "NIMAGES", "%lld", 1, (long long *) &Nimage);
    1313  if (stat (db[0].filename, &filestatus) == -1) {
    1414    if (VERBOSE) fprintf (stderr, "ERROR: failed to get status of image catalog\n");
    1515    exit (1);
    1616  }
    17   size = Nimage*sizeof(Image) + db[0].header.size;
     17  size = Nimage*sizeof(Image) + db[0].header.datasize;
    1818  if (size != filestatus.st_size) {
    1919    int Ndata;
    2020
    21     Ndata = (filestatus.st_size - db[0].header.size) / sizeof (Image);
     21    Ndata = (filestatus.st_size - db[0].header.datasize) / sizeof (Image);
    2222    if (VERBOSE) fprintf (stderr, "ERROR: image catalog has inconsistent size\n");
    23     if (VERBOSE) fprintf (stderr, "header: %d, data: %d\n", Nimage, Ndata);
     23    if (VERBOSE) fprintf (stderr, "header: %lld, data: %d\n", (long long) Nimage, Ndata);
    2424    if (!FORCE_READ) exit (1);
    2525    Nimage = Ndata;
    … …  
    4141  }
    4242  db[0].ftable.buffer = (char *) image;
    43   gfits_modify (&db[0].theader, "NAXIS2", "%d", 1, Nimage);
     43  gfits_modify (&db[0].theader, "NAXIS2", "%lld", 1, (long long) Nimage);
    4444  db[0].theader.Naxis[1] = Nimage;
    45   db[0].ftable.size = gfits_data_size (&db[0].theader);
     45  db[0].ftable.datasize = gfits_data_size (&db[0].theader);
    4646 
    4747  return (TRUE);

  • trunk/Ohana/src/imregister/imphot/subset.c

    r21508 r27435  
    22# include "imphot.h"
    33
    4 int *subset (Image *image, int Nimage, int *nsubset) {
     4off_t *subset (Image *image, off_t Nimage, off_t *nsubset) {
    55
    6   int i, j, status;
    7   int Nsubset, NameSelectLength;
    8   int *index;
     6  off_t i, j, status;
     7  off_t Nsubset, NameSelectLength;
     8  off_t *index;
    99
    1010  NameSelectLength = 0;
    … …  
    1212  /* allocate space for reference lists */
    1313  Nsubset = 0;
    14   ALLOCATE (index, int, Nimage);
     14  ALLOCATE (index, off_t, Nimage);
    1515 
    1616  if (criteria.NameSelect) {

  • trunk/Ohana/src/imregister/imreg/cadc.c

    r16040 r27435  
    44static int REFCCD;
    55
    6 void DumpCADCTable (char *filename, RegImage *image, int *match, int Nmatch) {
    7  
    8   int i, Obsid, Nobsid, Nsubset, ref;
     6void DumpCADCTable (char *filename, RegImage *image, off_t *match, off_t Nmatch) {
     7 
     8  off_t i, Obsid, Nobsid, Nsubset, ref;
    99  char *datestr, *line, hdrname[99];
    1010  time_t tsecond;
    … …  
    1313  FTable table;
    1414  RegImage *row;
    15   int *index, *entry, *obsid;
     15  off_t *index, *entry, *obsid;
    1616  MosaicLayout *layout;
    17   int *subset;
     17  off_t *subset;
    1818  double left, right, center, outer, top, bottom;
    1919  double iqx, iqy, iqr, iqf, iqo;
    … …  
    127127}
    128128
    129 int *GetObsIDSubset (RegImage *image, int start, int *index, int *entry, int Nindex, int *Nsubset) {
    130 
    131   int i, N, NSUBSET;
    132   int *subset;
     129off_t *GetObsIDSubset (RegImage *image, off_t start, off_t *index, off_t *entry, off_t Nindex, off_t *Nsubset) {
     130
     131  off_t i, N, NSUBSET;
     132  off_t *subset;
    133133
    134134  /* create output index */
    135135  N = 0;
    136136  NSUBSET = 64;
    137   ALLOCATE (subset, int, NSUBSET);
     137  ALLOCATE (subset, off_t, NSUBSET);
    138138
    139139  /* find unique sequences */
    … …  
    143143    if (N == NSUBSET) {
    144144      NSUBSET += 64;
    145       REALLOCATE (subset, int, NSUBSET);
     145      REALLOCATE (subset, off_t, NSUBSET);
    146146    }
    147147  }
    … …  
    152152
    153153/* return an index list of unique obs id entries at start of sequence */
    154 int *GetUniqueObsID (RegImage *image, int *index, int *entry, int Nindex, int *Nmatch) {
    155  
    156   int i, j, N, NMATCH;
    157   int *match;
     154off_t *GetUniqueObsID (RegImage *image, off_t *index, off_t *entry, off_t Nindex, off_t *Nmatch) {
     155 
     156  off_t i, j, N, NMATCH;
     157  off_t *match;
    158158
    159159  /* create output index */
    160160  N = 0;
    161161  NMATCH = 1000;
    162   ALLOCATE (match, int, NMATCH);
     162  ALLOCATE (match, off_t, NMATCH);
    163163
    164164  /* find unique sequences */
    … …  
    171171    if (N == NMATCH) {
    172172      NMATCH += 1000;
    173       REALLOCATE (match, int, NMATCH);
     173      REALLOCATE (match, off_t, NMATCH);
    174174    }
    175175
    … …  
    182182
    183183/* return seeing for ccd == REFCCD */
    184 int GetREFCCD (RegImage *image, int *index, int *entry, int Nindex, int start) {
    185  
    186   int i, N, NMATCH;
    187   int *match;
     184off_t GetREFCCD (RegImage *image, off_t *index, off_t *entry, off_t Nindex, off_t start) {
     185 
     186  off_t i, N, NMATCH;
     187  off_t *match;
    188188
    189189  /* create output index */
    190190  N = 0;
    191191  NMATCH = 1000;
    192   ALLOCATE (match, int, NMATCH);
     192  ALLOCATE (match, off_t, NMATCH);
    193193
    194194  /* find unique sequences */
    … …  
    199199}
    200200
    201 void GetObsIDIndex (RegImage *image, int *match, int Nmatch, int **Index, int **Entry) {
    202 
    203   int i;
    204   int *index, *entry;
     201void GetObsIDIndex (RegImage *image, off_t *match, off_t Nmatch, off_t **Index, off_t **Entry) {
     202
     203  off_t i;
     204  off_t *index, *entry;
    205205
    206206  /* index = OBSID */
    207   ALLOCATE (index, int, Nmatch);
    208   ALLOCATE (entry, int, Nmatch);
     207  ALLOCATE (index, off_t, Nmatch);
     208  ALLOCATE (entry, off_t, Nmatch);
    209209  for (i = 0; i < Nmatch; i++) {
    210210    index[i] = atoi (image[match[i]].filename);
    … …  
    212212    entry[i] = match[i];
    213213  }
    214   isortpair (index, entry, Nmatch);
     214  llsortpair (index, entry, Nmatch);
    215215  *Index = index;
    216216  *Entry = entry;
    … …  
    218218
    219219/* match is a list of image entries with the same obsid */
    220 double MosaicIQStats (RegImage *image, int *match, int Nmatch, MosaicRegion *region) {
    221 
    222   int i, j, N, Nccd;
     220double MosaicIQStats (RegImage *image, off_t *match, off_t Nmatch, MosaicRegion *region) {
     221
     222  int i, N, Nccd;
     223  off_t j;
    223224  double *list, value;
    224225

  • trunk/Ohana/src/imregister/imreg/delete.c

    r7080 r27435  
    22# include "imreg.h"
    33
    4 void DeleteSubset (FITS_DB *db, RegImage *image, int Nimage, int *match, int Nmatch) {
     4void DeleteSubset (FITS_DB *db, RegImage *image, off_t Nimage, off_t *match, off_t Nmatch) {
    55
    6   int i, j;
    7   int *keep, Ndel, Nsubset;
     6  off_t i, j;
     7  off_t *keep, Ndel, Nsubset;
    88  RegImage *subset;
    99
    10   ALLOCATE (keep, int, MAX (Nimage, 1));
     10  ALLOCATE (keep, off_t, MAX (Nimage, 1));
    1111  for (i = 0; i < Nimage; i++) keep[i] = TRUE;
    12   fprintf (stderr, "total of %d images\n", Nimage);
     12  fprintf (stderr, "total of %lld images\n", (long long) Nimage);
    1313
    1414  Ndel = 0;
    … …  
    1919    Ndel ++;
    2020  }
    21   fprintf (stderr, "delete %d images\n", Ndel);
     21  fprintf (stderr, "delete %lld images\n", (long long) Ndel);
    2222  if (Ndel == 0) {
    2323    fprintf (stderr, "SUCCESS\n");
    … …  
    2929  Nsubset = Nimage - Ndel;
    3030  ALLOCATE (subset, RegImage, MAX (1, Nsubset));
    31   fprintf (stderr, "keeping %d images\n", Nsubset);
     31  fprintf (stderr, "keeping %lld images\n", (long long) Nsubset);
    3232  for (j = i = 0; i < Nimage; i++) {
    3333    if (!keep[i]) continue;

  • trunk/Ohana/src/imregister/imreg/iminfo.c

    r14590 r27435  
    4242
    4343  /* determine data layout (SINGLE, SPLIT, MEF, CUBE, SLICE) */
    44   gfits_scan (&header, "EXTEND",  "%t", 1, &extend);
     44  gfits_scan_alt (&header, "EXTEND",  "%t", 1, &extend);
    4545  gfits_scan (&header, "NAXIS",  "%d", 1, &Naxes);
    4646  if (extend) { /* MEF file */
    … …  
    6868
    6969  /* extract other relevant data from header */
    70   gfits_scan (&header, ImagetypeKeyword,  "%s", 1, &Imagetype);
     70  gfits_scan (&header, ImagetypeKeyword,  "%s", 1, (char *)&Imagetype);
    7171
    7272  /* grab the image type : if not defined, set to 'none' */
    … …  
    108108      ohana_dms_to_ddd (&tmp, line);
    109109      image[0].ra = 15*tmp;
    110       gfits_scan (&header, DECSexigKeyword, "%s", 1, &line);
     110      gfits_scan (&header, DECSexigKeyword, "%s", 1, (char *)&line);
    111111      ohana_dms_to_ddd (&tmp, line);
    112112      image[0].dec = tmp;

  • trunk/Ohana/src/imregister/imreg/match.c

    r3606 r27435  
    22# include "imreg.h"
    33
    4 int *match_criteria (RegImage *image, int Nimage, int *Nmatch) {
     4off_t *match_criteria (RegImage *image, off_t Nimage, off_t *Nmatch) {
    55
    6   int i, j, Nname;
    7   int N, NMATCH;
    8   int *match;
    9   int reject;
     6  off_t i, j, Nname;
     7  off_t N, NMATCH;
     8  off_t *match;
     9  off_t reject;
    1010
    1111  /* create selection index */
    1212  N = 0;
    1313  NMATCH = 1000;
    14   ALLOCATE (match, int, NMATCH);
     14  ALLOCATE (match, off_t, NMATCH);
    1515
    1616  Nname = 0;
    … …  
    3636    if (N == NMATCH) {
    3737      NMATCH += 1000;
    38       REALLOCATE (match, int, NMATCH);
     38      REALLOCATE (match, off_t, NMATCH);
    3939    }
    4040  }
    … …  
    4343}
    4444
    45 int *match_images (RegImage *image, int Nimage, RegImage *subset, int Nsubset, int *Nmatch) {
     45off_t *match_images (RegImage *image, off_t Nimage, RegImage *subset, off_t Nsubset, off_t *Nmatch) {
    4646 
    47   int i, j, N, Nfound;
    48   int *match;
     47  off_t i, j, N, Nfound;
     48  off_t *match;
    4949
    5050  /* find matching images - very inefficient : sort by obstime, find those first? */
    51   ALLOCATE (match, int, Nsubset);
     51  ALLOCATE (match, off_t, Nsubset);
    5252  for (j = 0; j < Nsubset; j++) {
    5353    match[j] = -1;

  • trunk/Ohana/src/imregister/imreg/modify.c

    r7080 r27435  
    22# include "imreg.h"
    33
    4 void ModifySubset (FITS_DB *db, RegImage *image, int Nimage, int *match, int Nmatch) {
     4void ModifySubset (FITS_DB *db, RegImage *image, off_t Nimage, off_t *match, off_t Nmatch) {
    55
    6   int i, j, Nold;
     6  off_t i, j, Nold;
    77  char *tmppath;
    88  char *ext, *root, *path, dist;

  • trunk/Ohana/src/imregister/imreg/newimages.c

    r3606 r27435  
    22# include "imreg.h"
    33
    4 RegImage *newimages (RegImage *image, int *Nimage) {
     4RegImage *newimages (RegImage *image, off_t *Nimage) {
    55
    6   int i, Nnew;
     6  off_t i, Nnew;
    77  RegImage *regimage;
    88

  • trunk/Ohana/src/imregister/imreg/output.c

    r14590 r27435  
    2424
    2525/* given a subset list, write out the selected images, if desired */
    26 void OutputSubset (RegImage *image, int Nimage, int *match, int Nmatch) {
     26void OutputSubset (RegImage *image, off_t Nimage, off_t *match, off_t Nmatch) {
    2727
    2828  if (output.table != (char *) NULL) {
    … …  
    4545
    4646/* write out complete binary FITS table in format of db */
    47 void DumpFitsBintable (char *filename, RegImage *image, int *match, int Nmatch) {
    48 
    49   int i, j;
     47void DumpFitsBintable (char *filename, RegImage *image, off_t *match, off_t Nmatch) {
     48
     49  off_t i, j;
    5050  FILE *f;
    5151  Header header;
    … …  
    8787}
    8888
    89 void DumpFitsTable (char *filename, RegImage *image, int *match, int Nmatch) {
    90  
    91   int i;
     89void DumpFitsTable (char *filename, RegImage *image, off_t *match, off_t Nmatch) {
     90 
     91  off_t i;
    9292  char *obsstr, *regstr, *line, dummy[64];
    9393  char *modestr, *typestr, *ccdstr, *datestr;
    … …  
    184184
    185185/* Select, TimeMode are global */
    186 int PrintSubset (RegImage *image, int *match, int Nmatch) {
     186int PrintSubset (RegImage *image, off_t *match, off_t Nmatch) {
    187187 
    188188  char ccdstr[64]; 
    189   int i, j;
     189  off_t i, j;
    190190  char *modestr, *typestr, *timestr, *root, *path;
    191191
    … …  
    227227    } else {
    228228      /* this is somewhat poor: I have predefined a subset of value, and I can't guarantee that 'filter' has no spaces */
    229       fprintf (stdout, "%5d %6s %6s %s  ", i, typestr, modestr, ccdstr);
     229      fprintf (stdout, "%5lld %6s %6s %s  ", (long long) i, typestr, modestr, ccdstr);
    230230      fprintf (stdout, "%s %s  ", image[i].pathname, image[i].filename);
    231231      fprintf (stdout, "%s %f %s %f %f %f\n", image[i].filter, image[i].exptime,
    … …  
    238238}
    239239
    240 int dump_data (RegImage *image, int Nimage) {
    241 
    242   int i;
     240int dump_data (RegImage *image, off_t Nimage) {
     241
     242  off_t i;
    243243
    244244  for (i = 0; i < Nimage; i++) {

  • trunk/Ohana/src/imregister/imreg/unique.c

    r16045 r27435  
    22# include "imreg.h"
    33
    4 void sortstr (char **S, int *X, int N) {
     4void sortstr (char **S, off_t *X, off_t N) {
    55
    66# define SWAPFUNC(A,B){ \
    7   char *tmp = S[A]; S[A] = S[B]; S[B] = tmp; \
    8   int itmp = X[A]; X[A] = X[B]; X[B] = itmp; \
     7  char  *tmp = S[A]; S[A] = S[B]; S[B] = tmp; \
     8  off_t itmp = X[A]; X[A] = X[B]; X[B] = itmp; \
    99}
    1010# define COMPARE(A,B)(strcmp(S[A], S[B]) < 0)
    … …  
    1818
    1919/* input is a subset index of image list, output is a new subset */
    20 int *unique_entries (RegImage *image, int Nimage, int *subset, int *Nmatch) {
     20off_t *unique_entries (RegImage *image, off_t Nimage, off_t *subset, off_t *Nmatch) {
    2121
    22   int i, j, k, m, Nsubset;
    23   int N, NMATCH;
    24   int *match, *entry;
     22  off_t i, j, k, m, Nsubset;
     23  off_t N, NMATCH;
     24  off_t *match, *entry;
    2525  char idxline[128];
    2626  char **index;
    … …  
    3131  N = 0;
    3232  NMATCH = 1000;
    33   ALLOCATE (match, int, NMATCH);
     33  ALLOCATE (match, off_t, NMATCH);
    3434
    3535  Nsubset = *Nmatch;
    … …  
    3737  /* index = filename.ccd */
    3838  ALLOCATE (index, char *, Nsubset);
    39   ALLOCATE (entry, int, Nsubset);
     39  ALLOCATE (entry, off_t, Nsubset);
    4040  for (i = 0; i < Nsubset; i++) {
    4141    sprintf (idxline, "%s.%02d", image[subset[i]].filename, image[subset[i]].ccd);
    … …  
    6363    if (N == NMATCH) {
    6464      NMATCH += 1000;
    65       REALLOCATE (match, int, NMATCH);
     65      REALLOCATE (match, off_t, NMATCH);
    6666    }
    6767

  • trunk/Ohana/src/imregister/include/detrend.h

    r21153 r27435  
    8282char **LoadRecipe (char *filter, int *nrecipe);
    8383
    84 Match *MatchCriteria (DetReg *image, int Nimage, int *nmatch);
    85 Match *UniqueSubset (DetReg *image, int Nimage, Match *match, int *nmatch);
    86 Match *ExptimeCriteria (DetReg *image, int Nimage, Match *match, int *nmatch);
    87 Match *CloseCriteria (DetReg *image, int Nimage, Match *match, int *nmatch);
     84Match *MatchCriteria (DetReg *image, off_t Nimage, off_t *nmatch);
     85Match *UniqueSubset (DetReg *image, off_t Nimage, Match *match, off_t *nmatch);
     86Match *ExptimeCriteria (DetReg *image, off_t Nimage, Match *match, off_t *nmatch);
     87Match *CloseCriteria (DetReg *image, off_t Nimage, Match *match, off_t *nmatch);
    8888
    8989Match CheckCriteria (DetReg *image);
    9090
    91 int OutputSubset (DetReg *image, int Nimage, Match *match, int Nmatch);
    92 int DumpFitsTable (char *filename, DetReg *detdata, Match *match, int Nmatch);
    93 int PrintSubset (DetReg *detdata, Match *match, int Nmatch);
    94 Match SelectEntry (DetReg *image, int Nimage, Match *list, int Nlist, Criteria *crit);
     91int OutputSubset (DetReg *image, off_t Nimage, Match *match, off_t Nmatch);
     92int DumpFitsTable (char *filename, DetReg *detdata, Match *match, off_t Nmatch);
     93int PrintSubset (DetReg *detdata, Match *match, off_t Nmatch);
     94Match SelectEntry (DetReg *image, off_t Nimage, Match *list, off_t Nlist, Criteria *crit);
    9595
    9696int usage (void);
    … …  
    101101
    102102int escape (int mode, char *message);
    103 int DumpFitsBintable (char *filename, DetReg *image, Match *match, int Nmatch);
     103int DumpFitsBintable (char *filename, DetReg *image, Match *match, off_t Nmatch);
    104104int cmp_crit (Criteria *crit, DetReg *image);
    105105int set_crit (Criteria *crit, DetReg *image);
    … …  
    107107int PrintCriteria (void);
    108108
    109 int SetAltpath (FITS_DB *db, DetReg *image, int Nimage, Match *match, int Nmatch);
    110 int ModifySubset (FITS_DB *db, DetReg *image, int Nimage, Match *match, int Nmatch);
    111 void DeleteSubset (FITS_DB *db, DetReg *image, int Nimage, Match *match, int Nmatch);
     109int SetAltpath (FITS_DB *db, DetReg *image, off_t Nimage, Match *match, off_t Nmatch);
     110int ModifySubset (FITS_DB *db, DetReg *image, off_t Nimage, Match *match, off_t Nmatch);
     111void DeleteSubset (FITS_DB *db, DetReg *image, off_t Nimage, Match *match, off_t Nmatch);

  • trunk/Ohana/src/imregister/include/imphot.h

    r12332 r27435  
    2020int db_load (FITS_DB *db);
    2121int args (int argc, char **argv);
    22 int DumpFitsBintable (char *filename, Image *image, int *match, int Nmatch);
    23 int DumpFitsTable (char *filename, Image *image, int *match, int Nmatch);
    24 void ModifySubset (FITS_DB *db, Image *image, int Nimage, int *match, int Nmatch);
    25 int PrintSubset (Image *image, int *match, int Nmatch);
    26 int output (Image *image, int *match, int Nmatch);
     22int DumpFitsBintable (char *filename, Image *image, off_t *match, off_t Nmatch);
     23int DumpFitsTable (char *filename, Image *image, off_t *match, off_t Nmatch);
     24void ModifySubset (FITS_DB *db, Image *image, off_t Nimage, off_t *match, off_t Nmatch);
     25int PrintSubset (Image *image, off_t *match, off_t Nmatch);
     26int output (Image *image, off_t *match, off_t Nmatch);
    2727int rfits (FITS_DB *db);
    2828int rtext (FITS_DB *db);
    29 int *subset (Image *image, int Nimage, int *nsubset);
     29off_t *subset (Image *image, off_t Nimage, off_t *nsubset);

  • trunk/Ohana/src/imregister/include/imreg.h

    r21153 r27435  
    7474int args (int argc, char **argv);
    7575
    76 void DeleteSubset (FITS_DB *db, RegImage *image, int Nimage, int *match, int Nmatch);
     76void DeleteSubset (FITS_DB *db, RegImage *image, off_t Nimage, off_t *match, off_t Nmatch);
    7777RegImage *iminfo (char *filename);
    7878
    79 int *match_criteria (RegImage *image, int Nimage, int *Nmatch);
    80 int *match_images (RegImage *image, int Nimage, RegImage *subset, int Nsubset, int *Nmatch);
     79off_t *match_criteria (RegImage *image, off_t Nimage, off_t *Nmatch);
     80off_t *match_images (RegImage *image, off_t Nimage, RegImage *subset, off_t Nsubset, off_t *Nmatch);
    8181
    82 RegImage *newimages (RegImage *image, int *Nimage);
     82RegImage *newimages (RegImage *image, off_t *Nimage);
    8383
    84 void ModifySubset (FITS_DB *db, RegImage *image, int Nimage, int *match, int Nmatch);
     84void ModifySubset (FITS_DB *db, RegImage *image, off_t Nimage, off_t *match, off_t Nmatch);
    8585void SetOutputMode (char *mode);
    86 void OutputSubset (RegImage *image, int Nimage, int *match, int Nmatch);
    87 void DumpFitsBintable (char *filename, RegImage *image, int *match, int Nmatch);
    88 void DumpFitsTable (char *filename, RegImage *image, int *match, int Nmatch);
    89 int PrintSubset (RegImage *image, int *match, int Nmatch);
    90 int dump_data (RegImage *image, int Nimage);
     86void OutputSubset (RegImage *image, off_t Nimage, off_t *match, off_t Nmatch);
     87void DumpFitsBintable (char *filename, RegImage *image, off_t *match, off_t Nmatch);
     88void DumpFitsTable (char *filename, RegImage *image, off_t *match, off_t Nmatch);
     89int PrintSubset (RegImage *image, off_t *match, off_t Nmatch);
     90int dump_data (RegImage *image, off_t Nimage);
    9191int SubmitImages (RegImage *image);
    9292int load_probes (char *filename, unsigned long tzero, int *wantprobe, double *values, int Nprobe);
    … …  
    9494void set_timezone (double dt);
    9595
    96 void DumpCADCTable (char *filename, RegImage *image, int *match, int Nmatch);
    97 int *GetObsIDSubset (RegImage *image, int start, int *index, int *entry, int Nindex, int *Nsubset);
    98 int *GetUniqueObsID (RegImage *image, int *index, int *entry, int Nindex, int *Nmatch);
    99 void GetObsIDIndex (RegImage *image, int *match, int Nmatch, int **Index, int **Entry);
     96void DumpCADCTable (char *filename, RegImage *image, off_t *match, off_t Nmatch);
     97off_t *GetObsIDSubset (RegImage *image, off_t start, off_t *index, off_t *entry, off_t Nindex, off_t *Nsubset);
     98off_t *GetUniqueObsID (RegImage *image, off_t *index, off_t *entry, off_t Nindex, off_t *Nmatch);
     99void GetObsIDIndex (RegImage *image, off_t *match, off_t Nmatch, off_t **Index, off_t **Entry);
    100100double SigmaClipList (double *list, int N);
    101 double MosaicIQStats (RegImage *image, int *match, int Nmatch, MosaicRegion *region);
     101double MosaicIQStats (RegImage *image, off_t *match, off_t Nmatch, MosaicRegion *region);
    102102MosaicLayout *CreateCFH12K (void);
    103103MosaicLayout *CreateMegaCam (void);
    104 int GetREFCCD (RegImage *image, int *index, int *entry, int Nindex, int start);
     104off_t GetREFCCD (RegImage *image, off_t *index, off_t *entry, off_t Nindex, off_t start);
    105105
    106106int imregclient (char *fitsfile, char *statfile, char *datfile);
    … …  
    128128int memstr (char *m1, char *m2, int n);
    129129
    130 int *unique_entries (RegImage *image, int Nimage, int *subset, int *Nmatch);
     130off_t *unique_entries (RegImage *image, off_t Nimage, off_t *subset, off_t *Nmatch);

  • trunk/Ohana/src/imregister/include/imregister.h

    r21153 r27435  
    7373
    7474int parse_time (Header *header);
    75 void sort (float *value, int N);
    76 void dsort (double *value, int N);
    77 void sortstr (char **S, int *X, int N);
    78 void sortpair (int *X, int *Y, int N);
     75void sortstr (char **S, off_t *X, off_t N);
    7976
    8077void ConfigCamera (void);
    … …  
    9289
    9390void warn_scan (Header *header, char *field, char *format, int N, void *var);
    94 int gfits_scan_nchar (Header *header, int size, char *field, int N,...);
     91int gfits_scan_nchar (Header *header, int size, char *field, int N,...) OHANA_FORMAT(scanf, 3, 5);
    9592void warn_scan_nchar (Header *header, int size, char *field, int N, void *var);
    9693

  • trunk/Ohana/src/imregister/include/photreg.h

    r12332 r27435  
    2929int regargs (int argc, char **argv, PhotPars *);
    3030
    31 void DeleteSubset (FITS_DB *db, PhotPars *photpars, int Nphotpars, int *match, int Nmatch);
    32 int *match_criteria (PhotPars *photpars, int Nphotpars, int *Nmatch);
     31void DeleteSubset (FITS_DB *db, PhotPars *photpars, off_t Nphotpars, off_t *match, off_t Nmatch);
     32off_t *match_criteria (PhotPars *photpars, off_t Nphotpars, off_t *Nmatch);
    3333
    34 void OutputSubset (PhotPars *photpars, int Nphotpars, int *match, int Nmatch);
     34void OutputSubset (PhotPars *photpars, off_t Nphotpars, off_t *match, off_t Nmatch);
    3535
    36 void DumpFitsBintable (char *filename, PhotPars *image, int *match, int Nmatch);
    37 void DumpFitsTable (char *filename, PhotPars *image, int *match, int Nmatch);
    38 int PrintSubset (PhotPars *image, int *match, int Nmatch);
     36void DumpFitsBintable (char *filename, PhotPars *image, off_t *match, off_t Nmatch);
     37void DumpFitsTable (char *filename, PhotPars *image, off_t *match, off_t Nmatch);
     38int PrintSubset (PhotPars *image, off_t *match, off_t Nmatch);
    3939
    4040void set_timezone (double dt);
    … …  
    4242int escape (int mode, char *message);
    4343
    44 PhotPars *PhotParsOld_to_PhotPars (PhotParsOld *input, int Nphotpars);
     44PhotPars *PhotParsOld_to_PhotPars (PhotParsOld *input, off_t Nphotpars);
    4545

  • trunk/Ohana/src/imregister/include/spreg.h

    r12332 r27435  
    7878char TelescopeKeyword[64];
    7979
     80int args (int argc, char **argv);
     81off_t *match_criteria (Spectrum *spectrum, off_t Nspectrum, off_t *Nmatch);
     82off_t *unique_entries (Spectrum *spectrum, off_t Nspectrum, off_t *subset, off_t *Nmatch);
    8083
    81 int args (int argc, char **argv);
    82 int *match_criteria (Spectrum *spectrum, int Nspectrum, int *Nmatch);
    83 int *unique_entries (Spectrum *spectrum, int Nspectrum, int *subset, int *Nmatch);
    84 
    85 void ModifySubset (FITS_DB *db, Spectrum *spectrum, int Nspectrum, int *match, int Nmatch);
    86 void DeleteSubset (FITS_DB *db, Spectrum *spectrum, int Nspectrum, int *match, int Nmatch);
    87 void OutputSubset (Spectrum *spectrum, int Nspectrum, int *match, int Nmatch);
     84void ModifySubset (FITS_DB *db, Spectrum *spectrum, off_t Nspectrum, off_t *match, off_t Nmatch);
     85void DeleteSubset (FITS_DB *db, Spectrum *spectrum, off_t Nspectrum, off_t *match, off_t Nmatch);
     86void OutputSubset (Spectrum *spectrum, off_t Nspectrum, off_t *match, off_t Nmatch);
    8887
    8988void SetOutputMode (char *mode);
    90 void DumpFitsBintable (char *filename, Spectrum *spectrum, int *match, int Nmatch);
    91 void DumpFitsTable (char *filename, Spectrum *spectrum, int *match, int Nmatch);
    92 int PrintSubset (Spectrum *spectrum, int *match, int Nmatch);
    93 int dump_data (Spectrum *spectrum, int Nspectrum);
     89void DumpFitsBintable (char *filename, Spectrum *spectrum, off_t *match, off_t Nmatch);
     90void DumpFitsTable (char *filename, Spectrum *spectrum, off_t *match, off_t Nmatch);
     91int PrintSubset (Spectrum *spectrum, off_t *match, off_t Nmatch);
     92int dump_data (Spectrum *spectrum, off_t Nspectrum);
    9493
    9594Spectrum *spinfo (char *filename);
    96 int *match_spectrums (Spectrum *subset, int Nsubset, int *Nmatch);
     95off_t *match_spectrums (Spectrum *subset, off_t Nsubset, off_t *Nmatch);
    9796int SubmitSpectrums (Spectrum *spectrum);
    9897void set_timezone (double dt);
    … …  
    10099void showinfo (Spectrum *spec);
    101100int escape (int mode, char *message);
    102 int set_spectra (Spectrum *new, int Nnew);
    103 Spectrum *get_spectra (int *N);
     101int set_spectra (Spectrum *new, off_t Nnew);
     102Spectrum *get_spectra (off_t *N);
    104103
    105104void ConfigInitSpec (int *argc, char **argv);

  • trunk/Ohana/src/imregister/photreg/convert.c

    r3536 r27435  
    22# include "photreg.h"
    33
    4 PhotPars *PhotParsOld_to_PhotPars (PhotParsOld *input, int Nphotpars) {
     4PhotPars *PhotParsOld_to_PhotPars (PhotParsOld *input, off_t Nphotpars) {
    55
    6   int i;
     6  off_t i;
    77  PhotPars *output;
    88

  • trunk/Ohana/src/imregister/photreg/delete.c

    r7080 r27435  
    22# include "photreg.h"
    33
    4 void DeleteSubset (FITS_DB *db, PhotPars *photdata, int Nphotdata, int *match, int Nmatch) {
     4void DeleteSubset (FITS_DB *db, PhotPars *photdata, off_t Nphotdata, off_t *match, off_t Nmatch) {
    55
    6   int i, j;
    7   int *keep, Ndel, Nsubset;
     6  off_t i, j;
     7  off_t *keep, Ndel, Nsubset;
    88  PhotPars *subset;
    99
    10   ALLOCATE (keep, int, MAX (Nphotdata, 1));
     10  ALLOCATE (keep, off_t, MAX (Nphotdata, 1));
    1111  for (i = 0; i < Nphotdata; i++) keep[i] = TRUE;
    12   fprintf (stderr, "total of %d photdata\n", Nphotdata);
     12  fprintf (stderr, "total of %lld photdata\n", (long long) Nphotdata);
    1313
    1414  Ndel = 0;
    … …  
    1919    Ndel ++;
    2020  }
    21   fprintf (stderr, "delete %d photdata\n", Ndel);
     21  fprintf (stderr, "delete %lld photdata\n", (long long) Ndel);
    2222
    2323  if (Ndel == 0) {
    … …  
    3131  Nsubset = Nphotdata - Ndel;
    3232  ALLOCATE (subset, PhotPars, MAX (1, Nsubset));
    33   fprintf (stderr, "keeping %d photdata\n", Nsubset);
     33  fprintf (stderr, "keeping %lld photdata\n", (long long) Nsubset);
    3434  for (j = i = 0; i < Nphotdata; i++) {
    3535    if (!keep[i]) continue;

  • trunk/Ohana/src/imregister/photreg/match.c

    r3536 r27435  
    22# include "photreg.h"
    33
    4 int *match_criteria (PhotPars *photdata, int Nphotdata, int *Nmatch) {
     4off_t *match_criteria (PhotPars *photdata, off_t Nphotdata, off_t *Nmatch) {
    55
    6   int i, j;
    7   int N, NMATCH;
    8   int *match;
    9   int reject;
     6  off_t i, j;
     7  off_t N, NMATCH;
     8  off_t *match;
     9  off_t reject;
    1010
    1111  /* create selection index */
    1212  N = 0;
    1313  NMATCH = 1000;
    14   ALLOCATE (match, int, NMATCH);
     14  ALLOCATE (match, off_t, NMATCH);
    1515
    1616  /* find entries that matches criteria */
    … …  
    2727    if (N == NMATCH) {
    2828      NMATCH += 1000;
    29       REALLOCATE (match, int, NMATCH);
     29      REALLOCATE (match, off_t, NMATCH);
    3030    }
    3131  }

  • trunk/Ohana/src/imregister/photreg/output.c

    r14590 r27435  
    66
    77/* given a subset list, write out the selected images, if desired */
    8 void OutputSubset (PhotPars *photdata, int Nphotdata, int *match, int Nmatch) {
     8void OutputSubset (PhotPars *photdata, off_t Nphotdata, off_t *match, off_t Nmatch) {
    99
    1010  if (output.table != (char *) NULL) {
    … …  
    2323
    2424/* write out complete binary FITS table in format of db */
    25 void DumpFitsBintable (char *filename, PhotPars *photdata, int *match, int Nmatch) {
    26 
    27   int i, j;
     25void DumpFitsBintable (char *filename, PhotPars *photdata, off_t *match, off_t Nmatch) {
     26
     27  off_t i, j;
    2828  FILE *f;
    2929  Header header;
    … …  
    7171
    7272/** add ASCII table to autocode? **/
    73 void DumpFitsTable (char *filename, PhotPars *photdata, int *index, int Nkeep) {
     73void DumpFitsTable (char *filename, PhotPars *photdata, off_t *index, off_t Nkeep) {
    7474 
    7575  Header header, theader;
    … …  
    8080  char *startstr, *stopstr, *datestr, *line;
    8181  char *c1, *c2, *code, *photsys, *extname;
    82   int i;
     82  off_t i;
    8383  time_t tsecond;
    8484
    … …  
    196196
    197197/* Select, TimeMode are global */
    198 int PrintSubset (PhotPars *photdata, int *match, int Nmatch) {
    199  
    200   int i, j;
     198int PrintSubset (PhotPars *photdata, off_t *match, off_t Nmatch) {
     199 
     200  off_t i, j;
    201201  char *photstr, *timestr, *c1, *c2, *refcode;
    202202 

  • trunk/Ohana/src/imregister/spreg/delete.c

    r7080 r27435  
    22# include "spreg.h"
    33
    4 void DeleteSubset (FITS_DB *db, Spectrum *spectrum, int Nspectrum, int *match, int Nmatch) {
     4void DeleteSubset (FITS_DB *db, Spectrum *spectrum, off_t Nspectrum, off_t *match, off_t Nmatch) {
    55
    6   int i, j;
    7   int *keep, Nbad, Nsubset;
     6  off_t i, j;
     7  off_t *keep, Nbad, Nsubset;
    88  Spectrum *subset;
    99
    10   ALLOCATE (keep, int, MAX (Nspectrum, 1));
     10  ALLOCATE (keep, off_t, MAX (Nspectrum, 1));
    1111  for (i = 0; i < Nspectrum; i++) keep[i] = TRUE;
    12   fprintf (stderr, "total of %d spectra\n", Nspectrum);
     12  fprintf (stderr, "total of %lld spectra\n", (long long) Nspectrum);
    1313
    1414  Nbad = 0;
    … …  
    1919    Nbad ++;
    2020  }
    21   fprintf (stderr, "delete %d spectra\n", Nbad);
     21  fprintf (stderr, "delete %lld spectra\n", (long long) Nbad);
    2222  if (Nbad == 0) {
    2323    fprintf (stderr, "SUCCESS\n");
    … …  
    2828  Nsubset = Nspectrum - Nbad;
    2929  ALLOCATE (subset, Spectrum, MAX (1, Nsubset));
    30   fprintf (stderr, "keeping %d spectra\n", Nsubset);
     30  fprintf (stderr, "keeping %lld spectra\n", (long long) Nsubset);
    3131  for (j = i = 0; i < Nspectrum; i++) {
    3232    if (!keep[i]) continue;

  • trunk/Ohana/src/imregister/spreg/match.c

    r3509 r27435  
    22# include "spreg.h"
    33
    4 int *match_criteria (Spectrum *spectrum, int Nspectrum, int *Nmatch) {
     4off_t *match_criteria (Spectrum *spectrum, off_t Nspectrum, off_t *Nmatch) {
    55
    6   int i, j;
    7   int N, NMATCH;
    8   int *match;
    9   int reject;
    10   int Nfilename, Nobject, Ntelescope, Ninstrument;
     6  off_t i, j;
     7  off_t N, NMATCH;
     8  off_t *match;
     9  off_t reject;
     10  off_t Nfilename, Nobject, Ntelescope, Ninstrument;
    1111
    1212  /* create selection index */
    1313  N = 0;
    1414  NMATCH = 1000;
    15   ALLOCATE (match, int, NMATCH);
     15  ALLOCATE (match, off_t, NMATCH);
    1616
    1717  Nfilename = Nobject = Ntelescope = Ninstrument = 0;
    … …  
    4242    if (N == NMATCH) {
    4343      NMATCH += 1000;
    44       REALLOCATE (match, int, NMATCH);
     44      REALLOCATE (match, off_t, NMATCH);
    4545    }
    4646  }
    … …  
    5151# if (0)
    5252
    53 int *match_spectra (Spectrum *subset, int Nsubset, int *Nmatch) {
     53off_t *match_spectra (Spectrum *subset, off_t Nsubset, off_t *Nmatch) {
    5454 
    55   int i, j, N, Nspectrum, Nfound;
    56   int *match;
     55  off_t i, j, N, Nspectrum, Nfound;
     56  off_t *match;
    5757  Spectrum *spectrum;
    5858
    … …  
    6060
    6161  /* find matching spectra - very inefficient : sort by obstime, find those first? */
    62   ALLOCATE (match, int, Nsubset);
     62  ALLOCATE (match, off_t, Nsubset);
    6363  for (j = 0; j < Nsubset; j++) {
    6464    match[j] = -1;

  • trunk/Ohana/src/imregister/spreg/modify.c

    r7080 r27435  
    22# include "spreg.h"
    33
    4 void ModifySubset (FITS_DB *db, Spectrum *spectrum, int Nspectrum, int *match, int Nmatch) {
     4void ModifySubset (FITS_DB *db, Spectrum *spectrum, off_t Nspectrum, off_t *match, off_t Nmatch) {
    55
    6   int i, j, Nold;
     6  off_t i, j, Nold;
    77  char *tmppath;
    88

  • trunk/Ohana/src/imregister/spreg/output.c

    r14590 r27435  
    1414
    1515/* given a subset list, write out the selected spectra, if desired */
    16 void OutputSubset (Spectrum *spectrum, int Nspectra, int *match, int Nmatch) {
     16void OutputSubset (Spectrum *spectrum, off_t Nspectra, off_t *match, off_t Nmatch) {
    1717
    1818  if (output.table != (char *) NULL) {
    … …  
    2929
    3030/* write out complete binary FITS table in format of db */
    31 void DumpFitsBintable (char *filename, Spectrum *spectrum, int *match, int Nmatch) {
     31void DumpFitsBintable (char *filename, Spectrum *spectrum, off_t *match, off_t Nmatch) {
    3232
    33   int i, j;
     33  off_t i, j;
    3434  FILE *f;
    3535  Header header;
    … …  
    7272
    7373/* write out an ASCII table */
    74 void DumpFitsTable (char *filename, Spectrum *spectrum, int *match, int Nmatch) {
     74void DumpFitsTable (char *filename, Spectrum *spectrum, off_t *match, off_t Nmatch) {
    7575 
    76   int i;
     76  off_t i;
    7777  char *obsstr, *regstr, *line, *datestr;
    7878  time_t tsecond;
    … …  
    141141
    142142/* Select, TimeMode are global */
    143 int PrintSubset (Spectrum *spectrum, int *match, int Nmatch) {
     143int PrintSubset (Spectrum *spectrum, off_t *match, off_t Nmatch) {
    144144 
    145   int i, j;
     145  off_t i, j;
    146146  char *timestr;
    147147
    … …  
    153153
    154154    /* predefined subset of values */
    155     fprintf (stdout, "%5d %20s %s %s %s %s ", i, timestr, spectrum[i].pathname, spectrum[i].filename, spectrum[i].objname, spectrum[i].telescope);
     155    fprintf (stdout, "%5lld %20s %s %s %s %s ", (long long) i, timestr, spectrum[i].pathname, spectrum[i].filename, spectrum[i].objname, spectrum[i].telescope);
    156156    fprintf (stdout, "%5.1f %5.3f %.1f %.1f %.2f\n", spectrum[i].exptime, spectrum[i].airmass, spectrum[i].Ws, spectrum[i].We, spectrum[i].dW);
    157157
    … …  
    161161}
    162162
    163 int dump_data (Spectrum *spectrum, int Nspectrum) {
     163int dump_data (Spectrum *spectrum, off_t Nspectrum) {
    164164
    165   int i;
     165  off_t i;
    166166
    167167  for (i = 0; i < Nspectrum; i++) {

  • trunk/Ohana/src/imregister/spreg/unique.c

    r16045 r27435  
    22# include "spreg.h"
    33
    4 void sortstr (char **S, int *X, int N) {
     4void sortstr (char **S, off_t *X, off_t N) {
    55
    66# define SWAPFUNC(A,B){ \
    77  char *tmp = S[A]; S[A] = S[B]; S[B] = tmp; \
    8   int  itmp = X[A]; X[A] = X[B]; X[B] = itmp; \
     8  off_t  itmp = X[A]; X[A] = X[B]; X[B] = itmp; \
    99}
    1010# define COMPARE(A,B)(strcmp(S[A], S[B]) < 0)
    … …  
    1818
    1919/* input is a subset index of spectrum list, output is a new subset */
    20 int *unique_entries (Spectrum *spectrum, int Nspectrum, int *subset, int *Nmatch) {
     20off_t *unique_entries (Spectrum *spectrum, off_t Nspectrum, off_t *subset, off_t *Nmatch) {
    2121
    22   int i, j, m, Nsubset;
    23   int N, NMATCH;
    24   int *match, *entry;
     22  off_t i, j, m, Nsubset;
     23  off_t N, NMATCH;
     24  off_t *match, *entry;
    2525  char idxline[128];
    2626  char **index;
    … …  
    3131  N = 0;
    3232  NMATCH = 1000;
    33   ALLOCATE (match, int, NMATCH);
     33  ALLOCATE (match, off_t, NMATCH);
    3434
    3535  Nsubset = *Nmatch;
    … …  
    3737  /* index = filename */
    3838  ALLOCATE (index, char *, Nsubset);
    39   ALLOCATE (entry, int, Nsubset);
     39  ALLOCATE (entry, off_t, Nsubset);
    4040  for (i = 0; i < Nsubset; i++) {
    4141    sprintf (idxline, "%s", spectrum[subset[i]].filename);
    … …  
    5555    if (N == NMATCH) {
    5656      NMATCH += 1000;
    57       REALLOCATE (match, int, NMATCH);
     57      REALLOCATE (match, off_t, NMATCH);
    5858    }
    5959

  • trunk/Ohana/src/imregister/src/convertimreg.c

    r7080 r27435  
    88  Header header;
    99  RegImage *pimage;
    10   int i, Nimage, status, lockstate, dbstate;
    11   int *match;
     10  off_t i, Nimage, *match, status;
     11  int lockstate, dbstate;
    1212 
    1313  get_version (argc, argv, version);
    … …  
    4141
    4242  /* load existing data from database */
    43   gfits_scan (&header, "NIMAGES", "%d", 1, &Nimage);
     43  gfits_scan (&header, "NIMAGES", "%lld", 1, (long long *) &Nimage);
    4444  ALLOCATE (pimage, RegImage, Nimage);
    4545  status = fread (pimage, sizeof(RegImage), Nimage, f);
    4646  if (status != Nimage) {
    47     fprintf (stderr, "ERROR: header and data in dB don't match (%d vs %d)\n", Nimage, status);
     47    fprintf (stderr, "ERROR: header and data in dB don't match (%lld vs %lld)\n", (long long) Nimage, (long long) status);
    4848    fclearlockfile (argv[1], f, lockstate, &dbstate);
    4949    exit (1);
    … …  
    5353
    5454  /* create complete subset */
    55   ALLOCATE (match, int, Nimage);
     55  ALLOCATE (match, off_t, Nimage);
    5656  for (i = 0; i < Nimage; i++) match[i] = i;
    5757

  • trunk/Ohana/src/imregister/src/detsearch.c

    r7080 r27435  
    55int main (int argc, char **argv) {
    66 
    7   int Nmatch, Ndetrend;
     7  off_t Nmatch, Ndetrend;
    88  char *dBFile;
    99  FITS_DB db;

  • trunk/Ohana/src/imregister/src/imphotmerge.c

    r12332 r27435  
    33/*** this needs to be written using dvo_image functions !!! ***/
    44
    5 Image *LoadImageTable (FILE *f, Header *header, int *nimage);
     5Image *LoadImageTable (FILE *f, Header *header, off_t *nimage);
    66static char *version = "imphotcopy $Revision: 1.6 $";
    77
    88int main (int argc, char **argv) {
    99 
     10  int N, Ntimes;
     11  off_t status, Nimage;
     12  off_t i, j, Ninput, *index;
    1013  Header header, theader;
    1114  Image *image, *input;
    1215  FILE *f, *g;
    13   int i, j, status, N;
    1416  char *dBFile;
    15   int Nimage, Ninput, *index, Ntimes;
    1617  time_t *tstart, *tstop;
    1718  int VERBOSE, PHOTCODE, dbstate;
    … …  
    9192  /* allocate space for reference lists */
    9293  Nin = 0;
    93   ALLOCATE (index, int, Ninput);
     94  ALLOCATE (index, off_t, Ninput);
    9495 
    9596  /* these filters are applied to input NOT image */
    … …  
    115116
    116117  /* position to begining of file to write header */
    117   fseek (f, 0, SEEK_SET);
    118   status = Fwrite (header.buffer, 1, header.size, f, "char");
    119   if (status != header.size) {
     118  fseeko (f, 0, SEEK_SET);
     119  status = Fwrite (header.buffer, 1, header.datasize, f, "char");
     120  if (status != header.datasize) {
    120121    fprintf (stderr, "ERROR: failed writing data to image header\n");
    121122    exit (0);
    … …  
    123124
    124125  /* position to end of file for new image data */
    125   fseek (f, header.size, SEEK_SET);
     126  fseeko (f, header.datasize, SEEK_SET);
    126127  status = Fwrite (image, sizeof(Image), Nimage, f, "image");
    127128  if (status != Nimage) {
    … …  
    137138}
    138139
    139 Image *LoadImageTable (FILE *f, Header *header, int *nimage) {
     140Image *LoadImageTable (FILE *f, Header *header, off_t *nimage) {
    140141
    141   int Nimage, Ndata, Nread, size;
     142  off_t Nimage, Ndata, Nread, size;
    142143  struct stat filestatus;
    143144  Image *image;
    … …  
    151152  /* check that file size makes sense */
    152153  Nimage = 0;
    153   gfits_scan (header, "NIMAGES", "%d", 1, &Nimage);
     154  gfits_scan (header, "NIMAGES", "%lld", 1, &Nimage);
    154155  if (fstat (fileno(f), &filestatus) == -1) {
    155156    fprintf (stderr, "ERROR: failed to get status of image catalog\n");
    156157    exit (1);
    157158  }
    158   size = Nimage*sizeof(Image) + header[0].size;
     159  size = Nimage*sizeof(Image) + header[0].datasize;
    159160  if (size != filestatus.st_size) {
    160     Ndata = (filestatus.st_size - header[0].size) / sizeof (Image);
     161    Ndata = (filestatus.st_size - header[0].datasize) / sizeof (Image);
    161162    fprintf (stderr, "ERROR: image catalog has inconsistent size\n");
    162     fprintf (stderr, "header: %d, data: %d\n", Nimage, Ndata);
     163    fprintf (stderr, "header: %lld, data: %lld\n", (long long) Nimage, (long long) Ndata);
    163164    Nimage = Ndata;
    164165  }

  • trunk/Ohana/src/imregister/src/imphotsearch.c

    r7080 r27435  
    66int main (int argc, char **argv) {
    77 
    8   int Nmatch, Nimage;
    9   int *match;
     8  off_t Nmatch, Nimage;
     9  off_t *match;
    1010  Image *image;
    1111  FITS_DB db;

  • trunk/Ohana/src/imregister/src/imregister.c

    r7080 r27435  
    55int main (int argc, char **argv) {
    66 
    7   int Nregimage;
     7  off_t Nregimage;
    88  RegImage *image, *regimage;
    99  FITS_DB db;

  • trunk/Ohana/src/imregister/src/imregtable.c

    r7080 r27435  
    55int main (int argc, char **argv) {
    66 
    7   int Nimage;
     7  off_t Nimage;
    88  char *infile;
    99  RegImage *image;

  • trunk/Ohana/src/imregister/src/imsearch.c

    r7080 r27435  
    55int main (int argc, char **argv) {
    66 
    7   int Nmatch, Nimage, *match;
     7  off_t Nmatch, Nimage, *match;
    88  RegImage *image;
    99  FITS_DB db;

  • trunk/Ohana/src/imregister/src/imstatreg.c

    r7080 r27435  
    55int main (int argc, char **argv) {
    66 
    7   int i, child;
    8   int *match, Nmatch, Nimage, Nsubset;
     7  int child;
     8  off_t i, *match, Nmatch, Nimage, Nsubset;
    99  FILE *f;
    1010  RegImage *image, *subset;

  • trunk/Ohana/src/imregister/src/photsearch.c

    r7080 r27435  
    66
    77  char *filename;
    8   int Nmatch, Nphotpars;
    9   int *match;
     8  off_t Nmatch, Nphotpars;
     9  off_t *match;
    1010  FITS_DB db;
    1111  PhotPars *photpars;

  • trunk/Ohana/src/imregister/src/spsearch.c

    r7080 r27435  
    55int main (int argc, char **argv) {
    66 
    7   int Nmatch, Nspectrum, *match;
     7  off_t Nmatch, Nspectrum, *match;
    88  Spectrum *spectrum;
    99  FITS_DB db;

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

    r25757 r27435  
    1111
    1212  channel->coords.Npolyterms = 0;
    13   channel->matrix.size = 0; /* a flag to show there is no data in the matrix */
     13  channel->matrix.datasize = 0; /* a flag to show there is no data in the matrix */
    1414  ALLOCATE (channel->matrix.buffer, char, 1);  /* allocate so later free will not crash! */
    1515

  • trunk/Ohana/src/kapa2/src/LoadPicture.c

    r26891 r27435  
    55  Header header;
    66  char *buff;
    7   int status, bytes_left;
     7  off_t status, bytes_left;
    88  Section *section;
    99  KapaImageWidget *image;
    … …  
    2424  Xoffset = 0.0;
    2525  Yoffset = 0.0;
    26   if (image[0].image[0].matrix.size) {
     26  if (image[0].image[0].matrix.datasize) {
    2727    // XXX enforce int center here?
    2828    Xoffset = image[0].picture.Xc - 0.5*image[0].image[0].matrix.Naxis[0];
    … …  
    3232  gfits_init_header (&header);
    3333  header.Naxes = 2;
    34   KiiScanMessage (sock, "%d %d", &header.Naxis[0], &header.Naxis[1]);
     34  KiiScanMessage (sock, "%lld %lld", (long long *) &header.Naxis[0], (long long *) &header.Naxis[1]);
    3535
    3636  // internal image are 32 bit floats; sender must send in this format
    … …  
    4141
    4242  KiiScanMessage (sock, "%lf %lf %s %s",  &image[0].image[0].zero, &image[0].image[0].range, image[0].image[0].name, image[0].image[0].file);
    43   KiiScanMessage (sock, "%lf %lf %d", &image[0].image[0].min,  &image[0].image[0].max, &header.size);
     43  KiiScanMessage (sock, "%lf %lf %lld", &image[0].image[0].min,  &image[0].image[0].max, (long long *) &header.datasize);
    4444  KiiScanMessage (sock, "%lf %f %f %f %f", &image[0].image[0].coords.crval1, &image[0].image[0].coords.crpix1, &image[0].image[0].coords.cdelt1, &image[0].image[0].coords.pc1_1, &image[0].image[0].coords.pc1_2);
    4545  KiiScanMessage (sock, "%lf %f %f %f %f", &image[0].image[0].coords.crval2, &image[0].image[0].coords.crpix2, &image[0].image[0].coords.cdelt2, &image[0].image[0].coords.pc2_1, &image[0].image[0].coords.pc2_2);
    … …  
    6767  status = 1;
    6868  buff = image[0].image[0].matrix.buffer;
    69   bytes_left = header.size;
    70   image[0].image[0].matrix.size = 0;
     69  bytes_left = header.datasize;
     70  image[0].image[0].matrix.datasize = 0;
    7171  while (bytes_left > 0) {
    7272    status = read (sock, buff, bytes_left);
    … …  
    7777    }
    7878    if (status != -1) { /* pipe has data */
    79       image[0].image[0].matrix.size += status;
     79      image[0].image[0].matrix.datasize += status;
    8080      bytes_left -= status;
    8181      buff = (char *)(buff + status);
    … …  
    8585  fcntl (sock, F_SETFL, !O_NONBLOCK); 
    8686
    87   if (DEBUG) fprintf (stderr, "read %d bytes\n", image[0].image[0].matrix.size);
    88   /* it it not obvious this condition should kill kii, but ... */
    89   if (image[0].image[0].matrix.size != header.size) { 
    90     fprintf (stderr, "error: expected %d bytes, but got only %d\n", header.size, image[0].image[0].matrix.size);
     87  if (DEBUG) fprintf (stderr, "read %lld bytes\n", (long long) image[0].image[0].matrix.datasize);
     88  /* it it not obvious this condition should kill kapa, but ... */
     89  if (image[0].image[0].matrix.datasize != header.datasize) { 
     90    fprintf (stderr, "error: expected %lld bytes, but got only %lld\n", (long long) header.datasize, (long long) image[0].image[0].matrix.datasize);
    9191    return (FALSE);
    9292  }

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

    r26891 r27435  
    99  int Npalette;
    1010  char filename[1024];
    11   int Nbytes, status;
    1211  bDrawBuffer *buffer;
    1312  Graphic *graphic;

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

    r26891 r27435  
    55  FILE *f;
    66  char *line, filename[1024];
    7   int Nbytes, status, dx, dy, i, j, Npalette, color;
     7  int dx, dy, i, j, Npalette, color;
    88  png_color *palette;
    99  bDrawBuffer *buffer;

  • trunk/Ohana/src/kapa2/src/Relocate.c

    r25757 r27435  
    44int Relocate (int sock) {
    55 
    6   int i, Nsection;
    76  int x, y, dX, dY;
    87  Graphic *graphic;
    9   Section *section;
    108
    119  graphic = GetGraphic();

  • trunk/Ohana/src/kapa2/src/SetImageData.c

    r16256 r27435  
    1717 
    1818  // get image data from client
    19   KiiScanMessage (sock, "%lf %lf %s",
     19  KiiScanMessage (sock, "%lf %lf %s %s",
    2020                  &image[0].image[0].zero,
    2121                  &image[0].image[0].range,

  • trunk/Ohana/src/libautocode/def/autocode.c

    r24399 r27435  
    11# include "autocode.h"
    22
    3 int gfits_convert_$STRUCT ($STRUCT *data, int size, int nitems) {
     3int gfits_convert_$STRUCT ($STRUCT *data, off_t size, off_t nitems) {
    44
    5   int i;
     5  off_t i;
    66  unsigned char *byte, tmp;
    77
    88  if (size != $SIZE) {
    9     fprintf (stderr, "WARNING: mismatch in data types $STRUCT: %d vs %d\n", size, $SIZE);
     9    fprintf (stderr, "WARNING: mismatch in data types $STRUCT: %lld vs %lld\n", (long long) size, (long long) $SIZE);
    1010    return (FALSE);
    1111  }
    … …  
    2525}
    2626
    27 $STRUCT *gfits_downsize_and_convert_$STRUCT ($STRUCT *data, int size, int nitems) {
     27$STRUCT *gfits_downsize_and_convert_$STRUCT ($STRUCT *data, off_t size, off_t nitems) {
    2828
    29   int i;
     29  off_t i;
    3030  unsigned char *byte, tmp;
    3131  $STRUCT *output;
    3232
    3333  if ($SIZE > size) {
    34     fprintf (stderr, "ERROR: uncorrectable mismatch in data types $STRUCT: %d vs %d\n", size, $SIZE);
     34    fprintf (stderr, "ERROR: uncorrectable mismatch in data types $STRUCT: %lld vs %lld\n", (long long) size, (long long) $SIZE);
    3535    exit (1);
    3636  }
    … …  
    5858/*** add test of EXTNAME and header-defined columns? ***/
    5959/* return internal structure representation */
    60 $STRUCT *gfits_table_get_$STRUCT (FTable *ftable, int *Ndata, int *swapped) {
     60$STRUCT *gfits_table_get_$STRUCT (FTable *ftable, off_t *Ndata, char *swapped) {
    6161
    6262  $STRUCT *data, *output;
    … …  
    6868      output = gfits_downsize_and_convert_$STRUCT (data, sizeof ($STRUCT), *Ndata);
    6969      free (ftable[0].buffer);
    70       ftable[0].buffer = output;
     70      ftable[0].buffer = (char *) output;
    7171      // XXX do I need to change NX?
    7272    }
    … …  
    7777}
    7878
    79 int gfits_table_set_$STRUCT (FTable *ftable, $STRUCT *data, int Ndata) {
     79int gfits_table_set_$STRUCT (FTable *ftable, $STRUCT *data, off_t Ndata) {
    8080
    8181  Header *header;

  • trunk/Ohana/src/libautocode/def/autocode.h

    r7080 r27435  
    22/** STRUCT DEFINITION **/
    33
    4 $STRUCT *gfits_table_get_$STRUCT (FTable *table, int *Ndata, int *swapped);
    5 int      gfits_table_set_$STRUCT (FTable *ftable, $STRUCT *data, int Ndata);
     4$STRUCT *gfits_table_get_$STRUCT (FTable *table, off_t *Ndata, char *swapped);
     5int      gfits_table_set_$STRUCT (FTable *ftable, $STRUCT *data, off_t Ndata);
    66int      gfits_table_mkheader_$STRUCT (Header *header);
    7 int      gfits_convert_$STRUCT ($STRUCT *data, int size, int nitems);
    8 int Send_$STRUCT (int device, $STRUCT *data, int Ndata, int copy);
    9 int Recv_$STRUCT (int device, $STRUCT **data, int *Ndata);
     7int      gfits_convert_$STRUCT ($STRUCT *data, off_t size, off_t nitems);
     8int      Send_$STRUCT (int device, $STRUCT *data, int Ndata, int copy);
     9int      Recv_$STRUCT (int device, $STRUCT **data, int *Ndata);

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

    r25757 r27435  
    1010
    1111/* DVO table formats */
    12 typedef enum {DVO_FORMAT_UNDEF,
    13               DVO_FORMAT_INTERNAL,
    14               DVO_FORMAT_ELIXIR,
    15               DVO_FORMAT_LONEOS,
    16               DVO_FORMAT_PANSTARRS_DEV_0,
    17               DVO_FORMAT_PANSTARRS_DEV_1,
    18               DVO_FORMAT_PS1_DEV_1,
    19               DVO_FORMAT_PS1_DEV_2,
    20               DVO_FORMAT_PS1_DEV_3,
    21               DVO_FORMAT_PS1_V1,
    22               DVO_FORMAT_PS1_REF
     12typedef enum {
     13  DVO_FORMAT_UNDEF,
     14  DVO_FORMAT_INTERNAL,
     15  DVO_FORMAT_ELIXIR,
     16  DVO_FORMAT_LONEOS,
     17  DVO_FORMAT_PANSTARRS_DEV_0,
     18  DVO_FORMAT_PANSTARRS_DEV_1,
     19  DVO_FORMAT_PS1_DEV_1,
     20  DVO_FORMAT_PS1_DEV_2,
     21  DVO_FORMAT_PS1_DEV_3,
     22  DVO_FORMAT_PS1_V1,
     23  DVO_FORMAT_PS1_REF
    2324} DVOTableFormat;
    2425
    … …  
    155156  FILE  *f;
    156157  char  *filename;
    157   int    dbstate;
    158   int    lockstate;
    159158  double timeout;
    160159  Header header;
    … …  
    163162  FTable ftable;
    164163  VTable vtable;
    165   int    mode;          /* what data storage mode is used for disk file? */
    166   int    format;        /* what data format is used for disk file? */
    167   int    virtual;       /* is table in ftable or vtable? */
    168   int    swapped;       /* is table in internal byte-order? */
     164  int    dbstate;
     165  char   lockstate;
     166  char   mode;          /* what data storage mode is used for disk file? */
     167  char   format;        /* what data format is used for disk file? */
     168  char   virtual;       /* is table in ftable or vtable? */
     169  char   swapped;       /* is table in internal byte-order? */
    169170} FITS_DB;
    170171
    … …  
    174175/* SkyRegion : better implementation than GSCRegion */
    175176typedef struct {
    176   int Nregions;
     177  off_t Nregions;
    177178  char **filename;
    178179  SkyRegion *regions;
    … …  
    180181
    181182typedef struct {
    182   int Nregions;
     183  off_t Nregions;
    183184  int ownElements;                                /* does this list own filename, regions? */
    184185  char **filename;
    … …  
    187188
    188189// special-case function:
    189 CMF_PS1_V2 *gfits_table_get_CMF_PS1_V1_Alt (FTable *ftable, int *Ndata, int *swapped);
    190 
    191 # if (0)
    192 /* structure for data on a catalog region */
    193 typedef struct {
    194   char filename[256];
    195   double DEC[2], RA[2];
    196 } GSCRegion;
    197 # endif
     190CMF_PS1_V2 *gfits_table_get_CMF_PS1_V1_Alt (FTable *ftable, off_t *Ndata, char *swapped);
    198191
    199192typedef struct {
    … …  
    219212
    220213  int Nsecfilt;  /* number of secfilt entries for each average entry */
    221   int Naverage,   Nmeasure,   Nmissing,   Nsecf_mem;  /* current number of each component in memory */
    222   int Naves_disk, Nmeas_disk, Nmiss_disk, Nsecf_disk; /* current number of each component on disk */
    223   int Naves_off,  Nmeas_off,  Nmiss_off,  Nsecf_off;  /* index of first loaded data value */
     214  off_t Naverage,   Nmeasure,   Nmissing,   Nsecf_mem;  /* current number of each component in memory */
     215  off_t Naves_disk, Nmeas_disk, Nmiss_disk, Nsecf_disk; /* current number of each component on disk */
     216  off_t Naves_off,  Nmeas_off,  Nmiss_off,  Nsecf_off;  /* index of first loaded data value */
     217
     218  /* the Nsecf_* values above are number of table rows (eg, Naverage*Nsecfilt) */
    224219
    225220  /* note the different counting for Nsecfilt:
    … …  
    239234
    240235  /* extra catalog information */
    241   int lockmode;
    242   int catmode;                          /* storage mode (raw, mef, split, mysql) */
    243   int catformat;                        /* storage format (elixir, panstarrs, etc) */
    244   int catflags;                         /* choices to be loaded */
    245   int sorted;                           /* is measure table average-sorted? */
     236  char lockmode;
     237  char catmode;                         /* storage mode (raw, mef, split, mysql) */
     238  char catformat;                       /* storage format (elixir, panstarrs, etc) */
     239  char catflags;                                /* choices to be loaded */
     240  char sorted;                          /* is measure table average-sorted? */
    246241 
    247242  /* pointers for data manipulation */
    248   int *found;
    249   int *image;
    250   int *mosaic;
     243  off_t *found;
     244  off_t *image;
     245  off_t *mosaic;
    251246  float *X;
    252247  float *Y;
    … …  
    261256int   gfits_db_lock                PROTO((FITS_DB *db, char *filename));
    262257int   gfits_db_load                PROTO((FITS_DB *db));
    263 int   gfits_db_load_segment        PROTO((FITS_DB *db, int start, int Nrows));
     258int   gfits_db_load_segment        PROTO((FITS_DB *db, off_t start, off_t Nrows));
    264259int   gfits_db_save                PROTO((FITS_DB *db));
    265260int   gfits_db_update              PROTO((FITS_DB *db));
    … …  
    287282
    288283int isRegisteredMosaic (void);
    289 int GetRegisteredMosaic (void);
     284off_t GetRegisteredMosaic (void);
    290285int GetMosaicCoords (Coords *coords);
    291 int FindMosaicForImage (Image *images, int Nimages, int entry);
    292 int FindMosaicForImage_TableSearch (Image *images, int Nimages, int entry);
    293 int FindMosaicForImage_MatchSearch (Image *images, int Nimages, int entry);
    294 int BuildChipMatch (Image *images, int Nimages);
     286int FindMosaicForImage (Image *images, off_t Nimages, off_t entry);
     287int FindMosaicForImage_TableSearch (Image *images, off_t Nimages, off_t entry);
     288int FindMosaicForImage_MatchSearch (Image *images, off_t Nimages, off_t entry);
     289int BuildChipMatch (Image *images, off_t Nimages);
    295290void SetImageCorners (double *X, double *Y, Image *image);
    296291
    … …  
    347342int get_image_mode (char *name);
    348343char *get_mode_name (int mode);
    349 
    350 /* these functions refer to the DVO structures defined in the includes above
    351  *  they are being replaced with autocode entries (drop when totally autocoded)
    352  */
    353 
    354 int   Fread (void *ptr, int size, int nitems, FILE *f, char *type);
    355 int   Fwrite (void *ptr, int size, int nitems, FILE *f, char *type);
    356 int   ByteSwap (char *ptr, int size, int nitems, char *type);
    357 int   ConvertStruct (char *buffer, int size, int Nbytes, char *type);
    358344
    359345/** dvo_catalog APIs */
    … …  
    384370int dvo_catalog_save_split_complete (Catalog *catalog, char VERBOSE);
    385371
    386 int dvo_catalog_load_segment (Catalog *catalog, int VERBOSE, int start, int Nrows);
    387 int dvo_catalog_load_segment_split (Catalog *catalog, int VERBOSE, int start, int Nrows);
     372int dvo_catalog_load_segment (Catalog *catalog, int VERBOSE, off_t start, off_t Nrows);
     373int dvo_catalog_load_segment_split (Catalog *catalog, int VERBOSE, off_t start, off_t Nrows);
    388374
    389375/*** conversion functions / I/O conversions ***/
    390 Average *ReadRawAverage (FILE *f, int Naverage, int format, SecFilt **primary);
    391 Measure *ReadRawMeasure (FILE *f, int Nmeasure, int format);
    392 SecFilt *ReadRawSecFilt (FILE *f, int Nsecfilt, int format);
    393 int WriteRawAverage (FILE *f, Average *average, int Naverage, int format, SecFilt *primary);
    394 int WriteRawMeasure (FILE *f, Measure *measure, int Nmeasure, int format);
    395 int WriteRawSecFilt (FILE *f, SecFilt *secfilt, int Nsecfilt, int format);
    396 
    397 Average *FtableToAverage (FTable *ftable, int *Naverage, int *format, SecFilt **primary);
    398 Measure *FtableToMeasure (FTable *ftable, int *Nmeasure, int *format);
    399 SecFilt *FtableToSecFilt (FTable *ftable, int *Nsecfilt, int *format);
    400 int FtableToImage (FTable *ftable, Header *theader, int *format);
    401 
    402 int AverageToFtable (FTable *ftable, Average *average, int Naverage, int format, SecFilt *primary);
    403 int MeasureToFtable (FTable *ftable, Measure *measure, int Nmeasure, int format);
    404 int SecFiltToFtable (FTable *ftable, SecFilt *secfilt, int Nsecfilt, int format);
    405 int ImageToFtable (FTable *ftable, Header *theader, int format);
    406 int ImageToVtable (VTable *vtable, Header *theader, int format);
     376Average *ReadRawAverage (FILE *f, off_t Naverage, char format, SecFilt **primary);
     377Measure *ReadRawMeasure (FILE *f, off_t Nmeasure, char format);
     378SecFilt *ReadRawSecFilt (FILE *f, off_t Nsecfilt, char format);
     379int WriteRawAverage (FILE *f, Average *average, off_t Naverage, char format, SecFilt *primary);
     380int WriteRawMeasure (FILE *f, Measure *measure, off_t Nmeasure, char format);
     381int WriteRawSecFilt (FILE *f, SecFilt *secfilt, off_t Nsecfilt, char format);
     382
     383Average *FtableToAverage (FTable *ftable, off_t *Naverage, char *format, SecFilt **primary);
     384Measure *FtableToMeasure (FTable *ftable, off_t *Nmeasure, char *format);
     385SecFilt *FtableToSecFilt (FTable *ftable, off_t *Nsecfilt, char *format);
     386int      FtableToImage   (FTable *ftable, Header *theader, char *format);
     387
     388int AverageToFtable (FTable *ftable, Average *average, off_t Naverage, char format, SecFilt *primary);
     389int MeasureToFtable (FTable *ftable, Measure *measure, off_t Nmeasure, char format);
     390int SecFiltToFtable (FTable *ftable, SecFilt *secfilt, off_t Nsecfilt, char format);
     391int ImageToFtable (FTable *ftable, Header *theader, char format);
     392int ImageToVtable (VTable *vtable, Header *theader, char format);
    407393
    408394# include "loneos_defs.h"
    … …  
    425411int dvo_image_update_raw (FITS_DB *db, int VERBOSE);
    426412int dvo_image_save_raw (FITS_DB *db, int VERBOSE);
    427 int dvo_image_addrows (FITS_DB *db, Image *new, int Nnew);
     413int dvo_image_addrows (FITS_DB *db, Image *new, off_t Nnew);
    428414void dvo_image_create (FITS_DB *db, double ZeroPoint);
    429415
    … …  
    454440
    455441/* dvo-specific sorting functions */
    456 void sortave (Average *ave, int N);
    457 void sort_image_subset (Image *image, int *subset, int N);
    458 void sort_coords_index (double *X, double *Y, int *S, int N);
    459 void sort_regions (SkyRegion *region, int N);
     442void sortave (Average *ave, off_t N);
     443void sort_image_subset (Image *image, off_t *subset, off_t N);
     444void sort_coords_index (double *X, double *Y, off_t *S, off_t N);
     445void sort_regions (SkyRegion *region, off_t N);
    460446
    461447# endif

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

    r26410 r27435  
    99
    1010typedef struct {
    11     char        gscfile[256];
    12     char        catdir[256];
    13     char        catmode[256];
    14     char        catformat[256];
    15     char        photcodeFile[256];
    16     char        skyTableFile[256];
    17     int         skyDepth;
    18     FITS_DB     imageDB;
    19     Image       *images;
    20     int         nImages;
    21     SkyTable    *skyTable;
     11  char        gscfile[256];
     12  char        catdir[256];
     13  char        catmode[256];
     14  char        catformat[256];
     15  char        photcodeFile[256];
     16  char        skyTableFile[256];
     17  int         skyDepth;
     18  FITS_DB     imageDB;
     19  Image      *images;
     20  off_t       nImages;
     21  SkyTable   *skyTable;
    2222#if (DVO_UTIL_READ_CAMERA_CONFIG)
    23     char        cameraConfig[256];
    24     int         *ccdNum;
    25     int         nCCD;
     23  char        cameraConfig[256];
     24  int        *ccdNum;
     25  int         nCCD;
    2626#endif
    2727} dvoConfig;
    … …  
    2929// This structure needs to be fleshed out
    3030typedef struct {
    31     int         valid;
    32     Average     ave;
    33     Measure     meas;
     31  int         valid;
     32  Average     ave;
     33  Measure     meas;
    3434#ifdef notdef
    35     int         objID;
    36     int         catID;
    37     int         detID;
    38     uint64_t    pspsObjID;
    39     uint64_t    pspsDetID;
     35  int         objID;
     36  int         catID;
     37  int         detID;
     38  uint64_t    pspsObjID;
     39  uint64_t    pspsDetID;
    4040#endif
    4141} dvoDetection;
    … …  
    5252dvoConfig *dvoConfigRead(int *argc, char **argv);
    5353
    54 // free's memory associated with the dvoConfig structure
     54// frees memory associated with the dvoConfig structure
    5555void dvoConfigFree(dvoConfig *dvoConfig);
    5656
    … …  
    7070SkyList *dvoSkyListByExternID(dvoConfig *dvoConfig, int sourceID, int externID, Image **ppImage);
    7171
    72 // return a list of detectsions from a particular image id
     72// return a list of detections from a particular image id
    7373// Use dvoFree() to free the memory pointed to by results
    74 int dvoGetDetections(SkyList *skylist, int imageID, dvoDetection **results, int *pMaxDetID);
     74off_t dvoGetDetections(SkyList *skylist, int imageID, dvoDetection **results, int *pMaxDetID);
    7575
    7676// free memory returned by various dvo util functions

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

    r15694 r27435  
    1 Image                   *Image_Elixir_ToInternal (Image_Elixir *in, int Nvalues);
    2 Image_Elixir            *ImageInternalTo_Elixir (Image *in, int Nvalues);
    3 Average                 *Average_Elixir_ToInternal (Average_Elixir *in, int Nvalues, SecFilt **primary);
    4 Average_Elixir          *AverageInternalTo_Elixir (Average *in, int Nvalues, SecFilt *primary);
    5 Measure                 *Measure_Elixir_ToInternal (Measure_Elixir *in, int Nvalues);
    6 Measure_Elixir          *MeasureInternalTo_Elixir (Measure *in, int Nvalues);
    7 SecFilt                 *SecFilt_Elixir_ToInternal (SecFilt_Elixir *in, int Nvalues);
    8 SecFilt_Elixir          *SecFiltInternalTo_Elixir (SecFilt *in, int Nvalues);
     1Image                   *Image_Elixir_ToInternal (Image_Elixir *in, off_t Nvalues);
     2Image_Elixir            *ImageInternalTo_Elixir (Image *in, off_t Nvalues);
     3Average                 *Average_Elixir_ToInternal (Average_Elixir *in, off_t Nvalues, SecFilt **primary);
     4Average_Elixir          *AverageInternalTo_Elixir (Average *in, off_t Nvalues, SecFilt *primary);
     5Measure                 *Measure_Elixir_ToInternal (Measure_Elixir *in, off_t Nvalues);
     6Measure_Elixir          *MeasureInternalTo_Elixir (Measure *in, off_t Nvalues);
     7SecFilt                 *SecFilt_Elixir_ToInternal (SecFilt_Elixir *in, off_t Nvalues);
     8SecFilt_Elixir          *SecFiltInternalTo_Elixir (SecFilt *in, off_t Nvalues);
    99
    10 PhotCode *PhotCode_Elixir_To_Internal (PhotCode_Elixir *in, int Nvalues);
    11 PhotCode_Elixir *PhotCode_Internal_To_Elixir (PhotCode *in, int Nvalues);
     10PhotCode *PhotCode_Elixir_To_Internal (PhotCode_Elixir *in, off_t Nvalues);
     11PhotCode_Elixir *PhotCode_Internal_To_Elixir (PhotCode *in, off_t Nvalues);

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

    r15035 r27435  
    1 Image                   *Image_Loneos_ToInternal (Image_Loneos *in, int Nvalues);
    2 Image_Loneos            *ImageInternalTo_Loneos (Image *in, int Nvalues);
    3 Average                 *Average_Loneos_ToInternal (Average_Loneos *in, int Nvalues, SecFilt **primary);
    4 Average_Loneos          *AverageInternalTo_Loneos (Average *in, int Nvalues, SecFilt *primary);
    5 Measure                 *Measure_Loneos_ToInternal (Measure_Loneos *in, int Nvalues);
    6 Measure_Loneos          *MeasureInternalTo_Loneos (Measure *in, int Nvalues);
    7 SecFilt                 *SecFilt_Loneos_ToInternal (SecFilt_Loneos *in, int Nvalues);
    8 SecFilt_Loneos          *SecFiltInternalTo_Loneos (SecFilt *in, int Nvalues);
     1Image                   *Image_Loneos_ToInternal (Image_Loneos *in, off_t Nvalues);
     2Image_Loneos            *ImageInternalTo_Loneos (Image *in, off_t Nvalues);
     3Average                 *Average_Loneos_ToInternal (Average_Loneos *in, off_t Nvalues, SecFilt **primary);
     4Average_Loneos          *AverageInternalTo_Loneos (Average *in, off_t Nvalues, SecFilt *primary);
     5Measure                 *Measure_Loneos_ToInternal (Measure_Loneos *in, off_t Nvalues);
     6Measure_Loneos          *MeasureInternalTo_Loneos (Measure *in, off_t Nvalues);
     7SecFilt                 *SecFilt_Loneos_ToInternal (SecFilt_Loneos *in, off_t Nvalues);
     8SecFilt_Loneos          *SecFiltInternalTo_Loneos (SecFilt *in, off_t Nvalues);

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

    r15035 r27435  
    1 Image                   *Image_Panstarrs_DEV_0_ToInternal (Image_Panstarrs_DEV_0 *in, int Nvalues);
    2 Image_Panstarrs_DEV_0   *ImageInternalTo_Panstarrs_DEV_0 (Image *in, int Nvalues);
    3 Average                 *Average_Panstarrs_DEV_0_ToInternal (Average_Panstarrs_DEV_0 *in, int Nvalues, SecFilt **primary);
    4 Average_Panstarrs_DEV_0 *AverageInternalTo_Panstarrs_DEV_0 (Average *in, int Nvalues, SecFilt *primary);
    5 Measure                 *Measure_Panstarrs_DEV_0_ToInternal (Measure_Panstarrs_DEV_0 *in, int Nvalues);
    6 Measure_Panstarrs_DEV_0 *MeasureInternalTo_Panstarrs_DEV_0 (Measure *in, int Nvalues);
    7 SecFilt                 *SecFilt_Panstarrs_DEV_0_ToInternal (SecFilt_Panstarrs_DEV_0 *in, int Nvalues);
    8 SecFilt_Panstarrs_DEV_0 *SecFiltInternalTo_Panstarrs_DEV_0 (SecFilt *in, int Nvalues);
     1Image                   *Image_Panstarrs_DEV_0_ToInternal (Image_Panstarrs_DEV_0 *in, off_t Nvalues);
     2Image_Panstarrs_DEV_0   *ImageInternalTo_Panstarrs_DEV_0 (Image *in, off_t Nvalues);
     3Average                 *Average_Panstarrs_DEV_0_ToInternal (Average_Panstarrs_DEV_0 *in, off_t Nvalues, SecFilt **primary);
     4Average_Panstarrs_DEV_0 *AverageInternalTo_Panstarrs_DEV_0 (Average *in, off_t Nvalues, SecFilt *primary);
     5Measure                 *Measure_Panstarrs_DEV_0_ToInternal (Measure_Panstarrs_DEV_0 *in, off_t Nvalues);
     6Measure_Panstarrs_DEV_0 *MeasureInternalTo_Panstarrs_DEV_0 (Measure *in, off_t Nvalues);
     7SecFilt                 *SecFilt_Panstarrs_DEV_0_ToInternal (SecFilt_Panstarrs_DEV_0 *in, off_t Nvalues);
     8SecFilt_Panstarrs_DEV_0 *SecFiltInternalTo_Panstarrs_DEV_0 (SecFilt *in, off_t Nvalues);

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

    r15035 r27435  
    1 Image                   *Image_Panstarrs_DEV_1_ToInternal (Image_Panstarrs_DEV_1 *in, int Nvalues);
    2 Image_Panstarrs_DEV_1   *ImageInternalTo_Panstarrs_DEV_1 (Image *in, int Nvalues);
    3 Average                 *Average_Panstarrs_DEV_1_ToInternal (Average_Panstarrs_DEV_1 *in, int Nvalues, SecFilt **primary);
    4 Average_Panstarrs_DEV_1 *AverageInternalTo_Panstarrs_DEV_1 (Average *in, int Nvalues, SecFilt *primary);
    5 Measure                 *Measure_Panstarrs_DEV_1_ToInternal (Measure_Panstarrs_DEV_1 *in, int Nvalues);
    6 Measure_Panstarrs_DEV_1 *MeasureInternalTo_Panstarrs_DEV_1 (Measure *in, int Nvalues);
    7 SecFilt                 *SecFilt_Panstarrs_DEV_1_ToInternal (SecFilt_Panstarrs_DEV_1 *in, int Nvalues);
    8 SecFilt_Panstarrs_DEV_1 *SecFiltInternalTo_Panstarrs_DEV_1 (SecFilt *in, int Nvalues);
     1Image                   *Image_Panstarrs_DEV_1_ToInternal (Image_Panstarrs_DEV_1 *in, off_t Nvalues);
     2Image_Panstarrs_DEV_1   *ImageInternalTo_Panstarrs_DEV_1 (Image *in, off_t Nvalues);
     3Average                 *Average_Panstarrs_DEV_1_ToInternal (Average_Panstarrs_DEV_1 *in, off_t Nvalues, SecFilt **primary);
     4Average_Panstarrs_DEV_1 *AverageInternalTo_Panstarrs_DEV_1 (Average *in, off_t Nvalues, SecFilt *primary);
     5Measure                 *Measure_Panstarrs_DEV_1_ToInternal (Measure_Panstarrs_DEV_1 *in, off_t Nvalues);
     6Measure_Panstarrs_DEV_1 *MeasureInternalTo_Panstarrs_DEV_1 (Measure *in, off_t Nvalues);
     7SecFilt                 *SecFilt_Panstarrs_DEV_1_ToInternal (SecFilt_Panstarrs_DEV_1 *in, off_t Nvalues);
     8SecFilt_Panstarrs_DEV_1 *SecFiltInternalTo_Panstarrs_DEV_1 (SecFilt *in, off_t Nvalues);

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

    r15694 r27435  
    1 Image                   *Image_PS1_DEV_1_ToInternal (Image_PS1_DEV_1 *in, int Nvalues);
    2 Image_PS1_DEV_1         *ImageInternalTo_PS1_DEV_1 (Image *in, int Nvalues);
    3 Average                 *Average_PS1_DEV_1_ToInternal (Average_PS1_DEV_1 *in, int Nvalues, SecFilt **primary);
    4 Average_PS1_DEV_1       *AverageInternalTo_PS1_DEV_1 (Average *in, int Nvalues, SecFilt *primary);
    5 Measure                 *Measure_PS1_DEV_1_ToInternal (Measure_PS1_DEV_1 *in, int Nvalues);
    6 Measure_PS1_DEV_1       *MeasureInternalTo_PS1_DEV_1 (Measure *in, int Nvalues);
    7 SecFilt                 *SecFilt_PS1_DEV_1_ToInternal (SecFilt_PS1_DEV_1 *in, int Nvalues);
    8 SecFilt_PS1_DEV_1       *SecFiltInternalTo_PS1_DEV_1 (SecFilt *in, int Nvalues);
     1Image                   *Image_PS1_DEV_1_ToInternal (Image_PS1_DEV_1 *in, off_t Nvalues);
     2Image_PS1_DEV_1         *ImageInternalTo_PS1_DEV_1 (Image *in, off_t Nvalues);
     3Average                 *Average_PS1_DEV_1_ToInternal (Average_PS1_DEV_1 *in, off_t Nvalues, SecFilt **primary);
     4Average_PS1_DEV_1       *AverageInternalTo_PS1_DEV_1 (Average *in, off_t Nvalues, SecFilt *primary);
     5Measure                 *Measure_PS1_DEV_1_ToInternal (Measure_PS1_DEV_1 *in, off_t Nvalues);
     6Measure_PS1_DEV_1       *MeasureInternalTo_PS1_DEV_1 (Measure *in, off_t Nvalues);
     7SecFilt                 *SecFilt_PS1_DEV_1_ToInternal (SecFilt_PS1_DEV_1 *in, off_t Nvalues);
     8SecFilt_PS1_DEV_1       *SecFiltInternalTo_PS1_DEV_1 (SecFilt *in, off_t Nvalues);
    99
    10 PhotCode *PhotCode_PS1_DEV_1_To_Internal (PhotCode_PS1_DEV_1 *in, int Nvalues);
    11 PhotCode_PS1_DEV_1 *PhotCode_Internal_To_PS1_DEV_1 (PhotCode *in, int Nvalues);
     10PhotCode *PhotCode_PS1_DEV_1_To_Internal (PhotCode_PS1_DEV_1 *in, off_t Nvalues);
     11PhotCode_PS1_DEV_1 *PhotCode_Internal_To_PS1_DEV_1 (PhotCode *in, off_t Nvalues);

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

    r16810 r27435  
    1 Image                   *Image_PS1_DEV_2_ToInternal (Image_PS1_DEV_2 *in, int Nvalues);
    2 Image_PS1_DEV_2         *ImageInternalTo_PS1_DEV_2 (Image *in, int Nvalues);
    3 Average                 *Average_PS1_DEV_2_ToInternal (Average_PS1_DEV_2 *in, int Nvalues, SecFilt **primary);
    4 Average_PS1_DEV_2       *AverageInternalTo_PS1_DEV_2 (Average *in, int Nvalues, SecFilt *primary);
    5 Measure                 *Measure_PS1_DEV_2_ToInternal (Measure_PS1_DEV_2 *in, int Nvalues);
    6 Measure_PS1_DEV_2       *MeasureInternalTo_PS1_DEV_2 (Measure *in, int Nvalues);
    7 SecFilt                 *SecFilt_PS1_DEV_2_ToInternal (SecFilt_PS1_DEV_2 *in, int Nvalues);
    8 SecFilt_PS1_DEV_2       *SecFiltInternalTo_PS1_DEV_2 (SecFilt *in, int Nvalues);
     1Image                   *Image_PS1_DEV_2_ToInternal (Image_PS1_DEV_2 *in, off_t Nvalues);
     2Image_PS1_DEV_2         *ImageInternalTo_PS1_DEV_2 (Image *in, off_t Nvalues);
     3Average                 *Average_PS1_DEV_2_ToInternal (Average_PS1_DEV_2 *in, off_t Nvalues, SecFilt **primary);
     4Average_PS1_DEV_2       *AverageInternalTo_PS1_DEV_2 (Average *in, off_t Nvalues, SecFilt *primary);
     5Measure                 *Measure_PS1_DEV_2_ToInternal (Measure_PS1_DEV_2 *in, off_t Nvalues);
     6Measure_PS1_DEV_2       *MeasureInternalTo_PS1_DEV_2 (Measure *in, off_t Nvalues);
     7SecFilt                 *SecFilt_PS1_DEV_2_ToInternal (SecFilt_PS1_DEV_2 *in, off_t Nvalues);
     8SecFilt_PS1_DEV_2       *SecFiltInternalTo_PS1_DEV_2 (SecFilt *in, off_t Nvalues);
    99
    10 PhotCode *PhotCode_PS1_DEV_2_To_Internal (PhotCode_PS1_DEV_2 *in, int Nvalues);
    11 PhotCode_PS1_DEV_2 *PhotCode_Internal_To_PS1_DEV_2 (PhotCode *in, int Nvalues);
     10PhotCode *PhotCode_PS1_DEV_2_To_Internal (PhotCode_PS1_DEV_2 *in, off_t Nvalues);
     11PhotCode_PS1_DEV_2 *PhotCode_Internal_To_PS1_DEV_2 (PhotCode *in, off_t Nvalues);

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

    r20936 r27435  
    1 Image                   *Image_PS1_DEV_3_ToInternal (Image_PS1_DEV_3 *in, int Nvalues);
    2 Image_PS1_DEV_3         *ImageInternalTo_PS1_DEV_3 (Image *in, int Nvalues);
     1Image                   *Image_PS1_DEV_3_ToInternal (Image_PS1_DEV_3 *in, off_t Nvalues);
     2Image_PS1_DEV_3         *ImageInternalTo_PS1_DEV_3 (Image *in, off_t Nvalues);
    33
    4 PhotCode *PhotCode_PS1_DEV_3_To_Internal (PhotCode_PS1_DEV_3 *in, int Nvalues);
    5 PhotCode_PS1_DEV_3 *PhotCode_Internal_To_PS1_DEV_3 (PhotCode *in, int Nvalues);
     4PhotCode *PhotCode_PS1_DEV_3_To_Internal (PhotCode_PS1_DEV_3 *in, off_t Nvalues);
     5PhotCode_PS1_DEV_3 *PhotCode_Internal_To_PS1_DEV_3 (PhotCode *in, off_t Nvalues);

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

    r24748 r27435  
    1 Image                   *Image_PS1_REF_ToInternal (Image_PS1_REF *in, int Nvalues);
    2 Image_PS1_REF           *ImageInternalTo_PS1_REF (Image *in, int Nvalues);
    3 Average                 *Average_PS1_REF_ToInternal (Average_PS1_REF *in, int Nvalues, SecFilt **primary);
    4 Average_PS1_REF          *AverageInternalTo_PS1_REF (Average *in, int Nvalues, SecFilt *primary);
    5 Measure                 *Measure_PS1_REF_ToInternal (Measure_PS1_REF *in, int Nvalues);
    6 Measure_PS1_REF          *MeasureInternalTo_PS1_REF (Measure *in, int Nvalues);
    7 SecFilt                 *SecFilt_PS1_REF_ToInternal (SecFilt_PS1_REF *in, int Nvalues);
    8 SecFilt_PS1_REF          *SecFiltInternalTo_PS1_REF (SecFilt *in, int Nvalues);
     1Image                   *Image_PS1_REF_ToInternal (Image_PS1_REF *in, off_t Nvalues);
     2Image_PS1_REF           *ImageInternalTo_PS1_REF (Image *in, off_t Nvalues);
     3Average                 *Average_PS1_REF_ToInternal (Average_PS1_REF *in, off_t Nvalues, SecFilt **primary);
     4Average_PS1_REF          *AverageInternalTo_PS1_REF (Average *in, off_t Nvalues, SecFilt *primary);
     5Measure                 *Measure_PS1_REF_ToInternal (Measure_PS1_REF *in, off_t Nvalues);
     6Measure_PS1_REF          *MeasureInternalTo_PS1_REF (Measure *in, off_t Nvalues);
     7SecFilt                 *SecFilt_PS1_REF_ToInternal (SecFilt_PS1_REF *in, off_t Nvalues);
     8SecFilt_PS1_REF          *SecFiltInternalTo_PS1_REF (SecFilt *in, off_t Nvalues);
    99
    10 PhotCode                *PhotCode_PS1_REF_To_Internal (PhotCode_PS1_REF *in, int Nvalues);
    11 PhotCode_PS1_REF         *PhotCode_Internal_To_PS1_REF (PhotCode *in, int Nvalues);
     10PhotCode                *PhotCode_PS1_REF_To_Internal (PhotCode_PS1_REF *in, off_t Nvalues);
     11PhotCode_PS1_REF         *PhotCode_Internal_To_PS1_REF (PhotCode *in, off_t Nvalues);

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

    r21508 r27435  
    1 Image                   *Image_PS1_V1_ToInternal (Image_PS1_V1 *in, int Nvalues);
    2 Image_PS1_V1            *ImageInternalTo_PS1_V1 (Image *in, int Nvalues);
    3 Average                 *Average_PS1_V1_ToInternal (Average_PS1_V1 *in, int Nvalues, SecFilt **primary);
    4 Average_PS1_V1          *AverageInternalTo_PS1_V1 (Average *in, int Nvalues, SecFilt *primary);
    5 Measure                 *Measure_PS1_V1_ToInternal (Measure_PS1_V1 *in, int Nvalues);
    6 Measure_PS1_V1          *MeasureInternalTo_PS1_V1 (Measure *in, int Nvalues);
    7 SecFilt                 *SecFilt_PS1_V1_ToInternal (SecFilt_PS1_V1 *in, int Nvalues);
    8 SecFilt_PS1_V1          *SecFiltInternalTo_PS1_V1 (SecFilt *in, int Nvalues);
     1Image                   *Image_PS1_V1_ToInternal (Image_PS1_V1 *in, off_t Nvalues);
     2Image_PS1_V1            *ImageInternalTo_PS1_V1 (Image *in, off_t Nvalues);
     3Average                 *Average_PS1_V1_ToInternal (Average_PS1_V1 *in, off_t Nvalues, SecFilt **primary);
     4Average_PS1_V1          *AverageInternalTo_PS1_V1 (Average *in, off_t Nvalues, SecFilt *primary);
     5Measure                 *Measure_PS1_V1_ToInternal (Measure_PS1_V1 *in, off_t Nvalues);
     6Measure_PS1_V1          *MeasureInternalTo_PS1_V1 (Measure *in, off_t Nvalues);
     7SecFilt                 *SecFilt_PS1_V1_ToInternal (SecFilt_PS1_V1 *in, off_t Nvalues);
     8SecFilt_PS1_V1          *SecFiltInternalTo_PS1_V1 (SecFilt *in, off_t Nvalues);
    99
    10 PhotCode                *PhotCode_PS1_V1_To_Internal (PhotCode_PS1_V1 *in, int Nvalues);
    11 PhotCode_PS1_V1         *PhotCode_Internal_To_PS1_V1 (PhotCode *in, int Nvalues);
     10PhotCode                *PhotCode_PS1_V1_To_Internal (PhotCode_PS1_V1 *in, off_t Nvalues);
     11PhotCode_PS1_V1         *PhotCode_Internal_To_PS1_V1 (PhotCode *in, off_t Nvalues);

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

    r24748 r27435  
    1111  char extname[80];
    1212
    13   int i, code, Ncode, Nsec, Nsecfilt;
     13  int i, code, Nsec, Nsecfilt;
     14  off_t Ncode;
    1415
    1516  /* XXX choose more sensible lock timeouts! */

  • trunk/Ohana/src/libdvo/src/cmf-ps1-v1-alt.c

    r24400 r27435  
    11# include "dvo.h"
    22
    3 CMF_PS1_V2 *gfits_table_get_CMF_PS1_V1_Alt (FTable *ftable, int *Ndata, int *swapped) {
     3CMF_PS1_V2 *gfits_table_get_CMF_PS1_V1_Alt (FTable *ftable, off_t *Ndata, char *swapped) {
    44
    5   int i, nitems;
     5  off_t i, nitems;
    66  unsigned char *byte, *inbyte, *otbyte, tmp;
    77  CMF_PS1_V2 *output;
    … …  
    1313  // this function is a special case : it must have Nx = 136
    1414  if (ftable[0].header[0].Naxis[0] != 136) {
    15     fprintf (stderr, "ERROR: wrong format for CMF_PS1_V1_Alt: %d vs %d\n", ftable[0].header[0].Naxis[0], 136);
     15    fprintf (stderr, "ERROR: wrong format for CMF_PS1_V1_Alt: %lld vs %d\n", (long long) ftable[0].header[0].Naxis[0], 136);
    1616    exit (2);
    1717  }
    … …  
    8383
    8484  free (ftable[0].buffer);
    85   ftable[0].buffer = output;
     85  ftable[0].buffer = (char *) output;
    8686
    8787  // XXX other mods to make ftable consistent with CMF_PS1_V2? (Nx, EXTNAME?)

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

    r27025 r27435  
    307307  int i;
    308308  double Ro, Xo, Yo;
    309   double dX, dY, X, Y, Lo, Mo, dL, dM;
     309  double dX, dY, Lo, Mo, dL, dM;
    310310  double dLdX, dLdY, dMdX, dMdY, Do;
    311311

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

    r26398 r27435  
    141141  if (catalog[0].f == NULL)   return (DVO_CAT_OPEN_FAIL);
    142142
    143   fseek (catalog[0].f, 0, SEEK_SET);
     143  fseeko (catalog[0].f, 0, SEEK_SET);
    144144  return (DVO_CAT_OPEN_OK);
    145145}
    … …  
    253253  }
    254254  // check if the table has been sorted or not
    255   status = gfits_scan (&catalog[0].header, "SORTED", "%t", 1, &catalog[0].sorted);
     255  status = gfits_scan_alt (&catalog[0].header, "SORTED", "%t", 1, &catalog[0].sorted);
    256256  if (!status) catalog[0].sorted = TRUE;
    257257
    … …  
    302302
    303303  // set the 'sorted' header keyword
    304   gfits_modify (&catalog[0].header, "SORTED",  "%t", 1, catalog[0].sorted);
     304  gfits_modify_alt (&catalog[0].header, "SORTED",  "%t", 1, catalog[0].sorted);
    305305
    306306  // XXX handle return status
    … …  
    327327
    328328  // set the 'sorted' header keyword
    329   gfits_modify (&catalog[0].header, "SORTED",  "%t", 1, catalog[0].sorted);
     329  gfits_modify_alt (&catalog[0].header, "SORTED",  "%t", 1, catalog[0].sorted);
    330330
    331331  // XXX handle return status
    … …  
    353353  // set the 'sorted' header keyword
    354354  catalog[0].sorted = FALSE;
    355   gfits_modify (&catalog[0].header, "SORTED",  "%t", 1, catalog[0].sorted);
     355  gfits_modify_alt (&catalog[0].header, "SORTED",  "%t", 1, catalog[0].sorted);
    356356
    357357  /* update is only valid for catmode SPLIT */
    … …  
    376376int dvo_catalog_check (Catalog *catalog, int Nsecfilt, int extend) {
    377377
    378   int i, j, Nextra, in, out;
     378  off_t in, out, i;
     379  int j, Nextra;
    379380  SecFilt *insec, *outsec;
    380381
    … …  
    409410
    410411void dvo_catalog_free (Catalog *catalog) {
     412
     413  if (catalog[0].catmode == DVO_MODE_SPLIT) {
     414
     415    if (catalog[0].measure_catalog) {
     416      free (catalog[0].measure_catalog[0].filename);
     417      dvo_catalog_free (catalog[0].measure_catalog);
     418      free (catalog[0].measure_catalog);
     419    }
     420    if (catalog[0].missing_catalog) {
     421      free (catalog[0].missing_catalog[0].filename);
     422      dvo_catalog_free (catalog[0].missing_catalog);
     423      free (catalog[0].missing_catalog);
     424    }
     425    if (catalog[0].secfilt_catalog) {
     426      free (catalog[0].secfilt_catalog[0].filename);
     427      dvo_catalog_free (catalog[0].secfilt_catalog);
     428      free (catalog[0].secfilt_catalog);
     429    }
     430  }
    411431  dvo_catalog_free_data (catalog);
     432
    412433  gfits_free_header (&catalog[0].header);
    413434}
    … …  
    444465*/
    445466
    446 int dvo_catalog_load_segment (Catalog *catalog, int VERBOSE, int start, int Nrows) {
     467int dvo_catalog_load_segment (Catalog *catalog, int VERBOSE, off_t start, off_t Nrows) {
    447468
    448469  switch (catalog[0].catmode) {

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

    r20936 r27435  
    2727  }
    2828  gfits_create_header (&catalog[0].header);
    29  
     29
    3030  if (catalog[0].catmode == DVO_MODE_SPLIT) {
    3131    path = pathname (catalog[0].filename);
    … …  
    3939    /* create basic data for measure catalog file */
    4040    gfits_create_header (&catalog[0].measure_catalog[0].header);
     41
    4142    ALLOCATE (catalog[0].measure_catalog[0].filename, char, length);
     43
    4244    sprintf (catalog[0].measure_catalog[0].filename, "%s/%s.cpm", path, root);
    4345    file = filebasename (catalog[0].measure_catalog[0].filename);
    … …  
    8587      exit (2);
    8688    }
    87 
    8889  }   
    8990

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

    r24755 r27435  
    33int dvo_catalog_load_mef (Catalog *catalog, int VERBOSE) {
    44 
    5   int Nitems, Nbytes, Nexpect, Naverage, Nmeasure, Nmissing, Nsecfilt;
     5  int Nsecfilt;
     6  off_t Nitems, Nbytes, Nexpect, Naverage, Nmeasure, Nmissing;
    67  FILE *f;
    78
    … …  
    1516
    1617  /* move pointer past header -- must be already read (load_catalog) */
    17   fseek (f, catalog[0].header.size, SEEK_SET);
     18  fseeko (f, catalog[0].header.datasize, SEEK_SET);
    1819
    1920  /* matrix should be empty */
    … …  
    2324  }
    2425  /* get the components from the header */
    25   if (!gfits_scan (&catalog[0].header, "NSTARS",   "%d", 1, &Naverage)) return (FALSE);
    26   if (!gfits_scan (&catalog[0].header, "NMEAS",    "%d", 1, &Nmeasure)) return (FALSE);
    27   if (!gfits_scan (&catalog[0].header, "NMISS",    "%d", 1, &Nmissing)) return (FALSE);
    28   if (!gfits_scan (&catalog[0].header, "NSECFILT", "%d", 1, &Nsecfilt)) Nsecfilt = 0;
     26  if (!gfits_scan (&catalog[0].header, "NSTARS",   "%lld", 1, (long long *) &Naverage)) return (FALSE);
     27  if (!gfits_scan (&catalog[0].header, "NMEAS",    "%lld", 1, (long long *) &Nmeasure)) return (FALSE);
     28  if (!gfits_scan (&catalog[0].header, "NMISS",    "%lld", 1, (long long *) &Nmissing)) return (FALSE);
     29  if (!gfits_scan (&catalog[0].header, "NSECFILT", "%d",   1,              &Nsecfilt)) Nsecfilt = 0;
    2930
    3031  /* the OBJID is a counter that uniquely defines an average entry and never changes.  if
    … …  
    7273    catalog[0].average = FtableToAverage (&ftable, &Naverage, &catalog[0].catformat, &primary);
    7374    if (Naverage != catalog[0].Naves_disk) {
    74       fprintf (stderr, "Warning: mismatch between Naverage in PHU and Table headers (%d vs %d)\n", Naverage, catalog[0].Naves_disk);
     75      fprintf (stderr, "Warning: mismatch between Naverage in PHU and Table headers (%lld vs %lld)\n", (long long) Naverage, (long long) catalog[0].Naves_disk);
    7576    }
    7677    catalog[0].Naverage = catalog[0].Naves_disk;
    … …  
    7879  } else {
    7980    Nbytes = gfits_data_size (&header);
    80     fseek (f, Nbytes, SEEK_CUR);
     81    fseeko (f, Nbytes, SEEK_CUR);
    8182    ALLOCATE (catalog[0].average, Average, 1);
    8283    catalog[0].Naverage = 0;
    … …  
    99100    catalog[0].measure = FtableToMeasure (&ftable, &catalog[0].Nmeasure, &catalog[0].catformat);
    100101    if (Nmeasure != catalog[0].Nmeas_disk) {
    101       fprintf (stderr, "Warning: mismatch between Nmeasure in PHU and Table headers (%d vs %d)\n", Nmeasure, catalog[0].Nmeas_disk);
     102      fprintf (stderr, "Warning: mismatch between Nmeasure in PHU and Table headers (%lld vs %lld)\n", (long long) Nmeasure, (long long) catalog[0].Nmeas_disk);
    102103    }
    103104    catalog[0].Nmeasure = catalog[0].Nmeas_disk;
    … …  
    105106  } else {
    106107    Nbytes = gfits_data_size (&header);
    107     fseek (f, Nbytes, SEEK_CUR);
     108    fseeko (f, Nbytes, SEEK_CUR);
    108109    ALLOCATE (catalog[0].measure, Measure, 1);
    109110    catalog[0].Nmeasure = 0;
    … …  
    125126    catalog[0].missing = gfits_table_get_Missing (&ftable, &catalog[0].Nmissing, NULL);
    126127    if (Nmissing != catalog[0].Nmiss_disk) {
    127       fprintf (stderr, "Warning: mismatch between Nmissing in PHU and Table headers (%d vs %d)\n", Nmissing, catalog[0].Nmiss_disk);
     128      fprintf (stderr, "Warning: mismatch between Nmissing in PHU and Table headers (%lld vs %lld)\n", (long long) Nmissing, (long long) catalog[0].Nmiss_disk);
    128129    }
    129130    catalog[0].Nmissing = catalog[0].Nmiss_disk;
    … …  
    131132  } else {
    132133    Nbytes = gfits_data_size (&header);
    133     fseek (f, Nbytes, SEEK_CUR);
     134    fseeko (f, Nbytes, SEEK_CUR);
    134135    ALLOCATE (catalog[0].missing, Missing, 1);
    135136    catalog[0].Nmissing = 0;
    … …  
    153154    catalog[0].secfilt = FtableToSecFilt (&ftable, &Nitems, &catalog[0].catformat);
    154155    if (Nexpect != Nitems) {
    155       fprintf (stderr, "Warning: mismatch between Nsecfilt items in PHU and Table headers (%d vs %d)\n", Nexpect, Nitems);
     156      fprintf (stderr, "Warning: mismatch between Nsecfilt items in PHU and Table headers (%lld vs %lld)\n", (long long) Nexpect, (long long) Nitems);
    156157    }
    157158
    … …  
    159160       we need to interleave these magnitudes with the secfilt entries just loaded */
    160161    if (primary != NULL) {
    161       int Ntmpfilt, Ntotal, i, j;
     162      off_t Ntmpfilt, Ntotal, i, j;
    162163      SecFilt *tmpfilt;
    163164      tmpfilt  = catalog[0].secfilt;
    … …  
    182183    /* no real need to skip the data array here... */
    183184    Nbytes = gfits_data_size (&header);
    184     fseek (f, Nbytes, SEEK_CUR);
     185    fseeko (f, Nbytes, SEEK_CUR);
    185186    if (primary != NULL) {
    186187      free (primary);
    … …  
    200201int dvo_catalog_save_mef (Catalog *catalog, char VERBOSE) {
    201202
    202   int Nitems;
     203  off_t Nitems;
    203204  FILE *f;
    204205  Matrix matrix;
    … …  
    207208  SecFilt *primary;
    208209  SecFilt *secfilt;
    209   int i, j, Nsecfilt, Nallfilt, Ntotal;
     210  off_t i, j, Nallfilt, Ntotal;
     211  int Nsecfilt;
    210212
    211213  if (catalog[0].Naverage == 0) {
    … …  
    236238
    237239  /* make sure header is consistent with data */
    238   gfits_modify (&catalog[0].header, "NSTARS",   "%d", 1, catalog[0].Naverage);
    239   gfits_modify (&catalog[0].header, "NMEAS",    "%d", 1, catalog[0].Nmeasure);
    240   gfits_modify (&catalog[0].header, "NMISS",    "%d", 1, catalog[0].Nmissing);
    241   gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
    242   gfits_modify (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
     240  gfits_modify (&catalog[0].header, "NSTARS",   "%lld", 1, (long long) catalog[0].Naverage);
     241  gfits_modify (&catalog[0].header, "NMEAS",    "%lld", 1, (long long) catalog[0].Nmeasure);
     242  gfits_modify (&catalog[0].header, "NMISS",    "%lld", 1, (long long) catalog[0].Nmissing);
     243  gfits_modify (&catalog[0].header, "NSECFILT", "%d",   1,                        Nsecfilt);
     244  gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
    243245  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    244246
    245247  f = catalog[0].f;
    246248  /* rewind file pointers and truncate */
    247   fseek (f, 0, SEEK_SET);
     249  fseeko (f, 0LL, SEEK_SET);
    248250  ftruncate (fileno (catalog[0].f), 0);
    249251  ftable.header = &header;

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

    r24748 r27435  
    55int dvo_catalog_load_raw (Catalog *catalog, int VERBOSE) {
    66 
    7   int Nitems, nitems;
    8   int i, Nmeas, Nmiss, size;
    9   int NewMeasure, Nskip;
    10   int AverageSize, MeasureSize, MissingSize, SecFiltSize;
     7  off_t Nitems, nitems;
     8  off_t i, Nmeas, Nmiss, size;
     9  off_t NewMeasure, Nskip;
     10  off_t AverageSize, MeasureSize, MissingSize, SecFiltSize;
    1111  FILE *f;
    1212  struct stat filestatus;
    … …  
    1717
    1818  /* move pointer past header -- must be already read (load_catalog) */
    19   fseek (f, catalog[0].header.size, SEEK_SET);
     19  fseeko (f, catalog[0].header.datasize, SEEK_SET);
    2020
    2121  /* get the components from the header */
    2222  catalog[0].Naverage = catalog[0].Nmeasure = catalog[0].Nmissing = catalog[0].Nsecfilt = 0;
    23   if (!gfits_scan (&catalog[0].header, "NSTARS",   "%d", 1, &catalog[0].Naverage)) return (FALSE);
    24   if (!gfits_scan (&catalog[0].header, "NMEAS",    "%d", 1, &catalog[0].Nmeasure)) return (FALSE);
    25   if (!gfits_scan (&catalog[0].header, "NMISS",    "%d", 1, &catalog[0].Nmissing)) return (FALSE);
    26   if (!gfits_scan (&catalog[0].header, "NSECFILT", "%d", 1, &catalog[0].Nsecfilt)) catalog[0].Nsecfilt = 0;
     23  if (!gfits_scan (&catalog[0].header, "NSTARS",   "%lld", 1, (long long *) &catalog[0].Naverage)) return (FALSE);
     24  if (!gfits_scan (&catalog[0].header, "NMEAS",    "%lld", 1, (long long *) &catalog[0].Nmeasure)) return (FALSE);
     25  if (!gfits_scan (&catalog[0].header, "NMISS",    "%lld", 1, (long long *) &catalog[0].Nmissing)) return (FALSE);
     26  if (!gfits_scan (&catalog[0].header, "NSECFILT", "%d",   1,              &catalog[0].Nsecfilt)) catalog[0].Nsecfilt = 0;
    2727
    2828  /* the OBJID is a counter that uniquely defines an average entry and never changes.  if
    … …  
    4545  }
    4646  /* special cases: old versions of the DB tables which were poorly identified */
    47   if (gfits_scan (&catalog[0].header, "NEWMEAS",  "%t", 1, &NewMeasure)) {
     47  if (gfits_scan_alt (&catalog[0].header, "NEWMEAS",  "%t", 1, &NewMeasure)) {
    4848    catalog[0].catformat = DVO_FORMAT_ELIXIR; // special case for ELIXIR
    4949    goto got_format;
    … …  
    9898
    9999  /* predicted file size - for double checking data validity */
    100   size = catalog[0].header.size;
     100  size = catalog[0].header.datasize;
    101101  size += AverageSize * catalog[0].Naverage;
    102102  size += MeasureSize * catalog[0].Nmeasure;
    … …  
    112112    if (VERBOSE) {
    113113      fprintf (stderr, "star catalog has inconsistent size\n");
    114       fprintf (stderr, "average: %d = %d bytes\n", catalog[0].Naverage, catalog[0].Naverage*AverageSize);
    115       fprintf (stderr, "measure: %d = %d bytes\n", catalog[0].Nmeasure, catalog[0].Nmeasure*MeasureSize);
    116       fprintf (stderr, "missing: %d = %d bytes\n", catalog[0].Nmissing, catalog[0].Nmissing*MissingSize);
    117       fprintf (stderr, "secfilt: %d = %d bytes\n", catalog[0].Nsecfilt, catalog[0].Nsecfilt*SecFiltSize*catalog[0].Naverage);
    118       fprintf (stderr, "expect: %d, found: %d\n", size, (int)filestatus.st_size);
     114      fprintf (stderr, "average: %lld = %lld bytes\n", (long long) catalog[0].Naverage, (long long) catalog[0].Naverage*AverageSize);
     115      fprintf (stderr, "measure: %lld = %lld bytes\n", (long long) catalog[0].Nmeasure, (long long) catalog[0].Nmeasure*MeasureSize);
     116      fprintf (stderr, "missing: %lld = %lld bytes\n", (long long) catalog[0].Nmissing, (long long) catalog[0].Nmissing*MissingSize);
     117      fprintf (stderr, "secfilt: %lld = %lld bytes\n", (long long) catalog[0].Nsecfilt, (long long) catalog[0].Nsecfilt*SecFiltSize*catalog[0].Naverage);
     118      fprintf (stderr, "expect: %lld, found: %lld\n", (long long) size, (long long) filestatus.st_size);
    119119    }
    120120    return (FALSE);
    … …  
    136136    /* skip over averages */
    137137    Nskip = catalog[0].Naverage * AverageSize;
    138     fseek (f, Nskip, SEEK_CUR);
     138    fseeko (f, Nskip, SEEK_CUR);
    139139  }   
    140140 
    … …  
    145145    /* skip over measures */
    146146    Nskip = catalog[0].Nmeasure * MeasureSize;
    147     fseek (f, Nskip, SEEK_CUR);
     147    fseeko (f, Nskip, SEEK_CUR);
    148148  }   
    149149
    … …  
    154154    nitems = fread (catalog[0].missing, MissingSize, Nitems, f);
    155155    if (nitems != Nitems) {
    156       if (VERBOSE) fprintf (stderr, "failed to read missing from catalog file %s (%d vs %d)\n", catalog[0].filename, nitems, Nitems);
     156      if (VERBOSE) fprintf (stderr, "failed to read missing from catalog file %s (%lld vs %lld)\n", catalog[0].filename, (long long) nitems, (long long) Nitems);
    157157      return (FALSE);
    158158    }
    … …  
    161161    /* skip over missings */
    162162    Nskip = catalog[0].Nmissing * MissingSize;
    163     fseek (f, Nskip, SEEK_CUR);
     163    fseeko (f, Nskip, SEEK_CUR);
    164164  }
    165165 
    … …  
    172172       we need to interleave these magnitudes with the secfilt entries just loaded */
    173173    if (primary != NULL) {
    174       int Ntmpfilt, Nsecfilt, Ntotal, i, j;
     174      off_t Ntmpfilt, Nsecfilt, Ntotal, i, j;
    175175      SecFilt *tmpfilt;
    176176      tmpfilt  = catalog[0].secfilt;
    … …  
    193193    /* skip over secfilts */
    194194    Nskip = catalog[0].Nsecfilt * catalog[0].Naverage * SecFiltSize;
    195     fseek (f, Nskip, SEEK_CUR);
     195    fseeko (f, Nskip, SEEK_CUR);
    196196    if (primary != NULL) free (primary);
    197197  }
    198198
    199   if (VERBOSE) fprintf (stderr, "read %d stars from catalog file %s (%d measurements, %d missing, %d secondary filters)\n",
    200                         catalog[0].Naverage, catalog[0].filename, catalog[0].Nmeasure, catalog[0].Nmissing, catalog[0].Nsecfilt);
     199  if (VERBOSE) fprintf (stderr, "read %lld stars from catalog file %s (%lld measurements, %lld missing, %lld secondary filters)\n",
     200                        (long long) catalog[0].Naverage,
     201                        catalog[0].filename,
     202                        (long long) catalog[0].Nmeasure,
     203                        (long long) catalog[0].Nmissing,
     204                        (long long) catalog[0].Nsecfilt);
    201205
    202206  /* check data integrity */
    … …  
    209213      if (VERBOSE) {
    210214        fprintf (stderr, "****** data in catalog %s is corrupt, sums don't check\n", catalog[0].filename);
    211         fprintf (stderr, "****** Nmeas: %d, %d\n", Nmeas, catalog[0].Nmeasure);
    212         fprintf (stderr, "****** Nmiss: %d, %d\n", Nmiss, catalog[0].Nmissing);
     215        fprintf (stderr, "****** Nmeas: %lld, %lld\n", (long long) Nmeas, (long long) catalog[0].Nmeasure);
     216        fprintf (stderr, "****** Nmiss: %lld, %lld\n", (long long) Nmiss, (long long) catalog[0].Nmissing);
    213217      }
    214218      return (FALSE);
    … …  
    226230int dvo_catalog_save_raw (Catalog *catalog, char VERBOSE) {
    227231
    228   int Nitems, nitems;
     232  off_t Nitems, nitems;
    229233  FILE *f;
    230234  SecFilt *primary;
    231235  SecFilt *secfilt;
    232   int i, j, Nsecfilt, Nallfilt, Ntotal;
     236  off_t i, j, Nsecfilt, Nallfilt, Ntotal;
    233237
    234238  if (catalog[0].Naverage == 0) {
    … …  
    259263
    260264  /* make sure header is consistent with data */
    261   gfits_modify (&catalog[0].header, "NSTARS",   "%d", 1, catalog[0].Naverage);
    262   gfits_modify (&catalog[0].header, "NMEAS",    "%d", 1, catalog[0].Nmeasure);
    263   gfits_modify (&catalog[0].header, "NMISS",    "%d", 1, catalog[0].Nmissing);
    264   gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, catalog[0].Nsecfilt);
     265  gfits_modify (&catalog[0].header, "NSTARS",   "%lld", 1, (long long) catalog[0].Naverage);
     266  gfits_modify (&catalog[0].header, "NMEAS",    "%lld", 1, (long long) catalog[0].Nmeasure);
     267  gfits_modify (&catalog[0].header, "NMISS",    "%lld", 1, (long long) catalog[0].Nmissing);
     268  gfits_modify (&catalog[0].header, "NSECFILT", "%lld", 1, (long long) catalog[0].Nsecfilt);
    265269  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    266270
    … …  
    278282  /* rewind file pointers and truncate file */
    279283  f = catalog[0].f;
    280   fseek (f, 0, SEEK_SET);
     284  fseeko (f, 0, SEEK_SET);
    281285  ftruncate (fileno (catalog[0].f), 0);
    282286
    283287  /* write header data (use gfits_write_header?) */
    284   nitems = fwrite (catalog[0].header.buffer, 1, catalog[0].header.size, f);
    285   if (nitems != catalog[0].header.size) {
     288  nitems = fwrite (catalog[0].header.buffer, 1, catalog[0].header.datasize, f);
     289  if (nitems != catalog[0].header.datasize) {
    286290    if (VERBOSE) fprintf (stderr, "failed to write header\n");
    287291    goto failure;
    … …  
    330334   in these cases, save these values in primary; otherwise set primary to NULL */
    331335
    332 Average *ReadRawAverage (FILE *f, int Naverage, int format, SecFilt **primary) {
     336Average *ReadRawAverage (FILE *f, off_t Naverage, char format, SecFilt **primary) {
    333337
    334338  Average *average;
    … …  
    339343# define FORMAT_CASE(NAME,TYPE) \
    340344    case DVO_FORMAT_##NAME: { \
    341       int nitems; \
     345      off_t nitems; \
    342346      Average_##TYPE *tmpAverage; \
    343347      ALLOCATE (tmpAverage, Average_##TYPE, MAX (Naverage, 1)); \
    344348      nitems = fread (tmpAverage, sizeof(Average_##TYPE), Naverage, f); \
    345349      if (nitems != Naverage) { \
    346         fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage); \
     350        fprintf (stderr, "failed to read averages (%lld vs %lld)\n", (long long) nitems, (long long) Naverage); \
    347351        return (NULL); \
    348352      } \
    … …  
    354358  switch (format) {
    355359    case DVO_FORMAT_INTERNAL: {
    356       int nitems;
     360      off_t nitems;
    357361      ALLOCATE (average, Average, MAX (Naverage, 1));
    358362      nitems = fread (average, sizeof(Average), Naverage, f);
    359363      if (nitems != Naverage) {
    360         fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
     364        fprintf (stderr, "failed to read averages (%lld vs %lld)\n", (long long) nitems, (long long) Naverage);
    361365        return (NULL);
    362366      }
    … …  
    384388/* accepts and converts internal average formats and outputs
    385389   raw data in the specified format */
    386 int WriteRawAverage (FILE *f, Average *average, int Naverage, int format, SecFilt *primary) {
     390int WriteRawAverage (FILE *f, Average *average, off_t Naverage, char format, SecFilt *primary) {
    387391
    388392// this macro generates the case statements for each type
    389393# define FORMAT_CASE(NAME,TYPE) \
    390394    case DVO_FORMAT_##NAME: { \
    391       int nitems; \
     395      off_t nitems; \
    392396      Average_##TYPE *tmpAverage; \
    393397      tmpAverage = AverageInternalTo_##TYPE (average, Naverage, primary); \
    … …  
    396400      free (tmpAverage); \
    397401      if (nitems != Naverage) { \
    398         fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage); \
     402        fprintf (stderr, "failed to write averages (%lld vs %lld)\n", (long long) nitems, (long long) Naverage); \
    399403        return (FALSE); \
    400404      } \
    … …  
    403407  switch (format) {
    404408    case DVO_FORMAT_INTERNAL: {
    405       int nitems;
     409      off_t nitems;
    406410      gfits_convert_Average (average, sizeof(Average), Naverage);
    407411      nitems = fwrite (average, sizeof(Average), Naverage, f);
    408412      if (nitems != Naverage) {
    409         fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
     413        fprintf (stderr, "failed to write averages (%lld vs %lld)\n", (long long) nitems, (long long) Naverage);
    410414        return (FALSE);
    411415      }
    … …  
    432436/** Average / Raw Table conversions **/
    433437
    434 Measure *ReadRawMeasure (FILE *f, int Nmeasure, int format) {
     438Measure *ReadRawMeasure (FILE *f, off_t Nmeasure, char format) {
    435439
    436440  Measure *measure;
    … …  
    439443# define FORMAT_CASE(NAME,TYPE) \
    440444    case DVO_FORMAT_##NAME: { \
    441       int nitems; \
     445      off_t nitems; \
    442446      Measure_##TYPE *tmpMeasure; \
    443447      ALLOCATE (tmpMeasure, Measure_##TYPE, MAX (Nmeasure, 1)); \
    444448      nitems = fread (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure, f); \
    445449      if (nitems != Nmeasure) { \
    446         fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure); \
     450        fprintf (stderr, "failed to read measures (%lld vs %lld)\n", (long long) nitems, (long long) Nmeasure); \
    447451        return (NULL); \
    448452      } \
    … …  
    454458  switch (format) {
    455459    case DVO_FORMAT_INTERNAL: {
    456       int nitems;
     460      off_t nitems;
    457461      ALLOCATE (measure, Measure, MAX (Nmeasure, 1));
    458462      nitems = fread (measure, sizeof(Measure), Nmeasure, f);
    459463      if (nitems != Nmeasure) {
    460         fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
     464        fprintf (stderr, "failed to read measures (%lld vs %lld)\n", (long long) nitems, (long long) Nmeasure);
    461465        return (NULL);
    462466      }
    … …  
    484488/* accepts and converts internal measure formats and outputs
    485489   raw data in the specified format */
    486 int WriteRawMeasure (FILE *f, Measure *measure, int Nmeasure, int format) {
     490int WriteRawMeasure (FILE *f, Measure *measure, off_t Nmeasure, char format) {
    487491
    488492// this macro generates the case statements for each type
    489493# define FORMAT_CASE(NAME,TYPE) \
    490494    case DVO_FORMAT_##NAME: { \
    491       int nitems; \
     495      off_t nitems; \
    492496      Measure_##TYPE *tmpMeasure; \
    493497      tmpMeasure = MeasureInternalTo_##TYPE (measure, Nmeasure); \
    … …  
    496500      free (tmpMeasure); \
    497501      if (nitems != Nmeasure) { \
    498         fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure); \
     502        fprintf (stderr, "failed to write measures (%lld vs %lld)\n", (long long) nitems, (long long) Nmeasure); \
    499503        return (FALSE); \
    500504      } \
    … …  
    503507  switch (format) {
    504508    case DVO_FORMAT_INTERNAL: {
    505       int nitems;
     509      off_t nitems;
    506510      gfits_convert_Measure (measure, sizeof(Measure), Nmeasure);
    507511      nitems = fwrite (measure, sizeof(Measure), Nmeasure, f);
    508512      if (nitems != Nmeasure) {
    509         fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
     513        fprintf (stderr, "failed to write measures (%lld vs %lld)\n", (long long) nitems, (long long) Nmeasure);
    510514        return (FALSE);
    511515      }
    … …  
    532536/** SecFilt / Raw Table conversions **/
    533537
    534 SecFilt *ReadRawSecFilt (FILE *f, int Nsecfilt, int format) {
     538SecFilt *ReadRawSecFilt (FILE *f, off_t Nsecfilt, char format) {
    535539
    536540  SecFilt *secfilt;
    … …  
    539543# define FORMAT_CASE(NAME,TYPE) \
    540544    case DVO_FORMAT_##NAME: { \
    541       int nitems; \
     545      off_t nitems; \
    542546      SecFilt_##TYPE *tmpSecFilt; \
    543547      ALLOCATE (tmpSecFilt, SecFilt_##TYPE, MAX (Nsecfilt, 1)); \
    544548      nitems = fread (tmpSecFilt, sizeof(SecFilt_##TYPE), Nsecfilt, f); \
    545549      if (nitems != Nsecfilt) { \
    546         fprintf (stderr, "failed to read secfilts (%d vs %d)\n", nitems, Nsecfilt); \
     550        fprintf (stderr, "failed to read secfilts (%lld vs %lld)\n", (long long) nitems, (long long) Nsecfilt); \
    547551        return (NULL); \
    548552      } \
    … …  
    554558  switch (format) {
    555559    case DVO_FORMAT_INTERNAL: {
    556       int nitems;
     560      off_t nitems;
    557561      ALLOCATE (secfilt, SecFilt, MAX (Nsecfilt, 1));
    558562      nitems = fread (secfilt, sizeof(SecFilt), Nsecfilt, f);
    559563      if (nitems != Nsecfilt) {
    560         fprintf (stderr, "failed to read secfilts (%d vs %d)\n", nitems, Nsecfilt);
     564        fprintf (stderr, "failed to read secfilts (%lld vs %lld)\n", (long long) nitems, (long long) Nsecfilt);
    561565        return (NULL);
    562566      }
    … …  
    584588/* accepts and converts internal secfilt formats and outputs
    585589   raw data in the specified format */
    586 int WriteRawSecFilt (FILE *f, SecFilt *secfilt, int Nsecfilt, int format) {
     590int WriteRawSecFilt (FILE *f, SecFilt *secfilt, off_t Nsecfilt, char format) {
    587591
    588592// this macro generates the case statements for each type
    589593# define FORMAT_CASE(NAME,TYPE) \
    590594    case DVO_FORMAT_##NAME: { \
    591       int nitems; \
     595      off_t nitems; \
    592596      SecFilt_##TYPE *tmpSecFilt; \
    593597      tmpSecFilt = SecFiltInternalTo_##TYPE (secfilt, Nsecfilt); \
    … …  
    596600      free (tmpSecFilt); \
    597601      if (nitems != Nsecfilt) { \
    598         fprintf (stderr, "failed to write secfilts (%d vs %d)\n", nitems, Nsecfilt); \
     602        fprintf (stderr, "failed to write secfilts (%lld vs %lld)\n", (long long) nitems, (long long) Nsecfilt); \
    599603        return (FALSE); \
    600604      } \
    … …  
    603607  switch (format) {
    604608    case DVO_FORMAT_INTERNAL: {
    605       int nitems;
     609      off_t nitems;
    606610      gfits_convert_SecFilt (secfilt, sizeof(SecFilt), Nsecfilt);
    607611      nitems = fwrite (secfilt, sizeof(SecFilt), Nsecfilt, f);
    608612      if (nitems != Nsecfilt) {
    609         fprintf (stderr, "failed to write secfilts (%d vs %d)\n", nitems, Nsecfilt);
     613        fprintf (stderr, "failed to write secfilts (%lld vs %lld)\n", (long long) nitems, (long long) Nsecfilt);
    610614        return (FALSE);
    611615      }

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

    r20982 r27435  
    88int dvo_catalog_secfilt_to_primary (Catalog *catalog, SecFilt **myPrimary, SecFilt **mySecfilt, int *myNsecfilt) {
    99
    10   int i, j, Nallfilt, Nsecfilt, Ntotal;
     10  off_t i, j, Nallfilt, Nsecfilt, Ntotal;
    1111
    1212  SecFilt *primary;
    … …  
    4343}
    4444
    45 int dvo_catalog_primary_to_secfilt (Catalog *catalog, SecFilt *primary, int Naves) {
    46 
    47   int Ntmpfilt, Nsecfilt, Ntotal, i, j;
     45int dvo_catalog_primary_to_secfilt (Catalog *catalog, SecFilt *primary, off_t Naves) {
     46
     47  off_t Ntmpfilt, Nsecfilt, Ntotal, i, j;
    4848  SecFilt *tmpfilt;
    4949
    … …  
    7171}
    7272
    73 int dvo_catalog_save_subcat (Catalog *catalog, FTable *ftable, int start, int Nrows, int Ndisk, int Ntotal) {
     73int dvo_catalog_save_subcat (Catalog *catalog, FTable *ftable, off_t start, off_t Nrows, off_t Ndisk, off_t Ntotal) {
    7474
    7575  Matrix matrix;
    7676
    7777  /* rewind file pointers and truncate (file is still open) */
    78   fseek (catalog->f, 0, SEEK_SET);
     78  fseeko (catalog->f, 0LL, SEEK_SET);
    7979
    8080  // write PHU header
    … …  
    103103int dvo_catalog_open_subcat (Catalog *catalog, Catalog **Subcat, Header *header, char *name, int VERBOSE) {
    104104
    105   int Nskip, status;
     105  off_t Nskip;
     106  int status;
    106107  char *path, string[80];
    107108  Catalog *subcat;
    … …  
    145146  }
    146147  Nskip = gfits_data_size (&subcat[0].header);
    147   fseek (subcat[0].f, Nskip, SEEK_CUR);
     148  fseeko (subcat[0].f, Nskip, SEEK_CUR);
    148149
    149150  /* read Measure table header */
    … …  
    158159int dvo_catalog_load_split (Catalog *catalog, int VERBOSE) {
    159160
    160   int Nbytes, Nitems, Naverage, Nmeasure, Nmissing, Nsecfilt, status;
     161  off_t Nbytes;
     162  off_t Naverage, Nmeasure, Nmissing;
     163  off_t Nitems;
     164  int status, Nsecfilt;
    161165  Header header;
    162166  FTable ftable;
    … …  
    170174
    171175  /* get the components from the header - these duplicate information in the split files (NAXIS2) */
    172   if (!gfits_scan (&catalog[0].header, "NSTARS",   "%d", 1, &Naverage)) return (FALSE);
    173   if (!gfits_scan (&catalog[0].header, "NMEAS",    "%d", 1, &Nmeasure)) return (FALSE);
    174   if (!gfits_scan (&catalog[0].header, "NMISS",    "%d", 1, &Nmissing)) return (FALSE);
    175   if (!gfits_scan (&catalog[0].header, "NSECFILT", "%d", 1, &Nsecfilt)) Nsecfilt = 0;
     176  if (!gfits_scan (&catalog[0].header, "NSTARS",   "%lld", 1, (long long *) &Naverage)) return (FALSE);
     177  if (!gfits_scan (&catalog[0].header, "NMEAS",    "%lld", 1, (long long *) &Nmeasure)) return (FALSE);
     178  if (!gfits_scan (&catalog[0].header, "NMISS",    "%lld", 1, (long long *) &Nmissing)) return (FALSE);
     179  if (!gfits_scan (&catalog[0].header, "NSECFILT", "%d",   1,              &Nsecfilt)) Nsecfilt = 0;
    176180
    177181  /* the OBJID is a counter that uniquely defines an average entry and never changes.  if
    178182     it is not defined for a legacy database, we can generate them using the existing index values.
    179183     If it is missing, give a warning and recommend the user upgrade the DB */
    180   if (!gfits_scan (&catalog[0].header, "OBJID",    "%d", 1, &catalog[0].objID)) {
     184  if (!gfits_scan (&catalog[0].header, "OBJID",    "%u", 1, &catalog[0].objID)) {
    181185    if (VERBOSE) fprintf (stderr, "WARNING: OBJID is not set for this database: upgrade for full feature set\n");
    182186    catalog[0].objID = 0;
    183187  }
    184   if (!gfits_scan (&catalog[0].header, "CATID",    "%d", 1, &catalog[0].catID)) {
     188  if (!gfits_scan (&catalog[0].header, "CATID",    "%u", 1, &catalog[0].catID)) {
    185189    if (VERBOSE) fprintf (stderr, "WARNING: CATID is not set for this database: upgrade for full feature set\n");
    186190    catalog[0].catID = 0;
    … …  
    206210  if (catalog[0].catflags & LOAD_AVES) {
    207211    /* move pointer past header -- must be already read (load_catalog) */
    208     Nbytes = catalog[0].header.size + gfits_data_size (&catalog[0].header);
    209     fseek (catalog[0].f, Nbytes, SEEK_SET);
     212    Nbytes = catalog[0].header.datasize + gfits_data_size (&catalog[0].header);
     213    fseeko (catalog[0].f, Nbytes, SEEK_SET);
    210214    /* read Average table header */
    211215    if (!gfits_fread_header (catalog[0].f, &header)) {
    … …  
    223227    catalog[0].average = FtableToAverage (&ftable, &Naverage, &catalog[0].catformat, &primary);
    224228    if (Naverage != catalog[0].Naves_disk) {
    225       fprintf (stderr, "Warning: mismatch between Naverage in PHU and Table headers (%d vs %d)\n", Naverage, catalog[0].Naves_disk);
     229      fprintf (stderr, "Warning: mismatch between Naverage in PHU and Table headers (%lld vs %lld)\n", (long long) Naverage, (long long) catalog[0].Naves_disk);
    226230    }
    227231    gfits_free_header (&header);
    … …  
    252256    catalog[0].measure = FtableToMeasure (&ftable, &Nmeasure, &catalog[0].catformat);
    253257    if (Nmeasure != catalog[0].Nmeas_disk) {
    254       fprintf (stderr, "Warning: mismatch between Nmeasure in PHU and Table headers (%d vs %d)\n", Nmeasure, catalog[0].Nmeas_disk);
     258      fprintf (stderr, "Warning: mismatch between Nmeasure in PHU and Table headers (%lld vs %lld)\n", (long long) Nmeasure, (long long) catalog[0].Nmeas_disk);
    255259    }
    256260    catalog[0].Nmeasure = catalog[0].Nmeas_disk;
    … …  
    282286    catalog[0].missing = gfits_table_get_Missing (&ftable, &Nmissing, NULL);
    283287    if (Nmissing != catalog[0].Nmiss_disk) {
    284       fprintf (stderr, "Warning: mismatch between Nmissing in PHU and Table headers (%d vs %d)\n", Nmissing, catalog[0].Nmiss_disk);
     288      fprintf (stderr, "Warning: mismatch between Nmissing in PHU and Table headers (%lld vs %lld)\n", (long long) Nmissing, (long long) catalog[0].Nmiss_disk);
    285289    }
    286290    catalog[0].Nmissing = catalog[0].Nmiss_disk;
    … …  
    311315    catalog[0].secfilt = FtableToSecFilt (&ftable, &Nitems, &catalog[0].catformat);
    312316    if (Nitems != catalog[0].Nsecf_disk) {
    313       fprintf (stderr, "Warning: mismatch between Nsecfilt items in PHU and Table headers (%d vs %d)\n", Nitems, catalog[0].Nsecf_disk);
     317      fprintf (stderr, "Warning: mismatch between Nsecfilt items in PHU and Table headers (%lld vs %lld)\n", (long long) Nitems, (long long) catalog[0].Nsecf_disk);
    314318    }
    315319    catalog[0].Nsecf_mem = catalog[0].Nsecf_disk;
    … …  
    339343// I need to always read both average and secfilt at the same time to correctly manage the
    340344// primary secfilt values...
    341 int dvo_catalog_load_segment_split (Catalog *catalog, int VERBOSE, int start, int Nrows) {
    342 
    343   int Nbytes, Naverage, Nexpect, Nitems, Nmeasure, Nmissing;
     345int dvo_catalog_load_segment_split (Catalog *catalog, int VERBOSE, off_t start, off_t Nrows) {
     346
     347  off_t Nbytes;
     348  off_t Naverage, Nexpect, Nitems, Nmeasure, Nmissing;
    344349  Header header;
    345350  FTable ftable;
    … …  
    357362    /*** load the Average data ***/
    358363    /* move pointer past header and matrix -- must be already read (load_catalog) */
    359     Nbytes = catalog[0].header.size + gfits_data_size (&catalog[0].header);
    360     fseek (catalog[0].f, Nbytes, SEEK_SET);
     364    Nbytes = catalog[0].header.datasize + gfits_data_size (&catalog[0].header);
     365    fseeko (catalog[0].f, Nbytes, SEEK_SET);
    361366    /* read Average table header */
    362367    if (!gfits_fread_header (catalog[0].f, &header)) {
    … …  
    386391
    387392    /* move pointer past header -- must be already read (load_catalog) */
    388     Nbytes = subcat[0].header.size + gfits_data_size (&subcat[0].header);
    389     fseek (subcat[0].f, Nbytes, SEEK_SET);
     393    Nbytes = subcat[0].header.datasize + gfits_data_size (&subcat[0].header);
     394    fseeko (subcat[0].f, Nbytes, SEEK_SET);
    390395
    391396    /* read Secfilt table header */
    … …  
    403408    catalog[0].secfilt = FtableToSecFilt (&ftable, &Nitems, &catalog[0].catformat);
    404409    if (Nitems != Nexpect) {
    405       fprintf (stderr, "Warning: mismatch between Nsecfilt items in PHU and Table headers (%d vs %d)\n", Nitems, Nexpect);
     410      fprintf (stderr, "Warning: mismatch between Nsecfilt items in PHU and Table headers (%lld vs %lld)\n", (long long) Nitems, (long long) Nexpect);
    406411    }
    407412    catalog[0].Nsecf_mem = catalog[0].Naverage * catalog[0].Nsecfilt;
    … …  
    422427
    423428    /* move pointer past header -- must be already read (load_catalog) */
    424     Nbytes = subcat[0].header.size + gfits_data_size (&subcat[0].header);
    425     fseek (subcat[0].f, Nbytes, SEEK_SET);
     429    Nbytes = subcat[0].header.datasize + gfits_data_size (&subcat[0].header);
     430    fseeko (subcat[0].f, Nbytes, SEEK_SET);
    426431
    427432    /* read Measure table header */
    … …  
    439444    catalog[0].measure = FtableToMeasure (&ftable, &Nmeasure, &catalog[0].catformat);
    440445    if (Nmeasure != Nrows) {
    441       fprintf (stderr, "Warning: mismatch between Nmeasure in PHU and Table headers (%d vs %d)\n", Nmeasure, Nrows);
     446      fprintf (stderr, "Warning: mismatch between Nmeasure in PHU and Table headers (%lld vs %lld)\n", (long long) Nmeasure, (long long) Nrows);
    442447    }
    443448    gfits_free_header (&header);
    … …  
    452457
    453458    /* move pointer past header -- must be already read (load_catalog) */
    454     Nbytes = subcat[0].header.size + gfits_data_size (&subcat[0].header);
    455     fseek (subcat[0].f, Nbytes, SEEK_SET);
     459    Nbytes = subcat[0].header.datasize + gfits_data_size (&subcat[0].header);
     460    fseeko (subcat[0].f, Nbytes, SEEK_SET);
    456461
    457462    /* read Missing table header */
    … …  
    469474    catalog[0].missing = gfits_table_get_Missing (&ftable, &Nmissing, NULL);
    470475    if (Nmissing != Nrows) {
    471       fprintf (stderr, "Warning: mismatch between Nmissing in PHU and Table headers (%d vs %d)\n", Nmissing, Nrows);
     476      fprintf (stderr, "Warning: mismatch between Nmissing in PHU and Table headers (%lld vs %lld)\n", (long long) Nmissing, (long long) Nrows);
    472477    }
    473478    gfits_free_header (&header);
    … …  
    481486int dvo_catalog_save_split (Catalog *catalog, char VERBOSE) {
    482487
    483   int Nitems;
     488  off_t Nitems;
    484489  Header header;
    485490  FTable ftable;
    486491  SecFilt *primary, *secfilt;
    487492  int Nsecfilt;
    488   int Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new;
    489   int first, start, Nrows;
     493  off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new;
     494  off_t first, start, Nrows;
    490495
    491496  ftable.header = &header;
    … …  
    519524
    520525  /* make sure header is consistent with data */
    521   gfits_modify (&catalog[0].header, "NSTARS",   "%d", 1, Naves_disk_new);
    522   gfits_modify (&catalog[0].header, "NMEAS",    "%d", 1, Nmeas_disk_new);
    523   gfits_modify (&catalog[0].header, "NMISS",    "%d", 1, Nmiss_disk_new);
    524   gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
    525   gfits_modify (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
     526  gfits_modify (&catalog[0].header, "NSTARS",   "%lld", 1, (long long) Naves_disk_new);
     527  gfits_modify (&catalog[0].header, "NMEAS",    "%lld", 1, (long long) Nmeas_disk_new);
     528  gfits_modify (&catalog[0].header, "NMISS",    "%lld", 1, (long long) Nmiss_disk_new);
     529  gfits_modify (&catalog[0].header, "NSECFILT", "%d",   1, Nsecfilt);
     530  gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
    526531  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    527532
    … …  
    555560    // even if we do not save the average table, we need to keep the header in sync
    556561    /* rewind file pointers and truncate (file is still open) */
    557     fseek (catalog[0].f, 0, SEEK_SET);
     562    fseeko (catalog[0].f, 0, SEEK_SET);
    558563
    559564    /* write table PHU header - always write this out */
    … …  
    662667int dvo_catalog_save_split_complete (Catalog *catalog, char VERBOSE) {
    663668
    664   int Nitems;
     669  off_t Nitems;
    665670  Header header;
    666671  FTable ftable;
    667672  SecFilt *primary, *secfilt;
    668673  int Nsecfilt;
    669   int Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new;
    670   int first, start, Nrows;
     674  off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new;
     675  off_t first, start, Nrows;
    671676
    672677  ftable.header = &header;
    … …  
    693698  }
    694699
    695   if ((catalog[0].Naverage > 0) && (Naves_disk_new == 0)) {
    696     Naves_disk_new = catalog[0].Naverage;
     700  Naves_disk_new = catalog[0].Naverage;
     701  if (Naves_disk_new == 0) {
    697702    if (VERBOSE) fprintf (stderr, "resulting catalog is empty; delete it\n");
    698703    // unlink ();
    699704    return (TRUE);
    700705  }
    701 
    702   Naves_disk_new = catalog[0].Naverage;
    703706
    704707  // for the appropriate types, pull out the first secfilt and pass to AverageToFtable as primary
    … …  
    720723
    721724  /* make sure header is consistent with data */
    722   gfits_modify (&catalog[0].header, "NSTARS",   "%d", 1, Naves_disk_new);
    723   gfits_modify (&catalog[0].header, "NMEAS",    "%d", 1, Nmeas_disk_new);
    724   gfits_modify (&catalog[0].header, "NMISS",    "%d", 1, Nmiss_disk_new);
     725  gfits_modify (&catalog[0].header, "NSTARS",   "%lld", 1, (long long) Naves_disk_new);
     726  gfits_modify (&catalog[0].header, "NMEAS",    "%lld", 1, (long long) Nmeas_disk_new);
     727  gfits_modify (&catalog[0].header, "NMISS",    "%lld", 1, (long long) Nmiss_disk_new);
    725728  gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
    726   gfits_modify (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
     729  gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
    727730  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    728731
    … …  
    756759    // even if we do not save the average table, we need to keep the header in sync
    757760    /* rewind file pointers and truncate (file is still open) */
    758     fseek (catalog[0].f, 0, SEEK_SET);
     761    fseeko (catalog[0].f, 0, SEEK_SET);
    759762
    760763    /* write table PHU header - always write this out */
    … …  
    867870  SecFilt *primary, *secfilt;
    868871  int Nsecfilt;
    869   int Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new;
    870   int first, start, Nrows;
     872  off_t Naves_disk_new, Nmeas_disk_new, Nmiss_disk_new, Nsecf_disk_new;
     873  off_t first, start, Nrows;
    871874
    872875  ftable.header = &header;
    … …  
    899902
    900903  /* make sure header is consistent with data */
    901   gfits_modify (&catalog[0].header, "NSTARS",   "%d", 1, Naves_disk_new);
    902   gfits_modify (&catalog[0].header, "NMEAS",    "%d", 1, Nmeas_disk_new);
    903   gfits_modify (&catalog[0].header, "NMISS",    "%d", 1, Nmiss_disk_new);
     904  gfits_modify (&catalog[0].header, "NSTARS",   "%lld", 1, (long long) Naves_disk_new);
     905  gfits_modify (&catalog[0].header, "NMEAS",    "%lld", 1, (long long) Nmeas_disk_new);
     906  gfits_modify (&catalog[0].header, "NMISS",    "%lld", 1, (long long) Nmiss_disk_new);
    904907  gfits_modify (&catalog[0].header, "NSECFILT", "%d", 1, Nsecfilt);
    905   gfits_modify (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
     908  gfits_modify_alt (&catalog[0].header, "EXTEND",   "%t", 1, TRUE);
    906909  gfits_modify (&catalog[0].header, "OBJID",    "%d", 1, catalog[0].objID);
    907910
    … …  
    935938    // even if we do not save the average table, we need to keep the header in sync
    936939    /* rewind file pointers and truncate (file is still open) */
    937     fseek (catalog[0].f, 0, SEEK_SET);
     940    fseeko (catalog[0].f, 0, SEEK_SET);
    938941
    939942    /* write table PHU header - always write this out */

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

    r24748 r27435  
    1313/*** Average / FTable conversion functions ***/
    1414
    15 Average *FtableToAverage (FTable *ftable, int *Naverage, int *format, SecFilt **primary) {
     15Average *FtableToAverage (FTable *ftable, off_t *Naverage, char *format, SecFilt **primary) {
    1616
    1717  Average *average;
    … …  
    5959}
    6060
    61 int AverageToFtable (FTable *ftable, Average *average, int Naverage, int format, SecFilt *primary) {
     61int AverageToFtable (FTable *ftable, Average *average, off_t Naverage, char format, SecFilt *primary) {
    6262
    6363# define FORMAT_CASE(FORMAT, TYPE) \
    … …  
    9494/*** Measure / FTable conversion functions ***/
    9595
    96 Measure *FtableToMeasure (FTable *ftable, int *Nmeasure, int *format) {
     96Measure *FtableToMeasure (FTable *ftable, off_t *Nmeasure, char *format) {
    9797
    9898  Measure *measure;
    … …  
    136136}
    137137
    138 int MeasureToFtable (FTable *ftable, Measure *measure, int Nmeasure, int format) {
     138int MeasureToFtable (FTable *ftable, Measure *measure, off_t Nmeasure, char format) {
    139139
    140140# define FORMAT_CASE(FORMAT, TYPE) \
    … …  
    171171/*** SecFilt / FTable conversion functions ***/
    172172
    173 SecFilt *FtableToSecFilt (FTable *ftable, int *Nsecfilt, int *format) {
     173SecFilt *FtableToSecFilt (FTable *ftable, off_t *Nsecfilt, char *format) {
    174174
    175175  SecFilt *secfilt;
    … …  
    213213}
    214214
    215 int SecFiltToFtable (FTable *ftable, SecFilt *secfilt, int Nsecfilt, int format) {
     215int SecFiltToFtable (FTable *ftable, SecFilt *secfilt, off_t Nsecfilt, char format) {
    216216
    217217# define FORMAT_CASE(FORMAT, TYPE) \
    … …  
    248248/*** Image Conversions ***/
    249249
    250 int FtableToImage (FTable *ftable, Header *theader, int *format) {
    251 
    252   int Nimage;
     250int FtableToImage (FTable *ftable, Header *theader, char *format) {
     251
     252  off_t Nimage;
    253253  char extname[80];
    254254
    … …  
    261261    gfits_free_header (theader);
    262262    gfits_table_mkheader_Image (theader);
    263     gfits_modify (theader, "NAXIS2", "%d", 1, Nimage);
     263    gfits_modify (theader, "NAXIS2", "%lld", 1, (long long) Nimage);
    264264    theader[0].Naxis[1] = Nimage;
    265     ftable[0].size = gfits_data_size (theader);
     265    ftable[0].datasize = gfits_data_size (theader);
    266266    return (TRUE);
    267267  }
    … …  
    282282    gfits_free_header (theader); \
    283283    gfits_table_mkheader_Image (theader); \
    284     gfits_modify (theader, "NAXIS2", "%d", 1, Nimage); \
     284    gfits_modify (theader, "NAXIS2", "%lld", 1, (long long) Nimage); \
    285285    theader[0].Naxis[1] = Nimage; \
    286     ftable[0].size = gfits_data_size (theader); \
     286    ftable[0].datasize = gfits_data_size (theader); \
    287287    return (TRUE); }
    288288
    … …  
    312312}
    313313
    314 int ImageToFtable (FTable *ftable, Header *theader, int format) {
    315 
    316   int Nimage;
     314int ImageToFtable (FTable *ftable, Header *theader, char format) {
     315
     316  off_t Nimage;
    317317
    318318  Nimage = theader[0].Naxis[1];
    … …  
    353353}
    354354
    355 int ImageToVtable (VTable *vtable, Header *theader, int format) {
    356 
    357   int i, Nrow, Nimage;
     355int ImageToVtable (VTable *vtable, Header *theader, char format) {
     356
     357  off_t i, Nrow, Nimage;
    358358
    359359  Nrow = vtable[0].Nrow;
    … …  
    370370      } \
    371371      /* convert header from old format to new format */ \
    372       gfits_scan (theader, "NAXIS2", "%d", 1, &Nimage); \
     372      gfits_scan (theader, "NAXIS2", "%lld", 1, (long long *) &Nimage); \
    373373      gfits_free_header (theader); \
    374374      gfits_table_mkheader_Image_##TYPE (theader); \
    375       gfits_modify (theader, "NAXIS2", "%d", 1, Nimage); \
     375      gfits_modify (theader, "NAXIS2", "%lld", 1, (long long) Nimage); \
    376376      theader[0].Naxis[1] = Nimage; \
    377       vtable[0].size = gfits_data_size (theader); \
     377      vtable[0].datasize = gfits_data_size (theader); \
    378378      return (TRUE); }
    379379

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

    r21508 r27435  
    33/* convert PS1_DEV_1 formats to internal formats */
    44
    5 Measure *Measure_PS1_DEV_1_ToInternal (Measure_PS1_DEV_1 *in, int Nvalues) {
    6 
    7   int i;
     5Measure *Measure_PS1_DEV_1_ToInternal (Measure_PS1_DEV_1 *in, off_t Nvalues) {
     6
     7  off_t i;
    88  Measure *out;
    99
    … …  
    6161}
    6262
    63 Measure_PS1_DEV_1 *MeasureInternalTo_PS1_DEV_1 (Measure *in, int Nvalues) {
    64 
    65   int i;
     63Measure_PS1_DEV_1 *MeasureInternalTo_PS1_DEV_1 (Measure *in, off_t Nvalues) {
     64
     65  off_t i;
    6666  Measure_PS1_DEV_1 *out;
    6767
    … …  
    108108
    109109// 'primary' is needed to conform with the API for Loneos and Elixir, but is not used
    110 Average *Average_PS1_DEV_1_ToInternal (Average_PS1_DEV_1 *in, int Nvalues, SecFilt **primary) {
    111 
    112   int i;
     110Average *Average_PS1_DEV_1_ToInternal (Average_PS1_DEV_1 *in, off_t Nvalues, SecFilt **primary) {
     111
     112  off_t i;
    113113  Average *out;
    114114
    … …  
    148148
    149149// 'primary' is needed to conform with the API for Loneos and Elixir, but is not used
    150 Average_PS1_DEV_1 *AverageInternalTo_PS1_DEV_1 (Average *in, int Nvalues, SecFilt *primary) {
    151 
    152   int i;
     150Average_PS1_DEV_1 *AverageInternalTo_PS1_DEV_1 (Average *in, off_t Nvalues, SecFilt *primary) {
     151
     152  off_t i;
    153153  Average_PS1_DEV_1 *out;
    154154
    … …  
    182182}
    183183
    184 SecFilt *SecFilt_PS1_DEV_1_ToInternal (SecFilt_PS1_DEV_1 *in, int Nvalues) {
    185 
    186   int i;
     184SecFilt *SecFilt_PS1_DEV_1_ToInternal (SecFilt_PS1_DEV_1 *in, off_t Nvalues) {
     185
     186  off_t i;
    187187  SecFilt *out;
    188188
    … …  
    203203}
    204204
    205 SecFilt_PS1_DEV_1 *SecFiltInternalTo_PS1_DEV_1 (SecFilt *in, int Nvalues) {
    206 
    207   int i;
     205SecFilt_PS1_DEV_1 *SecFiltInternalTo_PS1_DEV_1 (SecFilt *in, off_t Nvalues) {
     206
     207  off_t i;
    208208  SecFilt_PS1_DEV_1 *out;
    209209
    … …  
    220220}
    221221
    222 Image *Image_PS1_DEV_1_ToInternal (Image_PS1_DEV_1 *in, int Nvalues) {
    223 
    224   int i;
     222Image *Image_PS1_DEV_1_ToInternal (Image_PS1_DEV_1 *in, off_t Nvalues) {
     223
     224  off_t i;
    225225  Image *out;
    226226
    … …  
    284284
    285285/* convert internal images to panstarrs-format images */
    286 Image_PS1_DEV_1 *ImageInternalTo_PS1_DEV_1 (Image *in, int Nvalues) {
    287 
    288   int i;
     286Image_PS1_DEV_1 *ImageInternalTo_PS1_DEV_1 (Image *in, off_t Nvalues) {
     287
     288  off_t i;
    289289  Image_PS1_DEV_1 *out;
    290290
    … …  
    342342}
    343343
    344 PhotCode *PhotCode_PS1_DEV_1_To_Internal (PhotCode_PS1_DEV_1 *in, int Nvalues) {
    345 
    346   int i;
     344PhotCode *PhotCode_PS1_DEV_1_To_Internal (PhotCode_PS1_DEV_1 *in, off_t Nvalues) {
     345
     346  off_t i;
    347347  PhotCode *out;
    348348
    … …  
    381381}
    382382
    383 PhotCode_PS1_DEV_1 *PhotCode_Internal_To_PS1_DEV_1 (PhotCode *in, int Nvalues) {
    384 
    385   int i;
     383PhotCode_PS1_DEV_1 *PhotCode_Internal_To_PS1_DEV_1 (PhotCode *in, off_t Nvalues) {
     384
     385  off_t i;
    386386  PhotCode_PS1_DEV_1 *out;
    387387

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

    r21508 r27435  
    33/* convert PS1_DEV_2 formats to internal formats */
    44
    5 Measure *Measure_PS1_DEV_2_ToInternal (Measure_PS1_DEV_2 *in, int Nvalues) {
    6 
    7   int i;
     5Measure *Measure_PS1_DEV_2_ToInternal (Measure_PS1_DEV_2 *in, off_t Nvalues) {
     6
     7  off_t i;
    88  Measure *out;
    99
    … …  
    5858}
    5959
    60 Measure_PS1_DEV_2 *MeasureInternalTo_PS1_DEV_2 (Measure *in, int Nvalues) {
    61 
    62   int i;
     60Measure_PS1_DEV_2 *MeasureInternalTo_PS1_DEV_2 (Measure *in, off_t Nvalues) {
     61
     62  off_t i;
    6363  Measure_PS1_DEV_2 *out;
    6464
    … …  
    104104
    105105// 'primary' is needed to conform with the API for Loneos and Elixir, but is not used
    106 Average *Average_PS1_DEV_2_ToInternal (Average_PS1_DEV_2 *in, int Nvalues, SecFilt **primary) {
    107 
    108   int i;
     106Average *Average_PS1_DEV_2_ToInternal (Average_PS1_DEV_2 *in, off_t Nvalues, SecFilt **primary) {
     107
     108  off_t i;
    109109  Average *out;
    110110
    … …  
    142142
    143143// 'primary' is needed to conform with the API for Loneos and Elixir, but is not used
    144 Average_PS1_DEV_2 *AverageInternalTo_PS1_DEV_2 (Average *in, int Nvalues, SecFilt *primary) {
    145 
    146   int i;
     144Average_PS1_DEV_2 *AverageInternalTo_PS1_DEV_2 (Average *in, off_t Nvalues, SecFilt *primary) {
     145
     146  off_t i;
    147147  Average_PS1_DEV_2 *out;
    148148
    … …  
    176176}
    177177
    178 SecFilt *SecFilt_PS1_DEV_2_ToInternal (SecFilt_PS1_DEV_2 *in, int Nvalues) {
    179 
    180   int i;
     178SecFilt *SecFilt_PS1_DEV_2_ToInternal (SecFilt_PS1_DEV_2 *in, off_t Nvalues) {
     179
     180  off_t i;
    181181  SecFilt *out;
    182182
    … …  
    197197}
    198198
    199 SecFilt_PS1_DEV_2 *SecFiltInternalTo_PS1_DEV_2 (SecFilt *in, int Nvalues) {
    200 
    201   int i;
     199SecFilt_PS1_DEV_2 *SecFiltInternalTo_PS1_DEV_2 (SecFilt *in, off_t Nvalues) {
     200
     201  off_t i;
    202202  SecFilt_PS1_DEV_2 *out;
    203203
    … …  
    214214}
    215215
    216 Image *Image_PS1_DEV_2_ToInternal (Image_PS1_DEV_2 *in, int Nvalues) {
    217 
    218   int i;
     216Image *Image_PS1_DEV_2_ToInternal (Image_PS1_DEV_2 *in, off_t Nvalues) {
     217
     218  off_t i;
    219219  Image *out;
    220220
    … …  
    224224    memcpy (&out[i].coords, &in[i].coords, sizeof(Coords));
    225225
    226     strncpy (out[i].name, in[i].name, 63); // out[121], int[64]
     226    strncpy (out[i].name, in[i].name, 63); // out[121], in[64]
    227227    out[i].name[63] = 0; // force termination
    228228
    … …  
    275275}
    276276
    277 Image_PS1_DEV_2 *ImageInternalTo_PS1_DEV_2 (Image *in, int Nvalues) {
    278 
    279   int i;
     277Image_PS1_DEV_2 *ImageInternalTo_PS1_DEV_2 (Image *in, off_t Nvalues) {
     278
     279  off_t i;
    280280  Image_PS1_DEV_2 *out;
    281281
    … …  
    335335}
    336336
    337 PhotCode *PhotCode_PS1_DEV_2_To_Internal (PhotCode_PS1_DEV_2 *in, int Nvalues) {
    338 
    339   int i;
     337PhotCode *PhotCode_PS1_DEV_2_To_Internal (PhotCode_PS1_DEV_2 *in, off_t Nvalues) {
     338
     339  off_t i;
    340340  PhotCode *out;
    341341
    … …  
    372372}
    373373
    374 PhotCode_PS1_DEV_2 *PhotCode_Internal_To_PS1_DEV_2 (PhotCode *in, int Nvalues) {
    375 
    376   int i;
     374PhotCode_PS1_DEV_2 *PhotCode_Internal_To_PS1_DEV_2 (PhotCode *in, off_t Nvalues) {
     375
     376  off_t i;
    377377  PhotCode_PS1_DEV_2 *out;
    378378

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

    r21508 r27435  
    55// We only provide image and photcode conversion
    66
    7 Image *Image_PS1_DEV_3_ToInternal (Image_PS1_DEV_3 *in, int Nvalues) {
     7Image *Image_PS1_DEV_3_ToInternal (Image_PS1_DEV_3 *in, off_t Nvalues) {
    88
    9   int i;
     9  off_t i;
    1010  Image *out;
    1111
    … …  
    6666}
    6767
    68 Image_PS1_DEV_3 *ImageInternalTo_PS1_DEV_3 (Image *in, int Nvalues) {
     68Image_PS1_DEV_3 *ImageInternalTo_PS1_DEV_3 (Image *in, off_t Nvalues) {
    6969
    70   int i;
     70  off_t i;
    7171  Image_PS1_DEV_3 *out;
    7272
    … …  
    126126}
    127127
    128 PhotCode *PhotCode_PS1_DEV_3_To_Internal (PhotCode_PS1_DEV_3 *in, int Nvalues) {
     128PhotCode *PhotCode_PS1_DEV_3_To_Internal (PhotCode_PS1_DEV_3 *in, off_t Nvalues) {
    129129
    130   int i;
     130  off_t i;
    131131  PhotCode *out;
    132132
    … …  
    162162}
    163163
    164 PhotCode_PS1_DEV_3 *PhotCode_Internal_To_PS1_DEV_3 (PhotCode *in, int Nvalues) {
     164PhotCode_PS1_DEV_3 *PhotCode_Internal_To_PS1_DEV_3 (PhotCode *in, off_t Nvalues) {
    165165
    166   int i;
     166  off_t i;
    167167  PhotCode_PS1_DEV_3 *out;
    168168

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

    r26482 r27435  
    33/* convert PS1_REF formats to internal formats */
    44
    5 Measure *Measure_PS1_REF_ToInternal (Measure_PS1_REF *in, int Nvalues) {
    6 
    7   int i;
     5Measure *Measure_PS1_REF_ToInternal (Measure_PS1_REF *in, off_t Nvalues) {
     6
     7  off_t i;
    88  Measure *out;
    99
    … …  
    5656}
    5757
    58 Measure_PS1_REF *MeasureInternalTo_PS1_REF (Measure *in, int Nvalues) {
    59 
    60   int i;
     58Measure_PS1_REF *MeasureInternalTo_PS1_REF (Measure *in, off_t Nvalues) {
     59
     60  off_t i;
    6161  Measure_PS1_REF *out;
    6262
    … …  
    7979
    8080// 'primary' is needed to conform with the API for Loneos and Elixir, but is not used
    81 Average *Average_PS1_REF_ToInternal (Average_PS1_REF *in, int Nvalues, SecFilt **primary) {
    82 
    83   int i;
     81Average *Average_PS1_REF_ToInternal (Average_PS1_REF *in, off_t Nvalues, SecFilt **primary) {
     82
     83  off_t i;
    8484  Average *out;
    8585
    … …  
    9797    out[i].P             = NAN;
    9898    out[i].dP            = NAN;
    99     out[i].Xp            = NAN;
     99    out[i].Xp            = NAN_S_SHORT;
    100100    out[i].ChiSq         = NAN;
    101101    out[i].Npos          = 0;
    … …  
    115115
    116116// 'primary' is needed to conform with the API for Loneos and Elixir, but is not used
    117 Average_PS1_REF *AverageInternalTo_PS1_REF (Average *in, int Nvalues, SecFilt *primary) {
    118 
    119   int i;
     117Average_PS1_REF *AverageInternalTo_PS1_REF (Average *in, off_t Nvalues, SecFilt *primary) {
     118
     119  off_t i;
    120120  Average_PS1_REF *out;
    121121
    … …  
    138138}
    139139
    140 SecFilt *SecFilt_PS1_REF_ToInternal (SecFilt_PS1_REF *in, int Nvalues) {
    141 
    142   int i;
     140SecFilt *SecFilt_PS1_REF_ToInternal (SecFilt_PS1_REF *in, off_t Nvalues) {
     141
     142  off_t i;
    143143  SecFilt *out;
    144144
    … …  
    148148    out[i].M     = in[i].M;     
    149149    out[i].dM    = in[i].dM;     
    150     out[i].Xm    = NAN;
     150    out[i].Xm    = NAN_S_SHORT;
    151151    out[i].Ncode = 0;
    152152    out[i].Nused = 0;
    … …  
    157157}
    158158
    159 SecFilt_PS1_REF *SecFiltInternalTo_PS1_REF (SecFilt *in, int Nvalues) {
    160 
    161   int i;
     159SecFilt_PS1_REF *SecFiltInternalTo_PS1_REF (SecFilt *in, off_t Nvalues) {
     160
     161  off_t i;
    162162  SecFilt_PS1_REF *out;
    163163
    … …  
    171171}
    172172
    173 Image *Image_PS1_REF_ToInternal (Image_PS1_REF *in, int Nvalues) {
    174 
    175   int i;
     173Image *Image_PS1_REF_ToInternal (Image_PS1_REF *in, off_t Nvalues) {
     174
     175  off_t i;
    176176  Image *out;
    177177
    … …  
    230230}
    231231
    232 Image_PS1_REF *ImageInternalTo_PS1_REF (Image *in, int Nvalues) {
    233 
    234   int i;
     232Image_PS1_REF *ImageInternalTo_PS1_REF (Image *in, off_t Nvalues) {
     233
     234  off_t i;
    235235  Image_PS1_REF *out;
    236236
    … …  
    289289}
    290290
    291 PhotCode *PhotCode_PS1_REF_To_Internal (PhotCode_PS1_REF *in, int Nvalues) {
    292 
    293   int i;
     291PhotCode *PhotCode_PS1_REF_To_Internal (PhotCode_PS1_REF *in, off_t Nvalues) {
     292
     293  off_t i;
    294294  PhotCode *out;
    295295
    … …  
    325325}
    326326
    327 PhotCode_PS1_REF *PhotCode_Internal_To_PS1_REF (PhotCode *in, int Nvalues) {
    328 
    329   int i;
     327PhotCode_PS1_REF *PhotCode_Internal_To_PS1_REF (PhotCode *in, off_t Nvalues) {
     328
     329  off_t i;
    330330  PhotCode_PS1_REF *out;
    331331

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

    r26482 r27435  
    33/* convert PS1_V1 formats to internal formats */
    44
    5 Measure *Measure_PS1_V1_ToInternal (Measure_PS1_V1 *in, int Nvalues) {
    6 
    7   int i;
     5Measure *Measure_PS1_V1_ToInternal (Measure_PS1_V1 *in, off_t Nvalues) {
     6
     7  off_t i;
    88  Measure *out;
    99
    … …  
    5656}
    5757
    58 Measure_PS1_V1 *MeasureInternalTo_PS1_V1 (Measure *in, int Nvalues) {
    59 
    60   int i;
     58Measure_PS1_V1 *MeasureInternalTo_PS1_V1 (Measure *in, off_t Nvalues) {
     59
     60  off_t i;
    6161  Measure_PS1_V1 *out;
    6262
    … …  
    111111
    112112// 'primary' is needed to conform with the API for Loneos and Elixir, but is not used
    113 Average *Average_PS1_V1_ToInternal (Average_PS1_V1 *in, int Nvalues, SecFilt **primary) {
    114 
    115   int i;
     113Average *Average_PS1_V1_ToInternal (Average_PS1_V1 *in, off_t Nvalues, SecFilt **primary) {
     114
     115  off_t i;
    116116  Average *out;
    117117
    … …  
    147147
    148148// 'primary' is needed to conform with the API for Loneos and Elixir, but is not used
    149 Average_PS1_V1 *AverageInternalTo_PS1_V1 (Average *in, int Nvalues, SecFilt *primary) {
    150 
    151   int i;
     149Average_PS1_V1 *AverageInternalTo_PS1_V1 (Average *in, off_t Nvalues, SecFilt *primary) {
     150
     151  off_t i;
    152152  Average_PS1_V1 *out;
    153153
    … …  
    182182}
    183183
    184 SecFilt *SecFilt_PS1_V1_ToInternal (SecFilt_PS1_V1 *in, int Nvalues) {
    185 
    186   int i;
     184SecFilt *SecFilt_PS1_V1_ToInternal (SecFilt_PS1_V1 *in, off_t Nvalues) {
     185
     186  off_t i;
    187187  SecFilt *out;
    188188
    … …  
    201201}
    202202
    203 SecFilt_PS1_V1 *SecFiltInternalTo_PS1_V1 (SecFilt *in, int Nvalues) {
    204 
    205   int i;
     203SecFilt_PS1_V1 *SecFiltInternalTo_PS1_V1 (SecFilt *in, off_t Nvalues) {
     204
     205  off_t i;
    206206  SecFilt_PS1_V1 *out;
    207207
    … …  
    220220}
    221221
    222 Image *Image_PS1_V1_ToInternal (Image_PS1_V1 *in, int Nvalues) {
    223 
    224   int i;
     222Image *Image_PS1_V1_ToInternal (Image_PS1_V1 *in, off_t Nvalues) {
     223
     224  off_t i;
    225225  Image *out;
    226226
    … …  
    279279}
    280280
    281 Image_PS1_V1 *ImageInternalTo_PS1_V1 (Image *in, int Nvalues) {
    282 
    283   int i;
     281Image_PS1_V1 *ImageInternalTo_PS1_V1 (Image *in, off_t Nvalues) {
     282
     283  off_t i;
    284284  Image_PS1_V1 *out;
    285285
    … …  
    338338}
    339339
    340 PhotCode *PhotCode_PS1_V1_To_Internal (PhotCode_PS1_V1 *in, int Nvalues) {
    341 
    342   int i;
     340PhotCode *PhotCode_PS1_V1_To_Internal (PhotCode_PS1_V1 *in, off_t Nvalues) {
     341
     342  off_t i;
    343343  PhotCode *out;
    344344
    … …  
    374374}
    375375
    376 PhotCode_PS1_V1 *PhotCode_Internal_To_PS1_V1 (PhotCode *in, int Nvalues) {
    377 
    378   int i;
     376PhotCode_PS1_V1 *PhotCode_Internal_To_PS1_V1 (PhotCode *in, off_t Nvalues) {
     377
     378  off_t i;
    379379  PhotCode_PS1_V1 *out;
    380380

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

    r21508 r27435  
    22
    33/* convert elixir-format measures to internal measures */
    4 Measure *Measure_Elixir_ToInternal (Measure_Elixir *in, int Nvalues) {
    5 
    6   int i;
     4Measure *Measure_Elixir_ToInternal (Measure_Elixir *in, off_t Nvalues) {
     5
     6  off_t i;
    77  Measure *out;
    88
    … …  
    6969
    7070/* convert internal measures to elixir-format measures */
    71 Measure_Elixir *MeasureInternalTo_Elixir (Measure *in, int Nvalues) {
    72 
    73   int i;
     71Measure_Elixir *MeasureInternalTo_Elixir (Measure *in, off_t Nvalues) {
     72
     73  off_t i;
    7474  Measure_Elixir *out;
    7575
    … …  
    108108
    109109/* convert elixir-format averages to internal averages */
    110 Average *Average_Elixir_ToInternal (Average_Elixir *in, int Nvalues, SecFilt **primary) {
    111 
    112   int i;
     110Average *Average_Elixir_ToInternal (Average_Elixir *in, off_t Nvalues, SecFilt **primary) {
     111
     112  off_t i;
    113113  Average *out;
    114114
    … …  
    159159
    160160/* convert internal averages to elixir-format averages */
    161 Average_Elixir *AverageInternalTo_Elixir (Average *in, int Nvalues, SecFilt *primary) {
    162 
    163   int i;
     161Average_Elixir *AverageInternalTo_Elixir (Average *in, off_t Nvalues, SecFilt *primary) {
     162
     163  off_t i;
    164164  Average_Elixir *out;
    165165
    … …  
    189189
    190190/* convert elixir-format secfilts to internal secfilts */
    191 SecFilt *SecFilt_Elixir_ToInternal (SecFilt_Elixir *in, int Nvalues) {
    192 
    193   int i;
     191SecFilt *SecFilt_Elixir_ToInternal (SecFilt_Elixir *in, off_t Nvalues) {
     192
     193  off_t i;
    194194  SecFilt *out;
    195195
    … …  
    213213
    214214/* convert internal secfilts to elixir-format secfilts */
    215 SecFilt_Elixir *SecFiltInternalTo_Elixir (SecFilt *in, int Nvalues) {
    216 
    217   int i;
     215SecFilt_Elixir *SecFiltInternalTo_Elixir (SecFilt *in, off_t Nvalues) {
     216
     217  off_t i;
    218218  SecFilt_Elixir *out;
    219219
    … …  
    231231
    232232/* convert elixir-format images to internal images */
    233 Image *Image_Elixir_ToInternal (Image_Elixir *in, int Nvalues) {
    234 
    235   int i;
     233Image *Image_Elixir_ToInternal (Image_Elixir *in, off_t Nvalues) {
     234
     235  off_t i;
    236236  Image *out;
    237237
    … …  
    297297
    298298/* convert internal images to elixir-format images */
    299 Image_Elixir *ImageInternalTo_Elixir (Image *in, int Nvalues) {
    300 
    301   int i;
     299Image_Elixir *ImageInternalTo_Elixir (Image *in, off_t Nvalues) {
     300
     301  off_t i;
    302302  Image_Elixir *out;
    303303
    … …  
    355355}
    356356
    357 PhotCode *PhotCode_Elixir_To_Internal (PhotCode_Elixir *in, int Nvalues) {
    358 
    359   int i;
     357PhotCode *PhotCode_Elixir_To_Internal (PhotCode_Elixir *in, off_t Nvalues) {
     358
     359  off_t i;
    360360  PhotCode *out;
    361361
    … …  
    395395}
    396396
    397 PhotCode_Elixir *PhotCode_Internal_To_Elixir (PhotCode *in, int Nvalues) {
    398 
    399   int i;
     397PhotCode_Elixir *PhotCode_Internal_To_Elixir (PhotCode *in, off_t Nvalues) {
     398
     399  off_t i;
    400400  PhotCode_Elixir *out;
    401401

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

    r21508 r27435  
    22
    33/* convert loneos-format measures to internal measures */
    4 Measure *Measure_Loneos_ToInternal (Measure_Loneos *in, int Nvalues) {
    5 
    6   int i;
     4Measure *Measure_Loneos_ToInternal (Measure_Loneos *in, off_t Nvalues) {
     5
     6  off_t i;
    77  Measure *out;
    88
    … …  
    7171
    7272/* convert internal measures to loneos-format measures */
    73 Measure_Loneos *MeasureInternalTo_Loneos (Measure *in, int Nvalues) {
    74 
    75   int i;
     73Measure_Loneos *MeasureInternalTo_Loneos (Measure *in, off_t Nvalues) {
     74
     75  off_t i;
    7676  Measure_Loneos *out;
    7777
    … …  
    9999
    100100/* convert loneos-format averages to internal averages */
    101 Average *Average_Loneos_ToInternal (Average_Loneos *in, int Nvalues, SecFilt **primary) {
    102 
    103   int i;
     101Average *Average_Loneos_ToInternal (Average_Loneos *in, off_t Nvalues, SecFilt **primary) {
     102
     103  off_t i;
    104104  Average *out;
    105105
    … …  
    151151
    152152/* convert internal averages to loneos-format averages */
    153 Average_Loneos *AverageInternalTo_Loneos (Average *in, int Nvalues, SecFilt *primary) {
    154 
    155   int i;
     153Average_Loneos *AverageInternalTo_Loneos (Average *in, off_t Nvalues, SecFilt *primary) {
     154
     155  off_t i;
    156156  Average_Loneos *out;
    157157
    … …  
    180180
    181181/* convert loneos-format secfilts to internal secfilts */
    182 SecFilt *SecFilt_Loneos_ToInternal (SecFilt_Loneos *in, int Nvalues) {
    183 
    184   int i;
     182SecFilt *SecFilt_Loneos_ToInternal (SecFilt_Loneos *in, off_t Nvalues) {
     183
     184  off_t i;
    185185  SecFilt *out;
    186186
    … …  
    206206
    207207/* convert internal secfilts to loneos-format secfilts */
    208 SecFilt_Loneos *SecFiltInternalTo_Loneos (SecFilt *in, int Nvalues) {
    209 
    210   int i;
     208SecFilt_Loneos *SecFiltInternalTo_Loneos (SecFilt *in, off_t Nvalues) {
     209
     210  off_t i;
    211211  SecFilt_Loneos *out;
    212212
    … …  
    223223
    224224/* convert loneos-format images to internal images */
    225 Image *Image_Loneos_ToInternal (Image_Loneos *in, int Nvalues) {
    226 
    227   int i;
     225Image *Image_Loneos_ToInternal (Image_Loneos *in, off_t Nvalues) {
     226
     227  off_t i;
    228228  Image *out;
    229229
    … …  
    290290
    291291/* convert internal images to loneos-format images */
    292 Image_Loneos *ImageInternalTo_Loneos (Image *in, int Nvalues) {
    293 
    294   int i;
     292Image_Loneos *ImageInternalTo_Loneos (Image *in, off_t Nvalues) {
     293
     294  off_t i;
    295295  Image_Loneos *out;
    296296

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

    r21508 r27435  
    22
    33/* convert panstarrs-format measures to internal measures */
    4 Measure *Measure_Panstarrs_DEV_0_ToInternal (Measure_Panstarrs_DEV_0 *in, int Nvalues) {
    5 
    6   int i;
     4Measure *Measure_Panstarrs_DEV_0_ToInternal (Measure_Panstarrs_DEV_0 *in, off_t Nvalues) {
     5
     6  off_t i;
    77  Measure *out;
    88
    … …  
    6666
    6767/* convert internal measures to panstarrs-format measures */
    68 Measure_Panstarrs_DEV_0 *MeasureInternalTo_Panstarrs_DEV_0 (Measure *in, int Nvalues) {
    69 
    70   int i;
     68Measure_Panstarrs_DEV_0 *MeasureInternalTo_Panstarrs_DEV_0 (Measure *in, off_t Nvalues) {
     69
     70  off_t i;
    7171  Measure_Panstarrs_DEV_0 *out;
    7272
    … …  
    115115/* convert panstarrs-format averages to internal averages */
    116116// 'primary is needed to conform with the API for Loneos and Elixir, but is not used
    117 Average *Average_Panstarrs_DEV_0_ToInternal (Average_Panstarrs_DEV_0 *in, int Nvalues, SecFilt **primary) {
    118 
    119   int i;
     117Average *Average_Panstarrs_DEV_0_ToInternal (Average_Panstarrs_DEV_0 *in, off_t Nvalues, SecFilt **primary) {
     118
     119  off_t i;
    120120  Average *out;
    121121
    … …  
    156156/* convert internal averages to panstarrs-format averages */
    157157// 'primary is needed to conform with the API for Loneos and Elixir, but is not used
    158 Average_Panstarrs_DEV_0 *AverageInternalTo_Panstarrs_DEV_0 (Average *in, int Nvalues, SecFilt *primary) {
    159 
    160   int i;
     158Average_Panstarrs_DEV_0 *AverageInternalTo_Panstarrs_DEV_0 (Average *in, off_t Nvalues, SecFilt *primary) {
     159
     160  off_t i;
    161161  Average_Panstarrs_DEV_0 *out;
    162162
    … …  
    191191
    192192/* convert panstarrs-format secfilts to internal secfilts */
    193 SecFilt *SecFilt_Panstarrs_DEV_0_ToInternal (SecFilt_Panstarrs_DEV_0 *in, int Nvalues) {
    194 
    195   int i;
     193SecFilt *SecFilt_Panstarrs_DEV_0_ToInternal (SecFilt_Panstarrs_DEV_0 *in, off_t Nvalues) {
     194
     195  off_t i;
    196196  SecFilt *out;
    197197
    … …  
    213213
    214214/* convert internal secfilts to panstarrs-format secfilts */
    215 SecFilt_Panstarrs_DEV_0 *SecFiltInternalTo_Panstarrs_DEV_0 (SecFilt *in, int Nvalues) {
    216 
    217   int i;
     215SecFilt_Panstarrs_DEV_0 *SecFiltInternalTo_Panstarrs_DEV_0 (SecFilt *in, off_t Nvalues) {
     216
     217  off_t i;
    218218  SecFilt_Panstarrs_DEV_0 *out;
    219219
    … …  
    231231
    232232/* convert panstarrs-format images to internal images */
    233 Image *Image_Panstarrs_DEV_0_ToInternal (Image_Panstarrs_DEV_0 *in, int Nvalues) {
    234 
    235   int i;
     233Image *Image_Panstarrs_DEV_0_ToInternal (Image_Panstarrs_DEV_0 *in, off_t Nvalues) {
     234
     235  off_t i;
    236236  Image *out;
    237237
    … …  
    297297
    298298/* convert internal images to panstarrs-format images */
    299 Image_Panstarrs_DEV_0 *ImageInternalTo_Panstarrs_DEV_0 (Image *in, int Nvalues) {
    300 
    301   int i;
     299Image_Panstarrs_DEV_0 *ImageInternalTo_Panstarrs_DEV_0 (Image *in, off_t Nvalues) {
     300
     301  off_t i;
    302302  Image_Panstarrs_DEV_0 *out;
    303303

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

    r21508 r27435  
    22
    33/* convert panstarrs-format measures to internal measures */
    4 Measure *Measure_Panstarrs_DEV_1_ToInternal (Measure_Panstarrs_DEV_1 *in, int Nvalues) {
    5 
    6   int i;
     4Measure *Measure_Panstarrs_DEV_1_ToInternal (Measure_Panstarrs_DEV_1 *in, off_t Nvalues) {
     5
     6  off_t i;
    77  Measure *out;
    88
    … …  
    6666
    6767/* convert internal measures to panstarrs-format measures */
    68 Measure_Panstarrs_DEV_1 *MeasureInternalTo_Panstarrs_DEV_1 (Measure *in, int Nvalues) {
    69 
    70   int i;
     68Measure_Panstarrs_DEV_1 *MeasureInternalTo_Panstarrs_DEV_1 (Measure *in, off_t Nvalues) {
     69
     70  off_t i;
    7171  Measure_Panstarrs_DEV_1 *out;
    7272
    … …  
    115115/* convert panstarrs-format averages to internal averages */
    116116// 'primary is needed to conform with the API for Loneos and Elixir, but is not used
    117 Average *Average_Panstarrs_DEV_1_ToInternal (Average_Panstarrs_DEV_1 *in, int Nvalues, SecFilt **primary) {
    118 
    119   int i;
     117Average *Average_Panstarrs_DEV_1_ToInternal (Average_Panstarrs_DEV_1 *in, off_t Nvalues, SecFilt **primary) {
     118
     119  off_t i;
    120120  Average *out;
    121121
    … …  
    156156/* convert internal averages to panstarrs-format averages */
    157157// 'primary is needed to conform with the API for Loneos and Elixir, but is not used
    158 Average_Panstarrs_DEV_1 *AverageInternalTo_Panstarrs_DEV_1 (Average *in, int Nvalues, SecFilt *primary) {
    159 
    160   int i;
     158Average_Panstarrs_DEV_1 *AverageInternalTo_Panstarrs_DEV_1 (Average *in, off_t Nvalues, SecFilt *primary) {
     159
     160  off_t i;
    161161  Average_Panstarrs_DEV_1 *out;
    162162
    … …  
    191191
    192192/* convert panstarrs-format secfilts to internal secfilts */
    193 SecFilt *SecFilt_Panstarrs_DEV_1_ToInternal (SecFilt_Panstarrs_DEV_1 *in, int Nvalues) {
    194 
    195   int i;
     193SecFilt *SecFilt_Panstarrs_DEV_1_ToInternal (SecFilt_Panstarrs_DEV_1 *in, off_t Nvalues) {
     194
     195  off_t i;
    196196  SecFilt *out;
    197197
    … …  
    213213
    214214/* convert internal secfilts to panstarrs-format secfilts */
    215 SecFilt_Panstarrs_DEV_1 *SecFiltInternalTo_Panstarrs_DEV_1 (SecFilt *in, int Nvalues) {
    216 
    217   int i;
     215SecFilt_Panstarrs_DEV_1 *SecFiltInternalTo_Panstarrs_DEV_1 (SecFilt *in, off_t Nvalues) {
     216
     217  off_t i;
    218218  SecFilt_Panstarrs_DEV_1 *out;
    219219
    … …  
    231231
    232232/* convert panstarrs-format images to internal images */
    233 Image *Image_Panstarrs_DEV_1_ToInternal (Image_Panstarrs_DEV_1 *in, int Nvalues) {
    234 
    235   int i;
     233Image *Image_Panstarrs_DEV_1_ToInternal (Image_Panstarrs_DEV_1 *in, off_t Nvalues) {
     234
     235  off_t i;
    236236  Image *out;
    237237
    … …  
    297297
    298298/* convert internal images to panstarrs-format images */
    299 Image_Panstarrs_DEV_1 *ImageInternalTo_Panstarrs_DEV_1 (Image *in, int Nvalues) {
    300 
    301   int i;
     299Image_Panstarrs_DEV_1 *ImageInternalTo_Panstarrs_DEV_1 (Image *in, off_t Nvalues) {
     300
     301  off_t i;
    302302  Image_Panstarrs_DEV_1 *out;
    303303

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

    r25757 r27435  
    5252  /* test for NAXIS == 2 in line 3 */
    5353  bzero (buffer, 241);
    54   fseek (db[0].f, 0, SEEK_SET);
     54  fseeko (db[0].f, 0, SEEK_SET);
    5555  Nread = fread (buffer, 1, 240, db[0].f);
    5656  if (Nread != 240) {
    … …  
    6363    return (FALSE);
    6464  }
    65   fseek (db[0].f, 0, SEEK_SET);
     65  fseeko (db[0].f, 0, SEEK_SET);
    6666
    6767  /* default values */
    … …  
    114114}
    115115
    116 int dvo_image_addrows (FITS_DB *db, Image *new, int Nnew) {
    117 
    118   int Nimages;
     116int dvo_image_addrows (FITS_DB *db, Image *new, off_t Nnew) {
     117
     118  off_t Nimages;
    119119
    120120  /* adjust header */
    121121  Nimages = 0;
    122   gfits_scan (&db[0].header, "NIMAGES", "%d", 1, &Nimages);
     122  gfits_scan (&db[0].header, "NIMAGES", "%lld", 1, (long long *) &Nimages);
    123123  Nimages += Nnew;
    124   gfits_modify (&db[0].header, "NIMAGES", "%d", 1, Nimages);
     124  gfits_modify (&db[0].header, "NIMAGES", "%lld", 1, (long long) Nimages);
    125125
    126126  gfits_table_to_vtable (&db[0].ftable, &db[0].vtable, 0, 0);
    … …  
    195195  gfits_table_set_Image (&db[0].ftable, NULL, 0);
    196196
    197   gfits_modify (&db[0].header, "NIMAGES", "%d", 1, 0);
     197  gfits_modify (&db[0].header, "NIMAGES", "%lld", 1, 0LL);
    198198  gfits_modify (&db[0].header, "ZERO_PT", "%lf", 1, ZeroPoint);
    199199

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

    r24748 r27435  
    77int dvo_image_load_raw (FITS_DB *db, int VERBOSE, int FORCE_READ) {
    88
    9   int Nimage, Ndata, size, ImageSize, nbytes, Nbytes;
     9  off_t Nimage, Ndata, size, ImageSize, nbytes, Nbytes;
    1010  struct stat filestatus;
    1111  char format[80], telescope[80];
    … …  
    3939  /* find number of images */
    4040  Nimage = 0;
    41   gfits_scan (&db[0].header, "NIMAGES", "%d", 1, &Nimage);
     41  gfits_scan (&db[0].header, "NIMAGES", "%lld", 1, (long long *) &Nimage);
    4242  if (stat (db[0].filename, &filestatus) == -1) {
    4343    if (VERBOSE) fprintf (stderr, "ERROR: failed to get status of image catalog\n");
    … …  
    5959
    6060  /* check that filesize makes sense */
    61   size = Nimage*ImageSize + db[0].header.size;
     61  size = Nimage*ImageSize + db[0].header.datasize;
    6262  if (size != filestatus.st_size) {
    63     Ndata = (filestatus.st_size - db[0].header.size) / ImageSize;
     63    Ndata = (filestatus.st_size - db[0].header.datasize) / ImageSize;
    6464    if (VERBOSE) fprintf (stderr, "ERROR: image catalog has inconsistent size\n");
    65     if (VERBOSE) fprintf (stderr, "header: %d, data: %d\n", Nimage, Ndata);
     65    if (VERBOSE) fprintf (stderr, "header: %lld, data: %lld\n", (long long) Nimage, (long long) Ndata);
    6666    if (!FORCE_READ) exit (1);
    6767    Nimage = Ndata;
    … …  
    9494  }
    9595
    96   gfits_modify (&db[0].theader, "NAXIS2", "%d", 1, Nimage);
     96  gfits_modify (&db[0].theader, "NAXIS2", "%lld", 1, (long long) Nimage);
    9797  db[0].theader.Naxis[1] = Nimage;
    98   db[0].ftable.size = gfits_data_size (&db[0].theader);
     98  db[0].ftable.datasize = gfits_data_size (&db[0].theader);
    9999  db[0].swapped = FALSE;  /* table does not have internal byte-order */
    100100  return (TRUE);
    … …  
    104104int dvo_image_update_raw (FITS_DB *db, int VERBOSE) {
    105105
    106   int i, Nx, Ny, Nrow, Nbytes;
    107   int status, start, offset;
    108   int *row;
     106  off_t i, Nx, Ny, Nrow, Nbytes, start, offset;
     107  off_t status;
     108  off_t *row;
    109109
    110   if (VERBOSE) fprintf (stderr, "writing out %d images\n", db[0].vtable.Nrow);
     110  if (VERBOSE) fprintf (stderr, "writing out %lld images\n", (long long) db[0].vtable.Nrow);
    111111
    112112  /* position to start of file */
    113   Fseek (db[0].f, 0, SEEK_SET);
     113  fseeko (db[0].f, 0, SEEK_SET);
    114114 
    115115  /* write out complete header (no check on disk size?) */
    116   status = fwrite (db[0].header.buffer, 1, db[0].header.size, db[0].f);
    117   if (status != db[0].header.size) {
     116  status = fwrite (db[0].header.buffer, 1, db[0].header.datasize, db[0].f);
     117  if (status != db[0].header.datasize) {
    118118    fprintf (stderr, "ERROR: failed writing data to image header\n");
    119119    exit (1);
    … …  
    123123  Nrow = db[0].vtable.Nrow;
    124124  row = db[0].vtable.row;
    125   gfits_scan (db[0].vtable.header, "NAXIS1", "%d", 1, &Nx);
    126   gfits_scan (db[0].vtable.header, "NAXIS2", "%d", 1, &Ny);
     125  gfits_scan (db[0].vtable.header, "NAXIS1", "%lld", 1, (long long *) &Nx);
     126  gfits_scan (db[0].vtable.header, "NAXIS2", "%lld", 1, (long long *) &Ny);
    127127
    128128  /* file pointer is at beginning of desired table data */
    … …  
    131131  for (i = 0; i < Nrow; i++) {
    132132    offset = start + Nx*row[i];
    133     fseek (db[0].f, offset, SEEK_SET);
     133    fseeko (db[0].f, offset, SEEK_SET);
    134134    Nbytes = fwrite (db[0].vtable.buffer[i], sizeof (char), Nx, db[0].f);
    135135    if (Nbytes != Nx) { return (FALSE); }
    … …  
    141141int dvo_image_save_raw (FITS_DB *db, int VERBOSE) {
    142142
    143   int status, Nx, Ny, size, Nbytes;
     143  off_t Nx, Ny, size, Nbytes;
     144  int status;
    144145
    145   if (VERBOSE) fprintf (stderr, "writing out %d images\n", db[0].theader.Naxis[1]);
     146  if (VERBOSE) fprintf (stderr, "writing out %lld images\n", (long long) db[0].theader.Naxis[1]);
    146147
    147148  /* position to start of file */
    … …  
    149150 
    150151  /* write out complete header (no check on disk size?) */
    151   status = fwrite (db[0].header.buffer, 1, db[0].header.size, db[0].f);
    152   if (status != db[0].header.size) {
     152  status = fwrite (db[0].header.buffer, 1, db[0].header.datasize, db[0].f);
     153  if (status != db[0].header.datasize) {
    153154    fprintf (stderr, "ERROR: failed writing data to image header\n");
    154155    exit (1);
    155156  }
    156157
    157   gfits_scan (db[0].ftable.header, "NAXIS1", "%d", 1, &Nx);
    158   gfits_scan (db[0].ftable.header, "NAXIS2", "%d", 1, &Ny);
     158  gfits_scan (db[0].ftable.header, "NAXIS1", "%lld", 1, (long long *) &Nx);
     159  gfits_scan (db[0].ftable.header, "NAXIS2", "%lld", 1, (long long *) &Ny);
    159160  size = Nx * Ny;
    160161  Nbytes = fwrite (db[0].ftable.buffer, sizeof(char), size, db[0].f);

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

    r26410 r27435  
    1818
    1919    memset(config, 0, sizeof(dvoConfig));
     20    return config;
    2021}
    2122
    … …  
    9899    }
    99100
    100     char *catdir, filename[256];
     101    char filename[256];
    101102 
    102103    sprintf (filename, "%s/Images.dat", dvoConfig->catdir);
    … …  
    136137Image *dvoImageByExternID(dvoConfig *dvoConfig, int sourceID, int externID)
    137138{
    138     Image *images;
    139     int Nimage;
    140139    int i;
    141140   
    … …  
    199198}
    200199
    201 int dvoGetDetections(SkyList *skylist, int imageID, dvoDetection **results, int *pMaxDetID)
    202 {
    203   int QUIET = 0;
    204   int FULL_OUTPUT = 0;
     200off_t dvoGetDetections(SkyList *skylist, int imageID, dvoDetection **results, int *pMaxDetID)
     201{
    205202  int GetMeasures = 1;
    206   int SaveVectors = 0;
    207203  int reg;
    208   int Ndetect = 0;
     204  off_t Ndetect = 0;
    209205
    210206  int detectionsArrayLength = 1000;
    … …  
    226222      dvo_catalog_unlock (&catalog);
    227223
    228       int Nstars = catalog.Naverage;
    229       int Nmeasure = catalog.Nmeasure;
    230 
    231       int i;
     224      off_t Nmeasure = catalog.Nmeasure;
     225
     226      off_t i;
    232227      for (i=0; i< Nmeasure; i++) {
    233228        Measure *m = catalog.measure + i;
    … …  
    265260
    266261      memset(sorted, 0, sizeof(dvoDetection) * *pMaxDetID);
    267       int i;
     262      off_t i;
    268263      for (i = 0; i < Ndetect; i++) {
    269264           sorted[detections[i].meas.detID] = detections[i];

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

    r21508 r27435  
    44
    55/* values are ave[i].R, ave[i].D, ave[i].M */
    6 void sortave (Average *ave, int N) {
     6void sortave (Average *ave, off_t N) {
    77
    88# define SWAPFUNC(A,B){ Average tmp; tmp = ave[A]; ave[A] = ave[B]; ave[B] = tmp; }
    … …  
    1717
    1818/* sort subset by image[subset[i]].tzero */
    19 void sort_image_subset (Image *image, int *subset, int N) {
     19void sort_image_subset (Image *image, off_t *subset, off_t N) {
    2020
    2121# define SWAPFUNC(A,B){ int tmp; tmp = subset[A]; subset[A] = subset[B]; subset[B] = tmp; }
    … …  
    3030
    3131/* sort a coordinate pair (X,Y) and the associated index (S) */
    32 void sort_coords_index (double *X, double *Y, int *S, int N) {
     32void sort_coords_index (double *X, double *Y, off_t *S, off_t N) {
    3333 
    34 # define SWAPFUNC(A,B){ double dtmp; int itmp; \
     34# define SWAPFUNC(A,B){ double dtmp; off_t itmp; \
    3535  dtmp = X[A]; X[A] = X[B]; X[B] = dtmp; \
    3636  dtmp = Y[A]; Y[A] = Y[B]; Y[B] = dtmp; \
    … …  
    4646}
    4747
    48 void sort_regions (SkyRegion *region, int N) {
     48void sort_regions (SkyRegion *region, off_t N) {
    4949
    5050# define SWAPFUNC(A,B){ SkyRegion tmp; tmp = region[A]; region[A] = region[B]; region[B] = tmp; }
    … …  
    5757
    5858}
    59 
    60 # if (0)
    61 // deprecated along with Stars as an autocode type
    62 void sort_stars_ra (Stars *stars, int N) {
    63 
    64 # define SWAPFUNC(A,B){ Stars tmp; tmp = stars[A]; stars[A] = stars[B]; stars[B] = tmp; }
    65 # define COMPARE(A,B)(stars[A].R < stars[B].R)
    66 
    67   OHANA_SORT (N, COMPARE, SWAPFUNC);
    68 
    69 # undef SWAPFUNC
    70 # undef COMPARE
    71 
    72 }
    73 # endif

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

    r15750 r27435  
    9292}
    9393
    94 /* load the data from Nrows from table starting at start; load header, etc if needed */
    95 int gfits_db_load_segment (FITS_DB *db, int start, int Nrows) {
    96 
    97   int Nskip;
     94/* load the Nrows data from table starting at start; load header, etc if needed */
     95int gfits_db_load_segment (FITS_DB *db, off_t start, off_t Nrows) {
     96
     97  off_t Nskip;
    9898
    9999  /* database name must be set first */
    … …  
    119119    }
    120120  } else {
    121     Nskip = db[0].header.size;
     121    Nskip = db[0].header.datasize;
    122122    Fseek (db[0].f, Nskip, SEEK_CUR);
    123123  }
    … …  
    141141    }
    142142  } else {
    143     Nskip = db[0].header.size;
     143    Nskip = db[0].header.datasize;
    144144    Fseek (db[0].f, Nskip, SEEK_CUR);
    145145  }

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

    r21047 r27435  
    11# include <dvo.h>
    22
     3off_t getDISentry (e_time start, e_time stop, e_time *startMos, off_t *indexMos, off_t Nmosaic);
     4void SortDISindex (e_time *S, off_t *I, off_t N);
     5
    36/* chip-match table: j = ChipMatch[i], images[j] is DIS for images[i] WRP */
    47
    5 static int    iDIS = -1;      // DIS entry in ChipMatch[]
    6 static int    Ndis = 0;
    7 static int    *DISentry = NULL;
     8static off_t  iDIS = -1;      // DIS entry in ChipMatch[]
     9static off_t  Ndis = 0;
     10static off_t  *DISentry = NULL;
    811static e_time *DIStzero = NULL;
    9 static int    *ChipMatch = NULL;
     12static off_t  *ChipMatch = NULL;
    1013
    1114/* what is the currently registered mosaic image? */
    12 int GetRegisteredMosaic () {
     15off_t GetRegisteredMosaic () {
    1316  return (iDIS);
    1417}
    1518
    1619/* given an image array and a current entry of type WRP, find matching DIS & Register it */
    17 int FindMosaicForImage (Image *images, int Nimages, int entry) {
     20int FindMosaicForImage (Image *images, off_t Nimages, off_t entry) {
    1821
    1922  int status;
    … …  
    2831
    2932/* given an image array and a current entry of type WRP, find matching DIS & Register it */
    30 int FindMosaicForImage_TableSearch (Image *images, int Nimages, int entry) {
     33int FindMosaicForImage_TableSearch (Image *images, off_t Nimages, off_t entry) {
    3134
    3235  e_time tzero;
    33   int i;
     36  off_t i;
    3437
    3538  /* search backwards for image with same time and type DIS */
    … …  
    6568
    6669/* given an image array and a current entry of type WRP, find matching DIS & Register it */
    67 int FindMosaicForImage_MatchSearch (Image *images, int Nimages, int entry) {
    68 
    69   int N;
     70int FindMosaicForImage_MatchSearch (Image *images, off_t Nimages, off_t entry) {
     71
     72  off_t N;
    7073
    7174  if (strcmp(&images[entry].coords.ctype[4], "-WRP")) {
    7275    /* not a wrp image, do nothing */
    73     return (TRUE); /* error or not */
     76    return (TRUE); /* error or not? */
    7477  }
    7578
    … …  
    8588}
    8689
    87 int BuildChipMatch (Image *images, int Nimages) {
    88 
    89   int i, j, NDIS;
     90int BuildChipMatch_old (Image *images, off_t Nimages) {
     91
     92  off_t i, j, NDIS;
    9093
    9194  if (DISentry != NULL) free (DISentry);
    … …  
    9699  Ndis = 0;
    97100  NDIS = 100;
    98   ALLOCATE (DISentry, int, NDIS);
     101  ALLOCATE (DISentry, off_t, NDIS);
    99102  ALLOCATE (DIStzero, e_time, NDIS);
    100103
    … …  
    106109    if (Ndis >= NDIS) {
    107110      NDIS += 100;
    108       REALLOCATE (DISentry, int, NDIS);
     111      REALLOCATE (DISentry, off_t, NDIS);
    109112      REALLOCATE (DIStzero, e_time, NDIS);
    110113    }
    … …  
    112115
    113116  /* find all matched WRP images */
    114   ALLOCATE (ChipMatch, int, Nimages);
     117  ALLOCATE (ChipMatch, off_t, Nimages);
    115118  for (i = 0; i < Nimages; i++) {
    116119    ChipMatch[i] = -1;
    … …  
    131134  return (TRUE);
    132135}
     136
     137int BuildChipMatch (Image *images, off_t Nimages) {
     138
     139  off_t i, j, NDIS;
     140
     141  if (DISentry != NULL) free (DISentry);
     142  if (DIStzero != NULL) free (DIStzero);
     143  if (ChipMatch != NULL) free (ChipMatch);
     144
     145  // allocate containers for DIS indexing
     146  Ndis = 0;
     147  NDIS = 100;
     148  ALLOCATE (DISentry, off_t, NDIS);
     149  ALLOCATE (DIStzero, e_time, NDIS);
     150
     151  // find all DIS images, save tzero (& instrument)
     152  for (i = 0; i < Nimages; i++) {
     153    if (strcmp(&images[i].coords.ctype[4], "-DIS")) continue;
     154    DISentry[Ndis] = i;
     155    DIStzero[Ndis] = images[i].tzero;
     156    Ndis ++;
     157    if (Ndis >= NDIS) {
     158      NDIS += 100;
     159      REALLOCATE (DISentry, off_t, NDIS);
     160      REALLOCATE (DIStzero, e_time, NDIS);
     161    }
     162  }
     163
     164  // sort the index, start, and stop by the start times:
     165  SortDISindex (DIStzero, DISentry, Ndis);
     166
     167  /* find all matched WRP images */
     168  ALLOCATE (ChipMatch, off_t, Nimages);
     169  for (i = 0; i < Nimages; i++) {
     170    ChipMatch[i] = -1;
     171    if (strcmp(&images[i].coords.ctype[4], "-WRP")) continue;
     172
     173    j = getDISentry (images[i].tzero, images[i].tzero + (int) images[i].exptime, DIStzero, DISentry, Ndis);
     174    if (j == -1) {
     175      fprintf (stderr, "WARNING: can't find matching mosaic \n");
     176      ChipMatch[i] = -2;
     177      continue;
     178    }
     179    if (j >= Nimages) abort();
     180
     181    ChipMatch[i] = j;
     182  }
     183  return (TRUE);
     184}
     185
     186off_t getDISentry (e_time start, e_time stop, e_time *startMos, off_t *indexMos, off_t Nmosaic) {
     187
     188  // use bisection to find the overlapping mosaic
     189
     190  off_t Nlo, Nhi, N;
     191
     192  // find the last mosaic before start
     193  Nlo = 0; Nhi = Nmosaic;
     194  while (Nhi - Nlo > 10) {
     195    N = 0.5*(Nlo + Nhi);
     196    if (startMos[N] < start) {
     197      Nlo = MAX(N, 0);
     198    } else {
     199      Nhi = MIN(N + 1, Nmosaic);
     200    }
     201  }
     202
     203  // check for the matched mosaic starting from Nlo
     204  // we may have to go much beyond Nlo since stop is not sorted
     205  // can we use a sorted version of stop to check when we are beyond the valid range??
     206  for (N = Nlo; N < Nmosaic; N++) {
     207    if (startMos[N] < start) continue;
     208    if (startMos[N] > stop) return (-1);
     209    return (indexMos[N]);
     210  }
     211
     212  return (-1);
     213}
     214
     215// sort two times vectors and an index by first time vector
     216void SortDISindex (e_time *S, off_t *I, off_t N) {
     217
     218# define SWAPFUNC(A,B){ e_time tmp_t; off_t tmp_i; \
     219  tmp_t = S[A]; S[A] = S[B]; S[B] = tmp_t; \
     220  tmp_i = I[A]; I[A] = I[B]; I[B] = tmp_i; \
     221}
     222# define COMPARE(A,B)(S[A] < S[B])
     223
     224  OHANA_SORT (N, COMPARE, SWAPFUNC);
     225
     226# undef SWAPFUNC
     227# undef COMPARE
     228
     229}
     230

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

    r25757 r27435  
    126126
    127127  /* third option: GSCFILE */
     128
     129  if (gscfile == NULL) {
     130    fprintf (stderr, "error loading sky table from existing db (%s)\n", catdir);
     131    return (NULL);
     132  }
     133
    128134  sky = SkyTableFromGSC (gscfile, depth, verbose);
    129135  if (sky == NULL) {

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

    r24976 r27435  
    386386SkyList *SkyListChildrenByBounds_List (SkyList *table, int depth, double Rmin, double Rmax, double Dmin, double Dmax) {
    387387
    388   int i, j, Ns, Ne, Nnew, NNEW;
    389   int append;
    390   SkyList *children;
     388  int i, Nnew, NNEW;
    391389  SkyList *list;
    392390  SkyRegion **region;

  • trunk/Ohana/src/libfits/header/F_H_field.c

    r21059 r27435  
    66
    77  char *buf;
    8   int i, Nwant, Nfound;
     8  off_t i;
     9  int Nwant, Nfound;
    910  char keyword[10];
     11
     12  if (header[0].buffer == NULL) return NULL;
    1013
    1114  /* create a blank-padded keyword with exactly 8 characters */
    … …  
    1922    /* find the Nth entry */
    2023    Nfound = 0;
    21     for (i = 0; i < header[0].size; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
     24    for (i = 0; i < header[0].datasize; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
    2225      if (!strncmp (keyword, buf, 8)) {
    2326        Nfound ++;
    … …  
    3033    /* count the entries */
    3134    Nfound = 0;
    32     for (i = 0; i < header[0].size; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
     35    for (i = 0; i < header[0].datasize; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
    3336      if (!strncmp (keyword, buf, 8)) {
    3437        Nfound ++;
    … …  
    4144    /* find the Nwant entry */
    4245    Nfound = 0;
    43     for (i = 0; i < header[0].size; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
     46    for (i = 0; i < header[0].datasize; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
    4447      if (!strncmp (keyword, buf, 8)) {
    4548        Nfound ++;
    … …  
    5053  }
    5154
    52   return ((char *) NULL);
     55  return NULL;
    5356
    5457/*
    … …  
    6669
    6770  char *buf, *ptr;
    68   int i, Nwant, Nfound, Nfield;
     71  off_t i;
     72  int Nwant, Nfound, Nfield;
     73
     74  if (header[0].buffer == NULL) return NULL;
    6975
    7076  Nfield = strlen (field);
    … …  
    7682  if (N > 0) {
    7783    Nfound = 0;
    78     for (i = 0; i < header[0].size; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
     84    for (i = 0; i < header[0].datasize; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
    7985      // have we found a HIERARCH entry?
    8086      if (strncmp ("HIERARCH", buf, 8)) continue;
    … …  
    9096    /* count the entries */
    9197    Nfound = 0;
    92     for (i = 0; i < header[0].size; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
     98    for (i = 0; i < header[0].datasize; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
    9399      if (strncmp ("HIERARCH", buf, 8)) continue;
    94100      ptr = buf + 9; // start of following keyword
    … …  
    102108    /* find the Nwant entry */
    103109    Nfound = 0;
    104     for (i = 0; i < header[0].size; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
     110    for (i = 0; i < header[0].datasize; i+= FT_LINE_LENGTH, buf += FT_LINE_LENGTH) {
    105111      if (strncmp ("HIERARCH", buf, 8)) continue;
    106112      ptr = buf + 9; // start of following keyword
    … …  
    111117  }
    112118
    113   return ((char *) NULL);
     119  return NULL;
    114120
    115121/*
    … …  
    122128
    123129/*********************** fits header field ****************************/
    124 char *gfits_header_lineno (Header *header, int N) {
     130char *gfits_header_lineno (Header *header, off_t N) {
    125131
    126132  char *buf;
    127133
    128   if (N*80 >= header[0].size) return NULL;
     134  if (N*80 >= header[0].datasize) return NULL;
    129135
    130136  buf = &header[0].buffer[N*80];

  • trunk/Ohana/src/libfits/header/F_copy_H.c

    r17903 r27435  
    1616    out[0].Naxis[i] = in[0].Naxis[i];
    1717
    18   out[0].size   = in[0].size;
     18  out[0].datasize = in[0].datasize;
    1919
    2020  out[0].pcount = in[0].pcount;
    … …  
    2424
    2525  if (out[0].buffer != NULL) free (out[0].buffer);
    26   ALLOCATE (out[0].buffer, char, out[0].size);
     26  ALLOCATE (out[0].buffer, char, out[0].datasize);
    2727 
    28   strncpy (out[0].buffer, in[0].buffer, out[0].size);
     28  memcpy (out[0].buffer, in[0].buffer, out[0].datasize);
    2929
    3030  return (TRUE);

  • trunk/Ohana/src/libfits/header/F_create_H.c

    r15487 r27435  
    99  char axis[10];
    1010 
    11   header[0].size = NBYTES;
     11  header[0].datasize = NBYTES;
    1212
    1313  ALLOCATE (header[0].buffer, char, NBYTES);
    … …  
    1717  strncpy (header[0].buffer, "END", 3);
    1818
    19   gfits_modify (header, "SIMPLE", "%t", 1, header[0].simple);
     19  gfits_modify_alt (header, "SIMPLE", "%t", 1, header[0].simple);
    2020  gfits_modify (header, "BITPIX", "%d", 1, header[0].bitpix);
    2121  gfits_modify (header, "NAXIS",  "%d", 1, header[0].Naxes);
    … …  
    2323  for (i = 0; i < header[0].Naxes; i++) {
    2424    snprintf (axis, 10, "NAXIS%d", i + 1);
    25     gfits_modify (header,  axis, "%d", 1, header[0].Naxis[i]);
     25    gfits_modify (header,  axis, "%lld", 1, (long long) header[0].Naxis[i]);
    2626  }
    2727
    … …  
    3030  gfits_modify (header, "BSCALE", "%lf", 1, header[0].bscale);
    3131  gfits_modify (header, "BZERO",  "%lf", 1, header[0].bzero);
    32   gfits_modify (header, "EXTEND", "%t",  1, header[0].extend);
     32  gfits_modify_alt (header, "EXTEND", "%t",  1, header[0].extend);
    3333  return (TRUE);
    3434

  • trunk/Ohana/src/libfits/header/F_delete.c

    r7054 r27435  
    55int gfits_delete (Header *header, char *field, int N) {
    66 
    7   int i, Nbytes;
     7  int i;
     8  off_t Nbytes;
    89  char *p1, *p2;
    910 
    … …  
    2223
    2324  p2 = gfits_header_field (header, "END", 1);
    24   if (header[0].size - (p2 - header[0].buffer + FT_LINE_LENGTH) > FT_RECORD_SIZE) {
    25     header[0].size -= FT_RECORD_SIZE;
    26     REALLOCATE (header[0].buffer, char, header[0].size);
     25  if (header[0].datasize - (p2 - header[0].buffer + FT_LINE_LENGTH) > FT_RECORD_SIZE) {
     26    header[0].datasize -= FT_RECORD_SIZE;
     27    REALLOCATE (header[0].buffer, char, header[0].datasize);
    2728  }
    2829  return (TRUE);

  • trunk/Ohana/src/libfits/header/F_modify.c

    r21059 r27435  
    22# include <gfitsio.h>
    33
     4// this is only valid for the regular and non-boolean fields
    45int gfits_modify (Header *header, char *field, char *mode, int N,...) {
    56 
    … …  
    89
    910  char comment[82], string[82], data[82];
    10   char *p, *qs, *qe;
     11  char *p, *qe;
    1112  va_list argp;
    1213 
    … …  
    2930   
    3031    /* is there enough space for 1 more line? */
    31     if (header[0].size - (p - (header[0].buffer)) < 2*FT_LINE_LENGTH) {
    32       header[0].size += FT_RECORD_SIZE;
    33       REALLOCATE (header[0].buffer, char, header[0].size);
     32    if (header[0].datasize - (p - (header[0].buffer)) < 2*FT_LINE_LENGTH) {
     33      header[0].datasize += FT_RECORD_SIZE;
     34      REALLOCATE (header[0].buffer, char, header[0].datasize);
    3435      p = gfits_header_field (header, "END", 1);
    3536      if (p == NULL) return (FALSE);
    … …  
    5051
    5152  /* write the numeric modes */
    52   if (!strcmp (mode, "%d"))  snprintf (string, 81, "%-8s= %20d / %-s ",     field, va_arg (argp, int),      comment);
    53   if (!strcmp (mode, "%u"))  snprintf (string, 81, "%-8s= %20d / %-s ",     field, va_arg (argp, unsigned), comment);
    54   if (!strcmp (mode, "%ld")) snprintf (string, 81, "%-8s= %20ld / %-s ",    field, va_arg (argp, long),     comment);
    55   if (!strcmp (mode, "%hd")) snprintf (string, 81, "%-8s= %20d / %-s ",     field, va_arg (argp, int),      comment);
    56   if (!strcmp (mode, "%f"))  snprintf (string, 81, "%-8s= %20.10f / %-s ",  field, va_arg (argp, double),   comment);
    57   if (!strcmp (mode, "%lf")) snprintf (string, 81, "%-8s= %20.10f / %-s ",  field, va_arg (argp, double),   comment);
    58   if (!strcmp (mode, "%e"))  snprintf (string, 81, "%-8s= %20.10E / %-s ",  field, va_arg (argp, double),   comment);
    59   if (!strcmp (mode, "%le")) snprintf (string, 81, "%-8s= %20.10E / %-s ",  field, va_arg (argp, double),   comment);
    60   if (!strcmp (mode, "%g"))  snprintf (string, 81, "%-8s= %20.10G / %-s ",  field, va_arg (argp, double),   comment);
    61   if (!strcmp (mode, "%lg")) snprintf (string, 81, "%-8s= %20.10G / %-s ",  field, va_arg (argp, double),   comment);
     53  if (!strcmp (mode, "%d"))   snprintf (string, 81, "%-8s= %20d / %-s ",    field, va_arg (argp, int),                comment);
     54  if (!strcmp (mode, "%ld"))  snprintf (string, 81, "%-8s= %20ld / %-s ",   field, va_arg (argp, long),               comment);
     55  if (!strcmp (mode, "%lld")) snprintf (string, 81, "%-8s= %20lld / %-s ",  field, va_arg (argp, long long),          comment);
     56  if (!strcmp (mode, "%Ld"))  snprintf (string, 81, "%-8s= %20lld / %-s ",  field, va_arg (argp, long long),          comment);
     57  if (!strcmp (mode, "%u"))   snprintf (string, 81, "%-8s= %20u / %-s ",    field, va_arg (argp, unsigned),           comment);
     58  if (!strcmp (mode, "%lu"))  snprintf (string, 81, "%-8s= %20lu / %-s ",   field, va_arg (argp, unsigned long),      comment);
     59  if (!strcmp (mode, "%llu")) snprintf (string, 81, "%-8s= %20llu / %-s ",  field, va_arg (argp, unsigned long long), comment);
     60  if (!strcmp (mode, "%Lu"))  snprintf (string, 81, "%-8s= %20llu / %-s ",  field, va_arg (argp, unsigned long long), comment);
     61  if (!strcmp (mode, "%hd"))  snprintf (string, 81, "%-8s= %20d / %-s ",    field, va_arg (argp, int),                comment);
     62  if (!strcmp (mode, "%f"))   snprintf (string, 81, "%-8s= %20.10f / %-s ", field, va_arg (argp, double),             comment);
     63  if (!strcmp (mode, "%lf"))  snprintf (string, 81, "%-8s= %20.10f / %-s ", field, va_arg (argp, double),             comment);
     64  if (!strcmp (mode, "%e"))   snprintf (string, 81, "%-8s= %20.10E / %-s ", field, va_arg (argp, double),             comment);
     65  if (!strcmp (mode, "%le"))  snprintf (string, 81, "%-8s= %20.10E / %-s ", field, va_arg (argp, double),             comment);
     66  if (!strcmp (mode, "%g"))   snprintf (string, 81, "%-8s= %20.10G / %-s ", field, va_arg (argp, double),             comment);
     67  if (!strcmp (mode, "%lg"))  snprintf (string, 81, "%-8s= %20.10G / %-s ", field, va_arg (argp, double),             comment);
     68
     69  /* string value.  Quotes must be at least 18 chars apart */
     70  if (!strcmp (mode, "%s")) {
     71    strncpy (data, va_arg (argp, char *), 68);
     72    snprintf (string, 81, "%-8s= '%-18s' / %-s ", field, data, comment);
     73  }
     74
     75  strncpy (p, string, 80);
     76  va_end (argp);
     77  return (TRUE);
     78
     79}
     80
     81// alternate version for the special types (boolean, comments, COMMENT)
     82int gfits_modify_alt (Header *header, char *field, char *mode, int N,...) {
     83 
     84  /* this function expects one more argument, the value to be written */
     85  /* this function is extremely similar to gfits_print, except it allows for changing an existing field. */
     86
     87  char comment[82], string[82], data[82];
     88  char *p, *qs, *qe;
     89  va_list argp;
     90 
     91  va_start (argp, N);
     92  bzero (data, 82);
     93  bzero (string, 82);
     94  bzero (comment, 82);
     95
     96  if (mode[0] != '%') {
     97    fprintf (stderr, "gfits_print: weird mode:  %s\n", mode);
     98    return (FALSE);
     99  }
     100
     101  /* find location of desired entry */
     102  p = gfits_header_field (header, field, N);
     103  if (p == NULL)  {
     104    /* new entry, find the END of the header */
     105    p = gfits_header_field (header, "END", 1);
     106    if (p == NULL) return (FALSE);
     107   
     108    /* is there enough space for 1 more line? */
     109    if (header[0].datasize - (p - (header[0].buffer)) < 2*FT_LINE_LENGTH) {
     110      header[0].datasize += FT_RECORD_SIZE;
     111      REALLOCATE (header[0].buffer, char, header[0].datasize);
     112      p = gfits_header_field (header, "END", 1);
     113      if (p == NULL) return (FALSE);
     114      memset (p + FT_LINE_LENGTH, ' ', FT_RECORD_SIZE);
     115    }
     116   
     117    /* push END line back 1 */
     118    memmove ((p + FT_LINE_LENGTH), p, FT_LINE_LENGTH);
     119    memset (p, ' ', FT_LINE_LENGTH);
     120  } else {
     121    /* old entry, save the comment region (is this skipping a character for non-strings?) */
     122    qe = gfits_keyword_end (p);
     123    qe += 3;
     124    qe = MIN (p + 80, qe);
     125    strncpy (comment, qe, p + 80 - qe);
     126  }
     127  gfits_pad_ending (comment, ' ', 82);  /* comment must contain spaces to the end */
    62128
    63129  /* write the boolean mode */
    … …  
    67133    else
    68134      snprintf (string, 81, "%-8s= %18s F / %-s ", field, " ", comment);
    69   }
    70 
    71   /* string value.  Quotes must be at least 18 chars apart */
    72   if (!strcmp (mode, "%s")) {
    73     strncpy (data, va_arg (argp, char *), 68);
    74     snprintf (string, 81, "%-8s= '%-18s' / %-s ", field, data, comment);
    75135  }
    76136

  • trunk/Ohana/src/libfits/header/F_print.c

    r7054 r27435  
    22# include <gfitsio.h>
    33
     4// this only prints the regular and non-boolean fields
    45int gfits_print (Header *header, char *field, char *mode, int N,...) {
     6 
     7  /* this function expects one more argument, the value to be written */
     8
     9  static char blank[] = " ";
     10  char string[82], line[80];
     11  char *p;
     12  va_list argp; 
     13
     14  va_start (argp, N);
     15 
     16  if (mode[0] != '%') {
     17    fprintf (stderr, "gfits_print: weird mode:  %s\n", mode);
     18    return (FALSE);
     19  }
     20
     21  /* this is supposed to create a new field, not modify an old one.  */
     22  p = gfits_header_field (header, field, N);
     23  if (p != NULL) return (FALSE);
     24
     25  /* find the END of the header */
     26  p = gfits_header_field (header, "END", 1);
     27  if (p == NULL) return (FALSE);
     28
     29  /* is there enough space for 1 more line? */
     30  if (header[0].datasize - (p - (header[0].buffer)) < 2*FT_LINE_LENGTH) {
     31    header[0].datasize += FT_RECORD_SIZE;
     32    REALLOCATE (header[0].buffer, char, header[0].datasize);
     33    /* re-find the "END" marker, in case new memory block is used */
     34    p = gfits_header_field (header, "END", 1);
     35    if (p == NULL) return (FALSE);
     36    memset (p + FT_LINE_LENGTH, ' ', FT_RECORD_SIZE);
     37  }
     38
     39  /* push END line back 1 */
     40  memmove ((p + FT_LINE_LENGTH), p, FT_LINE_LENGTH);
     41  memset (p, ' ', FT_LINE_LENGTH);
     42
     43  /* write the new FITS card, setting the comment to be blank */
     44  /* in these lines, the value field will expand as needed, forcing out the comment
     45     the total line is limited by snprintf to only 80 chars + EOL */
     46
     47  /* write the numeric modes */
     48  if (!strcmp (mode, "%d"))  { snprintf (string, 81, "%-8s= %20d / %46s ",    field, va_arg (argp, int),                blank); }
     49  if (!strcmp (mode, "%ld")) { snprintf (string, 81, "%-8s= %20ld / %46s ",   field, va_arg (argp, long),               blank); }
     50  if (!strcmp (mode, "%lld")){ snprintf (string, 81, "%-8s= %20lld / %46s ",  field, va_arg (argp, long long),          blank); }
     51  if (!strcmp (mode, "%Ld")) { snprintf (string, 81, "%-8s= %20lld / %46s ",  field, va_arg (argp, long long),          blank); }
     52  if (!strcmp (mode, "%u"))  { snprintf (string, 81, "%-8s= %20u / %46s ",    field, va_arg (argp, unsigned),           blank); }
     53  if (!strcmp (mode, "%lu")) { snprintf (string, 81, "%-8s= %20lu / %46s ",   field, va_arg (argp, unsigned long),      blank); }
     54  if (!strcmp (mode, "%llu")){ snprintf (string, 81, "%-8s= %20llu / %46s ",  field, va_arg (argp, unsigned long long), blank); }
     55  if (!strcmp (mode, "%Lu")) { snprintf (string, 81, "%-8s= %20llu / %46s ",  field, va_arg (argp, unsigned long long), blank); }
     56  if (!strcmp (mode, "%hd")) { snprintf (string, 81, "%-8s= %20d / %46s ",    field, va_arg (argp, int),                blank); }
     57  if (!strcmp (mode, "%f"))  { snprintf (string, 81, "%-8s= %20.10f / %46s ", field, va_arg (argp, double),             blank); }
     58  if (!strcmp (mode, "%lf")) { snprintf (string, 81, "%-8s= %20.10f / %46s ", field, va_arg (argp, double),             blank); }
     59  if (!strcmp (mode, "%e"))  { snprintf (string, 81, "%-8s= %20.10E / %46s ", field, va_arg (argp, double),             blank); }
     60  if (!strcmp (mode, "%le")) { snprintf (string, 81, "%-8s= %20.10E / %46s ", field, va_arg (argp, double),             blank); }
     61  if (!strcmp (mode, "%g"))  { snprintf (string, 81, "%-8s= %20.10G / %46s ", field, va_arg (argp, double),             blank); }
     62  if (!strcmp (mode, "%lg")) { snprintf (string, 81, "%-8s= %20.10G / %46s ", field, va_arg (argp, double),             blank); }
     63
     64  /* string value.  Quotes must be at least 18 chars apart.  Longer lines will this should be fixed to allow arbitrary string lengths, up to 69 chars */
     65  if (!strcmp (mode, "%s")) {
     66    strcpy (line, va_arg (argp, char *));
     67    line[68] = 0;
     68    snprintf (string, 81, "%-8s= '%-18s' / %46s ", field, line, blank);
     69  }
     70
     71  strncpy (p, string, 80);
     72 
     73  va_end (argp);
     74  return (TRUE);
     75
     76}
     77
     78// alternate version for the special types (boolean, comments, COMMENT)
     79int gfits_print_alt (Header *header, char *field, char *mode, int N,...) {
    580 
    681  /* this function expects one more argument, the value to be written */
    … …  
    27102
    28103  /* is there enough space for 1 more line? */
    29   if (header[0].size - (p - (header[0].buffer)) < 2*FT_LINE_LENGTH) {
    30     header[0].size += FT_RECORD_SIZE;
    31     REALLOCATE (header[0].buffer, char, header[0].size);
     104  if (header[0].datasize - (p - (header[0].buffer)) < 2*FT_LINE_LENGTH) {
     105    header[0].datasize += FT_RECORD_SIZE;
     106    REALLOCATE (header[0].buffer, char, header[0].datasize);
    32107    /* re-find the "END" marker, in case new memory block is used */
    33108    p = gfits_header_field (header, "END", 1);
    … …  
    40115  memset (p, ' ', FT_LINE_LENGTH);
    41116
    42   /* write the new FITS card, setting the comment to be blank */
    43   /* in these lines, the value field will expand as needed, forcing out the comment
    44      the total line is limited by snprintf to only 80 chars + EOL */
    45 
    46   /* write the numeric modes */
    47   if (!strcmp (mode, "%d"))  { snprintf (string, 81, "%-8s= %20d / %46s ",    field, va_arg (argp, int),      blank); }
    48   if (!strcmp (mode, "%u"))  { snprintf (string, 81, "%-8s= %20d / %46s ",    field, va_arg (argp, unsigned), blank); }
    49   if (!strcmp (mode, "%ld")) { snprintf (string, 81, "%-8s= %20ld / %46s ",   field, va_arg (argp, long),     blank); }
    50   if (!strcmp (mode, "%hd")) { snprintf (string, 81, "%-8s= %20d / %46s ",    field, va_arg (argp, int),      blank); }
    51   if (!strcmp (mode, "%f"))  { snprintf (string, 81, "%-8s= %20.10f / %46s ", field, va_arg (argp, double),   blank); }
    52   if (!strcmp (mode, "%lf")) { snprintf (string, 81, "%-8s= %20.10f / %46s ", field, va_arg (argp, double),   blank); }
    53   if (!strcmp (mode, "%e"))  { snprintf (string, 81, "%-8s= %20.10E / %46s ", field, va_arg (argp, double),   blank); }
    54   if (!strcmp (mode, "%le")) { snprintf (string, 81, "%-8s= %20.10E / %46s ", field, va_arg (argp, double),   blank); }
    55   if (!strcmp (mode, "%g"))  { snprintf (string, 81, "%-8s= %20.10G / %46s ", field, va_arg (argp, double),   blank); }
    56   if (!strcmp (mode, "%lg")) { snprintf (string, 81, "%-8s= %20.10G / %46s ", field, va_arg (argp, double),   blank); }
    57 
    58117  /* write the boolean mode */
    59118  if (!strcmp (mode, "%t")) {
    … …  
    63122    else
    64123      snprintf (string, 81, "%-8s= %18s F / %46s ", field, blank, blank);
    65   }
    66 
    67   /* string value.  Quotes must be at least 18 chars apart.  Longer lines will this should be fixed to allow arbitrary string lengths, up to 69 chars */
    68   if (!strcmp (mode, "%s")) {
    69     strcpy (line, va_arg (argp, char *));
    70     line[68] = 0;
    71     snprintf (string, 81, "%-8s= '%-18s' / %46s ", field, line, blank);
    72124  }
    73125

  • trunk/Ohana/src/libfits/header/F_read_H.c

    r15904 r27435  
    2323int gfits_load_header (FILE *f, Header *header) {
    2424
    25   int i, done, Nbytes, t1, t2;
     25  off_t i, Nbytes;
     26  int done, t1, t2;
    2627  char *p;
    2728
    28   header[0].size = 0;
     29  header[0].datasize = 0;
    2930  done = FALSE;
    3031  ALLOCATE (header[0].buffer, char, 1);
    … …  
    3233  for (i = 0; !done; i++) {
    3334    REALLOCATE (header[0].buffer, char, (i + 1)*FT_RECORD_SIZE);
    34     Nbytes = fread (&header[0].buffer[i*FT_RECORD_SIZE],
    35                     sizeof(char), FT_RECORD_SIZE, f);
     35    Nbytes = fread (&header[0].buffer[i*FT_RECORD_SIZE], sizeof(char), FT_RECORD_SIZE, f);
    3636    if (Nbytes != FT_RECORD_SIZE) {
    3737      if (feof(f)) return (FALSE);
    … …  
    4040    }
    4141   
    42     header[0].size += Nbytes;
     42    header[0].datasize += Nbytes;
    4343
    4444    if (i == 0) {
    … …  
    6060    header[0].Naxis[i] = 0;
    6161
    62   gfits_scan (header,  "SIMPLE", "%t",   1, &header[0].simple);
     62  gfits_scan_alt (header,  "SIMPLE", "%t",   1, &header[0].simple);
    6363  gfits_scan (header,  "BITPIX", "%d",   1, &header[0].bitpix);
    6464  gfits_scan (header,  "NAXIS",  "%d",   1, &header[0].Naxes);
    6565                                                           
    66   gfits_scan (header,  "EXTEND", "%t",   1, &header[0].extend);
    67   gfits_scan (header,  "UNSIGN", "%t",   1, &header[0].unsign);
     66  gfits_scan_alt (header,  "EXTEND", "%t",   1, &header[0].extend);
     67  gfits_scan_alt (header,  "UNSIGN", "%t",   1, &header[0].unsign);
    6868  gfits_scan (header,  "BSCALE", "%lf",  1, &header[0].bscale);
    6969  gfits_scan (header,  "BZERO",  "%lf",  1, &header[0].bzero);
    7070                                       
    71   gfits_scan (header,  "NAXIS1", "%d", 1, &header[0].Naxis[0]);
    72   gfits_scan (header,  "NAXIS2", "%d", 1, &header[0].Naxis[1]);
    73   gfits_scan (header,  "NAXIS3", "%d", 1, &header[0].Naxis[2]);
    74   gfits_scan (header,  "NAXIS4", "%d", 1, &header[0].Naxis[3]);
    75   gfits_scan (header,  "NAXIS5", "%d", 1, &header[0].Naxis[4]);
    76   gfits_scan (header,  "NAXIS6", "%d", 1, &header[0].Naxis[5]);
    77   gfits_scan (header,  "NAXIS7", "%d", 1, &header[0].Naxis[6]);
    78   gfits_scan (header,  "NAXIS8", "%d", 1, &header[0].Naxis[7]);
    79   gfits_scan (header,  "NAXIS9", "%d", 1, &header[0].Naxis[8]);
    80   gfits_scan (header, "NAXIS10", "%d", 1, &header[0].Naxis[9]);
     71  gfits_scan (header,  "NAXIS1", "%lld", 1, (long long *) &header[0].Naxis[0]);
     72  gfits_scan (header,  "NAXIS2", "%lld", 1, (long long *) &header[0].Naxis[1]);
     73  gfits_scan (header,  "NAXIS3", "%lld", 1, (long long *) &header[0].Naxis[2]);
     74  gfits_scan (header,  "NAXIS4", "%lld", 1, (long long *) &header[0].Naxis[3]);
     75  gfits_scan (header,  "NAXIS5", "%lld", 1, (long long *) &header[0].Naxis[4]);
     76  gfits_scan (header,  "NAXIS6", "%lld", 1, (long long *) &header[0].Naxis[5]);
     77  gfits_scan (header,  "NAXIS7", "%lld", 1, (long long *) &header[0].Naxis[6]);
     78  gfits_scan (header,  "NAXIS8", "%lld", 1, (long long *) &header[0].Naxis[7]);
     79  gfits_scan (header,  "NAXIS9", "%lld", 1, (long long *) &header[0].Naxis[8]);
     80  gfits_scan (header, "NAXIS10", "%lld", 1, (long long *) &header[0].Naxis[9]);
    8181
    8282  if (!gfits_scan (header, "PCOUNT",  "%d", 1, &header[0].pcount)) {

  • trunk/Ohana/src/libfits/header/F_read_XH.c

    r19250 r27435  
    3131  /* read header for extension number N */
    3232
    33   int j, Nmatrix, Nskip;
     33  int j;
     34  off_t Nmatrix, Nskip;
    3435  Header theader;
    3536 
    3637  /* set f to beginning of file */
    37   fseek (f, 0, SEEK_SET);
     38  fseeko (f, 0, SEEK_SET);
    3839
    3940  Nskip = 0;
    … …  
    4748
    4849    /* skip to next header */
    49     fseek (f, Nmatrix, SEEK_CUR);
    50     Nskip += (Nmatrix + theader.size);
     50    fseeko (f, Nmatrix, SEEK_CUR);
     51    Nskip += (Nmatrix + theader.datasize);
    5152    gfits_free_header (&theader);
    5253  }
    … …  
    5556    return (FALSE);
    5657  }
    57   Nskip += header[0].size;
     58  Nskip += header[0].datasize;
    5859  return (Nskip);
    5960}       

  • trunk/Ohana/src/libfits/header/F_scan.c

    r21059 r27435  
    22# include <gfitsio.h>
    33
     4// this only scans the regular and non-boolean fields
    45int gfits_scan (Header *header, char *field, char *mode, int N,...) {
    56
    … …  
    1314}
    1415 
     16// alternate version for the special types (boolean, comments, COMMENT)
     17int gfits_scan_alt (Header *header, char *field, char *mode, int N,...) {
     18
     19  int status;
     20  va_list argp;
     21 
     22  va_start (argp, N);
     23  status = gfits_vscan_alt (header, field, mode, N, argp);
     24  va_end (argp);
     25  return (status);
     26}
     27 
     28// this only scans the regular and non-boolean fields
    1529int gfits_vscan (Header *header, char *field, char *mode, int N, va_list argp) {
    1630
    1731  char *p, *q, *s, tmp[81];
    1832  int Nchar, status;
    19   double value;
     33  long long value;
     34  double fvalue;
    2035 
    2136  /* find the correct line with field */
    … …  
    2641  }
    2742
     43  /* all others require '=' in column 8 */
     44  if (p[8] != '=') return (FALSE);
     45
     46  /* extract data into char array (exclude containing ' chars) */
     47  if (!strcmp (mode, "%s")) {
     48    s = gfits_keyword_start (p); /* points at first char (not ') */
     49    q = gfits_keyword_end (p); /* points at following space or ' */
     50
     51    Nchar = MAX (0, (q - s));
     52    bzero (tmp, 81);
     53    memcpy (tmp, s, Nchar);
     54    stripwhite (tmp);
     55    strcpy (va_arg (argp, char *), tmp);
     56    return (TRUE);
     57  }
     58 
     59  /* remaining options are numerical data */
     60  /* need to interpret 1.0d5 as 1.0e5 */
     61  s = gfits_keyword_start (p); /* points at first char (not ') */
     62  q = gfits_keyword_end (p); /* points at following space or ' */
     63
     64  if (!strcmp (mode, "%f") || !strcmp (mode, "%lf")) {
     65    fvalue = strtod (s, &q);
     66    if ((*q == 'd') || (*q == 'D'))
     67      fvalue *= pow (10.0, atof (q + 1));
     68
     69    if (!strcmp (mode, "%f"))   { *va_arg (argp, float *)  = fvalue; return (TRUE); }
     70    if (!strcmp (mode, "%lf"))  { *va_arg (argp, double *) = fvalue; return (TRUE); }
     71  }
     72
     73  value = strtoll (s, &q, 0);
     74  if ((*q == 'd') || (*q == 'D')) value *= pow (10.0, atof (q + 1));
     75
     76  if (!strcmp (mode, "%d"))   { *va_arg (argp, int *)                = value; return (TRUE); }
     77  if (!strcmp (mode, "%ld"))  { *va_arg (argp, long *)               = value; return (TRUE); }
     78  if (!strcmp (mode, "%lld")) { *va_arg (argp, long long *)          = value; return (TRUE); }
     79  if (!strcmp (mode, "%Ld"))  { *va_arg (argp, long long *)          = value; return (TRUE); }
     80  if (!strcmp (mode, "%u"))   { *va_arg (argp, unsigned *)           = value; return (TRUE); }
     81  if (!strcmp (mode, "%lu"))  { *va_arg (argp, unsigned long *)      = value; return (TRUE); }
     82  if (!strcmp (mode, "%llu")) { *va_arg (argp, unsigned long long *) = value; return (TRUE); }
     83  if (!strcmp (mode, "%Lu"))  { *va_arg (argp, unsigned long long *) = value; return (TRUE); }
     84  if (!strcmp (mode, "%hd"))  { *va_arg (argp, short *)              = value; return (TRUE); }
     85
     86  /* no valid mode found */
     87  return (FALSE);
     88}
     89
     90// alternate version for the special types (boolean, comments, COMMENT)
     91int gfits_vscan_alt (Header *header, char *field, char *mode, int N, va_list argp) {
     92
     93  char *p, *q, *s, tmp[81];
     94  int Nchar, status;
     95
     96  /* find the correct line with field */
     97  p = gfits_header_field (header, field, N);
     98  if (p == NULL) {
     99    status = gfits_vscan_hierarch (header, field, mode, N, argp);
     100    return (status);
     101  }
     102
    28103  /* non-data entry (COMMENT, HISTORY) */
    29104  if (!strcmp (mode, "%S")) {
    … …  
    47122  }
    48123
    49   /* extract data into char array (exclude containing ' chars) */
    50   if (!strcmp (mode, "%s")) {
    51     s = gfits_keyword_start (p); /* points at first char (not ') */
    52     q = gfits_keyword_end (p); /* points at following space or ' */
    53 
    54     Nchar = MAX (0, (q - s));
    55     bzero (tmp, 81);
    56     memcpy (tmp, s, Nchar);
    57     stripwhite (tmp);
    58     strcpy (va_arg (argp, char *), tmp);
    59     return (TRUE);
    60   }
    61  
    62124  /* boolean data, requires int target */
    63125  if (!strcmp (mode, "%t")) {
    … …  
    73135  }
    74136
    75   /* remaining options are numerical data */
    76   /* need to interpret 1.0d5 as 1.0e5 */
    77   s = gfits_keyword_start (p); /* points at first char (not ') */
    78   q = gfits_keyword_end (p); /* points at following space or ' */
    79   value = strtod (s, &q);
    80   if ((*q == 'd') || (*q == 'D'))
    81     value *= pow (10.0, atof (q + 1));
    82 
    83   if (!strcmp (mode, "%d"))  { *va_arg (argp, int *)       = value; return (TRUE); }
    84   if (!strcmp (mode, "%u"))  { *va_arg (argp, unsigned *)  = value; return (TRUE); }
    85   if (!strcmp (mode, "%ld")) { *va_arg (argp, long *)      = value; return (TRUE); }
    86   if (!strcmp (mode, "%hd")) { *va_arg (argp, short *)     = value; return (TRUE); }
    87   if (!strcmp (mode, "%f"))  { *va_arg (argp, float *)     = value; return (TRUE); }
    88   if (!strcmp (mode, "%lf")) { *va_arg (argp, double *)    = value; return (TRUE); }
    89 
    90137  /* no valid mode found */
    91138  return (FALSE);
    … …  
    97144  char *p, *q, *s, tmp[81];
    98145  int Nchar, Nfield;
    99   double value;
     146  long long value;
     147  double fvalue;
    100148 
    101149  /* find the correct line with field */
    … …  
    156204  s = gfits_hierarch_keyword_start (p, field); /* points at first char (not ') */
    157205  q = gfits_hierarch_keyword_end (p, field); /* points at following space or ' */
    158   value = strtod (s, &q);
    159   if ((*q == 'd') || (*q == 'D'))
    160     value *= pow (10.0, atof (q + 1));
    161 
    162   if (!strcmp (mode, "%d"))  { *va_arg (argp, int *)       = value; return (TRUE); }
    163   if (!strcmp (mode, "%u"))  { *va_arg (argp, unsigned *)  = value; return (TRUE); }
    164   if (!strcmp (mode, "%ld")) { *va_arg (argp, long *)      = value; return (TRUE); }
    165   if (!strcmp (mode, "%hd")) { *va_arg (argp, short *)     = value; return (TRUE); }
    166   if (!strcmp (mode, "%f"))  { *va_arg (argp, float *)     = value; return (TRUE); }
    167   if (!strcmp (mode, "%lf")) { *va_arg (argp, double *)    = value; return (TRUE); }
     206
     207  if (!strcmp (mode, "%f") || !strcmp (mode, "%lf")) {
     208    fvalue = strtod (s, &q);
     209    if ((*q == 'd') || (*q == 'D'))
     210      fvalue *= pow (10.0, atof (q + 1));
     211
     212    if (!strcmp (mode, "%f"))   { *va_arg (argp, float *)  = fvalue; return (TRUE); }
     213    if (!strcmp (mode, "%lf"))  { *va_arg (argp, double *) = fvalue; return (TRUE); }
     214  }
     215
     216  value = strtoll (s, &q, 0);
     217  if ((*q == 'd') || (*q == 'D')) value *= pow (10.0, atof (q + 1));
     218
     219  if (!strcmp (mode, "%d"))   { *va_arg (argp, int *)                = value; return (TRUE); }
     220  if (!strcmp (mode, "%ld"))  { *va_arg (argp, long *)               = value; return (TRUE); }
     221  if (!strcmp (mode, "%lld")) { *va_arg (argp, long long *)          = value; return (TRUE); }
     222  if (!strcmp (mode, "%Ld"))  { *va_arg (argp, long long *)          = value; return (TRUE); }
     223  if (!strcmp (mode, "%u"))   { *va_arg (argp, unsigned *)           = value; return (TRUE); }
     224  if (!strcmp (mode, "%lu"))  { *va_arg (argp, unsigned long *)      = value; return (TRUE); }
     225  if (!strcmp (mode, "%llu")) { *va_arg (argp, unsigned long long *) = value; return (TRUE); }
     226  if (!strcmp (mode, "%Lu"))  { *va_arg (argp, unsigned long long *) = value; return (TRUE); }
     227  if (!strcmp (mode, "%hd"))  { *va_arg (argp, short *)              = value; return (TRUE); }
    168228
    169229  /* no valid mode found */

  • trunk/Ohana/src/libfits/header/F_write_H.c

    r7054 r27435  
    66
    77  FILE *f;
    8   int Nbytes, status;
     8  off_t Nbytes;
     9  int status;
    910 
    1011  status = TRUE;
    … …  
    1314  if (f == (FILE *) NULL) return (FALSE);
    1415
    15   Nbytes = fwrite (header[0].buffer, sizeof(char), header[0].size, f);
     16  Nbytes = fwrite (header[0].buffer, sizeof(char), header[0].datasize, f);
    1617
    17   if (Nbytes != header[0].size) {
     18  if (Nbytes != header[0].datasize) {
    1819    status = FALSE;
    1920  }
    … …  
    2728int gfits_save_header (FILE *f, Header *header) {
    2829
    29   int Nbytes, status;
     30  off_t Nbytes;
     31  int status;
    3032 
    3133  status = TRUE;
    3234
    33   Nbytes = fwrite (header[0].buffer, sizeof(char), header[0].size, f);
     35  Nbytes = fwrite (header[0].buffer, sizeof(char), header[0].datasize, f);
    3436
    35   if (Nbytes != header[0].size) {
     37  if (Nbytes != header[0].datasize) {
    3638    status = FALSE;
    3739  }

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

    r21059 r27435  
    4444
    4545typedef struct {
    46   int                     simple;
    47   int                     unsign;
    48   int                     extend;
    49   int                     bitpix;
    50   int                     Naxes;
    51   int                     Naxis[FT_MAX_NAXES];
    52   int                     size;
     46  int                     simple; // T or F
     47  int                     unsign; // T or F
     48  int                     extend; // T or F
     49  int                     bitpix; // 8, 16, 32, 64, or -32, -64
     50  int                     Naxes;  // < FT_MAX_NAXES (10)
     51  off_t                   Naxis[FT_MAX_NAXES];
     52  off_t                   datasize;
    5353  int                     pcount;
    5454  int                     gcount;
    … …  
    6565  int                     bitpix;
    6666  int                     Naxes;
    67   int                     Naxis[FT_MAX_NAXES];
    68   int                     size;
     67  off_t                   Naxis[FT_MAX_NAXES];
     68  off_t                   datasize;
    6969  double                  bzero;
    7070  double                  bscale;
    … …  
    7676  Header                 *header;
    7777  char                   *buffer;
    78   int                     size;
     78  off_t                   datasize;
    7979} FTable;
    8080
    … …  
    8383  Header                 *header;
    8484  char                  **buffer;
    85   int                     Nrow;
    86   int                    *row;
    87   int                     size;  /* total buffer size */
    88   int                     pad;   /* bytes of padding at the end */
     85  off_t                   Nrow;
     86  off_t                  *row;
     87  off_t                   datasize;  /* total buffer size */
     88  off_t                   pad;   /* bytes of padding at the end */
    8989} VTable;
    9090
    9191typedef struct {
    92   int  maxlen;                // max size of all table rows
    93   int  nbytes;                // number of bytes per column element
    94   int  Nstart;                // byte offset of this column
    95   int  heap_start;            // byte offset to start of HEAP
    96   char format;                // data format character (one of: XLABIJEDCM)
     92  int   maxlen;               // max size of all table rows
     93  int   nbytes;               // number of bytes per column element
     94  int   Nstart;               // byte offset of this column relative to first column
     95  off_t heap_start;           // byte offset to start of HEAP
     96  char  format;               // data format character (one of: XLABIJEDCM)
     97  char  mode;                 // access data pointer type (one of P or Q)
    9798} VarLengthColumn;
    9899
    … …  
    106107
    107108char   *gfits_header_field             PROTO((Header *header, char *field, int N));
    108 char   *gfits_header_lineno            PROTO((Header *header, int N));
     109char   *gfits_header_lineno            PROTO((Header *header, off_t N));
    109110char   *gfits_keyword_end              PROTO((char *line));
    110111int     gfits_copy_header              PROTO((Header *in, Header *out));
    … …  
    118119int     gfits_init_header              PROTO((Header *header));
    119120int     gfits_load_header              PROTO((FILE *f, Header *header));
    120 int     gfits_modify                   PROTO((Header *header, char *field, char *mode, int N,...));
    121 int     gfits_print                    PROTO((Header *header, char *field, char *mode, int N,...));
     121int     gfits_modify                   PROTO((Header *header, char *field, char *mode, int N,...)) OHANA_FORMAT(printf, 3, 5);
     122int     gfits_print                    PROTO((Header *header, char *field, char *mode, int N,...)) OHANA_FORMAT(printf, 3, 5);
     123int     gfits_modify_alt               PROTO((Header *header, char *field, char *mode, int N,...));
     124int     gfits_print_alt                PROTO((Header *header, char *field, char *mode, int N,...));
    122125int     gfits_read_Xheader             PROTO((char *filename, Header *header, int N));
    123126int     gfits_read_header              PROTO((char *filename, Header *header));
    124127int     gfits_save_header              PROTO((FILE *f, Header *header));
    125 int     gfits_scan                     PROTO((Header *header, char *field, char *mode, int N,...));
     128int     gfits_scan                     PROTO((Header *header, char *field, char *mode, int N,...)) OHANA_FORMAT(scanf, 3, 5);
     129int     gfits_scan_alt                 PROTO((Header *header, char *field, char *mode, int N,...));
    126130int     gfits_set_unsign_mode          PROTO((int mode));
    127131int     gfits_stripwhite               PROTO((char *string));
    128132int     gfits_vscan                    PROTO((Header *header, char *field, char *mode, int N, va_list argp));
     133int     gfits_vscan_alt                PROTO((Header *header, char *field, char *mode, int N, va_list argp));
    129134int     gfits_write_header             PROTO((char *filename, Header *header));
    130 int     gfits_data_size                PROTO((Header *header));
    131 int     gfits_data_min_size            PROTO((Header *header));
     135off_t   gfits_data_size                PROTO((Header *header));
     136off_t   gfits_data_min_size            PROTO((Header *header));
    132137int     gfits_extended_to_primary      PROTO((Header *header, int simple, char *comment));
    133138int     gfits_primary_to_extended      PROTO((Header *header, char *exttype, char *comment));
    … …  
    143148/******************************* Matrix functions *************/
    144149
    145 void    gfits_add_matrix_value         PROTO((Matrix *matrix, int x, int y, double value));
     150void    gfits_add_matrix_value         PROTO((Matrix *matrix, off_t x, off_t y, double value));
    146151int     gfits_convert_format           PROTO((Header *header, Matrix *matrix, int outBitpix, double outScale, double outZero, int inBlank, int outUnsign));
    147152int     gfits_copy_matrix              PROTO((Matrix *in, Matrix *out));
    … …  
    152157void    gfits_free_matrix              PROTO((Matrix *matrix));
    153158int     gfits_fwrite_matrix            PROTO((FILE *f, Matrix *matrix));     
    154 double  gfits_get_matrix_value         PROTO((Matrix *matrix, int x, int y));
    155 void    gfits_insert_array             PROTO((Matrix *matrix, Matrix *array, int x, int y));
     159double  gfits_get_matrix_value         PROTO((Matrix *matrix, off_t x, off_t y));
     160void    gfits_insert_matrix            PROTO((Matrix *matrix, Matrix *array, off_t x, off_t y));
    156161int     gfits_load_matrix              PROTO((FILE *f, Matrix *matrix, Header *header));
    157162int     gfits_multiply_matrix          PROTO((Matrix *M1, Matrix *M2, Matrix *M3));
    158163int     gfits_read_matrix              PROTO((char *filename, Matrix *matrix));     
    159164int     gfits_read_matrix_segment      PROTO((char *filename, Matrix *matrix, char *region));
    160 int     gfits_read_portion             PROTO((char *filename, Matrix *matrix, int Nskip, int Npix));
    161 void    gfits_set_matrix_value         PROTO((Matrix *matrix, int x, int y, double value));
     165int     gfits_read_portion             PROTO((char *filename, Matrix *matrix, off_t Nskip, off_t Npix));
     166void    gfits_set_matrix_value         PROTO((Matrix *matrix, off_t x, off_t y, double value));
    162167int     gfits_write_matrix             PROTO((char *filename, Matrix *matrix));
    163168int     gfits_uncompress_image         PROTO((Header *header, Matrix *matrix, FTable *ftable));
    … …  
    166171int     gfits_byteswap_zdata           PROTO((char *zdata, int Nzdata, int bitpix));
    167172int     gfits_extension_is_compressed  PROTO((Header *header));
    168 int     gfits_tile_size                PROTO((Matrix *matrix, int *otile, int *ztile));
     173off_t   gfits_tile_size                PROTO((Matrix *matrix, int *otile, int *ztile));
    169174int     gfits_uncompressed_data_pixsize PROTO((char *cmptype, int out_bitpix, char **optname, char **optvalue, int Noptions));
    170175int     gfits_vartable_heap_pixsize    PROTO((char format));
    … …  
    173178
    174179char   *gfits_table_print              PROTO((FTable *ftable,...));
    175 int     gfits_add_rows                 PROTO((FTable *ftable, char *data, int Nrow, int Nbytes));
     180int     gfits_add_rows                 PROTO((FTable *ftable, char *data, off_t Nrow, off_t Nbytes));
    176181int     gfits_bintable_format          PROTO((char *format, char *type, int *Nval, int *Nbytes));
    177182int     gfits_create_table             PROTO((Header *header, FTable *ftable));
    … …  
    181186int     gfits_fread_ftable             PROTO((FILE *f, FTable *ftable, char *extname));
    182187int     gfits_fread_ftable_data        PROTO((FILE *f, FTable *ftable));
    183 int     gfits_fread_ftable_range       PROTO((FILE *f, FTable *ftable, int start, int Nrows));
    184 int     gfits_fread_vtable             PROTO((FILE *f, VTable *vtable, char *extname, int Nrow, int *row));
    185 int     gfits_fread_vtable_range       PROTO((FILE *f, VTable *vtable, int start, int Nrows));
     188int     gfits_fread_ftable_range       PROTO((FILE *f, FTable *ftable, off_t start, off_t Nrows));
     189int     gfits_fread_vtable             PROTO((FILE *f, VTable *vtable, char *extname, off_t Nrow, off_t *row));
     190int     gfits_fread_vtable_range       PROTO((FILE *f, VTable *vtable, off_t start, off_t Nrows));
    186191int     gfits_free_table               PROTO((FTable *ftable));
    187192int     gfits_free_vtable              PROTO((VTable *vtable));
    188193int     gfits_fwrite_table             PROTO((FILE *f, FTable *table));
    189194int     gfits_fwrite_vtable            PROTO((FILE *f, VTable *table));
    190 int     gfits_fwrite_ftable_range      PROTO((FILE *f, FTable *table, int start, int Nrows, int Ndisk, int Ntotal));
     195int     gfits_fwrite_ftable_range      PROTO((FILE *f, FTable *table, off_t start, off_t Nrows, off_t Ndisk, off_t Ntotal));
    191196int     gfits_get_bintable_column      PROTO((Header *header, FTable *table, char *label, void **data));
    192197int     gfits_get_bintable_column_type PROTO((Header *header, char *label, char *type, int *Nval));
    193 void   *gfits_get_bintable_column_data PROTO((Header *header, FTable *table, char *label, char *type, int *Nrow, int *Ncol));
     198void   *gfits_get_bintable_column_data PROTO((Header *header, FTable *table, char *label, char *type, off_t *Nrow, int *Ncol));
    194199int     gfits_get_table_column         PROTO((Header *header, FTable *table, char *label, void **data));
    195200int     gfits_get_table_column_type    PROTO((Header *header, char *label, char *type));
    196201int     gfits_read_ftable              PROTO((char *filename, FTable *table, char *extname));
    197202int     gfits_read_table               PROTO((char *filename, FTable *ftable));
    198 int     gfits_set_bintable_column      PROTO((Header *header, FTable *table, char *label, void *data, int Nrow));
    199 int     gfits_set_table_column         PROTO((Header *header, FTable *table, char *label, void *data, int Nrow));
    200 int     gfits_table_column             PROTO((FTable *ftable, char *field, char *mode,...));
     203int     gfits_set_bintable_column      PROTO((Header *header, FTable *table, char *label, void *data, off_t Nrow));
     204int     gfits_set_table_column         PROTO((Header *header, FTable *table, char *label, void *data, off_t Nrow));
     205int     gfits_table_column             PROTO((FTable *ftable, char *field, char *mode,...)) OHANA_FORMAT(printf, 3, 4);
    201206int     gfits_table_format             PROTO((char *format, char *type, int *Nval, int *Nbytes));
    202207int     gfits_table_scale_data         PROTO((FTable *ftable));
    203208int     gfits_table_scale_storage      PROTO((FTable *ftable));
    204 int     gfits_table_to_vtable          PROTO((FTable *ftable, VTable *vtable, int start, int Nkeep));
    205 int     gfits_vadd_rows                PROTO((VTable *vtable, char *data, int Nrow, int Nbytes));
    206 int     gfits_vtable_from_ftable       PROTO((FTable *ftable, VTable *vtable, int *row, int Nrow));
     209int     gfits_table_to_vtable          PROTO((FTable *ftable, VTable *vtable, off_t start, off_t Nkeep));
     210int     gfits_vadd_rows                PROTO((VTable *vtable, char *data, off_t Nrow, off_t Nbytes));
     211int     gfits_vtable_from_ftable       PROTO((FTable *ftable, VTable *vtable, off_t *row, off_t Nrow));
    207212int     gfits_write_table              PROTO((char *filename, FTable *ftable));
    208213
    … …  
    215220
    216221int     gfits_varlength_column_define  PROTO((FTable *ftable, VarLengthColumn *def, int column));
    217 void   *gfits_varlength_column_pointer PROTO((FTable *ftable, VarLengthColumn *column, int row, int *length));
     222void   *gfits_varlength_column_pointer PROTO((FTable *ftable, VarLengthColumn *column, off_t row, off_t *length));
    218223
    219224#endif /* FITSIO */

  • trunk/Ohana/src/libfits/matrix/F_add_M.c

    r7054 r27435  
    33
    44/*********************** fits insert array ***********************************/
    5 void gfits_add_matrix (matrix, array, x, y)
    6 Matrix *matrix, *array;
    7 int x, y;
     5void gfits_add_matrix (Matrix *matrix, Matrix *array, off_t x, off_t y)
    86{
    97
    … …  
    1513  if ((x + array[0].Naxis[0] > matrix[0].Naxis[0]) ||
    1614      (y + array[0].Naxis[1] > matrix[0].Naxis[1])) {
    17     fprintf (stderr, "can't add array here: (%d,%d) - (%d,%d) vs (%d,%d)\n",
    18              x, y, x + array[0].Naxis[0], y + array[0].Naxis[1],
    19              matrix[0].Naxis[0], matrix[0].Naxis[1]);
     15    fprintf (stderr, "can't add array here: (%lld,%lld) - (%lld,%lld) vs (%lld,%lld)\n",
     16             (long long) x,
     17             (long long) y,
     18             (long long) x + array[0].Naxis[0],
     19             (long long) y + array[0].Naxis[1],
     20             (long long) matrix[0].Naxis[0],
     21             (long long) matrix[0].Naxis[1]);
    2022    return;
    2123  }

  • trunk/Ohana/src/libfits/matrix/F_add_M_value.c

    r7054 r27435  
    33
    44/***************** fits add matrix value ***********************************/
    5 void gfits_add_matrix_value (matrix, x, y, Value)
    6 Matrix *matrix;
    7 int x, y;
    8 double Value;
     5void gfits_add_matrix_value (Matrix *matrix, off_t x, off_t y, double Value)
    96{
    107

  • trunk/Ohana/src/libfits/matrix/F_compress_M.c

    r23724 r27435  
    2424    gfits_delete (header, ZNAME, 1); }
    2525
     26# define MOD_KEYWORD_ALT(ZNAME,NAME,TYPE,IN,OUT) { \
     27    if (gfits_scan_alt (header, ZNAME, TYPE, 1, IN)) { \
     28      gfits_modify_alt (header, NAME, TYPE, 1, OUT); \
     29    } \
     30    gfits_delete (header, ZNAME, 1); }
     31
    2632# define MOD_KEYWORD_REQUIRED(ZNAME,NAME,TYPE,IN,OUT) { \
    2733  if (!gfits_scan (header, ZNAME, TYPE, 1, IN)) ESCAPE; \
    … …  
    3137int gfits_uncompress_image (Header *header, Matrix *matrix, FTable *ftable) {
    3238
    33   int i, j, status, zimage, zcol, Nzrows, Nout, Nzdata, max_tile_size;
     39  off_t Nzdata, Nzrows, zcol;
     40  int i, j, status, zimage, Nout, max_tile_size;
    3441  char cmptype[80];
    3542  char zaxis[10], naxis[10], key[10], word[81], exttype[81], checksum[81], datasum[81];
    … …  
    5158
    5259  // is ZIMAGE present?
    53   status = gfits_scan (ftable->header, "ZIMAGE", "%t", 1, &zimage);
     60  status = gfits_scan_alt (ftable->header, "ZIMAGE", "%t", 1, &zimage);
    5461  if (!status || !zimage) ESCAPE;
    5562
    … …  
    7077    snprintf (zaxis, 10, "ZNAXIS%d", i + 1);
    7178    snprintf (naxis, 10, "NAXIS%d", i + 1);
    72     MOD_KEYWORD_REQUIRED (zaxis,  naxis,  "%d", &header->Naxis[i], header->Naxis[i]);
     79    MOD_KEYWORD_REQUIRED (zaxis,  naxis,  "%lld", (long long *) &header->Naxis[i], (long long) header->Naxis[i]);
    7380  }   
    7481
    … …  
    118125  int have_ztension;
    119126
    120   have_zsimple  = gfits_scan (header, "ZSIMPLE", "%t", 1, &zsimple);
     127  have_zsimple  = gfits_scan_alt (header, "ZSIMPLE", "%t", 1, &zsimple);
    121128  have_ztension = gfits_scan (header, "ZTENSION", "%s", 1, exttype);
    122129
    … …  
    130137    gfits_extended_to_primary (header, header->simple, "Image data");
    131138
    132     MOD_KEYWORD ("ZEXTEND",  "EXTEND",   "%t", &header->extend, header->extend);
    133     MOD_KEYWORD ("ZBLOCKED", "BLOCKED",  "%t", &header->extend, header->extend);
     139    MOD_KEYWORD_ALT ("ZEXTEND",  "EXTEND",   "%t", &header->extend, header->extend);
     140    MOD_KEYWORD_ALT ("ZBLOCKED", "BLOCKED",  "%t", &header->extend, header->extend);
    134141  }
    135142
    … …  
    140147    gfits_extended_to_primary (header, header->simple, "Image data");
    141148
    142     MOD_KEYWORD ("ZEXTEND",  "EXTEND",   "%t", &header->extend, header->extend);
    143     MOD_KEYWORD ("ZBLOCKED", "BLOCKED",  "%t", &header->extend, header->extend);
     149    MOD_KEYWORD_ALT ("ZEXTEND",  "EXTEND",   "%t", &header->extend, header->extend);
     150    MOD_KEYWORD_ALT ("ZBLOCKED", "BLOCKED",  "%t", &header->extend, header->extend);
    144151  }
    145152
    … …  
    175182
    176183  zscale = 1;
    177   gfits_scan (header, "ZSCALE", "%lf", 1, &zscale);
     184  gfits_scan (header, "ZSCALE", "%f", 1, &zscale);
    178185
    179186  zblank = 32767;
    … …  
    184191
    185192  zzero = 0;
    186   gfits_scan (header, "ZZERO", "%lf", 1, &zzero);
     193  gfits_scan (header, "ZZERO", "%f", 1, &zzero);
    187194
    188195  // find the COMPRESSED_DATA column (format should be 1PB, 1PI, 1PJ)
    … …  
    196203  if (!gfits_varlength_column_define (ftable, &zdef, zcol)) ESCAPE;
    197204  gfits_delete (header, "TFIELDS", 1);
    198   snprintf (key, 10, "TTYPE%d", zcol);
     205  snprintf (key, 10, "TTYPE%lld", (long long) zcol);
    199206  gfits_delete (header, key, 1);
    200   snprintf (key, 10, "TFORM%d", zcol);
     207  snprintf (key, 10, "TFORM%lld", (long long) zcol);
    201208  gfits_delete (header, key, 1);
    202209
    … …  
    236243  ALLOCATE (out, char, odata_pixsize*max_tile_size);
    237244
     245  off_t row;
     246
    238247  // uncompress the data
    239248  Nzrows = ftable->header->Naxis[1];
    240   for (i = 0; i < Nzrows; i++) {
     249  for (row = 0; row < Nzrows; row++) {
    241250
    242251    // expected output size for this tile
    243252    Nout = gfits_tile_size (matrix, otile, ztile);
    244253
    245     zdata = gfits_varlength_column_pointer (ftable, &zdef, i, &Nzdata);
     254    zdata = gfits_varlength_column_pointer (ftable, &zdef, row, &Nzdata);
    246255    if (!zdata) return (FALSE);
    247256
    … …  
    254263
    255264    // gfits_uncompress_data uncompresses from zdata to the temporary output buffer which must be allocated
     265    // XXX the tile must not be > 2GB
    256266    if (!gfits_uncompress_data ((char *)zdata, Nzdata, cmptype, optname, optvalue, Noptions, out, &Nout, odata_pixsize)) return (FALSE);
    257267
    … …  
    284294
    285295// true sizes of this tile (in pixels)
    286 int gfits_tile_size (Matrix *matrix, int *otile, int *ztile) {
    287 
    288   int i, Npixels, Ndimen;
     296off_t gfits_tile_size (Matrix *matrix, int *otile, int *ztile) {
     297
     298  off_t i, Npixels, Ndimen;
    289299
    290300  Npixels = 1;
    … …  
    470480    has_extension = gfits_scan (header, "XTENSION", "%s", 1, extension);
    471481    has_extname = gfits_scan (header, "EXTNAME", "%s", 1, extname);
    472     has_zimage  = gfits_scan (header, "ZIMAGE", "%t", 1, &zimage);
     482    has_zimage  = gfits_scan_alt (header, "ZIMAGE", "%t", 1, &zimage);
    473483
    474484    if (has_extension && !strcmp (extension, "IMAGE")) return (FALSE);
    … …  
    486496    int ztension, zimage;
    487497
    488     has_zimage   = gfits_scan (header, "ZIMAGE",   "%t", 1, &zimage);
    489     has_ztension = gfits_scan (header, "ZTENSION", "%t", 1, &ztension);
     498    has_zimage   = gfits_scan_alt (header, "ZIMAGE",   "%t", 1, &zimage);
     499    has_ztension = gfits_scan_alt (header, "ZTENSION", "%t", 1, &ztension);
    490500
    491501    if (has_zimage && zimage) return (TRUE);

  • trunk/Ohana/src/libfits/matrix/F_convert_format.c

    r20652 r27435  
    2424      *out = *in*A + B;                                 \
    2525    }                                                   \
    26   REALLOCATE (matrix[0].buffer, char, matrix[0].size);
     26  REALLOCATE (matrix[0].buffer, char, matrix[0].datasize);
    2727
    2828# define CONVERTSAME(MY_NAN)                    \
    … …  
    4141  inMode  *in;                                          \
    4242  outMode *out;                                         \
    43   REALLOCATE (matrix[0].buffer, char, matrix[0].size);  \
     43  REALLOCATE (matrix[0].buffer, char, matrix[0].datasize);      \
    4444  out = (outMode *)matrix[0].buffer + Npixels - 1;      \
    4545  in  = (inMode  *)matrix[0].buffer + Npixels - 1;      \
    … …  
    6262      *out = *in*A + B;                                 \
    6363    }                                                   \
    64   REALLOCATE (matrix[0].buffer, char, matrix[0].size);
     64  REALLOCATE (matrix[0].buffer, char, matrix[0].datasize);
    6565
    6666# define CONVERTSAME_FF(MY_NAN)                 \
    … …  
    7979  inMode  *in;                                          \
    8080  outMode *out;                                         \
    81   REALLOCATE (matrix[0].buffer, char, matrix[0].size);  \
     81  REALLOCATE (matrix[0].buffer, char, matrix[0].datasize);      \
    8282  out = (outMode *)matrix[0].buffer + Npixels - 1;      \
    8383  in  = (inMode  *)matrix[0].buffer + Npixels - 1;      \
    … …  
    106106    return (TRUE);
    107107
    108   matrix[0].bitpix = header[0].bitpix = outBitpix;
    109   matrix[0].bscale = header[0].bscale = outScale;
    110   matrix[0].bzero  = header[0].bzero  = outZero;
    111   matrix[0].unsign = header[0].unsign = outUnsign;
    112   matrix[0].size  = gfits_data_size (header);
     108  matrix[0].bitpix   = header[0].bitpix = outBitpix;
     109  matrix[0].bscale   = header[0].bscale = outScale;
     110  matrix[0].bzero    = header[0].bzero  = outZero;
     111  matrix[0].unsign   = header[0].unsign = outUnsign;
     112  matrix[0].datasize = gfits_data_size (header);
    113113  gfits_modify (header, "BITPIX", "%d", 1, outBitpix);
    114114  gfits_modify (header, "BSCALE", "%lf", 1, outScale);
    115115  gfits_modify (header, "BZERO",  "%lf", 1, outZero);
    116   gfits_modify (header, "UNSIGN", "%t", 1, outUnsign);
     116  gfits_modify_alt (header, "UNSIGN", "%t", 1, outUnsign);
    117117
    118118  Npixels          = header[0].Naxis[0]*header[0].Naxis[1];
    … …  
    426426  {
    427427    char *out;
    428     int Nextra;
     428    off_t Nextra;
    429429   
    430430    out = (char *)matrix[0].buffer;
    431     Nextra = matrix[0].size - nbytes;
     431    Nextra = matrix[0].datasize - nbytes;
    432432    bzero (&out[nbytes], Nextra);
    433433  }

  • trunk/Ohana/src/libfits/matrix/F_copy_M.c

    r17903 r27435  
    77  int i;
    88
    9   matrix2[0].unsign = matrix1[0].unsign;
    10   matrix2[0].bitpix = matrix1[0].bitpix;
    11   matrix2[0].size   = matrix1[0].size;
    12   matrix2[0].bzero  = matrix1[0].bzero;
    13   matrix2[0].bscale = matrix1[0].bscale;
    14   matrix2[0].Naxes  = matrix1[0].Naxes;
     9  matrix2[0].unsign   = matrix1[0].unsign;
     10  matrix2[0].bitpix   = matrix1[0].bitpix;
     11  matrix2[0].datasize = matrix1[0].datasize;
     12  matrix2[0].bzero    = matrix1[0].bzero;
     13  matrix2[0].bscale   = matrix1[0].bscale;
     14  matrix2[0].Naxes    = matrix1[0].Naxes;
    1515  for (i = 0; i < FT_MAX_NAXES; i++)
    1616    matrix2[0].Naxis[i] = matrix1[0].Naxis[i];
    1717
    1818  if (matrix2[0].buffer != NULL) free (matrix2[0].buffer);
    19   ALLOCATE (matrix2[0].buffer, char, matrix2[0].size);
     19  ALLOCATE (matrix2[0].buffer, char, matrix2[0].datasize);
    2020 
    21   memcpy (matrix2[0].buffer, matrix1[0].buffer, matrix2[0].size);
     21  memcpy (matrix2[0].buffer, matrix1[0].buffer, matrix2[0].datasize);
    2222
    2323  return (TRUE);

  • trunk/Ohana/src/libfits/matrix/F_create_M.c

    r17903 r27435  
    33
    44/*********************** fits create matrix *******************************/
    5 int gfits_create_matrix (header, matrix)
    6 Header *header;
    7 Matrix *matrix;
    8 {
     5int gfits_create_matrix (Header *header, Matrix *matrix) {
    96
    10   int i, Nbytes;
     7  int i;
     8  off_t Nbytes;
    119
    1210  matrix[0].bitpix = header[0].bitpix;
    … …  
    2018  Nbytes = gfits_data_size (header);
    2119  ALLOCATE (matrix[0].buffer, char, MAX (Nbytes, 1));
    22   bzero (matrix[0].buffer, Nbytes);
     20  memset (matrix[0].buffer, 0, Nbytes);
    2321 
    24   matrix[0].size = Nbytes;
     22  matrix[0].datasize = Nbytes;
    2523  return (TRUE);
    2624

  • trunk/Ohana/src/libfits/matrix/F_get_M_value.c

    r15487 r27435  
    33
    44/***************** fits get matrix value ***********************************/
    5 double gfits_get_matrix_value (Matrix *matrix, int x, int y) {
     5double gfits_get_matrix_value (Matrix *matrix, off_t x, off_t y) {
    66
    77  double value;
    … …  
    1111    return (0.0);
    1212  pixel = matrix[0].Naxis[0]*y + x;
    13   value = HUGE_VAL;
     13  value = NAN;
    1414
    1515  if (matrix[0].unsign) {

  • trunk/Ohana/src/libfits/matrix/F_insert_M.c

    r15487 r27435  
    33
    44/*********************** fits insert array ***********************************/
    5 void gfits_insert_matrix (Matrix *matrix, Matrix *array, int x, int y) {
     5void gfits_insert_matrix (Matrix *matrix, Matrix *array, off_t x, off_t y) {
    66
    77  /* there is no check here to match BITPIX, BZERO, or BSCALE */
    88
    9   int i, start_m, Nbytes_m, Nbytes;
     9  int i;
     10  off_t start_m, Nbytes_m, Nbytes;
    1011
    1112  if ((x + array[0].Naxis[0] > matrix[0].Naxis[0]) ||
    1213      (y + array[0].Naxis[1] > matrix[0].Naxis[1])) {
    13     fprintf (stderr, "can't insert array here: (%d,%d) - (%d,%d) vs (%d,%d)\n",
    14              x, y, x + array[0].Naxis[0], y + array[0].Naxis[1],
    15              matrix[0].Naxis[0], matrix[0].Naxis[1]);
     14    fprintf (stderr, "can't insert array here: (%lld,%lld) - (%lld,%lld) vs (%lld,%lld)\n",
     15             (long long) x,
     16             (long long) y,
     17             (long long) x + array[0].Naxis[0],
     18             (long long) y + array[0].Naxis[1],
     19             (long long) matrix[0].Naxis[0],
     20             (long long) matrix[0].Naxis[1]);
    1621    return;
    1722  }

  • trunk/Ohana/src/libfits/matrix/F_load_M.c

    r16139 r27435  
    1313int gfits_load_matrix (FILE *f, Matrix *matrix, Header *header) {
    1414
    15   int i, nbytes, Nbytes;
     15 
     16  off_t i, nbytes, Nbytes;
    1617
    1718  matrix[0].bitpix = header[0].bitpix;
    … …  
    2526  Nbytes = gfits_data_size (header);
    2627  ALLOCATE (matrix[0].buffer, char, Nbytes);
    27   matrix[0].size = Nbytes;
     28  matrix[0].datasize = Nbytes;
    2829
    2930  nbytes = fread (matrix[0].buffer, sizeof(char), Nbytes, f);
    … …  
    9495  }
    9596  if (nbytes != Nbytes) {  /* this is a FITS error, but often the image is OK */
    96     fprintf (stderr, "incomplete block in FITS file: (%d, %d)\n", nbytes, Nbytes);
     97    fprintf (stderr, "incomplete block in FITS file: (%lld, %lld)\n", (long long) nbytes, (long long) Nbytes);
    9798    return (TRUE);
    9899  }

  • trunk/Ohana/src/libfits/matrix/F_matrix.c

    r15751 r27435  
    22# include <gfitsio.h>
    33
    4 int gfits_data_size (Header *header) {
     4off_t gfits_data_size (Header *header) {
    55 
    6   int i, Nrec, size;
     6  int i;
     7  off_t Nrec, size;
    78
    89  if (header[0].Naxes == 0) return (0);
    … …  
    2526}
    2627
    27 int gfits_data_min_size (Header *header) {
     28off_t gfits_data_min_size (Header *header) {
    2829 
    29   int i, size;
     30  int i;
     31  off_t size;
    3032
    3133  if (header[0].Naxes == 0) return (0);

  • trunk/Ohana/src/libfits/matrix/F_read_M.c

    r7054 r27435  
    1818  if (f == NULL) return (FALSE);
    1919
    20   fseek (f, header.size, 0);
     20  fseeko (f, header.datasize, 0);
    2121 
    2222  status = gfits_load_matrix (f, matrix, &header);

  • trunk/Ohana/src/libfits/matrix/F_read_portion.c

    r16139 r27435  
    99/*********************** fits read matrix ***********************************/
    1010/** the result of this function is a matrix with dimension Npix * 1 **/
    11 int gfits_read_portion (char *filename, Matrix *matrix, int Nskip, int Npix) {
     11int gfits_read_portion (char *filename, Matrix *matrix, off_t Nskip, off_t Npix) {
    1212
    1313  FILE *f;
    1414  Header header;
    15   int status, nbytes, Nbytes, Nrec;
     15  int status;
     16  off_t nbytes, Nbytes, Nrec;
    1617
    1718  status = gfits_read_header (filename, &header);
    … …  
    3738    Nbytes = FT_RECORD_SIZE * Nrec;
    3839  }
    39   matrix[0].size = Nbytes;
     40  matrix[0].datasize = Nbytes;
    4041  ALLOCATE (matrix[0].buffer, char, Nbytes);
    4142
    … …  
    4344  f = fopen (filename, "r");
    4445  if (f == NULL) return (FALSE);
    45   fseek (f, header.size + Nskip, SEEK_SET);
     46  fseeko (f, header.datasize + Nskip, SEEK_SET);
    4647  nbytes = fread (matrix[0].buffer, sizeof(char), Nbytes, f);
    4748  if (nbytes != Nbytes) {
    … …  
    5253
    5354# ifdef BYTE_SWAP 
    54  {
    55   int i, perpix;
    56   unsigned char *byte0, *byte1, *byte2, *byte3, *byte4, *byte5, *byte6, *byte7, ctmp;
     55  {
     56    off_t i;
     57    int perpix;
     58    unsigned char *byte0, *byte1, *byte2, *byte3, *byte4, *byte5, *byte6, *byte7, ctmp;
    5759
    58   perpix = abs(header.bitpix) / 8;
    59   if (perpix > 1) {
    60     byte0 = (unsigned char *) matrix[0].buffer;
    61     byte1 = (unsigned char *) matrix[0].buffer + 1;
    62     byte2 = (unsigned char *) matrix[0].buffer + 2;
    63     byte3 = (unsigned char *) matrix[0].buffer + 3;
    64     byte4 = (unsigned char *) matrix[0].buffer + 4;
    65     byte5 = (unsigned char *) matrix[0].buffer + 5;
    66     byte6 = (unsigned char *) matrix[0].buffer + 6;
    67     byte7 = (unsigned char *) matrix[0].buffer + 7;
    68     if (perpix == 2) {
    69       for (i = 0; i < nbytes; i+=2, byte0 += 2, byte1 += 2) {
    70         ctmp = *byte0;
    71         *byte0 = *byte1;
    72         *byte1 = ctmp;
     60    perpix = abs(header.bitpix) / 8;
     61    if (perpix > 1) {
     62      byte0 = (unsigned char *) matrix[0].buffer;
     63      byte1 = (unsigned char *) matrix[0].buffer + 1;
     64      byte2 = (unsigned char *) matrix[0].buffer + 2;
     65      byte3 = (unsigned char *) matrix[0].buffer + 3;
     66      byte4 = (unsigned char *) matrix[0].buffer + 4;
     67      byte5 = (unsigned char *) matrix[0].buffer + 5;
     68      byte6 = (unsigned char *) matrix[0].buffer + 6;
     69      byte7 = (unsigned char *) matrix[0].buffer + 7;
     70      if (perpix == 2) {
     71        for (i = 0; i < nbytes; i+=2, byte0 += 2, byte1 += 2) {
     72          ctmp = *byte0;
     73          *byte0 = *byte1;
     74          *byte1 = ctmp;
     75        }
    7376      }
    74     }
    75     if (perpix == 4) {
    76       for (i = 0; i < nbytes; i+=4, byte0 += 4, byte1 += 4, byte2 += 4, byte3 += 4) {
    77         ctmp = *byte0;
    78         *byte0 = *byte3;
    79         *byte3 = ctmp;
    80         ctmp = *byte1;
    81         *byte1 = *byte2;
    82         *byte2 = ctmp;
     77      if (perpix == 4) {
     78        for (i = 0; i < nbytes; i+=4, byte0 += 4, byte1 += 4, byte2 += 4, byte3 += 4) {
     79          ctmp = *byte0;
     80          *byte0 = *byte3;
     81          *byte3 = ctmp;
     82          ctmp = *byte1;
     83          *byte1 = *byte2;
     84          *byte2 = ctmp;
     85        }
    8386      }
    84     }
    85     if (perpix == 8) {
    86       for (i = 0; i < nbytes; i+=8, byte0 += 8, byte1 += 8, byte2 += 8, byte3 += 8, byte4 += 8, byte5 += 8, byte6 += 8, byte7 += 8) {
    87         ctmp = *byte0;
    88         *byte0 = *byte7;
    89         *byte7 = ctmp;
    90         ctmp = *byte1;
    91         *byte1 = *byte6;
    92         *byte6 = ctmp;
    93         ctmp = *byte1;
    94         *byte2 = *byte5;
    95         *byte5 = ctmp;
    96         ctmp = *byte1;
    97         *byte3 = *byte4;
    98         *byte4 = ctmp;
     87      if (perpix == 8) {
     88        for (i = 0; i < nbytes; i+=8, byte0 += 8, byte1 += 8, byte2 += 8, byte3 += 8, byte4 += 8, byte5 += 8, byte6 += 8, byte7 += 8) {
     89          ctmp = *byte0;
     90          *byte0 = *byte7;
     91          *byte7 = ctmp;
     92          ctmp = *byte1;
     93          *byte1 = *byte6;
     94          *byte6 = ctmp;
     95          ctmp = *byte1;
     96          *byte2 = *byte5;
     97          *byte5 = ctmp;
     98          ctmp = *byte1;
     99          *byte3 = *byte4;
     100          *byte4 = ctmp;
     101        }
    99102      }
    100103    }
    101104  }
    102  }
    103105# endif
    104106
    … …  
    106108
    107109  if (nbytes < Nbytes - 2880) {  /* this is a bad FITS error: image is not OK */
    108     fprintf (stderr, "error reading in matrix data from FITS file %s (%d < %d - 2880)\n", filename, nbytes, Nbytes);
     110    fprintf (stderr, "error reading in matrix data from FITS file %s (%lld < %lld - 2880)\n", filename, (long long) nbytes, (long long) Nbytes);
    109111    return (FALSE);
    110112  }
    111113  if (nbytes != Nbytes) {  /* this is a FITS error, but often the image is OK */
    112     fprintf (stderr, "incomplete block in %s: (%d, %d)\n", filename, nbytes, Nbytes);
     114    fprintf (stderr, "incomplete block in %s: (%lld, %lld)\n", filename, (long long) nbytes, (long long) Nbytes);
    113115    return (TRUE);
    114116  }

  • trunk/Ohana/src/libfits/matrix/F_read_segment.c

    r16139 r27435  
    3636int gfits_fread_matrix_segment (FILE *f, Matrix *matrix, Header *header, char *region) {
    3737
    38   int status, i, nbytes, Nbytes, Nskip, NbytesData;
     38  int status;
     39  off_t i, nbytes, Nbytes, Nskip, NbytesData;
    3940  int wantaxis[FT_MAX_NAXES][2];
    4041  double tmp;
    … …  
    6566    matrix[0].Naxis[i] = wantaxis[i][1] - wantaxis[i][0];
    6667
    67   matrix[0].size = abs (matrix[0].bitpix) / 8;
     68  matrix[0].datasize = abs (matrix[0].bitpix) / 8;
    6869  for (i = 0; i < matrix[0].Naxes; i++)
    69     matrix[0].size *= matrix[0].Naxis[i];
     70    matrix[0].datasize *= matrix[0].Naxis[i];
    7071
    7172  Nskip = wantaxis[2][0]*matrix[0].Naxis[0]*matrix[0].Naxis[1]*abs(matrix[0].bitpix)/8;
    72   NbytesData = Nskip + matrix[0].size;
     73  NbytesData = Nskip + matrix[0].datasize;
    7374
    7475  if (NbytesData % FT_RECORD_SIZE)
    75     Nbytes = FT_RECORD_SIZE * ((int) (NbytesData / FT_RECORD_SIZE) + 1) - Nskip;
     76    Nbytes = FT_RECORD_SIZE * ((off_t) (NbytesData / FT_RECORD_SIZE) + 1) - Nskip;
    7677  else
    77     Nbytes = FT_RECORD_SIZE * ((int) (NbytesData / FT_RECORD_SIZE)) - Nskip;
     78    Nbytes = FT_RECORD_SIZE * ((off_t) (NbytesData / FT_RECORD_SIZE)) - Nskip;
    7879
    7980  ALLOCATE (matrix[0].buffer, char, MAX (Nbytes, 1));
    … …  
    8687
    8788  /* currently only good for reading in full planes in 3-D */
    88   fseek (f, Nskip, SEEK_CUR);
     89  fseeko (f, Nskip, SEEK_CUR);
    8990  nbytes = fread (matrix[0].buffer, sizeof(char), Nbytes, f);
    9091  if (nbytes != Nbytes) {
    … …  
    9293  }
    9394
    94   matrix[0].size = Nbytes;
     95  matrix[0].datasize = Nbytes;
    9596
    9697# ifdef BYTE_SWAP 
    … …  
    147148
    148149  if (nbytes < Nbytes - 2880) {  /* this is a bad FITS error: image is not OK */
    149     fprintf (stderr, "error reading in matrix data from FITS file (%d < %d - 2880)\n", nbytes, Nbytes);
     150    fprintf (stderr, "error reading in matrix data from FITS file (%lld < %lld - 2880)\n", (long long) nbytes, (long long) Nbytes);
    150151    return (FALSE);
    151152  }
    152153  if (nbytes != Nbytes) {  /* this is a FITS error, but often the image is OK */
    153     fprintf (stderr, "incomplete block in FITS file: (%d, %d)\n", nbytes, Nbytes);
     154    fprintf (stderr, "incomplete block in FITS file: (%lld, %lld)\n", (long long) nbytes, (long long) Nbytes);
    154155    return (TRUE);
    155156  }

  • trunk/Ohana/src/libfits/matrix/F_set_M_value.c

    r15487 r27435  
    33
    44/****************** fits set matrix value ***********************************/
    5 void gfits_set_matrix_value (Matrix *matrix, int x, int y, double Value) {
     5void gfits_set_matrix_value (Matrix *matrix, off_t x, off_t y, double Value) {
    66
    7   int pixel;
     7  off_t pixel;
    88  double value;
    99

  • trunk/Ohana/src/libfits/matrix/F_write_M.c

    r16139 r27435  
    1111  if (f == NULL) return (FALSE);
    1212 
    13   fseek (f, 0, SEEK_END);  /* write matrix to end of file! */
     13  fseeko (f, 0LL, SEEK_END);  /* write matrix to end of file! */
    1414
    1515  status = gfits_fwrite_matrix (f, matrix);
    … …  
    2121int gfits_fwrite_matrix (FILE *f, Matrix *matrix) {
    2222
    23   int status, nbytes, Nbytes;
     23  int status;
     24  off_t nbytes, Nbytes;
    2425
    2526  status = TRUE;
    … …  
    2728  /* this is a bit dangerous: we are not realloc'ing the matrix.
    2829     if the size is wrong, it probably should simply pad the fwrite statement.
    29      better policy should be defined (ie, matrix.size always correct blocking?)
     30     better policy should be defined (ie, matrix.datasize always correct blocking?)
    3031  */
    3132
    32   if (matrix[0].size % FT_RECORD_SIZE)
    33     nbytes = FT_RECORD_SIZE * ((int) (matrix[0].size / FT_RECORD_SIZE) + 1);
     33  if (matrix[0].datasize % FT_RECORD_SIZE)
     34    nbytes = FT_RECORD_SIZE * ((off_t) (matrix[0].datasize / FT_RECORD_SIZE) + 1);
    3435  else
    35     nbytes = FT_RECORD_SIZE * ((int) (matrix[0].size / FT_RECORD_SIZE));
     36    nbytes = FT_RECORD_SIZE * ((off_t) (matrix[0].datasize / FT_RECORD_SIZE));
    3637
    3738  /* this is a bit cumbersome: swap all words, write out file, then swap back... */
    3839# ifdef BYTE_SWAP 
    3940  {
    40     int i;
     41    off_t i;
    4142    unsigned char *byte0, *byte1, *byte2, *byte3, *byte4, *byte5, *byte6, *byte7, tmp;
    4243    int perpix;
    … …  
    9697# ifdef BYTE_SWAP
    9798  {
    98     int i;
     99    off_t i;
    99100    unsigned char *byte0, *byte1, *byte2, *byte3, *byte4, *byte5, *byte6, *byte7, tmp;
    100101    int perpix;

  • trunk/Ohana/src/libfits/table/F_create_T.c

    r15487 r27435  
    55int gfits_create_table (Header *header, FTable *table) {
    66
    7   int Nbytes;
     7  off_t Nbytes;
    88  char type[80];
    99
    … …  
    1919    memset (table[0].buffer, 0, Nbytes);
    2020  }
    21   table[0].size = Nbytes;
     21  table[0].datasize = Nbytes;
    2222  return (TRUE);
    2323
    … …  
    2929int gfits_create_vtable (Header *header, VTable *table, int Nrow) {
    3030
    31   int i, Nx, Ny;
     31  off_t i, Nx, Ny;
    3232  char type[80];
    3333
    … …  
    3737  Nx = table[0].header[0].Naxis[0];
    3838  Ny = table[0].header[0].Naxis[0];
    39   table[0].size = gfits_data_size (header);
    40   table[0].pad = table[0].size - Nx*Ny;
     39  table[0].datasize = gfits_data_size (header);
     40  table[0].pad = table[0].datasize - Nx*Ny;
    4141 
    4242  table[0].Nrow = Nrow;
    4343  ALLOCATE (table[0].buffer, char *, MAX (Nrow, 1));
    44   ALLOCATE (table[0].row, int, MAX (Nrow, 1));
     44  ALLOCATE (table[0].row, off_t, MAX (Nrow, 1));
    4545  for (i = 0; i < Nrow; i++) {
    4646    ALLOCATE (table[0].buffer[i], char, Nx);

  • trunk/Ohana/src/libfits/table/F_create_TH.c

    r15487 r27435  
    1313  char axis[10];
    1414 
    15   header[0].size = NBYTES;
     15  header[0].datasize = NBYTES;
    1616
    1717  ALLOCATE (header[0].buffer, char, NBYTES);
    … …  
    2727  for (i = 0; i < header[0].Naxes; i++) {
    2828    sprintf (axis, "NAXIS%d", i + 1);
    29     gfits_modify (header,  axis, "%d", 1, header[0].Naxis[i], 1);
     29    gfits_modify (header,  axis, "%lld", 1, (long long) header[0].Naxis[i]);
    3030  }
    3131 

  • trunk/Ohana/src/libfits/table/F_define_column.c

    r26384 r27435  
    55int gfits_define_bintable_column (Header *header, char *format, char *label, char *comment, char *unit, double bscale, double bzero) {
    66
    7   int Nfields, Nbytes, Nval, Naxis1;
     7  off_t Naxis1;
     8  int Nfields, Nbytes, Nval;
    89  char type[16], field[16];
    910 
    … …  
    1213  Nfields = 0;
    1314  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    14   gfits_scan (header, "NAXIS1",  "%d", 1, &Naxis1);
     15  gfits_scan (header, "NAXIS1",  "%lld", 1, (long long *) &Naxis1);
    1516  Nfields ++;
    1617  Naxis1 += Nbytes*Nval;
    … …  
    1819  sprintf (field, "TTYPE%d", Nfields);
    1920  gfits_modify (header, field, "%s", 1, label);
    20   gfits_modify (header, field, "%C", 1, comment);
     21  gfits_modify_alt (header, field, "%C", 1, comment);
    2122  sprintf (field, "TUNIT%d", Nfields);
    2223  gfits_modify (header, field, "%s", 1, unit);
    … …  
    3435  /* update TFIELDS & NAXIS1 */
    3536  gfits_modify (header, "TFIELDS", "%d", 1, Nfields);
    36   gfits_modify (header, "NAXIS1",  "%d", 1, Naxis1);
     37  gfits_modify (header, "NAXIS1",  "%lld", 1, (long long) Naxis1);
    3738  header[0].Naxis[0] = Naxis1;
    3839
    … …  
    4344int gfits_define_table_column (Header *header, char *format, char *label, char *comment, char *unit) {
    4445
    45   int Nstart, Nfields, Nbytes, Nval, Naxis1;
     46  off_t Naxis1;
     47  int Nstart, Nfields, Nbytes, Nval;
    4648  char type[16], field[16], cformat[16];
    4749
    … …  
    5153  Nfields = 0;
    5254  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    53   gfits_scan (header, "NAXIS1",  "%d", 1, &Naxis1);
     55  gfits_scan (header, "NAXIS1",  "%lld", 1, (long long *) &Naxis1);
    5456  Nstart = Naxis1 + 1;
    5557  Nfields ++;
    … …  
    5860  sprintf (field, "TTYPE%d", Nfields);
    5961  gfits_modify (header, field, "%s", 1, label);
    60   gfits_modify (header, field, "%C", 1, comment);
     62  gfits_modify_alt (header, field, "%C", 1, comment);
    6163  sprintf (field, "TUNIT%d", Nfields);
    6264  gfits_modify (header, field, "%s", 1, unit);
    … …  
    6870
    6971  gfits_modify (header, "TFIELDS", "%d", 1, Nfields);
    70   gfits_modify (header, "NAXIS1",  "%d", 1, Naxis1);
     72  gfits_modify (header, "NAXIS1",  "%lld", 1, (long long) Naxis1);
    7173  header[0].Naxis[0] = Naxis1;
    7274

  • trunk/Ohana/src/libfits/table/F_get_column.c

    r26384 r27435  
    1616  tmp = Pin[3]; Pin[3] = Pin[4]; Pin[4] = tmp; }
    1717
    18 void *gfits_get_bintable_column_data (Header *header, FTable *table, char *label, char *type, int *Nrow, int *Ncol) {
    19 
    20   int i, N, Nfields, Nval, Nbytes, Nx, Ny, Nstart, Nv, Nb;
     18void *gfits_get_bintable_column_data (Header *header, FTable *table, char *label, char *type, off_t *Nrow, int *Ncol) {
     19
     20  off_t Nx, Ny;
     21  int i, N, Nfields, Nval, Nbytes, Nstart, Nv, Nb;
    2122  char tlabel[80], field[80], format[80], tmpline[16];
    2223  char *Pin, *Pout, *array;
    … …  
    5051 
    5152  /* check existing table dimensions */
    52   gfits_scan (header, "NAXIS1",  "%d", 1, &Nx);
    53   gfits_scan (header, "NAXIS2",  "%d", 1, &Ny);
     53  gfits_scan (header, "NAXIS1",  "%lld", 1, (long long *) &Nx);
     54  gfits_scan (header, "NAXIS2",  "%lld", 1, (long long *) &Ny);
    5455
    5556  /* scan columns to find insert point */
    … …  
    153154int gfits_get_bintable_column (Header *header, FTable *table, char *label, void **data) {
    154155
    155   int i, N, Nfields, Nval, Nbytes, Nx, Ny, Nstart, Nv, Nb;
     156  off_t Nx, Ny;
     157  int i, N, Nfields, Nval, Nbytes, Nstart, Nv, Nb;
    156158  char tlabel[80], field[80], format[80], type[16], tmpline[16];
    157159  char *Pin, *Pout, *array;
    … …  
    185187 
    186188  /* check existing table dimensions */
    187   gfits_scan (header, "NAXIS1",  "%d", 1, &Nx);
    188   gfits_scan (header, "NAXIS2",  "%d", 1, &Ny);
     189  gfits_scan (header, "NAXIS1",  "%lld", 1, (long long *) &Nx);
     190  gfits_scan (header, "NAXIS2",  "%lld", 1, (long long *) &Ny);
    189191
    190192  /* scan columns to find insert point */
    … …  
    307309int gfits_get_table_column (Header *header, FTable *table, char *label, void **data) {
    308310
    309   int i, N, Nfields, Nval, Nbytes, Nx, Ny, Nstart, Nv, Nb;
     311  off_t Nx, Ny;
     312  int i, N, Nfields, Nval, Nbytes, Nstart, Nv, Nb;
    310313  char tlabel[80], field[80], format[80], cformat[80], type[16], tmp[16];
    311314  char *array, *Pin, *Pout, *line;
    … …  
    333336 
    334337  /* check existing table dimensions */
    335   gfits_scan (header, "NAXIS1",  "%d", 1, &Nx);
    336   gfits_scan (header, "NAXIS2",  "%d", 1, &Ny);
     338  gfits_scan (header, "NAXIS1",  "%lld", 1, (long long *) &Nx);
     339  gfits_scan (header, "NAXIS2",  "%lld", 1, (long long *) &Ny);
    337340
    338341  /* scan columns to find insert point */

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

    r15751 r27435  
    1919int gfits_fread_ftable (FILE *f, FTable *table, char *extname) {
    2020
    21   int j, found, Nbytes;
     21  int j, found;
     22  off_t Nbytes;
    2223  Header *header;
    2324  char tname[80];
    2425
    2526  header = table[0].header;
    26   fseek (f, 0, SEEK_SET);
     27  fseeko (f, 0, SEEK_SET);
    2728
    2829  found = FALSE;
    … …  
    4243    /* skip to next header */
    4344    Nbytes = gfits_data_size (header);
    44     fseek (f, Nbytes, SEEK_CUR);
     45    fseeko (f, Nbytes, SEEK_CUR);
    4546    gfits_free_header (header);
    4647  }
    … …  
    5152int gfits_fread_ftable_data (FILE *f, FTable *table) {
    5253
    53   int Nbytes, Nread;
     54  off_t Nbytes, Nread;
    5455  char string[128];
    5556
    … …  
    6364    perror (string);
    6465    if (Nread < gfits_data_min_size (table[0].header)) {
    65       fprintf (stderr, "error: fits read error in %s, read %d, need %d\n", __func__, Nread, gfits_data_min_size (table[0].header));
     66      fprintf (stderr, "error: fits read error in %s, read %lld, need %lld\n", __func__, (long long) Nread, (long long) gfits_data_min_size (table[0].header));
    6667      gfits_free_table  (table);
    6768      return (FALSE);
    … …  
    6970    fprintf (stderr, "warning: file missing pad\n");
    7071  }
    71   table[0].size = Nbytes;
     72  table[0].datasize = Nbytes;
    7273  return (TRUE);
    7374}       
    7475
    7576/*********************** fits read ftable data ***********************************/
    76 int gfits_fread_ftable_range (FILE *f, FTable *table, int start, int Nrows) {
    77 
    78   int Nbytes, Nread, Nskip, Nx, Ny;
     77int gfits_fread_ftable_range (FILE *f, FTable *table, off_t start, off_t Nrows) {
     78
     79  off_t Nbytes, Nread, Nskip, Nx, Ny;
    7980
    8081  /* find disk table size */
    … …  
    9394  ALLOCATE (table[0].buffer, char, MAX (Nbytes, 1));
    9495
    95   fseek (f, Nskip, SEEK_CUR);
     96  fseeko (f, Nskip, SEEK_CUR);
    9697
    9798  Nread = fread (table[0].buffer, sizeof (char), Nbytes, f);
    … …  
    108109  /* modify structure and header to match actual read rows Ny */
    109110  table[0].header[0].Naxis[1] = Nrows;
    110   gfits_modify (table[0].header, "NAXIS2",  "%d", 1, Nrows);
    111   table[0].size = gfits_data_size (table[0].header);
     111  gfits_modify (table[0].header, "NAXIS2",  "%lld", 1, (long long) Nrows);
     112  table[0].datasize = gfits_data_size (table[0].header);
    112113
    113114  return (TRUE);
    … …  
    115116
    116117/*********************** fits read ftable data ***********************************/
    117 int gfits_fread_vtable_range (FILE *f, VTable *table, int start, int Nrows) {
    118 
    119   int i, Nbytes, Nread, Nskip, Nx, Ny;
     118int gfits_fread_vtable_range (FILE *f, VTable *table, off_t start, off_t Nrows) {
     119
     120  off_t i, Nbytes, Nread, Nskip, Nx, Ny;
    120121  char *buffer;
    121122
    … …  
    123124  Nx = table[0].header[0].Naxis[0];
    124125  Ny = table[0].header[0].Naxis[1];
    125   table[0].size = gfits_data_size (table[0].header);
    126   table[0].pad = table[0].size - Nx*Ny;
     126  table[0].datasize = gfits_data_size (table[0].header);
     127  table[0].pad = table[0].datasize - Nx*Ny;
    127128
    128129  if (start < 0) return (FALSE);
    … …  
    133134  ALLOCATE (buffer, char, MAX (Nbytes, 1));
    134135
    135   fseek (f, Nskip, SEEK_CUR);
     136  fseeko (f, Nskip, SEEK_CUR);
    136137  Nread = fread (buffer, sizeof (char), Nbytes, f);
    137138  if (Nread != Nbytes) {
    … …  
    141142  }
    142143
    143   ALLOCATE (table[0].row, int, MAX (Nrows, 1));
     144  ALLOCATE (table[0].row, off_t, MAX (Nrows, 1));
    144145  ALLOCATE (table[0].buffer, char *, MAX (Nrows, 1));
    145146  for (i = 0; i < Nrows; i++) {
    … …  
    154155
    155156/*********************** fits read virtual table ***********************************/
    156 int gfits_fread_vtable (FILE *f, VTable *table, char *extname, int Nrow, int *row) {
    157 
    158   int i, j, Nbytes, Nread;
    159   int start, Nx, Ny, offset;
     157int gfits_fread_vtable (FILE *f, VTable *table, char *extname, off_t Nrow, off_t *row) {
     158
     159  off_t i, j;
     160  off_t Nbytes, Nread;
     161  off_t start, Nx, Ny, offset;
    160162  Header *header;
    161163  char tname[80];
    162164
    163165  header = table[0].header;
    164   fseek (f, 0, SEEK_SET);
     166  fseeko (f, 0, SEEK_SET);
    165167
    166168  for (j = -1; TRUE; j++) {
    … …  
    176178    if (strcmp (tname, extname)) {
    177179      /* skip to next header */
    178       fseek (f, Nbytes, SEEK_CUR);
     180      fseeko (f, Nbytes, SEEK_CUR);
    179181      gfits_free_header (header);
    180182      continue;
    … …  
    182184
    183185    /* file pointer is at beginning of desired table data */
    184     start = ftell (f);
    185     gfits_scan (header, "NAXIS1", "%d", 1, &Nx);
    186     gfits_scan (header, "NAXIS2", "%d", 1, &Ny);
     186    start = ftello (f);
     187    gfits_scan (header, "NAXIS1", "%lld", 1, (long long *) &Nx);
     188    gfits_scan (header, "NAXIS2", "%lld", 1, (long long *) &Ny);
    187189    for (i = 0; i < Nrow; i++) {
    188190      if (row[i] > Ny) { return (FALSE); }
    … …  
    193195      ALLOCATE (table[0].buffer[i], char, MAX (1, Nx));
    194196      offset = start + Nx*row[i];
    195       fseek (f, offset, SEEK_SET);
     197      fseeko (f, offset, SEEK_SET);
    196198      Nread = fread (table[0].buffer[i], sizeof (char), Nx, f);
    197199      if (Nread != Nx) {
    … …  
    202204
    203205    table[0].Nrow  = Nrow;
    204     ALLOCATE (table[0].row, int, MAX (1, Nrow));   
     206    ALLOCATE (table[0].row, off_t, MAX (1, Nrow));   
    205207    for (i = 0; i < Nrow; i++) table[0].row[i] = row[i];
    206     table[0].size  = gfits_data_size (table[0].header);
    207     table[0].pad    = table[0].size - Nx*Ny;
     208    table[0].datasize = gfits_data_size (table[0].header);
     209    table[0].pad      = table[0].datasize - Nx*Ny;
    208210    return (TRUE);
    209211  }
    … …  
    212214int gfits_fread_header_extname (FILE *f, Header *header, char *extname) {
    213215
    214   int Nbytes;
     216  off_t Nbytes;
    215217  char current[80];
    216218
    217   fseek (f, 0, SEEK_SET);
     219  fseeko (f, 0, SEEK_SET);
    218220  gfits_fread_header (f, header);
    219221
    … …  
    221223
    222224  Nbytes = gfits_data_size (header);
    223   fseek (f, Nbytes, SEEK_CUR);
     225  fseeko (f, Nbytes, SEEK_CUR);
    224226
    225227  while (gfits_fread_header (f, header)) {
    … …  
    227229    if (!strcmp (current, extname)) return (TRUE);
    228230    Nbytes = gfits_data_size (header);
    229     fseek (f, Nbytes, SEEK_CUR);
     231    fseeko (f, Nbytes, SEEK_CUR);
    230232  }
    231233  return (FALSE);

  • trunk/Ohana/src/libfits/table/F_read_TH.c

    r15743 r27435  
    77  FILE *f;
    88  Header header;
    9   int status, Nbytes;
     9  int status;
     10  off_t Nbytes;
    1011 
    1112  status = gfits_read_header (filename, &header);
    … …  
    2324
    2425  Nbytes = gfits_data_size (&header);
    25   fseek (f, Nbytes, SEEK_SET);
     26  fseeko (f, Nbytes, SEEK_SET);
    2627  gfits_free_header (&header);
    2728
    … …  
    3637 
    3738  char *p;
    38   int i, done, status, Nbytes;
     39  int i, done, status;
     40  off_t Nbytes;
    3941 
    40   Theader[0].size = 0;
     42  Theader[0].datasize = 0;
    4143  done = FALSE;
    4244  ALLOCATE (Theader[0].buffer, char, 1);
    … …  
    4446  for (i = 0; !done; i++) {
    4547    REALLOCATE (Theader[0].buffer, char, (i + 1)*FT_RECORD_SIZE);
    46     Nbytes = fread (&Theader[0].buffer[i*FT_RECORD_SIZE],
    47                     sizeof(char), FT_RECORD_SIZE, f);
     48    Nbytes = fread (&Theader[0].buffer[i*FT_RECORD_SIZE], sizeof(char), FT_RECORD_SIZE, f);
    4849    if (Nbytes != FT_RECORD_SIZE) {
    4950      perror ("fits matrix read error");
    5051    }
    5152
    52     Theader[0].size += Nbytes;
    53     if (Nbytes != FT_RECORD_SIZE)
     53    Theader[0].datasize += Nbytes;
     54    if (Nbytes != FT_RECORD_SIZE) {
    5455      done = TRUE;
     56    }
    5557    p = gfits_header_field (Theader, "END", 1);
    5658    if (p != NULL)
    … …  
    6870  if (!status) return (FALSE);
    6971                                                           
    70   gfits_scan (Theader,  "NAXIS1", "%d", 1, &Theader[0].Naxis[0]);
    71   gfits_scan (Theader,  "NAXIS2", "%d", 1, &Theader[0].Naxis[1]);
    72   gfits_scan (Theader,  "NAXIS3", "%d", 1, &Theader[0].Naxis[2]);
    73   gfits_scan (Theader,  "NAXIS4", "%d", 1, &Theader[0].Naxis[3]);
    74   gfits_scan (Theader,  "NAXIS5", "%d", 1, &Theader[0].Naxis[4]);
    75   gfits_scan (Theader,  "NAXIS6", "%d", 1, &Theader[0].Naxis[5]);
    76   gfits_scan (Theader,  "NAXIS7", "%d", 1, &Theader[0].Naxis[6]);
    77   gfits_scan (Theader,  "NAXIS8", "%d", 1, &Theader[0].Naxis[7]);
    78   gfits_scan (Theader,  "NAXIS9", "%d", 1, &Theader[0].Naxis[8]);
    79   gfits_scan (Theader, "NAXIS10", "%d", 1, &Theader[0].Naxis[9]);
     72  gfits_scan (Theader,  "NAXIS1", "%lld", 1, (long long *) &Theader[0].Naxis[0]);
     73  gfits_scan (Theader,  "NAXIS2", "%lld", 1, (long long *) &Theader[0].Naxis[1]);
     74  gfits_scan (Theader,  "NAXIS3", "%lld", 1, (long long *) &Theader[0].Naxis[2]);
     75  gfits_scan (Theader,  "NAXIS4", "%lld", 1, (long long *) &Theader[0].Naxis[3]);
     76  gfits_scan (Theader,  "NAXIS5", "%lld", 1, (long long *) &Theader[0].Naxis[4]);
     77  gfits_scan (Theader,  "NAXIS6", "%lld", 1, (long long *) &Theader[0].Naxis[5]);
     78  gfits_scan (Theader,  "NAXIS7", "%lld", 1, (long long *) &Theader[0].Naxis[6]);
     79  gfits_scan (Theader,  "NAXIS8", "%lld", 1, (long long *) &Theader[0].Naxis[7]);
     80  gfits_scan (Theader,  "NAXIS9", "%lld", 1, (long long *) &Theader[0].Naxis[8]);
     81  gfits_scan (Theader, "NAXIS10", "%lld", 1, (long long *) &Theader[0].Naxis[9]);
    8082
    8183  return (TRUE);

  • trunk/Ohana/src/libfits/table/F_set_column.c

    r16139 r27435  
    1616
    1717/***********************/
    18 int gfits_set_bintable_column (Header *header, FTable *table, char *label, void *data, int Nrow) {
    19 
    20   int i, N, Nfields, Nval, Nbytes, Nx, Ny, nbytes, Nstart, Nv, Nb;
     18int gfits_set_bintable_column (Header *header, FTable *table, char *label, void *data, off_t Nrow) {
     19
     20  off_t Nx, Ny, nbytes;
     21  int i, N, Nfields;
     22  int Nval, Nbytes, Nstart, Nv, Nb;
    2123  char tlabel[80], field[80], format[80], type[16], tmpline[16];
    2224  char *Pin, *Pout, *array;
    … …  
    4749 
    4850  /* check existing table dimensions */
    49   gfits_scan (header, "NAXIS1",  "%d", 1, &Nx);
    50   gfits_scan (header, "NAXIS2",  "%d", 1, &Ny);
     51  gfits_scan (header, "NAXIS1", "%lld", 1, (long long *) &Nx);
     52  gfits_scan (header, "NAXIS2", "%lld", 1, (long long *) &Ny);
    5153  if (Ny == 0) {
    5254    Ny = Nrow;
    5355    header[0].Naxis[1] = Ny;
    54     gfits_modify (header, "NAXIS2",  "%d", 1, Ny);
     56    gfits_modify (header, "NAXIS2", "%lld", 1, (long long) Ny);
    5557
    5658    nbytes = gfits_data_size (header);
    5759    REALLOCATE (table[0].buffer, char, MAX (nbytes, 1));
    5860    bzero (table[0].buffer, nbytes);
    59     table[0].size = nbytes;
     61    table[0].datasize = nbytes;
    6062  }
    6163  if (Ny != Nrow) return (FALSE);
    … …  
    151153
    152154/***********************/
    153 int gfits_set_table_column (Header *header, FTable *table, char *label, void *data, int Nrow) {
    154 
    155   int i, N, Nfields, Nval, Nbytes, Nx, Ny, nbytes, Nstart, Nv, Nb;
     155int gfits_set_table_column (Header *header, FTable *table, char *label, void *data, off_t Nrow) {
     156
     157  off_t Nx, Ny, nbytes;
     158  int i, N, Nfields, Nval, Nbytes, Nstart, Nv, Nb;
    156159  char tlabel[80], field[80], format[80], cformat[80], type[16], tmp[16];
    157160  char *array, *Pin, *Pout, *line;
    … …  
    178181 
    179182  /* check existing table dimensions */
    180   gfits_scan (header, "NAXIS1",  "%d", 1, &Nx);
    181   gfits_scan (header, "NAXIS2",  "%d", 1, &Ny);
     183  gfits_scan (header, "NAXIS1", "%lld", 1, (long long *) &Nx);
     184  gfits_scan (header, "NAXIS2", "%lld", 1, (long long *) &Ny);
    182185  if (Ny == 0) {
    183186    Ny = Nrow;
    184187    header[0].Naxis[1] = Ny;
    185     gfits_modify (header, "NAXIS2",  "%d", 1, Ny);
     188    gfits_modify (header, "NAXIS2", "%lld", 1, (long long) Ny);
    186189
    187190    nbytes = gfits_data_size (header);
    188191    REALLOCATE (table[0].buffer, char, MAX (nbytes, 1));
    189192    bzero (table[0].buffer, nbytes);
    190     table[0].size = nbytes;
     193    table[0].datasize = nbytes;
    191194  }
    192195  if (Ny != Nrow) return (FALSE);

  • trunk/Ohana/src/libfits/table/F_table_format.c

    r26384 r27435  
    33
    44/***********************/
     5// get the format of a table column
     6// Nval : number of joined columns
     7// Nbytes : width of column
    58int gfits_bintable_format (char *format, char *type, int *Nval, int *Nbytes) {
    69
    … …  
    119122
    120123/** extract a table subset to a vtable ***/
    121 int gfits_table_to_vtable (FTable *ftable, VTable *vtable, int start, int Nkeep) {
     124int gfits_table_to_vtable (FTable *ftable, VTable *vtable, off_t start, off_t Nkeep) {
    122125
    123126  /* gfits_table_to_vtable (f, v, 0, Ny - 1) - keep all of table
    … …  
    125128  */ 
    126129
    127   int i, Nx, Ny;
    128 
    129   gfits_scan (ftable[0].header, "NAXIS1", "%d", 1, &Nx);
    130   gfits_scan (ftable[0].header, "NAXIS2", "%d", 1, &Ny);
     130  off_t i, Nx, Ny;
     131
     132  gfits_scan (ftable[0].header, "NAXIS1", "%lld", 1, (long long *) &Nx);
     133  gfits_scan (ftable[0].header, "NAXIS2", "%lld", 1, (long long *) &Ny);
    131134 
    132135  if (start + Nkeep > Ny) return (FALSE);
    … …  
    134137  if (Nkeep < 0) return (FALSE);
    135138
    136   ALLOCATE (vtable[0].row, int, MAX (1, Nkeep));
     139  ALLOCATE (vtable[0].row, off_t, MAX (1, Nkeep));
    137140  ALLOCATE (vtable[0].buffer, char *, MAX (1, Nkeep));
    138141  for (i = 0; i < Nkeep; i++) {
    … …  
    143146 
    144147  vtable[0].header = ftable[0].header;
    145   vtable[0].size = ftable[0].size;
     148  vtable[0].datasize = ftable[0].datasize;
    146149  vtable[0].Nrow = Nkeep;
    147   vtable[0].pad = vtable[0].size - Nx*Ny;
     150  vtable[0].pad = vtable[0].datasize - Nx*Ny;
    148151
    149152  return (TRUE);
    … …  
    151154
    152155/** convert specified rows to vtable */
    153 int gfits_vtable_from_ftable (FTable *ftable, VTable *vtable, int *row, int Nrow) {
    154 
    155   int i, N, Nx, Ny;
    156 
    157   gfits_scan (ftable[0].header, "NAXIS1", "%d", 1, &Nx);
    158   gfits_scan (ftable[0].header, "NAXIS2", "%d", 1, &Ny);
     156int gfits_vtable_from_ftable (FTable *ftable, VTable *vtable, off_t *row, off_t Nrow) {
     157
     158  off_t i, N, Nx, Ny;
     159
     160  gfits_scan (ftable[0].header, "NAXIS1", "%lld", 1, (long long *) &Nx);
     161  gfits_scan (ftable[0].header, "NAXIS2", "%lld", 1, (long long *) &Ny);
    159162
    160163  /* make empty vtable from table */
    161   vtable[0].header = ftable[0].header;  /* make this a copy? */
    162   vtable[0].size   = ftable[0].size;
    163   vtable[0].pad    = vtable[0].size - Nx*Ny;
    164   vtable[0].Nrow   = Ny;
     164  vtable[0].header   = ftable[0].header;  /* make this a copy? */
     165  vtable[0].datasize = ftable[0].datasize;
     166  vtable[0].pad      = vtable[0].datasize - Nx*Ny;
     167  vtable[0].Nrow     = Ny;
    165168
    166169  /* insert selected rows in vtable (mask rows marked with -1) */
    167   ALLOCATE (vtable[0].row, int, Nrow);
     170  ALLOCATE (vtable[0].row, off_t, Nrow);
    168171  ALLOCATE (vtable[0].buffer, char *, Nrow);
    169172  for (N = i = 0; i < Nrow; i++) {
    … …  
    181184char *gfits_table_print (FTable *table,...) {
    182185 
    183   int i, Nx, Nfields;
    184   int off, Nchar, Nval, Nbytes;
     186  off_t Nx, off;
     187  int i, Nchar, Nval, Nbytes, Nfields;
    185188  char *line, format[64], field[16], type[16];
    186189  va_list argp;
    … …  
    188191  va_start (argp, table);
    189192
    190   gfits_scan (table[0].header, "NAXIS1",  "%d", 1, &Nx);
     193  gfits_scan (table[0].header, "NAXIS1",  "%lld", 1, (long long *) &Nx);
    191194  gfits_scan (table[0].header, "TFIELDS", "%d", 1, &Nfields);
    192195
    … …  
    220223// apply table tzero, tscal in situ (from storage to data)
    221224int gfits_table_scale_data (FTable *ftable) {
    222 
    223   int i, j, n, Nx, Ny, Nfields;
    224   int off, Nchar, Nval, Nbytes, status;
     225 
     226  off_t Nx, Ny, off;
     227  int i, j, n, Nfields;
     228  int Nchar, Nval, Nbytes, status;
    225229  char format[64], field[16], type[16];
    226230  double tzero, tscale;
    … …  
    232236  off = 0;
    233237
    234   gfits_scan (ftable[0].header, "NAXIS1",  "%d", 1, &Nx);
    235   gfits_scan (ftable[0].header, "NAXIS2",  "%d", 1, &Ny);
     238  gfits_scan (ftable[0].header, "NAXIS1",  "%lld", 1, (long long *) &Nx);
     239  gfits_scan (ftable[0].header, "NAXIS2",  "%lld", 1, (long long *) &Ny);
    236240  gfits_scan (ftable[0].header, "TFIELDS", "%d", 1, &Nfields);
    237241
    … …  
    304308int gfits_table_scale_storage (FTable *ftable) {
    305309
    306   int i, j, n, Nx, Ny, Nfields;
    307   int off, Nchar, Nval, Nbytes, status;
     310  off_t Nx, Ny, off;
     311  int i, j, n, Nfields;
     312  int Nchar, Nval, Nbytes, status;
    308313  char format[64], field[16], type[16];
    309314  double tzero, tscale;
    … …  
    315320  off = 0;
    316321
    317   gfits_scan (ftable[0].header, "NAXIS1",  "%d", 1, &Nx);
    318   gfits_scan (ftable[0].header, "NAXIS2",  "%d", 1, &Ny);
     322  gfits_scan (ftable[0].header, "NAXIS1",  "%lld", 1, (long long *) &Nx);
     323  gfits_scan (ftable[0].header, "NAXIS2",  "%lld", 1, (long long *) &Ny);
    319324  gfits_scan (ftable[0].header, "TFIELDS", "%d", 1, &Nfields);
    320325

  • trunk/Ohana/src/libfits/table/F_table_row.c

    r15487 r27435  
    33
    44/*********************** fits table column ****************************/
    5 int gfits_add_rows (FTable *table, char *data, int Nrow, int Nbytes) {
     5int gfits_add_rows (FTable *table, char *data, off_t Nrow, off_t Nbytes) {
    66
    7   int Nx, Ny;
    8   int nbytes, Nstart;
     7  off_t Nx, Ny;
     8  off_t nbytes, Nstart;
    99  Header *header;
    1010
    1111  header = table[0].header;
    1212
    13   gfits_scan (header, "NAXIS1", "%d", 1, &Nx);
    14   gfits_scan (header, "NAXIS2", "%d", 1, &Ny);
     13  gfits_scan (header, "NAXIS1", "%lld", 1, (long long *) &Nx);
     14  gfits_scan (header, "NAXIS2", "%lld", 1, (long long *) &Ny);
    1515 
    1616  if (header[0].Naxis[1] != Ny) return (FALSE);
    … …  
    2323  Ny += Nrow;
    2424  header[0].Naxis[1] = Ny;
    25   gfits_modify (header, "NAXIS2",  "%d", 1, Ny);
     25  gfits_modify (header, "NAXIS2",  "%lld", 1, (long long) Ny);
    2626
    2727  nbytes = gfits_data_size (header);
    2828  REALLOCATE (table[0].buffer, char, MAX (nbytes, 1));
    29   table[0].size = nbytes;
     29  table[0].datasize = nbytes;
    3030 
    3131  memcpy (&table[0].buffer[Nstart], data, Nbytes*Nrow);
    … …  
    3535
    3636/*********************** fits add (real) rows to virtual table ****************************/
    37 int gfits_vadd_rows (VTable *table, char *data, int Nrow, int Nbytes) {
     37int gfits_vadd_rows (VTable *table, char *data, off_t Nrow, off_t Nbytes) {
    3838
    39   int i, Nx, Ny;
    40   int Nstart;
     39  off_t i, Nx, Ny;
     40  off_t Nstart;
    4141  Header *header;
    4242
    4343  header = table[0].header;
    4444
    45   gfits_scan (header, "NAXIS1", "%d", 1, &Nx);
    46   gfits_scan (header, "NAXIS2", "%d", 1, &Ny);
     45  gfits_scan (header, "NAXIS1", "%lld", 1, (long long *) &Nx);
     46  gfits_scan (header, "NAXIS2", "%lld", 1, (long long *) &Ny);
    4747 
    4848  if (header[0].Naxis[1] != Ny) return (FALSE);
    … …  
    5454  table[0].Nrow += Nrow;
    5555  REALLOCATE (table[0].buffer, char *, table[0].Nrow);
    56   REALLOCATE (table[0].row, int, table[0].Nrow);
     56  REALLOCATE (table[0].row, off_t, table[0].Nrow);
    5757  for (i = 0; i < Nrow; i++) {
    5858    ALLOCATE (table[0].buffer[Nstart+i], char, MAX (1, Nx));
    … …  
    6464  Ny += Nrow;
    6565  header[0].Naxis[1] = Ny;
    66   gfits_modify (header, "NAXIS2",  "%d", 1, Ny);
     66  gfits_modify (header, "NAXIS2", "%lld", 1, (long long) Ny);
    6767
    68   table[0].size  = gfits_data_size (table[0].header);
    69   table[0].pad    = table[0].size - Nx*Ny;
     68  table[0].datasize = gfits_data_size (table[0].header);
     69  table[0].pad      = table[0].datasize - Nx*Ny;
    7070
    7171  return (TRUE);
    … …  
    7373
    7474/*********************** fits table column ****************************/
    75 int gfits_delete_rows (FTable *table, int Nstart, int Nrow) {
     75int gfits_delete_rows (FTable *table, off_t Nstart, off_t Nrow) {
    7676
    77   int Nx, Ny, N0, N1, N2;
    78   int nbytes;
     77  off_t Nx, Ny, N0, N1, N2;
     78  off_t nbytes;
    7979  Header *header;
    8080
    8181  header = table[0].header;
    8282
    83   gfits_scan (header, "NAXIS1", "%d", 1, &Nx);
    84   gfits_scan (header, "NAXIS2", "%d", 1, &Ny);
     83  gfits_scan (header, "NAXIS1", "%lld", 1, (long long *) &Nx);
     84  gfits_scan (header, "NAXIS2", "%lld", 1, (long long *) &Ny);
    8585 
    8686  if (header[0].Naxis[1] != Ny) return (FALSE);
    … …  
    9797  Ny -= Nrow;
    9898  header[0].Naxis[1] = Ny;
    99   gfits_modify (header, "NAXIS2",  "%d", 1, Ny);
     99  gfits_modify (header, "NAXIS2", "%lld", 1, (long long) Ny);
    100100
    101101  nbytes = gfits_data_size (header);
    102102  REALLOCATE (table[0].buffer, char, MAX (nbytes, 1));
    103   table[0].size = nbytes;
     103  table[0].datasize = nbytes;
    104104  return (TRUE);
    105105}

  • trunk/Ohana/src/libfits/table/F_table_varlength.c

    r18264 r27435  
    44int gfits_varlength_column_define (FTable *ftable, VarLengthColumn *def, int column) {
    55
    6   int i, Nv, Nb;
     6  int i;
     7  int Nv, Nb;
    78  char *p1, *p2, *p3;
    89  char field[81];
    … …  
    3233  // now p1 must be 'P';
    3334  if (*p1 == 0) return (FALSE);
    34   if (*p1 != 'P') return (FALSE);
     35  if ((*p1 != 'P') && (*p1 != 'Q')) return (FALSE);
     36  def->mode = *p1;
    3537
    3638  // next value is the actual varlength column format
    … …  
    6163  }
    6264
    63   if (!gfits_scan (ftable->header, "THEAP", "%d", 1, &def->heap_start)) {
     65  // heap_start must be long long so file may be very large
     66  if (!gfits_scan (ftable->header, "THEAP", "%lld", 1, (long long *) &def->heap_start)) {
    6467    def->heap_start = ftable->header->Naxis[0]*ftable->header->Naxis[1];
    6568  }
    … …  
    6871}
    6972
    70 void *gfits_varlength_column_pointer (FTable *ftable, VarLengthColumn *column, int row, int *length) {
     73// return the data and length for row 'row' of a variable length column
     74// is this capable of handling large files (value holding length and offset is an int)?
     75void *gfits_varlength_column_pointer (FTable *ftable, VarLengthColumn *column, off_t row, off_t *length) {
    7176
    7277  void *result;
    73   int offset, Nx, *ptr;
     78  off_t offset, Nx;
     79
     80  if ((column->mode != 'P') && (column->mode != 'Q')) abort();
    7481
    7582  // find the values for the specified row
    … …  
    8996# endif
    9097
    91   ptr = (int *) &ftable->buffer[row*Nx + column->Nstart];
    92   *length = ptr[0];
    93   offset = ptr[1];
     98  if (column->mode == 'P') {
     99    int *ptr;
     100    ptr = (int *) &ftable->buffer[row*Nx + column->Nstart];
     101    *length = ptr[0];
     102    offset = ptr[1];
     103  }
     104  if (column->mode == 'Q') {
     105    off_t *ptr;
     106    ptr = (off_t *) &ftable->buffer[row*Nx + column->Nstart];
     107    *length = ptr[0];
     108    offset = ptr[1];
     109  }
    94110
    95111  result = (void *) (ftable->buffer + column->heap_start + offset);

  • trunk/Ohana/src/libfits/table/F_write_T.c

    r15743 r27435  
    1313  if (f == (FILE *) NULL) return (FALSE);
    1414 
    15   status = fseek (f, 0, SEEK_END);  /* write table to end of file! */
     15  status = fseeko (f, 0LL, SEEK_END);  /* write table to end of file! */
    1616  status = gfits_fwrite_table (f, table);
    1717
    … …  
    2323int gfits_fwrite_table (FILE *f, FTable *table) {
    2424 
    25   int Nbytes;
     25  off_t Nbytes;
    2626 
    27   Nbytes = fwrite (table[0].buffer, sizeof(char), table[0].size, f);
     27  Nbytes = fwrite (table[0].buffer, sizeof(char), table[0].datasize, f);
    2828 
    29   if (Nbytes != table[0].size) return (FALSE);
     29  if (Nbytes != table[0].datasize) return (FALSE);
    3030  return (TRUE);
    3131}       
    … …  
    3434int gfits_fwrite_vtable (FILE *f, VTable *table) {
    3535 
    36   int i, Nx, Ny, Npad, offset, start;
    37   int Nbytes, *row, Nrow;
     36  off_t i, Nx, Ny, Npad, offset, start;
     37  off_t Nbytes, *row, Nrow;
    3838  char *pad;
    3939
    4040  Nrow = table[0].Nrow;
    4141  row = table[0].row;
    42   gfits_scan (table[0].header, "NAXIS1", "%d", 1, &Nx);
    43   gfits_scan (table[0].header, "NAXIS2", "%d", 1, &Ny);
     42  gfits_scan (table[0].header, "NAXIS1", "%lld", 1, (long long *) &Nx);
     43  gfits_scan (table[0].header, "NAXIS2", "%lld", 1, (long long *) &Ny);
    4444
    4545  /* file pointer is at beginning of desired table data */
    46   start = ftell (f);
     46  start = ftello (f);
    4747 
    4848  for (i = 0; i < Nrow; i++) {
    4949    offset = start + Nx*row[i];
    50     fseek (f, offset, SEEK_SET);
     50    fseeko (f, offset, SEEK_SET);
    5151    Nbytes = fwrite (table[0].buffer[i], sizeof (char), Nx, f);
    5252    if (Nbytes != Nx) { return (FALSE); }
    5353  }
    5454 
    55   Npad = table[0].size - Nx*Ny;
     55  Npad = table[0].datasize - Nx*Ny;
    5656  ALLOCATE (pad, char, Npad);
    5757  bzero (pad, Npad);
    5858
    5959  offset = start + Nx*Ny;
    60   fseek (f, offset, SEEK_SET);
     60  fseeko (f, offset, SEEK_SET);
    6161  Nbytes = fwrite (pad, sizeof (char), Npad, f);
    6262  if (Nbytes != Npad) { return (FALSE); }
    … …  
    7171
    7272/*********************** fits read ftable data ***********************************/
    73 int gfits_fwrite_ftable_range (FILE *f, FTable *ftable, int start, int Nrows, int Ndisk, int Ntotal) {
     73int gfits_fwrite_ftable_range (FILE *f, FTable *ftable, off_t start, off_t Nrows, off_t Ndisk, off_t Ntotal) {
    7474
    75   int Nbytes, Nwrite, Nskip, Nx, Npad;
     75  off_t Nbytes, Nwrite, Nskip, Nx, Npad;
    7676  char *pad;
    7777
    … …  
    7979 
    8080  /* modify vtable to represent full disk table */
    81   gfits_modify (ftable[0].header, "NAXIS2", "%d", 1, Ntotal);
     81  gfits_modify (ftable[0].header, "NAXIS2", "%lld", 1, (long long) Ntotal);
    8282  ftable[0].header[0].Naxis[1] = Ntotal;
    8383
    8484  Nx = ftable[0].header[0].Naxis[0]; // final output table size on disk
    85   ftable[0].size = gfits_data_size (ftable[0].header);
     85  ftable[0].datasize = gfits_data_size (ftable[0].header);
    8686
    8787  Nskip = start * Nx;
    … …  
    9595
    9696  // cursor must be at start of the table (after table header)
    97   fseek (f, Nskip, SEEK_CUR);
     97  fseeko (f, Nskip, SEEK_CUR);
    9898  Nwrite = fwrite (ftable[0].buffer, sizeof (char), Nbytes, f);
    9999  if (Nwrite != Nbytes) {
    … …  
    102102
    103103  if (Ntotal >= Ndisk) {
    104     Npad = ftable[0].size - Nx*Ntotal;
     104    Npad = ftable[0].datasize - Nx*Ntotal;
    105105    ALLOCATE (pad, char, Npad);
    106106    bzero (pad, Npad);

  • trunk/Ohana/src/libfits/table/F_write_TH.c

    r7054 r27435  
    1313  if (f == (FILE *) NULL) return (FALSE);
    1414 
    15   status = fseek (f, 0, SEEK_END);  /* write header to end of file! */
     15  status = fseeko (f, 0LL, SEEK_END);  /* write header to end of file! */
    1616  status = gfits_fwrite_Theader (f, header);
    1717
    … …  
    2323int gfits_fwrite_Theader (FILE *f, Header *header) {
    2424 
    25   int Nbytes;
     25  off_t Nbytes;
    2626 
    27   Nbytes = fwrite (header[0].buffer, sizeof(char), header[0].size, f);
     27  Nbytes = fwrite (header[0].buffer, sizeof(char), header[0].datasize, f);
    2828
    29   if (Nbytes != header[0].size) return (FALSE);
     29  if (Nbytes != header[0].datasize) return (FALSE);
    3030  return (TRUE);
    3131}       

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

    r25757 r27435  
    109109
    110110/* IOfuncs.c */
    111 int KiiSendMessage (int device, char *format, ...);
    112 int KiiScanMessage (int device, char *format, ...);
    113 int KiiSendCommand (int device, int length, char *format, ...);
     111int KiiSendMessage (int device, char *format, ...) OHANA_FORMAT(printf, 2, 3);
     112int KiiScanMessage (int device, char *format, ...) OHANA_FORMAT(scanf, 2, 3);
     113int KiiSendCommand (int device, int length, char *format, ...) OHANA_FORMAT(printf, 3, 4);
     114int KiiScanCommand (int device, int length, char *format, ...) OHANA_FORMAT(scanf, 3, 4);
    114115int KiiSendCommandV (int device, int length, char *format, va_list argp);
    115 int KiiScanCommand (int device, int length, char *format, ...);
    116116int KiiSendData (int device, char *data, int Nbytes);
    117117char *KiiRecvData (int device);

  • trunk/Ohana/src/libohana/Makefile

    r16040 r27435  
    1717FULL_CPPFLAGS = $(BASE_CPPFLAGS)
    1818FULL_LDFLAGS  = $(BASE_LDFLAGS)
    19 TFLAGS        = $(FULL_CFLAGS) $(FULL_LDFLAGS) -ltap_ohana
     19TFLAGS        = $(FULL_CFLAGS) $(FULL_CPPFLAGS) $(FULL_LDFLAGS) -lohana -ltap_ohana
    2020
    2121install: $(DESTLIB)/libohana.a $(DESTLIB)/libohana.$(DLLTYPE)
    2222libohana: $(LIB)/libohana.$(ARCH).a $(LIB)/libohana.$(ARCH).$(DLLTYPE)
    23 testcode: install $(TEST)
    24 test:
    25         make testcode
    26         for i in $(TEST); do $$i; done
    2723
    2824INCS = \
    … …  
    4844$(TESTDIR)/string.$(ARCH)
    4945
     46testcode: install $(TEST)
     47test:
     48        make testcode
     49        for i in $(TEST); do $$i; done
     50
    5051$(OBJS): $(INCS)
    5152

  • trunk/Ohana/src/libohana/include/ohana.h

    r25757 r27435  
    6868# endif
    6969
     70#ifdef __GNUC__
     71#define OHANA_FORMAT(style, fmt, varargs) __attribute__((format(style, fmt, varargs)))
     72#else // __GNUC__
     73#define OHANA_FORMAT(style, fmt, varargs)
     74#endif // __GNUC__
     75
    7076enum {
    7177 LCK_UNLOCK,        /* file is unlocked */
    … …  
    177183char   *SelectConfigFile       PROTO((int *argc, char **argv, char *progname));
    178184char   *LoadConfigFile         PROTO((char *filename));
    179 char   *ScanConfig             PROTO((char *config, char *field, char *mode, int N,...));
     185char   *ScanConfig             PROTO((char *config, char *field, char *mode, int N,...)) OHANA_FORMAT(scanf, 3, 5);
    180186char   *expandline             PROTO((char *line, char *config));
    181187char   *fileextname            PROTO((char *file));
    … …  
    214220int     EmptyIOBuffer          PROTO((IOBuffer *buffer, int Nmax, int fd));
    215221void    FreeIOBuffer           PROTO((IOBuffer *buffer));
    216 int     PrintIOBuffer          PROTO((IOBuffer *buffer, char *format, ...));
     222int     PrintIOBuffer          PROTO((IOBuffer *buffer, char *format, ...)) OHANA_FORMAT(printf, 2, 3);
    217223int     vPrintIOBuffer         PROTO((IOBuffer *buffer, char *format, va_list argp));
    218224
    … …  
    220226int     ExpectMessage          PROTO((int device, double timeout, IOBuffer *message));
    221227int     ExpectCommand          PROTO((int device, int length, double timeout, IOBuffer *buffer));
    222 int     SendMessage            PROTO((int device, char *format, ...));
     228int     SendMessage            PROTO((int device, char *format, ...)) OHANA_FORMAT(printf, 2, 3);
    223229int     SendMessageFixed       PROTO((int device, int length, char *messge));
    224 int     SendCommand            PROTO((int device, int length, char *format, ...));
     230int     SendCommand            PROTO((int device, int length, char *format, ...)) OHANA_FORMAT(printf, 3, 4);
    225231int     SendCommandV           PROTO((int device, int length, char *format, va_list argp));
    226232
    227233char   *CheckForMessage        PROTO((IOBuffer *buffer));
     234
     235off_t   Fread                  PROTO((void *ptr, off_t size, off_t nitems, FILE *f, char *type));
     236off_t   Fwrite                 PROTO((void *ptr, off_t size, off_t nitems, FILE *f, char *type));
    228237
    229238/*

  • trunk/Ohana/src/libohana/include/ohana_sort.h

    r16040 r27435  
    7070void dsortpair (double *X, double *Y, int N);
    7171void isortpair (int *X, int *Y, int N);
     72void llsortpair (off_t *X, off_t *Y, off_t N);
    7273void fsortthree (float *X, float *Y, float *Z, int N);
    7374void dsortthree (double *X, double *Y, double *Z, int N);

  • trunk/Ohana/src/libohana/src/CommOps.c

    r26996 r27435  
    103103int SendMessageFixed (int device, int length, char *message) {
    104104
    105   int status;
    106105  int Nbytes, Nsent;
    107106  struct timespec request, remain;

  • trunk/Ohana/src/libohana/src/Fread.c

    r5851 r27435  
    11# include <ohana.h>
    22
    3 int   ByteSwap (char *ptr, int size, int nitems, char *type);
     3static int ByteSwap (char *ptr, off_t size, off_t nitems, char *type);
    44
    55# define BYTE_EXCHANGE(X,Y) tmp = byte[X]; byte[X] = byte[Y]; byte[Y] = tmp;
    … …  
    3030/* add other architectures here, ie dec, alpha, etc */
    3131
    32 int Fread (void *ptr, int size, int nitems, FILE *f, char *type) {
     32off_t Fread (void *ptr, off_t size, off_t nitems, FILE *f, char *type) {
    3333
    34   int valid, status;
     34  int valid;
     35  off_t status;
    3536
    3637  status = fread (ptr, size, nitems, f);
    … …  
    4243}
    4344
    44 int Fwrite (void *ptr, int size, int nitems, FILE *f, char *type) {
     45off_t Fwrite (void *ptr, off_t size, off_t nitems, FILE *f, char *type) {
    4546
    46   int valid, status;
     47  int valid;
     48  off_t status;
    4749
    4850  valid = ByteSwap (ptr, size, nitems, type);
    … …  
    5456}
    5557
    56 int ByteSwap (char *ptr, int size, int nitems, char *type) {
     58static int ByteSwap (char *ptr, off_t size, off_t nitems, char *type) {
    5759
    5860# ifdef BYTE_SWAP
    5961
    60   int i;
     62  off_t i;
    6163  unsigned char *byte0, *byte1, *byte2, *byte3, *byte4, *byte5, *byte6, *byte7, tmp;
    6264
    … …  
    116118  }
    117119
    118 # if (0) /** now in autocode **/
    119   if (!strcmp (type, "regimage")) {
    120     if (size != REGIMAGE_SIZE) {
    121       fprintf (stderr, "mismatch in type sizes (RegImage) %d vs %d\n", size, REGIMAGE_SIZE);
    122       return (FALSE);
    123     }
    124     byte = (unsigned char *)ptr;
    125     for (i = 0; i < nitems; i++, byte += REGIMAGE_SIZE) {
    126       SWAP_WORD (284); /* exptime */
    127       SWAP_WORD (288); /* airmass */
    128       SWAP_WORD (292); /* sky */     
    129       SWAP_WORD (296); /* bias */   
    130       SWAP_WORD (300); /* fwhm */   
    131       SWAP_WORD (304); /* telfocus */
    132       SWAP_WORD (308); /* xprobe */
    133       SWAP_WORD (312); /* yprobe */
    134       SWAP_WORD (316); /* zprobe */
    135       SWAP_WORD (320); /* dettemp */
    136       SWAP_WORD (324); /* teltemp[0] */
    137       SWAP_WORD (328); /* teltemp[1] */ 
    138       SWAP_WORD (332); /* teltemp[2] */
    139       SWAP_WORD (336); /* teltemp[3] */
    140       SWAP_WORD (340); /* rotangle */
    141       SWAP_WORD (344); /* ra */     
    142       SWAP_WORD (348); /* dec */     
    143       SWAP_WORD (352); /* obstime */
    144       SWAP_WORD (356); /* regtime */ 
    145     }
    146     return (TRUE);
    147   }
    148 
    149   if (!strcmp (type, "detreg")) {
    150     if (size != DETREG_SIZE) {
    151       fprintf (stderr, "mismatch in type sizes (DetReg) %d vs %d\n", size, DETREG_SIZE);
    152       return (FALSE);
    153     }
    154     byte = (unsigned char *)ptr;
    155     for (i = 0; i < nitems; i++, byte += DETREG_SIZE) {
    156       SWAP_WORD (0);   /* tstart */
    157       SWAP_WORD (4);   /* tstop */
    158       SWAP_WORD (8);   /* treg */
    159       SWAP_WORD (12);  /* exptime */
    160       SWAP_WORD (16);  /* type */
    161       SWAP_WORD (20);  /* filter */
    162       SWAP_WORD (24);  /* ccd */
    163       SWAP_WORD (28);  /* Nentry */
    164       SWAP_WORD (32);  /* Norder */
    165     }
    166     return (TRUE);
    167   }
    168 
    169   if (!strcmp (type, "photpars")) {
    170     if (size != PHOTPARS_SIZE) {
    171       fprintf (stderr, "mismatch in type sizes (PhotPars) %d vs %d\n", size, PHOTPARS_SIZE);
    172       return (FALSE);
    173     }
    174     byte = (unsigned char *)ptr;
    175     for (i = 0; i < nitems; i++, byte += PHOTPARS_SIZE) {
    176       SWAP_WORD (0);    /* ZP */
    177       SWAP_WORD (4);    /* ZPo */
    178       SWAP_WORD (8);    /* dZP */
    179       SWAP_WORD (12);   /* K */
    180       SWAP_WORD (16);   /* A */
    181       SWAP_WORD (20);   /* tstart */
    182       SWAP_WORD (24);   /* tstop */
    183       SWAP_BYTE (28);   /* c1 */
    184       SWAP_BYTE (30);   /* c2 */
    185       SWAP_BYTE (32);   /* photcode */
    186       SWAP_WORD (100);   /* Ntime */
    187       SWAP_WORD (104);   /* Nmeas */
    188     }
    189     return (TRUE);
    190   }
    191 
    192   if (!strcmp (type, "missing")) {
    193     if (size != MISSING_SIZE) {
    194       fprintf (stderr, "mismatch in type sizes (Missing) %d vs %d\n", size, MISSING_SIZE);
    195       return (FALSE);
    196     }
    197     byte0 = (unsigned char *)ptr;
    198     byte1 = (unsigned char *)ptr + 1;
    199     byte2 = (unsigned char *)ptr + 2;
    200     byte3 = (unsigned char *)ptr + 3;
    201     for (i = 0; i < nitems; i++, byte0 += 4, byte1 += 4, byte2 += 4, byte3 += 4) {
    202       tmp = *byte0;
    203       *byte0 = *byte3;
    204       *byte3 = tmp;
    205       tmp = *byte1;
    206       *byte1 = *byte2;
    207       *byte2 = tmp;
    208     }
    209     return (TRUE);
    210   }
    211 
    212   if (!strcmp (type, "secfilt")) {
    213     if (size != SECFILT_SIZE) {
    214       fprintf (stderr, "mismatch in type sizes (SecFilt) %d vs %d\n", size, SECFILT_SIZE);
    215       return (FALSE);
    216     }
    217     byte = (unsigned char *) ptr;
    218     for (i = 0; i < nitems; i++, byte += SECFILT_SIZE) {
    219       SWAP_BYTE (0);   /* M */
    220       SWAP_BYTE (2);   /* Xm */
    221       SWAP_BYTE (4);   /* dM */
    222     }
    223     return (TRUE);
    224   }
    225 
    226   if (!strcmp (type, "spectrum")) {
    227     if (size != SPECTRUM_SIZE) {
    228       fprintf (stderr, "mismatch in type sizes (Spectrum) %d vs %d\n", size, SPECTRUM_SIZE);
    229       return (FALSE);
    230     }
    231     byte = (unsigned char *)ptr;
    232     for (i = 0; i < nitems; i++, byte += SPECTRUM_SIZE) {
    233       SWAP_WORD (0);  /* ra */
    234       SWAP_WORD (4);  /* dec */
    235       SWAP_WORD (8);  /* exptime */
    236       SWAP_WORD (12); /* airmass */
    237       SWAP_WORD (16); /* Ws */
    238       SWAP_WORD (20); /* We */
    239       SWAP_WORD (24); /* dW */
    240       SWAP_WORD (28); /* Nspec */
    241       SWAP_WORD (32); /* obstime */
    242       SWAP_WORD (36); /* regtime */
    243     }
    244     return (TRUE);
    245   }
    246 
    247   if (!strcmp (type, "image")) {
    248     if (size != IMAGE_SIZE) {
    249       fprintf (stderr, "mismatch in type sizes (Image) %d vs %d\n", size, IMAGE_SIZE);
    250       return (FALSE);
    251     }
    252     byte = (unsigned char *)ptr;
    253     for (i = 0; i < nitems; i++, byte += IMAGE_SIZE) {
    254       SWAP_DBLE (0); /* coords.crval1 */
    255       SWAP_DBLE (8); /* coords.crval2 */
    256       for (j = 16; j < 104; j+=4) { /* coords.crpix, delt, pc_ij, polyterms[7][2] */
    257         SWAP_WORD (j);
    258       }
    259       SWAP_WORD (120); /* tzero */
    260       SWAP_WORD (124); /* nstar */
    261       for (j = 128; j < 146; j+=2) { /* sec z, NX, NY, apmifit, dapmifit, source, Mcal, dMcal, Xm */
    262         SWAP_BYTE (j);
    263       }
    264       SWAP_WORD (184); /* exptime */
    265       SWAP_WORD (210); /* order */
    266       /**** this (210) is an error! (don't fix, replaced with autocode) ****/
    267       for (j = 212; j < 240; j+=2) {
    268         SWAP_BYTE (j); /* Mx - Myyy */
    269       }
    270     }
    271     return (TRUE);
    272   }
    273 
    274 # if (PANSTARRS)
    275   if (!strcmp (type, "average")) {
    276     if (size != AVERAGE_SIZE) {
    277       fprintf (stderr, "mismatch in type sizes (Average) %d vs %d\n", size, AVERAGE_SIZE);
    278       return (FALSE);
    279     }
    280     byte = (unsigned char *)ptr;
    281     for (i = 0; i < nitems; i++, byte += AVERAGE_SIZE) {
    282       SWAP_DBLE (0);   /* R */
    283       SWAP_DBLE (8);   /* D */
    284       SWAP_BYTE (16);  /* M */
    285       SWAP_BYTE (18);  /* Nm */
    286       SWAP_BYTE (20);  /* Nn */
    287       SWAP_BYTE (22);  /* Xp */
    288       SWAP_BYTE (24);  /* Xm */
    289       SWAP_BYTE (26);  /* code */
    290       SWAP_WORD (28);  /* offset */
    291       SWAP_WORD (32);  /* missing */
    292       SWAP_BYTE (36);  /* dM */
    293       SWAP_BYTE (38);  /* Xg */
    294     }
    295     return (TRUE);
    296   }
    297   if (!strcmp (type, "measure")) {
    298     if (size != MEASURE_SIZE) {
    299       fprintf (stderr, "mismatch in type sizes (Measure) %d vs %d\n", size, MEASURE_SIZE);
    300       return (FALSE);
    301     }
    302     byte = (unsigned char *)ptr;
    303     for (i = 0; i < nitems; i++, byte += MEASURE_SIZE) {
    304       SWAP_BYTE (0);   /* dR */
    305       SWAP_BYTE (2);   /* dD */
    306       SWAP_BYTE (4);   /* M  */
    307       SWAP_BYTE (6);   /* Mcal */
    308       SWAP_BYTE (8);   /* Mgal */
    309       SWAP_BYTE (10);  /* Map  */
    310       SWAP_BYTE (12);  /* FWx */
    311       /* 14, 15, 16, 17 - char */
    312       SWAP_BYTE (18);  /* source */
    313       SWAP_WORD (20);  /* t */
    314       SWAP_WORD (24);  /* averef */
    315       SWAP_BYTE (28);  /* dt */
    316       SWAP_BYTE (30);  /* flags */
    317     }
    318     return (TRUE);
    319   }
    320 
    321 # endif /** PANSTARRS **/
    322 
    323 
    324 # if (ELIXIR)
    325   if (!strcmp (type, "average")) {
    326     if (size != AVERAGE_SIZE) {
    327       fprintf (stderr, "mismatch in type sizes (Average) %d vs %d\n", size, AVERAGE_SIZE);
    328       return (FALSE);
    329     }
    330     byte = (unsigned char *)ptr;
    331     for (i = 0; i < nitems; i++, byte += AVERAGE_SIZE) {
    332       SWAP_WORD (0);   /* R */
    333       SWAP_WORD (4);   /* D */
    334       SWAP_BYTE (8);   /* M */
    335       SWAP_BYTE (10);  /* Nm */
    336       SWAP_BYTE (12);  /* Nn */
    337       SWAP_BYTE (14);  /* Xp */
    338       SWAP_BYTE (16);  /* Xm */
    339       SWAP_BYTE (18);  /* code */
    340       SWAP_WORD (20);  /* offset */
    341       SWAP_WORD (24);  /* missing */
    342       SWAP_BYTE (28);  /* dM */
    343       SWAP_BYTE (30);  /* Xg */
    344     }
    345     return (TRUE);
    346   }
    347   if (!strcmp (type, "measure")) {
    348     if (size != MEASURE_SIZE) {
    349       fprintf (stderr, "mismatch in type sizes (Measure) %d vs %d\n", size, MEASURE_SIZE);
    350       return (FALSE);
    351     }
    352     byte = (unsigned char *)ptr;
    353     for (i = 0; i < nitems; i++, byte += MEASURE_SIZE) {
    354       SWAP_BYTE (0);   /* dR */
    355       SWAP_BYTE (2);   /* dD */
    356       SWAP_BYTE (4);   /* M  */
    357       SWAP_BYTE (6);   /* Mcal */
    358       SWAP_BYTE (8);   /* Mgal */
    359       SWAP_BYTE (10);  /* Map  */
    360       SWAP_BYTE (12);  /* FWx */
    361       /* 14, 15, 16, 17 - char */
    362       SWAP_BYTE (18);  /* source */
    363       SWAP_WORD (20);  /* t */
    364       SWAP_WORD (24);  /* averef */
    365       SWAP_BYTE (28);  /* dt */
    366       SWAP_BYTE (30);  /* flags */
    367     }
    368     return (TRUE);
    369   }
    370 
    371 # endif /** ELIXIR **/
    372 
    373 
    374 # if (LONEOS)
    375   if (!strcmp (type, "average")) {
    376     if (size != OLDAVERAGE_SIZE) {
    377       fprintf (stderr, "mismatch in type sizes (OldAverage) %d vs %d\n", size, OLDAVERAGE_SIZE);
    378       return (FALSE);
    379     }
    380     byte = (unsigned char *)ptr;
    381     for (i = 0; i < nitems; i++, byte += OLDAVERAGE_SIZE) {
    382       SWAP_WORD (0);   /* R */
    383       SWAP_WORD (4);   /* D */
    384       SWAP_BYTE (8);   /* M */
    385       SWAP_BYTE (10); /* Nm */
    386       SWAP_BYTE (12); /* Nn */
    387       SWAP_BYTE (14); /* Xp */
    388       SWAP_BYTE (16); /* Xm */
    389       SWAP_BYTE (18); /* code */
    390       SWAP_WORD (20); /* offset */
    391       SWAP_WORD (24); /* missing */
    392     }
    393     return (TRUE);
    394   }
    395   if (!strcmp (type, "measure")) {
    396     if (size != OLDMEASURE_SIZE) {
    397       fprintf (stderr, "mismatch in type sizes (OldMeasure) %d vs %d\n", size, OLDMEASURE_SIZE);
    398       return (FALSE);
    399     }
    400     byte = (unsigned char *)ptr;
    401     for (i = 0; i < nitems; i++, byte += OLDMEASURE_SIZE) {
    402       SWAP_BYTE (0);   /* dR */
    403       SWAP_BYTE (2);   /* dD */
    404       SWAP_BYTE (4);   /* M  */
    405       SWAP_BYTE (6);   /* Mcal */
    406       SWAP_BYTE (10);  /* source */
    407       SWAP_WORD (12);  /* t */
    408       SWAP_WORD (16);  /* average */
    409     }
    410     return (TRUE);
    411   }
    412 # endif /** LONEOS **/
    413 
    414 # if (0) /*** others ***/
    415   if (!strcmp (type, "oldsecfilt")) {
    416     if (size != OLDSECFILT_SIZE) {
    417       fprintf (stderr, "mismatch in type sizes (OldSecFilt) %d vs %d\n", size, OLDSECFILT_SIZE);
    418       return (FALSE);
    419     }
    420     byte = (unsigned char *) ptr;
    421     for (i = 0; i < nitems; i++, byte += OLDSECFILT_SIZE) {
    422       SWAP_BYTE (0);   /* M */
    423       SWAP_BYTE (2);   /* Xm */
    424     }
    425     return (TRUE);
    426   }
    427   if (!strcmp (type, "rufimage")) {
    428     if (size != RUFIMAGE_SIZE) {
    429       fprintf (stderr, "mismatch in type sizes (RufImage) %d vs %d\n", size, RUFIMAGE_SIZE);
    430       return (FALSE);
    431     }
    432     byte = (unsigned char *)ptr;
    433     for (i = 0; i < nitems; i++, byte += RUFIMAGE_SIZE) {
    434       SWAP_WORD (0);   /* sky */
    435       SWAP_WORD (4);   /* bias */
    436       SWAP_WORD (8);  /* fwhm */
    437       SWAP_WORD (12); /* exptime */
    438       SWAP_WORD (16); /* airmass */
    439       SWAP_WORD (20); /* obstime */
    440       SWAP_BYTE (24); /* ccdnum */
    441     }
    442     return (TRUE);
    443   }
    444   if (!strcmp (type, "olddetreg")) {
    445     if (size != OLDDETREG_SIZE) {
    446       fprintf (stderr, "mismatch in type sizes (DetReg) %d vs %d\n", size, OLDDETREG_SIZE);
    447       return (FALSE);
    448     }
    449     byte = (unsigned char *)ptr;
    450     for (i = 0; i < nitems; i++, byte += OLDDETREG_SIZE) {
    451       SWAP_WORD (0);   /* tstart */
    452       SWAP_WORD (4);   /* tstop */
    453       SWAP_WORD (8);   /* treg */
    454       SWAP_WORD (12);  /* sigma */
    455       SWAP_WORD (16);  /* clipsigma */
    456       SWAP_WORD (20);  /* type */
    457       SWAP_WORD (24);  /* filter */
    458       SWAP_WORD (28);  /* ccd */
    459     }
    460     return (TRUE);
    461   }
    462 # endif /** others **/
    463 # endif /** now in autocode **/
    464 
    465120  fprintf (stderr, "unknown type %s\n", type);
    466121  return (FALSE);

  • trunk/Ohana/src/libohana/src/findexec.c

    r25757 r27435  
    391391
    392392/* fseek with timeout - 0.5 sec */
    393 int Fseek (FILE *f, long offset, int whence) {
     393int Fseek (FILE *f, off_t offset, int whence) {
    394394
    395395  int status, k;
    396396
    397   status = fseek (f, offset, whence);
     397  status = fseeko (f, offset, whence);
    398398  if (status == -1) {
    399     for (k = 0; (k < 10) && ((status = fseek (f, 0, SEEK_SET)) == -1); k++) usleep (50000);
     399    for (k = 0; (k < 10) && ((status = fseeko (f, 0, SEEK_SET)) == -1); k++) usleep (50000);
    400400    if (status == -1) {
    401       return (0);
    402     }
    403   }
    404   return (1);
    405 }
     401      return FALSE;
     402    }
     403  }
     404  return TRUE;
     405}

  • trunk/Ohana/src/libohana/src/glockfile.c

    r4717 r27435  
    117117  if (type == LCK_HARD) {
    118118    /* we've really got the lock, write BUSY to protect it */
    119     fseek (flock, 0, SEEK_SET);
     119    fseeko (flock, 0LL, SEEK_SET);
    120120    nbytes = fprintf (flock, "BUSY\n");
    121121
    … …  
    212212
    213213    /* set value to IDLE */
    214     fseek (flock, 0, SEEK_SET);
     214    fseeko (flock, 0LL, SEEK_SET);
    215215    nbytes = fprintf (flock, "IDLE\n");
    216216    if (nbytes != 5) {

  • trunk/Ohana/src/libohana/src/sorts.c

    r16040 r27435  
    7373}
    7474
     75// sort two int vectors by first vector
     76void llsortpair (off_t *X, off_t *Y, off_t N) {
     77
     78# define SWAPFUNC(A,B){ off_t tmp; \
     79  tmp = X[A]; X[A] = X[B]; X[B] = tmp; \
     80  tmp = Y[A]; Y[A] = Y[B]; Y[B] = tmp; \
     81}
     82# define COMPARE(A,B)(X[A] < X[B])
     83
     84  OHANA_SORT (N, COMPARE, SWAPFUNC);
     85
     86# undef SWAPFUNC
     87# undef COMPARE
     88
     89}
     90
    7591void fsortthree (float *X, float *Y, float *Z, int N) {
    7692

  • trunk/Ohana/src/libohana/src/string.c

    r19825 r27435  
    1313  string[++i] = 0;
    1414  return (i);
    15 
    1615}
    1716

  • trunk/Ohana/src/lightcurve/src/alter_headers.c

    r7080 r27435  
    4646    gfits_modify (&header, "NMcal",  "%d", 1,  images[i].Nstars);
    4747
    48     gfits_modify (&header, "Mcal",   "%C", 1, "relphot: calibration magnitude");
    49     gfits_modify (&header, "dMcal",  "%C", 1, "relphot: calibration error");
    50     gfits_modify (&header, "clouds", "%C", 1, "relphot: cloud level");
    51     gfits_modify (&header, "NMcal",  "%C", 1, "relphot: number of stars");
     48    gfits_modify_alt (&header, "Mcal",   "%C", 1, "relphot: calibration magnitude");
     49    gfits_modify_alt (&header, "dMcal",  "%C", 1, "relphot: calibration error");
     50    gfits_modify_alt (&header, "clouds", "%C", 1, "relphot: cloud level");
     51    gfits_modify_alt (&header, "NMcal",  "%C", 1, "relphot: number of stars");
    5252
    5353    gfits_write_header (head, &header);

  • trunk/Ohana/src/lightcurve/src/fix_header.c

    r7080 r27435  
    77*/
    88
    9 void
    10   fix_header
    11   (Header     *header)
     9void fix_header (Header *header)
    1210{
    1311
    … …  
    1513  char *p1, *p2;
    1614
    17   Nbytes = 2880 * (int) (header[0].size / 2880 + 1);
     15  Nbytes = 2880 * (int) (header[0].datasize / 2880 + 1);
    1816  reallocate (header[0].buffer, char, Nbytes);
    19   bzero (&header[0].buffer[header[0].size], Nbytes - header[0].size - 1);
     17  bzero (&header[0].buffer[header[0].datasize], Nbytes - header[0].datasize - 1);
    2018
    2119  p1 = header[0].buffer - 1;
    … …  
    2422  while (p2 != NULL) {
    2523    if ((N = p2 - p1) != 80) {
    26       bcopy (p2, p1 + 80, header[0].size - (p2 - header[0].buffer));
     24      bcopy (p2, p1 + 80, header[0].datasize - (p2 - header[0].buffer));
    2725      for (i = 0; i < 80 - N; i++) {
    2826        *(p2 + i) = ' ';
    2927      }
    30       header[0].size += 80 - N;
     28      header[0].datasize += 80 - N;
    3129    }
    3230    p1 = strchr (p1 + 1, RETURN);
    … …  
    3432  }
    3533
    36   header[0].size = Nbytes;
     34  header[0].datasize = Nbytes;
    3735  p1 = gfits_header_field (header, "END", 1);
    3836  for (i = 3; i < 79; i++)
    … …  
    4038  *(p1 + 79) = RETURN;
    4139 
    42   Nbytes = header[0].size - (p1 - header[0].buffer) - 80;
     40  Nbytes = header[0].datasize - (p1 - header[0].buffer) - 80;
    4341 
    4442  for (i = 0; i < Nbytes; i++) {
    … …  
    4846  }
    4947
    50   Nbytes = header[0].size - (p1 - header[0].buffer) - 80;
     48  Nbytes = header[0].datasize - (p1 - header[0].buffer) - 80;
    5149  while (Nbytes >= 2880) {
    52     header[0].size -= 2880;
    53     Nbytes = header[0].size - (p1 - header[0].buffer) - 80;
     50    header[0].datasize -= 2880;
     51    Nbytes = header[0].datasize - (p1 - header[0].buffer) - 80;
    5452  }
    5553
    56   reallocate (header[0].buffer, char, header[0].size);
     54  reallocate (header[0].buffer, char, header[0].datasize);
    5755}
    5856

  • trunk/Ohana/src/markrock/src/find_bright_stars.c

    r16040 r27435  
    33void find_bright_stars (Catalog *catalog, CatStats *catstats) {
    44
    5   int i, j, n, m, first_j, Nave, Ngsc, Nmark;
     5  off_t i, j, n, m, first_j, Nave, Ngsc, Nmark;
    66  Catalog GSCdata;
    77  double MinRA, MinDEC, MaxRA, MaxDEC, RaCenter, DecCenter;
    88  Coords *tcoords;
    99  double *X1, *Y1, *X2, *Y2;
    10   int *N1, *N2;
     10  off_t *N1, *N2;
    1111  char *mark;
    1212  double dX, dY, dR, MaxDist, MaxDist1, MaxRadius, radius, radius2;
    … …  
    2424  ALLOCATE (X1, double, Ngsc);
    2525  ALLOCATE (Y1, double, Ngsc);
    26   ALLOCATE (N1, int, Ngsc);
     26  ALLOCATE (N1, off_t, Ngsc);
    2727  ALLOCATE (mark, char, Nave);
    2828  bzero (mark, Nave);

  • trunk/Ohana/src/markrock/src/gcatstats.c

    r16040 r27435  
    66{
    77
    8   int i;
     8  off_t i;
    99  double RaCenter, DecCenter;
    1010  double MinRA, MaxRA, MinDEC, MaxDEC;
    1111  double *X1, *Y1;
    12   int *N1;
    1312  Coords tcoords;
    1413 
    … …  
    3130  ALLOCATE (catstats[0].X, double, catalog[0].Naverage);
    3231  ALLOCATE (catstats[0].Y, double, catalog[0].Naverage);
    33   ALLOCATE (catstats[0].N, int,   catalog[0].Naverage);
     32  ALLOCATE (catstats[0].N, off_t,   catalog[0].Naverage);
    3433
    3534  /* project onto rectilinear grid with 1 arcsec pixels, sort by X */

  • trunk/Ohana/src/markrock/src/wrocks.c

    r2490 r27435  
    1616  }
    1717  /* position to begining of file to write header */
    18   fseek (f, 0, SEEK_END);
     18  fseeko (f, 0, SEEK_END);
    1919
    2020  /* get statistics on rocks */

  • trunk/Ohana/src/markstar/src/find_bright_stars.c

    r16040 r27435  
    33void find_bright_stars (Catalog *catalog, CatStats *catstats) {
    44
    5   int i, j, n, m, first_j, Nave, Ngsc;
     5  off_t i, j, n, m, first_j, Nave, Ngsc;
    66  Catalog GSCdata;
    77  double MinRA, MinDEC, MaxRA, MaxDEC, RaCenter, DecCenter;
    88  Coords *tcoords;
    99  double *X1, *Y1, *X2, *Y2;
    10   int *N1, *N2;
     10  off_t *N1, *N2;
    1111  char *mark;
    1212  double dX, dY, dR, MaxDist, MaxDist1, MaxRadius, radius, radius2;
    … …  
    2525  ALLOCATE (X1, double, Ngsc);
    2626  ALLOCATE (Y1, double, Ngsc);
    27   ALLOCATE (N1, int, Ngsc);
     27  ALLOCATE (N1, off_t, Ngsc);
    2828  ALLOCATE (mark, char, Nave);
    2929  bzero (mark, Nave);

  • trunk/Ohana/src/markstar/src/find_matches.c

    r16040 r27435  
    77  double *X1, *Y1, *X2, *Y2;
    88  double dX, dY, dR;
    9   int *N1, *N2;
     9  off_t *N1, *N2;
    1010  int Nstar, Nghost, Ng;
    1111  unsigned int flags;
    … …  
    2525  ALLOCATE (X1, double, Nghost);
    2626  ALLOCATE (Y1, double, Nghost);
    27   ALLOCATE (N1, int, Nghost);
     27  ALLOCATE (N1, off_t, Nghost);
    2828
    2929  /* project ghosts to the frame of the catalog */

  • trunk/Ohana/src/markstar/src/gcatstats.c

    r16040 r27435  
    33void gcatstats (Catalog *catalog, CatStats *catstats) {
    44
    5   int i;
     5  off_t i;
    66  double RaCenter, DecCenter;
    77  double MinRA, MaxRA, MinDEC, MaxDEC;
    88  double *X1, *Y1;
    9   int *N1;
    109  Coords tcoords;
    1110 
    … …  
    4140  ALLOCATE (catstats[0].X, double, catalog[0].Naverage);
    4241  ALLOCATE (catstats[0].Y, double, catalog[0].Naverage);
    43   ALLOCATE (catstats[0].N, int,   catalog[0].Naverage);
     42  ALLOCATE (catstats[0].N, off_t,  catalog[0].Naverage);
    4443
    4544  /* project onto rectilinear grid with 1 arcsec pixels, sort by X */

  • trunk/Ohana/src/misc/src/addastro.c

    r7080 r27435  
    66  /* USAGE: addastro (cmp) (ref) */
    77
    8   int i, j, nbytes, itmp, oldsize;
     8  off_t nbytes, oldsize;
     9  int i, j, itmp;
    910  double tmp;
    1011  Header header, refhead;
    … …  
    2223    exit (1);
    2324  }
    24   oldsize = header.size;
     25  oldsize = header.datasize;
    2526
    2627  if (!gfits_read_header (argv[2], &refhead)) {
    … …  
    5859  gfits_modify (&header,  "CPRECISE", "%lf", 1, tmp);
    5960
    60   gfits_modify (&header, "CERROR", "%C", 1, "scatter in astrometry soln (arcsec)");
    61   gfits_modify (&header, "CPRECISE", "%C", 1, "precision of astrometry soln (arcsec)");
     61  gfits_modify_alt (&header, "CERROR", "%C", 1, "scatter in astrometry soln (arcsec)");
     62  gfits_modify_alt (&header, "CPRECISE", "%C", 1, "precision of astrometry soln (arcsec)");
    6263
    6364  /* write to file */
    … …  
    7273    exit (1);
    7374  }
    74   nbytes = fwrite (header.buffer, 1, header.size, g);
    75   fseek (g, header.size, SEEK_SET);
     75  nbytes = fwrite (header.buffer, 1, header.datasize, g);
     76  fseeko (g, header.datasize, SEEK_SET);
    7677
    7778  /* read date from file */

  • trunk/Ohana/src/misc/src/applyscat.c

    r21537 r27435  
    1414  Matrix matrix;
    1515  Stars *stars;
    16   int Nstar, Nbytes, nbytes;
     16  int Nstar;
     17  off_t Nbytes, nbytes;
    1718  FILE *f;
    1819  char *buffer, line[10];
    … …  
    3738    exit (1);
    3839  }
    39   fseek (f, header.size, SEEK_SET);
     40  fseeko (f, header.datasize, SEEK_SET);
    4041
    4142  /* find expected number of stars */
    … …  
    110111    exit (1);
    111112  }
    112   fseek (f, header.size, SEEK_SET);
     113  fseeko (f, header.datasize, SEEK_SET);
    113114
    114115  /* load in data */

  • trunk/Ohana/src/misc/src/fakecmp.c

    r7080 r27435  
    44void main (int argc, char **argv) {
    55
    6   int i, j, N, status;
    7   int Nreserved, start_size;
     6  off_t start_size, status;
     7  int i, j, N;
     8  int Nreserved;
    89  char *p, keyword[16], line[256];
    910  FILE *f;
    … …  
    6970    exit (1);
    7071  }
    71   start_size = header.size;
     72  start_size = header.datasize;
    7273
    7374  /* run through the lines in the header data file */
    … …  
    9495    p = (char *) NULL;
    9596    Nreserved = strlen (reserved);
    96     for (i = 0; (i < header.size) && (p == (char *) NULL) ; i+= FT_LINE_LENGTH) {
     97    for (i = 0; (i < header.datasize) && (p == (char *) NULL) ; i+= FT_LINE_LENGTH) {
    9798      if (!strncmp (&header.buffer[i], reserved, Nreserved)) {
    9899        p = &header.buffer[i];
    … …  
    114115  */
    115116
    116   if (header.size != start_size) {
     117  if (header.datasize != start_size) {
    117118    fprintf (stderr, "header changed size: should not happen!\n");
    118119    exit (1);
    … …  
    125126  }
    126127
    127   fseek (f, 0, SEEK_SET);
    128   status = fwrite (header.buffer, 1, header.size, f);
    129   if (status != header.size) {
     128  fseeko (f, 0, SEEK_SET);
     129  status = fwrite (header.buffer, 1, header.datasize, f);
     130  if (status != header.datasize) {
    130131    fprintf (stderr, "failed to write data to image header\n");
    131132    exit (1);

  • trunk/Ohana/src/misc/src/fakestars.c

    r7080 r27435  
    5757    exit (1);
    5858  }
    59   fseek (f, header.size, SEEK_SET);
     59  fseeko (f, header.datasize, SEEK_SET);
    6060
    6161  /* find expected number of stars */
    … …  
    108108    exit (1);
    109109  }
    110   fseek (f, header.size, SEEK_SET);
     110  fseeko (f, header.datasize, SEEK_SET);
    111111
    112112  for (i = 0; i < Nstar; i++) {

  • trunk/Ohana/src/misc/src/fiximg.c

    r7080 r27435  
    3131  fprintf (stderr, "deleted %d comments\n", N);
    3232  p = gfits_header_field (&header, "END", 1);
    33   for (i = 3; i < header.size - (int) (p - header.buffer); i++) {
     33  for (i = 3; i < header.datasize - (int) (p - header.buffer); i++) {
    3434    p[i] = ' ';
    3535  }

  • trunk/Ohana/src/misc/src/fixsimple.c

    r7080 r27435  
    2626  fprintf (stderr, "deleted %d comments\n", N);
    2727  p = gfits_header_field (&header, "END", 1);
    28   for (i = 3; i < header.size - (int) (p - header.buffer); i++) {
     28  for (i = 3; i < header.datasize - (int) (p - header.buffer); i++) {
    2929    p[i] = ' ';
    3030  }
    … …  
    4747  }
    4848
    49   fseek (f, skip, SEEK_SET);
    50   status = fwrite (header.buffer, 1, header.size, f);
    51   if (status != header.size) {
     49  fseeko (f, skip, SEEK_SET);
     50  status = fwrite (header.buffer, 1, header.datasize, f);
     51  if (status != header.datasize) {
    5252    fprintf (stderr, "failed to write data to image header\n");
    5353    exit (1);

  • trunk/Ohana/src/misc/src/striphead.c

    r7080 r27435  
    5151    }
    5252   
    53     for (j = 79; j < header.size; j+= 80) {
     53    for (j = 79; j < header.datasize; j+= 80) {
    5454      header.buffer[j] = 10;
    5555    }

  • trunk/Ohana/src/mosastro/src/LoadStars.c

    r19823 r27435  
    5050
    5151    extend = FALSE;
    52     gfits_scan (&chip[Nchip].header, "EXTEND",  "%t", 1, &extend);
     52    gfits_scan_alt (&chip[Nchip].header, "EXTEND",  "%t", 1, &extend);
    5353    if (extend) {
    5454      status = rfits (&chip[Nchip]);

  • trunk/Ohana/src/mosastro/src/SaveResiduals.c

    r7080 r27435  
    1212  header[0].Naxes = 0;
    1313  gfits_modify (header, "NAXIS",   "%d", 1, 0);
    14   gfits_modify (header, "EXTEND",  "%t", 1, TRUE);
     14  gfits_modify_alt (header, "EXTEND",  "%t", 1, TRUE);
    1515  gfits_modify (header, "NEXTEND", "%d", 1, 1);
    1616

  • trunk/Ohana/src/mosastro/src/getusno.c

    r8499 r27435  
    1111StarData *getusno (CatStats *catstats, int *Nstars) {
    1212
    13   long int offset;
    14   int i, bin, first, last, nitems, Nitems, Nbins;
     13  off_t offset, nitems, Nitems;
     14  int i, bin, first, last, Nbins;
    1515  float hours[100];
    1616  int start[100], number[100], *buffer, *buf;
    … …  
    9191    /* advance file pointer to first slice */
    9292    offset = 3*sizeof(int)*(start[first] - 1);
    93     fseek (f, offset, SEEK_SET);
     93    fseeko (f, offset, SEEK_SET);
    9494    /* on each loop, load data from an RA slice of the catalog */
    9595    for (bin = first; bin < last; bin++) {

  • trunk/Ohana/src/mosastro/src/getusnob.c

    r8499 r27435  
    55StarData *getusnob (CatStats *catstats, int *Nstars) {
    66
    7   long int offset;
    8   int i, bin, first, last, nitems, Nitems, Nbins;
     7  off_t offset, nitems, Nitems;
     8  int i, bin, first, last, Nbins;
    99  float hours[100];
    1010  int start[100], number[100], *buffer, *buf;
    … …  
    7676    /* advance file pointer to first slice */
    7777    offset = NELEM*NBYTE*(start[first] - 1);
    78     fseek (f, offset, SEEK_SET);
     78    fseeko (f, offset, SEEK_SET);
    7979
    8080    /* sum the number of stars in data segment of interest */

  • trunk/Ohana/src/mosastro/src/match.c

    r16040 r27435  
    88  double dp, dq, radius, Radius;
    99  double *p, *q, *P, *Q;
    10   int *U, *u;
     10  off_t *U, *u;
    1111
    1212  /* requested radius is in arcsec ; internally radius is in pixels */
    … …  
    1717  ALLOCATE (P, double, Nrefcat);
    1818  ALLOCATE (Q, double, Nrefcat);
    19   ALLOCATE (U, int, Nrefcat);
     19  ALLOCATE (U, off_t, Nrefcat);
    2020  for (i = 0; i < Nrefcat; i++) {
    2121    U[i] = i;
    … …  
    3535    ALLOCATE (p, double, chip[i].Nstars);
    3636    ALLOCATE (q, double, chip[i].Nstars);
    37     ALLOCATE (u, int, chip[i].Nstars);
     37    ALLOCATE (u, off_t, chip[i].Nstars);
    3838    for (j = 0; j < chip[i].Nstars; j++) {
    3939      u[j] = j;

  • trunk/Ohana/src/mosastro/src/output.c

    r3466 r27435  
    4141  }
    4242
    43   fwrite (header[0].buffer, 1, header[0].size, f);
     43  fwrite (header[0].buffer, 1, header[0].datasize, f);
    4444  fclose (f);
    4545}

  • trunk/Ohana/src/mosastro/src/rfits.c

    r7080 r27435  
    1414    exit (1);
    1515  }
    16   fseek (f, mychip[0].header.size, SEEK_SET);
     16  fseeko (f, mychip[0].header.datasize, SEEK_SET);
    1717
    1818  /* init & load in table data */
    … …  
    3030  }
    3131
    32   stars = gfits_table_get_SMPData (&table, &mychip[0].Nstars, NULL);
     32  off_t Nstars;
     33  stars = gfits_table_get_SMPData (&table, &Nstars, NULL);
     34  mychip[0].Nstars = Nstars;
    3335  gfits_scan (table.header, "NAXIS1", "%d", 1, &Nx);
    3436

  • trunk/Ohana/src/mosastro/src/rtext.c

    r7080 r27435  
    1212    return (FALSE);
    1313  }
    14   fseek (f, mychip[0].header.size, SEEK_SET);
     14  fseeko (f, mychip[0].header.datasize, SEEK_SET);
    1515
    1616  /* find expected number of stars */

  • trunk/Ohana/src/mosastro/src/wfits.c

    r7080 r27435  
    1010  header[0].Naxes = 0;
    1111  gfits_modify (header, "NAXIS",   "%d", 1, 0);
    12   gfits_modify (header, "EXTEND",  "%t", 1, TRUE);
     12  gfits_modify_alt (header, "EXTEND",  "%t", 1, TRUE);
    1313  gfits_modify (header, "NEXTEND", "%d", 1, 1);
    1414

  • trunk/Ohana/src/mosastro/src/wstars.c

    r3520 r27435  
    1616    }
    1717
    18     fwrite (data[0].header.buffer, 1, data[0].header.size, g);
     18    fwrite (data[0].header.buffer, 1, data[0].header.datasize, g);
    1919    fwrite (data[0].buffer, 1, data[0].Nbuffer, g);
    2020    fclose (g);
    … …  
    3434  }
    3535
    36   fwrite (header[0].buffer, 1, header[0].size, g);
     36  fwrite (header[0].buffer, 1, header[0].datasize, g);
    3737
    3838  for (i = 0; i < Nstars; i++) {

  • trunk/Ohana/src/opihi/cmd.astro/altaz.c

    r17282 r27435  
    44# define dSIN(A)   ((double) sin ((double)RAD_DEG*A))
    55
     6int HD_to_AZ(double *alt, double *az, double *rot, double ha, double dec, double lat);
     7int AZ_to_HD(double *ha, double *dec, double *rot, double alt, double az, double lat);
     8
    69double atan2 (double y, double x);
    710
    811int altaz (int argc, char **argv) {
    912 
     13  int i;
    1014  double alt, az, lat, rot;
    1115  double ha, dec;
    12   double sind, sinh, cosh;
    1316  char *latstr;
     17  Vector *hvec, *dvec, *avec, *zvec, *rvec;
     18  opihi_flt *Hv, *Dv, *Av, *Zv, *Rv;
    1419
    15   if (argc != 6) goto usage;
    16 
    17   if (!strcmp (argv[1], "-h")) goto radec;
    18   if (!strcmp (argv[1], "-c")) goto altaz;
    19 
    20  radec:
    21   /* ha/dec -> alt/az */
    22   ha  = atof (argv[2]);
    23   dec = atof (argv[3]);
     20  if (argc != 7) goto usage;
     21  if (strcasecmp (argv[4], "to")) goto usage;
    2422
    2523  latstr = get_variable ("LATITUDE");
    2624  if (latstr == (char *) NULL) {
    2725    gprint (GP_ERR, "please define $LATITUDE\n");
    28     return (FALSE);
     26    return FALSE;
    2927  }
    3028  lat = atof (latstr);
     29  gprint (GP_ERR, "using latitude of %f\n", lat);
    3130  free (latstr);
    32  
     31
     32  if (!strcmp (argv[1], "-az")) goto radec;
     33  if (!strcmp (argv[1], "-hd")) goto altaz;
     34
     35 radec:
     36  if (ISNUM(argv[2][0]) && ISNUM(argv[3][0])) {
     37    /* ha/dec -> alt/az */
     38    ha  = atof (argv[2]);
     39    dec = atof (argv[3]);
     40 
     41    HD_to_AZ (&alt, &az, &rot, ha, dec, lat);
     42
     43    set_variable (argv[5], alt);
     44    set_variable (argv[6], az);
     45    set_variable ("ROT", rot);
     46    return TRUE;
     47  }
     48
     49  /* find vectors */
     50  if ((hvec = SelectVector (argv[2], OLDVECTOR, TRUE)) == NULL) return FALSE;
     51  if ((dvec = SelectVector (argv[3], OLDVECTOR, TRUE)) == NULL) return FALSE;
     52  if ((avec = SelectVector (argv[5], ANYVECTOR, TRUE)) == NULL) return FALSE;
     53  if ((zvec = SelectVector (argv[6], ANYVECTOR, TRUE)) == NULL) return FALSE;
     54  if ((rvec = SelectVector ("ROT",   ANYVECTOR, TRUE)) == NULL) return FALSE;
     55
     56  if (hvec[0].Nelements != dvec[0].Nelements) {
     57    gprint (GP_ERR, "vectors %s and %s not the same length\n", argv[2], argv[3]);
     58    return FALSE;
     59  }
     60 
     61  // cast xvec or yvec to FLT if it is type INT
     62  CastVector (hvec, OPIHI_FLT);
     63  CastVector (dvec, OPIHI_FLT);
     64  ResetVector (avec, OPIHI_FLT, hvec[0].Nelements);
     65  ResetVector (zvec, OPIHI_FLT, hvec[0].Nelements);
     66  ResetVector (rvec, OPIHI_FLT, hvec[0].Nelements);
     67
     68  Hv = hvec[0].elements.Flt;
     69  Dv = dvec[0].elements.Flt;
     70  Av = avec[0].elements.Flt;
     71  Zv = zvec[0].elements.Flt;
     72  Rv = rvec[0].elements.Flt;
     73
     74  for (i = 0; i < hvec[0].Nelements; i++, Hv++, Dv++, Av++, Zv++, Rv++) {
     75    HD_to_AZ (Av, Zv, Rv, *Hv, *Dv, lat);
     76  }
     77  return TRUE;
     78 
     79 altaz:
     80  if (ISNUM(argv[2][0]) && ISNUM(argv[3][0])) {
     81    /* alt/az -> ha/dec */
     82    alt = atof (argv[2]);
     83    az  = atof (argv[3]);
     84
     85    AZ_to_HD (&ha, &dec, &rot, alt, az, lat);
     86
     87    set_variable (argv[5], ha);
     88    set_variable (argv[6], dec);
     89    set_variable ("ROT", rot);
     90    return TRUE;
     91  }
     92 
     93  /* find vectors */
     94  if ((avec = SelectVector (argv[2], OLDVECTOR, TRUE)) == NULL) return FALSE;
     95  if ((zvec = SelectVector (argv[3], OLDVECTOR, TRUE)) == NULL) return FALSE;
     96  if ((hvec = SelectVector (argv[5], ANYVECTOR, TRUE)) == NULL) return FALSE;
     97  if ((dvec = SelectVector (argv[6], ANYVECTOR, TRUE)) == NULL) return FALSE;
     98  if ((rvec = SelectVector ("ROT",   ANYVECTOR, TRUE)) == NULL) return FALSE;
     99
     100  if (avec[0].Nelements != zvec[0].Nelements) {
     101    gprint (GP_ERR, "vectors %s and %s not the same length\n", argv[2], argv[3]);
     102    return FALSE;
     103  }
     104 
     105  // cast xvec or yvec to FLT if it is type INT
     106  CastVector (avec, OPIHI_FLT);
     107  CastVector (zvec, OPIHI_FLT);
     108  ResetVector (hvec, OPIHI_FLT, avec[0].Nelements);
     109  ResetVector (dvec, OPIHI_FLT, avec[0].Nelements);
     110  ResetVector (rvec, OPIHI_FLT, avec[0].Nelements);
     111
     112  Hv = hvec[0].elements.Flt;
     113  Dv = dvec[0].elements.Flt;
     114  Av = avec[0].elements.Flt;
     115  Zv = zvec[0].elements.Flt;
     116  Rv = rvec[0].elements.Flt;
     117
     118  for (i = 0; i < hvec[0].Nelements; i++, Hv++, Dv++, Av++, Zv++, Rv++) {
     119    AZ_to_HD (Hv, Dv, Rv, *Av, *Zv, lat);
     120  }
     121  return TRUE;
     122 
     123 usage:
     124  gprint (GP_ERR, "USAGE: altaz -az (ha) (dec) to (alt) (az)\n");
     125  gprint (GP_ERR, "USAGE: altaz -hd (alt) (az) to (ha) (dec)\n");
     126  gprint (GP_ERR, "       -hd alt/az to ha/dec, -az ha/dec to alt/az\n");
     127  gprint (GP_ERR, "       returned values in variables or vectors provided\n");
     128  return FALSE;
     129}
     130
     131int HD_to_AZ(double *alt, double *az, double *rot, double ha, double dec, double lat) {
     132
     133  double sind, sinh, cosh;
     134
    33135  sind = dSIN (dec) * dSIN (lat) + dCOS (dec) * dCOS (ha) * dCOS (lat);
    34   alt  = DEG_RAD * asin (sind);
     136  *alt  = DEG_RAD * asin (sind);
    35137
    36138  sinh = - dCOS (dec) * dSIN (ha);
    37139  cosh =   dSIN (dec) * dCOS (lat) - dCOS (dec) * dCOS (ha) * dSIN (lat);
    38140
    39   az = DEG_RAD * atan2 (sinh, cosh);
    40   set_variable (argv[4], alt);
    41   set_variable (argv[5], az);
     141  *az = DEG_RAD * atan2 (sinh, cosh);
     142 
     143  sinh = -dCOS(*az) * dSIN(*alt) * dSIN(ha) * dSIN(lat) + dSIN(*az) * dSIN(*alt) * dCOS(ha) - dSIN(ha) * dCOS(*alt) * dCOS(lat);
     144  cosh = -dSIN(*az) * dSIN(ha) * dSIN(lat) - dCOS(*az) * dCOS(ha);
     145  *rot = -DEG_RAD * atan2 (sinh, cosh);
     146 
     147  return TRUE;
     148}
    42149
    43   sinh = -dCOS(az) * dSIN(alt) * dSIN(ha) * dSIN(lat) + dSIN(az) * dSIN(alt) * dCOS(ha) - dSIN(ha) * dCOS(alt) * dCOS(lat);
    44   cosh = -dSIN(az) * dSIN(ha) * dSIN(lat) - dCOS(az) * dCOS(ha);
    45   rot = -DEG_RAD * atan2 (sinh, cosh);
    46   set_variable ("ROT", rot);
     150int AZ_to_HD(double *ha, double *dec, double *rot, double alt, double az, double lat) {
    47151
    48   return (TRUE);
    49  
    50  altaz:
    51   /* alt/az -> ha/dec */
    52   alt = atof (argv[4]);
    53   az  = atof (argv[5]);
    54 
    55   latstr = get_variable ("LATITUDE");
    56   if (latstr == (char *) NULL) {
    57     gprint (GP_ERR, "please define $LATITUDE\n");
    58     return (FALSE);
    59   }
    60   lat = atof (latstr);
    61   free (latstr);
     152  double sind, sinh, cosh;
    62153
    63154  sind = dSIN (alt) * dSIN (lat) + dCOS (alt) * dCOS (az) * dCOS (lat);
    64   dec  = DEG_RAD * asin (sind);
     155  *dec  = DEG_RAD * asin (sind);
    65156
    66157  sinh = -dCOS (alt) * dSIN (az);
    67158  cosh =  dSIN (alt) * dCOS (lat) - dCOS (alt) * dCOS (az) * dSIN (lat);
    68159
    69   ha = DEG_RAD * atan2 (sinh, cosh);
    70   set_variable (argv[2], ha);
    71   set_variable (argv[3], dec);
     160  *ha = DEG_RAD * atan2 (sinh, cosh);
    72161
    73   sinh = -dCOS(az) * dSIN(alt) * dSIN(ha) * dSIN(lat) + dSIN(az) * dSIN(alt) * dCOS(ha) - dSIN(ha) * dCOS(alt) * dCOS(lat);
    74   cosh = -dSIN(az) * dSIN(ha) * dSIN(lat) - dCOS(az) * dCOS(ha);
    75   rot = -DEG_RAD * atan2 (sinh, cosh);
    76   set_variable ("ROT", rot);
     162  sinh = -dCOS(az) * dSIN(alt) * dSIN(*ha) * dSIN(lat) + dSIN(az) * dSIN(alt) * dCOS(*ha) - dSIN(*ha) * dCOS(alt) * dCOS(lat);
     163  cosh = -dSIN(az) * dSIN(*ha) * dSIN(lat) - dCOS(az) * dCOS(*ha);
     164  *rot = -DEG_RAD * atan2 (sinh, cosh);
    77165
    78   return (TRUE);
    79  
    80  usage:
    81   gprint (GP_ERR, "USAGE: altaz -h (ha) (dec) (alt) (az)\n");
    82   gprint (GP_ERR, "USAGE: altaz -c (ha) (dec) (alt) (az)\n");
    83   gprint (GP_ERR, "       -h alt/az to ha/dec, -c ha/dec to alt/az\n");
    84   gprint (GP_ERR, "       returned values in variables provided\n");
    85   return (FALSE);
    86 
     166  return TRUE;
    87167}
    88 

  • trunk/Ohana/src/opihi/cmd.astro/elliprofile.c

    r25757 r27435  
    33int elliprofile (int argc, char **argv) {
    44 
    5   int i, ix, iy, Nx, Ny, N, center;
     5  int i, ix, iy, Nx, Ny;
    66  float *in;
    7   double Rmaj, Rmin, phi, alpha, Io, ARatio;
     7  double Rmaj, Rmin, phi;
    88  double root1, root2, R, A1, A2, A3;
    99  double Sx, Sy, Sxy;
    10   double x, y, r, f, Xo, Yo;
     10  double x, y, Xo, Yo;
    1111  Buffer *buf;
    1212  Vector *rvec, *fvec;

  • trunk/Ohana/src/opihi/cmd.astro/galprofiles.c

    r25757 r27435  
    55int galprofiles (int argc, char **argv) {
    66 
    7   int i, j, Nx, Ny, N, Nsec, NELEMENTS;
     7  int i, Nx, Ny, N, Nsec, NELEMENTS;
    88  float *in;
    99  double theta, dtheta, x, y, Xo, Yo, r, Rmax, value;

  • trunk/Ohana/src/opihi/cmd.astro/galradbins.c

    r25757 r27435  
    1212 
    1313  int i, Nbin;
    14   double Rmin, Rmax;
     14  double Rmax;
    1515  Vector *fvec, *rvec, *Fvec, *Rvec, *Avec;
    1616

  • trunk/Ohana/src/opihi/cmd.astro/galradius.c

    r25757 r27435  
    66int galradius (int argc, char **argv) {
    77 
    8   int i, j, Nx, Ny, N, Nsec, NELEMENTS, Rbin, Nout, above;
    9   double theta, dtheta, x, y, Xo, Yo, r, Rmax, Rmin, value;
     8  int i, j, N, Rbin, Nout, above;
     9  double Rmax, Rmin;
    1010  double Fmin, Fmax, dF, Fm, Fp, Fo, Rsum, Rnpt, Ro;
    1111  opihi_flt *flux, *radius, *values;
    12   Buffer *buf;
    13   Vector *fvec, *rvec, *tvec, *Fvec, *Rvec;
    14   char name[128];
     12  Vector *fvec, *rvec, *Fvec, *Rvec;
    1513
    1614  if (argc != 5) {

  • trunk/Ohana/src/opihi/cmd.astro/petrosian.c

    r25757 r27435  
    44 
    55  int i, above;
    6   float *in;
    76  double Fsum, Asum, Area, R_90, rad_90, flux_90;
    87  Vector *rvec, *avec, *fvec, *Rvec, *Fvec, *Svec, *Avec;
    … …  
    4039  ResetVector (Avec, OPIHI_FLT, fvec[0].Nelements);
    4140
     41  R_90 = 0.1;
    4242  above = TRUE;
    4343  Fsum = 0.0;

  • trunk/Ohana/src/opihi/cmd.astro/precess.c

    r20936 r27435  
    9797  opihi_flt *Dv = yvec[0].elements.Flt;
    9898
    99   for (i = 0; i < xvec[0].Nelements; i++, Av, Dv) {
     99  for (i = 0; i < xvec[0].Nelements; i++, Av++, Dv++) {
    100100    A = *Av;
    101101    D = *Dv;

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

    r25757 r27435  
    33int region (int argc, char **argv) {
    44 
    5   char string[256];
    65  double Ra, Dec, Radius;
    76  float dx, dy;

  • trunk/Ohana/src/opihi/cmd.basic/cd.c

    r25995 r27435  
    5151  }
    5252 
    53   if ((cwd = getcwd(NULL, 64)) == NULL) {
     53  if ((cwd = getcwd(NULL, 1024)) == NULL) {
    5454    gprint (GP_ERR, "error getting cwd\n");
    5555    if (var != NULL) free (var);

  • trunk/Ohana/src/opihi/cmd.basic/date.c

    r12332 r27435  
    4040      set_int_variable (varName, now.tv_sec - REFTIME);
    4141    } else {
    42       gprint (GP_ERR, "%d\n", now.tv_sec - REFTIME);
     42      gprint (GP_ERR, "%d\n", (int) now.tv_sec - REFTIME);
    4343    }
    4444  } else {

  • trunk/Ohana/src/opihi/cmd.basic/inthash.c

    r25965 r27435  
    33int inthash (int argc, char **argv) {
    44
    5   int i, N, modulus, value, input;
     5  int N, modulus, value, input;
    66  char *varName;
    77

  • trunk/Ohana/src/opihi/cmd.basic/test/for.sh

    r14176 r27435  
    169169 $PASS = 1
    170170
    171  if ($endmem - $startmem > 10)
     171 if ($endmem - $startmem > 80)
    172172   $PASS = 0
    173173   echo "growth: {$endmem-$startmem}"

  • trunk/Ohana/src/opihi/cmd.data/dbconnect.c

    r14590 r27435  
    4747    gprint (GP_ERR, "failed to set interactive timout\n");
    4848    gprint (GP_ERR, "%s\n", mysql_error (connection));
    49     free (query);
    5049    return (FALSE);
    5150  }
    … …  
    5756    gprint (GP_ERR, "failed to set wait timout\n");
    5857    gprint (GP_ERR, "%s\n", mysql_error (connection));
    59     free (query);
    6058    return (FALSE);
    6159  }
    … …  
    7169    gprint (GP_ERR, "failed to get timout\n");
    7270    gprint (GP_ERR, "%s\n", mysql_error (connection));
    73     free (query);
    7471    return (FALSE);
    7572  }
    … …  
    8481    gprint (GP_ERR, "failed to get timout\n");
    8582    gprint (GP_ERR, "%s\n", mysql_error (connection));
    86     free (query);
    8783    return (FALSE);
    8884  }

  • trunk/Ohana/src/opihi/cmd.data/extract.c

    r26884 r27435  
    7070    if ((out[0].header.Naxis[1] != Ny) || (out[0].header.Naxis[0] != Nx)) {
    7171      gprint (GP_ERR, "matrix sizes mis-matched\n");
    72       gprint (GP_ERR, "%d x %d  vs  %d x %d\n", Nx, Ny,
    73                out[0].header.Naxis[0], out[0].header.Naxis[1]);
     72      gprint (GP_ERR, "%d x %d  vs  %lld x %lld\n", Nx, Ny,
     73              (long long) out[0].header.Naxis[0], (long long) out[0].header.Naxis[1]);
    7474      return (FALSE);
    7575    }

  • trunk/Ohana/src/opihi/cmd.data/keyword.c

    r7917 r27435  
    107107      }
    108108      ivalue = !strcasecmp (line, "T");
    109       gfits_modify (&buf[0].header, argv[2], "%t", 1, ivalue);
     109      gfits_modify_alt (&buf[0].header, argv[2], "%t", 1, ivalue);
    110110      return (TRUE);
    111111    case KEYCOMMENT:
    112       gfits_modify (&buf[0].header, argv[2], "%C", 1, line);
     112      gfits_modify_alt (&buf[0].header, argv[2], "%C", 1, line);
    113113      return (TRUE);
    114114    case COMMENT:
    115       gfits_modify (&buf[0].header, argv[2], "%S", 0, line);
     115      gfits_modify_alt (&buf[0].header, argv[2], "%S", 0, line);
    116116      return (TRUE);
    117117    }
    … …  
    135135
    136136  if (ascomment) {
    137     status = gfits_scan (&buf[0].header, argv[2], "%C", 1, line);
     137    status = gfits_scan_alt (&buf[0].header, argv[2], "%C", 1, line);
    138138    if (!status) goto failure;
    139139    if (argc == 4)

  • trunk/Ohana/src/opihi/cmd.data/list_header.c

    r7917 r27435  
    4949    gfits_modify (&buf[0].header, "BSCALE", "%lf", 1, bscale);
    5050    gfits_modify (&buf[0].header, "BZERO",  "%lf", 1, bzero);
    51     gfits_modify (&buf[0].header, "UNSIGN", "%t",  1, unsign);
     51    gfits_modify_alt (&buf[0].header, "UNSIGN", "%t",  1, unsign);
    5252   
    5353  } else {

  • trunk/Ohana/src/opihi/cmd.data/matrix.c

    r26891 r27435  
    2323
    2424    if (bufB[0].matrix.Naxis[0] != bufC[0].matrix.Naxis[1]) {
    25       gprint (GP_ERR, "size mis-match in matrices: (%d x %d) * (%d x %d)\n",
    26               bufB[0].matrix.Naxis[0], bufB[0].matrix.Naxis[1],
    27               bufC[0].matrix.Naxis[0], bufC[0].matrix.Naxis[1]);
     25      gprint (GP_ERR, "size mis-match in matrices: (%lld x %lld) * (%lld x %lld)\n",
     26              (long long) bufB[0].matrix.Naxis[0], (long long) bufB[0].matrix.Naxis[1],
     27              (long long) bufC[0].matrix.Naxis[0], (long long) bufC[0].matrix.Naxis[1]);
    2828      return (FALSE);
    2929    }

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

    r20652 r27435  
    153153    buf[0].header.Naxes = 0;
    154154    ALLOCATE (buf[0].matrix.buffer, char, 1);
    155     buf[0].matrix.size = 0;
     155    buf[0].matrix.datasize = 0;
    156156    buf[0].bitpix = 16;
    157157    buf[0].bzero = 0;
    … …  
    222222  buf[0].unsign = buf[0].header.unsign;
    223223
    224   gprint (GP_LOG, "read %d bytes from %s into buffer %s\n",
    225            buf[0].header.size + buf[0].matrix.size, argv[2], argv[1]);
     224  gprint (GP_LOG, "read %lld bytes from %s into buffer %s\n",
     225          (long long) buf[0].header.datasize + buf[0].matrix.datasize, argv[2], argv[1]);
    226226
    227227  blank = 0xffff;

  • trunk/Ohana/src/opihi/cmd.data/rdseg.c

    r20652 r27435  
    6262  buf[0].bzero  = buf[0].header.bzero;     /* store the original values */
    6363  buf[0].unsign = buf[0].header.unsign;
    64   gprint (GP_LOG, "read %d bytes from %s into buffer %s\n",
    65            buf[0].header.size + buf[0].matrix.size, argv[2], argv[1]);
     64  gprint (GP_LOG, "read %lld bytes from %s into buffer %s\n", (long long) buf[0].header.datasize + buf[0].matrix.datasize, argv[2], argv[1]);
    6665
    6766  gfits_scan (&buf[0].header, "BLANK", "%d", 1, &blank);

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

    r20936 r27435  
    5757    return (FALSE);
    5858  }
    59   fseek (f, 0, SEEK_SET);
     59  fseeko (f, 0LL, SEEK_SET);
    6060
    6161  Nvec = (argc - 1) / 2;
    … …  
    159159int read_table_vectors (int argc, char **argv, char *extname) {
    160160
    161   int i, j, k, N, Nbytes, Nextend, Ny, Binary, vecType;
     161  off_t Nbytes;
     162  int i, j, k, N, Nextend, Ny, Binary, vecType;
    162163  char type[16], ID[80], *CCDKeyword;
    163164  FTable table;
    … …  
    184185
    185186  if (f == NULL) ESCAPE ("file not found");
    186   fseek (f, 0, SEEK_SET);
     187  fseeko (f, 0LL, SEEK_SET);
    187188  table.header = &header;
    188189
    … …  
    193194    if (!gfits_load_header (f, &header)) ESCAPE ("error reading primary header for file");
    194195    Nbytes = gfits_data_size (&header);
    195     fseek (f, Nbytes, SEEK_CUR);
     196    fseeko (f, Nbytes, SEEK_CUR);
    196197    gfits_free_header (&header);
    197198
    … …  
    200201      Nbytes = gfits_data_size (&header);
    201202      /* skip the prior data buffers */
    202       fseek (f, Nbytes, SEEK_CUR);
     203      fseeko (f, Nbytes, SEEK_CUR);
    203204      gfits_free_header (&header);
    204205    }
    … …  
    215216
    216217    while (1) {
    217       if (!gfits_load_header (f, &header)) ESCAPE ("extensio not found in file");
     218      if (!gfits_load_header (f, &header)) ESCAPE ("extension not found in file");
    218219      Nbytes = gfits_data_size (&header);
    219220
    220221      if (!gfits_scan (&header, CCDKeyword, "%s", 1, ID)) {
    221         fseek (f, Nbytes, SEEK_CUR);
     222        fseeko (f, Nbytes, SEEK_CUR);
    222223        gfits_free_header (&header);
    223224        continue;
    224225      }
    225226      if (strcmp (ID, extname)) {
    226         fseek (f, Nbytes, SEEK_CUR);
     227        fseeko (f, Nbytes, SEEK_CUR);
    227228        gfits_free_header (&header);
    228229        continue;

  • trunk/Ohana/src/opihi/cmd.data/rebin.c

    r21064 r27435  
    6363    }     
    6464  }
    65   if (VERBOSE) gprint (GP_LOG, "rebin %s to %s (%d,%d to %d,%d)\n", argv[1], argv[2], in[0].header.Naxis[0], in[0].header.Naxis[1], nx, ny);
     65  if (VERBOSE) gprint (GP_LOG, "rebin %s to %s (%lld,%lld to %d,%d)\n", argv[1], argv[2], (long long) in[0].header.Naxis[0], (long long) in[0].header.Naxis[1], nx, ny);
    6666
    6767  Nx = in[0].header.Naxis[0];

  • trunk/Ohana/src/opihi/cmd.data/relocate.c

    r25757 r27435  
    33int relocate (int argc, char **argv) {
    44
    5   char *end;
    65  int x, y;
    76  int N, kapa;

  • trunk/Ohana/src/opihi/cmd.data/rotate.c

    r25584 r27435  
    4343    gfits_modify (&buf[0].header, "NAXIS1", "%d", 1, NY);
    4444    gfits_modify (&buf[0].header, "NAXIS2", "%d", 1, NX);
    45     gfits_print  (&buf[0].header, "HISTORY", "%S", 1, "WARNING: rotated image!");
     45    gfits_print_alt (&buf[0].header, "HISTORY", "%S", 1, "WARNING: rotated image!");
    4646    gfits_create_matrix (&buf[0].header, &buf[0].matrix);
    4747    out_buff = (float *)buf[0].matrix.buffer;
    … …  
    8282    gfits_modify (&buf[0].header, "NAXIS1", "%d", 1, NY);
    8383    gfits_modify (&buf[0].header, "NAXIS2", "%d", 1, NX);
    84     gfits_print  (&buf[0].header, "HISTORY", "%S", 1, "WARNING: rotated image!");
     84    gfits_print_alt (&buf[0].header, "HISTORY", "%S", 1, "WARNING: rotated image!");
    8585    gfits_create_matrix (&buf[0].header, &buf[0].matrix);
    8686    out_buff = (float *)buf[0].matrix.buffer;
    … …  
    120120
    121121  if (!strcasecmp (argv[2], "UPSIDE") || (atof (argv[2]) == -180) || (atof (argv[2]) == 180)) {
    122     gfits_print  (&buf[0].header, "HISTORY", "%S", 1, "WARNING: rotated image!");
     122    gfits_print_alt (&buf[0].header, "HISTORY", "%S", 1, "WARNING: rotated image!");
    123123    gfits_create_matrix (&buf[0].header, &buf[0].matrix);
    124124    out_buff = (float *)buf[0].matrix.buffer;
    … …  
    155155
    156156  if (!strcasecmp (argv[2], "FLIPY")) {
    157     gfits_print  (&buf[0].header, "HISTORY", "%S", 1, "WARNING: rotated image!");
     157    gfits_print_alt (&buf[0].header, "HISTORY", "%S", 1, "WARNING: rotated image!");
    158158    gfits_create_matrix (&buf[0].header, &buf[0].matrix);
    159159    out_buff = (float *)buf[0].matrix.buffer;
    … …  
    190190
    191191  if (!strcasecmp (argv[2], "FLIPX")) {
    192     gfits_print  (&buf[0].header, "HISTORY", "%S", 1, "WARNING: rotated image!");
     192    gfits_print_alt (&buf[0].header, "HISTORY", "%S", 1, "WARNING: rotated image!");
    193193    gfits_create_matrix (&buf[0].header, &buf[0].matrix);
    194194    out_buff = (float *)buf[0].matrix.buffer;
    … …  
    272272  gfits_modify (&buf[0].header, "NAXIS2", "%d", 1, Ly);
    273273  gfits_create_matrix (&buf[0].header, &buf[0].matrix);
    274   gfits_print  (&buf[0].header, "HISTORY", "%S", 1, "WARNING: rotated image!");
     274  gfits_print_alt (&buf[0].header, "HISTORY", "%S", 1, "WARNING: rotated image!");
    275275  out_buff = (float *)buf[0].matrix.buffer;
    276276  for (j = 0; j < Ly; j++) {

  • trunk/Ohana/src/opihi/cmd.data/test/dimendown.sh

    r16056 r27435  
    4242 $startmem = $word:1
    4343
    44  for i 0 1000
     44 for i 0 10000
    4545  dimendown timg val
    4646  dimendown timg xc -x
    … …  
    5353 $PASS = 1
    5454
    55  if ($endmem - $startmem > 10)
     55 if ($endmem - $startmem > 128)
    5656   $PASS = 0
    5757   echo "growth: {$endmem-$startmem}"

  • trunk/Ohana/src/opihi/cmd.data/test/integrate.sh

    r16056 r27435  
    4040 $PASS = 1
    4141
    42  if ($endmem - $startmem > 10)
     42 if ($endmem - $startmem > 128)
    4343   $PASS = 0
    4444   echo "growth: {$endmem-$startmem}"

  • trunk/Ohana/src/opihi/cmd.data/test/interpolate.sh

    r16056 r27435  
    4141 $PASS = 1
    4242
    43  if ($endmem - $startmem > 10)
     43 if ($endmem - $startmem > 128)
    4444   $PASS = 0
    4545   echo "growth: {$endmem-$startmem}"

  • trunk/Ohana/src/opihi/cmd.data/test/periodogram.sh

    r16465 r27435  
    136136 $PASS = 1
    137137
    138  if ($endmem - $startmem > 10)
     138 if ($endmem - $startmem > 180)
    139139   $PASS = 0
    140140   echo "growth: {$endmem-$startmem}"

  • trunk/Ohana/src/opihi/cmd.data/wd.c

    r20652 r27435  
    7575  /* save the (float) version, write out a temporary buffer */
    7676  temp_matrix = buf[0].matrix;
    77   ALLOCATE (temp_matrix.buffer, char, MAX(1, temp_matrix.size));
    78   memcpy (temp_matrix.buffer, buf[0].matrix.buffer, temp_matrix.size);
     77  ALLOCATE (temp_matrix.buffer, char, MAX(1, temp_matrix.datasize));
     78  memcpy (temp_matrix.buffer, buf[0].matrix.buffer, temp_matrix.datasize);
    7979  temp_header = buf[0].header;
    80   ALLOCATE (temp_header.buffer, char, MAX(1, temp_header.size));
    81   memcpy (temp_header.buffer, buf[0].header.buffer, temp_header.size);
     80  ALLOCATE (temp_header.buffer, char, MAX(1, temp_header.datasize));
     81  memcpy (temp_header.buffer, buf[0].header.buffer, temp_header.datasize);
    8282
    8383  if (temp_header.Naxes) {
    … …  
    8888    gfits_modify (&temp_header, "BSCALE", "%lf", 1, outScale);
    8989    gfits_modify (&temp_header, "BZERO",  "%lf", 1, outZero);
    90     gfits_modify (&temp_header, "UNSIGN", "%t", 1, outUnsign);
     90    gfits_modify_alt (&temp_header, "UNSIGN", "%t", 1, outUnsign);
    9191  }
    9292
    … …  
    9494    Header Xhead;
    9595    FILE *f;
     96    off_t nbytes;
    9697    int status, Nextend;
    9798
    … …  
    109110    }
    110111
    111     gfits_modify (&Xhead, "EXTEND", "%t", 1, TRUE);
     112    gfits_modify_alt (&Xhead, "EXTEND", "%t", 1, TRUE);
    112113
    113114    Nextend = 0;
    … …  
    125126   
    126127    /* position to begining of file to write header */
    127     fseek (f, 0, SEEK_SET);
    128     status = fwrite (Xhead.buffer, 1, Xhead.size, f);
    129     if (status != Xhead.size) {
     128    fseeko (f, 0LL, SEEK_SET);
     129    nbytes = fwrite (Xhead.buffer, 1, Xhead.datasize, f);
     130    if (nbytes != Xhead.datasize) {
    130131      gprint (GP_ERR, "ERROR: failed writing data to image header\n");
    131132      status = FALSE;
    … …  
    144145
    145146    /* position to end of file to write new extend */
    146     fseek (f, 0, SEEK_END);
    147     status = fwrite (temp_header.buffer, 1, temp_header.size, f);
     147    fseeko (f, 0LL, SEEK_END);
     148    nbytes = fwrite (temp_header.buffer, 1, temp_header.datasize, f);
    148149    fclose (f);
    149     if (status != temp_header.size) {
     150    if (nbytes != temp_header.datasize) {
    150151      gprint (GP_ERR, "failed to write file\n");
    151152      status = FALSE;

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

    r19823 r27435  
    11# include "dvoshell.h"
    22
    3 void image_subset (Image *image, int Nimage, int **Subset, int *Nsubset,
     3void image_subset (Image *image, off_t Nimage, off_t **Subset, off_t *Nsubset,
    44                   SkyRegionSelection *selection,
    55                   unsigned long int tzero, double trange, int TimeSelect)
    66{
    77
    8   int i, j, flipped, status, InPic;
    9   int *subset;
    10   int N, n, npts;
     8  int j, flipped, status, InPic;
     9  off_t i, n, *subset;
     10  int npts;
    1111  double r, d, X, Y, x[4], y[4], Rmin, Rmax, Rmid;
    1212  Graphdata graph;
    … …  
    4444
    4545  npts = 200;
    46   ALLOCATE (subset, int, npts);
    47   n = N = 0;
     46  ALLOCATE (subset, off_t, npts);
     47  n = 0;
    4848  for (i = 0; i < Nimage; i++) {
    4949    if (TimeSelect && ((image[i].tzero < tzero) || (image[i].tzero+image[i].trate*image[i].NY > tzero + trange))) continue;
    … …  
    114114    if (n > npts - 1) {
    115115      npts += 200;
    116       REALLOCATE (subset, int, npts);
     116      REALLOCATE (subset, off_t, npts);
    117117    }
    118118  }
    119119
    120   REALLOCATE (subset, int, MAX (n, 1));
     120  REALLOCATE (subset, off_t, MAX (n, 1));
    121121  *Subset = subset;
    122122  *Nsubset = n;

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

    r14590 r27435  
    33/* db image table */
    44static Image *image = NULL;
    5 static int *subset = NULL;
    6 static int Nimage = 0;
    7 static int Nsubset = 0;
     5static off_t *subset = NULL;
     6static off_t Nimage = 0;
     7static off_t Nsubset = 0;
    88static Coords mosaic;
    99

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

    r15752 r27435  
    11# include "dvoshell.h"
    22
    3 Image *LoadImages (int *nimage) {
     3Image *LoadImages (off_t *Nimage) {
    44
    55  int status;
    … …  
    2525    gprint (GP_ERR, "note: image catalog is empty\n");
    2626    ALLOCATE (image, Image, 1);
    27     *nimage = 1;
     27    *Nimage = 1;
    2828    return (image);
    2929  }
    … …  
    3737  }
    3838
    39   image = gfits_table_get_Image (&db.ftable, nimage, &db.swapped);
     39  image = gfits_table_get_Image (&db.ftable, Nimage, &db.swapped);
    4040  return (image);
    4141}

  • trunk/Ohana/src/opihi/dvo/Makefile

    r25757 r27435  
    2626$(SRC)/compare.$(ARCH).o                \
    2727$(SRC)/match_image.$(ARCH).o            \
    28 $(SRC)/photometry.$(ARCH).o             \
    2928$(SRC)/dvomisc.$(ARCH).o                \
    3029$(SRC)/region_list.$(ARCH).o            \
     30$(SRC)/photometry.$(ARCH).o             \
    3131$(SRC)/dbBooleanCond.$(ARCH).o          \
    3232$(SRC)/dbCheckStack.$(ARCH).o           \

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

    r19823 r27435  
    4444    NLINES += NDecLines[i];
    4545  }
    46   fseek (f, 5*2880 + 48*NLINES, SEEK_SET);
     46  fseeko (f, 5*2880 + 48*NLINES, SEEK_SET);
    4747     
    4848  done = FALSE;

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

    r24233 r27435  
    33int avextract (int argc, char **argv) {
    44 
    5   int i, j, n, m, N, Npts, NPTS, last, next, state, Nfields, Nreturn, Ncstack, Nstack;
     5  off_t i, j, n, m;
     6  int N, Npts, NPTS, last, next, state, Nfields, Nreturn, Ncstack, Nstack;
    67  int Nsecfilt, mode, VERBOSE;
    78  char **cstack, name[1024];
    … …  
    7980
    8081  /* create output storage vectors */
     82  Npts = 0;
     83  NPTS = 100;
    8184  ALLOCATE (values, dbValue, Nfields);
    8285  ALLOCATE (vec, Vector *, Nreturn);
    … …  
    9093    ResetVector (vec[i], fields[i].type, NPTS);
    9194  }
    92 
    93   Npts = 0;
    94   NPTS = 1;
    9595
    9696  // grab data from all selected sky regions
    … …  
    103103    catalog.Nsecfilt = 0;
    104104
    105     if (VERBOSE) gprint (GP_ERR, "trying %s (%d of %d)\n", catalog.filename, i, skylist[0].Nregions);
     105    if (VERBOSE) gprint (GP_ERR, "trying %s (%lld of %lld)\n", catalog.filename, (long long) i, (long long) skylist[0].Nregions);
    106106     
    107107    // an error exit status here is a significant error

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

    r7917 r27435  
    88int badimages (int argc, char **argv) {
    99 
    10   int i, Nimage, entry, First, Cross;
     10  off_t i, Nimage;
     11  int entry, First, Cross;
    1112  float *ptr;
    1213  double nominal, big, small, value;
    … …  
    3839    ptr = &image[entry].coords.crpix1;
    3940    for (i = 0; i < 22; i++) {
    40       gprint (GP_LOG, "%2d: %g\n", i, ptr[i]);
     41      gprint (GP_LOG, "%2lld: %g\n", (long long) i, ptr[i]);
    4142    }
    4243    value = image[entry].coords.pc1_1*image[entry].coords.pc2_2 + image[entry].coords.pc1_2*image[entry].coords.pc2_1;
    … …  
    5758      value = image[i].coords.pc1_1*image[i].coords.pc2_2 + image[i].coords.pc1_2*image[i].coords.pc2_1;
    5859      if ((value > big) || (value < small)) {
    59         gprint (GP_LOG, "%5d %s: %d %g\n", i, image[i].name, image[i].tzero, value);
     60        gprint (GP_LOG, "%5lld %s: %d %g\n", (long long) i, image[i].name, image[i].tzero, value);
    6061      }
    6162    }
    … …  
    6465      ptr = &image[i].coords.crpix1;
    6566      if ((ptr[entry] > big) || (ptr[entry] < small)) {
    66         gprint (GP_LOG, "%5d %s: %d %g\n", i, image[i].name, image[i].tzero, ptr[entry]);
     67        gprint (GP_LOG, "%5lld %s: %d %g\n", (long long) i, image[i].name, image[i].tzero, ptr[entry]);
    6768      }
    6869    }

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

    r15509 r27435  
    55int calextract (int argc, char **argv) {
    66 
    7   int i, N, Nr, mode[2];
    8   int Nsecfilt, NSTAR;
     7  off_t i, Nr;
     8  int Nsecfilt, NSTAR, N, mode[2];
    99
    1010  PhotCode *code[2];

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

    r20936 r27435  
    66int calmextract (int argc, char **argv) {
    77 
    8   int i, k, N, Nr, mode[2];
    9   int NSTAR, Nstar, Nsecfilt;
     8  off_t i, k, Nr;
     9  int NSTAR, Nstar, Nsecfilt, N, mode[2];
    1010
    1111  Catalog catalog;
    … …  
    169169int ConcatMeasures (Vector *vec, PhotCode *code, int mode, Average *average, SecFilt *secfilt, Measure *measure, int Nin, int param) {
    170170
    171   int i, Ns, N;
     171  off_t i, N;
     172  int Ns;
    172173  double *value;
    173174

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

    r20936 r27435  
    44 
    55  double *M1, *M2;
    6   int i, m, k, Npts, NPTS, N;
    7   int N1, N2, i1, i2, mode[4];
     6  off_t i, m, k, N1, N2, i1, i2;
     7  int Npts, NPTS, N;
     8  int mode[4];
    89  int Nsecfilt, KeepNulls;
    910  void *Signal;

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

    r12332 r27435  
    3737  }
    3838  dvo_catalog_unlock (&catalog1);
    39   gprint (GP_ERR, "read %d stars from phot catalog file %s\n", catalog1.Naverage, filename);
     39  gprint (GP_ERR, "read %lld stars from phot catalog file %s\n", (long long) catalog1.Naverage, filename);
    4040
    4141  /* this is for loading from a text file, presumably hstgsc or usno

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

    r20936 r27435  
    44 
    55  double *M1, *M3;
    6   int i, j, m, i1, i3, N1, N3, N;
     6  off_t i, j, m, N1, N3, i1, i3;
     7  int N;
    78  int Npts, NPTS, mode[3];
    89  int Nsecfilt, KeepNulls;

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

    r12840 r27435  
    44# define BLOCK 1000
    55
    6 CMPstars *cmpReadFits (FILE *f, int *nstars) {
     6CMPstars *cmpReadFits (FILE *f, off_t *nstars) {
    77
    8   int i, Nstars;
     8  off_t i, Nstars;
    99  Header theader;
    1010  FTable table;
    … …  
    4444}
    4545
    46 CMPstars *cmpReadText (FILE *f, int *nstars) {
     46CMPstars *cmpReadText (FILE *f, off_t *nstars) {
    4747
    48   int j, N, Nextra, Ninstar, Nskip, Nbytes, nbytes;
     48  off_t N;
     49  int j, Nextra, Ninstar, Nskip, Nbytes, nbytes;
    4950  int done;
    5051  char *buffer, *c, *c2;

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

    r13479 r27435  
    5656    return (FALSE);
    5757  }
    58   fseek (f, header.size, SEEK_SET);
     58  fseeko (f, header.datasize, SEEK_SET);
    5959
    6060  Noverlay = 0;

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

    r20936 r27435  
    66int cmpread (int argc, char **argv) {
    77 
    8   int i, field, Naxis, Nbytes, Nstars;
     8  off_t i, Nbytes, Nstars;
     9  int field, Naxis;
    910  double tR, tD;
    1011  float value;
    … …  
    6162    return (FALSE);
    6263  }
    63   fseek (f, header.size, SEEK_SET);
     64  fseeko (f, header.datasize, SEEK_SET);
    6465
    6566  /* find expected number of stars */
    66   if (!gfits_scan (&header, "NSTARS", "%d", 1, &Nstars)) {
     67  if (!gfits_scan (&header, "NSTARS", "%lld", 1, (long long *) &Nstars)) {
    6768    gprint (GP_ERR, "ERROR: can't get NSTARS from header\n");
    6869    gfits_free_header (&header);
    … …  
    7677    /* allocate space for stars */
    7778    gprint (GP_ERR, "reading from TEXT cmp file %s\n", argv[2]);
    78     if (!gfits_scan (&header, "NSTARS", "%d", 1, &Nstars)) {
     79    if (!gfits_scan (&header, "NSTARS", "%lld", 1, (long long *) &Nstars)) {
    7980      gprint (GP_ERR, "ERROR: failed to find NSTARS\n");
    8081      exit (1);
    … …  
    8485    gprint (GP_ERR, "reading from FITS cmp file %s\n", argv[2]);
    8586    Nbytes = gfits_data_size (&header);
    86     fseek (f, Nbytes, SEEK_CUR);
     87    fseeko (f, Nbytes, SEEK_CUR);
    8788    stars = cmpReadFits (f, &Nstars);
    8889  }
    … …  
    138139  free (stars);
    139140  gfits_free_header (&header);
    140   gprint (GP_ERR, "loaded %d objects\n", Nstars);
     141  gprint (GP_ERR, "loaded %lld objects\n", (long long) Nstars);
    141142  return (TRUE);
    142143}

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

    r20936 r27435  
    55              Vector *rvec,  Vector *dvec,  Vector *mvec, Vector *drvec, Vector *ddvec, Vector *dmvec, double radius) {
    66
    7   int i, j, first_j, Nmatch, NMATCH;
     7  off_t i, j, first_j, Nmatch, NMATCH;
    88  double dX, dY, dR;
    99

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

    r21508 r27435  
    4242dbValue dbExtractAverages (Average *average, SecFilt *secfilt, Measure *measure, dbField *field) {
    4343
    44   int i, Nsec;
     44  off_t i;
     45  int Nsec;
    4546  dbValue value;
    4647

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

    r21508 r27435  
    5454
    5555/* return image.field based on the selection */
    56 dbValue dbExtractImages (Image *image, int Nimage, int N, dbField *field) {
     56dbValue dbExtractImages (Image *image, off_t Nimage, off_t N, dbField *field) {
    5757
    5858  double x, y;

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

    r20936 r27435  
    77 
    88  FILE *f;
    9   int i, Nimage, status, N, TimeSelect;
     9  off_t i, Nimage, status;
     10  int N, TimeSelect;
    1011  char DataBase[256];
    1112  time_t tzero, tend;
    … …  
    133134    return (FALSE);
    134135  }
    135   fseek (f, header.size, SEEK_SET);
     136  fseeko (f, header.datasize, SEEK_SET);
    136137
    137138  /* load existing data from database */
    138   gfits_scan (&header, "NIMAGES", "%d", 1, &Nimage);
     139  gfits_scan (&header, "NIMAGES", "%lld", 1, (long long *) &Nimage);
    139140  ALLOCATE (pimage, RegImage, Nimage);
    140141  status = fread (pimage, sizeof(RegImage), Nimage, f);
    … …  
    142143
    143144  if (status != Nimage) {
    144     gprint (GP_ERR, "ERROR: header and data in dB don't match (%d vs %d)\n", Nimage, status);
     145    gprint (GP_ERR, "ERROR: header and data in dB don't match (%lld vs %lld)\n", (long long) Nimage, (long long) status);
    145146    gfits_free_header (&header);
    146147    free (pimage);

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

    r14590 r27435  
    1010# if (0)
    1111
    12   int i, m, k, N, kapa, SaveVectors;
    13   int Nsec, Nsecfilt, NPTS;
     12  int kapa, SaveVectors;
     13  int Nsec, Nsecfilt;
     14  off_t i, m, k, N, NPTS;
    1415  double Radius;
    1516  float dt1, dt2, dmt1, dmt2;

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

    r16040 r27435  
    11# include "dvoshell.h"
    22
    3 void cprecess (Average *average, int Naverage, double in_epoch, double out_epoch) {
     3void cprecess (Average *average, off_t Naverage, double in_epoch, double out_epoch) {
    44
    5   int i;
     5  off_t i;
    66  double T;
    77  double A, D, RA, DEC, zeta, z, theta;

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

    r7917 r27435  
    7373
    7474  /* write message to end of file */
    75   fseek (f, 0, SEEK_END);
     75  fseeko (f, 0LL, SEEK_END);
    7676  fprintf (f, "%s\n", message);
    7777

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

    r19823 r27435  
    1313  double RA0, RA1, DEC0, DEC1;
    1414  int i, j, NBigDec;
    15   int NLINES, done, NREGIONS, nregion;
     15  int done, NREGIONS, nregion;
     16  off_t NLINES;
    1617 
    1718  VarConfig ("GSCFILE", "%s", filename);
    … …  
    9192    NLINES += NDecLines[i];
    9293  }
    93   fseek (f, 5*2880 + 48*NLINES, SEEK_SET);
     94  fseeko (f, 5*2880 + 48*NLINES, SEEK_SET);
    9495 
    9596  /* should be in this section.  if not, there is a problem counting... */
    … …  
    140141        NLINES += NDecLines[i];
    141142      }
    142       fseek (f, 5*2880 + 48*NLINES, SEEK_SET);
     143      fseeko (f, 5*2880 + 48*NLINES, SEEK_SET);
    143144      done = FALSE;
    144145      j = 12;

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

    r20936 r27435  
    1010 
    1111  int *list, Nlist;
    12   int i, k, m, N, NP1, NP2, NP, Np, Npts, NPTS;
    13   int N1, N2, i1, i2, mode[4];
     12  off_t i, k, m, N1, N2, i1, i2;
     13  int N, NP1, NP2, NP, Np, Npts, NPTS;
     14  int mode[4];
    1415  int Nsecfilt, status;
    1516  void *oldsignal;
    … …  
    173174    // the selection criteria
    174175  }
    175   gprint (GP_ERR, "using %d possible regions\n", skylist[0].Nregions);
     176  gprint (GP_ERR, "using %lld possible regions\n", (long long) skylist[0].Nregions);
    176177
    177178  /* vectors to save data */

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

    r16810 r27435  
    2424 
    2525  int *hashcode;
    26   int i, j, k, m, N, done, Nfit;
     26  off_t i, j, k, m;
     27  int N, done, Nfit;
    2728  int Nsecfilt, status;
    2829  void *oldsignal;
    … …  
    184185  /* loop over regions, extract data for each region */
    185186  // XXX add interrupt checks
    186   gprint (GP_ERR, "using %d possible regions\n", skylist[0].Nregions);
     187  gprint (GP_ERR, "using %lld possible regions\n", (long long) skylist[0].Nregions);
    187188  for (k = 0; k < skylist[0].Nregions; k++) {
    188189    /* lock, load, unlock catalog */

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

    r27024 r27435  
    55int gimages (int argc, char **argv) {
    66 
    7   int i, j, N, Nimage, Nfound, *subset, Nsubset, status;
     7  off_t i, j, Nimage, *subset, Nsubset;
     8  int N, Nfound, status;
    89  double ra, dec, Ra, Dec, X, Y, Yo;
    910  double trange, t;
    … …  
    114115    {
    115116      Coords local;
    116       double Ro, Do, Xo, Yo, Xs, Ys, Xe, Ye, Radius;
     117      double Ro, Do, Xo, Yo, Xs, Ys, Radius;
    117118     
    118119      if (typehash == DistortImage) {

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

    r23664 r27435  
    1111  double Mcat, Mrel;
    1212  double *RA, *DEC;
    13   int i, j, k, m, N, *N1, Nsecfilt, NPTS, QUIET, FULL_OUTPUT, INST;
    14   int Nstars, found, GetMeasures, Nlo, Nhi;
     13  off_t i, Nstars, *N1;
     14  off_t j, k, m, N, Nlo, Nhi;
     15  int Nsecfilt, NPTS, QUIET, FULL_OUTPUT, INST;
     16  int found, GetMeasures;
    1517  int SaveVectors;
    1618  Vector *vec1, *vec2, *vec3, *vec4, *vec5, *vec6;
    … …  
    102104  ALLOCATE (RA, double, Nstars);
    103105  ALLOCATE (DEC, double, Nstars);
    104   ALLOCATE (N1, int, Nstars);
     106  ALLOCATE (N1, off_t, Nstars);
    105107
    106108  /* find star(s) in RA, DEC list -- use a dumb algorithm for now, improve later */
    … …  
    157159      k = N1[i];
    158160      if (!QUIET) {
    159         gprint (GP_LOG, "star: %d\n", k);
     161        gprint (GP_LOG, "star: %lld\n", (long long) k);
    160162        gprint (GP_LOG, "%11.7f ", catalog.average[k].R);
    161163        gprint (GP_LOG, "%11.7f ", catalog.average[k].D);

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

    r20936 r27435  
    1111int images (int argc, char **argv) {
    1212
    13   int i, j, Nimage, status, InPic, leftside, *plist, TimeSelect, ByName;
     13  off_t i, Nimage;
     14  int j, status, InPic, leftside, *plist, TimeSelect, ByName;
    1415  int WITH_MOSAIC, SOLO_MOSAIC, HIDDEN;
    1516  time_t tzero, tend;

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

    r25757 r27435  
    11# include "dvoshell.h"
    22
     3// LARGEFILES: this function is currently limited to images with Nx,Ny each < 2^31
    34int imbox (int argc, char **argv) {
    45 
    5   int j, kapa, Nskip, status, InPic, flipped, N, haveNx, haveNy, Nx, Ny, SOLO_PHU, Npts, NPTS;
     6  off_t Nskip;
     7  int j, kapa, status, InPic, flipped, N, haveNx, haveNy, Nx, Ny, SOLO_PHU, Npts, NPTS;
    68  Vector Xvec, Yvec;
    79  double r, d, x[4], y[4], Rmin, Rmax, Rmid;
    … …  
    112114  skip:
    113115    Nskip = gfits_data_size (&header);
    114     fseek (f, Nskip, SEEK_CUR);
     116    fseeko (f, Nskip, SEEK_CUR);
    115117    gfits_free_header (&header);
    116118  }

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

    r20936 r27435  
    33int imdata (int argc, char **argv) {
    44 
    5   int i, j, k, I;
    6   int Nimage, N, NPTS, found, mode, TimeSelect;
    7   int n, Nregions, NREGIONS, TimeFormat;
    8   int *subset, Nsubset;
     5  off_t i, j, k, n, I;
     6  int N, NPTS, found, mode, TimeSelect, TimeFormat;
     7  off_t Nregions, NREGIONS;
     8  off_t *subset, Nsubset, Nimage;
    99  double trange;
    1010  time_t tzero, start, stop, TimeReference;

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

    r20936 r27435  
    55 
    66  long A, B;
    7   int i, kapa, N, Nimage, status, NPTS;
     7  off_t i, Nimage;
     8  int kapa, N, status, NPTS;
    89  double r, d, x, y, Rmin, Rmax;
    910  Vector Xvec, Yvec;

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

    r20936 r27435  
    33int imextract (int argc, char **argv) {
    44 
    5   // int *subset, Nsubset;  -- not sure if we need to use this or not...
    6 
    7   int i, j, n, N, Npts, NPTS, last, next, state, Nfields, Nreturn, Ncstack, Nstack;
    8   int Nimage, VERBOSE;
     5  off_t i, j, Nimage;
     6  int n, N, Npts, NPTS, last, next, state, Nfields, Nreturn, Ncstack, Nstack;
     7  int VERBOSE;
    98  char **cstack, name[1024];
    109  void *Signal;
    … …  
    7372
    7473  /* create output storage vectors */
     74  Npts = 0;
     75  NPTS = 100;
    7576  ALLOCATE (values, dbValue, Nfields);
    7677  ALLOCATE (vec, Vector *, Nreturn);
    … …  
    8485    ResetVector (vec[i], fields[i].type, NPTS);
    8586  }
    86 
    87   Npts = 0;
    88   NPTS = 1;
    8987
    9088  if ((image = LoadImages (&Nimage)) == NULL) goto escape;

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

    r17248 r27435  
    33int imlist (int argc, char **argv) {
    44 
    5   int i, j, N, Nimage, *subset, Nsubset, TimeSelect, RegionSelect, TimeFormat, NameSelect;
     5  off_t i, j, Nimage, *subset, Nsubset;
     6  int N, TimeSelect, RegionSelect, TimeFormat, NameSelect;
    67  int PhotcodeSelect;
    78  time_t tzero, TimeReference;
    … …  
    103104      XY_to_RD (&r, &d, 0.5*image[i].NX, 0.5*image[i].NY, &image[i].coords);
    104105    }
    105     gprint (GP_LOG, "%3d %s %8.4f %8.4f %f %5d %2d %4.2f %5.3f %5.3f\n",
    106             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 %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);
    107108  }
    108109

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

    r14590 r27435  
    66  double trange;
    77  int N, GreyScale;
    8   int i, j, Nimage, Nsubset, *subset;
     8  off_t i, j, Nimage, Nsubset, *subset;
    99  char bufname[64];
    1010  float *p;

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

    r20936 r27435  
    11# include "dvoshell.h"
    2 RegImage *load_imreg (char *DataBase, int *nimage);
     2RegImage *load_imreg (char *DataBase, off_t *nimage);
    33
    44# define NVALUE 22
    … …  
    88int imrough (int argc, char **argv) {
    99 
    10   int i, N, Nimage, TimeSelect;
     10  off_t i, Nimage;
     11  int N, TimeSelect;
    1112  int ModeSelect, TypeSelect, CCDSelect, FilterSelect, TimeFormat;
    1213  int type, value, mode, CCD, NVEC;
    … …  
    231232}
    232233
    233 RegImage *load_imreg (char *DataBase, int *nimage) {
    234 
    235   int Nimage, status;
     234RegImage *load_imreg (char *DataBase, off_t *nimage) {
     235
     236  off_t Nimage;
     237  int status;
    236238  char line[80];
    237239  FILE *f;
    … …  
    262264  if (!strcmp (line, "MDM Observatory")) {
    263265
    264     fseek (f, header.size, SEEK_SET);
     266    fseeko (f, header.datasize, SEEK_SET);
    265267   
    266268    /* load existing data from database */
    267     gfits_scan (&header, "NIMAGES", "%d", 1, &Nimage);
     269    gfits_scan (&header, "NIMAGES", "%lld", 1, (long long *) &Nimage);
    268270    ALLOCATE (image, RegImage, Nimage);
    269271    status = fread (image, sizeof(RegImage), Nimage, f);
    … …  
    271273   
    272274    if (status != Nimage) {
    273       gprint (GP_ERR, "ERROR: header and data in dB don't match (%d vs %d)\n", Nimage, status);
     275      gprint (GP_ERR, "ERROR: header and data in dB don't match (%lld vs %d)\n", (long long) Nimage, status);
    274276      gfits_free_header (&header);
    275277      free (image);
    … …  
    302304  /* convert to internal format */
    303305  image = (RegImage *) table.buffer;
    304   gfits_scan (table.header, "NAXIS2", "%d", 1, &Nimage);
     306  gfits_scan (table.header, "NAXIS2", "%lld", 1, (long long *) &Nimage);
    305307  gfits_convert_RegImage (image, sizeof (RegImage), Nimage);
    306308

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

    r14590 r27435  
    77  Header header;
    88  RegImage *pimage;
    9   int i, Nimage, status, N, TimeSelect, SaveNames;
     9  off_t i, Nimage, status;
     10  int N, TimeSelect, SaveNames;
    1011  int ModeSelect, TypeSelect, CCDSelect, FilterSelect;
    1112  char *Filter, *obstime;
    … …  
    102103    return (FALSE);
    103104  }
    104   fseek (f, header.size, SEEK_SET);
     105  fseeko (f, header.datasize, SEEK_SET);
    105106
    106107  /* load existing data from database */
    107   gfits_scan (&header, "NIMAGES", "%d", 1, &Nimage);
     108  gfits_scan (&header, "NIMAGES", "%lld", 1, (long long *) &Nimage);
    108109  ALLOCATE (pimage, RegImage, Nimage);
    109110  status = fread (pimage, sizeof(RegImage), Nimage, f);
    110111  fclose (f);
    111112  if (status != Nimage) {
    112     gprint (GP_ERR, "ERROR: header and data in dB don't match (%d vs %d)\n", Nimage, status);
     113    gprint (GP_ERR, "ERROR: header and data in dB don't match (%lld vs %lld)\n", (long long) Nimage, (long long) status);
    113114    gfits_free_header (&header);
    114115    free (pimage);
    … …  
    130131    obstime[strlen(obstime)-1] = 0;
    131132
    132     gprint (GP_LOG, "%5d %6s %6s %2d %2d   ", i, get_type_name(pimage[i].type), get_mode_name(pimage[i].mode), pimage[i].ccd, pimage[i].type);
     133    gprint (GP_LOG, "%5lld %6s %6s %2d %2d   ", (long long) i, get_type_name(pimage[i].type), get_mode_name(pimage[i].mode), pimage[i].ccd, pimage[i].type);
    133134    gprint (GP_LOG, "%s %s  ", pimage[i].pathname, pimage[i].filename);
    134135    gprint (GP_LOG, "%s %s %f %s\n", pimage[i].filter, pimage[i].instrument, pimage[i].exptime, obstime);

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

    r20936 r27435  
    33int imstats (int argc, char **argv) {
    44 
    5   int i, kapa, Nimage, N;
     5  off_t i, Nimage;
     6  int kapa, N;
    67  int Mcal, AutoLimits;
    78  double r, d;

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

    r20936 r27435  
    77  double *RA, *DEC;
    88  int kapa, TimeFormat;
    9   int Nstars, found, AutoLimits, ErrorBars, GalMag, AbsPhot, SaveVectors;
    10   int i, j, m, N, NPTS, *N1;
     9  int found, AutoLimits, ErrorBars, GalMag, AbsPhot, SaveVectors;
     10  off_t i, j, m, Nstars, *N1;
     11  int N, NPTS;
    1112  time_t TimeReference;
    1213  struct tm *timeptr;
    … …  
    8889  ALLOCATE (RA, double, Nstars);
    8990  ALLOCATE (DEC, double, Nstars);
    90   ALLOCATE (N1, int, Nstars);
     91  ALLOCATE (N1, off_t, Nstars);
    9192
    9293  /* find star(s) in RA, DEC list -- use a dumb algorithm for now, improve later */

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

    r20936 r27435  
    55  double Ra, Dec, Radius, Radius2, r;
    66  double *RA, *DEC;
    7   int Nstars, found, PhotCodeSelect;
    8   int i, j, k, m, N, NPTS, Nsecfilt, RELPHOT, *N1, TimeFormat;
     7  off_t i, j, k, m, Nstars, *N1;
     8  int found, PhotCodeSelect;
     9  int N, NPTS, Nsecfilt, RELPHOT, TimeFormat;
    910  time_t TimeReference;
    1011
    … …  
    7172  ALLOCATE (RA, double, Nstars);
    7273  ALLOCATE (DEC, double, Nstars);
    73   ALLOCATE (N1, int, Nstars);
     74  ALLOCATE (N1, off_t, Nstars);
    7475
    7576  /* find star(s) in RA, DEC list -- use a dumb algorithm for now, improve later */

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

    r12332 r27435  
    11# include "dvoshell.h"
    22
    3 int match_image (Image *image, int Nimage, unsigned int T, short int S) {
     3off_t match_image (Image *image, off_t Nimage, unsigned int T, short int S) {
    44
    5   int N, Nlo, Nhi, N1, N2;
     5  off_t N, Nlo, Nhi, N1, N2;
    66
    77  /* bracket first value of interest */
    … …  
    3737}
    3838
    39 int match_image_subset (Image *image, int *subset, int Nsubset, unsigned int T, short int S) {
     39off_t match_image_subset (Image *image, off_t *subset, off_t Nsubset, unsigned int T, short int S) {
    4040
    41   int N, Nlo, Nhi, N1, N2;
     41  off_t N, Nlo, Nhi, N1, N2;
    4242
    4343  /* bracket first value of interest */

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

    r26285 r27435  
    33int mextract (int argc, char **argv) {
    44 
    5   int i, j, k, m, n, N, Npts, NPTS, last, next, state, Nfields, Nreturn, Ncstack, Nstack;
     5  off_t i, j, k, m; // used for counter averages and measures
     6  int n, N, Npts, NPTS, last, next, state, Nfields, Nreturn, Ncstack, Nstack;
    67  int Nsecfilt, VERBOSE, loadImages, mosaicMode;
    78  char **cstack, name[1024];
    … …  
    119120    catalog.Nsecfilt = Nsecfilt;
    120121
    121     if (VERBOSE) gprint (GP_ERR, "trying %s (%d of %d)\n", catalog.filename, i, skylist[0].Nregions);
     122    if (VERBOSE) gprint (GP_ERR, "trying %s (%lld of %lld)\n", catalog.filename, (long long) i, (long long) skylist[0].Nregions);
    122123     
    123124    // an error exit status here is a significant error

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

    r24233 r27435  
    33int mmextract (int argc, char **argv) {
    44 
    5   int i, j, k, m, n, N, Npts, NPTS, last, next, state;
     5  off_t i, j, k, m;
     6  int n, N, Npts, NPTS, last, next, state;
    67  int Nfields, Nreturn, Nreturn_base, Ncstack1, Ncstack2, Nstack1, Nstack2;
    78  int Nwhere, Iwhere, Nmatch, Imatch, NTABLE, Nt1, Nt2, n1, n2;
    … …  
    185186    catalog.Nsecfilt = Nsecfilt;
    186187
    187     if (VERBOSE) gprint (GP_ERR, "trying %s (%d of %d)\n", catalog.filename, i, skylist[0].Nregions);
     188    if (VERBOSE) gprint (GP_ERR, "trying %s (%lld of %lld)\n", catalog.filename, (long long) i, (long long) skylist[0].Nregions);
    188189     
    189190    // an error exit status here is a significant error

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

    r21508 r27435  
    55 
    66  FILE *f;
    7   int i, j, kapa, Narg, Npts, NPTS, status, VERBOSE;
     7  off_t i, j;
     8  int kapa, Narg, Npts, NPTS, status, VERBOSE;
    89  int Nsecfilt, Nsec, Nloaded;
    910  double Mz, Mr, mag;

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

    r25757 r27435  
    336336int ListPhotSelections () {
    337337
    338   gprint (GP_ERR, "TimeSelect: %d, %d - %d\n",      TimeSelect, tzero, tend);
     338  gprint (GP_ERR, "TimeSelect: %d, %s - %s\n",      TimeSelect, ctime(&tzero), ctime(&tend));
    339339  gprint (GP_ERR, "MagSelect: %d, %f - %f\n",       MagSelect, MagMax, MagMin);
    340340  gprint (GP_ERR, "TypeSelect: %d, %d\n",           TypeSelect, TypeValue);
    … …  
    555555
    556556/* extract a list of measure parameters from the specified average entry based on the pre-set selections */
    557 double *ExtractMeasures (PhotCode *code, int mode, Average *average, SecFilt *secfilt, Measure *measure, int *nlist, int param) {
    558 
    559   int i, Nlist, NLIST;
     557double *ExtractMeasures (PhotCode *code, int mode, Average *average, SecFilt *secfilt, Measure *measure, off_t *nlist, int param) {
     558
     559  off_t i, Nlist, NLIST;
    560560  double M, *list;
    561561 
    … …  
    585585double ExtractAverages (PhotCode *code, int mode, Average *average, SecFilt *secfilt, Measure *measure, int param) {
    586586
    587   int i;
     587  off_t i;
    588588  double value;
    589589
    … …  
    714714
    715715  double frac;
    716   int k, Nc, Nt;
     716  int Nc, Nt;
     717  off_t k;
    717718 
    718719  Nt = Nc = 0;
    … …  
    730731int DetermineTypeCode (Average *average, Measure *measure, int code) {
    731732
    732   int k, N, Nt[3];
     733  off_t k;
     734  int N, Nt[3];
    733735 
    734736  Nt[0] = Nt[1] = Nt[2] = 0;
    … …  
    788790int TestAverage (PhotCode *code, Average *average, SecFilt *secfilt, Measure *measure) {
    789791
    790   int i, Nm, Type, Select;
     792  off_t i, Nm;
     793  int Type, Select;
    791794  double fwhm, typefrac, dM, Xm;
    792795
    … …  
    937940
    938941
    939 double *ExtractMagnitudes (PhotCode *code, int mode, Average *average, SecFilt *secfilt, Measure *measure, int *n) {
     942double *ExtractMagnitudes (PhotCode *code, int mode, Average *average, SecFilt *secfilt, Measure *measure, off_t *n) {
    940943 
    941944  double *M, mag;
    942   int N;
     945  off_t N;
    943946
    944947  if ((mode == MAG_AVE) || (mode == MAG_REF)) {
    … …  
    960963
    961964/* extract delta-mag pairs applying specified selections */
    962 double *ExtractDMag (PhotCode **code, int *mode, Average *average, SecFilt *secfilt, Measure *measure, int *nlist) {
    963 
    964   int i, j, A1, A2, N1, N2, Np, Nlist, NLIST;
     965double *ExtractDMag (PhotCode **code, int *mode, Average *average, SecFilt *secfilt, Measure *measure, off_t *nlist) {
     966
     967  int A1, A2;
     968  off_t i, j, N1, N2, Np, Nlist, NLIST;
    965969  double *M1, *M2, *list;
    966970
    … …  
    10091013/* extract a list of delta-measure-mags from the specified average entry based on the
    10101014   pre-set selections - does not return self-matched measurements */
    1011 double *ExtractMeasuresDMag (PhotCode **code, int *mode, Average *average, SecFilt *secfilt, Measure *measure, int *nlist) {
    1012 
    1013   int i, j, Np0, Np1, Nlist, NLIST;
     1015double *ExtractMeasuresDMag (PhotCode **code, int *mode, Average *average, SecFilt *secfilt, Measure *measure, off_t *nlist) {
     1016
     1017  int Np0, Np1;
     1018  off_t i, j, Nlist, NLIST;
    10141019  double *list, M1, M2;
    10151020 
    … …  
    10561061
    10571062/* extract a measurement list matching the number of dmag entries */
    1058 double *ExtractByDMag (PhotCode **code, int *mode, Average *average, SecFilt *secfilt, Measure *measure, int *nlist, int param) {
    1059 
    1060   int A1, A2, N1;
     1063double *ExtractByDMag (PhotCode **code, int *mode, Average *average, SecFilt *secfilt, Measure *measure, off_t *nlist, int param) {
     1064
     1065  off_t N1;
     1066  int A1, A2;
    10611067  double *list;
    10621068
    … …  
    10801086 
    10811087/* extract a list of delta-measure-mags from the specified average entry based on the pre-set selections */
    1082 double *ExtractMeasuresByDMag (PhotCode **code, int *mode, int use_first, Average *average, SecFilt *secfilt, Measure *measure, int *nlist, int param) {
    1083 
    1084   int i, j, n, Nlist, NLIST;
     1088double *ExtractMeasuresByDMag (PhotCode **code, int *mode, int use_first, Average *average, SecFilt *secfilt, Measure *measure, off_t *nlist, int param) {
     1089
     1090  off_t i, j, n, Nlist, NLIST;
    10851091  double *list, M1, M2;
    10861092 

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

    r21508 r27435  
    77 
    88  FILE *f;
    9   int i, j, k, m, kapa, Narg, Npts, NPTS, status, VERBOSE, TimeSelect, Nloaded;
     9  off_t i, j, k, m;
     10  int kapa, Narg, Npts, NPTS, status, VERBOSE, TimeSelect, Nloaded;
    1011  double Mz, Mr, mag;
    1112  double Radius, Rmin, Rmax, R, D, trange;

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

    r20936 r27435  
    8989    return (FALSE);
    9090  }
    91   fseek (f, header.size, SEEK_SET);
     91  fseeko (f, header.datasize, SEEK_SET);
    9292
    9393  /* set up storage buffers */

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

    r27262 r27435  
    66
    77  int WITH_MOSAIC, SOLO_MOSAIC;
    8   int i, N, Nimage, status, TimeSelect, ByName, xs, ys;
     8  off_t i, Nimage;
     9  int N, status, TimeSelect, ByName, xs, ys;
    910  time_t tzero, tend;
    1011  double pixscale, dX, dY, Npts, r, d, Xi, Yi, Xs, Ys, x[2], y[2], trange, RaCenter, DecCenter;

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

    r19823 r27435  
    33int subpix (int argc, char **argv) {
    44 
    5   int i, j, I, Nlo, Nhi, Nentry, Nstars, Nimage, Nmeasure;
    6   int *index, *entry;
    7   int Nmin, Nsub, NSUB, status;
    8   int TimeFormat;
     5  off_t Nlo, Nhi, *entry, Nentry;
     6  off_t j, i, I, *index, Nstars, Nimage, Nmeasure;
     7  off_t Nmin, Nsub, NSUB;
     8  int status, TimeFormat;
    99  time_t Timage, TimeReference;
    1010  double X, Y, Mabs, t;
    … …  
    5454  ALLOCATE (RA, double, Nstars);
    5555  ALLOCATE (DEC, double, Nstars);
    56   ALLOCATE (index, int, Nstars);
     56  ALLOCATE (index, off_t, Nstars);
    5757  for (i = 0; i < Nstars; i++) {
    5858    RA[i] = catalog.average[i].R;
    … …  
    6565  Nlo = bracket (DEC, Nstars, FALSE, Dec - Radius);
    6666  Nhi = bracket (DEC, Nstars, TRUE,  Dec + Radius);
    67   ALLOCATE (entry, int, MAX (Nhi - Nlo, 1));
     67  ALLOCATE (entry, off_t, MAX (Nhi - Nlo, 1));
    6868  Nentry = 0;
    6969
    … …  
    111111  Nsub = 0;
    112112  NSUB = 100;
    113   ALLOCATE (index, int, NSUB);
     113  ALLOCATE (index, off_t, NSUB);
    114114
    115115  /* load all images, extract those touching Ra, Dec */
    … …  
    125125    if (Nsub == NSUB - 1) {
    126126      NSUB += 100;
    127       REALLOCATE (index, int, NSUB);
     127      REALLOCATE (index, off_t, NSUB);
    128128    }
    129129  }

  • trunk/Ohana/src/opihi/include/data.h

    r26891 r27435  
    7777/* in fft.c */
    7878void fft1D (float *dataRe, float *dataIm, int N, int Nbit, int forward);
    79 int fftND (float *dataRe, float *dataIm, int Ndim, int *Nsize, int forward);
     79int fftND (float *dataRe, float *dataIm, int Ndim, off_t *Nsize, int forward);
    8080void dfft1D (double *dataRe, double *dataIm, int N, int Nbit, int forward);
    8181int dfftND (double *dataRe, double *dataIm, int Ndim, int *Nsize, int forward);

  • trunk/Ohana/src/opihi/include/display.h

    r21153 r27435  
    3636int SendLabel (char *string, int Xgraph, int mode);
    3737
    38 int SendGraphMessage (int device, char *format, ...);
    39 int SendGraphCommand (int device, int length, char *format, ...);
     38int SendGraphMessage (int device, char *format, ...) OHANA_FORMAT(printf, 2, 3);
     39int SendGraphCommand (int device, int length, char *format, ...) OHANA_FORMAT(printf, 3, 4);
    4040int SendGraphCommandV (int device, int length, char *format, va_list argp);
    4141

  • trunk/Ohana/src/opihi/include/dvoshell.h

    r26285 r27435  
    260260double        DetermineTypefrac     PROTO((Average *average, Measure *measure, PhotCode *code));
    261261double        ExtractAverages       PROTO((PhotCode *code, int mode, Average *average, SecFilt *secfilt, Measure *measure, int param));
    262 double       *ExtractByDMag         PROTO((PhotCode **code, int *mode, Average *average, SecFilt *secfilt, Measure *measure, int *nlist, int param));
    263 double       *ExtractDMag           PROTO((PhotCode **code, int *mode, Average *average, SecFilt *secfilt, Measure *measure, int *nlist));
    264 double       *ExtractMagnitudes     PROTO((PhotCode *code, int mode, Average *average, SecFilt *secfilt, Measure *measure, int *n));
    265 double       *ExtractMeasures       PROTO((PhotCode *code, int mode, Average *average, SecFilt *secfilt, Measure *measure, int *nlist, int param));
    266 double       *ExtractMeasuresByDMag PROTO((PhotCode **code, int *mode, int use_first, Average *average, SecFilt *secfilt, Measure *measure, int *nlist, int param));
    267 double       *ExtractMeasuresDMag   PROTO((PhotCode **code, int *mode, Average *average, SecFilt *secfilt, Measure *measure, int *nlist));
     262double       *ExtractByDMag         PROTO((PhotCode **code, int *mode, Average *average, SecFilt *secfilt, Measure *measure, off_t *nlist, int param));
     263double       *ExtractDMag           PROTO((PhotCode **code, int *mode, Average *average, SecFilt *secfilt, Measure *measure, off_t *nlist));
     264double       *ExtractMagnitudes     PROTO((PhotCode *code, int mode, Average *average, SecFilt *secfilt, Measure *measure, off_t *n));
     265double       *ExtractMeasures       PROTO((PhotCode *code, int mode, Average *average, SecFilt *secfilt, Measure *measure, off_t *nlist, int param));
     266double       *ExtractMeasuresByDMag PROTO((PhotCode **code, int *mode, int use_first, Average *average, SecFilt *secfilt, Measure *measure, off_t *nlist, int param));
     267double       *ExtractMeasuresDMag   PROTO((PhotCode **code, int *mode, Average *average, SecFilt *secfilt, Measure *measure, off_t *nlist));
    268268void          FreeImageSelection    PROTO((void));
    269269void          FreeImageSelection    PROTO((void));
    … …  
    280280void          FreeDVO               PROTO((void));
    281281int           InitPhotcodes         PROTO((void));
    282 Image        *LoadImages            PROTO((int *Nimage));
     282Image        *LoadImages            PROTO((off_t *Nimage));
    283283Image        *MatchImage            PROTO((unsigned int time, short int source));
    284284Coords       *MatchMosaic           PROTO((unsigned int time, short int source));
    … …  
    300300int           TestPhotSelections    PROTO((PhotCode **code, int *mode, int param));
    301301void          compare               PROTO((Catalog *catlog1, Catalog *catlog2, Vector *rvec,  Vector *dvec,  Vector *mvec, Vector *drvec, Vector *ddvec, Vector *dmvec, double radius));
    302 void          cprecess              PROTO((Average *average, int Naverage, double in_epoch, double out_epoch));
    303 void          image_subset          PROTO((Image *image, int Nimage, int **Subset, int *Nsubset, SkyRegionSelection *selection, unsigned long int tzero, double trange, int TimeSelect));
    304 int           match_image           PROTO((Image *image, int Nimage, unsigned int T, short int S));
    305 int           match_image_subset    PROTO((Image *image, int *subset, int Nsubset, unsigned int T, short int S));
     302void          cprecess              PROTO((Average *average, off_t Naverage, double in_epoch, double out_epoch));
     303void          image_subset          PROTO((Image *image, off_t Nimage, off_t **Subset, off_t *Nsubset, SkyRegionSelection *selection, unsigned long int tzero, double trange, int TimeSelect));
     304off_t         match_image           PROTO((Image *image, off_t Nimage, unsigned int T, short int S));
     305off_t         match_image_subset    PROTO((Image *image, off_t *subset, off_t Nsubset, unsigned int T, short int S));
    306306void          print_value           PROTO((double value, short int ival));
    307 void          sort_image_subset     PROTO((Image *image, int *subset, int N));
    308 void          sort_images           PROTO((Image *image, int N));
    309 void          sortave               PROTO((Average *ave, int N));
    310 CMPstars     *cmpReadFits           PROTO((FILE *f, int *nstars));
    311 CMPstars     *cmpReadText           PROTO((FILE *f, int *nstars));
     307CMPstars     *cmpReadFits           PROTO((FILE *f, off_t *nstars));
     308CMPstars     *cmpReadText           PROTO((FILE *f, off_t *nstars));
    312309int           RD_to_XYpic           PROTO((double *x, double *y, double r, double d, Coords *coords, double Rmin, double Rmax, double Rmid, int *leftside));
    313310
    … …  
    334331dbValue      dbExtractAverages      PROTO((Average *average, SecFilt *secfilt, Measure *measure, dbField *field));
    335332dbValue      dbExtractMeasures      PROTO((Average *average, SecFilt *secfilt, Measure *measure, dbField *field));
    336 dbValue      dbExtractImages        PROTO((Image *image, int Nimage, int N, dbField *field));
     333dbValue      dbExtractImages        PROTO((Image *image, off_t Nimage, off_t N, dbField *field));
    337334
    338335void         dbInitField            PROTO((dbField *field));

  • trunk/Ohana/src/opihi/include/pantasks.h

    r23530 r27435  
    269269int CheckJobsGetState (void);
    270270
    271 // void *CheckTasksThread (void *data);
    272 // void *CheckJobsThread (void *data);
    273 
    274271void CheckControllerSetState (int state);
    275272int CheckControllerGetState (void);
    … …  
    287284void CheckInputs (void);
    288285
    289 void ClientThreadLock (void);
    290 void ClientThreadUnlock (void);
    291 void CommandThreadLock (void);
    292 void CommandThreadUnlock (void);
    293 void ControlThreadLock (void);
    294 void ControlThreadUnlock (void);
    295 void JobTaskThreadLock (void);
    296 void JobTaskThreadUnlock (void);
     286void ClientLock (void);
     287void ClientUnlock (void);
     288void CommandLock (void);
     289void CommandUnlock (void);
     290void ControlLock (const char *func);
     291void ControlUnlock (const char *func);
     292void JobTaskLock (void);
     293void JobTaskUnlock (void);
    297294
    298295int InitPassword (void);

  • trunk/Ohana/src/opihi/include/shell.h

    r27255 r27435  
    153153
    154154char         *memstr                    PROTO((char *m1, char *m2, int n));
    155 int           write_fmt                 PROTO((int fd, char *format, ...));
     155int           write_fmt                 PROTO((int fd, char *format, ...)) OHANA_FORMAT(printf, 2, 3);
    156156char         *opihi_version             PROTO((void));
    157157char         *strip_version             PROTO((char *input));
    … …  
    167167FILE         *gprintGetFile             PROTO((gpDest dest));
    168168char         *gprintGetName             PROTO((gpDest dest));
    169 int           gprint                    PROTO((gpDest dest, char *format, ...));
     169int           gprint                    PROTO((gpDest dest, char *format, ...)) OHANA_FORMAT(printf, 2, 3);
    170170int           gwrite                    PROTO((char *buffer, int size, int N, gpDest dest));
    171 int           gprint_syserror           PROTO((gpDest dest, int myError, char *format, ...));
     171int           gprint_syserror           PROTO((gpDest dest, int myError, char *format, ...)) OHANA_FORMAT(printf, 3, 4);
    172172int           gprintv                   PROTO((gpDest dest, char *format, va_list argp));
    173173

  • trunk/Ohana/src/opihi/lib.data/fft.c

    r20936 r27435  
    7272// This requires 2(Nx*Ny*...) mem copies, but the fft operations are likely to happen in
    7373// cache.
    74 int fftND (float *x, float *y, int Ndim, int *Nsize, int forward) {
     74int fftND (float *x, float *y, int Ndim, off_t *Nsize, int forward) {
    7575
    7676  int i, nIndex, minor, major, iDim;

  • trunk/Ohana/src/opihi/lib.shell/BufferOps.c

    r17903 r27435  
    8383  return (buffers[i]);
    8484
    85  error:
     85error:
    8686  if (verbose) gprint (GP_ERR, "invalid matrix %s\n", name);
    8787  return (NULL);
    … …  
    238238    gprint (GP_LOG, "    N       name                      file     X     Y    bytes BP  U   bzero     bscale  \n");
    239239    for (i = 0; i < Nbuffers; i++) {
    240       gprint (GP_LOG, "%5d %10s %25s %5d %5d %10d %3d %1d %10.4e %10.4e\n",
    241                i, buffers[i][0].name, buffers[i][0].file,
    242                buffers[i][0].header.Naxis[0], buffers[i][0].header.Naxis[1],
    243                buffers[i][0].header.size + buffers[i][0].matrix.size, buffers[i][0].bitpix,
    244                buffers[i][0].unsign, buffers[i][0].bzero, buffers[i][0].bscale);
     240      gprint (GP_LOG, "%5d %10s %25s %5lld %5lld %10lld %3d %1d %10.4e %10.4e\n",
     241              i, buffers[i][0].name, buffers[i][0].file,
     242              (long long) buffers[i][0].header.Naxis[0], (long long) buffers[i][0].header.Naxis[1],
     243              (long long) buffers[i][0].header.datasize + buffers[i][0].matrix.datasize, buffers[i][0].bitpix,
     244              buffers[i][0].unsign, buffers[i][0].bzero, buffers[i][0].bscale);
    245245    }
    246246    return (TRUE);
    … …  
    249249  gprint (GP_LOG, "    N       name                      file     X     Y    bytes\n");
    250250  for (i = 0; i < Nbuffers; i++) {
    251     gprint (GP_LOG, "%5d %10s %25s %5d %5d %10d\n",
    252              i, buffers[i][0].name, buffers[i][0].file,
    253              buffers[i][0].header.Naxis[0], buffers[i][0].header.Naxis[1],
    254              buffers[i][0].header.size + buffers[i][0].matrix.size);
    255   }
    256   return (TRUE);
    257 }
     251    gprint (GP_LOG, "%5d %10s %25s %5lld %5lld %10lld\n",
     252            i, buffers[i][0].name, buffers[i][0].file,
     253            (long long) buffers[i][0].header.Naxis[0], (long long) buffers[i][0].header.Naxis[1],
     254            (long long) buffers[i][0].header.datasize + buffers[i][0].matrix.datasize);
     255  }
     256  return (TRUE);
     257}

  • trunk/Ohana/src/opihi/lib.shell/gprint.c

    r27255 r27435  
    352352  // there are two strerror_r implementations; choose the right one:
    353353#if ((_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) && ! _GNU_SOURCE)
    354   errorMsg = strerror_r (myError, errorBuf, MAX_ERROR_LENGTH);
    355 #else
    356354  strerror_r (myError, errorBuf, MAX_ERROR_LENGTH);
    357355  errorMsg = errorBuf;
     356#else
     357  errorMsg = strerror_r (myError, errorBuf, MAX_ERROR_LENGTH);
    358358#endif
    359359
    … …  
    362362  va_end (argp);
    363363
    364   gprintv (dest, "%s\n", errorMsg);
     364  gprint (dest, "%s\n", errorMsg);
    365365  return TRUE;
    366366}

  • trunk/Ohana/src/opihi/lib.shell/multicommand.c

    r26995 r27435  
    3232  /* here we can perform the security handshaking */
    3333  VarConfig ("PASSWORD", "%s", PASSWORD);
    34   SendCommand (server, strlen(PASSWORD), PASSWORD);
     34  SendCommand (server, strlen(PASSWORD), "%s", PASSWORD);
    3535 
    3636  return;
    … …  
    8282        if (server) {
    8383          // send the command to the server instead
    84           if (!SendMessage (server, outline)) {
     84          if (!SendMessage (server, "%s", outline)) {
    8585            switch (errno) {
    8686              case EPIPE:

  • trunk/Ohana/src/opihi/lib.shell/stack_math.c

    r26891 r27435  
    11351135  /* copy all but the matrix */
    11361136
    1137   matrix2[0].unsign = matrix1[0].unsign;
    1138   matrix2[0].bitpix = matrix1[0].bitpix;
    1139   matrix2[0].size   = matrix1[0].size;
    1140   matrix2[0].bzero  = matrix1[0].bzero;
    1141   matrix2[0].bscale = matrix1[0].bscale;
    1142   matrix2[0].Naxes  = matrix1[0].Naxes;
    1143   for (i = 0; i < FT_MAX_NAXES; i++)
     1137  matrix2[0].unsign   = matrix1[0].unsign;
     1138  matrix2[0].bitpix   = matrix1[0].bitpix;
     1139  matrix2[0].datasize = matrix1[0].datasize;
     1140  matrix2[0].bzero    = matrix1[0].bzero;
     1141  matrix2[0].bscale   = matrix1[0].bscale;
     1142  matrix2[0].Naxes    = matrix1[0].Naxes;
     1143  for (i = 0; i < FT_MAX_NAXES; i++) {
    11441144    matrix2[0].Naxis[i] = matrix1[0].Naxis[i];
    1145 
     1145  }
    11461146
    11471147  return (TRUE);

  • trunk/Ohana/src/opihi/pantasks/JobOps.c

    r23563 r27435  
    7373
    7474  int i;
    75   int status;
    76   char command[1024];
    77   IOBuffer buffer;
    7875
    7976  gprint (GP_LOG, "\n");

  • trunk/Ohana/src/opihi/pantasks/ListenClients.c

    r23530 r27435  
    7070 
    7171  int i, Ncurrent, Nmax, status, Nread;
    72   char *line, log_stdout[128], log_stderr[128];
     72  char *line;
    7373  fd_set fdSet;
    7474  struct timeval timeout;

  • trunk/Ohana/src/opihi/pantasks/status_server.c

    r26948 r27435  
    11# include "pantasks.h"
     2
     3int status_scheduler(void);
    24
    35int status_server (int argc, char **argv) {
    … …  
    103105}
    104106
    105 int status_scheduler() {
     107int status_scheduler(void) {
    106108 
    107109  gprint (GP_LOG, "\n");

  • trunk/Ohana/src/opihi/pantasks/thread_locks.c

    r23530 r27435  
    44static pthread_mutex_t ClientMutex = PTHREAD_MUTEX_INITIALIZER;
    55
    6 void ClientLock () {
     6void ClientLock (void) {
    77  pthread_mutex_lock (&ClientMutex);
    88}
    99
    10 void ClientUnlock () {
     10void ClientUnlock (void) {
    1111  pthread_mutex_unlock (&ClientMutex);
    1212}
    … …  
    1515static pthread_mutex_t CommandMutex = PTHREAD_MUTEX_INITIALIZER;
    1616
    17 void CommandLock () {
     17void CommandLock (void) {
    1818  //  fprintf (stderr, "command lock\n");
    1919  pthread_mutex_lock (&CommandMutex);
    2020}
    2121
    22 void CommandUnlock () {
     22void CommandUnlock (void) {
    2323  //  fprintf (stderr, "command unlock\n");
    2424  pthread_mutex_unlock (&CommandMutex);
    … …  
    2828static pthread_mutex_t ControlMutex = PTHREAD_MUTEX_INITIALIZER;
    2929
    30 void ControlLock (char *func) {
     30void ControlLock (const char *func) {
    3131  // fprintf (stderr, "control lock %s\n", func);
    3232  pthread_mutex_lock (&ControlMutex);
    3333}
    3434
    35 void ControlUnlock (char *func) {
     35void ControlUnlock (const char *func) {
    3636  // fprintf (stderr, "control unlock %s\n", func);
    3737  pthread_mutex_unlock (&ControlMutex);
    … …  
    4141static pthread_mutex_t JobTaskMutex = PTHREAD_MUTEX_INITIALIZER;
    4242
    43 void JobTaskLock () {
     43void JobTaskLock (void) {
    4444  //  fprintf (stderr, "jobtask lock\n");
    4545  pthread_mutex_lock (&JobTaskMutex);
    4646}
    4747
    48 void JobTaskUnlock () {
     48void JobTaskUnlock (void) {
    4949  //  fprintf (stderr, "jobtask unlock\n");
    5050  pthread_mutex_unlock (&JobTaskMutex);

  • trunk/Ohana/src/opihi/pcontrol/PclientCommand.c

    r17476 r27435  
    6363  }
    6464  if (status ==  0) {
    65     gprint (GP_ERR, "pclient read returns 0 for %s\n", command);
     65    gprint (GP_ERR, "pclient read returns 0 for %s\n", response);
    6666    return (PCLIENT_DOWN);
    6767  }

  • trunk/Ohana/src/opihi/pcontrol/StartHost.c

    r25872 r27435  
    1414  if (VarConfig ("SHELL", "%s", shell)     == NULL) strcpy (shell, "pclient");
    1515
    16   if (VerboseMode()) gprint (GP_ERR, "starting host within thread %d\n", pthread_self());
     16  if (VerboseMode()) gprint (GP_ERR, "starting host within thread %lld\n", (long long) pthread_self());
    1717
    1818  pid = rconnect (command, host[0].hostname, shell, stdio);

  • trunk/Ohana/src/opihi/pcontrol/StopHosts.c

    r25872 r27435  
    121121  int i, result, waitstatus;
    122122
    123   if (VerboseMode()) gprint (GP_ERR, "harvesting within thread %p\n", pthread_self());
     123  if (VerboseMode()) gprint (GP_ERR, "harvesting within thread %lld\n", (long long) pthread_self());
    124124  if (VerboseMode()) gprint (GP_ERR, "child process %d is down, wait for exit status\n", pid);
    125125 

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

    r21153 r27435  
    104104void          check_directory (char *basefile);
    105105
    106 int Shutdown (char *format, ...);
     106int Shutdown (char *format, ...) OHANA_FORMAT(printf, 1, 2);
    107107void set_db (FITS_DB *in);
    108108void lock_image_db (FITS_DB *db, char *filename);

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

    r17284 r27435  
    33void join_stars (Catalog *catalog) {
    44
    5   int i, j, k, m, M, Ni, Nj, first_j;
    6   int Naves, Nmeas, Ncurr;
    7   int Naverage, Nmeasure, *found, *index;
     5  off_t i, j, k, m, M, Ni, Nj, first_j, Nfirst;
     6  off_t Naves, Nmeas, Ncurr;
     7  off_t Naverage, Nmeasure, *index;
    88  double *X, *Y, dX, dY, dR, RADIUS2;
    99  double Sr, Sd, Rmid, Dmid;
    10   int basecode, baseNsec, Nsecfilt, Nfirst;
     10  int basecode, baseNsec, Nsecfilt, *found;
    1111
    1212  Average *naverage, *average;
    … …  
    6161  ALLOCATE (X, double, Naverage);
    6262  ALLOCATE (Y, double, Naverage);
    63   ALLOCATE (index, int, Naverage);
     63  ALLOCATE (index, off_t, Naverage);
    6464  for (i = 0; i < Naverage; i++) {
    6565    index[i] = i;

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

    r17043 r27435  
     1
     22010.03.24
     3
     4  I have finished only part of the optimizations listed below: I have
     5  made the detection->image and image->mosaic lookups use bracket
     6  searches.  I have NOT converted the image->mosaic lookups to use the
     7  parentID, so these matches are still based on time ranges.  I have
     8  also added a bit of positional constraint to the image match
     9  function in 'select_images' (comparing Rmax of the sky regions to
     10  Rmin of the images).  These have had a huge improvement.  Here is
     11  the execution time for the SAS data (~450 images) with the old vs
     12  the new code on pikake:
     13
     14  old : 39min
     15  new :  7min
     16
     17  The bulk of the time for the new code is now disk I/O.
     18
     192010.03.23
     20
     21  I've been working on optimization.  I've updated ImageOps to make
     22  the measure->image relationship generation use the image IDs along
     23  with a bracket search -- this goes much faster as a result.  More
     24  work is needed:
     25
     26  * select_images needs to apply astrometry to all image corners:
     27    -> cache the image center and radius and use this to narrow down
     28       the searches.
     29
     30  * MosaicOps uses the time to match mosaics.  I've added sorting to
     31    speed this up, but this should be done based on the image and
     32    parent index.
     33
     34    -> make a tool to create the parent ID for existing DBs.
     35    -> make sure addstar is populating the parent IDs
     36    -> use the parent IDs to make the link.
     37
     38load image data: 0.006347 sec
     39  setup sky: 0.091475 sec
     40  convert image table: 0.091498 sec
     41  select images: 2.925978 sec
     42  init images: 2.926957 sec
     43  init mosaics: 2.927319 sec
     44load images: 2.933762 sec
     45load catalog data: 9.772259 sec
     46make image bins: 9.780618 sec
     47set up image indexes: 10.196519 sec
     48
     49load image data: 0.006746 sec
     50  setup sky: 0.091440 sec
     51  convert image table: 0.091467 sec
     52  select images: 0.374193 sec
     53  init images: 0.375355 sec
     54  init mosaics: 0.375753 sec
     55load images: 0.382606 sec
     56load catalog data: 7.260094 sec
     57make image bins: 7.268564 sec
     58set up image indexes: 7.687485 sec
     59
    160
    2612008.03.01

  • trunk/Ohana/src/relastro/include/relastro.h

    r24308 r27435  
    140140char         *GetPhotnamebyCode   PROTO((PhotCodeData *photcodes, int code));
    141141void          InterpolateGrid     PROTO((float *buffer, int Nx, int Ny, Coords *ccd, Coords *gcoords));
    142 int          *SelectRefMosaic     PROTO((Mosaic **refmosaic, int *Nimage));
     142off_t          *SelectRefMosaic     PROTO((Mosaic **refmosaic, off_t *Nimage));
    143143int           args                PROTO((int argc, char **argv));
    144144int           bcatalog            PROTO((Catalog *subcatalog, Catalog *catalog));
    … …  
    153153void          findImages          PROTO((Catalog *catalog, int Ncatalog));
    154154int           findMosaics         PROTO((Catalog *catalog, int Ncatalog));
    155 Image        *find_images         PROTO((FITS_DB *db, GSCRegion *region, int Nregion, int *Nimage, int **LineNum));
     155Image        *find_images         PROTO((FITS_DB *db, GSCRegion *region, off_t Nregion, off_t *Nimage, off_t **LineNum));
    156156void set_db (FITS_DB *in);
    157 int Shutdown (char *format, ...);
     157int Shutdown (char *format, ...) OHANA_FORMAT(printf, 1, 2);
    158158void TrapSignal (int sig);
    159159void SetProtect (int mode);
    160160int SetSignals (void);
    161161
    162 GSCRegion    *find_regions        PROTO((Image *image, int Nimage, int *Nregions, GSCRegion *fullregion));
     162GSCRegion    *find_regions        PROTO((Image *image, off_t Nimage, int *Nregions, GSCRegion *fullregion));
    163163void          freeGridBins        PROTO((int Ncatalog));
    164164void          freeImageBins       PROTO((int Ncatalog));
    … …  
    166166void          free_catalogs       PROTO((Catalog *catalog, int Ncatalog));
    167167int           gcatalog            PROTO((Catalog *catalog, int FINAL));
    168 Coords       *getCoords           PROTO((int meas, int cat));
    169 float         getMcal             PROTO((int meas, int cat));
    170 float         getMgrid            PROTO((int meas, int cat));
    171 float         getMmos             PROTO((int meas, int cat));
    172 float         getMrel             PROTO((Catalog *catalog, int meas, int cat));
    173 GSCRegion    *get_regions         PROTO((double minRa, double maxRa, double minDec, double maxDec, int *Nregions));
    174 void          getfullregion       PROTO((Image *image, int Nimage, GSCRegion *fullregion));
    175 Image        *getimage            PROTO((int N));
    176 Image        *getimages           PROTO((int *N));
     168Coords       *getCoords           PROTO((off_t meas, int cat));
     169float         getMcal             PROTO((off_t meas, int cat));
     170float         getMgrid            PROTO((off_t meas, int cat));
     171float         getMmos             PROTO((off_t meas, int cat));
     172float         getMrel             PROTO((Catalog *catalog, off_t meas, int cat));
     173GSCRegion    *get_regions         PROTO((double minRa, double maxRa, double minDec, double maxDec, off_t *Nregions));
     174void          getfullregion       PROTO((Image *image, off_t Nimage, GSCRegion *fullregion));
     175Image        *getimage            PROTO((off_t N));
     176Image        *getimages           PROTO((off_t *N));
    177177void          global_stats        PROTO((Catalog *catalog, int Ncatalog));
    178178void          initGrid            PROTO((int dX, int dY));
    179179void          initGridBins        PROTO((Catalog *catalog, int Ncatalog));
    180180void          initImageBins       PROTO((Catalog *catalog, int Ncatalog));
    181 void          initImages          PROTO((Image *input, int N));
     181void          initImages          PROTO((Image *input, off_t N));
    182182void          initMosaicBins      PROTO((Catalog *catalog, int Ncatalog));
    183 void          initMosaicGrid      PROTO((Image *image, int Nimage));
    184 void          initMosaics         PROTO((Image *image, int Nimage));
     183void          initMosaicGrid      PROTO((Image *image, off_t Nimage));
     184void          initMosaics         PROTO((Image *image, off_t Nimage));
    185185void          initMrel            PROTO((Catalog *catalog, int Ncatalog));
    186186void          initialize          PROTO((int argc, char **argv));
    … …  
    189189Catalog      *load_catalogs       PROTO((SkyList *skylist, int *Ncatalog, int subselect));
    190190SkyList      *load_images         PROTO((FITS_DB *db, SkyRegion *region));
    191 Image        *select_images       PROTO((SkyList *skylist, Image *timage, int Ntimage, int **LineNumber, int *Nimage));
     191Image        *select_images       PROTO((SkyList *skylist, Image *timage, off_t Ntimage, off_t **LineNumber, off_t *Nimage));
    192192
    193193void check_permissions (char *basefile);
    … …  
    198198
    199199int           main                PROTO((int argc, char **argv));
    200 void          mark_images         PROTO((Image *image, int Nimage, Image *timage, int Ntimage));
    201 void          matchImage          PROTO((Catalog *catalog, int meas, int cat));
    202 void          matchMosaics        PROTO((Catalog *catalog, int meas, int cat));
    203 GSCRegion    *name_region         PROTO((char *name, int *Nregions));
     200void          mark_images         PROTO((Image *image, off_t Nimage, Image *timage, off_t Ntimage));
     201void          matchImage          PROTO((Catalog *catalog, off_t meas, int cat));
     202void          matchMosaics        PROTO((Catalog *catalog, off_t meas, int cat));
     203GSCRegion    *name_region         PROTO((char *name, off_t *Nregions));
    204204double        opening_angle       PROTO((double x1, double y1, double x2, double y2, double x3, double y3));
    205205void          plot_chisq          PROTO((Catalog *catalog, int Ncatalog));
    … …  
    224224int           setMrelOutput       PROTO((Catalog *catalog, int Ncatalog, int mark));
    225225void          set_ZP              PROTO((double ZERO));
    226 int           setrefcode          PROTO((Image *image, int Nimage));
     226int           setrefcode          PROTO((Image *image, off_t Nimage));
    227227void          skip_measurements   PROTO((Catalog *catalog, int pass));
    228228void          sortA               PROTO((double *X, int N));
    … …  
    268268int UpdateMosaic (Catalog *catalog, int Ncatalog);
    269269int UpdateMeasures (Catalog *catalog, int Ncatalog);
    270 void fixImageRaw (Catalog *catalog, int Ncatalog, int im);
     270void fixImageRaw (Catalog *catalog, int Ncatalog, off_t im);
    271271void FlagOutliers(Catalog *catalog);
    272272int MeasFilterTest(Measure *measure);
    … …  
    278278int FitPMandPar (PMFit *fit, double *X, double *dX, double *Y, double *dY, double *T, double *pR, double *pD, int Npts);
    279279
    280 Mosaic *getMosaicForImage (int N);
    281 
    282 StarData *getImageRef (Catalog *catalog, int Ncatalog, int im, int *Nstars, CoordMode mode);
    283 StarData *getImageRaw (Catalog *catalog, int Ncatalog, int im, int *Nstars, CoordMode mode);
    284 
    285 Mosaic *getmosaics (int *N);
    286 void initMosaics (Image *image, int Nimage);
    287 StarData *getMosaicRaw (Catalog *catalog, int Ncatalog, int mos, int *Nstars);
    288 StarData *getMosaicRef (Catalog *catalog, int Ncatalog, int mos, int *Nstars);
    289 Mosaic *getMosaicForImage (int im);
     280Mosaic *getMosaicForImage (off_t N);
     281
     282StarData *getImageRef (Catalog *catalog, int Ncatalog, off_t im, off_t *Nstars, CoordMode mode);
     283StarData *getImageRaw (Catalog *catalog, int Ncatalog, off_t im, off_t *Nstars, CoordMode mode);
     284
     285Mosaic *getmosaics (off_t *N);
     286void initMosaics (Image *image, off_t Nimage);
     287StarData *getMosaicRaw (Catalog *catalog, int Ncatalog, off_t mos, off_t *Nstars);
     288StarData *getMosaicRef (Catalog *catalog, int Ncatalog, off_t mos, off_t *Nstars);
     289Mosaic *getMosaicForImage (off_t im);
    290290
    291291double getMeanR (Measure *measure, Average *average, SecFilt *secfilt);
    … …  
    297297int relastro_objects (void);
    298298int UpdateObjectOffsets (SkyList *skylist);
     299
     300int relastroVisualPlotRawRef(StarData *raw, StarData *ref, double dRmax, int numObj);
     301int relastroVisualPlotScatter(double values[], double thresh, int npts);
     302int relastroVisualPlotOutliers(Catalog *catalog, int offset, int Nmeasure,
     303                               StatType statsR, StatType statsD, double thresh);
     304

  • trunk/Ohana/src/relastro/src/FitSimple.c

    r16810 r27435  
    1717
    1818    // XXX the value needs to be set in a more intelligent way
    19     if (dR > 0.15) continue;
     19    if (dR > 0.50) continue;
    2020   
    2121    fit_add (fit, raw[i].X, raw[i].Y, ref[i].P, ref[i].Q, 1.0);

  • trunk/Ohana/src/relastro/src/ImageOps.c

    r24308 r27435  
    11# include "relastro.h"
    2 #define TESTING
    3 
     2# define TESTING
     3# define USE_IMAGE_ID 1
     4
     5static off_t       **bin;     // link from catalog,measure to image
     6static int         **clist;   // catalog which supplied measurement on image
     7static off_t       **mlist;   // measure reference for measurement on image
     8static off_t        *Nlist;   // number of measurements on image
     9static off_t        *NLIST;   // allocated number of measurements on image
     10
     11static Image        *image;   // list of available images
     12static off_t        Nimage;   // number of available images
     13
     14# if USE_IMAGE_ID
     15// we sort (imageIDs, imageIdx) by imageIDs to get a sorted index
     16static off_t        *imageIDs; // list of all image IDs
     17static off_t        *imageIdx; // list of index for image IDs
     18# else
    419static unsigned int *start;
    520static unsigned int *stop;
    6 static int         **bin;
    7 
    8 static int         **clist;
    9 static int         **mlist;
    10 static int          *Nlist;
    11 static int          *NLIST;
    12 
    13 static Image        *image;
    14 static int          Nimage;
    15 
    16 Image *getimages (int *N) {
     21# endif
     22
     23Image *getimages (off_t *N) {
    1724  *N = Nimage;
    1825  return (image);
    1926}
    2027
    21 Image *getimage (int N) {
     28Image *getimage (off_t N) {
    2229  return (&image[N]);
    2330}
    2431
    25 void initImages (Image *input, int N) {
    26 
    27   int i;
     32void initImages (Image *input, off_t N) {
     33
     34  off_t i;
    2835
    2936  image = input;
    3037  Nimage = N;
    3138
    32   ALLOCATE (start,   unsigned, Nimage);
    33   ALLOCATE (stop,    unsigned, Nimage);
     39# if USE_IMAGE_ID
     40  ALLOCATE (imageIDs, off_t, Nimage);
     41  ALLOCATE (imageIdx, off_t, Nimage);
     42
     43  for (i = 0; i < Nimage; i++) {
     44    imageIdx[i] = i;
     45    imageIDs[i] = image[i].imageID;
     46  }
     47  llsortpair (imageIDs, imageIdx, Nimage);
     48# else
     49  ALLOCATE (start, unsigned, Nimage);
     50  ALLOCATE (stop, unsigned, Nimage);
    3451
    3552  for (i = 0; i < Nimage; i++) {
    … …  
    3754    stop[i]  = image[i].tzero + MAX(1.01*image[i].trate*image[i].NY, 1);
    3855  }
     56# endif
     57
     58}
     59
     60off_t getImageByID (off_t ID) {
     61
     62  // we have a pair of vectors (imageIDs, imageIdx) sorted by imageIDs
     63  // use bisection to find the specified image ID
     64
     65# if USE_IMAGE_ID
     66  off_t Nlo, Nhi, N;
     67
     68  Nlo = 0; Nhi = Nimage;
     69  while (Nhi - Nlo > 10) {
     70    N = 0.5*(Nlo + Nhi);
     71    if (imageIDs[N] < ID) {
     72      Nlo = MAX(N, 0);
     73    } else {
     74      Nhi = MIN(N + 1, Nimage);
     75    }
     76  }
     77
     78  for (N = Nlo; N < Nhi; N++) {
     79    if (imageIDs[N] == ID)
     80      return (imageIdx[N]);
     81  }
     82# endif
     83
     84  return (-1);
    3985}
    4086
    4187void initImageBins (Catalog *catalog, int Ncatalog) {
    4288
    43   int i, j;
    44 
    45   ALLOCATE (bin, int *, Ncatalog);
     89  off_t i, j;
     90
     91  ALLOCATE (bin, off_t *, Ncatalog);
    4692  for (i = 0; i < Ncatalog; i++) {
    47     ALLOCATE (bin[i], int, MAX (catalog[i].Nmeasure, 1));
     93    ALLOCATE (bin[i], off_t, MAX (catalog[i].Nmeasure, 1));
    4894    for (j = 0; j < catalog[i].Nmeasure; j++) bin[i][j] = -1;
    4995  }
    5096
    51   ALLOCATE (Nlist, int, Nimage);
    52   ALLOCATE (NLIST, int, Nimage);
    53   ALLOCATE (clist, int *, Nimage);
    54   ALLOCATE (mlist, int *, Nimage);
     97  ALLOCATE (Nlist, off_t,  Nimage);
     98  ALLOCATE (NLIST, off_t,  Nimage);
     99  ALLOCATE (clist, int *,   Nimage);
     100  ALLOCATE (mlist, off_t *, Nimage);
    55101
    56102  for (i = 0; i < Nimage; i++) {
    … …  
    58104    NLIST[i] = 100;
    59105    ALLOCATE (clist[i], int, NLIST[i]);
    60     ALLOCATE (mlist[i], int, NLIST[i]);
     106    ALLOCATE (mlist[i], off_t, NLIST[i]);
    61107  }
    62108}
    … …  
    64110void freeImageBins (int Ncatalog) {
    65111
    66   int i;
     112  off_t i;
    67113
    68114  for (i = 0; i < Ncatalog; i++) {
    … …  
    81127void findImages (Catalog *catalog, int Ncatalog) {
    82128
    83   int i, j;
     129  off_t i, j;
    84130  char *name;
    85131
    … …  
    92138  for (i = 0; VERBOSE && (i < Nimage); i++) {
    93139    name = GetPhotcodeNamebyCode (image[i].photcode);
    94     fprintf (stderr, "image %d has %d measures (%s, %s)\n", i, Nlist[i],
     140    fprintf (stderr, "image %lld has %lld measures (%s, %s)\n", (long long) i, (long long) Nlist[i],
    95141             ohana_sec_to_date(image[i].tzero), name);
    96142  }
    97143}
    98144
     145# if USE_IMAGE_ID
    99146/* modify this function to use the measure->imageID field */
    100 void matchImage (Catalog *catalog, int meas, int cat) {
    101 
    102   int i;
     147void matchImage (Catalog *catalog, off_t meas, int cat) {
     148
     149  off_t idx, ID;
     150  Measure *measure;
     151
     152  measure = &catalog[cat].measure[meas];
     153
     154  ID = measure[0].imageID;
     155  idx = getImageByID (ID);
     156  if (idx == -1) {
     157    fprintf (stderr, "can't match detection to image?\n");
     158    abort();
     159  }
     160
     161  // index for (catalog, measure) -> image
     162  bin[cat][meas] = idx;
     163
     164  // index for image, Nentry -> catalog
     165  clist[idx][Nlist[idx]] = cat;
     166
     167  // index for image, Nentry -> measure
     168  mlist[idx][Nlist[idx]] = meas;
     169  Nlist[idx] ++;
     170
     171  if (Nlist[idx] == NLIST[idx]) {
     172    NLIST[idx] += 100;
     173    REALLOCATE (clist[idx], int,   NLIST[idx]);
     174    REALLOCATE (mlist[idx], off_t, NLIST[idx]);
     175  }
     176  return;
     177}
     178
     179# else
     180/* modify this function to use the measure->imageID field */
     181void matchImage (Catalog *catalog, off_t meas, int cat) {
     182
     183  off_t i;
    103184  Measure *measure;
    104185
    … …  
    107188  /* find the image that supplied this measurement */
    108189  for (i = 0; i < Nimage; i++) {
     190    // let's try the very slow method first before adding a bisection search
     191    // if (image[i].imageID != measure[0].imageID) continue;
    109192    if (image[0].photcode == -1) continue;
    110193    if (measure[0].photcode != image[i].photcode) continue;
    … …  
    124207    if (Nlist[i] == NLIST[i]) {
    125208      NLIST[i] += 100;
    126       REALLOCATE (clist[i], int, NLIST[i]);
    127       REALLOCATE (mlist[i], int, NLIST[i]);
     209      REALLOCATE (clist[i], int,   NLIST[i]);
     210      REALLOCATE (mlist[i], off_t, NLIST[i]);
    128211    }
    129212    return;
    130213  }
    131 }
    132 
    133 Coords *getCoords (int meas, int cat) {
    134 
    135   int i;
     214  fprintf (stderr, "can't match detection to image?\n");
     215  abort();
     216}
     217# endif
     218
     219Coords *getCoords (off_t meas, int cat) {
     220
     221  off_t i;
    136222
    137223  i = bin[cat][meas];
    … …  
    142228void plot_images () {
    143229
    144   int i, bin;
     230  off_t i, bin;
    145231  double *xlist, *Mlist, *dlist;
    146232  Graphdata graphdata;
    … …  
    188274// return StarData values for detections in the specified image, converting coordinates from the
    189275// chip positions: X,Y -> L,M -> P,Q -> R,D
    190 void fixImageRaw (Catalog *catalog, int Ncatalog, int im) {
    191 
    192   int i, m, c, n;
     276void fixImageRaw (Catalog *catalog, int Ncatalog, off_t im) {
     277
     278  off_t i, m, c, n;
    193279  double X, Y, L, M, P, Q, R, D, dR, dD;
    194280
    … …  
    199285  mosaic = getMosaicForImage (im);
    200286  if (mosaic != NULL) {
    201       moscoords = &mosaic[0].coords;
     287    moscoords = &mosaic[0].coords;
    202288  }
    203289  imcoords = &image[im].coords;
    … …  
    257343// chip positions: X,Y -> L,M -> P,Q -> R,D.  This function is used by the image fitting steps, for
    258344// which the detections have already been filtered when they were loaded (bcatalog)
    259 StarData *getImageRaw (Catalog *catalog, int Ncatalog, int im, int *Nstars, CoordMode mode) {
    260 
    261   int i, m, c, n;
     345StarData *getImageRaw (Catalog *catalog, int Ncatalog, off_t im, off_t *Nstars, CoordMode mode) {
     346
     347  off_t i, m, c, n;
    262348
    263349  Mosaic *mosaic;
    … …  
    270356  moscoords = NULL;
    271357  if (mode == MODE_MOSAIC) {
    272       mosaic = getMosaicForImage (im);
    273       if (mosaic == NULL) {
    274         fprintf (stderr, "mosaic not found for image %s\n", image[im].name);
    275         exit (1);
    276       }
    277       moscoords = &mosaic[0].coords;
     358    mosaic = getMosaicForImage (im);
     359    if (mosaic == NULL) {
     360      fprintf (stderr, "mosaic not found for image %s\n", image[im].name);
     361      exit (1);
     362    }
     363    moscoords = &mosaic[0].coords;
    278364  }
    279365
    … …  
    319405        LM_to_RD (&raw[i].R, &raw[i].D, raw[i].P, raw[i].Q, moscoords);
    320406        break;
    321     default:
    322       fprintf (stderr, "error: invalid mode in getImageRaw");
    323       abort ();
     407      default:
     408        fprintf (stderr, "error: invalid mode in getImageRaw");
     409        abort ();
    324410    }
    325411  }
    … …  
    332418// the sky positions: R,D -> P,Q -> L,M -> X,Y
    333419
    334 StarData *getImageRef (Catalog *catalog, int Ncatalog, int im, int *Nstars, CoordMode mode) {
    335 
    336   int i, m, c, n;
     420StarData *getImageRef (Catalog *catalog, int Ncatalog, off_t im, off_t *Nstars, CoordMode mode) {
     421
     422  off_t i, m, c, n;
    337423
    338424  Mosaic *mosaic;
    … …  
    371457    switch (mode) {
    372458      case MODE_SIMPLE:
    373       RD_to_LM (&ref[i].P, &ref[i].Q, ref[i].R, ref[i].D, &image[im].coords);
    374       ref[i].L = ref[i].P;
    375       ref[i].M = ref[i].Q;
    376       LM_to_XY (&ref[i].X, &ref[i].Y, ref[i].L, ref[i].M, &image[im].coords);
    377       break;
     459        RD_to_LM (&ref[i].P, &ref[i].Q, ref[i].R, ref[i].D, &image[im].coords);
     460        ref[i].L = ref[i].P;
     461        ref[i].M = ref[i].Q;
     462        LM_to_XY (&ref[i].X, &ref[i].Y, ref[i].L, ref[i].M, &image[im].coords);
     463        break;
    378464      case MODE_MOSAIC:
    379       RD_to_LM (&ref[i].P, &ref[i].Q, ref[i].R, ref[i].D, moscoords);
    380       LM_to_XY (&ref[i].L, &ref[i].M, ref[i].P, ref[i].Q, moscoords);
    381       LM_to_XY (&ref[i].X, &ref[i].Y, ref[i].L, ref[i].M, &image[im].coords);
    382       break;
     465        RD_to_LM (&ref[i].P, &ref[i].Q, ref[i].R, ref[i].D, moscoords);
     466        LM_to_XY (&ref[i].L, &ref[i].M, ref[i].P, ref[i].Q, moscoords);
     467        LM_to_XY (&ref[i].X, &ref[i].Y, ref[i].L, ref[i].M, &image[im].coords);
     468        break;
    383469      default:
    384470        fprintf (stderr, "invalid case");
    … …  
    399485  return;
    400486
    401   int i, j, k, m, N, Ndel, Nave, Nmax, TOOFEW, Nsecfilt;
     487  int Ndel, Nave;
     488  off_t i, j, k, m, N, Nmax, TOOFEW, Nsecfilt;
    402489  double Ns, theta, x, y;
    403490  double *R, *D, *dR, *dD;
    … …  
    490577void FlagOutliers2D (Catalog *catalog) {
    491578
    492   int i, j, k, m, N, Ndel, Nave, Nmax, TOOFEW, Nsecfilt;
     579  int Ndel, Nave;
     580  off_t i, j, k, m, N, Nmax, TOOFEW, Nsecfilt;
    493581  double *index;
    494582  double Ns, theta, x, y;
    … …  
    569657    // recalculate image center, sigma based on closest 50% of points
    570658    for(k = 0;  k < N; k++) {
    571       int ind = (int) index[k];
     659      off_t ind = (off_t) index[k];
    572660      R[k] = catalog[0].measure[ind].dR;
    573661      D[k] = catalog[0].measure[ind].dD;

  • trunk/Ohana/src/relastro/src/MosaicOps.c

    r21508 r27435  
    22
    33// array of mosaic definition structures
    4 static int    Nmosaic;
     4static off_t    Nmosaic;
    55static Mosaic *mosaic;
    66
    77// list of all images associated with a mosaic
    8 static int   *Nmosaic_own_images; // number of images for this mosaic
    9 static int   *Amosaic_own_images; // size of allocated array
    10 static int   **mosaic_own_images; // array of arrays: mosaic -> images
     8static off_t   *Nmosaic_own_images; // number of images for this mosaic
     9static off_t   *Amosaic_own_images; // size of allocated array
     10static off_t   **mosaic_own_images; // array of arrays: mosaic -> images
    1111
    1212// list of mosaic associated with each image 
    13 static int    Nmosaic_for_images; // number of images (for internal checks)
    14 static int    *mosaic_for_images; // array of: image -> mosaic
    15 
    16 Mosaic *getmosaics (int *N) {
     13static off_t    Nmosaic_for_images; // number of images (for off_ternal checks)
     14static off_t    *mosaic_for_images; // array of: image -> mosaic
     15
     16Mosaic *getmosaics (off_t *N) {
    1717  *N = Nmosaic;
    1818  return (mosaic);
    1919}
    2020
     21off_t getMosaicByTimes (unsigned int start, unsigned int stop, unsigned int *startMos, unsigned int *stopMos, off_t *indexMos) {
     22
     23  // use bisection to find the overlapping mosaic
     24
     25  off_t Nlo, Nhi, N;
     26
     27  // find the last mosaic before start
     28  Nlo = 0; Nhi = Nmosaic;
     29  while (Nhi - Nlo > 10) {
     30    N = 0.5*(Nlo + Nhi);
     31    if (startMos[N] < start) {
     32      Nlo = MAX(N, 0);
     33    } else {
     34      Nhi = MIN(N + 1, Nmosaic);
     35    }
     36  }
     37
     38  // check for the matched mosaic starting from Nlo
     39  // we may have to go much beyond Nlo since stop is not sorted
     40  // can we use a sorted version of stop to check when we are beyond the valid range??
     41  for (N = Nlo; N < Nmosaic; N++) {
     42    if (stop  < stopMos[N]) continue;
     43    if (start > startMos[N])  continue;
     44    if (stop  < startMos[N]) return (-1);
     45    return (indexMos[N]);
     46  }
     47
     48  return (-1);
     49}
     50
     51// sort two times vectors and an index by first time vector
     52void sort_mosaic_times (unsigned int *S, unsigned int *E, off_t *I, off_t N) {
     53
     54# define SWAPFUNC(A,B){ unsigned int tmp_t; off_t tmp_i; \
     55  tmp_t = S[A]; S[A] = S[B]; S[B] = tmp_t; \
     56  tmp_t = E[A]; E[A] = E[B]; E[B] = tmp_t; \
     57  tmp_i = I[A]; I[A] = I[B]; I[B] = tmp_i; \
     58}
     59# define COMPARE(A,B)(S[A] < S[B])
     60
     61  OHANA_SORT (N, COMPARE, SWAPFUNC);
     62
     63# undef SWAPFUNC
     64# undef COMPARE
     65
     66}
     67
     68// first, let's continue to use the time to make the match, but use bracketing to make it faster:
     69
    2170// find mosaic frames (unique time periods & photcode name matches mosaic)
    22 void initMosaics (Image *image, int Nimage) {
    23 
    24   int i, j, found, NMOSAIC;
     71void initMosaics (Image *image, off_t Nimage) {
     72
     73  off_t i, Nmos, NMOSAIC;
    2574  unsigned int start, stop;
     75
     76  unsigned int *startMos, *stopMos;
     77  off_t *indexMos;
    2678
    2779  Nmosaic = 0;
    … …  
    2981  ALLOCATE (mosaic, Mosaic, NMOSAIC);
    3082
    31   ALLOCATE (Nmosaic_own_images, int, NMOSAIC);
    32   ALLOCATE (Amosaic_own_images, int, NMOSAIC);
    33   ALLOCATE (mosaic_own_images, int *, NMOSAIC);
     83  ALLOCATE (Nmosaic_own_images, off_t, NMOSAIC);
     84  ALLOCATE (Amosaic_own_images, off_t, NMOSAIC);
     85  ALLOCATE (mosaic_own_images, off_t *, NMOSAIC);
     86  ALLOCATE (startMos, unsigned int, NMOSAIC);
     87  ALLOCATE (stopMos, unsigned int, NMOSAIC);
     88  ALLOCATE (indexMos, off_t, NMOSAIC);
    3489
    3590  /* find the mosaic images (coords.ctype = DIS); generate list of unique mosaics */
    … …  
    54109    Nmosaic_own_images[Nmosaic] = 0;
    55110    Amosaic_own_images[Nmosaic] = 10;
    56     ALLOCATE (mosaic_own_images[Nmosaic], int, Amosaic_own_images[Nmosaic]);
     111    ALLOCATE (mosaic_own_images[Nmosaic], off_t, Amosaic_own_images[Nmosaic]);
     112
     113    startMos[Nmosaic] = start;
     114    stopMos[Nmosaic] = stop;
     115    indexMos[Nmosaic] = Nmosaic;
    57116
    58117    Nmosaic ++;
    … …  
    60119      NMOSAIC += 10;
    61120      REALLOCATE (mosaic, Mosaic, NMOSAIC);
    62       REALLOCATE (mosaic_own_images, int *, NMOSAIC);
    63       REALLOCATE (Nmosaic_own_images, int, NMOSAIC);
    64       REALLOCATE (Amosaic_own_images, int, NMOSAIC);
    65     }
    66   }
    67 
     121      REALLOCATE (mosaic_own_images, off_t *, NMOSAIC);
     122      REALLOCATE (Nmosaic_own_images, off_t, NMOSAIC);
     123      REALLOCATE (Amosaic_own_images, off_t, NMOSAIC);
     124      REALLOCATE (startMos, unsigned int, NMOSAIC);
     125      REALLOCATE (stopMos, unsigned int, NMOSAIC);
     126      REALLOCATE (indexMos, off_t, NMOSAIC);
     127    }
     128  }
     129
     130  // sort the index, start, and stop by the start times:
     131  sort_mosaic_times (startMos, stopMos, indexMos, Nmosaic);
     132 
    68133  // array to store image->mosaic index
    69134  Nmosaic_for_images = Nimage;
    70   ALLOCATE (mosaic_for_images, int, Nmosaic_for_images);
     135  ALLOCATE (mosaic_for_images, off_t, Nmosaic_for_images);
    71136
    72137  /* now assign the WRP images to these mosaics */
    … …  
    80145    stop  = image[i].tzero + MAX(1.01*image[i].trate*image[i].NY, 1);
    81146
    82     /* find existing mosaic with this time range */
    83     found = FALSE;
    84     for (j = 0; !found && (j < Nmosaic); j++) {
    85       if (stop  < mosaic[j].start) continue;
    86       if (start > mosaic[j].stop)  continue;
    87       found = TRUE;
    88       break;
    89     }
    90     /* if no matching mosaic exists, skip this image */
    91     if (!found) continue;
     147    Nmos = getMosaicByTimes (start, stop, startMos, stopMos, indexMos);
     148    if (Nmos == -1) continue;
    92149
    93150    // mosaic corresponding to this image
    94     mosaic_for_images[i] = j;
     151    mosaic_for_images[i] = Nmos;
    95152
    96153    // add image to mosaic_own_image list
    97     mosaic_own_images[j][Nmosaic_own_images[j]] = i;
    98     Nmosaic_own_images[j] ++;
    99     if (Nmosaic_own_images[j] == Amosaic_own_images[j]) {
    100       Amosaic_own_images[j] += 10;
    101       REALLOCATE (mosaic_own_images[j], int, Amosaic_own_images[j]);
    102     }
    103     assert (Nmosaic_own_images[j] < Amosaic_own_images[j]);
     154    mosaic_own_images[Nmos][Nmosaic_own_images[Nmos]] = i;
     155    Nmosaic_own_images[Nmos] ++;
     156    if (Nmosaic_own_images[Nmos] == Amosaic_own_images[Nmos]) {
     157      Amosaic_own_images[Nmos] += 10;
     158      REALLOCATE (mosaic_own_images[Nmos], off_t, Amosaic_own_images[Nmos]);
     159    }
     160    assert (Nmosaic_own_images[Nmos] < Amosaic_own_images[Nmos]);
    104161  }
    105162
    … …  
    109166// return StarData values for detections in the specified image, converting coordinates from the
    110167// chip positions: X,Y -> L,M -> P,Q -> R,D
    111 StarData *getMosaicRaw (Catalog *catalog, int Ncatalog, int mos, int *Nstars) {
    112 
    113   int i, j, im, Nraw, Nnew;
     168StarData *getMosaicRaw (Catalog *catalog, int Ncatalog, off_t mos, off_t *Nstars) {
     169
     170  off_t i, j, im, Nraw, Nnew;
    114171  StarData *raw, *new;
    115172
    … …  
    142199// return StarData values for averages positions in the specified image, converting coordinates from
    143200// the sky positions: R,D -> P,Q -> L,M -> X,Y
    144 StarData *getMosaicRef (Catalog *catalog, int Ncatalog, int mos, int *Nstars) {
    145 
    146   int i, j, im, Nref, Nnew;
     201StarData *getMosaicRef (Catalog *catalog, int Ncatalog, off_t mos, off_t *Nstars) {
     202
     203  off_t i, j, im, Nref, Nnew;
    147204  StarData *ref, *new;
    148205 
    … …  
    172229}
    173230
    174 Mosaic *getMosaicForImage (int im) {
    175 
    176   int mos;
     231Mosaic *getMosaicForImage (off_t im) {
     232
     233  off_t mos;
    177234
    178235  if (im < 0) abort();

  • trunk/Ohana/src/relastro/src/UpdateChips.c

    r17151 r27435  
    44
    55  /* we can measure new image parameters for each non-mosaic chip independently */
    6   int i, Nimage, Nraw, Nref;
     6  off_t i, Nimage, Nraw, Nref;
    77  Image *image;
    88  StarData *raw, *ref;
    … …  
    2525
    2626    // FitChip does iterative, clipped fitting
    27     fprintf (stderr, "image %d : Nstars: %d\n", i, Nraw);
     27    fprintf (stderr, "image %lld : Nstars: %lld\n", (long long) i, (long long) Nraw);
    2828    FitChip (raw, ref, Nraw, &image[i].coords);
    2929

  • trunk/Ohana/src/relastro/src/UpdateMeasures.c

    r16810 r27435  
    33int UpdateMeasures (Catalog *catalog, int Ncatalog) {
    44
    5   int i, Nimage;
     5  off_t i, Nimage;
    66  Image *image;
    77

  • trunk/Ohana/src/relastro/src/UpdateMosaic.c

    r15600 r27435  
    44
    55  /* we can measure new image parameters for each mosaic independently */
    6   int i, Nmosaic, Nstars;
     6  off_t i, Nmosaic, Nstars;
    77  Mosaic *mosaic;
    88  StarData *raw, *ref;

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

    r24308 r27435  
    11# include "relastro.h"
    22
    3 static int Nmax;
     3static off_t  Nmax;
    44static double *X, *dX;
    55static double *Y, *dY;
    … …  
    1313void initObjectData (Catalog *catalog, int Ncatalog) {
    1414
    15   int i, j;
     15  off_t i, j;
    1616 
    1717  Nmax = 0;
    … …  
    4040int UpdateObjects (Catalog *catalog, int Ncatalog) {
    4141
    42   int i, j, k, m, N, Nsecfilt, found, kp;
     42  int i, j, k, m, N, Nsecfilt;
    4343  StatType statsR, statsD;
    4444  Coords coords;
    … …  
    4747  int mode, Nave, Npm, Npar, Nskip;
    4848  double Tmin, Tmax;
    49   float mag;
    50   int mask;
    51   PhotCode *code;
    5249
    5350  initObjectData (catalog, Ncatalog);
    … …  
    7471  for (i = 0; i < Ncatalog; i++) {
    7572
    76     if (VERBOSE) fprintf (stderr, "astrometrize catalog %d : %d ave, %d meas\n", i, catalog[i].Naverage, catalog[i].Nmeasure);
     73    if (VERBOSE) fprintf (stderr, "astrometrize catalog %d : %lld ave, %lld meas\n", i, (long long) catalog[i].Naverage, (long long) catalog[i].Nmeasure);
    7774
    7875    Nskip = 0;

  • trunk/Ohana/src/relastro/src/UpdateSimple.c

    r15590 r27435  
    44
    55  /* we can measure new image parameters for each non-mosaic chip independently */
    6   int i, Nimage, Nstars;
     6  off_t i, Nimage, Nstars;
    77  Image *image;
    88  StarData *raw, *ref;

  • trunk/Ohana/src/relastro/src/bcatalog.c

    r24308 r27435  
    33int bcatalog (Catalog *subcatalog, Catalog *catalog) {
    44
    5   int i, j, k, offset, found;
    6   int NAVERAGE, NMEASURE, Naverage, Nmeasure, Nm, Nsecfilt;
    7   float mag;
    8   int mask;
    9   PhotCode *code;
     5  off_t i, j, offset;
     6  off_t NAVERAGE, NMEASURE, Naverage, Nmeasure, Nm;
     7  int Nsecfilt;
    108
    119  // XXX in the future, use catalog[0].Nsecfilt only?  allow catalogs to have variable Nsecfilt?
    … …  
    106104
    107105  if (VERBOSE) {
    108     fprintf (stderr, "%d: using %d stars (%d measures) for catalog\n", i,
    109              subcatalog[0].Naverage, subcatalog[0].Nmeasure);
     106    fprintf (stderr, "%lld: using %lld stars (%lld measures) for catalog\n", (long long) i, (long long) subcatalog[0].Naverage, (long long) subcatalog[0].Nmeasure);
    110107   }
    111108  return (TRUE);

  • trunk/Ohana/src/relastro/src/load_images.c

    r25757 r27435  
    11# include "relastro.h"
     2
     3# define MARKTIME(MSG,...) { \
     4  float dtime; \
     5  gettimeofday (&stop, (void *) NULL); \
     6  dtime = DTIME (stop, start); \
     7  fprintf (stderr, MSG, __VA_ARGS__); }
    28
    39SkyList *load_images (FITS_DB *db, SkyRegion *region) {
    410
    511  Image     *image, *subset;
    6   int        Nimage, Nsubset;
    7   int       *LineNumber;
     12  off_t      Nimage, Nsubset;
     13  off_t     *LineNumber;
     14  struct timeval start, stop;
    815
    916  SkyTable *sky = NULL;
    1017  SkyList *skylist = NULL;
     18
     19  gettimeofday (&start, (void *) NULL);
    1120
    1221  // load the current sky table (layout of all SkyRegions)
    … …  
    1625  // determine the populated SkyRegions overlapping the requested area
    1726  skylist = SkyListByPatch (sky, -1, region);
     27  MARKTIME("  setup sky: %f sec\n", dtime);
    1828
    1929  // convert database table to internal structure
    2030  image = gfits_table_get_Image (&db[0].ftable, &Nimage, &db[0].swapped);
     31  MARKTIME("  convert image table: %f sec\n", dtime);
    2132
    2233  // select the images which overlap the selected sky regions
    2334  subset = select_images (skylist, image, Nimage, &LineNumber, &Nsubset);
     35  MARKTIME("  select images: %f sec\n", dtime);
    2436
    2537  gfits_vtable_from_ftable (&db[0].ftable, &db[0].vtable, LineNumber, Nsubset);
    2638
    2739  initImages (subset, Nsubset);
     40  MARKTIME("  init images: %f sec\n", dtime);
     41
    2842  initMosaics (subset, Nsubset);
     43  MARKTIME("  init mosaics: %f sec\n", dtime);
    2944 
    3045  /* unlock, if we can (else, unlocked below) */

  • trunk/Ohana/src/relastro/src/relastro.c

    r17243 r27435  
    11# include "relastro.h"
     2
     3# define MARKTIME(MSG,...) { \
     4  float dtime; \
     5  gettimeofday (&stop, (void *) NULL); \
     6  dtime = DTIME (stop, start); \
     7  fprintf (stderr, MSG, __VA_ARGS__); }
    28
    39int main (int argc, char **argv) {
    … …  
    612  Catalog *catalog;
    713  FITS_DB db;
     14  struct timeval start, stop;
    815
    916  SkyList *skylist = NULL;
     17
     18  gettimeofday (&start, (void *) NULL);
    1019
    1120  /* get configuration info, args */
    … …  
    2635  if (db.dbstate == LCK_EMPTY) Shutdown ("ERROR: No images in catalog %s (1)", db.filename);
    2736  if (!dvo_image_load (&db, VERBOSE, FALSE)) Shutdown ("can't read image catalog %s", db.filename);
     37  MARKTIME("load image data: %f sec\n", dtime);
    2838
    2939  /* load regions and images based on specified sky patch (default depth) */
    3040  skylist = load_images (&db, &UserPatch);
     41  MARKTIME("load images: %f sec\n", dtime);
    3142
    3243  /* load catalog data from region files : subselect high-quality measurements */
    3344  catalog = load_catalogs (skylist, &Ncatalog, TRUE);
     45  MARKTIME("load catalog data: %f sec\n", dtime);
    3446
    3547  /* match measurements with images */
    3648  initImageBins (catalog, Ncatalog);
     49  MARKTIME("make image bins: %f sec\n", dtime);
     50
    3751  findImages (catalog, Ncatalog);
     52  MARKTIME("set up image indexes: %f sec\n", dtime);
    3853
    3954  if (PLOTSTUFF) {

  • trunk/Ohana/src/relastro/src/select_images.c

    r21508 r27435  
    1313} SkyRegionCoords;
    1414
    15 Image *select_images (SkyList *skylist, Image *timage, int Ntimage, int **LineNumber, int *Nimage) {
     15void dsortindex (double *X, off_t *Y, int N);
     16off_t getRegionStartByRA (double R, double *Rref, off_t Nregions);
     17
     18Image *select_images (SkyList *skylist, Image *timage, off_t Ntimage, off_t **LineNumber, off_t *Nimage) {
    1619 
    1720  Image *image;
    18   int i, j, k, m, found, nimage, NIMAGE;
    19   int InRange;
     21  off_t i, j, k, m, nStart, iSky, nimage, NIMAGE;
     22  int InRange, found;
    2023  double Ri[5], Di[5], Xi[5], Yi[5], dx, dy;
    21   int *line_number;
     24  off_t *line_number;
    2225  Coords tcoords;
    2326  SkyRegionCoords *skycoords;
    2427 
     28  double *RmaxSky;
     29  off_t *index;
     30
    2531  if (skylist[0].Nregions < 1) {
    2632    *Nimage = 0;
    … …  
    3844
    3945  ALLOCATE (skycoords, SkyRegionCoords, skylist[0].Nregions);
     46
     47  ALLOCATE (RmaxSky, double, skylist[0].Nregions);
     48  ALLOCATE (index, off_t, skylist[0].Nregions);
    4049
    4150  /* compare with each region file */
    … …  
    5665    skycoords[i].Yc[4] = skycoords[i].Yc[0];   
    5766
     67    RmaxSky[i] = skylist[0].regions[i][0].Rmax;
     68    index[i] = i;
     69
    5870    dx = 0.02*(skycoords[i].Xc[2] - skycoords[i].Xc[0]);
    5971    dy = 0.02*(skycoords[i].Yc[2] - skycoords[i].Yc[0]);
    … …  
    6577  }
    6678
     79  dsortindex (RmaxSky, index, skylist[0].Nregions);
     80
    6781  if (VERBOSE) fprintf (stderr, "finding images\n");
    6882  BuildChipMatch (timage, Ntimage);
    … …  
    7185  NIMAGE = 100;
    7286  ALLOCATE (image, Image, NIMAGE);
    73   ALLOCATE (line_number, int, NIMAGE);
     87  ALLOCATE (line_number, off_t, NIMAGE);
    7488 
    7589  // go through the complete list of images, selecting ones which overlap any region
    … …  
    100114    }
    101115   
    102     if (!FindMosaicForImage (timage, Ntimage, i)) continue;
     116    if (!FindMosaicForImage (timage, Ntimage, i)) {
     117      fprintf (stderr, "cannot find mosaic for %lld\n", (long long) i);
     118      continue;
     119    }
    103120
    104121    /* define image corners */
    … …  
    111128
    112129    /* transform to ra,dec */
     130    double RminImage = 360.0;
     131    // double RmaxImage =   0.0;
    113132    for (j = 0; j < 5; j++) {
    114133      XY_to_RD (&Ri[j], &Di[j], Xi[j], Yi[j], &timage[i].coords);
    115     }
     134      RminImage = MIN(RminImage, Ri[j]);
     135      // RmaxImage = MIN(RmaxImage, Ri[j]);
     136    }
     137
     138    // RA(nStart) is guaranteed to be < RminImage:
     139    nStart = getRegionStartByRA (RminImage, RmaxSky, skylist[0].Nregions);
    116140
    117141    /* compare with each region file */
    118     for (m = 0; (m < skylist[0].Nregions) && !found; m++) {
     142    for (iSky = nStart; (iSky < skylist[0].Nregions) && !found; iSky++) {
     143
     144      m = index[iSky];
     145      // if (RmaxImage < skylist[0].regions[m][0].Rmin) {
     146      // break;
     147      // }
    119148
    120149      /* we make positional comparisons in the projection of catalog */
    … …  
    122151      tcoords.crval2 = skycoords[m].Dc;
    123152
    124       /* transform to ra,dec */
     153      /* transform corner coords to X,Y in this catalog system */
    125154      InRange = TRUE;
    126155      for (j = 0; (j < 5) && InRange; j++) {
    … …  
    161190        NIMAGE += 100;
    162191        REALLOCATE (image, Image, NIMAGE);
    163         REALLOCATE (line_number, int, NIMAGE);
     192        REALLOCATE (line_number, off_t, NIMAGE);
    164193      }
    165194    }
    166195  }
    167196     
    168   if (VERBOSE) fprintf (stderr, "found %d images\n", nimage);
     197  if (VERBOSE) fprintf (stderr, "found %lld images\n", (long long) nimage);
    169198
    170199  REALLOCATE (image, Image, MAX (nimage, 1));
    171   REALLOCATE (line_number, int, MAX (nimage, 1));
     200  REALLOCATE (line_number, off_t, MAX (nimage, 1));
    172201  free (skycoords);
    173202
    … …  
    253282}
    254283
     284void dsortindex (double *X, off_t *Y, int N) {
     285
     286# define SWAPFUNC(A,B){ double tmpf; off_t tmpi; \
     287  tmpf = X[A]; X[A] = X[B]; X[B] = tmpf; \
     288  tmpi = Y[A]; Y[A] = Y[B]; Y[B] = tmpi; \
     289}
     290# define COMPARE(A,B)(X[A] < X[B])
     291
     292  OHANA_SORT (N, COMPARE, SWAPFUNC);
     293
     294# undef SWAPFUNC
     295# undef COMPARE
     296
     297}
     298
     299off_t getRegionStartByRA (double R, double *Rref, off_t Nregions) {
     300
     301  // use bisection to find the overlapping mosaic
     302
     303  off_t Nlo, Nhi, N;
     304
     305  // find the last mosaic before start
     306  Nlo = 0; Nhi = Nregions;
     307  while (Nhi - Nlo > 10) {
     308    N = 0.5*(Nlo + Nhi);
     309    if (Rref[N] < R) {
     310      Nlo = MAX(N, 0);
     311    } else {
     312      Nhi = MIN(N, Nregions);
     313    }
     314  }
     315  return (Nlo);
     316}

  • trunk/Ohana/src/relphot/include/relphot.h

    r21508 r27435  
    77# define GRID_V2
    88# define NO_IMAGE -100
    9 
    10 # if (0)
    11 typedef struct {
    12   double xmin, xmax, ymin, ymax;
    13   int style, ptype, ltype, etype, color;
    14   double lweight, size;
    15 } Graphdata;
    16 # endif
    179
    1810typedef struct {
    … …  
    110102
    111103# ifdef GRID_V1
    112 int setGridMeasure (int meas, int cat, double X, double Y);
     104int setGridMeasure (off_t meas, int cat, double X, double Y);
    113105# endif
    114106
    115107# ifdef GRID_V2
    116 int setGridMeasure (int meas, int cat, double X, double Y, int ccdnum);
     108int setGridMeasure (off_t meas, int cat, double X, double Y, int ccdnum);
    117109# endif
    118110
    … …  
    122114char         *GetPhotnamebyCode   PROTO((PhotCodeData *photcodes, int code));
    123115void          InterpolateGrid     PROTO((float *buffer, int Nx, int Ny, Coords *ccd, Coords *gcoords));
    124 int          *SelectRefMosaic     PROTO((Mosaic **refmosaic, int *Nimage));
     116off_t        *SelectRefMosaic     PROTO((Mosaic **refmosaic, off_t *Nimage));
    125117int           args                PROTO((int argc, char **argv));
    126118int           bcatalog            PROTO((Catalog *subcatalog, Catalog *catalog));
    … …  
    137129
    138130void set_db (FITS_DB *in);
    139 int Shutdown (char *format, ...);
     131int Shutdown (char *format, ...) OHANA_FORMAT(printf, 1, 2) ;
    140132void TrapSignal (int sig);
    141133void SetProtect (int mode);
    … …  
    147139void          free_catalogs       PROTO((Catalog *catalog, int Ncatalog));
    148140int           gcatalog            PROTO((Catalog *catalog, int FINAL));
    149 Coords       *getCoords           PROTO((int meas, int cat));
    150 int           getImageEntry       PROTO((int meas, int cat));
    151 float         getMcal             PROTO((int meas, int cat));
    152 float         getMgrid            PROTO((int meas, int cat));
    153 float         getMmos             PROTO((int meas, int cat));
    154 float         getMrel             PROTO((Catalog *catalog, int meas, int cat));
    155 Image        *getimage            PROTO((int N));
    156 Image        *getimages           PROTO((int *N));
     141Coords       *getCoords           PROTO((off_t meas, int cat));
     142off_t         getImageEntry       PROTO((off_t meas, int cat));
     143float         getMcal             PROTO((off_t meas, int cat));
     144float         getMgrid            PROTO((off_t meas, int cat));
     145float         getMmos             PROTO((off_t meas, int cat));
     146float         getMrel             PROTO((Catalog *catalog, off_t meas, int cat));
     147Image        *getimage            PROTO((off_t N));
     148Image        *getimages           PROTO((off_t *N));
    157149void          global_stats        PROTO((Catalog *catalog, int Ncatalog));
    158150void          initGrid            PROTO((int dX, int dY));
    159151void          initGridBins        PROTO((Catalog *catalog, int Ncatalog));
    160152void          initImageBins       PROTO((Catalog *catalog, int Ncatalog));
    161 void          initImages          PROTO((Image *input, int N));
     153void          initImages          PROTO((Image *input, off_t N));
    162154void          initMosaicBins      PROTO((Catalog *catalog, int Ncatalog));
    163 void          initMosaicGrid      PROTO((Image *image, int Nimage));
    164 void          initMosaics         PROTO((Image *image, int Nimage));
     155void          initMosaicGrid      PROTO((Image *image, off_t Nimage));
     156void          initMosaics         PROTO((Image *image, off_t Nimage));
    165157void          initMrel            PROTO((Catalog *catalog, int Ncatalog));
    166158void          initialize          PROTO((int argc, char **argv));
    … …  
    169161Catalog       *load_catalogs      PROTO((SkyList *skylist, int *Ncatalog));
    170162SkyList      *load_images         PROTO((FITS_DB *db, char *regionName, SkyRegion *region, int RegionSelect));
    171 Image         *select_images      PROTO((SkyList *skylist, Image *timage, int Ntimage, int **LineNumber, int *Nimage));
     163Image         *select_images      PROTO((SkyList *skylist, Image *timage, off_t Ntimage, off_t **LineNumber, off_t *Nimage));
    172164
    173165int           main                PROTO((int argc, char **argv));
    174 void          mark_images         PROTO((Image *image, int Nimage, Image *timage, int Ntimage));
    175 void          matchImage          PROTO((Catalog *catalog, int meas, int cat));
    176 void          matchMosaics        PROTO((Catalog *catalog, int meas, int cat));
     166void          mark_images         PROTO((Image *image, off_t Nimage, Image *timage, off_t Ntimage));
     167void          matchImage          PROTO((Catalog *catalog, off_t meas, int cat));
     168void          matchMosaics        PROTO((Catalog *catalog, off_t meas, int cat));
    177169double        opening_angle       PROTO((double x1, double y1, double x2, double y2, double x3, double y3));
    178170void          plot_chisq          PROTO((Catalog *catalog, int Ncatalog));
    … …  
    180172void          plot_grid           PROTO((Catalog *catalog));
    181173void          plot_images         PROTO((void));
    182 void          plot_list           PROTO((Graphdata *graphdata, double *xlist, double *ylist, int N, char *label, char *format, ...));
     174void          plot_list           PROTO((Graphdata *graphdata, double *xlist, double *ylist, int N, char *label, char *format, ...) OHANA_FORMAT(printf, 6, 7) );
    183175void          plot_mosaic_fields  PROTO((Catalog *catalog));
    184176void          plot_mosaics        PROTO((void));
    … …  
    199191int           setMave             PROTO((Catalog *catalog, int Ncatalog));
    200192void          set_ZP              PROTO((double ZERO));
    201 int           setrefcode          PROTO((Image *image, int Nimage));
     193int           setrefcode          PROTO((Image *image, off_t Nimage));
    202194void          skip_measurements   PROTO((Catalog *catalog, int pass));
    203195void          sortA               PROTO((double *X, int N));

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

    r21508 r27435  
    77};
    88
    9 static int     Ngrid;
     9static int     Ngrid;  // number of grid elements (gridX * gridY)
    1010static float   *gridM; // magnitude offset for this grid cell
    1111static float   *gridS; // stdev of the magnitude offset for this grid cell
    1212static int     *gridN; // number of stars used to measure the magnitude offset for this grid cell
    1313static int     *gridV; // data mode for this cell: fitted, frozen, reference
    14 static int      gridX;
    15 static int      gridY;
    16 
    17 static int    **bin;
    18 static int    **Xmeas;
    19 static int    **Ymeas;
     14static int      gridX; // number of grid elements in X direction
     15static int      gridY; // number of grid elements in Y direction
     16
     17static int    **bin;   // link from catalog, measure to grid element
     18static int    **Xmeas; // grid x-coordinate for a measurement
     19static int    **Ymeas; // grid y-coordinate for a measurement
    2020
    2121static int    **clist; // link from measurement on a cell to catalog containing measurement
    22 static int    **mlist; // link from measurement on a cell to measurement in a catalog
    23 static int     *Nlist; // list of measurements for each grid cell
    24 static int     *NLIST;
     22static off_t  **mlist; // link from measurement on a cell to measurement in a catalog
     23static off_t   *Nlist; // number of measurements for each grid cell
     24static off_t   *NLIST; // allocated number of measurements for each grid cell
    2525
    2626static struct {
    … …  
    159159  ALLOCATE (Ymeas, int *, Ncatalog);
    160160  for (i = 0; i < Ncatalog; i++) {
    161     ALLOCATE (bin[i], int, MAX (catalog[i].Nmeasure, 1));
     161    ALLOCATE (bin[i],   int, MAX (catalog[i].Nmeasure, 1));
    162162    ALLOCATE (Xmeas[i], int, MAX (catalog[i].Nmeasure, 1));
    163163    ALLOCATE (Ymeas[i], int, MAX (catalog[i].Nmeasure, 1));
    … …  
    166166
    167167  /* define grid -> cat,meas pointers */
    168   ALLOCATE (Nlist, int, Ngrid);
    169   ALLOCATE (NLIST, int, Ngrid);
    170   ALLOCATE (clist, int *, Ngrid);
    171   ALLOCATE (mlist, int *, Ngrid);
     168  ALLOCATE (Nlist, off_t,  Ngrid);
     169  ALLOCATE (NLIST, off_t,  Ngrid);
     170  ALLOCATE (clist, int *,   Ngrid);
     171  ALLOCATE (mlist, off_t *, Ngrid);
    172172
    173173  for (i = 0; i < Ngrid; i++) {
    174174    Nlist[i] = 0;
    175175    NLIST[i] = 100;
    176     ALLOCATE (clist[i], int, NLIST[i]);
    177     ALLOCATE (mlist[i], int, NLIST[i]);
     176    ALLOCATE (clist[i], int,   NLIST[i]);
     177    ALLOCATE (mlist[i], off_t, NLIST[i]);
    178178  }
    179179}
    … …  
    206206}
    207207
    208 int setGridMeasure (int meas, int cat, double X, double Y, int ccdnum) {
     208int setGridMeasure (off_t meas, int cat, double X, double Y, int ccdnum) {
    209209
    210210  int ix, iy, Cx, Cy, i;
    … …  
    241241  if (Nlist[i] == NLIST[i]) {
    242242    NLIST[i] += 100;
    243     REALLOCATE (clist[i], int, NLIST[i]);
    244     REALLOCATE (mlist[i], int, NLIST[i]);
     243    REALLOCATE (clist[i], int,   NLIST[i]);
     244    REALLOCATE (mlist[i], off_t, NLIST[i]);
    245245  }     
    246246  return (TRUE);
    … …  
    264264}
    265265
    266 float getMgrid (int meas, int cat) {
     266float getMgrid (off_t meas, int cat) {
    267267
    268268  int i;
    … …  
    287287
    288288  int **gotstar, **gridmeas;
    289   int i, j, k, N, Ngood, Nbad, Nmos, Ncal, Nrel, Nsys;
     289  int i, j, k, Ngood, Nbad, Nmos, Ncal, Nrel, Nsys;
    290290  double **A, **B, *Mjx, *Wjx;
    291291  float Msys, Mcal, Mmos, Merr, Wsys;
    … …  
    498498    gridM[i] = B[i][0];
    499499    gridS[i] = sqrt(A[i][i]);
    500     gridN[i] = N;
     500    gridN[i] = Ngood;
    501501  }
    502502
    … …  
    673673void dump_grid () {
    674674
    675   int i, j, Nimage, Nbytes, Nformat;
    676   int *imlist;
     675  off_t i, Nimage;
     676  int j, Nbytes, Nformat;
     677  off_t *imlist;
    677678  FILE *f;
    678679  Header header, theader;
    … …  
    702703  gfits_create_header (&header);
    703704  gfits_create_matrix (&header, &matrix);
    704   gfits_modify (&header, "NEXTEND", "%d", 1, Nimage + 3);
     705  gfits_modify (&header, "NEXTEND", "%lld", 1, (long long) Nimage + 3);
    705706  gfits_modify (&header, "FILTER", "%s", 1, photcode[0].name);
    706   gfits_modify (&header, "COMMENT", "%S", 1, "Mosaic Photometry Grid Analysis");
     707  gfits_modify_alt (&header, "COMMENT", "%S", 1, "Mosaic Photometry Grid Analysis");
    707708
    708709  // we need to add lines to the PHU to identify the camera and format; these are used by the ipp config system

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

    r21508 r27435  
    33static unsigned int *start;
    44static unsigned int *stop;
    5 static int         **bin;
    6 
    7 static int         **clist;
    8 static int         **mlist;
    9 static int          *Nlist;
    10 static int          *NLIST;
     5static off_t       **bin;
     6
     7static off_t       **clist;
     8static off_t       **mlist;
     9static off_t        *Nlist;
     10static off_t        *NLIST;
    1111
    1212static Image        *image;
    13 static int          Nimage;
    14 
    15 void initImages (Image *input, int N) {
    16 
    17   int i;
     13static off_t        Nimage;
     14
     15void initImages (Image *input, off_t N) {
     16
     17  off_t i;
    1818
    1919  image = input;
    … …  
    3131void initImageBins (Catalog *catalog, int Ncatalog) {
    3232
    33   int i, j;
    34 
    35   ALLOCATE (bin, int *, Ncatalog);
     33  off_t i, j;
     34
     35  ALLOCATE (bin, off_t *, Ncatalog);
    3636  for (i = 0; i < Ncatalog; i++) {
    37     ALLOCATE (bin[i], int, MAX (catalog[i].Nmeasure, 1));
     37    ALLOCATE (bin[i], off_t, MAX (catalog[i].Nmeasure, 1));
    3838    for (j = 0; j < catalog[i].Nmeasure; j++) bin[i][j] = -1;
    3939  }
    4040
    41   ALLOCATE (Nlist, int, Nimage);
    42   ALLOCATE (NLIST, int, Nimage);
    43   ALLOCATE (clist, int *, Nimage);
    44   ALLOCATE (mlist, int *, Nimage);
     41  ALLOCATE (Nlist, off_t, Nimage);
     42  ALLOCATE (NLIST, off_t, Nimage);
     43  ALLOCATE (clist, off_t *, Nimage);
     44  ALLOCATE (mlist, off_t *, Nimage);
    4545
    4646  for (i = 0; i < Nimage; i++) {
    4747    Nlist[i] = 0;
    4848    NLIST[i] = 100;
    49     ALLOCATE (clist[i], int, NLIST[i]);
    50     ALLOCATE (mlist[i], int, NLIST[i]);
     49    ALLOCATE (clist[i], off_t, NLIST[i]);
     50    ALLOCATE (mlist[i], off_t, NLIST[i]);
    5151  }
    5252}
    … …  
    5454void freeImageBins (int Ncatalog) {
    5555
    56   int i;
     56  off_t i;
    5757
    5858  for (i = 0; i < Ncatalog; i++) {
    … …  
    7070/* **** use this to mimic the Mosaic version ***/
    7171# if (0)
    72 void initImageGrid (Image *image, int Nimage) {
     72void initImageGrid (Image *image, off_t Nimage) {
    7373
    7474  /* find max dR, dD range for all mosaics */
    … …  
    7676  /* send results to initGridBins */
    7777
    78   int i, j, m, NX, NY;
     78  off_t i, j, m, NX, NY;
    7979  int dXmax, dYmax;
    8080  double dS, dX, dY;
    … …  
    151151void findImages (Catalog *catalog, int Ncatalog) {
    152152
    153   int i, j, ecode;
     153  off_t j;
     154  int i, ecode;
    154155
    155156  for (i = 0; i < Ncatalog; i++) {
    … …  
    164165/* XXX convert this to use the values of measure->Xccd,Yccd */
    165166/* XXX need to apply the conversion for ELIXIR and LONEOS formats */
    166 void matchImage (Catalog *catalog, int meas, int cat) {
    167 
    168   int i, ccdnum;
     167void matchImage (Catalog *catalog, off_t meas, int cat) {
     168
     169  off_t i;
     170  int ccdnum;
    169171  double X, Y;
    170172  char *pname, *filter, *p, base[256];
    … …  
    220222    if (Nlist[i] == NLIST[i]) {
    221223      NLIST[i] += 100;
    222       REALLOCATE (clist[i], int, NLIST[i]);
    223       REALLOCATE (mlist[i], int, NLIST[i]);
     224      REALLOCATE (clist[i], off_t, NLIST[i]);
     225      REALLOCATE (mlist[i], off_t, NLIST[i]);
    224226    }   
    225227    return;
    … …  
    228230}
    229231
    230 int getImageEntry (int meas, int cat) {
    231 
    232   int i;
     232off_t getImageEntry (off_t meas, int cat) {
     233
     234  off_t i;
    233235
    234236  i = bin[cat][meas];
    … …  
    236238}
    237239
    238 float getMcal (int meas, int cat) {
    239 
    240   int i;
     240float getMcal (off_t meas, int cat) {
     241
     242  off_t i;
    241243  float value;
    242244
    … …  
    249251}
    250252
    251 Coords *getCoords (int meas, int cat) {
    252 
    253   int i;
     253Coords *getCoords (off_t meas, int cat) {
     254
     255  off_t i;
    254256
    255257  i = bin[cat][meas];
    … …  
    261263void setMcal (Catalog *catalog, int PoorImages) {
    262264
    263   int i, j, m, c, n, N, Nmax, mark, bad, Nfew, Nbad, Nmos, Ngrid, Nrel, Nsys;
     265  off_t i, j, m, c, n, N, Nmax, mark, bad;
     266  int Nfew, Nbad, Nmos, Ngrid, Nrel, Nsys;
    264267  float Msys, Mrel, Mmos, Mgrid;
    265268  double *list, *dlist;
    … …  
    359362void clean_images () {
    360363
    361   int i, N, mark, Nmark;
     364  int mark, Nmark;
     365  off_t i, N;
    362366  double *mlist, *slist, *dlist;
    363367  double MaxOffset, MaxScatter, MedOffset;
    … …  
    409413void plot_images () {
    410414
    411   int i, bin;
     415  off_t i, bin;
    412416  double *xlist, *Mlist, *dlist;
    413417  Graphdata graphdata;
    … …  
    457461StatType statsImageN (Catalog *catalog) {
    458462
    459   int i, j, m, c, n, N;
     463  off_t i, j, m, c, n, N;
    460464  double *list, *dlist;
    461465  float Mcal, Mmos, Mgrid;
    … …  
    499503StatType statsImageX (Catalog *catalog) {
    500504
    501   int i, n;
     505  off_t i, n;
    502506  double *list, *dlist;
    503507  StatType stats;
    … …  
    527531StatType statsImageM (Catalog *catalog) {
    528532
    529   int i, n;
     533  off_t i, n;
    530534  double *list, *dlist;
    531535  StatType stats;
    … …  
    555559StatType statsImagedM (Catalog *catalog) {
    556560
    557   int i, n;
     561  off_t i, n;
    558562  double *list, *dlist;
    559563  StatType stats;
    … …  
    581585}
    582586
    583 Image *getimages (int *N) {
     587Image *getimages (off_t *N) {
    584588
    585589  *N = Nimage;
    … …  
    587591}
    588592
    589 Image *getimage (int N) {
     593Image *getimage (off_t N) {
    590594  return (&image[N]);
    591595}

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

    r21508 r27435  
    11# include "relphot.h"
    22
    3 Image *getimages (int *N);
    4 
    5 static int    Nmosaic;
     3static off_t  Nmosaic;
    64static Mosaic *mosaic;
    75
    8 static int    *Nimlist;
    9 static int   **imlist; /* mosaic -> image[] */
    10 static int   **bin;    /* catalog, measure -> mosaic */
    11 
    12 static int   **clist;  /* mosaic -> catalog[] */
    13 static int   **mlist;  /* mosiac -> measure[] */
    14 static int    *Nlist;
    15 static int    *NLIST;
     6static off_t  *Nimlist;
     7static off_t   **imlist; /* mosaic -> image[] */
     8static off_t   **bin;    /* catalog, measure -> mosaic */
     9
     10static int     **clist;  /* mosaic -> catalog[] */
     11static off_t   **mlist;  /* mosiac -> measure[] */
     12static off_t    *Nlist;
     13static off_t    *NLIST;
    1614
    1715/* find mosaic frames (unique time periods & photcode name matches mosaic) */
    18 void initMosaics (Image *image, int Nimage) {
    19 
    20   int i, j, status, found, NMOSAIC, *NIMLIST;
     16void initMosaics (Image *image, off_t Nimage) {
     17
     18  off_t i, j, status, found, NMOSAIC, *NIMLIST;
    2119  unsigned int start, stop;
    2220  char *pname;
    … …  
    2826  ALLOCATE (mosaic, Mosaic, NMOSAIC);
    2927
    30   ALLOCATE (imlist, int *, NMOSAIC);
    31   ALLOCATE (Nimlist, int, NMOSAIC);
    32   ALLOCATE (NIMLIST, int, NMOSAIC);
     28  ALLOCATE (imlist,  off_t *, NMOSAIC);
     29  ALLOCATE (Nimlist, off_t,  NMOSAIC);
     30  ALLOCATE (NIMLIST, off_t,  NMOSAIC);
    3331
    3432  /* generate list of unique mosaics */
    … …  
    5654      if (Nimlist[j] == NIMLIST[j]) {
    5755        NIMLIST[j] += 10;
    58         REALLOCATE (imlist[j], int, NIMLIST[j]);
     56        REALLOCATE (imlist[j], off_t, NIMLIST[j]);
    5957      }
    6058
    … …  
    7472    NIMLIST[Nmosaic] = 10;
    7573    Nimlist[Nmosaic] = 1;
    76     ALLOCATE (imlist[Nmosaic], int, NIMLIST[Nmosaic]);
     74    ALLOCATE (imlist[Nmosaic], off_t, NIMLIST[Nmosaic]);
    7775    imlist[Nmosaic][0] = i;
    7876
    … …  
    8078    if (Nmosaic == NMOSAIC) {
    8179      NMOSAIC += 10;
    82       REALLOCATE (mosaic, Mosaic, NMOSAIC);
    83       REALLOCATE (imlist, int *, NMOSAIC);
    84       REALLOCATE (Nimlist, int, NMOSAIC);
    85       REALLOCATE (NIMLIST, int, NMOSAIC);
     80      REALLOCATE (mosaic,  Mosaic, NMOSAIC);
     81      REALLOCATE (imlist,  off_t *, NMOSAIC);
     82      REALLOCATE (Nimlist, off_t,  NMOSAIC);
     83      REALLOCATE (NIMLIST, off_t,  NMOSAIC);
    8684    }
    8785  }
    … …  
    9189}
    9290
    93 void initMosaicGrid (Image *image, int Nimage) {
     91void initMosaicGrid (Image *image, off_t Nimage) {
    9492
    9593  /* find max dR, dD range for all mosaics */
    … …  
    9795  /* send results to initGridBins */
    9896
    99   int i, j, m, NX, NY;
     97  off_t i, j, m, NX, NY;
    10098  int dXmax, dYmax;
    10199  double dS, dX, dY;
    … …  
    170168void setMcalFinal () {
    171169
    172   int i, j, im, Nimage;
     170  off_t i, j, im, Nimage;
    173171  Image *image;
    174172
    … …  
    191189void initMosaicBins (Catalog *catalog, int Ncatalog) {
    192190
    193   int i, j;
     191  off_t i, j;
    194192
    195193  /* measure -> mosaic */
    196194  if (!MOSAIC_ZEROPT) return;
    197195
    198   ALLOCATE (bin, int *, Ncatalog);
     196  ALLOCATE (bin, off_t *, Ncatalog);
    199197  for (i = 0; i < Ncatalog; i++) {
    200     ALLOCATE (bin[i], int, MAX (catalog[i].Nmeasure, 1));
     198    ALLOCATE (bin[i], off_t, MAX (catalog[i].Nmeasure, 1));
    201199    for (j = 0; j < catalog[i].Nmeasure; j++) bin[i][j] = -1;
    202200  }
    203201
    204202  /* mosaic -> measure */
    205   ALLOCATE (Nlist, int, Nmosaic);
    206   ALLOCATE (NLIST, int, Nmosaic);
    207   ALLOCATE (clist, int *, Nmosaic);
    208   ALLOCATE (mlist, int *, Nmosaic);
     203  ALLOCATE (Nlist, off_t,  Nmosaic);
     204  ALLOCATE (NLIST, off_t,  Nmosaic);
     205  ALLOCATE (clist, int *,   Nmosaic);
     206  ALLOCATE (mlist, off_t *, Nmosaic);
    209207
    210208  for (i = 0; i < Nmosaic; i++) {
    211209    Nlist[i] = 0;
    212210    NLIST[i] = 100;
    213     ALLOCATE (clist[i], int, NLIST[i]);
    214     ALLOCATE (mlist[i], int, NLIST[i]);
     211    ALLOCATE (clist[i], int,   NLIST[i]);
     212    ALLOCATE (mlist[i], off_t, NLIST[i]);
    215213  }
    216214}
    … …  
    218216void freeMosaicBins (int Ncatalog) {
    219217
    220   int i;
     218  off_t i;
    221219
    222220  /* measure -> mosaic */
    … …  
    241239int findMosaics (Catalog *catalog, int Ncatalog) {
    242240 
    243   int i, j, ecode;
     241  int i, ecode;
     242  off_t j;
    244243
    245244  if (!MOSAIC_ZEROPT) return (FALSE);
    … …  
    259258}
    260259
    261 void matchMosaics (Catalog *catalog, int meas, int cat) {
     260void matchMosaics (Catalog *catalog, off_t meas, int cat) {
    262261
    263262  int i;
    … …  
    287286    if (Nlist[i] == NLIST[i]) {
    288287      NLIST[i] += 100;
    289       REALLOCATE (clist[i], int, NLIST[i]);
    290       REALLOCATE (mlist[i], int, NLIST[i]);
     288      REALLOCATE (clist[i], int,   NLIST[i]);
     289      REALLOCATE (mlist[i], off_t, NLIST[i]);
    291290    }   
    292291    return;
    … …  
    296295}
    297296
    298 float getMmos (int meas, int cat) {
    299 
    300   int i;
     297float getMmos (off_t meas, int cat) {
     298
     299  off_t i;
    301300  float value;
    302301
    … …  
    313312int setMmos (Catalog *catalog, int PoorImages) {
    314313
    315   int i, j, m, c, n, N, Nmax, mark, bad, Nfew, Nbad, Ncal, Nrel, Ngrid, Nsys;
     314  off_t i, j, m, c, N, Nmax;
     315  int n, mark, bad, Nfew, Nbad, Ncal, Nrel, Ngrid, Nsys;
    316316  float Msys, Mrel, Mcal, Mgrid;
    317317  double *list, *dlist, *Mlist, *dMlist;
    … …  
    392392      mark = (N < IMAGE_TOOFEW) || (N < IMAGE_GOOD_FRACTION*Nlist[i]);
    393393      if (mark) {
    394         fprintf (stderr, "marked image %s (%d), (%d < %d) || (%d < %f*%d)\n", image[imlist[i][0]].name, i, N, IMAGE_TOOFEW, N, IMAGE_GOOD_FRACTION, Nlist[i]);
     394        fprintf (stderr, "marked image %s (%lld), (%lld < %d) || (%lld < %f*%lld)\n", image[imlist[i][0]].name, (long long) i, (long long) N, IMAGE_TOOFEW, (long long) N, IMAGE_GOOD_FRACTION, (long long) Nlist[i]);
    395395        mosaic[i].flags |= ID_IMAGE_FEW;
    396396        Nfew ++;
    … …  
    400400    }
    401401    liststats (list, dlist, N, &stats);
    402     if (PoorImages) fprintf (stderr, "Mmos: %f %f %d %d\n", stats.mean, stats.sigma, stats.Nmeas, N);
     402    if (PoorImages) fprintf (stderr, "Mmos: %f %f %d %lld\n", stats.mean, stats.sigma, stats.Nmeas, (long long) N);
    403403    mosaic[i].Mcal  = stats.mean;
    404404    mosaic[i].dMcal = stats.sigma;
    … …  
    422422StatType statsMosaicM (Catalog *catalog) {
    423423
    424   int i, n;
     424  off_t i;
     425  int n;
    425426  double *list, *dlist;
    426427  StatType stats;
    … …  
    448449StatType statsMosaicdM (Catalog *catalog) {
    449450
    450   int i, n;
     451  off_t i, n;
    451452  double *list, *dlist;
    452453  StatType stats;
    … …  
    476477StatType statsMosaicN (Catalog *catalog) {
    477478
    478   int i, j, m, c, n, N;
     479  off_t i, j, m, c, n, N;
    479480  double *list, *dlist;
    480481  float Mcal, Mgrid, Mrel;
    … …  
    510511    n++;
    511512  }
    512   fprintf (stderr, "Nmosaic: %d, n: %d\n", Nmosaic, n);
     513  fprintf (stderr, "Nmosaic: %lld, n: %lld\n", (long long) Nmosaic, (long long) n);
    513514
    514515  liststats (list, dlist, n, &stats);
    … …  
    520521StatType statsMosaicX (Catalog *catalog) {
    521522
    522   int i, n;
     523  off_t i, n;
    523524  double *list, *dlist;
    524525  StatType stats;
    … …  
    549550void clean_mosaics () {
    550551
    551   int i, N, mark, Nmark;
     552  off_t i, N, mark, Nmark;
    552553  double *mlist, *slist, *dlist;
    553554  double MaxOffset, MedOffset, MaxScatter;
    … …  
    590591  }
    591592
    592   fprintf (stderr, "%d mosaics marked poor\n", Nmark);
     593  fprintf (stderr, "%lld mosaics marked poor\n", (long long) Nmark);
    593594  initstats (STATMODE);
    594595  free (mlist);
    … …  
    599600void plot_mosaic_fields (Catalog *catalog) {
    600601
    601   int i, j, m, c, N, ave, Nimage;
     602  off_t i, j, m, c, N, ave, Nimage;
    602603  double *xlist, *ylist;
    603604  double Xmin, Xmax, Ymin, Ymax;
    … …  
    634635    }
    635636 
    636     sprintf (string, "Mosaic %d", i);
     637    sprintf (string, "Mosaic %lld", (long long) i);
    637638    plot_defaults (&graphdata);
    638639    plot_list (&graphdata, xlist, ylist, N, string, NULL);
    … …  
    645646void plot_mosaics () {
    646647
    647   int i, bin;
     648  off_t i, bin;
    648649  double *xlist, *Mlist, *dlist;
    649650  Graphdata graphdata;
    … …  
    694695}
    695696
    696 int *SelectRefMosaic (Mosaic **refmosaic, int *Nimage) {
    697 
    698   int i, Imax, Nmax;
     697off_t *SelectRefMosaic (Mosaic **refmosaic, off_t *Nimage) {
     698
     699  off_t i, Imax, Nmax;
    699700
    700701  Imax = 0;

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

    r25735 r27435  
    77void initMrel (Catalog *catalog, int Ncatalog) {
    88
    9   int i, j;
     9  off_t i, j;
    1010 
    1111  Nmax = 0;
    … …  
    2020} 
    2121
    22 float getMrel (Catalog *catalog, int meas, int cat) {
     22float getMrel (Catalog *catalog, off_t meas, int cat) {
    2323
    2424  int ave;
    … …  
    3434int setMrel (Catalog *catalog, int Ncatalog) {
    3535
    36   int i, j, k, m, N, Nfew, Nsys, Nbad, Ncal, Nmos, Ngrid;
     36  off_t j, k, m;
     37  int i, N, Nfew, Nsys, Nbad, Ncal, Nmos, Ngrid;
    3738  float Msys, Mcal, Mmos, Mgrid;
    3839  StatType stats;
    … …  
    109110int setMrelOutput (Catalog *catalog, int Ncatalog, int mark) {
    110111
    111   int i, j, k, m, N, Nmax;
     112  int i, N;
     113  off_t j, k, m, Nmax;
    112114  float Msys, Mcal, Mmos, Mgrid;
    113115  double *list, *dlist;
    … …  
    173175int setMave (Catalog *catalog, int Ncatalog) {
    174176
    175   int i, j, k, m, Ns, Nsecfilt, N, Nmax, Nc;
     177  off_t j, k, m, Nmax;
     178  int i, Ns, Nsecfilt, N, Nc;
    176179  float Msys;
    177180  double *list, *dlist;
    … …  
    293296int setMcalOutput (Catalog *catalog, int Ncatalog) {
    294297
    295   int i, j, k, m;
     298  int i;
     299  off_t j, k, m;
    296300  float Mcal, Mmos, Mgrid;
    297301
    … …  
    380384void clean_measures (Catalog *catalog, int Ncatalog, int final) {
    381385
    382   int i, j, k, m, N, Ndel, Nave, Nmax, image_bad, TOOFEW;
    383   int *ilist;
     386  off_t j, k, m, Nmax, Ndel, Nave;
     387  int i, N, image_bad, TOOFEW;
     388  off_t *ilist;
    384389  double *tlist, *list, *dlist, Ns;
    385390  float Msys, Mcal, Mmos, Mgrid;
    … …  
    396401  ALLOCATE (list, double, MAX (1, Nmax));
    397402  ALLOCATE (dlist, double, MAX (1, Nmax));
    398   ALLOCATE (ilist, int, Nmax);
     403  ALLOCATE (ilist, off_t, Nmax);
    399404  ALLOCATE (tlist, double, Nmax);
    400405 
    … …  
    480485  }
    481486  initstats (STATMODE);
    482   if (VERBOSE) fprintf (stderr, "%d measures marked poor, %d total\n", Ndel, Nave);
     487  if (VERBOSE) fprintf (stderr, "%lld measures marked poor, %lld total\n", (long long) Ndel, (long long) Nave);
    483488  free (ilist);
    484489  free (tlist);
    … …  
    487492StatType statsStarN (Catalog *catalog, int Ncatalog) {
    488493
    489   int i, j, k, m, n, N, Ntot;
     494  off_t j, k, m, Ntot;
     495  int i, n, N;
    490496  double *list, *dlist;
    491497  float Mcal, Mmos, Mgrid;
    … …  
    533539StatType statsStarX (Catalog *catalog, int Ncatalog) {
    534540
    535   int i, j, n, Ntot, Xm;
     541  off_t j, Ntot;
     542  int i, n, Xm;
    536543  double *list, *dlist;
    537544  StatType stats;
    … …  
    568575StatType statsStarS (Catalog *catalog, int Ncatalog) {
    569576
    570   int i, j, n, Ntot;
     577  int i, n;
     578  off_t j, Ntot;
    571579  double *list, *dlist;
    572580  float dM;
    … …  
    603611void plot_stars (Catalog *catalog, int Ncatalog) {
    604612
    605   int i, j, bin;
     613  int i, bin;
     614  off_t j;
    606615  float dMrel;
    607616  double *xlist, *Mlist;
    … …  
    634643void plot_chisq (Catalog *catalog, int Ncatalog) {
    635644
    636   int i, j, N, Ntotal, value;
     645  off_t j, Ntotal;
     646  int i, N, value;
    637647  double *xlist, *ylist;
    638648  Graphdata graphdata;
    … …  
    665675void plot_star_coords (Catalog *catalog, int Ncatalog) {
    666676
    667   int i, j, N;
     677  int i;
     678  off_t j, N;
    668679  double *xlist, *ylist;
    669680  double Xmin, Ymin, Xmax, Ymax;

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

    r21508 r27435  
    33int bcatalog (Catalog *subcatalog, Catalog *catalog) {
    44 
    5   int i, j, offset, ecode;
    6   int NAVERAGE, NMEASURE, Naverage, Nmeasure, Nm;
     5  off_t i, j, offset;
     6  int ecode;
     7  off_t NAVERAGE, NMEASURE, Naverage, Nmeasure, Nm;
    78  float mag;
    89
    … …  
    113114
    114115  if (VERBOSE) {
    115     fprintf (stderr, "%d: using %d stars (%d measures) for catalog\n", i,
    116              subcatalog[0].Naverage, subcatalog[0].Nmeasure);
     116    fprintf (stderr, "%lld: using %lld stars (%lld measures) for catalog\n", (long long) i,
     117             (long long) subcatalog[0].Naverage, (long long) subcatalog[0].Nmeasure);
    117118  }
    118119  return (TRUE);

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

    r25757 r27435  
    44
    55  Image     *image, *subset;
    6   int        Nimage, Nsubset, Nchar;
    7   int       *LineNumber;
     6  off_t      Nimage, Nsubset, Nchar;
     7  off_t     *LineNumber;
    88
    99  SkyTable *sky = NULL;
    … …  
    4040
    4141  Image     *image;
    42   int        Nimage, Nx, i;
     42  off_t     Nimage, Nx, i;
    4343  VTable    *vtable;
    4444
    … …  
    4747  vtable = &db[0].vtable;
    4848
    49   gfits_scan (vtable[0].header, "NAXIS1", "%d", 1, &Nx);
     49  gfits_scan (vtable[0].header, "NAXIS1", "%lld", 1, (long long *) &Nx);
    5050  for (i = 0; i < Nimage; i++) {
    5151    memcpy (vtable[0].buffer[i], &image[i], Nx);

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

    r21508 r27435  
    33void plot_scatter (Catalog *catalog, int Ncatalog) {
    44
    5   int i, j, k, m, N, Ntot;
     5  off_t i, j, k, m, N, Ntot;
    66  float Mrel, Mcal, Mmos, Mgrid;
    77  double *xlist, *ylist, *ilist;

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

    r25757 r27435  
    33int relphot_objects () {
    44
    5   int i, j, k, m;
     5  off_t i, j, k, m;
    66  int Nsecfilt;
    77

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

    r21508 r27435  
    1313} SkyRegionCoords;
    1414
    15 Image *select_images (SkyList *skylist, Image *timage, int Ntimage, int **LineNumber, int *Nimage) {
     15Image *select_images (SkyList *skylist, Image *timage, off_t Ntimage, off_t **LineNumber, off_t *Nimage) {
    1616 
    1717  Image *image;
    18   int i, j, k, m, found, nimage, NIMAGE;
    19   int InRange, ecode;
     18  off_t i, j, k, m;
     19  off_t *line_number, nimage, NIMAGE;
     20  int InRange, ecode, found;
    2021  double Ri[5], Di[5], Xi[5], Yi[5], dx, dy;
    21   int *line_number;
    2222  Coords tcoords;
    2323  SkyRegionCoords *skycoords;
    … …  
    7171  NIMAGE = 100;
    7272  ALLOCATE (image, Image, NIMAGE);
    73   ALLOCATE (line_number, int, NIMAGE);
     73  ALLOCATE (line_number, off_t, NIMAGE);
    7474 
    7575  // go through the complete list of images, selecting ones which overlap any region
    … …  
    146146        NIMAGE += 100;
    147147        REALLOCATE (image, Image, NIMAGE);
    148         REALLOCATE (line_number, int, NIMAGE);
     148        REALLOCATE (line_number, off_t, NIMAGE);
    149149      }
    150150    }
    151151  }
    152152     
    153   if (VERBOSE) fprintf (stderr, "found %d images\n", nimage);
     153  if (VERBOSE) fprintf (stderr, "found %lld images\n", (long long) nimage);
    154154
    155155  REALLOCATE (image, Image, MAX (nimage, 1));
    156   REALLOCATE (line_number, int, MAX (nimage, 1));
     156  REALLOCATE (line_number, off_t, MAX (nimage, 1));
    157157  free (skycoords);
    158158

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

    r16810 r27435  
    33int setExclusions (Catalog *catalog, int Ncatalog) {
    44
    5   int i, j, k, m, Narea, Nnocal, Ngood, ecode;
     5  off_t i, j, k, m, Narea, Nnocal, Ngood;
     6  int ecode;
    67  Coords *coords;
    78  double r, d, x, y;
    … …  
    4950    }
    5051  }
    51   if (VERBOSE) fprintf (stderr, "%d measurements marked by area\n", Narea);
    52   if (VERBOSE) fprintf (stderr, "%d measurements marked nocal\n", Nnocal);
    53   if (VERBOSE) fprintf (stderr, "%d measurements kept for analysis\n", Ngood);
     52  if (VERBOSE) fprintf (stderr, "%lld measurements marked by area\n",    (long long) Narea);
     53  if (VERBOSE) fprintf (stderr, "%lld measurements marked nocal\n",      (long long) Nnocal);
     54  if (VERBOSE) fprintf (stderr, "%lld measurements kept for analysis\n", (long long) Ngood);
    5455  return (TRUE);
    5556}

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

    r26154 r27435  
    33void setMrelFinal (Catalog *catalog) {
    44
    5   int i, j, m, ecode;
     5  off_t i, j, m;
     6  int ecode;
    67
    78  /* if we reset the catalog, reset all the current measurements */
    … …  
    3940
    4041  /* set catalog[0].found[i] = FALSE */
    41   ALLOCATE (catalog[0].found, int, MAX (1, catalog[0].Naverage));
     42  ALLOCATE (catalog[0].found, off_t, MAX (1, catalog[0].Naverage));
    4243  for (i = 0; i < catalog[0].Naverage; i++) {
    4344    catalog[0].found[i] = FALSE;
    … …  
    6667void skip_measurements (Catalog *catalog, int pass) {
    6768
    68   int i, k, m, ecode, d1, d2;
    69   int Ntot, Ntry, Nkeep, Nskip;
     69  off_t i, k, m;
     70  int ecode;
     71  off_t Ntot, Ntry, Nkeep, Nskip;
    7072  float mag;
    7173
    … …  
    136138    }
    137139  }
    138   if (VERBOSE) fprintf (stderr, "pass %d, Ntot: %d, Ntry: %d, Nskip: %d, Nkeep: %d\n",
    139                         pass, Ntot, Ntry, Nskip, Nkeep);
     140  if (VERBOSE) fprintf (stderr, "pass %d, Ntot: %lld, Ntry: %lld, Nskip: %lld, Nkeep: %lld\n",
     141                        pass, (long long) Ntot, (long long) Ntry, (long long) Nskip, (long long) Nkeep);
    140142}
    141143

  • trunk/Ohana/src/tools/src/ckfits.c

    r15487 r27435  
    44int main (int argc, char **argv) {
    55
    6   int i, Nbytes, nbytes, Ndata, Ntotal, nskip, status;
     6  off_t i, Nbytes, nbytes, Ndata, Ntotal, nskip;
     7  int status;
    78  Header header;
    89  FILE *f;
    … …  
    2627
    2728  nbytes = Ntotal - Ndata;
    28   nskip = Ndata + header.size;
     29  nskip = Ndata + header.datasize;
    2930
    3031  f = fopen (argv[1], "r");
    … …  
    3536
    3637  ALLOCATE (buffer, char, MAX (nbytes, 1));
    37   fseek (f, nskip, SEEK_SET);
     38  fseeko (f, nskip, SEEK_SET);
    3839  Nbytes = fread (buffer, 1, nbytes, f);
    3940  fclose (f);

  • trunk/Ohana/src/tools/src/fhead.c

    r12333 r27435  
    55
    66  int N, Extend, Nextend, status;
    7   int i, j, nbytes;
     7  int i, j;
     8  off_t nbytes;
    89  Header head;
    910  char *p;
    … …  
    2930    if (!status) continue;
    3031
    31     for (j = 79; j < head.size; j+= 80) {
     32    for (j = 79; j < head.datasize; j+= 80) {
    3233      head.buffer[j] = 10;
    3334    }

  • trunk/Ohana/src/tools/src/fields.c

    r24232 r27435  
    2222  Header header;
    2323  char filename[1000], *CCDKeyword, *Extname, extname[80];
    24   int N, Nbytes, Extnum, Nextend, status, GotFile, GotField, GotExtension;
    25 
     24  int N, Extnum, Nextend, status, GotFile, GotField, GotExtension;
     25  off_t Nbytes;
    2626  regex_t preg;
    2727
    … …  
    9797   
    9898        Nbytes = gfits_data_size (&header);
    99         fseek (f, Nbytes, SEEK_CUR);
     99        fseeko (f, Nbytes, SEEK_CUR);
    100100        Nextend ++;
    101101

  • trunk/Ohana/src/tools/src/fits_insert.c

    r21046 r27435  
    77int main (int argc, char **argv) {
    88
    9   int i, N, status, EXTNUM, Nbytes, skip, Delete, DeleteStart, DeleteStop;
    10   int Nreserved, start_size;
     9  off_t i, skip, Nbytes, start_size;
     10  int N, status, EXTNUM, Delete, DeleteStart, DeleteStop;
     11  int Nreserved;
    1112  char *p, keyword[16], line[256];
    1213  FILE *f;
    … …  
    6263      exit (1);
    6364  }
    64   start_size = header.size;
    65   skip = Nbytes - header.size;
     65  start_size = header.datasize;
     66  skip = Nbytes - header.datasize;
    6667
    6768  /* open header data file */
    … …  
    116117    /* check that the line does not already exist */
    117118    p = (char *) NULL;
    118     for (i = 0; (i < header.size) && (p == (char *) NULL) ; i+= FT_LINE_LENGTH) {
     119    for (i = 0; (i < header.datasize) && (p == (char *) NULL) ; i+= FT_LINE_LENGTH) {
    119120      if (!strncmp (&header.buffer[i], line, 80)) {
    120121        p = &header.buffer[i];
    … …  
    126127    p = (char *) NULL;
    127128    Nreserved = strlen (reserved);
    128     for (i = 0; (i < header.size) && (p == (char *) NULL) ; i+= FT_LINE_LENGTH) {
     129    for (i = 0; (i < header.datasize) && (p == (char *) NULL) ; i+= FT_LINE_LENGTH) {
    129130      if (!strncmp (&header.buffer[i], "END     ", 8)) break;
    130131      if (!strncmp (&header.buffer[i], reserved, Nreserved)) {
    … …  
    142143        exit (1);
    143144      }
    144       if (p - header.buffer + 80 == header.size) {
     145      if (p - header.buffer + 80 == header.datasize) {
    145146        fprintf (stderr, "no free space in block, can't insert keyword\n");
    146147        exit (1);
    … …  
    161162  */
    162163
    163   if (header.size != start_size) {
     164  if (header.datasize != start_size) {
    164165    fprintf (stderr, "header changed size: should not happen!\n");
    165166    exit (1);
    … …  
    172173  }
    173174
    174   fseek (f, skip, SEEK_SET);
    175   status = fwrite (header.buffer, 1, header.size, f);
    176   if (status != header.size) {
     175  fseeko (f, skip, SEEK_SET);
     176  status = fwrite (header.buffer, 1, header.datasize, f);
     177  if (status != header.datasize) {
    177178    fprintf (stderr, "failed to write data to image header\n");
    178179    exit (1);

  • trunk/Ohana/src/tools/src/ftable.c

    r26384 r27435  
    88void list_extnames (char *file);
    99void print_layout (Header *header);
    10 int   ByteSwap (char *ptr, int size, int nitems, char *type);
    1110int Binary;
    1211
    1312int main (int argc, char **argv) {
    1413
    15   int i, N, Nx, Ny, Nbytes, Nread;
    16   int Nextend, Column, Row, ListExtname, Layout;
     14  off_t i, Nx, Ny, Nbytes, Nread, Row;
     15  int N, Nextend, Column, ListExtname, Layout;
    1716  char *Extname, *Colname, *line, ttype[80];
    1817  FTable table;
    … …  
    9493    exit (1);
    9594  }
    96   table.size = Nbytes;
    97 
    98   gfits_scan (table.header, "NAXIS1",  "%d", 1, &Nx);
    99   gfits_scan (table.header, "NAXIS2",  "%d", 1, &Ny);
     95  table.datasize = Nbytes;
     96
     97  gfits_scan (table.header, "NAXIS1",  "%lld", 1, (long long *) &Nx);
     98  gfits_scan (table.header, "NAXIS2",  "%lld", 1, (long long *) &Ny);
    10099
    101100  /* print a column */
    … …  
    122121char *print_table_row (char *row, Header *header) {
    123122 
    124   int i, j, Nx, Nfields, Nbytes, Nvals, Oout, Oin;
     123  off_t Nx;
     124  int i, j, Nfields, Nbytes, Nvals, Oout, Oin;
    125125  char field[16], type[16], format[16], *line;
    126126
    127   gfits_scan (header, "NAXIS1",  "%d", 1, &Nx);
     127  gfits_scan (header, "NAXIS1",  "%lld", 1, (long long *) &Nx);
    128128  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    129129
    … …  
    160160
    161161  FILE *f;
    162   int i, Naxis, Nelem, Ncomp, extend, Nbytes, status;
     162  off_t Nbytes, Nelem;
     163  int i, Naxis, Ncomp, extend, status;
    163164  char extname[82], exttype[82], axisname[32];
    164165  Header header;
    … …  
    169170    exit (1);
    170171  }
    171 
    172   /*
    173      if (!gfits_fread_header (f, &header)) {
    174      fprintf (stderr, "can't read header from %s\n", file);
    175      exit (1);
    176      }
    177      Nbytes = gfits_data_size (&header);
    178      fseek (f, Nbytes, SEEK_CUR);
    179   */
    180172
    181173  fprintf (stdout, "%-30s %-15s NAXIS NAXIS(i)...\n", "extname", "datatype");
    … …  
    217209    for (i = 0; i < Naxis; i++) {
    218210      sprintf (axisname, "NAXIS%d", i+1);
    219       status = gfits_scan (&header, axisname,  "%d", 1, &Nelem);
     211      status = gfits_scan (&header, axisname,  "%lld", 1, (long long *) &Nelem);
    220212      if (!status) {
    221213        fprintf (stderr, "missing %s\n", axisname);
    222214      }
    223       fprintf (stdout, " %7d", Nelem);
     215      fprintf (stdout, " %7lld", (long long) Nelem);
    224216    }
    225217    fprintf (stdout, "\n");
    … …  
    228220    if (Ncomp == 0) {
    229221      extend = FALSE;
    230       gfits_scan (&header, "EXTEND", "%t", 1, &extend);
     222      gfits_scan_alt (&header, "EXTEND", "%t", 1, &extend);
    231223      if (!extend) {
    232224        fprintf (stderr, "no extensions listed in file\n");
    … …  
    235227
    236228    Nbytes = gfits_data_size (&header);
    237     fseek (f, Nbytes, SEEK_CUR);
     229    fseeko (f, Nbytes, SEEK_CUR);
    238230
    239231    Ncomp ++;
    … …  
    245237FILE *load_extension (char *file, int Nextend, char *Extname, Header *header) {
    246238
    247   int i, extend, Nbytes;
     239  off_t Nbytes;
     240  int i, extend;
    248241  char extname[82];
    249242  FILE *f;
    … …  
    264257  /* check for existence of extensions */
    265258  extend = FALSE;
    266   gfits_scan (header, "EXTEND", "%t", 1, &extend);
     259  gfits_scan_alt (header, "EXTEND", "%t", 1, &extend);
    267260  if (!extend) {
    268261    fprintf (stderr, "no extensions listed in file\n");
    … …  
    271264  /* skip first data array */
    272265  Nbytes = gfits_data_size (header);
    273   fseek (f, Nbytes, SEEK_CUR);
     266  fseeko (f, Nbytes, SEEK_CUR);
    274267
    275268  /* search for extension of interest */
    … …  
    281274
    282275    Nbytes = gfits_data_size (header);
    283     fseek (f, Nbytes, SEEK_CUR);
     276    fseeko (f, Nbytes, SEEK_CUR);
    284277    gfits_free_header (header);
    285278  }
    … …  
    292285void print_column (FTable *table, int Column, char *Colname) {
    293286 
    294   int i, j, Nfields, Nstart, Nv, Nb, Nx, Ny;
     287  off_t Nx, Ny;
     288  int i, j, Nfields, Nstart, Nv, Nb;
    295289  Header *header;
    296290  char format[16], field[16], type[16], *line, *data;
    … …  
    300294
    301295  gfits_scan (header, "TFIELDS", "%d", 1, &Nfields);
    302   gfits_scan (header, "NAXIS1",  "%d", 1, &Nx);
    303   gfits_scan (header, "NAXIS2",  "%d", 1, &Ny);
     296  gfits_scan (header, "NAXIS1",  "%lld", 1, (long long *) &Nx);
     297  gfits_scan (header, "NAXIS2",  "%lld", 1, (long long *) &Ny);
    304298
    305299  if (Colname != (char *) NULL) {
    … …  
    364358          if (!strcmp (type, "int64_t")) {
    365359            memcpy (line, &data[i*Nv*Nb + Nb*j], Nb);
    366             fprintf (stdout, "%d ", *(int64_t*)line);
     360            fprintf (stdout, "%lld ", (long long) *(int64_t*)line);
    367361          }
    368362          if (!strcmp (type, "float")) {
    … …  
    394388    sprintf (field, "TTYPE%d", i);
    395389    gfits_scan (header, field, "%s", 1, type);
    396     gfits_scan (header, field, "%C", 1, comment);
     390    gfits_scan_alt (header, field, "%C", 1, comment);
    397391    sprintf (field, "TFORM%d", i);
    398392    gfits_scan (header, field, "%s", 1, format);

  • trunk/Ohana/src/tools/src/mefhead.c

    r15487 r27435  
    55
    66  struct stat filestat;
    7   int NEXTEND, Nextend, Nmatrix, status;
     7  int NEXTEND, Nextend, status;
     8  off_t Nmatrix;
    89  Header header;
    910  FILE *f, *g;
    … …  
    4344  /* skip matrix */
    4445  Nmatrix = gfits_data_size (&header);
    45   fseek (g, Nmatrix, SEEK_CUR);
     46  fseeko (g, Nmatrix, SEEK_CUR);
    4647
    4748  /* write PHU */
    … …  
    6566    /* skip matrix */
    6667    Nmatrix = gfits_data_size (&header);
    67     fseek (g, Nmatrix, SEEK_CUR);
     68    fseeko (g, Nmatrix, SEEK_CUR);
    6869   
    6970    /* write header */

  • trunk/Ohana/src/tools/src/mktemp.c

    r25757 r27435  
    55# define FALSE 0
    66# define TRUE 1
     7
     8void usage(void);
    79
    810int main (int argc, char **argv) {
    … …  
    9597
    9698  if (make_directory) {
    97     if (mkdtemp (template) == -1) {
     99    if (mkdtemp (template) == NULL) {
    98100      if (!fail_silently) fprintf (stderr, "failed to make temp file from %s\n", template);
    99101      exit (1);
    … …  
    111113}
    112114 
    113 usage() {
     115void usage(void) {
    114116  fprintf (stderr, "Usage: mktemp [-V] | [-dqtu] [-p prefix] [template]\n");
    115117  exit (1);

  • trunk/Ohana/src/uniphot/include/uniphot.h

    r21153 r27435  
    9393void          wcatalog           PROTO((Catalog *catalog));
    9494void          wimages            PROTO((Image *image, int Nimage));
    95 void check_permissions (char *basefile);
    96 void lock_image_db (FITS_DB *db, char *filename);
    97 void unlock_image_db (FITS_DB *db);
    98 void create_image_db (FITS_DB *db);
    99 void set_db (FITS_DB *in);
    100 int Shutdown (char *format, ...);
    101 void TrapSignal (int sig);
    102 void SetProtect (int mode);
    103 int SetSignals (void);
    104 int subset_images (FITS_DB *db);
    105 void update (FITS_DB *db, Group *sgroup, int Nsgroup);
    106 void sort_time (unsigned int *value, int N);
     95void          check_permissions  PROTO((char *basefile));
     96void          lock_image_db      PROTO((FITS_DB *db, char *filename));
     97void          unlock_image_db    PROTO((FITS_DB *db));
     98void          create_image_db    PROTO((FITS_DB *db));
     99void          set_db             PROTO((FITS_DB *in));
     100int           Shutdown           PROTO((char *format, ...) OHANA_FORMAT(printf, 1, 2) );
     101void          TrapSignal         PROTO((int sig));
     102void          SetProtect         PROTO((int mode));
     103int           SetSignals         PROTO((void));
     104int           subset_images      PROTO((FITS_DB *db));
     105void          update             PROTO((FITS_DB *db, Group *sgroup, int Nsgroup));
     106void          sort_time          PROTO((unsigned int *value, int N));

  • trunk/Ohana/src/uniphot/src/find_image_sgroups.c

    r21508 r27435  
    33Group *find_image_sgroups (FITS_DB *db, ImageLink **Imlink, int *Nsgroup) {
    44
    5   int i, j, Nimage, Ngroup, Nentry, NENTRY;
     5  off_t i, Nimage;
     6  int j, Ngroup, Nentry, NENTRY;
    67  double r, d, x, y, radius;
    78  Group *group;

  • trunk/Ohana/src/uniphot/src/find_image_tgroups.c

    r21508 r27435  
    44
    55  char *start, *stop;
    6   int i, j, Nimage, Ngroup, NGROUP, Nentry, NENTRY;
     6  int j, Ngroup, NGROUP, Nentry, NENTRY;
     7  off_t i, Nimage;
    78  unsigned int *time, *tmin, *tmax;
    89  Group *group;

  • trunk/Ohana/src/uniphot/src/subset_images.c

    r21508 r27435  
    33int subset_images (FITS_DB *db) {
    44
    5   int    i, Nimage, equiv;
    6   int    Nkeep, *keep;
     5  off_t i, Nimage, Nkeep, *keep;
     6  int equiv;
    77  Image *image;
    88
    … …  
    1111
    1212  Nkeep = 0;
    13   ALLOCATE (keep, int, Nimage);
     13  ALLOCATE (keep, off_t, Nimage);
    1414
    1515  /* mark images to be calibrated */

  • trunk/Ohana/src/uniphot/src/update.c

    r21508 r27435  
    44void update (FITS_DB *db, Group *sgroup, int Nsgroup) {
    55
    6   int i, j, status, Nmin, Nimage;
     6  off_t i, Nimage;
     7  int j, status, Nmin;
    78  char line[256];
    89  glob_t pglob;
Note: See TracChangeset for help on using the changeset viewer.