IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 9741


Ignore:
Timestamp:
Oct 24, 2006, 2:29:31 PM (20 years ago)
Author:
Paul Price
Message:

Changed definition of psArrayAlloc

Location:
trunk/icd-demo/src
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/icd-demo/src/icd-demo.c

    r9127 r9741  
    1111
    1212    if (argc != 3) {
    13         fprintf (stderr, "USAGE: icd-demo (input) (output)\n");
    14         exit (2);
     13        fprintf (stderr, "USAGE: icd-demo (input) (output)\n");
     14        exit (2);
    1515    }
    1616
     
    3838    while ((item = psListGetAndIncrement (iter)) != NULL) {
    3939        char *file = item->data.V;
    40         parseFile (fits, file);
     40        parseFile (fits, file);
    4141    }
    4242    psFitsClose (fits);
     
    5858    psMetadata *blank  = psMetadataLookupPtr (NULL, fd, "BLANK");
    5959    if (blank) {
    60         fprintf (stderr, "adding BLANK\n");
    61         psFitsWriteBlank (fits, blank, "");
     60        fprintf (stderr, "adding BLANK\n");
     61        psFitsWriteBlank (fits, blank, "");
    6262    }
    6363
    6464    psMetadata *fitstable  = psMetadataLookupPtr (NULL, fd, "FITSTABLE");
    6565    if (fitstable) {
    66         fprintf (stderr, "adding TABLE\n");
    67         psMetadata *header  = psMetadataLookupPtr (NULL, fitstable, "HEADER");
    68         psMetadata *columns = psMetadataLookupPtr (NULL, fitstable, "COLUMNS");
    69         psMetadataIterator *iter = psMetadataIteratorAlloc (columns, PS_LIST_HEAD, NULL);
    70         char *extname       = psMetadataLookupStr (NULL, header, "EXTNAME");
    71 
    72         psArray *table = psArrayAlloc (10);
    73 
    74         // XXX insert unit values: we need a method to do this in psFitsWriteTable
    75         int nCol = 1;
    76         while ((col = psMetadataGetAndIncrement (iter)) != NULL) {
    77             psMetadata *md = col->data.V;
    78             char *unit = psMetadataLookupStr (NULL, md, "TUNIT");
    79             if (strcasecmp (unit, "NONE")) {
    80                 sprintf (unitWord, "TUNIT%d", nCol);
    81                 psMetadataAddStr (header, PS_LIST_TAIL, unitWord, 0, "", unit);
    82             }
    83             nCol ++;
    84         }
    85         psMetadataIteratorSet (iter, PS_LIST_HEAD);
    86 
    87         // make a total of NN fake data columns
    88         for (int i = 0; i < 10; i++) {
    89        
    90             int nCol = 1;
    91 
    92             psMetadata *row = psMetadataAlloc ();
    93 
    94             while ((col = psMetadataGetAndIncrement (iter)) != NULL) {
    95 
    96                 psMetadata *md = col->data.V;
    97 
    98                 char *format = psMetadataLookupStr (NULL, md, "TFORM");
    99                 char *comment = psMetadataLookupStr (NULL, md, "COMMENT");
    100                 char *unit = psMetadataLookupStr (NULL, md, "TUNIT");
    101                 if (strcasecmp (unit, "NONE")) {
    102                     sprintf (unitWord, "TUNIT%d", nCol);
    103                     psMetadataAddStr (header, PS_LIST_TAIL, unitWord, 0, "", unit);
    104                 }
    105 
    106                 if (!strcasecmp (format, "I")) {
    107                     int value;
    108 
    109                     char *minWord = psMetadataLookupStr (NULL, md, "TMIN");
    110                     char *maxWord = psMetadataLookupStr (NULL, md, "TMAX");
    111 
    112                     min = atoi (minWord);
    113                     if (!strcasecmp (minWord, "NONE")) min = 0;
    114                     max = atoi (maxWord);
    115                     if (!strcasecmp (maxWord, "NONE")) max = 100;
    116                     range = max - min;
    117 
    118                     rvalue = psRandomUniform (rnd);
    119                     value = range * rvalue + min;
    120 
    121                     psMetadataAdd (row, PS_LIST_TAIL, col->name, PS_DATA_S16, comment, value);
    122                 }
    123 
    124                 if (!strcasecmp (format, "J")) {
    125                     int value;
    126 
    127                     char *minWord = psMetadataLookupStr (NULL, md, "TMIN");
    128                     char *maxWord = psMetadataLookupStr (NULL, md, "TMAX");
    129 
    130                     min = atoi (minWord);
    131                     if (!strcasecmp (minWord, "NONE")) min = 0;
    132                     max = atoi (maxWord);
    133                     if (!strcasecmp (maxWord, "NONE")) max = 100;
    134                     range = max - min;
    135 
    136                     rvalue = psRandomUniform (rnd);
    137                     value = range * rvalue + min;
    138 
    139                     psMetadataAdd (row, PS_LIST_TAIL, col->name, PS_DATA_S32, comment, value);
    140                 }
    141 
    142                 if (!strcasecmp (format, "K")) {
    143                     long int value;
    144 
    145                     char *minWord = psMetadataLookupStr (NULL, md, "TMIN");
    146                     char *maxWord = psMetadataLookupStr (NULL, md, "TMAX");
    147 
    148                     min = atoi (minWord);
    149                     if (!strcasecmp (minWord, "NONE")) min = 0;
    150                     max = atoi (maxWord);
    151                     if (!strcasecmp (maxWord, "NONE")) max = 100;
    152                     range = max - min;
    153 
    154                     rvalue = psRandomUniform (rnd);
    155                     value = range * rvalue + min;
    156 
    157                     psMetadataAdd (row, PS_LIST_TAIL, col->name, PS_DATA_S64, comment, value);
    158                 }
    159 
    160                 if (!strcasecmp (format, "E")) {
    161                     float value;
    162 
    163                     char *minWord = psMetadataLookupStr (NULL, md, "TMIN");
    164                     char *maxWord = psMetadataLookupStr (NULL, md, "TMAX");
    165 
    166                     min = atoi (minWord);
    167                     if (!strcasecmp (minWord, "NONE")) min = 0;
    168                     max = atoi (maxWord);
    169                     if (!strcasecmp (maxWord, "NONE")) max = 100;
    170                     range = max - min;
    171 
    172                     rvalue = psRandomUniform (rnd);
    173                     value = range * rvalue + min;
    174 
    175                     psMetadataAdd (row, PS_LIST_TAIL, col->name, PS_DATA_F32, comment, value);
    176                 }
    177 
    178                 if (!strcasecmp (format, "D")) {
    179                     double value;
    180 
    181                     char *minWord = psMetadataLookupStr (NULL, md, "TMIN");
    182                     char *maxWord = psMetadataLookupStr (NULL, md, "TMAX");
    183 
    184                     min = atoi (minWord);
    185                     if (!strcasecmp (minWord, "NONE")) min = 0;
    186                     max = atoi (maxWord);
    187                     if (!strcasecmp (maxWord, "NONE")) max = 100;
    188                     range = max - min;
    189 
    190                     rvalue = psRandomUniform (rnd);
    191                     value = range * rvalue + min;
    192 
    193                     psMetadataAdd (row, PS_LIST_TAIL, col->name, PS_DATA_F64, comment, value);
    194                 }
    195 
    196                 if (!strcasecmp (format, "A")) {
    197                     char *value = NULL;
    198                     psStringAppend (&value, "word %03d", i);
    199                     psMetadataAdd (row, PS_LIST_TAIL, col->name, PS_DATA_STRING, "", value);
    200                 }
    201             }
    202             psArrayAdd (table, 100, row);
    203             psFree (row);
    204             psMetadataIteratorSet (iter, PS_LIST_HEAD);
    205         }
    206         psFitsInsertTable (fits, header, table, extname, true);
     66        fprintf (stderr, "adding TABLE\n");
     67        psMetadata *header  = psMetadataLookupPtr (NULL, fitstable, "HEADER");
     68        psMetadata *columns = psMetadataLookupPtr (NULL, fitstable, "COLUMNS");
     69        psMetadataIterator *iter = psMetadataIteratorAlloc (columns, PS_LIST_HEAD, NULL);
     70        char *extname       = psMetadataLookupStr (NULL, header, "EXTNAME");
     71
     72        psArray *table = psArrayAllocEmpty (10);
     73
     74        // XXX insert unit values: we need a method to do this in psFitsWriteTable
     75        int nCol = 1;
     76        while ((col = psMetadataGetAndIncrement (iter)) != NULL) {
     77            psMetadata *md = col->data.V;
     78            char *unit = psMetadataLookupStr (NULL, md, "TUNIT");
     79            if (strcasecmp (unit, "NONE")) {
     80                sprintf (unitWord, "TUNIT%d", nCol);
     81                psMetadataAddStr (header, PS_LIST_TAIL, unitWord, 0, "", unit);
     82            }
     83            nCol ++;
     84        }
     85        psMetadataIteratorSet (iter, PS_LIST_HEAD);
     86
     87        // make a total of NN fake data columns
     88        for (int i = 0; i < 10; i++) {
     89
     90            int nCol = 1;
     91
     92            psMetadata *row = psMetadataAlloc ();
     93
     94            while ((col = psMetadataGetAndIncrement (iter)) != NULL) {
     95
     96                psMetadata *md = col->data.V;
     97
     98                char *format = psMetadataLookupStr (NULL, md, "TFORM");
     99                char *comment = psMetadataLookupStr (NULL, md, "COMMENT");
     100                char *unit = psMetadataLookupStr (NULL, md, "TUNIT");
     101                if (strcasecmp (unit, "NONE")) {
     102                    sprintf (unitWord, "TUNIT%d", nCol);
     103                    psMetadataAddStr (header, PS_LIST_TAIL, unitWord, 0, "", unit);
     104                }
     105
     106                if (!strcasecmp (format, "I")) {
     107                    int value;
     108
     109                    char *minWord = psMetadataLookupStr (NULL, md, "TMIN");
     110                    char *maxWord = psMetadataLookupStr (NULL, md, "TMAX");
     111
     112                    min = atoi (minWord);
     113                    if (!strcasecmp (minWord, "NONE")) min = 0;
     114                    max = atoi (maxWord);
     115                    if (!strcasecmp (maxWord, "NONE")) max = 100;
     116                    range = max - min;
     117
     118                    rvalue = psRandomUniform (rnd);
     119                    value = range * rvalue + min;
     120
     121                    psMetadataAdd (row, PS_LIST_TAIL, col->name, PS_DATA_S16, comment, value);
     122                }
     123
     124                if (!strcasecmp (format, "J")) {
     125                    int value;
     126
     127                    char *minWord = psMetadataLookupStr (NULL, md, "TMIN");
     128                    char *maxWord = psMetadataLookupStr (NULL, md, "TMAX");
     129
     130                    min = atoi (minWord);
     131                    if (!strcasecmp (minWord, "NONE")) min = 0;
     132                    max = atoi (maxWord);
     133                    if (!strcasecmp (maxWord, "NONE")) max = 100;
     134                    range = max - min;
     135
     136                    rvalue = psRandomUniform (rnd);
     137                    value = range * rvalue + min;
     138
     139                    psMetadataAdd (row, PS_LIST_TAIL, col->name, PS_DATA_S32, comment, value);
     140                }
     141
     142                if (!strcasecmp (format, "K")) {
     143                    long int value;
     144
     145                    char *minWord = psMetadataLookupStr (NULL, md, "TMIN");
     146                    char *maxWord = psMetadataLookupStr (NULL, md, "TMAX");
     147
     148                    min = atoi (minWord);
     149                    if (!strcasecmp (minWord, "NONE")) min = 0;
     150                    max = atoi (maxWord);
     151                    if (!strcasecmp (maxWord, "NONE")) max = 100;
     152                    range = max - min;
     153
     154                    rvalue = psRandomUniform (rnd);
     155                    value = range * rvalue + min;
     156
     157                    psMetadataAdd (row, PS_LIST_TAIL, col->name, PS_DATA_S64, comment, value);
     158                }
     159
     160                if (!strcasecmp (format, "E")) {
     161                    float value;
     162
     163                    char *minWord = psMetadataLookupStr (NULL, md, "TMIN");
     164                    char *maxWord = psMetadataLookupStr (NULL, md, "TMAX");
     165
     166                    min = atoi (minWord);
     167                    if (!strcasecmp (minWord, "NONE")) min = 0;
     168                    max = atoi (maxWord);
     169                    if (!strcasecmp (maxWord, "NONE")) max = 100;
     170                    range = max - min;
     171
     172                    rvalue = psRandomUniform (rnd);
     173                    value = range * rvalue + min;
     174
     175                    psMetadataAdd (row, PS_LIST_TAIL, col->name, PS_DATA_F32, comment, value);
     176                }
     177
     178                if (!strcasecmp (format, "D")) {
     179                    double value;
     180
     181                    char *minWord = psMetadataLookupStr (NULL, md, "TMIN");
     182                    char *maxWord = psMetadataLookupStr (NULL, md, "TMAX");
     183
     184                    min = atoi (minWord);
     185                    if (!strcasecmp (minWord, "NONE")) min = 0;
     186                    max = atoi (maxWord);
     187                    if (!strcasecmp (maxWord, "NONE")) max = 100;
     188                    range = max - min;
     189
     190                    rvalue = psRandomUniform (rnd);
     191                    value = range * rvalue + min;
     192
     193                    psMetadataAdd (row, PS_LIST_TAIL, col->name, PS_DATA_F64, comment, value);
     194                }
     195
     196                if (!strcasecmp (format, "A")) {
     197                    char *value = NULL;
     198                    psStringAppend (&value, "word %03d", i);
     199                    psMetadataAdd (row, PS_LIST_TAIL, col->name, PS_DATA_STRING, "", value);
     200                }
     201            }
     202            psArrayAdd (table, 100, row);
     203            psFree (row);
     204            psMetadataIteratorSet (iter, PS_LIST_HEAD);
     205        }
     206        psFitsInsertTable (fits, header, table, extname, true);
    207207    }
    208208    return 1;
  • trunk/icd-demo/src/icd-test.c

    r9127 r9741  
    77
    88    if (argc != 3) {
    9         fprintf (stderr, "USAGE: icd-demo (input) (output)\n");
    10         exit (2);
     9        fprintf (stderr, "USAGE: icd-demo (input) (output)\n");
     10        exit (2);
    1111    }
    1212
     
    1515
    1616    {
    17         psMetadata *header  = psMetadataAlloc ();
    18         psMetadataAddStr (header, PS_LIST_HEAD, "EXTID", 0, "", "blank");
    19         psFitsWriteBlank (fits, header, "blank");
     17        psMetadata *header  = psMetadataAlloc ();
     18        psMetadataAddStr (header, PS_LIST_HEAD, "EXTID", 0, "", "blank");
     19        psFitsWriteBlank (fits, header, "blank");
    2020    }
    2121
    2222    {
    23         psMetadata *header  = psMetadataAlloc ();
    24         psMetadataAddStr (header, PS_LIST_HEAD, "EXTID", 0, "", "blank1");
    25         psFitsWriteBlank (fits, header, "blank1");
     23        psMetadata *header  = psMetadataAlloc ();
     24        psMetadataAddStr (header, PS_LIST_HEAD, "EXTID", 0, "", "blank1");
     25        psFitsWriteBlank (fits, header, "blank1");
    2626    }
    2727
    2828    {
    29         psMetadata *header  = psMetadataAlloc ();
    30         psMetadataAddStr (header, PS_LIST_HEAD, "EXTID", 0, "", "table1");
     29        psMetadata *header  = psMetadataAlloc ();
     30        psMetadataAddStr (header, PS_LIST_HEAD, "EXTID", 0, "", "table1");
    3131
    32         psArray *table = psArrayAlloc (100);
    33         for (int i = 0; i < 10; i++) {
    34        
    35             psMetadata *row = psMetadataAlloc ();
    36             psMetadataAdd (row, PS_LIST_TAIL, "N", PS_DATA_S16, "", i);
    37             psMetadataAdd (row, PS_LIST_TAIL, "F", PS_DATA_F32, "", i*0.2);
    38             psMetadataAdd (row, PS_LIST_TAIL, "G", PS_DATA_F32, "", i*0.5);
    39             psArrayAdd (table, 100, row);
    40             psFree (row);
    41         }
     32        psArray *table = psArrayAllocEmpty (100);
     33        for (int i = 0; i < 10; i++) {
    4234
    43         psFitsInsertTable (fits, header, table, "table1", true);
     35            psMetadata *row = psMetadataAlloc ();
     36            psMetadataAdd (row, PS_LIST_TAIL, "N", PS_DATA_S16, "", i);
     37            psMetadataAdd (row, PS_LIST_TAIL, "F", PS_DATA_F32, "", i*0.2);
     38            psMetadataAdd (row, PS_LIST_TAIL, "G", PS_DATA_F32, "", i*0.5);
     39            psArrayAdd (table, 100, row);
     40            psFree (row);
     41        }
     42
     43        psFitsInsertTable (fits, header, table, "table1", true);
    4444    }
    4545
    4646    {
    47         psMetadata *header  = psMetadataAlloc ();
    48         psMetadataAddStr (header, PS_LIST_HEAD, "EXTID", 0, "", "blank2");
    49         psFitsWriteBlank (fits, header, "blank2");
     47        psMetadata *header  = psMetadataAlloc ();
     48        psMetadataAddStr (header, PS_LIST_HEAD, "EXTID", 0, "", "blank2");
     49        psFitsWriteBlank (fits, header, "blank2");
    5050    }
    5151
    5252    {
    53         psMetadata *header  = psMetadataAlloc ();
    54         psMetadataAddStr (header, PS_LIST_HEAD, "EXTID", 0, "", "table2");
     53        psMetadata *header  = psMetadataAlloc ();
     54        psMetadataAddStr (header, PS_LIST_HEAD, "EXTID", 0, "", "table2");
    5555
    56         psArray *table = psArrayAlloc (100);
    57         for (int i = 0; i < 10; i++) {
    58        
    59             psMetadata *row = psMetadataAlloc ();
    60             psMetadataAdd (row, PS_LIST_TAIL, "N", PS_DATA_S16, "", i);
    61             psMetadataAdd (row, PS_LIST_TAIL, "F", PS_DATA_F32, "", i*0.2);
    62             psMetadataAdd (row, PS_LIST_TAIL, "G", PS_DATA_F32, "", i*0.5);
    63             psArrayAdd (table, 100, row);
    64             psFree (row);
    65         }
     56        psArray *table = psArrayAllocEmpty (100);
     57        for (int i = 0; i < 10; i++) {
    6658
    67         psFitsInsertTable (fits, header, table, "table2", true);
     59            psMetadata *row = psMetadataAlloc ();
     60            psMetadataAdd (row, PS_LIST_TAIL, "N", PS_DATA_S16, "", i);
     61            psMetadataAdd (row, PS_LIST_TAIL, "F", PS_DATA_F32, "", i*0.2);
     62            psMetadataAdd (row, PS_LIST_TAIL, "G", PS_DATA_F32, "", i*0.5);
     63            psArrayAdd (table, 100, row);
     64            psFree (row);
     65        }
     66
     67        psFitsInsertTable (fits, header, table, "table2", true);
    6868    }
    6969
Note: See TracChangeset for help on using the changeset viewer.