IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Mar 27, 2006, 4:16:26 PM (20 years ago)
Author:
magnier
Message:

added HDU weights, masks; substantial work on the pmFPAfile,view concepts

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/rel10_ifa/psModules/src/astrom/pmFPAfile.c

    r6573 r6713  
    1616        return;
    1717
    18     psFree (file->fits);
     18    psFree (file->fpa);
     19    psFree (file->names);
     20
     21    psFitsClose (file->fits);
     22
    1923    psFree (file->filerule);
    2024    psFree (file->filextra);
    2125    psFree (file->extrule);
    2226    psFree (file->extxtra);
    23     psFree (file->filename);
    24     psFree (file->extname);
     27
     28    // these are just views:
     29    // psFree (file->filename);
     30    // psFree (file->extname);
     31    // psFree (file->phu);
     32    // psFree (file->header);
     33
    2534    return;
    2635}
    … …  
    3241    psMemSetDeallocator (file, (psFreeFunc) pmFPAfileFree);
    3342
     43    file->phu = NULL;
     44    file->header = NULL;
     45
     46    file->fpa = NULL;
    3447    file->fits = NULL;
     48    file->names = psMetadataAlloc();
     49
    3550    file->filerule = NULL;
    3651    file->filextra = NULL;
    3752    file->extrule  = NULL;
    3853    file->extxtra  = NULL;
     54
    3955    file->filename = NULL;
    4056    file->extname  = NULL;
     57
     58    file->type = PM_FPA_FILE_NONE;
     59    file->mode = PM_FPA_MODE_NONE;
     60    file->state = PM_FPA_STATE_CLOSED;
     61
    4162    return (file);
    4263}
    4364
    4465// XXX is a file allowed to be both READ and WRITE?
    45 pmFPAfile *pmFPAfileDefine (psMetadata *files, psMetadata *camera, pmFPA *fpa, char *name)
     66pmFPAfile *pmFPAfileDefine (psMetadata *files, psMetadata *format, pmFPA *fpa, char *name)
    4667{
    4768
    4869    bool status;
    4970    char *depth;
    50 
    51     // select the name from the camera config data
    52     psMetadata *data = psMetadataLookupPtr (&status, camera, name);
     71    char *type;
     72
     73    // select the FILERULES from the camera format
     74    psMetadata *filerules = psMetadataLookupPtr (&status, format, "FILERULES");
     75    if (filerules == NULL) {
     76        psErrorStackPrint(stderr, "Can't find FILERULES in the FORMAT configuration!\n");
     77        return NULL;
     78    }
     79
     80    // select the name from the FILERULES
     81    // check for indirect name (type == STR, name is aliased name)
     82    char *realname = psMetadataLookupStr (&status, filerules, name);
     83    if (realname == NULL)
     84        realname = name;
     85
     86    psMetadata *data = psMetadataLookupPtr (&status, filerules, realname);
    5387    if (data == NULL) {
     88        psErrorStackPrint(stderr, "Can't find file concept %s!\n", name);
    5489        return NULL;
    5590    }
    5691
    5792    pmFPAfile *file = pmFPAfileAlloc ();
    58     file->filerule = psMetadataLookupStr (&status, data, "FILENAME.RULE");
    59     file->filextra = psMetadataLookupStr (&status, data, "FILENAME.XTRA");
    60     file->extrule  = psMetadataLookupStr (&status, data, "EXTNAME.RULE");
    61     file->extxtra  = psMetadataLookupStr (&status, data, "EXTNAME.XTRA");
    62 
    63     file->openDepth = PM_FPA_DEPTH_NONE;
    64     depth = psMetadataLookupStr (&status, data, "OPEN.DEPTH");
     93    file->filerule = psMemIncrRefCounter(psMetadataLookupStr (&status, data, "FILENAME.RULE"));
     94    file->filextra = psMemIncrRefCounter(psMetadataLookupStr (&status, data, "FILENAME.XTRA"));
     95    file->extrule  = psMemIncrRefCounter(psMetadataLookupStr (&status, data, "EXTNAME.RULE"));
     96    file->extxtra  = psMemIncrRefCounter(psMetadataLookupStr (&status, data, "EXTNAME.XTRA"));
     97
     98    file->fileDepth = PM_FPA_DEPTH_NONE;
     99    depth = psMetadataLookupStr (&status, data, "FILE.DEPTH");
    65100    if (depth != NULL) {
    66101        if (!strcasecmp (depth, "FPA"))     {
    67             file->openDepth = PM_FPA_DEPTH_FPA;
     102            file->fileDepth = PM_FPA_DEPTH_FPA;
    68103        }
    69104        if (!strcasecmp (depth, "CHIP"))    {
    70             file->openDepth = PM_FPA_DEPTH_CHIP;
     105            file->fileDepth = PM_FPA_DEPTH_CHIP;
    71106        }
    72107        if (!strcasecmp (depth, "CELL"))    {
    73             file->openDepth = PM_FPA_DEPTH_CELL;
     108            file->fileDepth = PM_FPA_DEPTH_CELL;
    74109        }
    75110        if (!strcasecmp (depth, "READOUT")) {
    76             file->openDepth = PM_FPA_DEPTH_READOUT;
    77         }
    78     }
    79 
    80     file->readDepth = PM_FPA_DEPTH_NONE;
    81     depth = psMetadataLookupStr (&status, data, "READ.DEPTH");
     111            file->fileDepth = PM_FPA_DEPTH_READOUT;
     112        }
     113    }
     114    if (file->fileDepth == PM_FPA_DEPTH_NONE) {
     115        psLogMsg (__func__, 3, "warning: FILE.DEPTH is not set for %s\n", name);
     116    }
     117
     118    file->dataDepth = PM_FPA_DEPTH_NONE;
     119    depth = psMetadataLookupStr (&status, data, "DATA.DEPTH");
    82120    if (depth != NULL) {
    83121        if (!strcasecmp (depth, "FPA"))     {
    84             file->readDepth = PM_FPA_DEPTH_FPA;
     122            file->dataDepth = PM_FPA_DEPTH_FPA;
    85123        }
    86124        if (!strcasecmp (depth, "CHIP"))    {
    87             file->readDepth = PM_FPA_DEPTH_CHIP;
     125            file->dataDepth = PM_FPA_DEPTH_CHIP;
    88126        }
    89127        if (!strcasecmp (depth, "CELL"))    {
    90             file->readDepth = PM_FPA_DEPTH_CELL;
     128            file->dataDepth = PM_FPA_DEPTH_CELL;
    91129        }
    92130        if (!strcasecmp (depth, "READOUT")) {
    93             file->readDepth = PM_FPA_DEPTH_READOUT;
    94         }
    95     }
    96 
    97     file->writeDepth = PM_FPA_DEPTH_NONE;
    98     depth = psMetadataLookupStr (&status, data, "WRITE.DEPTH");
    99     if (depth != NULL) {
    100         if (!strcasecmp (depth, "FPA"))     {
    101             file->writeDepth = PM_FPA_DEPTH_FPA;
    102         }
    103         if (!strcasecmp (depth, "CHIP"))    {
    104             file->writeDepth = PM_FPA_DEPTH_CHIP;
    105         }
    106         if (!strcasecmp (depth, "CELL"))    {
    107             file->writeDepth = PM_FPA_DEPTH_CELL;
    108         }
    109         if (!strcasecmp (depth, "READOUT")) {
    110             file->writeDepth = PM_FPA_DEPTH_READOUT;
    111         }
    112     }
    113 
    114     if ((file->readDepth != PM_FPA_DEPTH_NONE) && (file->writeDepth != PM_FPA_DEPTH_NONE)) {
    115         psLogMsg (__func__, 3, "warning: file %s is set to both read and write; write is ignored\n", name);
    116         file->writeDepth = PM_FPA_DEPTH_NONE;
    117     }
    118 
    119     if (fpa == NULL) {
    120         fpa = pmFPAConstruct (camera);
    121     }
    122     file->fpa = fpa;
    123 
    124     psMetadataAddPtr (files, PS_LIST_TAIL, name, PS_META_REPLACE, "", file);
     131            file->dataDepth = PM_FPA_DEPTH_READOUT;
     132        }
     133    }
     134    if (file->dataDepth == PM_FPA_DEPTH_NONE) {
     135        psLogMsg (__func__, 3, "warning: DATA.DEPTH is not set for %s\n", name);
     136    }
     137
     138    file->type = PM_FPA_FILE_NONE;
     139    type = psMetadataLookupStr (&status, data, "FILE.TYPE");
     140    if (type != NULL) {
     141        if (!strcasecmp (type, "SX"))     {
     142            file->type = PM_FPA_FILE_SX;
     143        }
     144        if (!strcasecmp (type, "OBJ"))     {
     145            file->type = PM_FPA_FILE_OBJ;
     146        }
     147        if (!strcasecmp (type, "CMP"))     {
     148            file->type = PM_FPA_FILE_CMP;
     149        }
     150        if (!strcasecmp (type, "CMF"))     {
     151            file->type = PM_FPA_FILE_CMF;
     152        }
     153        if (!strcasecmp (type, "RAW"))     {
     154            file->type = PM_FPA_FILE_RAW;
     155        }
     156        if (!strcasecmp (type, "IMAGE"))     {
     157            file->type = PM_FPA_FILE_IMAGE;
     158        }
     159    }
     160    if (file->type == PM_FPA_FILE_NONE) {
     161        psLogMsg (__func__, 3, "warning: FILE.TYPE is not defined for %s\n", name);
     162    }
     163
     164    file->mode = PM_FPA_MODE_NONE;
     165    type = psMetadataLookupStr (&status, data, "FILE.MODE");
     166    if (type != NULL) {
     167        if (!strcasecmp (type, "READ"))     {
     168            file->mode = PM_FPA_MODE_READ;
     169        }
     170        if (!strcasecmp (type, "WRITE"))     {
     171            file->mode = PM_FPA_MODE_WRITE;
     172        }
     173    }
     174    if (file->mode == PM_FPA_MODE_NONE) {
     175        psLogMsg (__func__, 3, "warning: FILE.MODE is not defined for %s\n", name);
     176    }
     177
     178    file->fpa = psMemIncrRefCounter(fpa);
     179
     180    psMetadataAddPtr (files, PS_LIST_TAIL, name, PS_DATA_UNKNOWN, "", file);
     181
     182    // we free this copy of file, but 'files' still has a copy
     183    psFree (file);
     184
     185    // the returned value is a view into the version on 'files'
    125186    return (file);
    126187}
    127188
     189pmFPAfile *pmFPAfileConstruct (psMetadata *files, psMetadata *format, psMetadata *camera, char *name)
     190{
     191    pmFPA *fpa = pmFPAConstruct (camera);
     192    pmFPAfile *file = pmFPAfileDefine (files, format, fpa, name);
     193    psFree (fpa);
     194    return file;
     195}
     196
     197// open file (if not already opened XXX : better tracking of open state?
    128198bool pmFPAfileOpen (pmFPAfile *file, pmFPAview *view)
    129199{
    … …  
    131201    bool status;
    132202    char *extra;
    133 
    134     // is current depth == open depth?
    135     pmFPAdepth depth = pmFPAviewDepth (view);
    136     if (file->openDepth != depth) {
    137         return false;
     203    char *mode;
     204    char *readMode = "r";
     205    char *writeMode = "w";
     206
     207    if (file->mode == PM_FPA_MODE_NONE) {
     208        return false;
     209    }
     210    if (file->mode == PM_FPA_MODE_READ) {
     211        mode = readMode;
     212    }
     213    if (file->mode == PM_FPA_MODE_WRITE) {
     214        mode = writeMode;
     215    }
     216
     217    if (file->state == PM_FPA_STATE_OPEN) {
     218        return true;
    138219    }
    139220
    140221    // determine the file name
    141     file->filename = pmFPAviewNameFromRule (file->filerule, view, file->fpa);
     222    // XXX file->filename needs to be a copy, and freed in places like this...
     223    file->filename = pmFPAfileNameFromRule (file->filerule, file, view);
     224    if (file->filename == NULL)
     225        return false;
    142226
    143227    // indirect filenames
    144228    if (!strcasecmp (file->filename, "@FPAIO")) {
    145         extra = pmFPAviewNameFromRule (file->filextra, view, file->fpa);
     229        extra = pmFPAfileNameFromRule (file->filextra, file, view);
    146230        file->filename = psMetadataLookupStr (&status, file->names, extra);
     231        if (file->filename == NULL)
     232            return false;
    147233    }
    148234    if (!strcasecmp (file->filename, "@DETDB")) {
    149         extra = pmFPAviewNameFromRule (file->filextra, view, file->fpa);
     235        extra = pmFPAfileNameFromRule (file->filextra, file, view);
    150236        // file->filename = pmDetrendSelect (extra);
    151     }
    152 
    153     if (file->readDepth != PM_FPA_DEPTH_NONE) {
    154         file->fits = psFitsOpen (file->filename, "r");
    155     } else if (file->writeDepth != PM_FPA_DEPTH_NONE) {
    156         file->fits = psFitsOpen (file->filename, "w");
     237        if (file->filename == NULL)
     238            return false;
     239    }
     240
     241    switch (file->type) {
     242        // open the FITS types:
     243    case PM_FPA_FILE_IMAGE:
     244    case PM_FPA_FILE_CMF:
     245        file->fits = psFitsOpen (file->filename, mode);
     246        psTrace ("pmFPAfile", 5, "opening %s (type: %d)\n", file->filename, file->type);
     247        file->state = PM_FPA_STATE_OPEN;
     248        break;
     249
     250        // defer opening TEXT types:
     251    case PM_FPA_FILE_SX:
     252    case PM_FPA_FILE_OBJ:
     253    case PM_FPA_FILE_CMP:
     254    case PM_FPA_FILE_RAW:
     255        psTrace ("pmFPAfile", 5, "not opening %s (type: %d)\n", file->filename, file->type);
     256        break;
     257
     258    default:
     259        fprintf (stderr, "warning: type mismatch for %s : %d\n", file->filename, file->type);
     260        return false;
    157261    }
    158262    return true;
    … …  
    161265bool pmFPAfileRead (pmFPAfile *file, pmFPAview *view)
    162266{
    163 
    164     // is current depth == open depth?
     267    if (file->mode != PM_FPA_MODE_READ)
     268        return false;
     269
     270    // get the current depth
    165271    pmFPAdepth depth = pmFPAviewDepth (view);
    166     if (file->readDepth != depth) {
    167         return false;
    168     }
    169 
    170     if (file->readDepth == PM_FPA_DEPTH_NONE) {
    171         return false;
    172     }
     272
     273    // do we need to open this file?
     274    if (depth == file->fileDepth) {
     275        pmFPAfileOpen (file, view);
     276    }
     277
     278    // do we need to read this file?
     279    if (depth != file->dataDepth)
     280        return false;
    173281
    174282    switch (file->type) {
    175283    case PM_FPA_FILE_IMAGE:
    176         pmFPAviewReadFitsImage (view, file);
     284        if (pmFPAviewReadFitsImage (view, file)) {
     285            psTrace ("pmFPAfile", 5, "reading %s (type: %d)\n", file->filename, file->type);
     286        } else {
     287            psTrace ("pmFPAfile", 5, "skipping %s (type: %d)\n", file->filename, file->type);
     288        }
    177289        break;
    178290
    179291    case PM_FPA_FILE_SX:
     292    case PM_FPA_FILE_RAW:
    180293    case PM_FPA_FILE_OBJ:
    181294    case PM_FPA_FILE_CMP:
    182295    case PM_FPA_FILE_CMF:
    183296        pmFPAviewReadObjects (view, file);
     297        psTrace ("pmFPAfile", 5, "reading %s (type: %d)\n", file->filename, file->type);
    184298        break;
    185299
    … …  
    193307bool pmFPAfileWrite (pmFPAfile *file, pmFPAview *view)
    194308{
    195 
    196     // is current depth == open depth?
     309    if (file->mode != PM_FPA_MODE_WRITE)
     310        return false;
     311
     312    // get the current depth
    197313    pmFPAdepth depth = pmFPAviewDepth (view);
    198     if (file->writeDepth != depth) {
    199         return false;
    200     }
    201 
    202     if (file->writeDepth == PM_FPA_DEPTH_NONE) {
    203         return false;
     314
     315    // do we need to write this file?
     316    if (depth != file->dataDepth)
     317        return false;
     318
     319    // do we need to open this file?
     320    if (depth >= file->fileDepth) {
     321        pmFPAfileOpen (file, view);
    204322    }
    205323
    … …  
    212330
    213331    case PM_FPA_FILE_SX:
     332    case PM_FPA_FILE_RAW:
    214333    case PM_FPA_FILE_OBJ:
    215334    case PM_FPA_FILE_CMP:
    216335    case PM_FPA_FILE_CMF:
    217336        pmFPAviewWriteObjects (view, file);
     337        psTrace ("pmFPAfile", 5, "wrote %s (type: %d)\n", file->filename, file->type);
    218338        break;
    219339
    … …  
    227347bool pmFPAfileClose (pmFPAfile *file, pmFPAview *view)
    228348{
     349    if (file->state == PM_FPA_STATE_CLOSED) {
     350        return true;
     351    }
     352
    229353    // is current depth == open depth?
    230354    pmFPAdepth depth = pmFPAviewDepth (view);
    231     if (file->openDepth != depth) {
     355    if (file->fileDepth != depth) {
    232356        return false;
    233357    }
    234358
    235359    // check if we are actually open
    236     psFitsClose (file->fits);
    237     return true;
    238 }
    239 
    240 // attempt open and read for all pmFPAfiles in view->IO
    241 bool pmFPAfileReadChecks (psMetadata *files, pmFPAview *view)
     360    switch (file->type) {
     361        // check the FITS types
     362    case PM_FPA_FILE_IMAGE:
     363    case PM_FPA_FILE_CMF:
     364        psFitsClose (file->fits);
     365        psTrace ("pmFPAfile", 5, "closing %s (type: %d)\n", file->filename, file->type);
     366        file->fits = NULL;
     367        file->phu = NULL;
     368        file->header = NULL;
     369        file->state = PM_FPA_STATE_CLOSED;
     370        break;
     371
     372        // ignore the TEXT types
     373    case PM_FPA_FILE_SX:
     374    case PM_FPA_FILE_RAW:
     375    case PM_FPA_FILE_OBJ:
     376    case PM_FPA_FILE_CMP:
     377        break;
     378
     379    default:
     380        fprintf (stderr, "warning: type mismatch\n");
     381        return false;
     382    }
     383    return true;
     384}
     385
     386// attempt open, read, write, or close pmFPAfiles in files
     387bool pmFPAfileIOChecks (psMetadata *files, pmFPAview *view, pmFPAfilePlace place)
    242388{
    243389    // recipe override values (command-line options):
    … …  
    247393        pmFPAfile *file = item->data.V;
    248394
    249         pmFPAfileOpen (file, view);
    250         pmFPAfileRead (file, view);
     395        if (place == PM_FPA_BEFORE) {
     396            pmFPAfileRead (file, view);
     397        } else {
     398            pmFPAfileWrite (file, view);
     399            pmFPAfileClose (file, view);
     400        }
    251401    }
    252402    psFree (iter);
    … …  
    254404}
    255405
    256 // attempt open and read for all pmFPAfiles in view->IO
    257 bool pmFPAfileWriteChecks (psMetadata *files, pmFPAview *view)
    258 {
    259     // recipe override values (command-line options):
    260     psMetadataItem *item = NULL;
    261     psMetadataIterator *iter = psMetadataIteratorAlloc (files, PS_LIST_HEAD, NULL);
    262     while ((item = psMetadataGetAndIncrement (iter)) != NULL) {
    263         pmFPAfile *file = item->data.V;
    264 
    265         pmFPAfileWrite (file, view);
    266         pmFPAfileClose (file, view);
    267     }
    268     psFree (iter);
    269     return true;
     406// select the rule from the camera configuration, perform substitutions as needed
     407char *pmFPAfileNameFromRule (char *rule, pmFPAfile *file, pmFPAview *view)
     408{
     409
     410    char *newName = NULL;     // destination for resulting name
     411
     412    newName = psStringCopy (rule);
     413
     414    if (strstr (newName, "{CHIP.NAME}") != NULL) {
     415        pmChip *chip = pmFPAviewThisChip (view, file->fpa);
     416        if (chip != NULL) {
     417            char *name = psMetadataLookupStr (NULL, chip->concepts, "CHIP.NAME");
     418            if (name != NULL) {
     419                newName = psStringSubstitute (newName, name, "{CHIP.NAME}");
     420            }
     421        }
     422    }
     423    if (strstr (newName, "{CELL.NAME}") != NULL) {
     424        pmCell *cell = pmFPAviewThisCell (view, file->fpa);
     425        if (cell != NULL) {
     426            char *name = psMetadataLookupStr (NULL, cell->concepts, "CELL.NAME");
     427            if (name != NULL) {
     428                newName = psStringSubstitute (newName, name, "{CELL.NAME}");
     429            }
     430        }
     431    }
     432    if (strstr (newName, "{EXTNAME}") != NULL) {
     433        pmHDU *hdu = pmFPAviewThisHDU (view, file->fpa);
     434        if (hdu->extname != NULL) {
     435            newName = psStringSubstitute (newName, hdu->extname, "{EXTNAME}");
     436        }
     437    }
     438    if (strstr (newName, "{OUTPUT}") != NULL) {
     439        char *name = psMetadataLookupStr (NULL, file->names, "OUTPUT");
     440        if (name != NULL) {
     441            newName = psStringSubstitute (newName, name, "{OUTPUT}");
     442        }
     443    }
     444    return newName;
    270445}
    271446
    … …  
    299474}
    300475
    301 # if (0)
    302     // return the named pmFPAfile
    303     pmFPAfile *pmFPAfileSelect (pmFPAview *view, char *name)
    304 {
    305 
    306     // select the name from the camera config data
    307     pmFPAfile *file = psMetadataLookupPtr (&status, view->IO, name);
    308     if (file == NULL) {
    309         return NULL;
    310     }
    311     return file;
    312 }
    313 
    314 bool pmFPAfileWriteChecks (pmFPAview *view, char *name)
    315 {
    316 
    317     pmFPAfile *file = pmFPAfileSelect (view, name);
    318     pmFPAfileWrite (file, view);
    319     return true;
    320 }
    321 #endif
    322 
    323476// given an already-opened fits file, read the components corresponding
    324477// to the specified view
    325478bool pmFPAviewReadFitsImage (pmFPAview *view, pmFPAfile *file)
    326479{
     480    bool status;
    327481    pmFPA *fpa = file->fpa;
    328482    psFits *fits = file->fits;
    329483
    330484    if (view->chip == -1) {
    331         pmFPARead (fpa, fits, NULL);
    332         return true;
     485        status = pmFPARead (fpa, fits, NULL);
     486        return status;
    333487    }
    334488
    … …  
    339493
    340494    if (view->cell == -1) {
    341         pmChipRead (chip, fits, NULL);
    342         return true;
     495        status = pmChipRead (chip, fits, NULL);
     496        return status;
    343497    }
    344498
    … …  
    349503
    350504    if (view->readout == -1) {
    351         pmCellRead (cell, fits, NULL);
    352         return true;
     505        status = pmCellRead (cell, fits, NULL);
     506        return status;
    353507    }
    354508
Note: See TracChangeset for help on using the changeset viewer.