IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 38693


Ignore:
Timestamp:
Aug 31, 2015, 2:37:11 PM (11 years ago)
Author:
eugene
Message:

convert the internal description of the AstromOffsetMap to an array of floats, not an array of arrays

Location:
branches/eam_branches/ipp-20150625/Ohana/src/libdvo
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branches/ipp-20150625/Ohana/src/libdvo/include/libdvo_astro.h

    r38687 r38693  
    5656  float dX;
    5757  float dY;
    58   float **dXv;
    59   float **dYv;
     58  float *dXv;
     59  float *dYv;
    6060  unsigned int tableID;
    6161  unsigned int imageID;
    … …  
    6565typedef struct {
    6666  int Nmap;
     67  int NMAP;
    6768  AstromOffsetMap **map;
    6869   int *imageIDtoTableSeq;

  • branches/eam_branches/ipp-20150625/Ohana/src/libdvo/src/AstromOffsetMapIO.c

    r38687 r38693  
    1111  FTable ftable;
    1212  ftable.header = &theader;
     13  ftable.buffer = NULL;
    1314
    1415  FILE *f = fopen (filename, "r");
    … …  
    4243    int NrowsTotal = ftable.header[0].Naxis[1];
    4344    int Nblocks = (NrowsTotal % Nrows) ? (int) (NrowsTotal / Nrows) + 1 : (NrowsTotal / Nrows);
     45
     46    // allocate the full array up front.  passes through AstromOffsetMapAppendToTable
     47    // check the current allocation and will bump the allocation as needed.
     48    ALLOCATE (table, AstromOffsetTable, 1);
     49    ALLOCATE (table->map, AstromOffsetMap *, NrowsTotal);
     50    table->Nmap = 0;
     51    table->NMAP = NrowsTotal;
     52
     53    // on each call to gfits_fread_ftable_range, we need to reset the FILE pointer to the
     54    // beginning of the data block.  again this seems a little wrong.
     55    off_t diskStart = ftello (f);
    4456
    4557    int i;
    … …  
    5163
    5264      table = AstromOffsetMapAppendToTable (table, map_disk, Nmap);
    53       gfits_free_table  (&ftable);
     65
     66      // XXX this is kind of hack-ish: gfits_fread_ftable_range modifies Naxis[1] to the
     67      // number of rows actually read, but this makes a subsequent read invalid.  I'm
     68      // resetting the value of Naxis[1] before the next read to deal with this problem.
     69      // But is there a more consistent way to address this?
     70
     71      // Answer: the FTable structure could include information about the table
     72      // representation on disk, including start,Nrows values.  I'm not going to mess
     73      // around with that just now.
     74
     75      ftable.header[0].Naxis[1] = NrowsTotal;
     76      fseeko (f, diskStart, SEEK_SET);
    5477    }
    5578    AstromOffsetTableSetIDs (table);
    5679    gfits_free_header (ftable.header);
     80    gfits_free_table  (&ftable);
    5781  } else {
    5882
    … …  
    162186    table->map[i][0].Nx           = map_disk[i].Nx;
    163187    table->map[i][0].Ny           = map_disk[i].Ny;
    164     table->map[i][0].tableID = map_disk[i].tableID;
    165     table->map[i][0].imageID = map_disk[i].imageID;
     188    table->map[i][0].tableID      = map_disk[i].tableID;
     189    table->map[i][0].imageID      = map_disk[i].imageID;
    166190   
    167191    // STORE THESE VALUES?
    … …  
    172196    table->map[i][0].keep         = TRUE;
    173197
    174     ALLOCATE (table->map[i][0].dXv, float *, map_disk[i].Nx);
    175     ALLOCATE (table->map[i][0].dYv, float *, map_disk[i].Nx);
    176 
    177     for (j = 0; j < map_disk[i].Nx; j++) {
    178       ALLOCATE (table->map[i][0].dXv[j], float, map_disk[i].Ny);
    179       ALLOCATE (table->map[i][0].dYv[j], float, map_disk[i].Ny);
    180 
    181       for (k = 0; k < map_disk[i].Ny; k++) {
    182         table->map[i][0].dXv[j][k] = map_disk[i].dXv[j][k];
    183         table->map[i][0].dYv[j][k] = map_disk[i].dYv[j][k];
     198    int Nx = table->map[i][0].Nx;
     199    int Ny = table->map[i][0].Ny;
     200
     201    ALLOCATE (table->map[i][0].dXv, float, Nx*Ny);
     202    ALLOCATE (table->map[i][0].dYv, float, Nx*Ny);
     203
     204    for (j = 0; j < Nx; j++) {
     205      for (k = 0; k < Ny; k++) {
     206        table->map[i][0].dXv[j + k*Nx] = map_disk[i].dXv[j][k];
     207        table->map[i][0].dYv[j + k*Nx] = map_disk[i].dYv[j][k];
    184208      }
    185209    }
    … …  
    209233    map_disk[Ndisk].dY      = table->map[i][0].dY;
    210234
    211     for (j = 0; j < map_disk[Ndisk].Nx; j++) {
    212       for (k = 0; k < map_disk[Ndisk].Ny; k++) {
    213         map_disk[Ndisk].dXv[j][k] = table->map[i][0].dXv[j][k];
    214         map_disk[Ndisk].dYv[j][k] = table->map[i][0].dYv[j][k];
     235    int Nx = table->map[i][0].Nx;
     236    int Ny = table->map[i][0].Ny;
     237
     238    for (j = 0; j < Nx; j++) {
     239      for (k = 0; k < Ny; k++) {
     240        map_disk[Ndisk].dXv[j][k] = table->map[i][0].dXv[j + k*Nx];
     241        map_disk[Ndisk].dYv[j][k] = table->map[i][0].dYv[j + k*Nx];
    215242      }
    216243      for (k = map_disk[Ndisk].Ny; k < 6; k++) {
    … …  
    242269  } else {
    243270    Nstart = table->Nmap;
     271    if (table->Nmap + Nmap > table->NMAP) {
     272      table->NMAP = table->Nmap + Nmap;
     273      REALLOCATE (table->map, AstromOffsetMap *, table->NMAP);
     274    }
    244275    table->Nmap += Nmap;
    245     REALLOCATE (table->map, AstromOffsetMap *, table->Nmap);
    246276  }
    247277
    … …  
    264294    table->map[N][0].keep         = TRUE;
    265295
    266     ALLOCATE (table->map[N][0].dXv, float *, map_disk[i].Nx);
    267     ALLOCATE (table->map[N][0].dYv, float *, map_disk[i].Nx);
    268 
    269     for (j = 0; j < map_disk[i].Nx; j++) {
    270       ALLOCATE (table->map[N][0].dXv[j], float, map_disk[i].Ny);
    271       ALLOCATE (table->map[N][0].dYv[j], float, map_disk[i].Ny);
    272 
    273       for (k = 0; k < map_disk[i].Ny; k++) {
    274         table->map[N][0].dXv[j][k] = map_disk[i].dXv[j][k];
    275         table->map[N][0].dYv[j][k] = map_disk[i].dYv[j][k];
     296    int Nx = table->map[N][0].Nx;
     297    int Ny = table->map[N][0].Ny;
     298
     299    ALLOCATE (table->map[N][0].dXv, float, Nx*Ny);
     300    ALLOCATE (table->map[N][0].dYv, float, Nx*Ny);
     301
     302    for (j = 0; j < Nx; j++) {
     303      for (k = 0; k < Ny; k++) {
     304        table->map[N][0].dXv[j + k*Nx] = map_disk[i].dXv[j][k];
     305        table->map[N][0].dYv[j + k*Nx] = map_disk[i].dYv[j][k];
    276306      }
    277307    }

  • branches/eam_branches/ipp-20150625/Ohana/src/libdvo/src/AstromOffsetMapOps.c

    r37807 r38693  
    1212  // given x,y find the offset (x-direction) at that location from the map
    1313
    14   float **V = xdir ? map->dXv : map->dYv;
     14  int Nx = map->Nx;
     15  int Ny = map->Ny;
     16
     17  float *V = xdir ? map->dXv : map->dYv;
    1518
    1619  // if there is no spatial information, the value at the point is the value in the map
    17   if ((map->Nx == 1) && (map->Ny == 1)) return V[0][0];
     20  if ((Nx == 1) && (Ny == 1)) return V[0];
    1821
    1922  // if there is no spatial information in 1D, the interpolation is 1D
    20   if (map->Nx == 1) {
     23  if (Nx == 1) {
    2124    float ymo = y * map->dY - 0.5;
    2225    int   ymi = floor(ymo);
    23     ymi = MAX(0,MIN(map->Ny - 2, ymi)); // force range of ymi to be 0,Ny-2 (Ny must be > 1)
     26    ymi = MAX(0,MIN(Ny - 2, ymi)); // force range of ymi to be 0,Ny-2 (Ny must be > 1)
    2427
    2528    float ymf = ymo - ymi;
    2629
    27     float value = ymf * V[0][ymi+1] + (1.0 - ymf) * V[0][ymi];
     30    float value = ymf * V[ymi+1] + (1.0 - ymf) * V[ymi];
    2831    return value;
    2932  }
    3033
    3134  // if there is no spatial information in 1D, the interpolation is 1D
    32   if (map->Ny == 1) {
     35  if (Ny == 1) {
    3336    float xmo = x * map->dX - 0.5;
    3437    int   xmi = floor(xmo);
    35     xmi = MAX(0,MIN(map->Nx - 2, xmi)); // force range of ymi to be 0,Nx-2  (Nx must be > 1)
     38    xmi = MAX(0,MIN(Nx - 2, xmi)); // force range of ymi to be 0,Nx-2  (Nx must be > 1)
    3639
    3740    float xmf = xmo - xmi;
    3841
    39     float value = xmf * V[xmi+1][0] + (1.0 - xmf) * V[xmi][0];
     42    float value = xmf * V[xmi+1] + (1.0 - xmf) * V[xmi];
    4043    return value;
    4144  }
    … …  
    4548  float xmo = x * map->dX - 0.5;
    4649  int   xmi = floor(xmo);
    47   xmi = MAX(0,MIN(map->Nx - 2, xmi)); // force range of ymi to be 0,Nx-1
     50  xmi = MAX(0,MIN(Nx - 2, xmi)); // force range of ymi to be 0,Nx-1
    4851  float xmf = xmo - xmi;
    4952
    5053  float ymo = y * map->dY - 0.5;
    5154  int   ymi = floor(ymo);
    52   ymi = MAX(0,MIN(map->Ny - 2, ymi)); // force range of ymi to be 0,Ny-2
     55  ymi = MAX(0,MIN(Ny - 2, ymi)); // force range of ymi to be 0,Ny-2
    5356  float ymf = ymo - ymi;
    5457
    55   float V00 = V[xmi+0][ymi+0];
    56   float V01 = V[xmi+0][ymi+1];
    57   float V10 = V[xmi+1][ymi+0];
    58   float V11 = V[xmi+1][ymi+1];
     58  float V00 = V[xmi+0 + (ymi+0)*Nx];
     59  float V01 = V[xmi+0 + (ymi+1)*Nx];
     60  float V10 = V[xmi+1 + (ymi+0)*Nx];
     61  float V11 = V[xmi+1 + (ymi+1)*Nx];
    5962
    6063  float Vx0 = V10*xmf + V00*(1.0 - xmf);
    … …  
    7881
    7982  // choose to map direction:
    80   float **V = xdir ? map->dXv : map->dYv;
     83  float *Vptr = xdir ? map->dXv : map->dYv;
    8184
    8285  // special cases:
    … …  
    8891
    8992    vstats_getstats_f (f, NULL, NULL, Npts, &stats);
    90     V[0][0] = stats.mean;
     93    Vptr[0] = stats.mean;
    9194    return TRUE;
    9295  }
    … …  
    352355    for (iy = 0; iy < Ny; iy++) {
    353356      int I = ix + Nx * iy;
    354       V[ix][iy] = B[I][0];
     357      Vptr[I] = B[I][0];
    355358      // error[ix][iy] = sqrt(A[I][I]);
    356359    }
    … …  
    376379
    377380  // choose to map direction:
    378   float **V = xdir ? map->dXv : map->dYv;
     381  float *Vptr = xdir ? map->dXv : map->dYv;
    379382
    380383  // measure clipped median in each bin
    … …  
    422425      if (Nvalue[I] > 5) {
    423426        vstats_getstats (values[I], NULL, NULL, Nvalue[I], &stats);
    424         V[ix][iy] = stats.mean;
     427        Vptr[I] = stats.mean;
    425428      } else {
    426         V[ix][iy] = NAN;
     429        Vptr[I] = NAN;
    427430      }
    428431    }
    … …  
    453456  int ix, iy;
    454457
    455   float **Vfix = NULL;
    456   ALLOCATE (Vfix, float *, Nx);
     458  float *Vfix = NULL;
     459  ALLOCATE (Vfix, float, Nx*Ny);
    457460  for (ix = 0; ix < Nx; ix++) {
    458     ALLOCATE (Vfix[ix], float, Ny);
    459     for (iy = 0; iy < Ny; iy++) {
    460       Vfix[ix][iy] = NAN;
     461    for (iy = 0; iy < Ny; iy++) {
     462      Vfix[ix + iy*Nx] = NAN;
    461463    }
    462464  }
    … …  
    468470  for (ix = 0; ix < Nx; ix++) {
    469471    for (iy = 0; iy < Ny; iy++) {
    470       float value = xdir ? map->dXv[ix][iy] : map->dYv[ix][iy];
     472      int I = ix + iy*Nx;
     473      float value = xdir ? map->dXv[I] : map->dYv[I];
    471474      if (isnan(value)) continue;
    472475      mean += value;
    … …  
    479482  for (ix = 0; ix < Nx; ix++) {
    480483    for (iy = 0; iy < Ny; iy++) {
    481 
    482       float value = xdir ? map->dXv[ix][iy] : map->dYv[ix][iy];
     484      int I = ix + iy*Nx;
     485      float value = xdir ? map->dXv[I] : map->dYv[I];
    483486      if (!isnan(value)) {
    484         Vfix[ix][iy] = value;
     487        Vfix[I] = value;
    485488        continue;
    486489      }
    … …  
    499502          if (ny < 0) continue;
    500503          if (ny >= Ny) continue;
    501           float value = xdir ? map->dXv[nx][ny] : map->dYv[nx][ny];
     504          int I = ix + iy*Nx;
     505          float value = xdir ? map->dXv[I] : map->dYv[I];
    502506          if (isnan(value)) continue;
    503507
    … …  
    508512      // if there are no valid (non-NAN) local pixels, use global mean
    509513      meanLocal = (npixLocal > 0.0) ? meanLocal / npixLocal : mean;
    510       Vfix[ix][iy] = meanLocal;
     514      Vfix[I] = meanLocal;
    511515    }
    512516  }
    … …  
    515519  for (ix = 0; ix < Ny; ix++) {
    516520    for (iy = 0; iy < Ny; iy++) {
     521      int I = ix + iy*Nx;
    517522      if (xdir) {
    518         map->dXv[ix][iy] = Vfix[ix][iy];
     523        map->dXv[I] = Vfix[I];
    519524      } else {
    520         map->dYv[ix][iy] = Vfix[ix][iy];
    521       }
    522     }
    523   }
    524   for (ix = 0; ix < Nx; ix++) {
    525     free (Vfix[ix]);
     525        map->dYv[I] = Vfix[I];
     526      }
     527    }
    526528  }
    527529  free (Vfix);

  • branches/eam_branches/ipp-20150625/Ohana/src/libdvo/src/AstromOffsetMapUtils.c

    r37807 r38693  
    3636  map->keep = TRUE; // output map size
    3737
    38   ALLOCATE (map->dXv, float *, map->Nx);
    39   ALLOCATE (map->dYv, float *, map->Nx);
    40 
    41   int j, k;
    42   for (j = 0; j < map->Nx; j++) {
    43     ALLOCATE (map->dXv[j], float, map->Ny);
    44     ALLOCATE (map->dYv[j], float, map->Ny);
    45 
    46     for (k = 0; k < map->Ny; k++) {
    47       map->dXv[j][k] = 0.0;
    48       map->dYv[j][k] = 0.0;
     38  ALLOCATE (map->dXv, float, Nx*Ny);
     39  ALLOCATE (map->dYv, float, Nx*Ny);
     40
     41  int j, k;
     42  for (j = 0; j < Nx; j++) {
     43    for (k = 0; k < Ny; k++) {
     44      map->dXv[j + k*Nx] = 0.0;
     45      map->dYv[j + k*Nx] = 0.0;
    4946    }
    5047  }
    … …  
    5653
    5754  if (!map) return;
    58 
    59   int j;
    60   for (j = 0; j < map->Nx; j++) {
    61     if (map->dXv) free (map->dXv[j]);
    62     if (map->dYv) free (map->dYv[j]);
    63   }
    6455
    6556  free (map->dXv);
    … …  
    7667
    7768  // rather than try to figure out how to resize, and free/allocate, lets just free the old arrays and make new ones
    78   for (j = 0; j < map->Nx; j++) {
    79     if (map->dXv) free (map->dXv[j]);
    80     if (map->dYv) free (map->dYv[j]);
    81   }
    8269  free (map->dXv);
    8370  free (map->dYv);
    … …  
    9077  map->keep = TRUE; // output map size
    9178
    92   ALLOCATE (map->dXv, float *, map->Nx);
    93   ALLOCATE (map->dYv, float *, map->Nx);
    94 
    95   for (j = 0; j < map->Nx; j++) {
    96     ALLOCATE (map->dXv[j], float, map->Ny);
    97     ALLOCATE (map->dYv[j], float, map->Ny);
    98 
    99     for (k = 0; k < map->Ny; k++) {
    100       map->dXv[j][k] = 0.0;
    101       map->dYv[j][k] = 0.0;
     79  ALLOCATE (map->dXv, float, Nx*Ny);
     80  ALLOCATE (map->dYv, float, Nx*Ny);
     81
     82  for (j = 0; j < Nx; j++) {
     83    for (k = 0; k < Ny; k++) {
     84      map->dXv[j + k*Nx] = 0.0;
     85      map->dYv[j + k*Nx] = 0.0;
    10286    }
    10387  }
    … …  
    116100  tgt->tableID = map->tableID;
    117101
    118   int j, k;
    119   for (j = 0; j < tgt->Nx; j++) {
    120     for (k = 0; k < map->Ny; k++) {
    121       tgt->dXv[j][k] = map->dXv[j][k];
    122       tgt->dYv[j][k] = map->dYv[j][k];
     102  int Nx = map->Nx;
     103  int Ny = map->Ny;
     104
     105  int j, k;
     106  for (j = 0; j < Nx; j++) {
     107    for (k = 0; k < Ny; k++) {
     108      tgt->dXv[j + k*Nx] = map->dXv[j + k*Nx];
     109      tgt->dYv[j + k*Nx] = map->dYv[j + k*Nx];
    123110    }
    124111  }
    … …  
    139126  tgt->keep = src->keep;
    140127
    141   int j, k;
    142   for (j = 0; j < tgt->Nx; j++) {
    143     for (k = 0; k < src->Ny; k++) {
    144       tgt->dXv[j][k] = src->dXv[j][k];
    145       tgt->dYv[j][k] = src->dYv[j][k];
     128  int Nx = src->dX;
     129  int Ny = src->dY;
     130
     131  int j, k;
     132  for (j = 0; j < Nx; j++) {
     133    for (k = 0; k < Ny; k++) {
     134      tgt->dXv[j + k*Nx] = src->dXv[j + k*Nx];
     135      tgt->dYv[j + k*Nx] = src->dYv[j + k*Nx];
    146136    }
    147137  }
    … …  
    153143  if (!table) return;
    154144
    155   int i, j;
     145  int i;
    156146  for (i = 0; i < table->Nmap; i++) {
    157     for (j = 0; j < table->map[i][0].Nx; j++) {
    158       free (table->map[i][0].dXv[j]);
    159       free (table->map[i][0].dYv[j]);
    160     }
    161147    if (!table->map[i]) continue;
    162148    FREE (table->map[i][0].dXv);
    … …  
    260246  }
    261247
     248  int Nx = map->Nx;
     249  int Ny = map->Ny;
     250
    262251  fprintf (f, "imageID: %d, tableID: %d (dX: %f, dY: %f), keep: %d\n", map->imageID, map->tableID, map->dX, map->dY, map->keep);
    263252  int ix, iy;
    264253  fprintf (f, "dXv map:\n");
    265   for (ix = 0; ix < map->Nx; ix++) {
    266     for (iy = 0; iy < map->Ny; iy++) {
    267       fprintf (f, "%9.5f ", map->dXv[ix][iy]);
     254  for (ix = 0; ix < Nx; ix++) {
     255    for (iy = 0; iy < Ny; iy++) {
     256      fprintf (f, "%9.5f ", map->dXv[ix + iy*Nx]);
    268257    }
    269258    fprintf (f, "\n");
    270259  }
    271260  fprintf (f, "dYv map:\n");
    272   for (ix = 0; ix < map->Nx; ix++) {
    273     for (iy = 0; iy < map->Ny; iy++) {
    274       fprintf (f, "%9.5f ", map->dYv[ix][iy]);
     261  for (ix = 0; ix < Nx; ix++) {
     262    for (iy = 0; iy < Ny; iy++) {
     263      fprintf (f, "%9.5f ", map->dYv[ix + iy*Nx]);
    275264    }
    276265    fprintf (f, "\n");

  • branches/eam_branches/ipp-20150625/Ohana/src/libdvo/src/dvo_convert.c

    r38590 r38693  
    7777    average = Average_PS1_V4alt_ToInternal (tmpAverage, *Naverage);
    7878    free (tmpAverage);
     79    ftable[0].buffer = NULL;
    7980    *format = DVO_FORMAT_PS1_V4;
    8081    return (average);
    … …  
    9192    average = Average_PS1_V5alt_ToInternal (tmpAverage, *Naverage);
    9293    free (tmpAverage);
     94    ftable[0].buffer = NULL;
    9395    *format = DVO_FORMAT_PS1_V5;
    9496    return (average);
    9597  }
    9698
    97 # define CONVERT_FORMAT(NAME, FORMAT, TYPE) \
    98   if (!strcmp (extname, NAME)) { \
    99     Average_##TYPE *tmpAverage; \
    100       tmpAverage = gfits_table_get_Average_##TYPE (ftable, Naverage, NULL, &nativeBytes); \
    101     if (!tmpAverage) { \
    102       fprintf (stderr, "ERROR: failed to read averages\n"); \
    103       exit (2); \
    104     } \
     99# define CONVERT_FORMAT(NAME, FORMAT, TYPE)                             \
     100  if (!strcmp (extname, NAME)) {                                        \
     101    Average_##TYPE *tmpAverage;                                         \
     102    tmpAverage = gfits_table_get_Average_##TYPE (ftable, Naverage, NULL, &nativeBytes); \
     103    if (!tmpAverage) {                                                  \
     104      fprintf (stderr, "ERROR: failed to read averages\n");             \
     105      exit (2);                                                         \
     106    }                                                                   \
    105107    average = Average_##TYPE##_ToInternal (tmpAverage, *Naverage, primary); \
    106     free (tmpAverage); \
    107     *format = DVO_FORMAT_##FORMAT; \
     108    free (tmpAverage);                                                  \
     109    ftable[0].buffer = NULL;                                            \
     110    *format = DVO_FORMAT_##FORMAT;                                      \
    108111    return (average); }
    109112
    … …  
    141144int AverageToFtable (FTable *ftable, Average *average, off_t Naverage, DVOCatFormat format, SecFilt *primary, int swapFromNative) {
    142145 
    143 # define FORMAT_CASE(FORMAT, TYPE)              \
     146# define FORMAT_CASE(FORMAT, TYPE)                                      \
    144147  case DVO_FORMAT_##FORMAT: {                                           \
    145148    Average_##TYPE *tmpAverage;                                         \
    146       tmpAverage = AverageInternalTo_##TYPE (average, Naverage, primary); \
    147         gfits_table_set_Average_##TYPE (ftable, tmpAverage, Naverage, swapFromNative); \
    148           free (tmpAverage);                                            \
    149           break; }
     149    tmpAverage = AverageInternalTo_##TYPE (average, Naverage, primary); \
     150    gfits_table_set_Average_##TYPE (ftable, tmpAverage, Naverage, swapFromNative); \
     151    free (tmpAverage);                                                  \
     152    break; }
    150153 
    151154  /* convert from the internal format */
    … …  
    205208    measure = Measure_PS1_V4alt_ToInternal (average, tmpMeasure, *Nmeasure);
    206209    free (tmpMeasure);
     210    ftable[0].buffer = NULL;
    207211    *format = DVO_FORMAT_PS1_V4;
    208212    return (measure);
    … …  
    222226    measure = Measure_PS1_V5alt_ToInternal (average, tmpMeasure, *Nmeasure);
    223227    free (tmpMeasure);
     228    ftable[0].buffer = NULL;
    224229    *format = DVO_FORMAT_PS1_V5;
    225230    return (measure);
    226231  }
    227232
    228 # define CONVERT_FORMAT(NAME, FORMAT, TYPE, ABS_COORDS)         \
     233# define CONVERT_FORMAT(NAME, FORMAT, TYPE, ABS_COORDS)                 \
    229234  if (!strcmp (extname, NAME)) {                                        \
    230235    Measure_##TYPE *tmpMeasure;                                         \
    231       tmpMeasure = gfits_table_get_Measure_##TYPE (ftable, Nmeasure, NULL, &nativeBytes); \
    232         if (!tmpMeasure) {                                              \
    233           fprintf (stderr, "ERROR: failed to read measures\n");         \
    234           exit (2);                                                     \
    235         }                                                               \
    236         myAssert (ABS_COORDS || average, "conversion to internal needs average table"); \
     236    tmpMeasure = gfits_table_get_Measure_##TYPE (ftable, Nmeasure, NULL, &nativeBytes); \
     237    if (!tmpMeasure) {                                                  \
     238      fprintf (stderr, "ERROR: failed to read measures\n");             \
     239      exit (2);                                                         \
     240    }                                                                   \
     241    myAssert (ABS_COORDS || average, "conversion to internal needs average table"); \
    237242    measure = Measure_##TYPE##_ToInternal (average, tmpMeasure, *Nmeasure); \
    238243    free (tmpMeasure);                                                  \
     244    ftable[0].buffer = NULL;                                            \
    239245    *format = DVO_FORMAT_##FORMAT;                                      \
    240246    return (measure); }
    … …  
    274280int MeasureToFtable (FTable *ftable, Average *average, Measure *measure, off_t Nmeasure, DVOCatFormat format, int swapFromNative) {
    275281
    276 # define FORMAT_CASE(FORMAT, TYPE, ABS_COORDS)          \
    277     case DVO_FORMAT_##FORMAT: { \
    278       Measure_##TYPE *tmpMeasure; \
    279       myAssert (ABS_COORDS || average, "conversion from internal needs average table"); \
    280       tmpMeasure = MeasureInternalTo_##TYPE (average, measure, Nmeasure); \
    281         gfits_table_set_Measure_##TYPE (ftable, tmpMeasure, Nmeasure, swapFromNative); \
    282       free (tmpMeasure); \
    283       break; }
     282# define FORMAT_CASE(FORMAT, TYPE, ABS_COORDS)                          \
     283  case DVO_FORMAT_##FORMAT: {                                           \
     284    Measure_##TYPE *tmpMeasure;                                         \
     285    myAssert (ABS_COORDS || average, "conversion from internal needs average table"); \
     286    tmpMeasure = MeasureInternalTo_##TYPE (average, measure, Nmeasure); \
     287    gfits_table_set_Measure_##TYPE (ftable, tmpMeasure, Nmeasure, swapFromNative); \
     288    free (tmpMeasure);                                                  \
     289    break; }
    284290
    285291  /* convert from the internal format */
    … …  
    324330  }
    325331
    326 # define SKIPPING_FORMAT(NAME, FORMAT, TYPE)            \
     332# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)                            \
    327333  if (!strcmp (extname, NAME)) {                                        \
    328334    fprintf (stderr, "ERROR: format %s not defined for missing, skipping\n", NAME); \
    329     *Nmissing = 0; \
    330     return NULL; \
    331   }
    332 
    333 # define CONVERT_FORMAT(NAME, FORMAT, TYPE)             \
     335    *Nmissing = 0;                                                      \
     336    return NULL;                                                        \
     337  }
     338
     339# define CONVERT_FORMAT(NAME, FORMAT, TYPE)                             \
    334340  if (!strcmp (extname, NAME)) {                                        \
    335341    Missing_##TYPE *tmpMissing;                                         \
    … …  
    339345      exit (2);                                                         \
    340346    }                                                                   \
    341     missing = Missing_##TYPE##_ToInternal (tmpMissing, *Nmissing); \
     347    missing = Missing_##TYPE##_ToInternal (tmpMissing, *Nmissing);      \
    342348    free (tmpMissing);                                                  \
     349    ftable[0].buffer = NULL;                                            \
    343350    *format = DVO_FORMAT_##FORMAT;                                      \
    344351    return (missing); }
    … …  
    410417    secfilt = SecFilt_PS1_V5alt_ToInternal (tmpSecFilt, *Nsecfilt);
    411418    free (tmpSecFilt);
     419    ftable[0].buffer = NULL;
    412420    *format = DVO_FORMAT_PS1_V5;
    413421    return (secfilt);
    … …  
    415423
    416424
    417 # define CONVERT_FORMAT(NAME, FORMAT, TYPE) \
    418   if (!strcmp (extname, NAME)) { \
    419     SecFilt_##TYPE *tmpSecFilt; \
     425# define CONVERT_FORMAT(NAME, FORMAT, TYPE)                             \
     426  if (!strcmp (extname, NAME)) {                                        \
     427    SecFilt_##TYPE *tmpSecFilt;                                         \
    420428    tmpSecFilt = gfits_table_get_SecFilt_##TYPE (ftable, Nsecfilt, NULL, &nativeBytes); \
    421     if (!tmpSecFilt) { \
    422       fprintf (stderr, "ERROR: failed to read secfilts\n"); \
    423       exit (2); \
    424     } \
    425     secfilt = SecFilt_##TYPE##_ToInternal (tmpSecFilt, *Nsecfilt); \
    426     free (tmpSecFilt); \
    427     *format = DVO_FORMAT_##FORMAT; \
     429    if (!tmpSecFilt) {                                                  \
     430      fprintf (stderr, "ERROR: failed to read secfilts\n");             \
     431      exit (2);                                                         \
     432    }                                                                   \
     433    secfilt = SecFilt_##TYPE##_ToInternal (tmpSecFilt, *Nsecfilt);      \
     434    free (tmpSecFilt);                                                  \
     435    ftable[0].buffer = NULL;                                            \
     436    *format = DVO_FORMAT_##FORMAT;                                      \
    428437    return (secfilt); }
    429438
    … …  
    461470int SecFiltToFtable (FTable *ftable, SecFilt *secfilt, off_t Nsecfilt, DVOCatFormat format, int swapFromNative) {
    462471
    463 # define FORMAT_CASE(FORMAT, TYPE) \
    464     case DVO_FORMAT_##FORMAT: { \
    465       SecFilt_##TYPE *tmpSecFilt; \
    466       tmpSecFilt = SecFiltInternalTo_##TYPE (secfilt, Nsecfilt); \
    467         gfits_table_set_SecFilt_##TYPE (ftable, tmpSecFilt, Nsecfilt, swapFromNative); \
    468       free (tmpSecFilt); \
    469       break; }
     472# define FORMAT_CASE(FORMAT, TYPE)                                      \
     473  case DVO_FORMAT_##FORMAT: {                                           \
     474    SecFilt_##TYPE *tmpSecFilt;                                         \
     475    tmpSecFilt = SecFiltInternalTo_##TYPE (secfilt, Nsecfilt);          \
     476    gfits_table_set_SecFilt_##TYPE (ftable, tmpSecFilt, Nsecfilt, swapFromNative); \
     477    free (tmpSecFilt);                                                  \
     478    break; }
    470479
    471480  /* convert from the internal format */
    … …  
    519528    lensing = Lensing_PS1_V5_R0_ToInternal (tmpLensing, *Nlensing);
    520529    free (tmpLensing);                                                 
     530    ftable[0].buffer = NULL;
    521531    *format = DVO_FORMAT_PS1_V5;                                       
    522532    return (lensing); }
    … …  
    531541    lensing = Lensing_PS1_V5_R1_ToInternal (tmpLensing, *Nlensing);
    532542    free (tmpLensing);                                                 
     543    ftable[0].buffer = NULL;
    533544    *format = DVO_FORMAT_PS1_V5;                                       
    534545    return (lensing); }
    … …  
    543554    lensing = Lensing_PS1_V5_R2_ToInternal (tmpLensing, *Nlensing);
    544555    free (tmpLensing);                                                 
     556    ftable[0].buffer = NULL;
    545557    *format = DVO_FORMAT_PS1_V5;                                       
    546558    return (lensing); }
    547559
    548 # define SKIPPING_FORMAT(NAME, FORMAT, TYPE)            \
     560# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)                            \
    549561  if (!strcmp (extname, NAME)) {                                        \
    550562    fprintf (stderr, "ERROR: format %s not defined for lensing, skipping\n", NAME); \
    551     *Nlensing = 0; \
    552     return NULL; \
    553   }
    554 
    555 # define CONVERT_FORMAT(NAME, FORMAT, TYPE)             \
     563    *Nlensing = 0;                                                      \
     564    return NULL;                                                        \
     565  }
     566
     567# define CONVERT_FORMAT(NAME, FORMAT, TYPE)                             \
    556568  if (!strcmp (extname, NAME)) {                                        \
    557569    Lensing_##TYPE *tmpLensing;                                         \
    … …  
    561573      exit (2);                                                         \
    562574    }                                                                   \
    563     lensing = Lensing_##TYPE##_ToInternal (tmpLensing, *Nlensing); \
     575    lensing = Lensing_##TYPE##_ToInternal (tmpLensing, *Nlensing);      \
    564576    free (tmpLensing);                                                  \
     577    ftable[0].buffer = NULL;                                            \
    565578    *format = DVO_FORMAT_##FORMAT;                                      \
    566579    return (lensing); }
    … …  
    601614int LensingToFtable (FTable *ftable, Lensing *lensing, off_t Nlensing, DVOCatFormat format, int swapFromNative) {
    602615
    603 # define FORMAT_CASE(FORMAT, TYPE)              \
    604     case DVO_FORMAT_##FORMAT: { \
    605       Lensing_##TYPE *tmpLensing; \
    606       tmpLensing = LensingInternalTo_##TYPE (lensing, Nlensing); \
    607         gfits_table_set_Lensing_##TYPE (ftable, tmpLensing, Nlensing, swapFromNative); \
    608       free (tmpLensing); \
    609       break; }
     616# define FORMAT_CASE(FORMAT, TYPE)                                      \
     617  case DVO_FORMAT_##FORMAT: {                                           \
     618    Lensing_##TYPE *tmpLensing;                                         \
     619    tmpLensing = LensingInternalTo_##TYPE (lensing, Nlensing);          \
     620    gfits_table_set_Lensing_##TYPE (ftable, tmpLensing, Nlensing, swapFromNative); \
     621    free (tmpLensing);                                                  \
     622    break; }
    610623
    611624  /* convert from the internal format */
    … …  
    658671    lensobj = Lensobj_PS1_V5_R0_ToInternal (tmpLensobj, *Nlensobj);
    659672    free (tmpLensobj);                                                 
     673    ftable[0].buffer = NULL;
    660674    *format = DVO_FORMAT_PS1_V5;                                       
    661675    return (lensobj); }
    662676
    663 # define SKIPPING_FORMAT(NAME, FORMAT, TYPE)            \
     677# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)                            \
    664678  if (!strcmp (extname, NAME)) {                                        \
    665679    fprintf (stderr, "ERROR: format %s not defined for lensobj, skipping\n", NAME); \
    666     *Nlensobj = 0; \
    667     return NULL; \
    668   }
    669 
    670 # define CONVERT_FORMAT(NAME, FORMAT, TYPE)             \
     680    *Nlensobj = 0;                                                      \
     681    return NULL;                                                        \
     682  }
     683
     684# define CONVERT_FORMAT(NAME, FORMAT, TYPE)                             \
    671685  if (!strcmp (extname, NAME)) {                                        \
    672686    Lensobj_##TYPE *tmpLensobj;                                         \
    … …  
    676690      exit (2);                                                         \
    677691    }                                                                   \
    678     lensobj = Lensobj_##TYPE##_ToInternal (tmpLensobj, *Nlensobj); \
     692    lensobj = Lensobj_##TYPE##_ToInternal (tmpLensobj, *Nlensobj);      \
    679693    free (tmpLensobj);                                                  \
     694    ftable[0].buffer = NULL;                                            \
    680695    *format = DVO_FORMAT_##FORMAT;                                      \
    681696    return (lensobj); }
    … …  
    716731int LensobjToFtable (FTable *ftable, Lensobj *lensobj, off_t Nlensobj, DVOCatFormat format, int swapFromNative) {
    717732
    718 # define FORMAT_CASE(FORMAT, TYPE)              \
    719     case DVO_FORMAT_##FORMAT: { \
    720       Lensobj_##TYPE *tmpLensobj; \
    721       tmpLensobj = LensobjInternalTo_##TYPE (lensobj, Nlensobj); \
    722         gfits_table_set_Lensobj_##TYPE (ftable, tmpLensobj, Nlensobj, swapFromNative); \
    723       free (tmpLensobj); \
    724       break; }
     733# define FORMAT_CASE(FORMAT, TYPE)                                      \
     734  case DVO_FORMAT_##FORMAT: {                                           \
     735    Lensobj_##TYPE *tmpLensobj;                                         \
     736    tmpLensobj = LensobjInternalTo_##TYPE (lensobj, Nlensobj);          \
     737    gfits_table_set_Lensobj_##TYPE (ftable, tmpLensobj, Nlensobj, swapFromNative); \
     738    free (tmpLensobj);                                                  \
     739    break; }
    725740
    726741  /* convert from the internal format */
    … …  
    764779  }
    765780
    766 # define SKIPPING_FORMAT(NAME, FORMAT, TYPE)            \
     781# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)                            \
    767782  if (!strcmp (extname, NAME)) {                                        \
    768783    fprintf (stderr, "ERROR: format %s not defined for starpar, skipping\n", NAME); \
    769     *Nstarpar = 0; \
    770     return NULL; \
    771   }
    772 
    773 # define CONVERT_FORMAT(NAME, FORMAT, TYPE)             \
     784    *Nstarpar = 0;                                                      \
     785    return NULL;                                                        \
     786  }
     787 
     788# define CONVERT_FORMAT(NAME, FORMAT, TYPE)                             \
    774789  if (!strcmp (extname, NAME)) {                                        \
    775790    StarPar_##TYPE *tmpStarPar;                                         \
    … …  
    779794      exit (2);                                                         \
    780795    }                                                                   \
    781     starpar = StarPar_##TYPE##_ToInternal (tmpStarPar, *Nstarpar); \
     796    starpar = StarPar_##TYPE##_ToInternal (tmpStarPar, *Nstarpar);      \
    782797    free (tmpStarPar);                                                  \
     798    ftable[0].buffer = NULL;                                            \
    783799    *format = DVO_FORMAT_##FORMAT;                                      \
    784800    return (starpar); }
    … …  
    819835int StarParToFtable (FTable *ftable, StarPar *starpar, off_t Nstarpar, DVOCatFormat format, int swapFromNative) {
    820836
    821 # define FORMAT_CASE(FORMAT, TYPE)              \
    822     case DVO_FORMAT_##FORMAT: { \
    823       StarPar_##TYPE *tmpStarPar; \
    824       tmpStarPar = StarParInternalTo_##TYPE (starpar, Nstarpar); \
    825         gfits_table_set_StarPar_##TYPE (ftable, tmpStarPar, Nstarpar, swapFromNative); \
    826       free (tmpStarPar); \
    827       break; }
     837# define FORMAT_CASE(FORMAT, TYPE)                                      \
     838  case DVO_FORMAT_##FORMAT: {                                           \
     839    StarPar_##TYPE *tmpStarPar;                                         \
     840    tmpStarPar = StarParInternalTo_##TYPE (starpar, Nstarpar);          \
     841    gfits_table_set_StarPar_##TYPE (ftable, tmpStarPar, Nstarpar, swapFromNative); \
     842    free (tmpStarPar);                                                  \
     843    break; }
    828844
    829845  /* convert from the internal format */
    … …  
    868884  }
    869885
    870 # define SKIPPING_FORMAT(NAME, FORMAT, TYPE)            \
     886# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)                            \
    871887  if (!strcmp (extname, NAME)) {                                        \
    872888    fprintf (stderr, "ERROR: format %s not defined for galphot, skipping\n", NAME); \
    873     *Ngalphot = 0; \
    874     return NULL; \
    875   }
    876 
    877 # define CONVERT_FORMAT(NAME, FORMAT, TYPE)             \
     889    *Ngalphot = 0;                                                      \
     890    return NULL;                                                        \
     891  }
     892
     893# define CONVERT_FORMAT(NAME, FORMAT, TYPE)                             \
    878894  if (!strcmp (extname, NAME)) {                                        \
    879895    GalPhot_##TYPE *tmpGalPhot;                                         \
    … …  
    883899      exit (2);                                                         \
    884900    }                                                                   \
    885     galphot = GalPhot_##TYPE##_ToInternal (tmpGalPhot, *Ngalphot); \
     901    galphot = GalPhot_##TYPE##_ToInternal (tmpGalPhot, *Ngalphot);      \
    886902    free (tmpGalPhot);                                                  \
     903    ftable[0].buffer = NULL;                                            \
    887904    *format = DVO_FORMAT_##FORMAT;                                      \
    888905    return (galphot); }
    … …  
    923940int GalPhotToFtable (FTable *ftable, GalPhot *galphot, off_t Ngalphot, DVOCatFormat format, int swapFromNative) {
    924941
    925 # define FORMAT_CASE(FORMAT, TYPE)              \
    926     case DVO_FORMAT_##FORMAT: { \
    927       GalPhot_##TYPE *tmpGalPhot; \
    928       tmpGalPhot = GalPhotInternalTo_##TYPE (galphot, Ngalphot); \
    929         gfits_table_set_GalPhot_##TYPE (ftable, tmpGalPhot, Ngalphot, swapFromNative); \
    930       free (tmpGalPhot); \
    931       break; }
     942# define FORMAT_CASE(FORMAT, TYPE)                                      \
     943  case DVO_FORMAT_##FORMAT: {                                           \
     944    GalPhot_##TYPE *tmpGalPhot;                                         \
     945    tmpGalPhot = GalPhotInternalTo_##TYPE (galphot, Ngalphot);          \
     946    gfits_table_set_GalPhot_##TYPE (ftable, tmpGalPhot, Ngalphot, swapFromNative); \
     947    free (tmpGalPhot);                                                  \
     948    break; }
    932949
    933950  /* convert from the internal format */
    … …  
    9921009  }
    9931010
    994 # define CONVERT_FORMAT(NAME, FORMAT, TYPE) \
    995   if (!strcmp (extname, NAME)) { \
    996     Image_##TYPE *tmpimage; \
    997     *format = DVO_FORMAT_##FORMAT; \
     1011# define CONVERT_FORMAT(NAME, FORMAT, TYPE)                             \
     1012  if (!strcmp (extname, NAME)) {                                        \
     1013    Image_##TYPE *tmpimage;                                             \
     1014    *format = DVO_FORMAT_##FORMAT;                                      \
    9981015    tmpimage = gfits_table_get_Image_##TYPE (ftable, &Nimage, NULL, NULL); \
    999     if (!tmpimage) { \
    1000       fprintf (stderr, "ERROR: failed to read images\n"); \
    1001       exit (2); \
    1002     } \
     1016    if (!tmpimage) {                                                    \
     1017      fprintf (stderr, "ERROR: failed to read images\n");               \
     1018      exit (2);                                                         \
     1019    }                                                                   \
    10031020    off_t Nalloc = gfits_data_pad_size(Nimage*sizeof(Image));           \
    10041021    ftable[0].buffer = (char *) Image_##TYPE##_ToInternal (tmpimage, Nimage, Nalloc); \
    1005     free (tmpimage); \
    1006     gfits_free_header (theader); \
    1007     gfits_table_mkheader_Image (theader); \
    1008     gfits_modify (theader, "NAXIS2", OFF_T_FMT, 1,  Nimage); \
    1009     theader[0].Naxis[1] = Nimage; \
    1010     ftable[0].datasize = gfits_data_size (theader); \
     1022    free (tmpimage);                                                    \
     1023    gfits_free_header (theader);                                        \
     1024    gfits_table_mkheader_Image (theader);                               \
     1025    gfits_modify (theader, "NAXIS2", OFF_T_FMT, 1,  Nimage);            \
     1026    theader[0].Naxis[1] = Nimage;                                       \
     1027    ftable[0].datasize = gfits_data_size (theader);                     \
    10111028    return (TRUE); }
    10121029
    … …  
    10371054  Nimage = theader[0].Naxis[1];
    10381055
    1039 # define FORMAT_CASE(FORMAT, TYPE)              \
    1040   case DVO_FORMAT_##FORMAT: {                   \
     1056# define FORMAT_CASE(FORMAT, TYPE)                                      \
     1057  case DVO_FORMAT_##FORMAT: {                                           \
    10411058    Image_##TYPE *tmpImage;                                             \
    1042       tmpImage = ImageInternalTo_##TYPE ((Image *) ftable[0].buffer, Nimage); \
    1043         free (ftable[0].buffer);                                        \
    1044         gfits_free_header (ftable->header);                             \
    1045         gfits_table_set_Image_##TYPE (ftable, tmpImage, Nimage, TRUE);  \
    1046           free (tmpImage);                                              \
    1047           break; }
     1059    tmpImage = ImageInternalTo_##TYPE ((Image *) ftable[0].buffer, Nimage); \
     1060    free (ftable[0].buffer);                                            \
     1061    gfits_free_header (ftable->header);                                 \
     1062    gfits_table_set_Image_##TYPE (ftable, tmpImage, Nimage, TRUE);      \
     1063    free (tmpImage);                                                    \
     1064    break; }
    10481065
    10491066  /* convert from the internal format */
    10501067  switch (format) {
    1051       FORMAT_CASE (ELIXIR,          Elixir);
    1052       FORMAT_CASE (LONEOS,          Loneos);
    1053       FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
    1054       FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
    1055       FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
    1056       FORMAT_CASE (PS1_DEV_2,       PS1_DEV_2);
    1057       FORMAT_CASE (PS1_V1,          PS1_V1);
    1058       FORMAT_CASE (PS1_V2,          PS1_V2);
    1059       FORMAT_CASE (PS1_V3,          PS1_V3);
    1060       FORMAT_CASE (PS1_V4,          PS1_V4);
    1061       FORMAT_CASE (PS1_V5,          PS1_V5);
    1062       FORMAT_CASE (PS1_REF,         PS1_REF);
    1063       FORMAT_CASE (PS1_SIM,         PS1_SIM);
     1068    FORMAT_CASE (ELIXIR,            Elixir);
     1069    FORMAT_CASE (LONEOS,            Loneos);
     1070    FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
     1071    FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
     1072    FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
     1073    FORMAT_CASE (PS1_DEV_2,       PS1_DEV_2);
     1074    FORMAT_CASE (PS1_V1,          PS1_V1);
     1075    FORMAT_CASE (PS1_V2,          PS1_V2);
     1076    FORMAT_CASE (PS1_V3,          PS1_V3);
     1077    FORMAT_CASE (PS1_V4,          PS1_V4);
     1078    FORMAT_CASE (PS1_V5,          PS1_V5);
     1079    FORMAT_CASE (PS1_REF,         PS1_REF);
     1080    FORMAT_CASE (PS1_SIM,         PS1_SIM);
    10641081
    10651082# undef FORMAT_CASE
    … …  
    10781095  Nrow = vtable[0].Nrow;
    10791096
    1080 # define FORMAT_CASE(FORMAT, TYPE) \
    1081   case DVO_FORMAT_##FORMAT: { \
    1082       Image_##TYPE *tmpImage; \
    1083       /* convert table rows from internal to external format */ \
    1084       for (i = 0; i < Nrow; i++) { \
    1085           tmpImage = ImageInternalTo_##TYPE ((Image *) vtable[0].buffer[i], 1); \
    1086           gfits_convert_Image_##TYPE (tmpImage, sizeof(Image_##TYPE), 1); \
    1087           free (vtable[0].buffer[i]); \
    1088           vtable[0].buffer[i] = (char *) tmpImage; \
    1089       } \
    1090       /* convert header from old format to new format */ \
    1091       gfits_scan (theader, "NAXIS2", OFF_T_FMT, 1,  &Nimage); \
    1092       gfits_free_header (theader); \
    1093       gfits_table_mkheader_Image_##TYPE (theader); \
    1094       gfits_modify (theader, "NAXIS2", OFF_T_FMT, 1,  Nimage); \
    1095       theader[0].Naxis[1] = Nimage; \
    1096       vtable[0].datasize = gfits_data_size (theader); \
    1097       return (TRUE); }
     1097# define FORMAT_CASE(FORMAT, TYPE)                                      \
     1098  case DVO_FORMAT_##FORMAT: {                                           \
     1099    Image_##TYPE *tmpImage;                                             \
     1100    /* convert table rows from internal to external format */           \
     1101    for (i = 0; i < Nrow; i++) {                                        \
     1102      tmpImage = ImageInternalTo_##TYPE ((Image *) vtable[0].buffer[i], 1); \
     1103      gfits_convert_Image_##TYPE (tmpImage, sizeof(Image_##TYPE), 1);   \
     1104      free (vtable[0].buffer[i]);                                       \
     1105      vtable[0].buffer[i] = (char *) tmpImage;                          \
     1106    }                                                                   \
     1107    /* convert header from old format to new format */                  \
     1108    gfits_scan (theader, "NAXIS2", OFF_T_FMT, 1,  &Nimage);             \
     1109    gfits_free_header (theader);                                        \
     1110    gfits_table_mkheader_Image_##TYPE (theader);                        \
     1111    gfits_modify (theader, "NAXIS2", OFF_T_FMT, 1,  Nimage);            \
     1112    theader[0].Naxis[1] = Nimage;                                       \
     1113    vtable[0].datasize = gfits_data_size (theader);                     \
     1114    return (TRUE); }
    10981115
    10991116
    11001117  /* convert from the internal format */
    11011118  switch (format) {
    1102       FORMAT_CASE (ELIXIR,          Elixir);
    1103       FORMAT_CASE (LONEOS,          Loneos);
    1104       FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
    1105       FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
    1106       FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
    1107       FORMAT_CASE (PS1_DEV_2,       PS1_DEV_2);
    1108       FORMAT_CASE (PS1_V1,          PS1_V1);
    1109       FORMAT_CASE (PS1_V2,          PS1_V2);
    1110       FORMAT_CASE (PS1_V3,          PS1_V3);
    1111       FORMAT_CASE (PS1_V4,          PS1_V4);
    1112       FORMAT_CASE (PS1_V5,          PS1_V5);
    1113       FORMAT_CASE (PS1_REF,         PS1_REF);
    1114       FORMAT_CASE (PS1_SIM,         PS1_SIM);
     1119    FORMAT_CASE (ELIXIR,            Elixir);
     1120    FORMAT_CASE (LONEOS,            Loneos);
     1121    FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
     1122    FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
     1123    FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
     1124    FORMAT_CASE (PS1_DEV_2,       PS1_DEV_2);
     1125    FORMAT_CASE (PS1_V1,          PS1_V1);
     1126    FORMAT_CASE (PS1_V2,          PS1_V2);
     1127    FORMAT_CASE (PS1_V3,          PS1_V3);
     1128    FORMAT_CASE (PS1_V4,          PS1_V4);
     1129    FORMAT_CASE (PS1_V5,          PS1_V5);
     1130    FORMAT_CASE (PS1_REF,         PS1_REF);
     1131    FORMAT_CASE (PS1_SIM,         PS1_SIM);
    11151132
    11161133# undef FORMAT_CASE
Note: See TracChangeset for help on using the changeset viewer.