IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 5164


Ignore:
Timestamp:
Sep 27, 2005, 4:38:01 PM (21 years ago)
Author:
desonia
Message:

added support for writing psVectors to tables.

Location:
trunk/psLib
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/fits/psFits.c

    r5149 r5164  
    77 *  @author Robert DeSonia, MHPCC
    88 *
    9  *  @version $Revision: 1.48 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2005-09-27 19:55:32 $
     9 *  @version $Revision: 1.49 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2005-09-28 02:37:58 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2424#include "psLogMsg.h"
    2525#include "psTrace.h"
     26#include "psVector.h"
    2627
    2728#define MAX_STRING_LENGTH 256  // maximum length string for FITS routines
    … …  
    165166}
    166167
    167 static bool convertMetadataTypeToBinaryTForm(psDataType type, char** fitsType)
     168static char getTForm(int type)
    168169{
    169170    switch (type) {
    170     case PS_DATA_BOOL:
    171         *fitsType = psStringCopy("1L");
    172         break;
    173     case PS_DATA_S32:
    174         *fitsType = psStringCopy("1J");
    175         break;
    176     case PS_DATA_F32:
    177         *fitsType = psStringCopy("1E");
    178         break;
    179     case PS_DATA_F64:
    180         *fitsType = psStringCopy("1D");
    181         break;
     171    case PS_TYPE_U8:
     172    case PS_TYPE_S8:
     173        return 'B';
     174    case PS_TYPE_S16:
     175        return 'I';
     176    case PS_TYPE_S32:
     177        return 'J';
     178    case PS_TYPE_U64:
     179    case PS_TYPE_S64:
     180        return 'K';
     181    case PS_TYPE_U16:
     182        return 'U';
     183    case PS_TYPE_U32:
     184        return 'V';
     185    case PS_TYPE_F32:
     186        return 'E';
     187    case PS_TYPE_F64:
     188        return 'D';
     189    case PS_TYPE_C32:
     190        return 'C';
     191    case PS_TYPE_C64:
     192        return 'M';
     193    case PS_TYPE_BOOL:
     194        return 'L';
    182195    case PS_DATA_STRING:
    183         *fitsType = psStringCopy("A");
    184         break;
    185         // XXX: Handle other types, e.g., Vectors, etc.
     196        return 'A';
     197    default:
     198        return '?';
     199    }
     200}
     201
     202
     203static bool getMetadataTForm(psMetadataItem* item, char** fitsType, int repeat)
     204{
     205    if (item == NULL) {
     206        return false;
     207    }
     208
     209    *fitsType = NULL;
     210    char tform = getTForm(item->type);
     211
     212    switch (item->type) {
     213    case PS_TYPE_U8:
     214    case PS_TYPE_S8:
     215    case PS_TYPE_S16:
     216    case PS_TYPE_S32:
     217    case PS_TYPE_U64:
     218    case PS_TYPE_S64:
     219    case PS_TYPE_U16:
     220    case PS_TYPE_U32:
     221    case PS_TYPE_F32:
     222    case PS_TYPE_F64:
     223    case PS_TYPE_C32:
     224    case PS_TYPE_C64:
     225    case PS_TYPE_BOOL:
     226        psStringAppend(fitsType, "%d%c",repeat,tform);
     227        break;
     228
     229    case PS_DATA_STRING:
     230        psStringAppend(fitsType,"%dA",
     231                       strlen(item->data.V)*repeat);
     232        break;
     233
     234    case PS_DATA_VECTOR: {
     235            psVector* vec = item->data.V;
     236            tform = getTForm(vec->type.type);
     237            psStringAppend(fitsType,"%d%c",repeat*vec->n,tform);
     238        }
     239        break;
     240
    186241    default:
    187242        return false;
    … …  
    15031558                                   PS_LIST_HEAD,true);
    15041559            while ( (item=psListGetAndIncrement(iter)) != NULL) {
    1505                 if (PS_DATA_IS_PRIMITIVE(item->type) || item->type == PS_DATA_STRING) {
     1560                if (PS_DATA_IS_PRIMITIVE(item->type) ||
     1561                        item->type == PS_DATA_STRING ||
     1562                        item->type == PS_DATA_VECTOR) {
    15061563                    bool found = false;
    15071564                    psMetadataItem* fItem = NULL;
    … …  
    15221579                        columns->data[n] = psMemIncrRefCounter(item);
    15231580
     1581                    } else if (item->type == PS_DATA_VECTOR &&
     1582                               ((psVector*)(fItem->data.V))->n < ((psVector*)(item->data.V))->n) {
     1583                        psMemDecrRefCounter(fItem);
     1584                        columns->data[n] = psMemIncrRefCounter(item);
    15241585                    }
    1525 
    15261586                }
    15271587            }
    … …  
    15411601        char* fitsType;
    15421602        columnNames->data[n] = psMemIncrRefCounter(((psMetadataItem*)columns->data[n])->name);
    1543         if ( ! convertMetadataTypeToBinaryTForm(((psMetadataItem*)columns->data[n])->type,
    1544                                                 &fitsType)) {
     1603        if ( ! getMetadataTForm((psMetadataItem*)columns->data[n],
     1604                                &fitsType,1) ) {
    15451605            // XXX: error message
    15461606            return false;
    1547         }
    1548         if (fitsType[strlen(fitsType)-1] == 'A') {
    1549             // string type -- append length to the type.
    1550             psStringPrepend(&fitsType,"%d",strlen(((psMetadataItem*)columns->data[n])->data.V));
    15511607        }
    15521608        columnTypes->data[n] = fitsType;
    … …  
    15781634        int row;
    15791635        item = columns->data[n];
    1580         psVector* col = NULL;
    1581         psArray* colArray = NULL;
    1582         switch (item->type) {
    1583         case PS_DATA_S32:
    1584             col = psVectorAlloc(table->n, PS_TYPE_S32);
     1636        if (PS_DATA_IS_PRIMITIVE(item->type) ) {
     1637            psVector* col = psVectorAlloc(table->n, item->type);
     1638            int dataSize = PSELEMTYPE_SIZEOF(item->type);
     1639            int dataType;
     1640            convertPsTypeToFits(item->type, NULL,NULL,&dataType);
    15851641            for (row = 0; row < table->n; row++) {
    1586                 col->data.S32[row] = psMetadataLookupS32(NULL,
    1587                                      table->data[row],
    1588                                      item->name);
     1642                psMetadataItem* dataItem = psMetadataLookup(
     1643                                               table->data[row],
     1644                                               item->name);
     1645                memcpy(&col->data.U8[row*dataSize],&dataItem->data,dataSize);
    15891646            }
    1590             fits_write_col_int(fits->fd,
    1591                                n+1, // column number
    1592                                1, // firstrow
    1593                                1, // firstelem
    1594                                table->n, // nelements
    1595                                col->data.S32,
    1596                                &status);
    1597             break;
    1598 
    1599         case PS_DATA_F32:
    1600             col = psVectorAlloc(table->n, PS_TYPE_F32);
    1601             for (row = 0; row < table->n; row++) {
    1602                 col->data.F32[row] = psMetadataLookupF32(NULL,
    1603                                      table->data[row],
    1604                                      item->name);
    1605             }
    1606             fits_write_col_flt(fits->fd,
    1607                                n+1, // column number
    1608                                1, // firstrow
    1609                                1, // firstelem
    1610                                table->n, // nelements
    1611                                col->data.F32,
    1612                                &status);
    1613             break;
    1614 
    1615         case PS_DATA_F64:
    1616             col = psVectorAlloc(table->n, PS_TYPE_F64);
    1617             for (row = 0; row < table->n; row++) {
    1618                 col->data.F64[row] = psMetadataLookupF64(NULL,
    1619                                      table->data[row],
    1620                                      item->name);
    1621             }
    1622             fits_write_col_dbl(fits->fd,
    1623                                n+1, // column number
    1624                                1, // firstrow
    1625                                1, // firstelem
    1626                                table->n, // nelements
    1627                                col->data.F64,
    1628                                &status);
    1629             break;
    1630 
    1631         case PS_DATA_BOOL:
    1632             col = psVectorAlloc(table->n, PS_TYPE_BOOL);
    1633             for (row = 0; row < table->n; row++) {
    1634                 col->data.S8[row] = psMetadataLookupBool(NULL,
    1635                                     table->data[row],
    1636                                     item->name);
    1637             }
    1638             fits_write_col_log(fits->fd,
    1639                                n+1, // column number
    1640                                1, // firstrow
    1641                                1, // firstelem
    1642                                table->n, // nelements
    1643                                (char*)col->data.S8,
    1644                                &status);
    1645             break;
    1646 
    1647         case PS_DATA_STRING:
    1648             colArray = psArrayAlloc(table->n);
     1647            fits_write_col(fits->fd,
     1648                           dataType,
     1649                           n+1, // column number
     1650                           1, // firstrow
     1651                           1, // firstelem
     1652                           table->n, // nelements
     1653                           col->data.U8,
     1654                           &status);
     1655            psFree(col);
     1656        } else if (item->type == PS_DATA_STRING) {
     1657            psArray* colArray = psArrayAlloc(table->n);
    16491658            for (row = 0; row < table->n; row++) {
    16501659                colArray->data[row] = psMemIncrRefCounter(
    … …  
    16611670                               &status);
    16621671            psFree(colArray);
    1663             break;
    1664 
    1665         default:
    1666             // XXX: error message?
    1667             break;
    1668         }
    1669         psFree(col);
     1672        } else if (item->type == PS_DATA_VECTOR) {
     1673            psVector* vec = (psVector*)(item->data.V);
     1674            psVector* col = psVectorAlloc(table->n*vec->n, vec->type.type);
     1675            int dataSize = PSELEMTYPE_SIZEOF(vec->type.type)*vec->n;
     1676            int dataType;
     1677            convertPsTypeToFits(vec->type.type, NULL,NULL,&dataType);
     1678            for (row = 0; row < table->n; row++) {
     1679                psMetadataItem* dataItem = psMetadataLookup(
     1680                                               table->data[row],
     1681                                               item->name);
     1682                memcpy(&col->data.U8[row*dataSize],
     1683                       ((psVector*)(dataItem->data.V))->data.U8,
     1684                       dataSize);
     1685            }
     1686            fits_write_col(fits->fd,
     1687                           dataType,
     1688                           n+1, // column number
     1689                           1, // firstrow
     1690                           1, // firstelem
     1691                           table->n*vec->n, // nelements
     1692                           col->data.U8,
     1693                           &status);
     1694            psFree(col);
     1695        }
    16701696        if (status != 0) {
    16711697            char fitsErr[MAX_STRING_LENGTH];

  • trunk/psLib/test/fits/tst_psFits.c

    r5147 r5164  
    66*  @author Robert DeSonia, MHPCC
    77*
    8 *  @version $Revision: 1.9 $ $Name: not supported by cvs2svn $
    9 *  @date $Date: 2005-09-27 19:54:52 $
     8*  @version $Revision: 1.10 $ $Name: not supported by cvs2svn $
     9*  @date $Date: 2005-09-28 02:38:01 $
    1010*
    1111*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    201201                      str);
    202202        psFree(str);
     203
     204        psVector* vec = psVectorAlloc(5,PS_TYPE_S32);
     205        for (int x=0; x < 5; x++) {
     206            vec->data.S32[x] = x*2;
     207        }
     208        psMetadataAdd(header,PS_LIST_TAIL, "MYVEC",
     209                      PS_DATA_VECTOR,
     210                      "psVector Item",
     211                      vec);
     212        psFree(vec);
    203213
    204214        table->data[row] = header;
Note: See TracChangeset for help on using the changeset viewer.