IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Nov 4, 2021, 6:10:51 PM (5 years ago)
Author:
eugene
Message:

merge changes from eam_branches/ipp-dev-20210817 (fix chebyshevs 1D, 2D, set DB field to NULL for inf, psFitsTableNew)

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r33030 r41896  
    137137
    138138    return table;
     139}
     140
     141psFitsTable *psFitsTableCreate (psArray *tableColumns, int numRows) {
     142
     143    psFitsTable *table = psFitsTableAlloc (tableColumns->n, numRows);
     144
     145    // now define the table colums
     146    for (int i = 0; i < tableColumns->n; i++) {
     147        psFitsTableColumn *column = &table->columns[i];
     148
     149        psFitsTableColumn *myColumn = tableColumns->data[i];
     150
     151        column->name = psStringCopy (myColumn->name);
     152        column->type = myColumn->type;
     153        column->vectorType = myColumn->vectorType;
     154        column->elementSize = myColumn->elementSize;
     155       
     156        psMetadataAddS32(table->index, PS_LIST_TAIL, column->name, 0, NULL, i);
     157
     158        switch (column->type) {
     159          case PS_DATA_S8:  column->data.S8  = psAlloc(sizeof(psS8) *table->numRows); break;
     160          case PS_DATA_S16: column->data.S16 = psAlloc(sizeof(psS16)*table->numRows); break;
     161          case PS_DATA_S32: column->data.S32 = psAlloc(sizeof(psS32)*table->numRows); break;
     162          case PS_DATA_S64: column->data.S64 = psAlloc(sizeof(psS64)*table->numRows); break;
     163          case PS_DATA_U8:  column->data.U8  = psAlloc(sizeof(psU8) *table->numRows); break;
     164          case PS_DATA_U16: column->data.U16 = psAlloc(sizeof(psU16)*table->numRows); break;
     165          case PS_DATA_U32: column->data.U32 = psAlloc(sizeof(psU32)*table->numRows); break;
     166          case PS_DATA_U64: column->data.U64 = psAlloc(sizeof(psU64)*table->numRows); break;
     167          case PS_DATA_F32: column->data.F32 = psAlloc(sizeof(psF32)*table->numRows); break;
     168          case PS_DATA_F64: column->data.F64 = psAlloc(sizeof(psF64)*table->numRows); break;
     169          default: break;
     170        }
     171    }
     172    return table;
     173}
     174
     175static void freeColumn(psFitsTableColumn *column)
     176{
     177    // add any element frees here
     178    return;
     179}
     180
     181psFitsTableColumn *psFitsTableColumnAlloc (char *name, psDataType type) {
     182
     183    psFitsTableColumn *column = psAlloc(sizeof(psFitsTableColumn));
     184    psMemSetDeallocator(column, (psFreeFunc) freeColumn);
     185
     186    column->name = psStringCopy (name);
     187    column->type = type;
     188    column->vectorType  = 0;
     189    column->elementSize = 1;
     190    column->data.S8 = NULL; // no data yet allocated, place-holder only
     191    return column;
     192}
     193
     194bool psFitsTableColumnAdd (psArray *tableColumns, char *name, psDataType type) {
     195    psFitsTableColumn *column = psFitsTableColumnAlloc (name, type);
     196    psArrayAdd (tableColumns, 10, column);
     197    return true;
    139198}
    140199
    … …  
    397456psFitsTableGetNumTYPE(Bool, BOOL);
    398457
     458#define psFitsTableSetNumTYPE(TYPE, NAME) \
     459    bool psFitsTableSet##NAME(psFitsTable *table, int row, const char *name, ps##TYPE value) { \
     460                                                                        \
     461    if (row >= table->numRows || row < 0) { return false; }             \
     462                                                                        \
     463    bool mdok;                                                          \
     464    int col = psMetadataLookupS32(&mdok, table->index, name);           \
     465    if (!mdok) { return false; }                                        \
     466    if (col < 0) { return false; }                                      \
     467                                                                        \
     468    psFitsTableColumn *column = &table->columns[col];                   \
     469    switch (column->type) {                                             \
     470      case PS_DATA_S8:                                                  \
     471        column->data.S8[row] = (psS8) value;                            \
     472        break;                                                          \
     473      case PS_DATA_S16:                                                 \
     474        column->data.S16[row] = (psS16) value;                          \
     475        break;                                                          \
     476      case PS_DATA_S32:                                                 \
     477        column->data.S32[row] = (psS32) value;                          \
     478        break;                                                          \
     479      case PS_DATA_S64:                                                 \
     480        column->data.S64[row] = (psS64) value;                          \
     481        break;                                                          \
     482      case PS_DATA_U8:                                                  \
     483        column->data.U8[row] = (psU8) value;                            \
     484        break;                                                          \
     485      case PS_DATA_U16:                                                 \
     486        column->data.U16[row] = (psU16) value;                          \
     487        break;                                                          \
     488      case PS_DATA_U32:                                                 \
     489        column->data.U32[row] = (psU32) value;                          \
     490        break;                                                          \
     491      case PS_DATA_U64:                                                 \
     492        column->data.U64[row] = (psU64) value;                          \
     493        break;                                                          \
     494      case PS_DATA_F32:                                                 \
     495        column->data.F32[row] = (psF32) value;                          \
     496        break;                                                          \
     497      case PS_DATA_F64:                                                 \
     498        column->data.F64[row] = (psF64) value;                          \
     499        break;                                                          \
     500      case PS_DATA_BOOL:                                                \
     501        if (value) { column->data.F64[row] = 1; }                       \
     502        else { column->data.F64[row] = 0; }                             \
     503        break;                                                          \
     504      default:                                                          \
     505        /* if you get to this point, the value is not a number. */      \
     506        return false;                                                   \
     507        break;                                                          \
     508    }                                                                   \
     509    return true;                                                        \
     510}
     511
     512psFitsTableSetNumTYPE(S8, S8);
     513psFitsTableSetNumTYPE(U8, U8);
     514psFitsTableSetNumTYPE(S16, S16);
     515psFitsTableSetNumTYPE(U16, U16);
     516psFitsTableSetNumTYPE(S32, S32);
     517psFitsTableSetNumTYPE(U32, U32);
     518psFitsTableSetNumTYPE(S64, S64);
     519psFitsTableSetNumTYPE(U64, U64);
     520psFitsTableSetNumTYPE(F32, F32);
     521psFitsTableSetNumTYPE(F64, F64);
     522psFitsTableSetNumTYPE(Bool, BOOL);
     523
    399524// remove rows from table that are marked in the mask array as censored.
    400525bool psFitsTableCensor(psFitsTable *table, bool *censorMask)
Note: See TracChangeset for help on using the changeset viewer.