IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Aug 5, 2004, 10:55:34 AM (22 years ago)
Author:
harman
Message:

Minor corrections from testing

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/astronomy/psMetadata.c

    r1393 r1394  
    1111*  @author Ross Harman, MHPCC
    1212*
    13 *  @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
    14 *  @date $Date: 2004-08-05 19:38:51 $
     13*  @version $Revision: 1.11 $ $Name: not supported by cvs2svn $
     14*  @date $Date: 2004-08-05 20:55:16 $
    1515*
    1616*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    3939/******************************************************************************/
    4040
    41 /** Maximum length of string */
    42 #define MAX_STRING_LENGTH 1024
    43 
    44 /** Maximum length of FITS line */
    45 #define FITS_LINE_SIZE 80
     41#define FITS_ERROR(STRING,PS_ERROR)                                                                          \
     42fits_get_errstatus(status, fitsErr);                                                                     \
     43psError( __func__, STRING, PS_ERROR, fitsErr);                                                           \
     44status = 0;                                                                                              \
     45if(fits_close_file(fd, &status) != 0) {                                                                  \
     46    fits_get_errstatus(status, fitsErr);                                                                 \
     47    psError( __func__, "FITS error while closing file: ", fitsErr);                                      \
     48}                                                                                                        \
     49return output;
    4650
    4751/******************************************************************************/
    … …  
    7276    type = metadataItem->type;
    7377
    74     if ( metadataItem == NULL ) {
     78    if(metadataItem == NULL) {
    7579        return ;
    7680    }
    … …  
    8084    psFree( metadataItem->items );
    8185
    82     if ( type == PS_META_STR ||
     86    if(type == PS_META_STR ||
    8387            type == PS_META_IMG ||
    8488            type == PS_META_JPEG ||
    8589            type == PS_META_PNG ||
    8690            type == PS_META_ASTROM ||
    87             type == PS_META_UNKNOWN ) {
     91            type == PS_META_UNKNOWN) {
    8892        psFree( metadataItem->data.V );
    8993    }
    … …  
    9296static void metadataFree( psMetadata *metadata )
    9397{
    94     if ( metadata == NULL ) {
     98    if(metadata == NULL) {
    9599        return ;
    96100    }
    … …  
    124128    psMetadataItem * metadataItem = NULL;
    125129
    126     if ( name == NULL ) {
     130    if(name == NULL) {
    127131        psError( __func__, "Null value for string not allowed" );
    128132        return NULL;
    … …  
    131135    // Allocate metadata item
    132136    metadataItem = ( psMetadataItem * ) psAlloc( sizeof( psMetadataItem ) );
    133     if ( metadataItem == NULL ) {
     137    if(metadataItem == NULL) {
    134138        psAbort( __func__, "Failed to allocate memory" );
    135139    }
    … …  
    140144    // Allocate and set metadata item comment
    141145    metadataItem->comment = ( char * ) psAlloc( sizeof( char ) * MAX_STRING_LENGTH );
    142     if ( comment == NULL ) {
     146    if(comment == NULL) {
    143147        // Per SDRS, null isn't allowed, must use "" instead
    144148        strncpy( metadataItem->comment, "", MAX_STRING_LENGTH );
    … …  
    154158
    155159    // Set metadata item value
    156     switch ( type ) {
     160    switch(type) {
    157161    case PS_META_BOOL:
    158162        metadataItem->data.B = ( bool ) va_arg( argPtr, int );
    … …  
    197201    // Allocate metadata
    198202    metadata = ( psMetadata * ) psAlloc( sizeof( psMetadata ) );
    199     if ( metadata == NULL ) {
     203    if(metadata == NULL) {
    200204        psAbort( __func__, "Failed to allocate metadata" );
    201205    }
    … …  
    206210    // Allocate metadata's internal containers
    207211    list = ( psList * ) psListAlloc( NULL );
    208     if ( list == NULL ) {
     212    if(list == NULL) {
    209213        psAbort( __func__, "Failed to allocate list" );
    210214    }
    211215
    212216    table = ( psHash * ) psHashAlloc( 10 );
    213     if ( table == NULL ) {
     217    if(table == NULL) {
    214218        psAbort( __func__, "Failed to allocate table" );
    215219    }
    … …  
    229233    psMetadataType type = PS_META_ITEM_SET;
    230234
    231     if ( md == NULL ) {
     235    if(md == NULL) {
    232236        psError( __func__, "Null metadata collection not allowed" );
    233237        return false;
    234238    }
    235239
    236     if ( metadataItem == NULL ) {
     240    if(metadataItem == NULL) {
    237241        psError( __func__, "Null metadata item not allowed" );
    238242        return false;
    … …  
    242246
    243247    mdTable = md->table;
    244     if ( mdTable == NULL ) {
     248    if(mdTable == NULL) {
    245249        psError( __func__, "Null metadata table not allowed" );
    246250        return false;
    … …  
    248252
    249253    mdList = md->list;
    250     if ( mdList == NULL ) {
     254    if(mdList == NULL) {
    251255        psError( __func__, "Null metadata list not allowed" );
    252256        return false;
    … …  
    254258
    255259    key = metadataItem->name;
    256     if ( key == NULL ) {
     260    if(key == NULL) {
    257261        psError( __func__, "Null key item not allowed" );
    258262        return false;
    … …  
    261265    // Check if key is already in table
    262266    value = ( psMetadataItem* ) psHashLookup( mdTable, key );
    263     if ( value != NULL && type != PS_META_ITEM_SET ) {
     267    if(value != NULL && type != PS_META_ITEM_SET) {
    264268
    265269        // The key was found and the new metadata item is a leaf node (its type isn't PS_META_ITEM_SET), so
    266270        // add the new metadata item to hash as a child of the existing metadata item folder node.
    267         if ( !psListAdd( value->items, metadataItem, where ) ) {
     271        if(!psListAdd( value->items, metadataItem, where )) {
    268272            psError( __func__, "Couldn't add metadata item to items list. Name: %s",
    269273                     metadataItem->name );
    270274            return false;
    271275        }
    272     } else if ( value != NULL ) {
     276    } else if(value != NULL) {
    273277
    274278        // The key was found and the new metadata item is a folder node. Don't add new metadata item, since
    … …  
    280284
    281285        // Duplicate key not found. Add new metadata item to metadata collection's hash
    282         if ( !psHashAdd( mdTable, key, metadataItem ) ) {
     286        if(!psHashAdd( mdTable, key, metadataItem )) {
    283287            psError( __func__, "Couldn't add metadata item to metadata collection table. Name: %s",
    284288                     metadataItem->name );
    … …  
    288292
    289293    // Add all items to metadata collection's list, even if they have the same metadata item names
    290     if ( !psListAdd( md->list, metadataItem, where ) ) {
     294    if(!psListAdd( md->list, metadataItem, where )) {
    291295        psError( __func__, "Couldn't add metadata item to metadata collection list. Name: %s",
    292296                 metadataItem->name );
    … …  
    307311    va_end( argPtr );
    308312
    309     if ( !psMetadataAddItem( md, where, metadataItem ) ) {
     313    if(!psMetadataAddItem( md, where, metadataItem )) {
    310314        psError( __func__, "Couldn't add metadata item to metadata collection list. Name: %s",
    311315                 metadataItem->name );
    … …  
    329333
    330334    mdList = md->list;
    331     if ( mdList == NULL ) {
     335    if(mdList == NULL) {
    332336        psError( __func__, "Null metadata list not allowed" );
    333337        return false;
    … …  
    335339
    336340    mdTable = md->table;
    337     if ( mdTable == NULL ) {
     341    if(mdTable == NULL) {
    338342        psError( __func__, "Null metadata table not allowed" );
    339343        return false;
    … …  
    341345
    342346    // Select removal by key or index
    343     if ( key != NULL ) {
     347    if(key != NULL) {
    344348
    345349        // Remove by key name
    346350        entry = ( psMetadataItem* ) psHashLookup( mdTable, key );
    347         if ( entry == NULL ) {
     351        if(entry == NULL) {
    348352            psError( __func__, "Couldn't find metadata item remove. Name: %s", key );
    349353            return false;
    … …  
    351355
    352356        numChildren = entry->items->size;
    353         if ( entry->type == PS_META_ITEM_SET && numChildren > 0 ) {
     357        if(entry->type == PS_META_ITEM_SET && numChildren > 0) {
    354358
    355359            // Table entry has children. Entry and children must be removed from metadata collection's list
    356360            psListSetIterator( mdList, PS_LIST_HEAD );
    357361            entryChild = psListGetCurrent( mdList );
    358             while ( entryChild != NULL ) {
    359                 if ( !psListRemove( entry->items, entryChild, PS_LIST_UNKNOWN ) ) {
     362            while(entryChild != NULL) {
     363                if(!psListRemove( entry->items, entryChild, PS_LIST_UNKNOWN )) {
    360364                    psError( __func__, "Couldn't remove metadata item from list. Name: %s", key );
    361365                    return false;
    … …  
    366370
    367371        // Remove entry from metadata collection's list
    368         if ( !psListRemove( mdList, entry, PS_LIST_UNKNOWN ) ) {
     372        if(!psListRemove( mdList, entry, PS_LIST_UNKNOWN )) {
    369373            psError( __func__, "Couldn't remove metadata item from list. Name: %s", key );
    370374            return false;
    … …  
    372376
    373377        // Remove entry from metadata collection's table
    374         if ( !psHashRemove( mdTable, key ) ) {
     378        if(!psHashRemove( mdTable, key )) {
    375379            psError( __func__, "Couldn't remove metadata item from table. Name: %s", key );
    376380            return false;
    … …  
    380384        // Remove by index
    381385        entry = psListGet( mdList, where );
    382         if ( entry == NULL ) {
     386        if(entry == NULL) {
    383387            psError( __func__, "Couldn't find metadata item from list. Index: %d", where );
    384388            return false;
    … …  
    386390
    387391        key = entry->name;
    388         if ( key == NULL ) {
     392        if(key == NULL) {
    389393            psError( __func__, "Null key name not allowed. Index: %d", where );
    390394            return false;
    … …  
    404408
    405409    mdTable = md->table;
    406     if ( mdTable == NULL ) {
     410    if(mdTable == NULL) {
    407411        psError( __func__, "Null metadata table not allowed" );
    408412        return NULL;
    409413    }
    410414
    411     if ( key == NULL ) {
     415    if(key == NULL) {
    412416        psError( __func__, "Null key name not allowed" );
    413417        return NULL;
    … …  
    415419
    416420    entry = ( psMetadataItem* ) psHashLookup( mdTable, key );
    417     if ( entry == NULL ) {
     421    if(entry == NULL) {
    418422        psError( __func__, "Could not find metadata item with given key. Key: %s", key );
    419423        return NULL;
    … …  
    429433
    430434    mdList = md->list;
    431     if ( mdList == NULL ) {
     435    if(mdList == NULL) {
    432436        psError( __func__, "Null metadata list not allowed" );
    433437        return NULL;
    … …  
    435439
    436440    entry = ( psMetadataItem* ) psListGet( mdList, where );
    437     if ( entry == NULL ) {
     441    if(entry == NULL) {
    438442        psError( __func__, "Couldn't find metadata item with given index. Index: %d", where );
    439443        return NULL;
    … …  
    448452
    449453    mdList = md->list;
    450     if ( mdList == NULL ) {
     454    if(mdList == NULL) {
    451455        psError( __func__, "Null metadata list not allowed" );
    452456        return false;
    … …  
    464468
    465469    mdList = md->list;
    466     if ( mdList == NULL ) {
    467         psError( __func__, "Null metadata list not allowed" );
    468         return NULL;
    469     }
    470 
    471     mdList = md->list;
    472     if ( mdList == NULL ) {
     470    if(mdList == NULL) {
     471        psError( __func__, "Null metadata list not allowed" );
     472        return NULL;
     473    }
     474
     475    mdList = md->list;
     476    if(mdList == NULL) {
    473477        psError( __func__, "Null metadata list not allowed" );
    474478        return NULL;
    … …  
    477481    psListSetIterator( mdList, which );
    478482    entry = psListGetCurrent( mdList );
    479     while ( entry != NULL ) {
    480         if ( !strncmp( match, entry->name, strlen( match ) ) ) {
     483    while(entry != NULL) {
     484        if(!strncmp( match, entry->name, strlen( match ) )) {
    481485
    482486            // Match found
    … …  
    487491
    488492    // Match not found
    489     if ( entry == NULL ) {
     493    if(entry == NULL) {
    490494        psError( __func__, "Couldn't find metadata item with given match. Match: %s", match );
    491495    }
    … …  
    500504
    501505    mdList = md->list;
    502     if ( mdList == NULL ) {
    503         psError( __func__, "Null metadata list not allowed" );
    504         return NULL;
    505     }
    506 
    507     mdList = md->list;
    508     if ( mdList == NULL ) {
     506    if(mdList == NULL) {
     507        psError( __func__, "Null metadata list not allowed" );
     508        return NULL;
     509    }
     510
     511    mdList = md->list;
     512    if(mdList == NULL) {
    509513        psError( __func__, "Null metadata list not allowed" );
    510514        return NULL;
    … …  
    513517    psListSetIterator( mdList, which );
    514518    entry = psListGetCurrent( mdList );
    515     while ( entry != NULL ) {
    516         if ( !strncmp( match, entry->name, strlen( match ) ) ) {
     519    while(entry != NULL) {
     520        if(!strncmp( match, entry->name, strlen( match ) )) {
    517521
    518522            // Match found
    … …  
    523527
    524528    // Match not found
    525     if ( entry == NULL ) {
     529    if(entry == NULL) {
    526530        psError( __func__, "Couldn't find metadata item with given match. Match: %s", match );
    527531    }
    … …  
    534538    psMetadataType type;
    535539
    536     if ( fd == NULL ) {
     540    if(fd == NULL) {
    537541        psError( __func__, "Null file descriptor not allowed" );
    538542        return ;
    539543    }
    540544
    541     if ( format == NULL ) {
     545    if(format == NULL) {
    542546        psError( __func__, "Null format not allowed" );
    543547        return ;
    544548    }
    545549
    546     if ( metadataItem == NULL ) {
     550    if(metadataItem == NULL) {
    547551        psError( __func__, "Null metadata not allowed" );
    548552        return ;
    … …  
    551555    type = metadataItem->type;
    552556
    553     switch ( type ) {
     557    switch(type) {
    554558    case PS_META_BOOL:
    555559        fprintf( fd, format, metadataItem->data.B );
    … …  
    578582}
    579583
    580 psMetadata *psMetadataFReadHeader( psMetadata *output, const char *extname, int extnum, fitsfile *fd )
     584psMetadata *psMetadataFReadHeader( psMetadata *output, char *extName, int extNum, fitsfile *fd )
    581585{
    582586    bool tempBool;
    … …  
    587591    char keyComment[ FITS_LINE_SIZE ];
    588592    char fitsErr[ MAX_STRING_LENGTH ];
    589     char* tempExtname = NULL;
    590593    int i;
    591594    int hduType = 0;
    … …  
    595598    psMetadataType metadataItemType;
    596599
    597     if ( fd == NULL ) {
     600    if(fd == NULL) {
    598601        psError( __func__, "Null FITS file descriptor not allowed" );
    599602        return NULL;
    600603    }
    601604
    602     if ( extname == NULL && extnum == 0 ) {
    603         psError( __func__, "Null extname AND extnum = 0 not allowed" );
    604         return NULL;
    605     } else if ( extname && extnum ) {
    606         psError( __func__, "Both extname AND extnum arguments should not have values." );
     605    if(extName == NULL && extNum == 0) {
     606        psError( __func__, "Null extName and extNum = 0 not allowed" );
     607        return NULL;
     608    } else if(extName && extNum) {
     609        psError( __func__, "Both extName and extNum arguments should not have non zero values." );
    607610        return NULL;
    608611    }
    609612
    610613    // Allocate metadata if user didn't
    611     if ( output == NULL ) {
     614    if(output == NULL) {
    612615        output = psMetadataAlloc();
    613616    }
    614617
    615618    // Move to user designated HDU number or HDU name in FITS file. HDU numbers starts at one.
    616     if ( extname == NULL ) {
    617         if ( fits_movabs_hdu( fd, extnum, &hduType, &status ) != 0 ) {
     619    if(extName != NULL) {
     620        if(fits_movnam_hdu( fd, ANY_HDU, extName, 0, &status ) != 0) {
     621            FITS_ERROR("FITS error while locating header %s: %s", extName);
     622        }
     623    } else {
     624        if(fits_movabs_hdu( fd, extNum, &hduType, &status ) != 0) {
     625            FITS_ERROR("FITS error while locating header %d: %s", extNum);
     626        }
     627    }
     628
     629    // Get number of key names
     630    if(fits_get_hdrpos( fd, &numKeys, &keyNum, &status ) != 0) {
     631        FITS_ERROR("FITS error while reading key %d: %s", keyNum);
     632    }
     633
     634    // Get each key name. Keywords start at one.
     635    for(i = 1; i <= numKeys; i++) {
     636        if(fits_read_keyn( fd, i, keyName, keyValue, keyComment, &status ) != 0) {
     637            FITS_ERROR("FITS error while reading key %d: %s", keyNum);
     638        }
     639        if(fits_get_keytype( keyValue, &keyType, &status ) != 0) {
    618640            fits_get_errstatus( status, fitsErr );
    619             psError( __func__, "FITS error while locating header: %s", fitsErr );
    620             status = 0;
    621             return output;
    622         }
    623     } else if ( extnum > 0 ) {
    624         tempExtname = ( char* ) extname;
    625         if ( fits_movnam_hdu( fd, ANY_HDU, tempExtname, 0, &status ) != 0 ) {
    626             fits_get_errstatus( status, fitsErr );
    627             psError( __func__, "FITS error while locating header: %s", fitsErr );
    628             status = 0;
    629             return output;
    630         }
    631     }
    632 
    633     // Get number of key names
    634     if ( fits_get_hdrpos( fd, &numKeys, &keyNum, &status ) != 0 ) {
    635         fits_get_errstatus( status, fitsErr );
    636         psError( __func__, "FITS error while reading keys: %s", fitsErr );
    637         status = 0;
    638         return output;
    639     }
    640 
    641     // Get each key name. Keywords start at one.
    642     for ( i = 1; i <= numKeys; i++ ) {
    643         if ( fits_read_keyn( fd, i, keyName, keyValue, keyComment, &status ) != 0 ) {
    644             fits_get_errstatus( status, fitsErr );
    645             psError( __func__, "FITS error while reading key number %d: %s", i, fitsErr );
    646             status = 0;
    647             return output;
    648         }
    649         if ( fits_get_keytype( keyValue, &keyType, &status ) != 0 ) {
    650             fits_get_errstatus( status, fitsErr );
    651             if ( status != VALUE_UNDEFINED ) {
    652                 psError( __func__, "FITS error while determining key type: %s", fitsErr );
    653                 status = 0;
    654                 return output;
     641            if(status != VALUE_UNDEFINED) {
     642                FITS_ERROR("FITS error while determining key %d type: %s", keyNum);
    655643            } else {
    656                 // Some keywords are still valid even though they don't have a type or value, like COMMENTS
     644                // Some keywords are still valid even though they don't have a type, like COMMENTS and HISTORY
    657645                keyType = 'C';
    658646                status = 0;
    … …  
    660648        }
    661649
    662         switch ( keyType ) {
     650        switch(keyType) {
    663651        case 'I':
    664652            metadataItemType = PS_META_S32;
    665             success = psMetadataAdd( output, PS_LIST_HEAD, keyName, metadataItemType, keyComment, atoi( keyValue ) );
     653            success = psMetadataAdd( output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, atoi( keyValue ) );
    666654            break;
    667655        case 'F':
    668656            metadataItemType = PS_META_F64;
    669             success = psMetadataAdd( output, PS_LIST_HEAD, keyName, metadataItemType, keyComment, atof( keyValue ) );
     657            success = psMetadataAdd( output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, atof( keyValue ) );
    670658            break;
    671659        case 'C':
    672660            metadataItemType = PS_META_STR;
    673             success = psMetadataAdd( output, PS_LIST_HEAD, keyName, metadataItemType, keyComment, keyValue );
     661            success = psMetadataAdd( output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, keyValue );
    674662            break;
    675663        case 'L':
    676664            metadataItemType = PS_META_BOOL;
    677665            tempBool = ( keyValue[ 0 ] == 'T' ) ? 1 : 0;
    678             success = psMetadataAdd( output, PS_LIST_HEAD, keyName, metadataItemType, keyComment, tempBool );
     666            success = psMetadataAdd( output, PS_LIST_TAIL, keyName, metadataItemType, keyComment, tempBool );
    679667            break;
    680668        case 'U':
    … …  
    685673        }
    686674
    687         if ( !success ) {
     675        if(!success) {
    688676            psError( __func__, "Failed to add metadata item. Name: %s", keyName );
     677            return output;
    689678        }
    690679    }
Note: See TracChangeset for help on using the changeset viewer.