IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 15035


Ignore:
Timestamp:
Sep 26, 2007, 1:29:18 PM (19 years ago)
Author:
eugene
Message:

major cleanup of I/O formats; use macros for simplifications; add PS1_DEV_1 output format

Location:
trunk/Ohana/src/libdvo
Files:
6 added
2 deleted
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/Ohana/src/libdvo/Makefile

    r13884 r15035  
    2424libdvo: $(LIB)/libdvo.$(ARCH).a $(LIB)/libdvo.$(ARCH).$(DLLTYPE)
    2525
    26 INCS = $(DESTINC)/dvo.h $(DESTINC)/autocode.h
     26DEFS = \
     27$(DESTINC)/loneos_defs.h \
     28$(DESTINC)/elixir_defs.h \
     29$(DESTINC)/panstarrs_dev_0_defs.h \
     30$(DESTINC)/panstarrs_dev_1_defs.h \
     31$(DESTINC)/ps1_dev_1_defs.h
     32
     33INCS = $(DEFS) $(DESTINC)/dvo.h $(DESTINC)/autocode.h
    2734
    2835OBJS = \
    … …  
    5259$(SRC)/dvo_convert_panstarrs_DEV_0.$(ARCH).o \
    5360$(SRC)/dvo_convert_panstarrs_DEV_1.$(ARCH).o \
     61$(SRC)/dvo_convert_PS1_DEV_1.$(ARCH).o \
    5462$(SRC)/skyregion_io.$(ARCH).o    \
    5563$(SRC)/skyregion_gsc.$(ARCH).o    \

  • trunk/Ohana/src/libdvo/include/dvo.h

    r14446 r15035  
    1919/* DVO table formats */
    2020typedef enum {DVO_FORMAT_UNDEF,
    21       DVO_FORMAT_INTERNAL,
    22       DVO_FORMAT_ELIXIR,
    23       DVO_FORMAT_LONEOS,
    24       DVO_FORMAT_PANSTARRS,
    25       DVO_FORMAT_PMTEST,
    26       DVO_FORMAT_PANSTARRS_DEV_0,
    27       DVO_FORMAT_PANSTARRS_DEV_1
     21              DVO_FORMAT_INTERNAL,
     22              DVO_FORMAT_ELIXIR,
     23              DVO_FORMAT_LONEOS,
     24              DVO_FORMAT_PANSTARRS_DEV_0,
     25              DVO_FORMAT_PANSTARRS_DEV_1,
     26              DVO_FORMAT_PS1_DEV_1
    2827} DVOTableFormat;
    2928
    … …  
    3332
    3433typedef enum {
    35     PROJ_NONE, // undefined
    36     PROJ_ZEA, // zenithal
    37     PROJ_ZPL, // zenithal
    38     PROJ_ARC, // zenithal
    39     PROJ_STG, // zenithal
    40     PROJ_SIN, // zenithal
    41     PROJ_TAN, // zenithal
    42     PROJ_DIS, // zenithal (TAN + polyterms)
    43     PROJ_LIN, // cartesian
    44     PROJ_PLY, // cartesian
    45     PROJ_WRP, // cartesian
    46     PROJ_AIT, // pseudocyl
    47     PROJ_GLS, // pseudocyl
    48     PROJ_PAR, // pseudocyl
     34  PROJ_NONE, // undefined
     35  PROJ_ZEA, // zenithal
     36  PROJ_ZPL, // zenithal
     37  PROJ_ARC, // zenithal
     38  PROJ_STG, // zenithal
     39  PROJ_SIN, // zenithal
     40  PROJ_TAN, // zenithal
     41  PROJ_DIS, // zenithal (TAN + polyterms)
     42  PROJ_LIN, // cartesian
     43  PROJ_PLY, // cartesian
     44  PROJ_WRP, // cartesian
     45  PROJ_AIT, // pseudocyl
     46  PROJ_GLS, // pseudocyl
     47  PROJ_PAR, // pseudocyl
    4948} OhanaProjection;
    5049
    … …  
    294293int GetPhotcodeNsecfilt ();
    295294void SetZeroPoint (double ZP);
     295double GetZeroPoint ();
    296296int *GetPhotcodeEquivList (int code, int *nlist);
    297297void ParseColorTerms (char *terms, float *X, int *N);
    … …  
    354354int ImageToVtable (VTable *vtable, Header *theader, int format);
    355355
    356 Image                  *ImageElixirToInternal (ImageElixir *in, int Nvalues);
    357 Image                  *ImageLoneosToInternal (ImageLoneos *in, int Nvalues);
    358 Image                  *ImagePanstarrsToInternal (ImagePanstarrs *in, int Nvalues);
    359 Image                  *ImagePanstarrs_DEV_0_ToInternal (ImagePanstarrs_DEV_0 *in, int Nvalues);
    360 Image                  *ImagePanstarrs_DEV_1_ToInternal (ImagePanstarrs_DEV_1 *in, int Nvalues);
    361 
    362 ImageElixir            *ImageInternalToElixir (Image *in, int Nvalues);
    363 ImageLoneos            *ImageInternalToLoneos (Image *in, int Nvalues);
    364 ImagePanstarrs         *ImageInternalToPanstarrs (Image *in, int Nvalues);
    365 ImagePanstarrs_DEV_0   *ImageInternalToPanstarrs_DEV_0 (Image *in, int Nvalues);
    366 ImagePanstarrs_DEV_1   *ImageInternalToPanstarrs_DEV_1 (Image *in, int Nvalues);
    367 
    368 Average                *AverageLoneosToInternal (AverageLoneos *in, int Nvalues, SecFilt **primary);
    369 Average                *AverageElixirToInternal (AverageElixir *in, int Nvalues, SecFilt **primary);
    370 Average                *AveragePanstarrsToInternal (AveragePanstarrs *in, int Nvalues);
    371 Average                *AveragePanstarrs_DEV_0_ToInternal (AveragePanstarrs_DEV_0 *in, int Nvalues);
    372 Average                *AveragePanstarrs_DEV_1_ToInternal (AveragePanstarrs_DEV_1 *in, int Nvalues);
    373 
    374 AverageLoneos          *AverageInternalToLoneos (Average *in, int Nvalues, SecFilt *primary);
    375 AverageElixir          *AverageInternalToElixir (Average *in, int Nvalues, SecFilt *primary);
    376 AveragePanstarrs       *AverageInternalToPanstarrs (Average *in, int Nvalues);
    377 AveragePanstarrs_DEV_0 *AverageInternalToPanstarrs_DEV_0 (Average *in, int Nvalues);
    378 AveragePanstarrs_DEV_1 *AverageInternalToPanstarrs_DEV_1 (Average *in, int Nvalues);
    379 
    380 Measure                *MeasureLoneosToInternal (MeasureLoneos *in, int Nvalues);
    381 Measure                *MeasureElixirToInternal (MeasureElixir *in, int Nvalues);
    382 Measure                *MeasurePanstarrsToInternal (MeasurePanstarrs *in, int Nvalues);
    383 Measure                *MeasurePanstarrs_DEV_0_ToInternal (MeasurePanstarrs_DEV_0 *in, int Nvalues);
    384 Measure                *MeasurePanstarrs_DEV_1_ToInternal (MeasurePanstarrs_DEV_1 *in, int Nvalues);
    385 
    386 MeasureLoneos          *MeasureInternalToLoneos (Measure *in, int Nvalues);
    387 MeasureElixir          *MeasureInternalToElixir (Measure *in, int Nvalues);
    388 MeasurePanstarrs       *MeasureInternalToPanstarrs (Measure *in, int Nvalues);
    389 MeasurePanstarrs_DEV_0 *MeasureInternalToPanstarrs_DEV_0 (Measure *in, int Nvalues);
    390 MeasurePanstarrs_DEV_1 *MeasureInternalToPanstarrs_DEV_1 (Measure *in, int Nvalues);
    391 
    392 SecFilt                *SecFiltLoneosToInternal (SecFiltLoneos *in, int Nvalues);
    393 SecFilt                *SecFiltElixirToInternal (SecFiltElixir *in, int Nvalues);
    394 SecFilt                *SecFiltPanstarrsToInternal (SecFiltPanstarrs *in, int Nvalues);
    395 SecFilt                *SecFiltPanstarrs_DEV_0_ToInternal (SecFiltPanstarrs_DEV_0 *in, int Nvalues);
    396 SecFilt                *SecFiltPanstarrs_DEV_1_ToInternal (SecFiltPanstarrs_DEV_1 *in, int Nvalues);
    397 
    398 SecFiltLoneos          *SecFiltInternalToLoneos (SecFilt *in, int Nvalues);
    399 SecFiltElixir          *SecFiltInternalToElixir (SecFilt *in, int Nvalues);
    400 SecFiltPanstarrs       *SecFiltInternalToPanstarrs (SecFilt *in, int Nvalues);
    401 SecFiltPanstarrs_DEV_0 *SecFiltInternalToPanstarrs_DEV_0 (SecFilt *in, int Nvalues);
    402 SecFiltPanstarrs_DEV_1 *SecFiltInternalToPanstarrs_DEV_1 (SecFilt *in, int Nvalues);
     356# include "loneos_defs.h"
     357# include "elixir_defs.h"
     358# include "panstarrs_dev_0_defs.h"
     359# include "panstarrs_dev_1_defs.h"
     360# include "ps1_dev_1_defs.h"
    403361
    404362/*** DVO image db I/O Functions ***/

  • trunk/Ohana/src/libdvo/src/dvo_catalog.c

    r14450 r15035  
    4545 
    4646  /* set the specified CATFORMAT */
    47   if (!strcasecmp (catformat, "INTERNAL"))  return (DVO_FORMAT_INTERNAL);
    48   if (!strcasecmp (catformat, "LONEOS"))    return (DVO_FORMAT_LONEOS);
    49   if (!strcasecmp (catformat, "ELIXIR"))    return (DVO_FORMAT_ELIXIR);
    50   if (!strcasecmp (catformat, "PANSTARRS")) return (DVO_FORMAT_PANSTARRS);
    51   if (!strcasecmp (catformat, "PMTEST"))    return (DVO_FORMAT_PMTEST);
     47  if (!strcasecmp (catformat, "INTERNAL"))        return (DVO_FORMAT_INTERNAL);
     48  if (!strcasecmp (catformat, "LONEOS"))          return (DVO_FORMAT_LONEOS);
     49  if (!strcasecmp (catformat, "ELIXIR"))          return (DVO_FORMAT_ELIXIR);
    5250  if (!strcasecmp (catformat, "PANSTARRS_DEV_0")) return (DVO_FORMAT_PANSTARRS_DEV_0);
    5351  if (!strcasecmp (catformat, "PANSTARRS_DEV_1")) return (DVO_FORMAT_PANSTARRS_DEV_1);
     52  if (!strcasecmp (catformat, "PS1_DEV_1"))       return (DVO_FORMAT_PS1_DEV_1);
    5453  return (DVO_FORMAT_UNDEF);
    5554}

  • trunk/Ohana/src/libdvo/src/dvo_catalog_raw.c

    r13884 r15035  
    5050  return (FALSE);
    5151
     52// this macro generates the case statements for each type
     53# define FORMAT_CASE(NAME,TYPE) \
     54  case DVO_FORMAT_##NAME: { \
     55    AverageSize = sizeof(Average_##TYPE); \
     56    MeasureSize = sizeof(Measure_##TYPE); \
     57    SecFiltSize = sizeof(SecFilt_##TYPE); \
     58    break; }
     59
    5260got_format:
    5361  /* determine datatype sizes */
    5462  switch (catalog[0].catformat) {
    55     case DVO_FORMAT_INTERNAL:
     63    case DVO_FORMAT_INTERNAL: {
    5664      AverageSize = sizeof(Average);
    5765      MeasureSize = sizeof(Measure);
    5866      SecFiltSize = sizeof(SecFilt);
    5967      break;
    60     case DVO_FORMAT_LONEOS:
    61       AverageSize = sizeof(AverageLoneos);
    62       MeasureSize = sizeof(MeasureLoneos);
    63       SecFiltSize = sizeof(SecFiltLoneos);
    64       break;
    65     case DVO_FORMAT_ELIXIR:
    66       AverageSize = sizeof(AverageElixir);
    67       MeasureSize = sizeof(MeasureElixir);
    68       SecFiltSize = sizeof(SecFiltElixir);
    69       break;
    70     case DVO_FORMAT_PANSTARRS_DEV_0:
    71       AverageSize = sizeof(AveragePanstarrs_DEV_0);
    72       MeasureSize = sizeof(MeasurePanstarrs_DEV_0);
    73       SecFiltSize = sizeof(SecFiltPanstarrs_DEV_0);
    74       break;
    75     case DVO_FORMAT_PANSTARRS_DEV_1:
    76       AverageSize = sizeof(AveragePanstarrs_DEV_1);
    77       MeasureSize = sizeof(MeasurePanstarrs_DEV_1);
    78       SecFiltSize = sizeof(SecFiltPanstarrs_DEV_1);
    79       break;
    80 # if 0
    81     case DVO_FORMAT_PANSTARRS:
    82       AverageSize = sizeof(AveragePanstarrs);
    83       MeasureSize = sizeof(MeasurePanstarrs);
    84       SecFiltSize = sizeof(SecFiltPanstarrs);
    85       break;
    86     case DVO_FORMAT_PMTEST:
    87       AverageSize = sizeof(AveragePMtest);
    88       MeasureSize = sizeof(MeasurePanstarrs);
    89       SecFiltSize = sizeof(SecFiltPanstarrs);
    90       break;
    91 # endif
     68    }
     69
     70      FORMAT_CASE (LONEOS, Loneos);
     71      FORMAT_CASE (ELIXIR, Elixir);
     72      FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
     73      FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
     74      FORMAT_CASE (PS1_DEV_1, PS1_DEV_1);
     75
    9276    default:
    9377      fprintf (stderr, "programming error in phot_catalog_raw\n");
    9478      exit (2);
    9579  }
     80# undef FORMAT_CASE
     81
    9682  MissingSize = sizeof (Missing);
    9783
    … …  
    263249
    264250  /* specify the appropriate data format */
    265   if (catalog[0].catformat == DVO_FORMAT_INTERNAL)  gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "INTERNAL");
    266   if (catalog[0].catformat == DVO_FORMAT_LONEOS)    gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "LONEOS");
    267   if (catalog[0].catformat == DVO_FORMAT_ELIXIR)    gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "ELIXIR");
     251  if (catalog[0].catformat == DVO_FORMAT_INTERNAL)        gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "INTERNAL");
     252  if (catalog[0].catformat == DVO_FORMAT_LONEOS)          gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "LONEOS");
     253  if (catalog[0].catformat == DVO_FORMAT_ELIXIR)          gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "ELIXIR");
    268254  if (catalog[0].catformat == DVO_FORMAT_PANSTARRS_DEV_0) gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PANSTARRS_DEV_0");
    269255  if (catalog[0].catformat == DVO_FORMAT_PANSTARRS_DEV_1) gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PANSTARRS_DEV_1");
    270   // if (catalog[0].catformat == DVO_FORMAT_PANSTARRS) gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PANSTARRS");
    271   // if (catalog[0].catformat == DVO_FORMAT_PMTEST)    gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PMTEST");
     256  if (catalog[0].catformat == DVO_FORMAT_PS1_DEV_1)       gfits_modify (&catalog[0].header, "FORMAT", "%s", 1, "PS1_DEV_1");
    272257
    273258  /* rewind file pointers and truncate file */
    … …  
    322307/** Average / Raw Table conversions **/
    323308
     309/* in the Elixir and Loneos cases, we are supplied with an average magnitude in Average
     310   in these cases, save these values in primary; otherwise set primary to NULL */
     311
    324312Average *ReadRawAverage (FILE *f, int Naverage, int format, SecFilt **primary) {
    325313
    326   int nitems;
    327314  Average *average;
    328315
    329   /* in the Elixir and Loneos cases, we are supplied with an average magnitude in Average
    330      in these cases, save these values in primary; otherwise set primary to NULL */
    331316  *primary = NULL;
    332317
     318// this macro generates the case statements for each type
     319# define FORMAT_CASE(NAME,TYPE) \
     320    case DVO_FORMAT_##NAME: { \
     321      int nitems; \
     322      Average_##TYPE *tmpAverage; \
     323      ALLOCATE (tmpAverage, Average_##TYPE, MAX (Naverage, 1)); \
     324      nitems = fread (tmpAverage, sizeof(Average_##TYPE), Naverage, f); \
     325      if (nitems != Naverage) { \
     326        fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage); \
     327        return (NULL); \
     328      } \
     329      gfits_convert_Average_##TYPE (tmpAverage, sizeof(Average_##TYPE), Naverage); \
     330      average = Average_##TYPE##_ToInternal (tmpAverage, Naverage, primary); \
     331      free (tmpAverage); \
     332      break; } \
     333
    333334  switch (format) {
    334335    case DVO_FORMAT_INTERNAL: {
     336      int nitems;
    335337      ALLOCATE (average, Average, MAX (Naverage, 1));
    336338      nitems = fread (average, sizeof(Average), Naverage, f);
    … …  
    341343      gfits_convert_Average (average, sizeof(Average), Naverage);
    342344      break; }
    343     case DVO_FORMAT_ELIXIR: {
    344       AverageElixir *tmpAverage;
    345       ALLOCATE (tmpAverage, AverageElixir, MAX (Naverage, 1));
    346       nitems = fread (tmpAverage, sizeof(AverageElixir), Naverage, f);
    347       if (nitems != Naverage) {
    348         fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
    349         return (NULL);
    350       }
    351       gfits_convert_AverageElixir (tmpAverage, sizeof(AverageElixir), Naverage);
    352       average = AverageElixirToInternal (tmpAverage, Naverage, primary);
    353       free (tmpAverage);
    354       break; }
    355     case DVO_FORMAT_LONEOS: {
    356       AverageLoneos *tmpAverage;
    357       ALLOCATE (tmpAverage, AverageLoneos, MAX (Naverage, 1));
    358       nitems = fread (tmpAverage, sizeof(AverageLoneos), Naverage, f);
    359       if (nitems != Naverage) {
    360         fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
    361         return (NULL);
    362       }
    363       gfits_convert_AverageLoneos (tmpAverage, sizeof(AverageLoneos), Naverage);
    364       average = AverageLoneosToInternal (tmpAverage, Naverage, primary);
    365       free (tmpAverage);
    366       break; }
    367     case DVO_FORMAT_PANSTARRS_DEV_0: {
    368       AveragePanstarrs_DEV_0 *tmpAverage;
    369       ALLOCATE (tmpAverage, AveragePanstarrs_DEV_0, MAX (Naverage, 1));
    370       nitems = fread (tmpAverage, sizeof(AveragePanstarrs_DEV_0), Naverage, f);
    371       if (nitems != Naverage) {
    372         fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
    373         return (NULL);
    374       }
    375       gfits_convert_AveragePanstarrs_DEV_0 (tmpAverage, sizeof(AveragePanstarrs_DEV_0), Naverage);
    376       average = AveragePanstarrs_DEV_0_ToInternal (tmpAverage, Naverage);
    377       free (tmpAverage);
    378       break; }
    379     case DVO_FORMAT_PANSTARRS_DEV_1: {
    380       AveragePanstarrs_DEV_1 *tmpAverage;
    381       ALLOCATE (tmpAverage, AveragePanstarrs_DEV_1, MAX (Naverage, 1));
    382       nitems = fread (tmpAverage, sizeof(AveragePanstarrs_DEV_1), Naverage, f);
    383       if (nitems != Naverage) {
    384         fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
    385         return (NULL);
    386       }
    387       gfits_convert_AveragePanstarrs_DEV_1 (tmpAverage, sizeof(AveragePanstarrs_DEV_1), Naverage);
    388       average = AveragePanstarrs_DEV_1_ToInternal (tmpAverage, Naverage);
    389       free (tmpAverage);
    390       break; }
    391 # if 0
    392     case DVO_FORMAT_PANSTARRS: {
    393       AveragePanstarrs *tmpAverage;
    394       ALLOCATE (tmpAverage, AveragePanstarrs, MAX (Naverage, 1));
    395       nitems = fread (tmpAverage, sizeof(AveragePanstarrs), Naverage, f);
    396       if (nitems != Naverage) {
    397         fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
    398         return (NULL);
    399       }
    400       gfits_convert_AveragePanstarrs (tmpAverage, sizeof(AveragePanstarrs), Naverage);
    401       average = AveragePanstarrsToInternal (tmpAverage, Naverage);
    402       free (tmpAverage);
    403       break; }
    404     case DVO_FORMAT_PMTEST: {
    405       AveragePMtest *tmpAverage;
    406       ALLOCATE (tmpAverage, AveragePMtest, MAX (Naverage, 1));
    407       nitems = fread (tmpAverage, sizeof(AveragePMtest), Naverage, f);
    408       if (nitems != Naverage) {
    409         fprintf (stderr, "failed to read averages (%d vs %d)\n", nitems, Naverage);
    410         return (NULL);
    411       }
    412       gfits_convert_AveragePMtest (tmpAverage, sizeof(AveragePMtest), Naverage);
    413       average = AveragePMtestToInternal (tmpAverage, Naverage);
    414       free (tmpAverage);
    415       break; }
    416 # endif
     345
     346      FORMAT_CASE (LONEOS, Loneos);
     347      FORMAT_CASE (ELIXIR, Elixir);
     348      FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
     349      FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
     350      FORMAT_CASE (PS1_DEV_1, PS1_DEV_1);
     351
    417352    default:
    418353      fprintf (stderr, "error reading measures\n");
    419354      return (NULL);
    420355  }
     356# undef FORMAT_CASE
     357
    421358  return (average);
    422359}
    … …  
    426363int WriteRawAverage (FILE *f, Average *average, int Naverage, int format, SecFilt *primary) {
    427364
    428   int nitems;
     365// this macro generates the case statements for each type
     366# define FORMAT_CASE(NAME,TYPE) \
     367    case DVO_FORMAT_##NAME: { \
     368      int nitems; \
     369      Average_##TYPE *tmpAverage; \
     370      tmpAverage = AverageInternalTo_##TYPE (average, Naverage, primary); \
     371      gfits_convert_Average_##TYPE (tmpAverage, sizeof(Average_##TYPE), Naverage); \
     372      nitems = fwrite (tmpAverage, sizeof(Average_##TYPE), Naverage, f); \
     373      free (tmpAverage); \
     374      if (nitems != Naverage) { \
     375        fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage); \
     376        return (FALSE); \
     377      } \
     378      break; }
    429379
    430380  switch (format) {
    431381    case DVO_FORMAT_INTERNAL: {
     382      int nitems;
    432383      gfits_convert_Average (average, sizeof(Average), Naverage);
    433384      nitems = fwrite (average, sizeof(Average), Naverage, f);
    … …  
    437388      }
    438389      break; }
    439     case DVO_FORMAT_ELIXIR: {
    440       AverageElixir *tmpAverage;
    441       tmpAverage = AverageInternalToElixir (average, Naverage, primary);
    442       gfits_convert_AverageElixir (tmpAverage, sizeof(AverageElixir), Naverage);
    443       nitems = fwrite (tmpAverage, sizeof(AverageElixir), Naverage, f);
    444       free (tmpAverage);
    445       if (nitems != Naverage) {
    446         fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
    447         return (FALSE);
    448       }
    449       break; }
    450     case DVO_FORMAT_LONEOS: {
    451       AverageLoneos *tmpAverage;
    452       tmpAverage = AverageInternalToLoneos (average, Naverage, primary);
    453       gfits_convert_AverageLoneos (tmpAverage, sizeof(AverageLoneos), Naverage);
    454       nitems = fwrite (tmpAverage, sizeof(AverageLoneos), Naverage, f);
    455       free (tmpAverage);
    456       if (nitems != Naverage) {
    457         fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
    458         return (FALSE);
    459       }
    460       break; }
    461     case DVO_FORMAT_PANSTARRS_DEV_0: {
    462       AveragePanstarrs_DEV_0 *tmpAverage;
    463       tmpAverage = AverageInternalToPanstarrs_DEV_0 (average, Naverage);
    464       gfits_convert_AveragePanstarrs_DEV_0 (tmpAverage, sizeof(AveragePanstarrs_DEV_0), Naverage);
    465       nitems = fwrite (tmpAverage, sizeof(AveragePanstarrs_DEV_0), Naverage, f);
    466       free (tmpAverage);
    467       if (nitems != Naverage) {
    468         fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
    469         return (FALSE);
    470       }
    471       break; }
    472     case DVO_FORMAT_PANSTARRS_DEV_1: {
    473       AveragePanstarrs_DEV_1 *tmpAverage;
    474       tmpAverage = AverageInternalToPanstarrs_DEV_1 (average, Naverage);
    475       gfits_convert_AveragePanstarrs_DEV_1 (tmpAverage, sizeof(AveragePanstarrs_DEV_1), Naverage);
    476       nitems = fwrite (tmpAverage, sizeof(AveragePanstarrs_DEV_1), Naverage, f);
    477       free (tmpAverage);
    478       if (nitems != Naverage) {
    479         fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
    480         return (FALSE);
    481       }
    482       break; }
    483 # if 0
    484     case DVO_FORMAT_PANSTARRS: {
    485       AveragePanstarrs *tmpAverage;
    486       tmpAverage = AverageInternalToPanstarrs (average, Naverage);
    487       gfits_convert_AveragePanstarrs (tmpAverage, sizeof(AveragePanstarrs), Naverage);
    488       nitems = fwrite (tmpAverage, sizeof(AveragePanstarrs), Naverage, f);
    489       free (tmpAverage);
    490       if (nitems != Naverage) {
    491         fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
    492         return (FALSE);
    493       }
    494       break; }
    495     case DVO_FORMAT_PMTEST: {
    496       AveragePMtest *tmpAverage;
    497       tmpAverage = AverageInternalToPMtest (average, Naverage);
    498       gfits_convert_AveragePMtest (tmpAverage, sizeof(AveragePMtest), Naverage);
    499       nitems = fwrite (tmpAverage, sizeof(AveragePMtest), Naverage, f);
    500       free (tmpAverage);
    501       if (nitems != Naverage) {
    502         fprintf (stderr, "failed to write averages (%d vs %d)\n", nitems, Naverage);
    503         return (FALSE);
    504       }
    505       break; }
    506 # endif
     390
     391      FORMAT_CASE (LONEOS, Loneos);
     392      FORMAT_CASE (ELIXIR, Elixir);
     393      FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
     394      FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
     395      FORMAT_CASE (PS1_DEV_1, PS1_DEV_1);
     396
    507397    default:
    508398      fprintf (stderr, "error writing averages\n");
    509399      return (FALSE);
    510400  }
     401# undef FORMAT_CASE
     402
    511403  return (TRUE);
    512404}
    … …  
    516408Measure *ReadRawMeasure (FILE *f, int Nmeasure, int format) {
    517409
    518   int nitems;
    519410  Measure *measure;
    520411
     412// this macro generates the case statements for each type
     413# define FORMAT_CASE(NAME,TYPE) \
     414    case DVO_FORMAT_##NAME: { \
     415      int nitems; \
     416      Measure_##TYPE *tmpMeasure; \
     417      ALLOCATE (tmpMeasure, Measure_##TYPE, MAX (Nmeasure, 1)); \
     418      nitems = fread (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure, f); \
     419      if (nitems != Nmeasure) { \
     420        fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure); \
     421        return (NULL); \
     422      } \
     423      gfits_convert_Measure_##TYPE (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure); \
     424      measure = Measure_##TYPE##_ToInternal (tmpMeasure, Nmeasure); \
     425      free (tmpMeasure); \
     426      break; }
     427
    521428  switch (format) {
    522429    case DVO_FORMAT_INTERNAL: {
     430      int nitems;
    523431      ALLOCATE (measure, Measure, MAX (Nmeasure, 1));
    524432      nitems = fread (measure, sizeof(Measure), Nmeasure, f);
    … …  
    529437      gfits_convert_Measure (measure, sizeof(Measure), Nmeasure);
    530438      break; }
    531     case DVO_FORMAT_ELIXIR: {
    532       MeasureElixir *tmpMeasure;
    533       ALLOCATE (tmpMeasure, MeasureElixir, MAX (Nmeasure, 1));
    534       nitems = fread (tmpMeasure, sizeof(MeasureElixir), Nmeasure, f);
    535       if (nitems != Nmeasure) {
    536         fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
    537         return (NULL);
    538       }
    539       gfits_convert_MeasureElixir (tmpMeasure, sizeof(MeasureElixir), Nmeasure);
    540       measure = MeasureElixirToInternal (tmpMeasure, Nmeasure);
    541       free (tmpMeasure);
    542       break; }
    543     case DVO_FORMAT_LONEOS: {
    544       MeasureLoneos *tmpMeasure;
    545       ALLOCATE (tmpMeasure, MeasureLoneos, MAX (Nmeasure, 1));
    546       nitems = fread (tmpMeasure, sizeof(MeasureLoneos), Nmeasure, f);
    547       if (nitems != Nmeasure) {
    548         fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
    549         return (NULL);
    550       }
    551       gfits_convert_MeasureLoneos (tmpMeasure, sizeof(MeasureLoneos), Nmeasure);
    552       measure = MeasureLoneosToInternal (tmpMeasure, Nmeasure);
    553       free (tmpMeasure);
    554       break; }
    555     case DVO_FORMAT_PANSTARRS_DEV_0: {
    556       MeasurePanstarrs_DEV_0 *tmpMeasure;
    557       ALLOCATE (tmpMeasure, MeasurePanstarrs_DEV_0, MAX (Nmeasure, 1));
    558       nitems = fread (tmpMeasure, sizeof(MeasurePanstarrs_DEV_0), Nmeasure, f);
    559       if (nitems != Nmeasure) {
    560         fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
    561         return (NULL);
    562       }
    563       gfits_convert_MeasurePanstarrs_DEV_0 (tmpMeasure, sizeof(MeasurePanstarrs_DEV_0), Nmeasure);
    564       measure = MeasurePanstarrs_DEV_0_ToInternal (tmpMeasure, Nmeasure);
    565       free (tmpMeasure);
    566       break; }
    567     case DVO_FORMAT_PANSTARRS_DEV_1: {
    568       MeasurePanstarrs_DEV_1 *tmpMeasure;
    569       ALLOCATE (tmpMeasure, MeasurePanstarrs_DEV_1, MAX (Nmeasure, 1));
    570       nitems = fread (tmpMeasure, sizeof(MeasurePanstarrs_DEV_1), Nmeasure, f);
    571       if (nitems != Nmeasure) {
    572         fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
    573         return (NULL);
    574       }
    575       gfits_convert_MeasurePanstarrs_DEV_1 (tmpMeasure, sizeof(MeasurePanstarrs_DEV_1), Nmeasure);
    576       measure = MeasurePanstarrs_DEV_1_ToInternal (tmpMeasure, Nmeasure);
    577       free (tmpMeasure);
    578       break; }
    579 # if 0
    580     case DVO_FORMAT_PANSTARRS: {
    581       MeasurePanstarrs *tmpMeasure;
    582       ALLOCATE (tmpMeasure, MeasurePanstarrs, MAX (Nmeasure, 1));
    583       nitems = fread (tmpMeasure, sizeof(MeasurePanstarrs), Nmeasure, f);
    584       if (nitems != Nmeasure) {
    585         fprintf (stderr, "failed to read measures (%d vs %d)\n", nitems, Nmeasure);
    586         return (NULL);
    587       }
    588       gfits_convert_MeasurePanstarrs (tmpMeasure, sizeof(MeasurePanstarrs), Nmeasure);
    589       measure = MeasurePanstarrsToInternal (tmpMeasure, Nmeasure);
    590       free (tmpMeasure);
    591       break; }
    592 # endif
     439
     440      FORMAT_CASE (LONEOS, Loneos);
     441      FORMAT_CASE (ELIXIR, Elixir);
     442      FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
     443      FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
     444      FORMAT_CASE (PS1_DEV_1, PS1_DEV_1);
     445
    593446    default:
    594447      fprintf (stderr, "error reading measures\n");
    595448      return (NULL);
    596449  }
     450# undef FORMAT_CASE
     451
    597452  return (measure);
    598453}
    … …  
    602457int WriteRawMeasure (FILE *f, Measure *measure, int Nmeasure, int format) {
    603458
    604   int nitems;
     459// this macro generates the case statements for each type
     460# define FORMAT_CASE(NAME,TYPE) \
     461    case DVO_FORMAT_##NAME: { \
     462      int nitems; \
     463      Measure_##TYPE *tmpMeasure; \
     464      tmpMeasure = MeasureInternalTo_##TYPE (measure, Nmeasure); \
     465      gfits_convert_Measure_##TYPE (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure); \
     466      nitems = fwrite (tmpMeasure, sizeof(Measure_##TYPE), Nmeasure, f); \
     467      free (tmpMeasure); \
     468      if (nitems != Nmeasure) { \
     469        fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure); \
     470        return (FALSE); \
     471      } \
     472      break; }
    605473
    606474  switch (format) {
    607475    case DVO_FORMAT_INTERNAL: {
     476      int nitems;
    608477      gfits_convert_Measure (measure, sizeof(Measure), Nmeasure);
    609478      nitems = fwrite (measure, sizeof(Measure), Nmeasure, f);
    … …  
    613482      }
    614483      break; }
    615     case DVO_FORMAT_ELIXIR: {
    616       MeasureElixir *tmpMeasure;
    617       tmpMeasure = MeasureInternalToElixir (measure, Nmeasure);
    618       gfits_convert_MeasureElixir (tmpMeasure, sizeof(MeasureElixir), Nmeasure);
    619       nitems = fwrite (tmpMeasure, sizeof(MeasureElixir), Nmeasure, f);
    620       free (tmpMeasure);
    621       if (nitems != Nmeasure) {
    622         fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
    623         return (FALSE);
    624       }
    625       break; }
    626     case DVO_FORMAT_LONEOS: {
    627       MeasureLoneos *tmpMeasure;
    628       tmpMeasure = MeasureInternalToLoneos (measure, Nmeasure);
    629       gfits_convert_MeasureLoneos (tmpMeasure, sizeof(MeasureLoneos), Nmeasure);
    630       nitems = fwrite (tmpMeasure, sizeof(MeasureLoneos), Nmeasure, f);
    631       free (tmpMeasure);
    632       if (nitems != Nmeasure) {
    633         fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
    634         return (FALSE);
    635       }
    636       break; }
    637     case DVO_FORMAT_PANSTARRS_DEV_0: {
    638       MeasurePanstarrs_DEV_0 *tmpMeasure;
    639       tmpMeasure = MeasureInternalToPanstarrs_DEV_0 (measure, Nmeasure);
    640       gfits_convert_MeasurePanstarrs_DEV_0 (tmpMeasure, sizeof(MeasurePanstarrs_DEV_0), Nmeasure);
    641       nitems = fwrite (tmpMeasure, sizeof(MeasurePanstarrs_DEV_0), Nmeasure, f);
    642       free (tmpMeasure);
    643       if (nitems != Nmeasure) {
    644         fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
    645         return (FALSE);
    646       }
    647       break; }
    648     case DVO_FORMAT_PANSTARRS_DEV_1: {
    649       MeasurePanstarrs_DEV_1 *tmpMeasure;
    650       tmpMeasure = MeasureInternalToPanstarrs_DEV_1 (measure, Nmeasure);
    651       gfits_convert_MeasurePanstarrs_DEV_1 (tmpMeasure, sizeof(MeasurePanstarrs_DEV_1), Nmeasure);
    652       nitems = fwrite (tmpMeasure, sizeof(MeasurePanstarrs_DEV_1), Nmeasure, f);
    653       free (tmpMeasure);
    654       if (nitems != Nmeasure) {
    655         fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
    656         return (FALSE);
    657       }
    658       break; }
    659 # if 0
    660     case DVO_FORMAT_PANSTARRS: {
    661       MeasurePanstarrs *tmpMeasure;
    662       tmpMeasure = MeasureInternalToPanstarrs (measure, Nmeasure);
    663       gfits_convert_MeasurePanstarrs (tmpMeasure, sizeof(MeasurePanstarrs), Nmeasure);
    664       nitems = fwrite (tmpMeasure, sizeof(MeasurePanstarrs), Nmeasure, f);
    665       free (tmpMeasure);
    666       if (nitems != Nmeasure) {
    667         fprintf (stderr, "failed to write measures (%d vs %d)\n", nitems, Nmeasure);
    668         return (FALSE);
    669       }
    670       break; }
    671 # endif
     484
     485      FORMAT_CASE (LONEOS, Loneos);
     486      FORMAT_CASE (ELIXIR, Elixir);
     487      FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
     488      FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
     489      FORMAT_CASE (PS1_DEV_1, PS1_DEV_1);
     490
    672491    default:
    673492      fprintf (stderr, "error writing measures\n");
    674493      return (FALSE);
    675494  }
     495# undef FORMAT_CASE
     496
    676497  return (TRUE);
    677498}
    … …  
    681502SecFilt *ReadRawSecFilt (FILE *f, int Nsecfilt, int format) {
    682503
    683   int nitems;
    684504  SecFilt *secfilt;
    685505
     506// this macro generates the case statements for each type
     507# define FORMAT_CASE(NAME,TYPE) \
     508    case DVO_FORMAT_##NAME: { \
     509      int nitems; \
     510      SecFilt_##TYPE *tmpSecFilt; \
     511      ALLOCATE (tmpSecFilt, SecFilt_##TYPE, MAX (Nsecfilt, 1)); \
     512      nitems = fread (tmpSecFilt, sizeof(SecFilt_##TYPE), Nsecfilt, f); \
     513      if (nitems != Nsecfilt) { \
     514        fprintf (stderr, "failed to read secfilts (%d vs %d)\n", nitems, Nsecfilt); \
     515        return (NULL); \
     516      } \
     517      gfits_convert_SecFilt_##TYPE (tmpSecFilt, sizeof(SecFilt_##TYPE), Nsecfilt); \
     518      secfilt = SecFilt_##TYPE##_ToInternal (tmpSecFilt, Nsecfilt); \
     519      free (tmpSecFilt); \
     520      break; }
     521
    686522  switch (format) {
    687523    case DVO_FORMAT_INTERNAL: {
     524      int nitems;
    688525      ALLOCATE (secfilt, SecFilt, MAX (Nsecfilt, 1));
    689526      nitems = fread (secfilt, sizeof(SecFilt), Nsecfilt, f);
    … …  
    694531      gfits_convert_SecFilt (secfilt, sizeof(SecFilt), Nsecfilt);
    695532      break; }
    696     case DVO_FORMAT_ELIXIR: {
    697       SecFiltElixir *tmpSecFilt;
    698       ALLOCATE (tmpSecFilt, SecFiltElixir, MAX (Nsecfilt, 1));
    699       nitems = fread (tmpSecFilt, sizeof(SecFiltElixir), Nsecfilt, f);
    700       if (nitems != Nsecfilt) {
    701         fprintf (stderr, "failed to read secfilts (%d vs %d)\n", nitems, Nsecfilt);
    702         return (NULL);
    703       }
    704       gfits_convert_SecFiltElixir (tmpSecFilt, sizeof(SecFiltElixir), Nsecfilt);
    705       secfilt = SecFiltElixirToInternal (tmpSecFilt, Nsecfilt);
    706       free (tmpSecFilt);
    707       break; }
    708     case DVO_FORMAT_LONEOS: {
    709       SecFiltLoneos *tmpSecFilt;
    710       ALLOCATE (tmpSecFilt, SecFiltLoneos, MAX (Nsecfilt, 1));
    711       nitems = fread (tmpSecFilt, sizeof(SecFiltLoneos), Nsecfilt, f);
    712       if (nitems != Nsecfilt) {
    713         fprintf (stderr, "failed to read secfilts (%d vs %d)\n", nitems, Nsecfilt);
    714         return (NULL);
    715       }
    716       gfits_convert_SecFiltLoneos (tmpSecFilt, sizeof(SecFiltLoneos), Nsecfilt);
    717       secfilt = SecFiltLoneosToInternal (tmpSecFilt, Nsecfilt);
    718       free (tmpSecFilt);
    719       break; }
    720     case DVO_FORMAT_PANSTARRS_DEV_0: {
    721       SecFiltPanstarrs_DEV_0 *tmpSecFilt;
    722       ALLOCATE (tmpSecFilt, SecFiltPanstarrs_DEV_0, MAX (Nsecfilt, 1));
    723       nitems = fread (tmpSecFilt, sizeof(SecFiltPanstarrs_DEV_0), Nsecfilt, f);
    724       if (nitems != Nsecfilt) {
    725         fprintf (stderr, "failed to read secfilts (%d vs %d)\n", nitems, Nsecfilt);
    726         return (NULL);
    727       }
    728       gfits_convert_SecFiltPanstarrs_DEV_0 (tmpSecFilt, sizeof(SecFiltPanstarrs_DEV_0), Nsecfilt);
    729       secfilt = SecFiltPanstarrs_DEV_0_ToInternal (tmpSecFilt, Nsecfilt);
    730       free (tmpSecFilt);
    731       break; }
    732     case DVO_FORMAT_PANSTARRS_DEV_1: {
    733       SecFiltPanstarrs_DEV_1 *tmpSecFilt;
    734       ALLOCATE (tmpSecFilt, SecFiltPanstarrs_DEV_1, MAX (Nsecfilt, 1));
    735       nitems = fread (tmpSecFilt, sizeof(SecFiltPanstarrs_DEV_1), Nsecfilt, f);
    736       if (nitems != Nsecfilt) {
    737         fprintf (stderr, "failed to read secfilts (%d vs %d)\n", nitems, Nsecfilt);
    738         return (NULL);
    739       }
    740       gfits_convert_SecFiltPanstarrs_DEV_1 (tmpSecFilt, sizeof(SecFiltPanstarrs_DEV_1), Nsecfilt);
    741       secfilt = SecFiltPanstarrs_DEV_1_ToInternal (tmpSecFilt, Nsecfilt);
    742       free (tmpSecFilt);
    743       break; }
    744 # if 0
    745     case DVO_FORMAT_PANSTARRS: {
    746       SecFiltPanstarrs *tmpSecFilt;
    747       ALLOCATE (tmpSecFilt, SecFiltPanstarrs, MAX (Nsecfilt, 1));
    748       nitems = fread (tmpSecFilt, sizeof(SecFiltPanstarrs), Nsecfilt, f);
    749       if (nitems != Nsecfilt) {
    750         fprintf (stderr, "failed to read secfilts (%d vs %d)\n", nitems, Nsecfilt);
    751         return (NULL);
    752       }
    753       gfits_convert_SecFiltPanstarrs (tmpSecFilt, sizeof(SecFiltPanstarrs), Nsecfilt);
    754       secfilt = SecFiltPanstarrsToInternal (tmpSecFilt, Nsecfilt);
    755       free (tmpSecFilt);
    756       break; }
    757 # endif
     533
     534      FORMAT_CASE (LONEOS, Loneos);
     535      FORMAT_CASE (ELIXIR, Elixir);
     536      FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
     537      FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
     538      FORMAT_CASE (PS1_DEV_1, PS1_DEV_1);
     539
    758540    default:
    759541      fprintf (stderr, "error reading measures\n");
    760542      return (NULL);
    761543  }
     544# undef FORMAT_CASE
     545
    762546  return (secfilt);
    763547}
    … …  
    767551int WriteRawSecFilt (FILE *f, SecFilt *secfilt, int Nsecfilt, int format) {
    768552
    769   int nitems;
     553// this macro generates the case statements for each type
     554# define FORMAT_CASE(NAME,TYPE) \
     555    case DVO_FORMAT_##NAME: { \
     556      int nitems; \
     557      SecFilt_##TYPE *tmpSecFilt; \
     558      tmpSecFilt = SecFiltInternalTo_##TYPE (secfilt, Nsecfilt); \
     559      gfits_convert_SecFilt_##TYPE (tmpSecFilt, sizeof(SecFilt_##TYPE), Nsecfilt); \
     560      nitems = fwrite (tmpSecFilt, sizeof(SecFilt_##TYPE), Nsecfilt, f); \
     561      free (tmpSecFilt); \
     562      if (nitems != Nsecfilt) { \
     563        fprintf (stderr, "failed to write secfilts (%d vs %d)\n", nitems, Nsecfilt); \
     564        return (FALSE); \
     565      } \
     566      break; }
    770567
    771568  switch (format) {
    772569    case DVO_FORMAT_INTERNAL: {
     570      int nitems;
    773571      gfits_convert_SecFilt (secfilt, sizeof(SecFilt), Nsecfilt);
    774572      nitems = fwrite (secfilt, sizeof(SecFilt), Nsecfilt, f);
    … …  
    778576      }
    779577      break; }
    780     case DVO_FORMAT_ELIXIR: {
    781       SecFiltElixir *tmpSecFilt;
    782       tmpSecFilt = SecFiltInternalToElixir (secfilt, Nsecfilt);
    783       gfits_convert_SecFiltElixir (tmpSecFilt, sizeof(SecFiltElixir), Nsecfilt);
    784       nitems = fwrite (tmpSecFilt, sizeof(SecFiltElixir), Nsecfilt, f);
    785       free (tmpSecFilt);
    786       if (nitems != Nsecfilt) {
    787         fprintf (stderr, "failed to write secfilts (%d vs %d)\n", nitems, Nsecfilt);
    788         return (FALSE);
    789       }
    790       break; }
    791     case DVO_FORMAT_LONEOS: {
    792       SecFiltLoneos *tmpSecFilt;
    793       tmpSecFilt = SecFiltInternalToLoneos (secfilt, Nsecfilt);
    794       gfits_convert_SecFiltLoneos (tmpSecFilt, sizeof(SecFiltLoneos), Nsecfilt);
    795       nitems = fwrite (tmpSecFilt, sizeof(SecFiltLoneos), Nsecfilt, f);
    796       free (tmpSecFilt);
    797       if (nitems != Nsecfilt) {
    798         fprintf (stderr, "failed to write secfilts (%d vs %d)\n", nitems, Nsecfilt);
    799         return (FALSE);
    800       }
    801       break; }
    802     case DVO_FORMAT_PANSTARRS_DEV_0: {
    803       SecFiltPanstarrs_DEV_0 *tmpSecFilt;
    804       tmpSecFilt = SecFiltInternalToPanstarrs_DEV_0 (secfilt, Nsecfilt);
    805       gfits_convert_SecFiltPanstarrs_DEV_0 (tmpSecFilt, sizeof(SecFiltPanstarrs_DEV_0), Nsecfilt);
    806       nitems = fwrite (tmpSecFilt, sizeof(SecFiltPanstarrs_DEV_0), Nsecfilt, f);
    807       free (tmpSecFilt);
    808       if (nitems != Nsecfilt) {
    809         fprintf (stderr, "failed to write secfilts (%d vs %d)\n", nitems, Nsecfilt);
    810         return (FALSE);
    811       }
    812       break; }
    813     case DVO_FORMAT_PANSTARRS_DEV_1: {
    814       SecFiltPanstarrs_DEV_1 *tmpSecFilt;
    815       tmpSecFilt = SecFiltInternalToPanstarrs_DEV_1 (secfilt, Nsecfilt);
    816       gfits_convert_SecFiltPanstarrs_DEV_1 (tmpSecFilt, sizeof(SecFiltPanstarrs_DEV_1), Nsecfilt);
    817       nitems = fwrite (tmpSecFilt, sizeof(SecFiltPanstarrs_DEV_1), Nsecfilt, f);
    818       free (tmpSecFilt);
    819       if (nitems != Nsecfilt) {
    820         fprintf (stderr, "failed to write secfilts (%d vs %d)\n", nitems, Nsecfilt);
    821         return (FALSE);
    822       }
    823       break; }
    824 # if 0
    825     case DVO_FORMAT_PANSTARRS: {
    826       SecFiltPanstarrs *tmpSecFilt;
    827       tmpSecFilt = SecFiltInternalToPanstarrs (secfilt, Nsecfilt);
    828       gfits_convert_SecFiltPanstarrs (tmpSecFilt, sizeof(SecFiltPanstarrs), Nsecfilt);
    829       nitems = fwrite (tmpSecFilt, sizeof(SecFiltPanstarrs), Nsecfilt, f);
    830       free (tmpSecFilt);
    831       if (nitems != Nsecfilt) {
    832         fprintf (stderr, "failed to write secfilts (%d vs %d)\n", nitems, Nsecfilt);
    833         return (FALSE);
    834       }
    835       break; }
    836 # endif
     578
     579      FORMAT_CASE (LONEOS, Loneos);
     580      FORMAT_CASE (ELIXIR, Elixir);
     581      FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
     582      FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
     583      FORMAT_CASE (PS1_DEV_1, PS1_DEV_1);
     584
    837585    default:
    838586      fprintf (stderr, "error writing secfilts\n");
    839587      return (FALSE);
    840588  }
     589# undef FORMAT_CASE
     590
    841591  return (TRUE);
    842592}

  • trunk/Ohana/src/libdvo/src/dvo_convert.c

    r13884 r15035  
    2727    return (FALSE);
    2828  }
     29
     30# define CONVERT_FORMAT(NAME, FORMAT, TYPE) \
     31  if (!strcmp (extname, NAME)) { \
     32    Average_##TYPE *tmpAverage; \
     33    tmpAverage = gfits_table_get_Average_##TYPE (ftable, Naverage, NULL); \
     34    average = Average_##TYPE##_ToInternal (tmpAverage, *Naverage, primary); \
     35    free (tmpAverage); \
     36    *format = DVO_FORMAT_##FORMAT; \
     37    return (average); }
     38
    2939  if (!strcmp (extname, "DVO_AVERAGE")) {
    3040    average = gfits_table_get_Average (ftable, Naverage, NULL);
    … …  
    3242    return (average);
    3343  }
    34   if (!strcmp (extname, "DVO_AVERAGE_ELIXIR")) {
    35     AverageElixir *tmpAverage;
    36     tmpAverage = gfits_table_get_AverageElixir (ftable, Naverage, NULL);
    37     average = AverageElixirToInternal (tmpAverage, *Naverage, primary);
    38     free (tmpAverage);
    39     *format = DVO_FORMAT_ELIXIR;
    40     return (average);
    41   }
    42   if (!strcmp (extname, "DVO_AVERAGE_LONEOS")) {
    43     AverageLoneos *tmpAverage;
    44     tmpAverage = gfits_table_get_AverageLoneos (ftable, Naverage, NULL);
    45     average = AverageLoneosToInternal (tmpAverage, *Naverage, primary);
    46     free (tmpAverage);
    47     *format = DVO_FORMAT_LONEOS;
    48     return (average);
    49   }
    50   if (!strcmp (extname, "DVO_AVERAGE_PANSTARRS_DEV_0")) {
    51     AveragePanstarrs_DEV_0 *tmpAverage;
    52     tmpAverage = gfits_table_get_AveragePanstarrs_DEV_0 (ftable, Naverage, NULL);
    53     average = AveragePanstarrs_DEV_0_ToInternal (tmpAverage, *Naverage);
    54     free (tmpAverage);
    55     *format = DVO_FORMAT_PANSTARRS_DEV_0;
    56     return (average);
    57   }
    58   if (!strcmp (extname, "DVO_AVERAGE_PANSTARRS_DEV_1")) {
    59     AveragePanstarrs_DEV_1 *tmpAverage;
    60     tmpAverage = gfits_table_get_AveragePanstarrs_DEV_1 (ftable, Naverage, NULL);
    61     average = AveragePanstarrs_DEV_1_ToInternal (tmpAverage, *Naverage);
    62     free (tmpAverage);
    63     *format = DVO_FORMAT_PANSTARRS_DEV_1;
    64     return (average);
    65   }
    66 /* disable the new and minimally-used versions for now. 
    67    put them back in after dev work is further along
    68    OR replace with other output formats */
    69 # if 0
    70   if (!strcmp (extname, "DVO_AVERAGE_PANSTARRS")) {
    71     AveragePanstarrs *tmpAverage;
    72     tmpAverage = gfits_table_get_AveragePanstarrs (ftable, Naverage, NULL);
    73     average = AveragePanstarrsToInternal (tmpAverage, *Naverage);
    74     free (tmpAverage);
    75     *format = DVO_FORMAT_PANSTARRS;
    76     return (average);
    77   }
    78   if (!strcmp (extname, "DVO_AVERAGE_PMTEST")) {
    79     AveragePMtest *tmpAverage;
    80     tmpAverage = gfits_table_get_AveragePMtest (ftable, Naverage, NULL);
    81     average = AveragePMtestToInternal (tmpAverage, *Naverage);
    82     free (tmpAverage);
    83     *format = DVO_FORMAT_PMTEST;
    84     return (average);
    85   }
    86 # endif
     44
     45  CONVERT_FORMAT ("DVO_AVERAGE_ELIXIR",          ELIXIR,          Elixir);
     46  CONVERT_FORMAT ("DVO_AVERAGE_LONEOS",          LONEOS,          Loneos);
     47  CONVERT_FORMAT ("DVO_AVERAGE_PANSTARRS_DEV_0", PANSTARRS_DEV_0, Panstarrs_DEV_0);
     48  CONVERT_FORMAT ("DVO_AVERAGE_PANSTARRS_DEV_1", PANSTARRS_DEV_1, Panstarrs_DEV_1);
     49  CONVERT_FORMAT ("DVO_AVERAGE_PS1_DEV_1",       PS1_DEV_1,       PS1_DEV_1);
     50# undef CONVERT_FORMAT
    8751
    8852  fprintf (stderr, "table format unknown: %s\n", extname);
    … …  
    9458int AverageToFtable (FTable *ftable, Average *average, int Naverage, int format, SecFilt *primary) {
    9559
     60# define FORMAT_CASE(FORMAT, TYPE) \
     61    case DVO_FORMAT_##FORMAT: { \
     62      Average_##TYPE *tmpAverage; \
     63      tmpAverage = AverageInternalTo_##TYPE (average, Naverage, primary); \
     64      gfits_table_set_Average_##TYPE (ftable, tmpAverage, Naverage); \
     65      free (tmpAverage); \
     66      break; }
    9667
    9768  /* convert from the internal format */
    … …  
    10071      gfits_table_set_Average (ftable, average, Naverage);
    10172      break; }
    102     case DVO_FORMAT_ELIXIR: {
    103       AverageElixir *tmpAverage;
    104       tmpAverage = AverageInternalToElixir (average, Naverage, primary);
    105       gfits_table_set_AverageElixir (ftable, tmpAverage, Naverage);
    106       free (tmpAverage);
    107       break; }
    108     case DVO_FORMAT_LONEOS: {
    109       AverageLoneos *tmpAverage ;
    110       tmpAverage  = AverageInternalToLoneos (average, Naverage, primary);
    111       gfits_table_set_AverageLoneos (ftable, tmpAverage, Naverage);
    112       free (tmpAverage );
    113       break; }
    114     case DVO_FORMAT_PANSTARRS_DEV_0: {
    115       AveragePanstarrs_DEV_0 *tmpAverage;
    116       tmpAverage = AverageInternalToPanstarrs_DEV_0 (average, Naverage);
    117       gfits_table_set_AveragePanstarrs_DEV_0 (ftable, tmpAverage, Naverage);
    118       free (tmpAverage);
    119       break; }
    120     case DVO_FORMAT_PANSTARRS_DEV_1: {
    121       AveragePanstarrs_DEV_1 *tmpAverage;
    122       tmpAverage = AverageInternalToPanstarrs_DEV_1 (average, Naverage);
    123       gfits_table_set_AveragePanstarrs_DEV_1 (ftable, tmpAverage, Naverage);
    124       free (tmpAverage);
    125       break; }
    126 # if 0
    127     case DVO_FORMAT_PANSTARRS: {
    128       AveragePanstarrs *tmpAverage;
    129       tmpAverage = AverageInternalToPanstarrs (average, Naverage);
    130       gfits_table_set_AveragePanstarrs (ftable, tmpAverage, Naverage);
    131       free (tmpAverage);
    132       break; }
    133     case DVO_FORMAT_PMTEST: {
    134       AveragePMtest *tmpAverage;
    135       tmpAverage = AverageInternalToPMtest (average, Naverage);
    136       gfits_table_set_AveragePMtest (ftable, tmpAverage, Naverage);
    137       free (tmpAverage);
    138       break; }
    139 # endif
     73
     74      FORMAT_CASE (ELIXIR,          Elixir);
     75      FORMAT_CASE (LONEOS,          Loneos);
     76      FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
     77      FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
     78      FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
     79# undef FORMAT_CASE
     80
    14081    default:
    14182      fprintf (stderr, "table format unknown (average)\n");
    … …  
    15798    return (FALSE);
    15899  }
     100
     101# define CONVERT_FORMAT(NAME, FORMAT, TYPE) \
     102  if (!strcmp (extname, NAME)) { \
     103    Measure_##TYPE *tmpMeasure; \
     104    tmpMeasure = gfits_table_get_Measure_##TYPE (ftable, Nmeasure, NULL); \
     105    measure = Measure_##TYPE##_ToInternal (tmpMeasure, *Nmeasure); \
     106    free (tmpMeasure); \
     107    *format = DVO_FORMAT_##FORMAT; \
     108    return (measure); }
     109
    159110  if (!strcmp (extname, "DVO_MEASURE")) {
    160111    measure = gfits_table_get_Measure (ftable, Nmeasure, NULL);
    … …  
    162113    return (measure);
    163114  }
    164   if (!strcmp (extname, "DVO_MEASURE_ELIXIR")) {
    165     MeasureElixir *tmpMeasure;
    166     tmpMeasure = gfits_table_get_MeasureElixir (ftable, Nmeasure, NULL);
    167     measure = MeasureElixirToInternal (tmpMeasure, *Nmeasure);
    168     free (tmpMeasure);
    169     *format = DVO_FORMAT_ELIXIR;
    170     return (measure);
    171   }
    172   if (!strcmp (extname, "DVO_MEASURE_LONEOS")) {
    173     MeasureLoneos *tmpMeasure;
    174     tmpMeasure = gfits_table_get_MeasureLoneos (ftable, Nmeasure, NULL);
    175     measure = MeasureLoneosToInternal (tmpMeasure, *Nmeasure);
    176     free (tmpMeasure);
    177     *format = DVO_FORMAT_LONEOS;
    178     return (measure);
    179   }
    180   if (!strcmp (extname, "DVO_MEASURE_PANSTARRS_DEV_0")) {
    181     MeasurePanstarrs_DEV_0 *tmpMeasure;
    182     tmpMeasure = gfits_table_get_MeasurePanstarrs_DEV_0 (ftable, Nmeasure, NULL);
    183     measure = MeasurePanstarrs_DEV_0_ToInternal (tmpMeasure, *Nmeasure);
    184     free (tmpMeasure);
    185     *format = DVO_FORMAT_PANSTARRS_DEV_0;
    186     return (measure);
    187   }
    188   if (!strcmp (extname, "DVO_MEASURE_PANSTARRS_DEV_1")) {
    189     MeasurePanstarrs_DEV_1 *tmpMeasure;
    190     tmpMeasure = gfits_table_get_MeasurePanstarrs_DEV_1 (ftable, Nmeasure, NULL);
    191     measure = MeasurePanstarrs_DEV_1_ToInternal (tmpMeasure, *Nmeasure);
    192     free (tmpMeasure);
    193     *format = DVO_FORMAT_PANSTARRS_DEV_1;
    194     return (measure);
    195   }
    196 # if 0
    197   if (!strcmp (extname, "DVO_MEASURE_PANSTARRS") || !strcmp (extname, "DVO_MEASURE_PMTEST")) {
    198     MeasurePanstarrs *tmpMeasure;
    199     tmpMeasure = gfits_table_get_MeasurePanstarrs (ftable, Nmeasure, NULL);
    200     measure = MeasurePanstarrsToInternal (tmpMeasure, *Nmeasure);
    201     free (tmpMeasure);
    202     *format = DVO_FORMAT_PANSTARRS;
    203     return (measure);
    204   }
    205 # endif
     115
     116  CONVERT_FORMAT ("DVO_MEASURE_ELIXIR",          ELIXIR,          Elixir);
     117  CONVERT_FORMAT ("DVO_MEASURE_LONEOS",          LONEOS,          Loneos);
     118  CONVERT_FORMAT ("DVO_MEASURE_PANSTARRS_DEV_0", PANSTARRS_DEV_0, Panstarrs_DEV_0);
     119  CONVERT_FORMAT ("DVO_MEASURE_PANSTARRS_DEV_1", PANSTARRS_DEV_1, Panstarrs_DEV_1);
     120  CONVERT_FORMAT ("DVO_MEASURE_PS1_DEV_1",       PS1_DEV_1,       PS1_DEV_1);
     121# undef CONVERT_FORMAT
    206122
    207123  fprintf (stderr, "table format unknown: %s\n", extname);
    … …  
    213129int MeasureToFtable (FTable *ftable, Measure *measure, int Nmeasure, int format) {
    214130
     131# define FORMAT_CASE(FORMAT, TYPE) \
     132    case DVO_FORMAT_##FORMAT: { \
     133      Measure_##TYPE *tmpMeasure; \
     134      tmpMeasure = MeasureInternalTo_##TYPE (measure, Nmeasure); \
     135      gfits_table_set_Measure_##TYPE (ftable, tmpMeasure, Nmeasure); \
     136      free (tmpMeasure); \
     137      break; }
    215138
    216139  /* convert from the internal format */
    … …  
    219142      gfits_table_set_Measure (ftable, measure, Nmeasure);
    220143      break; }
    221     case DVO_FORMAT_ELIXIR: {
    222       MeasureElixir *tmpMeasure;
    223       tmpMeasure = MeasureInternalToElixir (measure, Nmeasure);
    224       gfits_table_set_MeasureElixir (ftable, tmpMeasure, Nmeasure);
    225       free (tmpMeasure);
    226       break; }
    227     case DVO_FORMAT_LONEOS: {
    228       MeasureLoneos *tmpMeasure;
    229       tmpMeasure = MeasureInternalToLoneos (measure, Nmeasure);
    230       gfits_table_set_MeasureLoneos (ftable, tmpMeasure, Nmeasure);
    231       free (tmpMeasure);
    232       break; }
    233     case DVO_FORMAT_PANSTARRS_DEV_0: {
    234       MeasurePanstarrs_DEV_0 *tmpMeasure;
    235       tmpMeasure = MeasureInternalToPanstarrs_DEV_0 (measure, Nmeasure);
    236       gfits_table_set_MeasurePanstarrs_DEV_0 (ftable, tmpMeasure, Nmeasure);
    237       free (tmpMeasure);
    238       break; }
    239     case DVO_FORMAT_PANSTARRS_DEV_1: {
    240       MeasurePanstarrs_DEV_1 *tmpMeasure;
    241       tmpMeasure = MeasureInternalToPanstarrs_DEV_1 (measure, Nmeasure);
    242       gfits_table_set_MeasurePanstarrs_DEV_1 (ftable, tmpMeasure, Nmeasure);
    243       free (tmpMeasure);
    244       break; }
    245 # if 0
    246     case DVO_FORMAT_PANSTARRS: {
    247       MeasurePanstarrs *tmpMeasure;
    248       tmpMeasure = MeasureInternalToPanstarrs (measure, Nmeasure);
    249       gfits_table_set_MeasurePanstarrs (ftable, tmpMeasure, Nmeasure);
    250       free (tmpMeasure);
    251       break; }
    252 # endif
     144
     145      FORMAT_CASE (ELIXIR,          Elixir);
     146      FORMAT_CASE (LONEOS,          Loneos);
     147      FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
     148      FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
     149      FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
     150# undef FORMAT_CASE
     151
    253152    default:
    254153      fprintf (stderr, "table format unknown (measure)\n");
    … …  
    270169    return (FALSE);
    271170  }
     171
     172# define CONVERT_FORMAT(NAME, FORMAT, TYPE) \
     173  if (!strcmp (extname, NAME)) { \
     174    SecFilt_##TYPE *tmpSecFilt; \
     175    tmpSecFilt = gfits_table_get_SecFilt_##TYPE (ftable, Nsecfilt, NULL); \
     176    secfilt = SecFilt_##TYPE##_ToInternal (tmpSecFilt, *Nsecfilt); \
     177    free (tmpSecFilt); \
     178    *format = DVO_FORMAT_##FORMAT; \
     179    return (secfilt); }
     180
    272181  if (!strcmp (extname, "DVO_SECFILT")) {
    273182    secfilt = gfits_table_get_SecFilt (ftable, Nsecfilt, NULL);
    … …  
    275184    return (secfilt);
    276185  }
    277   if (!strcmp (extname, "DVO_SECFILT_ELIXIR")) {
    278     SecFiltElixir *tmpSecFilt;
    279     tmpSecFilt = gfits_table_get_SecFiltElixir (ftable, Nsecfilt, NULL);
    280     secfilt = SecFiltElixirToInternal (tmpSecFilt, *Nsecfilt);
    281     free (tmpSecFilt);
    282     *format = DVO_FORMAT_ELIXIR;
    283     return (secfilt);
    284   }
    285   if (!strcmp (extname, "DVO_SECFILT_LONEOS")) {
    286     SecFiltLoneos *tmpSecFilt;
    287     tmpSecFilt = gfits_table_get_SecFiltLoneos (ftable, Nsecfilt, NULL);
    288     secfilt = SecFiltLoneosToInternal (tmpSecFilt, *Nsecfilt);
    289     free (tmpSecFilt);
    290     *format = DVO_FORMAT_LONEOS;
    291     return (secfilt);
    292   }
    293   if (!strcmp (extname, "DVO_SECFILT_PANSTARRS_DEV_0")) {
    294     SecFiltPanstarrs_DEV_0 *tmpSecFilt;
    295     tmpSecFilt = gfits_table_get_SecFiltPanstarrs_DEV_0 (ftable, Nsecfilt, NULL);
    296     secfilt = SecFiltPanstarrs_DEV_0_ToInternal (tmpSecFilt, *Nsecfilt);
    297     free (tmpSecFilt);
    298     *format = DVO_FORMAT_PANSTARRS_DEV_0;
    299     return (secfilt);
    300   }
    301   if (!strcmp (extname, "DVO_SECFILT_PANSTARRS_DEV_1")) {
    302     SecFiltPanstarrs_DEV_1 *tmpSecFilt;
    303     tmpSecFilt = gfits_table_get_SecFiltPanstarrs_DEV_1 (ftable, Nsecfilt, NULL);
    304     secfilt = SecFiltPanstarrs_DEV_1_ToInternal (tmpSecFilt, *Nsecfilt);
    305     free (tmpSecFilt);
    306     *format = DVO_FORMAT_PANSTARRS_DEV_1;
    307     return (secfilt);
    308   }
    309 # if 0
    310   if (!strcmp (extname, "DVO_SECFILT_PANSTARRS") || !strcmp (extname, "DVO_SECFILT_PMTEST")) {
    311     SecFiltPanstarrs *tmpSecFilt;
    312     tmpSecFilt = gfits_table_get_SecFiltPanstarrs (ftable, Nsecfilt, NULL);
    313     secfilt = SecFiltPanstarrsToInternal (tmpSecFilt, *Nsecfilt);
    314     free (tmpSecFilt);
    315     *format = DVO_FORMAT_PANSTARRS;
    316     return (secfilt);
    317   }
    318 # endif
     186
     187  CONVERT_FORMAT ("DVO_SECFILT_ELIXIR",          ELIXIR,          Elixir);
     188  CONVERT_FORMAT ("DVO_SECFILT_LONEOS",          LONEOS,          Loneos);
     189  CONVERT_FORMAT ("DVO_SECFILT_PANSTARRS_DEV_0", PANSTARRS_DEV_0, Panstarrs_DEV_0);
     190  CONVERT_FORMAT ("DVO_SECFILT_PANSTARRS_DEV_1", PANSTARRS_DEV_1, Panstarrs_DEV_1);
     191  CONVERT_FORMAT ("DVO_SECFILT_PS1_DEV_1",       PS1_DEV_1,       PS1_DEV_1);
     192# undef CONVERT_FORMAT
    319193
    320194  fprintf (stderr, "table format unknown: %s\n", extname);
    … …  
    326200int SecFiltToFtable (FTable *ftable, SecFilt *secfilt, int Nsecfilt, int format) {
    327201
     202# define FORMAT_CASE(FORMAT, TYPE) \
     203    case DVO_FORMAT_##FORMAT: { \
     204      SecFilt_##TYPE *tmpSecFilt; \
     205      tmpSecFilt = SecFiltInternalTo_##TYPE (secfilt, Nsecfilt); \
     206      gfits_table_set_SecFilt_##TYPE (ftable, tmpSecFilt, Nsecfilt); \
     207      free (tmpSecFilt); \
     208      break; }
     209
    328210  /* convert from the internal format */
    329211  switch (format) {
    … …  
    331213      gfits_table_set_SecFilt (ftable, secfilt, Nsecfilt);
    332214      break; }
    333     case DVO_FORMAT_ELIXIR: {
    334       SecFiltElixir *tmpSecFilt;
    335       tmpSecFilt = SecFiltInternalToElixir (secfilt, Nsecfilt);
    336       gfits_table_set_SecFiltElixir (ftable, tmpSecFilt, Nsecfilt);
    337       free (tmpSecFilt);
    338       break; }
    339     case DVO_FORMAT_LONEOS: {
    340       SecFiltLoneos *tmpSecFilt;
    341       tmpSecFilt = SecFiltInternalToLoneos (secfilt, Nsecfilt);
    342       gfits_table_set_SecFiltLoneos (ftable, tmpSecFilt, Nsecfilt);
    343       free (tmpSecFilt);
    344       break; }
    345     case DVO_FORMAT_PANSTARRS_DEV_0: {
    346       SecFiltPanstarrs_DEV_0 *tmpSecFilt;
    347       tmpSecFilt = SecFiltInternalToPanstarrs_DEV_0 (secfilt, Nsecfilt);
    348       gfits_table_set_SecFiltPanstarrs_DEV_0 (ftable, tmpSecFilt, Nsecfilt);
    349       free (tmpSecFilt);
    350       break; }
    351     case DVO_FORMAT_PANSTARRS_DEV_1: {
    352       SecFiltPanstarrs_DEV_1 *tmpSecFilt;
    353       tmpSecFilt = SecFiltInternalToPanstarrs_DEV_1 (secfilt, Nsecfilt);
    354       gfits_table_set_SecFiltPanstarrs_DEV_1 (ftable, tmpSecFilt, Nsecfilt);
    355       free (tmpSecFilt);
    356       break; }
    357 # if 0
    358     case DVO_FORMAT_PANSTARRS: {
    359       SecFiltPanstarrs *tmpSecFilt;
    360       tmpSecFilt = SecFiltInternalToPanstarrs (secfilt, Nsecfilt);
    361       gfits_table_set_SecFiltPanstarrs (ftable, tmpSecFilt, Nsecfilt);
    362       free (tmpSecFilt);
    363       break; }
    364 # endif
     215
     216      FORMAT_CASE (ELIXIR,          Elixir);
     217      FORMAT_CASE (LONEOS,          Loneos);
     218      FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
     219      FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
     220      FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
     221# undef FORMAT_CASE
     222
    365223    default:
    366224      fprintf (stderr, "table format unknown (secfilt)\n");
    … …  
    379237  /* extname may be set from outside if the source is RAW not MEF */
    380238  if (*format == DVO_FORMAT_ELIXIR) {             // special case for ELIXIR
    381     ImageElixir *tmpimage;
    382     tmpimage = gfits_table_get_ImageElixir (ftable, &Nimage, NULL);
    383     ftable[0].buffer = (char *) ImageElixirToInternal (tmpimage, Nimage);
     239    Image_Elixir *tmpimage;
     240    tmpimage = gfits_table_get_Image_Elixir (ftable, &Nimage, NULL);
     241    ftable[0].buffer = (char *) Image_Elixir_ToInternal (tmpimage, Nimage);
    384242    free (tmpimage);
    385     goto set_header;
     243    gfits_free_header (theader);
     244    gfits_table_mkheader_Image (theader);
     245    gfits_modify (theader, "NAXIS2", "%d", 1, Nimage);
     246    theader[0].Naxis[1] = Nimage;
     247    ftable[0].size = gfits_matrix_size (theader);
     248    return (TRUE);
    386249  }
    387250
    … …  
    391254    return (FALSE);
    392255  }
     256
     257# define CONVERT_FORMAT(NAME, FORMAT, TYPE) \
     258  if (!strcmp (extname, NAME)) { \
     259    Image_##TYPE *tmpimage; \
     260    *format = DVO_FORMAT_##FORMAT; \
     261    tmpimage = gfits_table_get_Image_##TYPE (ftable, &Nimage, NULL); \
     262    ftable[0].buffer = (char *) Image_##TYPE##_ToInternal (tmpimage, Nimage); \
     263    free (tmpimage); \
     264    gfits_free_header (theader); \
     265    gfits_table_mkheader_Image (theader); \
     266    gfits_modify (theader, "NAXIS2", "%d", 1, Nimage); \
     267    theader[0].Naxis[1] = Nimage; \
     268    ftable[0].size = gfits_matrix_size (theader); \
     269    return (TRUE); }
     270
    393271  if (!strcmp (extname, "DVO_IMAGE")) {
    394272    Image *image;
    … …  
    397275    return (TRUE);
    398276  }
    399   if (!strcmp (extname, "DVO_IMAGE_ELIXIR")) {
    400     ImageElixir *tmpimage;
    401     *format = DVO_FORMAT_ELIXIR;
    402     tmpimage = gfits_table_get_ImageElixir (ftable, &Nimage, NULL);
    403     ftable[0].buffer = (char *) ImageElixirToInternal (tmpimage, Nimage);
    404     free (tmpimage);
    405     goto set_header;
    406   }
    407   if (!strcmp (extname, "DVO_IMAGE_LONEOS")) {
    408     ImageLoneos *tmpimage;
    409     *format = DVO_FORMAT_LONEOS;
    410     tmpimage = gfits_table_get_ImageLoneos (ftable, &Nimage, NULL);
    411     ftable[0].buffer = (char *) ImageLoneosToInternal (tmpimage, Nimage);
    412     free (tmpimage);
    413     goto set_header;
    414   }
    415   if (!strcmp (extname, "DVO_IMAGE_PANSTARRS_DEV_0")) {
    416     ImagePanstarrs_DEV_0 *tmpimage;
    417     *format = DVO_FORMAT_PANSTARRS_DEV_0;
    418     tmpimage = gfits_table_get_ImagePanstarrs_DEV_0 (ftable, &Nimage, NULL);
    419     ftable[0].buffer = (char *) ImagePanstarrs_DEV_0_ToInternal (tmpimage, Nimage);
    420     free (tmpimage);
    421     goto set_header;
    422   }
    423   if (!strcmp (extname, "DVO_IMAGE_PANSTARRS_DEV_1")) {
    424     ImagePanstarrs_DEV_1 *tmpimage;
    425     *format = DVO_FORMAT_PANSTARRS_DEV_1;
    426     tmpimage = gfits_table_get_ImagePanstarrs_DEV_1 (ftable, &Nimage, NULL);
    427     ftable[0].buffer = (char *) ImagePanstarrs_DEV_1_ToInternal (tmpimage, Nimage);
    428     free (tmpimage);
    429     goto set_header;
    430   }
    431 # if 0
    432   if (!strcmp (extname, "DVO_IMAGE_PANSTARRS") || !strcmp (extname, "DVO_IMAGE_PMTEST")) {
    433     ImagePanstarrs *tmpimage;
    434     *format = DVO_FORMAT_PANSTARRS;
    435     tmpimage = gfits_table_get_ImagePanstarrs (ftable, &Nimage, NULL);
    436     ftable[0].buffer = (char *) ImagePanstarrsToInternal (tmpimage, Nimage);
    437     free (tmpimage);
    438     goto set_header;
    439   }
    440 # endif
     277
     278  CONVERT_FORMAT ("DVO_IMAGE_ELIXIR",          ELIXIR,          Elixir);
     279  CONVERT_FORMAT ("DVO_IMAGE_LONEOS",          LONEOS,          Loneos);
     280  CONVERT_FORMAT ("DVO_IMAGE_PANSTARRS_DEV_0", PANSTARRS_DEV_0, Panstarrs_DEV_0);
     281  CONVERT_FORMAT ("DVO_IMAGE_PANSTARRS_DEV_1", PANSTARRS_DEV_1, Panstarrs_DEV_1);
     282  CONVERT_FORMAT ("DVO_IMAGE_PS1_DEV_1",       PS1_DEV_1,       PS1_DEV_1);
     283# undef CONVERT_FORMAT
     284
    441285  fprintf (stderr, "table format unknown: %s\n", extname);
    442286  return (FALSE);
    443 
    444 set_header:
    445   gfits_free_header (theader);
    446   gfits_table_mkheader_Image (theader);
    447   gfits_modify (theader, "NAXIS2", "%d", 1, Nimage);
    448   theader[0].Naxis[1] = Nimage;
    449   ftable[0].size = gfits_matrix_size (theader);
    450   return (TRUE);
    451287}
    452288
    … …  
    457293  Nimage = theader[0].Naxis[1];
    458294
     295# define FORMAT_CASE(FORMAT, TYPE) \
     296    case DVO_FORMAT_##FORMAT: { \
     297      Image_##TYPE *tmpImage; \
     298      tmpImage = ImageInternalTo_##TYPE ((Image *) ftable[0].buffer, Nimage); \
     299      free (ftable[0].buffer); \
     300      gfits_table_set_Image_##TYPE (ftable, tmpImage, Nimage); \
     301      free (tmpImage); \
     302      break; }
     303
    459304  /* convert from the internal format */
    460305  switch (format) {
    … …  
    462307      gfits_convert_Image ((Image *) ftable[0].buffer, sizeof(Image), Nimage);
    463308      break; }
    464     case DVO_FORMAT_ELIXIR: {
    465       ImageElixir *tmpImage;
    466       tmpImage = ImageInternalToElixir ((Image *) ftable[0].buffer, Nimage);
    467       free (ftable[0].buffer);
    468       gfits_table_set_ImageElixir (ftable, tmpImage, Nimage);
    469       free (tmpImage);
    470       break; }
    471     case DVO_FORMAT_LONEOS: {
    472       ImageLoneos *tmpImage;
    473       tmpImage = ImageInternalToLoneos ((Image *) ftable[0].buffer, Nimage);
    474       free (ftable[0].buffer);
    475       gfits_table_set_ImageLoneos (ftable, tmpImage, Nimage);
    476       free (tmpImage);
    477       break; }
    478     case DVO_FORMAT_PANSTARRS_DEV_0: {
    479       ImagePanstarrs_DEV_0 *tmpImage;
    480       tmpImage = ImageInternalToPanstarrs_DEV_0 ((Image *) ftable[0].buffer, Nimage);
    481       free (ftable[0].buffer);
    482       gfits_table_set_ImagePanstarrs_DEV_0 (ftable, tmpImage, Nimage);
    483       free (tmpImage);
    484       break; }
    485     case DVO_FORMAT_PANSTARRS_DEV_1: {
    486       ImagePanstarrs_DEV_1 *tmpImage;
    487       tmpImage = ImageInternalToPanstarrs_DEV_1 ((Image *) ftable[0].buffer, Nimage);
    488       free (ftable[0].buffer);
    489       gfits_table_set_ImagePanstarrs_DEV_1 (ftable, tmpImage, Nimage);
    490       free (tmpImage);
    491       break; }
    492 # if 0
    493     case DVO_FORMAT_PANSTARRS: {
    494       ImagePanstarrs *tmpImage;
    495       tmpImage = ImageInternalToPanstarrs ((Image *) ftable[0].buffer, Nimage);
    496       free (ftable[0].buffer);
    497       gfits_table_set_ImagePanstarrs (ftable, tmpImage, Nimage);
    498       free (tmpImage);
    499       break; }
    500 # endif
     309
     310      FORMAT_CASE (ELIXIR,          Elixir);
     311      FORMAT_CASE (LONEOS,          Loneos);
     312      FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
     313      FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
     314      FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
     315# undef FORMAT_CASE
     316
    501317    default:
    502318      fprintf (stderr, "table format unknown (image ftable)\n");
    … …  
    511327
    512328  Nrow = vtable[0].Nrow;
     329
     330# define FORMAT_CASE(FORMAT, TYPE) \
     331  case DVO_FORMAT_##FORMAT: { \
     332      Image_##TYPE *tmpImage; \
     333      /* convert table rows from internal to external format */ \
     334      for (i = 0; i < Nrow; i++) { \
     335          tmpImage = ImageInternalTo_##TYPE ((Image *) vtable[0].buffer[i], 1); \
     336          gfits_convert_Image_##TYPE (tmpImage, sizeof(Image_##TYPE), 1); \
     337          free (vtable[0].buffer[i]); \
     338          vtable[0].buffer[i] = (char *) tmpImage; \
     339      } \
     340      /* convert header from old format to new format */ \
     341      gfits_scan (theader, "NAXIS2", "%d", 1, &Nimage); \
     342      gfits_free_header (theader); \
     343      gfits_table_mkheader_Image_##TYPE (theader); \
     344      gfits_modify (theader, "NAXIS2", "%d", 1, Nimage); \
     345      theader[0].Naxis[1] = Nimage; \
     346      vtable[0].size = gfits_matrix_size (theader); \
     347      return (TRUE); }
     348
    513349
    514350  /* convert from the internal format */
    … …  
    519355      }
    520356      return (TRUE); }
    521     case DVO_FORMAT_ELIXIR: {
    522       ImageElixir *tmpImage;
    523       /* convert table rows from internal to external format */
    524       for (i = 0; i < Nrow; i++) {
    525         tmpImage = ImageInternalToElixir ((Image *) vtable[0].buffer[i], 1);
    526         gfits_convert_ImageElixir (tmpImage, sizeof(ImageElixir), 1);
    527         free (vtable[0].buffer[i]);
    528         vtable[0].buffer[i] = (char *) tmpImage;
    529       }
    530 
    531       /* convert header from old format to new format */
    532       gfits_scan (theader, "NAXIS2", "%d", 1, &Nimage);
    533 
    534       gfits_free_header (theader);
    535       gfits_table_mkheader_ImageElixir (theader);
    536 
    537       gfits_modify (theader, "NAXIS2", "%d", 1, Nimage);
    538       theader[0].Naxis[1] = Nimage;
    539       vtable[0].size = gfits_matrix_size (theader);
    540       return (TRUE); }
    541     case DVO_FORMAT_LONEOS: {
    542       ImageLoneos *tmpImage;
    543       /* convert table rows from internal to external format */
    544       for (i = 0; i < Nrow; i++) {
    545         tmpImage = ImageInternalToLoneos ((Image *) vtable[0].buffer[i], 1);
    546         gfits_convert_ImageLoneos (tmpImage, sizeof(ImageLoneos), 1);
    547         free (vtable[0].buffer[i]);
    548         vtable[0].buffer[i] = (char *) tmpImage;
    549       }
    550 
    551       /* convert header from old format to new format */
    552       gfits_scan (theader, "NAXIS2", "%d", 1, &Nimage);
    553 
    554       gfits_free_header (theader);
    555       gfits_table_mkheader_ImageLoneos (theader);
    556 
    557       gfits_modify (theader, "NAXIS2", "%d", 1, Nimage);
    558       theader[0].Naxis[1] = Nimage;
    559       vtable[0].size = gfits_matrix_size (theader);
    560       return (TRUE); }
    561     case DVO_FORMAT_PANSTARRS_DEV_0: {
    562       ImagePanstarrs_DEV_0 *tmpImage;
    563       /* convert table rows from internal to external format */
    564       for (i = 0; i < Nrow; i++) {
    565         tmpImage = ImageInternalToPanstarrs_DEV_0 ((Image *) vtable[0].buffer[i], 1);
    566         gfits_convert_ImagePanstarrs_DEV_0 (tmpImage, sizeof(ImagePanstarrs_DEV_0), 1);
    567         free (vtable[0].buffer[i]);
    568         vtable[0].buffer[i] = (char *) tmpImage;
    569       }
    570       /* convert header from old format to new format */
    571       gfits_scan (theader, "NAXIS2", "%d", 1, &Nimage);
    572       gfits_free_header (theader);
    573       gfits_table_mkheader_ImagePanstarrs_DEV_0 (theader);
    574       gfits_modify (theader, "NAXIS2", "%d", 1, Nimage);
    575       theader[0].Naxis[1] = Nimage;
    576       vtable[0].size = gfits_matrix_size (theader);
    577       return (TRUE); }
    578     case DVO_FORMAT_PANSTARRS_DEV_1: {
    579       ImagePanstarrs_DEV_1 *tmpImage;
    580       /* convert table rows from internal to external format */
    581       for (i = 0; i < Nrow; i++) {
    582         tmpImage = ImageInternalToPanstarrs_DEV_1 ((Image *) vtable[0].buffer[i], 1);
    583         gfits_convert_ImagePanstarrs_DEV_1 (tmpImage, sizeof(ImagePanstarrs_DEV_1), 1);
    584         free (vtable[0].buffer[i]);
    585         vtable[0].buffer[i] = (char *) tmpImage;
    586       }
    587       /* convert header from old format to new format */
    588       gfits_scan (theader, "NAXIS2", "%d", 1, &Nimage);
    589       gfits_free_header (theader);
    590       gfits_table_mkheader_ImagePanstarrs_DEV_1 (theader);
    591       gfits_modify (theader, "NAXIS2", "%d", 1, Nimage);
    592       theader[0].Naxis[1] = Nimage;
    593       vtable[0].size = gfits_matrix_size (theader);
    594       return (TRUE); }
    595 # if 0
    596     case DVO_FORMAT_PANSTARRS: {
    597       ImagePanstarrs *tmpImage;
    598       /* convert table rows from internal to external format */
    599       for (i = 0; i < Nrow; i++) {
    600         tmpImage = ImageInternalToPanstarrs ((Image *) vtable[0].buffer[i], 1);
    601         gfits_convert_ImagePanstarrs (tmpImage, sizeof(ImagePanstarrs), 1);
    602         free (vtable[0].buffer[i]);
    603         vtable[0].buffer[i] = (char *) tmpImage;
    604       }
    605       /* convert header from old format to new format */
    606       gfits_scan (theader, "NAXIS2", "%d", 1, &Nimage);
    607       gfits_free_header (theader);
    608       gfits_table_mkheader_ImagePanstarrs (theader);
    609       gfits_modify (theader, "NAXIS2", "%d", 1, Nimage);
    610       theader[0].Naxis[1] = Nimage;
    611       vtable[0].size = gfits_matrix_size (theader);
    612       return (TRUE); }
    613 # endif
     357
     358      FORMAT_CASE (ELIXIR,          Elixir);
     359      FORMAT_CASE (LONEOS,          Loneos);
     360      FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
     361      FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
     362      FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
     363# undef FORMAT_CASE
     364
    614365    default:
    615366      break;

  • trunk/Ohana/src/libdvo/src/dvo_convert_elixir.c

    r12332 r15035  
    22
    33/* convert elixir-format measures to internal measures */
    4 Measure *MeasureElixirToInternal (MeasureElixir *in, int Nvalues) {
     4Measure *Measure_Elixir_ToInternal (Measure_Elixir *in, int Nvalues) {
    55
    66  int i;
    … …  
    4949
    5050/* convert internal measures to elixir-format measures */
    51 MeasureElixir *MeasureInternalToElixir (Measure *in, int Nvalues) {
    52 
    53   int i;
    54   MeasureElixir *out;
    55 
    56   ALLOCATE (out, MeasureElixir, Nvalues);
     51Measure_Elixir *MeasureInternalTo_Elixir (Measure *in, int Nvalues) {
     52
     53  int i;
     54  Measure_Elixir *out;
     55
     56  ALLOCATE (out, Measure_Elixir, Nvalues);
    5757
    5858  for (i = 0; i < Nvalues; i++) {
    … …  
    7878
    7979/* convert elixir-format averages to internal averages */
    80 Average *AverageElixirToInternal (AverageElixir *in, int Nvalues, SecFilt **primary) {
     80Average *Average_Elixir_ToInternal (Average_Elixir *in, int Nvalues, SecFilt **primary) {
    8181
    8282  int i;
    … …  
    123123
    124124/* convert internal averages to elixir-format averages */
    125 AverageElixir *AverageInternalToElixir (Average *in, int Nvalues, SecFilt *primary) {
    126 
    127   int i;
    128   AverageElixir *out;
    129 
    130   ALLOCATE (out, AverageElixir, Nvalues);
     125Average_Elixir *AverageInternalTo_Elixir (Average *in, int Nvalues, SecFilt *primary) {
     126
     127  int i;
     128  Average_Elixir *out;
     129
     130  ALLOCATE (out, Average_Elixir, Nvalues);
    131131
    132132  for (i = 0; i < Nvalues; i++) {
    … …  
    149149
    150150/* convert elixir-format secfilts to internal secfilts */
    151 SecFilt *SecFiltElixirToInternal (SecFiltElixir *in, int Nvalues) {
     151SecFilt *SecFilt_Elixir_ToInternal (SecFilt_Elixir *in, int Nvalues) {
    152152
    153153  int i;
    … …  
    167167
    168168/* convert internal secfilts to elixir-format secfilts */
    169 SecFiltElixir *SecFiltInternalToElixir (SecFilt *in, int Nvalues) {
    170 
    171   int i;
    172   SecFiltElixir *out;
    173 
    174   ALLOCATE (out, SecFiltElixir, Nvalues);
     169SecFilt_Elixir *SecFiltInternalTo_Elixir (SecFilt *in, int Nvalues) {
     170
     171  int i;
     172  SecFilt_Elixir *out;
     173
     174  ALLOCATE (out, SecFilt_Elixir, Nvalues);
    175175
    176176  for (i = 0; i < Nvalues; i++) {
    … …  
    183183
    184184/* convert elixir-format images to internal images */
    185 Image *ImageElixirToInternal (ImageElixir *in, int Nvalues) {
     185Image *Image_Elixir_ToInternal (Image_Elixir *in, int Nvalues) {
    186186
    187187  int i;
    … …  
    239239
    240240/* convert internal images to elixir-format images */
    241 ImageElixir *ImageInternalToElixir (Image *in, int Nvalues) {
    242 
    243   int i;
    244   ImageElixir *out;
    245 
    246   ALLOCATE (out, ImageElixir, Nvalues);
     241Image_Elixir *ImageInternalTo_Elixir (Image *in, int Nvalues) {
     242
     243  int i;
     244  Image_Elixir *out;
     245
     246  ALLOCATE (out, Image_Elixir, Nvalues);
    247247
    248248  for (i = 0; i < Nvalues; i++) {

  • trunk/Ohana/src/libdvo/src/dvo_convert_loneos.c

    r12332 r15035  
    22
    33/* convert loneos-format measures to internal measures */
    4 Measure *MeasureLoneosToInternal (MeasureLoneos *in, int Nvalues) {
     4Measure *Measure_Loneos_ToInternal (Measure_Loneos *in, int Nvalues) {
    55
    66  int i;
    … …  
    5151
    5252/* convert internal measures to loneos-format measures */
    53 MeasureLoneos *MeasureInternalToLoneos (Measure *in, int Nvalues) {
    54 
    55   int i;
    56   MeasureLoneos *out;
    57 
    58   ALLOCATE (out, MeasureLoneos, Nvalues);
     53Measure_Loneos *MeasureInternalTo_Loneos (Measure *in, int Nvalues) {
     54
     55  int i;
     56  Measure_Loneos *out;
     57
     58  ALLOCATE (out, Measure_Loneos, Nvalues);
    5959
    6060  for (i = 0; i < Nvalues; i++) {
    … …  
    7575
    7676/* convert loneos-format averages to internal averages */
    77 Average *AverageLoneosToInternal (AverageLoneos *in, int Nvalues, SecFilt **primary) {
     77Average *Average_Loneos_ToInternal (Average_Loneos *in, int Nvalues, SecFilt **primary) {
    7878
    7979  int i;
    … …  
    120120
    121121/* convert internal averages to loneos-format averages */
    122 AverageLoneos *AverageInternalToLoneos (Average *in, int Nvalues, SecFilt *primary) {
    123 
    124   int i;
    125   AverageLoneos *out;
    126 
    127   ALLOCATE (out, AverageLoneos, Nvalues);
     122Average_Loneos *AverageInternalTo_Loneos (Average *in, int Nvalues, SecFilt *primary) {
     123
     124  int i;
     125  Average_Loneos *out;
     126
     127  ALLOCATE (out, Average_Loneos, Nvalues);
    128128
    129129  for (i = 0; i < Nvalues; i++) {
    … …  
    144144
    145145/* convert loneos-format secfilts to internal secfilts */
    146 SecFilt *SecFiltLoneosToInternal (SecFiltLoneos *in, int Nvalues) {
     146SecFilt *SecFilt_Loneos_ToInternal (SecFilt_Loneos *in, int Nvalues) {
    147147
    148148  int i;
    … …  
    162162
    163163/* convert internal secfilts to loneos-format secfilts */
    164 SecFiltLoneos *SecFiltInternalToLoneos (SecFilt *in, int Nvalues) {
    165 
    166   int i;
    167   SecFiltLoneos *out;
    168 
    169   ALLOCATE (out, SecFiltLoneos, Nvalues);
     164SecFilt_Loneos *SecFiltInternalTo_Loneos (SecFilt *in, int Nvalues) {
     165
     166  int i;
     167  SecFilt_Loneos *out;
     168
     169  ALLOCATE (out, SecFilt_Loneos, Nvalues);
    170170
    171171  for (i = 0; i < Nvalues; i++) {
    … …  
    177177
    178178/* convert loneos-format images to internal images */
    179 Image *ImageLoneosToInternal (ImageLoneos *in, int Nvalues) {
     179Image *Image_Loneos_ToInternal (Image_Loneos *in, int Nvalues) {
    180180
    181181  int i;
    … …  
    233233
    234234/* convert internal images to loneos-format images */
    235 ImageLoneos *ImageInternalToLoneos (Image *in, int Nvalues) {
    236 
    237   int i;
    238   ImageLoneos *out;
    239 
    240   ALLOCATE (out, ImageLoneos, Nvalues);
     235Image_Loneos *ImageInternalTo_Loneos (Image *in, int Nvalues) {
     236
     237  int i;
     238  Image_Loneos *out;
     239
     240  ALLOCATE (out, Image_Loneos, Nvalues);
    241241
    242242  for (i = 0; i < Nvalues; i++) {

  • trunk/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_0.c

    r12332 r15035  
    22
    33/* convert panstarrs-format measures to internal measures */
    4 Measure *MeasurePanstarrs_DEV_0_ToInternal (MeasurePanstarrs_DEV_0 *in, int Nvalues) {
     4Measure *Measure_Panstarrs_DEV_0_ToInternal (Measure_Panstarrs_DEV_0 *in, int Nvalues) {
    55
    66  int i;
    … …  
    4444
    4545/* convert internal measures to panstarrs-format measures */
    46 MeasurePanstarrs_DEV_0 *MeasureInternalToPanstarrs_DEV_0 (Measure *in, int Nvalues) {
    47 
    48   int i;
    49   MeasurePanstarrs_DEV_0 *out;
    50 
    51   ALLOCATE (out, MeasurePanstarrs_DEV_0, Nvalues);
     46Measure_Panstarrs_DEV_0 *MeasureInternalTo_Panstarrs_DEV_0 (Measure *in, int Nvalues) {
     47
     48  int i;
     49  Measure_Panstarrs_DEV_0 *out;
     50
     51  ALLOCATE (out, Measure_Panstarrs_DEV_0, Nvalues);
    5252
    5353  for (i = 0; i < Nvalues; i++) {
    … …  
    8686
    8787/* convert panstarrs-format averages to internal averages */
    88 Average *AveragePanstarrs_DEV_0_ToInternal (AveragePanstarrs_DEV_0 *in, int Nvalues) {
     88// 'primary is needed to conform with the API for Loneos and Elixir, but is not used
     89Average *Average_Panstarrs_DEV_0_ToInternal (Average_Panstarrs_DEV_0 *in, int Nvalues, SecFilt **primary) {
    8990
    9091  int i;
    … …  
    117118
    118119/* convert internal averages to panstarrs-format averages */
    119 AveragePanstarrs_DEV_0 *AverageInternalToPanstarrs_DEV_0 (Average *in, int Nvalues) {
    120 
    121   int i;
    122   AveragePanstarrs_DEV_0 *out;
    123 
    124   ALLOCATE (out, AveragePanstarrs_DEV_0, Nvalues);
     120// 'primary is needed to conform with the API for Loneos and Elixir, but is not used
     121Average_Panstarrs_DEV_0 *AverageInternalTo_Panstarrs_DEV_0 (Average *in, int Nvalues, SecFilt *primary) {
     122
     123  int i;
     124  Average_Panstarrs_DEV_0 *out;
     125
     126  ALLOCATE (out, Average_Panstarrs_DEV_0, Nvalues);
    125127
    126128  for (i = 0; i < Nvalues; i++) {
    … …  
    148150
    149151/* convert panstarrs-format secfilts to internal secfilts */
    150 SecFilt *SecFiltPanstarrs_DEV_0_ToInternal (SecFiltPanstarrs_DEV_0 *in, int Nvalues) {
     152SecFilt *SecFilt_Panstarrs_DEV_0_ToInternal (SecFilt_Panstarrs_DEV_0 *in, int Nvalues) {
    151153
    152154  int i;
    … …  
    166168
    167169/* convert internal secfilts to panstarrs-format secfilts */
    168 SecFiltPanstarrs_DEV_0 *SecFiltInternalToPanstarrs_DEV_0 (SecFilt *in, int Nvalues) {
    169 
    170   int i;
    171   SecFiltPanstarrs_DEV_0 *out;
    172 
    173   ALLOCATE (out, SecFiltPanstarrs_DEV_0, Nvalues);
     170SecFilt_Panstarrs_DEV_0 *SecFiltInternalTo_Panstarrs_DEV_0 (SecFilt *in, int Nvalues) {
     171
     172  int i;
     173  SecFilt_Panstarrs_DEV_0 *out;
     174
     175  ALLOCATE (out, SecFilt_Panstarrs_DEV_0, Nvalues);
    174176
    175177  for (i = 0; i < Nvalues; i++) {
    … …  
    184186
    185187/* convert panstarrs-format images to internal images */
    186 Image *ImagePanstarrs_DEV_0_ToInternal (ImagePanstarrs_DEV_0 *in, int Nvalues) {
     188Image *Image_Panstarrs_DEV_0_ToInternal (Image_Panstarrs_DEV_0 *in, int Nvalues) {
    187189
    188190  int i;
    … …  
    240242
    241243/* convert internal images to panstarrs-format images */
    242 ImagePanstarrs_DEV_0 *ImageInternalToPanstarrs_DEV_0 (Image *in, int Nvalues) {
    243 
    244   int i;
    245   ImagePanstarrs_DEV_0 *out;
    246 
    247   ALLOCATE (out, ImagePanstarrs_DEV_0, Nvalues);
     244Image_Panstarrs_DEV_0 *ImageInternalTo_Panstarrs_DEV_0 (Image *in, int Nvalues) {
     245
     246  int i;
     247  Image_Panstarrs_DEV_0 *out;
     248
     249  ALLOCATE (out, Image_Panstarrs_DEV_0, Nvalues);
    248250
    249251  for (i = 0; i < Nvalues; i++) {

  • trunk/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_1.c

    r13884 r15035  
    22
    33/* convert panstarrs-format measures to internal measures */
    4 Measure *MeasurePanstarrs_DEV_1_ToInternal (MeasurePanstarrs_DEV_1 *in, int Nvalues) {
     4Measure *Measure_Panstarrs_DEV_1_ToInternal (Measure_Panstarrs_DEV_1 *in, int Nvalues) {
    55
    66  int i;
    … …  
    4444
    4545/* convert internal measures to panstarrs-format measures */
    46 MeasurePanstarrs_DEV_1 *MeasureInternalToPanstarrs_DEV_1 (Measure *in, int Nvalues) {
    47 
    48   int i;
    49   MeasurePanstarrs_DEV_1 *out;
    50 
    51   ALLOCATE (out, MeasurePanstarrs_DEV_1, Nvalues);
     46Measure_Panstarrs_DEV_1 *MeasureInternalTo_Panstarrs_DEV_1 (Measure *in, int Nvalues) {
     47
     48  int i;
     49  Measure_Panstarrs_DEV_1 *out;
     50
     51  ALLOCATE (out, Measure_Panstarrs_DEV_1, Nvalues);
    5252
    5353  for (i = 0; i < Nvalues; i++) {
    … …  
    8686
    8787/* convert panstarrs-format averages to internal averages */
    88 Average *AveragePanstarrs_DEV_1_ToInternal (AveragePanstarrs_DEV_1 *in, int Nvalues) {
     88// 'primary is needed to conform with the API for Loneos and Elixir, but is not used
     89Average *Average_Panstarrs_DEV_1_ToInternal (Average_Panstarrs_DEV_1 *in, int Nvalues, SecFilt **primary) {
    8990
    9091  int i;
    … …  
    117118
    118119/* convert internal averages to panstarrs-format averages */
    119 AveragePanstarrs_DEV_1 *AverageInternalToPanstarrs_DEV_1 (Average *in, int Nvalues) {
    120 
    121   int i;
    122   AveragePanstarrs_DEV_1 *out;
    123 
    124   ALLOCATE (out, AveragePanstarrs_DEV_1, Nvalues);
     120// 'primary is needed to conform with the API for Loneos and Elixir, but is not used
     121Average_Panstarrs_DEV_1 *AverageInternalTo_Panstarrs_DEV_1 (Average *in, int Nvalues, SecFilt *primary) {
     122
     123  int i;
     124  Average_Panstarrs_DEV_1 *out;
     125
     126  ALLOCATE (out, Average_Panstarrs_DEV_1, Nvalues);
    125127
    126128  for (i = 0; i < Nvalues; i++) {
    … …  
    148150
    149151/* convert panstarrs-format secfilts to internal secfilts */
    150 SecFilt *SecFiltPanstarrs_DEV_1_ToInternal (SecFiltPanstarrs_DEV_1 *in, int Nvalues) {
     152SecFilt *SecFilt_Panstarrs_DEV_1_ToInternal (SecFilt_Panstarrs_DEV_1 *in, int Nvalues) {
    151153
    152154  int i;
    … …  
    166168
    167169/* convert internal secfilts to panstarrs-format secfilts */
    168 SecFiltPanstarrs_DEV_1 *SecFiltInternalToPanstarrs_DEV_1 (SecFilt *in, int Nvalues) {
    169 
    170   int i;
    171   SecFiltPanstarrs_DEV_1 *out;
    172 
    173   ALLOCATE (out, SecFiltPanstarrs_DEV_1, Nvalues);
     170SecFilt_Panstarrs_DEV_1 *SecFiltInternalTo_Panstarrs_DEV_1 (SecFilt *in, int Nvalues) {
     171
     172  int i;
     173  SecFilt_Panstarrs_DEV_1 *out;
     174
     175  ALLOCATE (out, SecFilt_Panstarrs_DEV_1, Nvalues);
    174176
    175177  for (i = 0; i < Nvalues; i++) {
    … …  
    184186
    185187/* convert panstarrs-format images to internal images */
    186 Image *ImagePanstarrs_DEV_1_ToInternal (ImagePanstarrs_DEV_1 *in, int Nvalues) {
     188Image *Image_Panstarrs_DEV_1_ToInternal (Image_Panstarrs_DEV_1 *in, int Nvalues) {
    187189
    188190  int i;
    … …  
    240242
    241243/* convert internal images to panstarrs-format images */
    242 ImagePanstarrs_DEV_1 *ImageInternalToPanstarrs_DEV_1 (Image *in, int Nvalues) {
    243 
    244   int i;
    245   ImagePanstarrs_DEV_1 *out;
    246 
    247   ALLOCATE (out, ImagePanstarrs_DEV_1, Nvalues);
     244Image_Panstarrs_DEV_1 *ImageInternalTo_Panstarrs_DEV_1 (Image *in, int Nvalues) {
     245
     246  int i;
     247  Image_Panstarrs_DEV_1 *out;
     248
     249  ALLOCATE (out, Image_Panstarrs_DEV_1, Nvalues);
    248250
    249251  for (i = 0; i < Nvalues; i++) {

  • trunk/Ohana/src/libdvo/src/dvo_image.c

    r13884 r15035  
    192192  if (db[0].format == DVO_FORMAT_PANSTARRS_DEV_0) gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PANSTARRS_DEV_0");
    193193  if (db[0].format == DVO_FORMAT_PANSTARRS_DEV_1) gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PANSTARRS_DEV_1");
    194   // if (db[0].format == DVO_FORMAT_PANSTARRS)    gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PANSTARRS");
    195   // if (db[0].format == DVO_FORMAT_PMTEST)       gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PMTEST");
     194  if (db[0].format == DVO_FORMAT_PS1_DEV_1)       gfits_modify (&db[0].header, "FORMAT", "%s", 1, "PS1_DEV_1");
    196195 
    197196  return;

  • trunk/Ohana/src/libdvo/src/dvo_image_raw.c

    r13884 r15035  
    4848  ImageSize = 0;
    4949  if (db[0].format == DVO_FORMAT_INTERNAL)        ImageSize = sizeof(Image);
    50   if (db[0].format == DVO_FORMAT_LONEOS)          ImageSize = sizeof(ImageLoneos);
    51   if (db[0].format == DVO_FORMAT_ELIXIR)          ImageSize = sizeof(ImageElixir);
    52   if (db[0].format == DVO_FORMAT_PANSTARRS)       ImageSize = sizeof(ImagePanstarrs);
    53   if (db[0].format == DVO_FORMAT_PANSTARRS_DEV_0) ImageSize = sizeof(ImagePanstarrs_DEV_0);
    54   if (db[0].format == DVO_FORMAT_PANSTARRS_DEV_1) ImageSize = sizeof(ImagePanstarrs_DEV_1);
     50  if (db[0].format == DVO_FORMAT_LONEOS)          ImageSize = sizeof(Image_Loneos);
     51  if (db[0].format == DVO_FORMAT_ELIXIR)          ImageSize = sizeof(Image_Elixir);
     52  if (db[0].format == DVO_FORMAT_PANSTARRS_DEV_0) ImageSize = sizeof(Image_Panstarrs_DEV_0);
     53  if (db[0].format == DVO_FORMAT_PANSTARRS_DEV_1) ImageSize = sizeof(Image_Panstarrs_DEV_1);
     54  if (db[0].format == DVO_FORMAT_PS1_DEV_1)       ImageSize = sizeof(Image_PS1_DEV_1);
    5555
    5656  /* check that filesize makes sense */
    … …  
    7171
    7272  if (db[0].format == DVO_FORMAT_INTERNAL)        gfits_table_mkheader_Image (&db[0].theader);
    73   if (db[0].format == DVO_FORMAT_LONEOS)          gfits_table_mkheader_ImageLoneos (&db[0].theader);
    74   if (db[0].format == DVO_FORMAT_ELIXIR)          gfits_table_mkheader_ImageElixir (&db[0].theader);
    75   if (db[0].format == DVO_FORMAT_PANSTARRS)       gfits_table_mkheader_ImagePanstarrs (&db[0].theader);
    76   if (db[0].format == DVO_FORMAT_PANSTARRS_DEV_0) gfits_table_mkheader_ImagePanstarrs_DEV_0 (&db[0].theader);
    77   if (db[0].format == DVO_FORMAT_PANSTARRS_DEV_1) gfits_table_mkheader_ImagePanstarrs_DEV_1 (&db[0].theader);
     73  if (db[0].format == DVO_FORMAT_LONEOS)          gfits_table_mkheader_Image_Loneos (&db[0].theader);
     74  if (db[0].format == DVO_FORMAT_ELIXIR)          gfits_table_mkheader_Image_Elixir (&db[0].theader);
     75  if (db[0].format == DVO_FORMAT_PANSTARRS_DEV_0) gfits_table_mkheader_Image_Panstarrs_DEV_0 (&db[0].theader);
     76  if (db[0].format == DVO_FORMAT_PANSTARRS_DEV_1) gfits_table_mkheader_Image_Panstarrs_DEV_1 (&db[0].theader);
     77  if (db[0].format == DVO_FORMAT_PS1_DEV_1)       gfits_table_mkheader_Image_PS1_DEV_1 (&db[0].theader);
    7878   
    7979  /* read data from file */

  • trunk/Ohana/src/libdvo/src/dvo_photcode_ops.c

    r12332 r15035  
    3030
    3131/* the static ZERO_POINT is used by programs as an approximate nominal */
    32 static double ZERO_POINT;
     32static double ZERO_POINT = 0.0;
    3333
    3434void SetZeroPoint (double ZP) {
    3535  ZERO_POINT = ZP;
     36}
     37
     38double GetZeroPoint () {
     39  return ZERO_POINT;
    3640}
    3741
Note: See TracChangeset for help on using the changeset viewer.