Pileus Git - ~andy/rsl/blob - src/read_write.c

   1 /*
   2     NASA/TRMM, Code 910.1.
   3     This is the TRMM Office Radar Software Library.
   4     Copyright (C) 1996, 1997
   5             John H. Merritt
   6             Space Applications Corporation
   7             Vienna, Virginia
   8
   9     This library is free software; you can redistribute it and/or
  10     modify it under the terms of the GNU Library General Public
  11     License as published by the Free Software Foundation; either
  12     version 2 of the License, or (at your option) any later version.
  13
  14     This library is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17     Library General Public License for more details.
  18
  19     You should have received a copy of the GNU Library General Public
  20     License along with this library; if not, write to the Free
  21     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23 /**********************************************************************/
  24 /*                                                                    */
  25 /*                     RSL_read_ray                                   */
  26 /*                     RSL_read_sweep                                 */
  27 /*                     RSL_read_volume                                */
  28 /*                     RSL_read_radar                                 */
  29 /*                                                                    */
  30 /*                     RSL_write_ray                                  */
  31 /*                     RSL_write_sweep                                */
  32 /*                     RSL_write_volume                               */
  33 /*                     RSL_write_radar                                */
  34 /*                                                                    */
  35 /*  By: John Merritt                                                  */
  36 /*      Space Applications Corporation                                */
  37 /*      April 7, 1994                                                 */
  38 /**********************************************************************/
  39 #include <stdio.h>
  40 #include <string.h>
  41 #include "rsl.h"
  42
  43 extern int radar_verbose_flag;
  44 /**********************************************************************/
  45 /**********************************************************************/
  46 /*                                                                    */
  47 /*                             I N P U T                              */
  48 /*                                                                    */
  49 /**********************************************************************/
  50 /**********************************************************************/
  51
  52 Ray *RSL_read_ray(FILE *fp)
  53 {
  54   char header_buf[512];
  55   Ray_header ray_h;
  56   Ray *r;
  57   int nbins;
  58
  59   if (fread(header_buf, sizeof(header_buf), 1, fp) != 1 ||
  60       fread(&nbins, sizeof(int), 1, fp) != 1) {
  61         perror("RSL_read_ray: fread");
  62         return NULL;
  63   }
  64   if (nbins == 0) return NULL;
  65
  66   memcpy(&ray_h, header_buf, sizeof(Ray_header));
  67
  68   r = RSL_new_ray(ray_h.nbins);
  69   r->h = ray_h;
  70
  71   if (fread(r->range, sizeof(Range), r->h.nbins, fp) != r->h.nbins) {
  72     perror("RSL_read_ray: fread");
  73     return NULL;
  74   }
  75   return r;
  76 }
  77 Sweep *RSL_read_sweep(FILE *fp)
  78 {
  79   char header_buf[512];
  80   Sweep_header sweep_h;
  81   int i;
  82   Sweep *s;
  83   int nrays;
  84
  85   if (fread(header_buf, sizeof(header_buf), 1, fp) != 1 ||
  86       fread(&nrays, sizeof(int), 1, fp) != 1) {
  87         perror("RSL_read_sweep: fread");
  88         return NULL;
  89   }
  90   if (nrays == 0) return NULL;
  91
  92   if (radar_verbose_flag)
  93         fprintf(stderr,"Reading %d rays. ", nrays);
  94   memcpy(&sweep_h, header_buf, sizeof(Sweep_header));
  95   if (radar_verbose_flag)
  96         fprintf(stderr,"From header info nrays = %d\n", sweep_h.nrays);
  97   s = RSL_new_sweep(sweep_h.nrays);
  98   s->h = sweep_h;
  99   for (i=0; i<s->h.nrays; i++) {
 100         s->ray[i] = RSL_read_ray(fp);
 101  }
 102   return s;
 103 }
 104 Volume *RSL_read_volume(FILE *fp)
 105 {
 106   char header_buf[512];
 107   Volume_header vol_h;
 108   int i;
 109   Volume *v;
 110   int nsweeps;
 111
 112   if (fread(header_buf, sizeof(header_buf), 1, fp) != 1 ||
 113       fread(&nsweeps, sizeof(int), 1, fp) != 1) {
 114         perror("RSL_read_volume: fread");
 115         return NULL;
 116   }
 117   if (nsweeps == 0)     return NULL;
 118
 119   if (radar_verbose_flag)
 120         fprintf(stderr,"Reading %d sweeps. ", nsweeps);
 121   memcpy(&vol_h, header_buf, sizeof(Volume_header));
 122   if (radar_verbose_flag)
 123         fprintf(stderr,"From header info nsweeps = %d\n", vol_h.nsweeps);
 124   v = RSL_new_volume(vol_h.nsweeps);
 125   v->h = vol_h;
 126   for (i=0; i<v->h.nsweeps; i++) {
 127   if (radar_verbose_flag)
 128         fprintf(stderr,"RSL_read_sweep %d ", i);
 129         v->sweep[i] = RSL_read_sweep(fp);
 130   }
 131   return v;
 132 }
 133
 134 Radar *set_default_function_pointers(Radar *radar)
 135 {
 136   int i,j,k;
 137   Volume *v;
 138   Sweep *s;
 139   Ray *r;
 140   float (*f[MAX_RADAR_VOLUMES])(Range x);
 141   Range (*invf[MAX_RADAR_VOLUMES])(float x);
 142   f[DZ_INDEX] = DZ_F;
 143   f[VR_INDEX] = VR_F;
 144   f[SW_INDEX] = SW_F;
 145   f[CZ_INDEX] = CZ_F;
 146   f[ZT_INDEX] = ZT_F;
 147   f[DR_INDEX] = DR_F;
 148   f[LR_INDEX] = LR_F;
 149
 150   invf[DZ_INDEX] = DZ_INVF;
 151   invf[VR_INDEX] = VR_INVF;
 152   invf[SW_INDEX] = SW_INVF;
 153   invf[CZ_INDEX] = CZ_INVF;
 154   invf[ZT_INDEX] = ZT_INVF;
 155   invf[DR_INDEX] = DR_INVF;
 156   invf[LR_INDEX] = LR_INVF;
 157
 158   if (radar == NULL) return NULL;
 159   for (i=0; i<radar->h.nvolumes; i++) {
 160         v = radar->v[i];
 161         if (v) {
 162           for (j=0; j<v->h.nsweeps; j++) {
 163                 s = v->sweep[j];
 164                 if (s) {
 165                   for (k=0; k<s->h.nrays; k++) {
 166                         r = s->ray[k];
 167                         if (r) {
 168                           r->h.f = f[i];
 169                           r->h.invf = invf[i];
 170                         }
 171                   }
 172                   s->h.f = f[i];
 173                   s->h.invf = invf[i];
 174                 }
 175           }
 176           v->h.f = f[i];
 177           v->h.invf = invf[i];
 178         }
 179   }
 180   return radar;
 181 }
 182
 183 Radar *RSL_read_radar(char *infile)
 184 {
 185   /* On disk each header buffer size is this big to reserve space for
 186    * any new members.  This will make older radar files readable as
 187    * development proceeds.
 188    */
 189   char header_buf[512];
 190   Radar_header radar_h;
 191   Radar *radar;
 192   FILE *fp;
 193   int i;
 194   int nradar;
 195   char title[100];
 196
 197   if ((fp = fopen(infile, "rb")) == NULL) {
 198         perror(infile);
 199         return NULL;
 200   }
 201   fp = uncompress_pipe(fp);
 202   if (fread(title, sizeof(title), 1, fp) != 1) {
 203         perror("RSL_read_radar: fread");
 204         return NULL;
 205   }
 206   if (strncmp(title, "RSL", 3) != 0) return NULL;
 207
 208   if (fread(header_buf, sizeof(header_buf), 1, fp) != 1) {
 209         perror("RSL_read_radar: fread");
 210         return NULL;
 211   }
 212   memcpy(&radar_h, header_buf, sizeof(Radar_header));
 213   radar = RSL_new_radar(MAX_RADAR_VOLUMES);
 214   radar->h = radar_h;
 215
 216   if (fread(&nradar, sizeof(int), 1, fp) != 1) {
 217         perror("RSL_read_radar: fread");
 218         return NULL;
 219   }
 220   if (radar_verbose_flag)
 221         fprintf(stderr,"Reading %d volumes.\n", nradar);
 222
 223   for (i=0; i<nradar; i++) {
 224         if (radar_verbose_flag)
 225           fprintf(stderr,"RSL_read_volume %d ", i);
 226         radar->v[i] = RSL_read_volume(fp);
 227   }
 228
 229   rsl_pclose(fp);
 230   radar = set_default_function_pointers(radar);
 231   return radar;
 232 }
 233
 234
 235 /**********************************************************************/
 236 /**********************************************************************/
 237 /*                                                                    */
 238 /*                           O U T P U T                              */
 239 /*                                                                    */
 240 /**********************************************************************/
 241 /**********************************************************************/
 242
 243 int RSL_write_ray(Ray *r, FILE *fp)
 244 {
 245   char header_buf[512];
 246   int n = 0;
 247   int zero = 0;
 248
 249   memset(header_buf, 0, sizeof(header_buf));
 250   if (r == NULL) {
 251         n += fwrite(header_buf, sizeof(header_buf), 1, fp) * sizeof(header_buf);
 252         n += fwrite(&zero, sizeof(int), 1, fp) * sizeof(int);
 253         return n;
 254   }
 255   memcpy(header_buf, &r->h, sizeof(r->h));
 256   n += fwrite(header_buf, sizeof(char), sizeof(header_buf), fp);
 257   n += fwrite(&r->h.nbins, sizeof(int), 1, fp) * sizeof(int);
 258   n += fwrite(r->range, sizeof(Range), r->h.nbins, fp) * sizeof(Range);
 259   return n;
 260 }
 261 int RSL_write_sweep(Sweep *s, FILE *fp)
 262 {
 263   char header_buf[512];
 264   int i;
 265   int n = 0;
 266   int zero = 0;
 267
 268
 269   memset(header_buf, 0, sizeof(header_buf));
 270   if (s == NULL) {
 271         n += fwrite(header_buf, sizeof(header_buf), 1, fp) * sizeof(header_buf);
 272         n += fwrite(&zero, sizeof(int), 1, fp) * sizeof(int);
 273         return n;
 274   }
 275   memcpy(header_buf, &s->h, sizeof(s->h));
 276   n += fwrite(header_buf, sizeof(char), sizeof(header_buf), fp);
 277   if (radar_verbose_flag)
 278         fprintf(stderr,"Expect to output %d rays.\n", s->h.nrays);
 279   n += fwrite(&s->h.nrays, sizeof(int), 1, fp) * sizeof(int);
 280   for (i=0; i<s->h.nrays; i++) {
 281         n += RSL_write_ray(s->ray[i], fp);
 282   }
 283   return n;
 284 }
 285 int RSL_write_volume(Volume *v, FILE *fp)
 286 {
 287   char header_buf[512];
 288   int i;
 289   int n = 0;
 290   int zero = 0;
 291
 292   memset(header_buf, 0, sizeof(header_buf));
 293   if (v == NULL) { /* Special case for missing volume.  Volume type
 294                     * is identified by it ordinal within the array.
 295                     * See DZ_INDEX, VR_INDEX, and SW_INDEX in volume.h
 296                     */
 297         /* Write a place holder volume. Just an empty header will do since
 298          * the reading code is data driven.
 299          */
 300         n += fwrite(header_buf, sizeof(header_buf), 1, fp) * sizeof(header_buf);
 301         n += fwrite(&zero, sizeof(int), 1, fp) * sizeof(int);
 302         return n;
 303   }
 304
 305   memcpy(header_buf, &v->h, sizeof(v->h));
 306   n += fwrite(header_buf, sizeof(char), sizeof(header_buf), fp);
 307
 308   if (radar_verbose_flag)
 309         fprintf(stderr,"Expect to output %d sweeps.\n", v->h.nsweeps);
 310   n += fwrite(&v->h.nsweeps, sizeof(int), 1, fp) * sizeof(int);
 311
 312   for (i=0; i<v->h.nsweeps; i++) {
 313         if (radar_verbose_flag)
 314           fprintf(stderr,"write_sweep %d ", i);
 315         n += RSL_write_sweep(v->sweep[i], fp);
 316   }
 317   return n;
 318 }
 319
 320 int RSL_write_radar_fp(Radar *radar, FILE *fp)
 321 {
 322   /* On disk each header buffer size is this big to reserve space for
 323    * any new members.  This will make older radar files readable as
 324    * development proceeds.
 325    */
 326   char header_buf[512];
 327   int i;
 328   int n = 0;
 329   int nradar;
 330   char title[100];
 331
 332   if (radar == NULL) return 0;
 333
 334   memset(title, 0, sizeof(title));
 335   (void)sprintf(title, "RSL v%s. sizeof(Range) %d", VERSION, sizeof(Range));
 336   n += fwrite(title, sizeof(char), sizeof(title), fp);
 337
 338   memset(header_buf, 0, sizeof(header_buf));
 339   memcpy(header_buf, &radar->h, sizeof(radar->h));
 340   n += fwrite(header_buf, sizeof(char), sizeof(header_buf), fp);
 341
 342   nradar = radar->h.nvolumes;
 343   n += fwrite(&nradar, sizeof(int), 1, fp) * sizeof(int);
 344   if (radar_verbose_flag)
 345         fprintf(stderr,"Number of volumes to write: %d\n", nradar);
 346
 347   for (i=0; i<nradar; i++) {
 348         if (radar_verbose_flag)
 349           fprintf(stderr,"write_volume %d ", i);
 350         n += RSL_write_volume(radar->v[i], fp);
 351
 352   }
 353
 354   if (radar_verbose_flag)
 355         fprintf(stderr,"write_radar done.  Wrote %d bytes.\n", n);
 356   return n;
 357 }
 358 int RSL_write_radar(Radar *radar, char *outfile)
 359 {
 360   /* On disk each header buffer size is this big to reserve space for
 361    * any new members.  This will make older radar files readable as
 362    * development proceeds.
 363    */
 364   FILE *fp;
 365   int n;
 366
 367   if (radar == NULL) return 0;
 368
 369   if ((fp = fopen(outfile, "wb")) == NULL) {
 370         perror(outfile);
 371         return -1;
 372   }
 373   n = RSL_write_radar_fp(radar, fp);
 374
 375   (void)fclose(fp);
 376
 377   return n;
 378 }
 379 int RSL_write_radar_gzip(Radar *radar, char *outfile)
 380 {
 381   /* On disk each header buffer size is this big to reserve space for
 382    * any new members.  This will make older radar files readable as
 383    * development proceeds.
 384    */
 385   FILE *fp;
 386   int n;
 387   if (radar == NULL) return 0;
 388
 389   if ((fp = fopen(outfile, "wb")) == NULL) {
 390         perror(outfile);
 391         return -1;
 392   }
 393   fp = compress_pipe(fp);
 394   n = RSL_write_radar_fp(radar, fp);
 395
 396   rsl_pclose(fp);
 397
 398   return n;
 399 }
 400