Pileus Git - ~andy/rsl/blob - 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   (void)fread(header_buf, sizeof(char), sizeof(header_buf), fp);
  60   (void)fread(&nbins, sizeof(int), 1, fp);
  61   if (nbins == 0) return NULL;
  62
  63   memcpy(&ray_h, header_buf, sizeof(Ray_header));
  64
  65   r = RSL_new_ray(ray_h.nbins);
  66   r->h = ray_h;
  67
  68   (void)fread(r->range, sizeof(Range), r->h.nbins, fp);
  69   return r;
  70 }
  71 Sweep *RSL_read_sweep(FILE *fp)
  72 {
  73   char header_buf[512];
  74   Sweep_header sweep_h;
  75   int i;
  76   Sweep *s;
  77   int nrays;
  78
  79   (void)fread(header_buf, sizeof(char), sizeof(header_buf), fp);
  80
  81   (void)fread(&nrays, sizeof(int), 1, fp);
  82   if (nrays == 0) return NULL;
  83
  84   if (radar_verbose_flag)
  85         fprintf(stderr,"Reading %d rays. ", nrays);
  86   memcpy(&sweep_h, header_buf, sizeof(Sweep_header));
  87   if (radar_verbose_flag)
  88         fprintf(stderr,"From header info nrays = %d\n", sweep_h.nrays);
  89   s = RSL_new_sweep(sweep_h.nrays);
  90   s->h = sweep_h;
  91   for (i=0; i<s->h.nrays; i++) {
  92         s->ray[i] = RSL_read_ray(fp);
  93  }
  94   return s;
  95 }
  96 Volume *RSL_read_volume(FILE *fp)
  97 {
  98   char header_buf[512];
  99   Volume_header vol_h;
 100   int i;
 101   Volume *v;
 102   int nsweeps;
 103
 104
 105
 106   (void)fread(header_buf, sizeof(char), sizeof(header_buf), fp);
 107   (void)fread(&nsweeps, sizeof(int), 1, fp);
 108   if (nsweeps == 0)     return NULL;
 109
 110   if (radar_verbose_flag)
 111         fprintf(stderr,"Reading %d sweeps. ", nsweeps);
 112   memcpy(&vol_h, header_buf, sizeof(Volume_header));
 113   if (radar_verbose_flag)
 114         fprintf(stderr,"From header info nsweeps = %d\n", vol_h.nsweeps);
 115   v = RSL_new_volume(vol_h.nsweeps);
 116   v->h = vol_h;
 117   for (i=0; i<v->h.nsweeps; i++) {
 118   if (radar_verbose_flag)
 119         fprintf(stderr,"RSL_read_sweep %d ", i);
 120         v->sweep[i] = RSL_read_sweep(fp);
 121   }
 122   return v;
 123 }
 124
 125 Radar *set_default_function_pointers(Radar *radar)
 126 {
 127   int i,j,k;
 128   Volume *v;
 129   Sweep *s;
 130   Ray *r;
 131   float (*f[MAX_RADAR_VOLUMES])(Range x);
 132   Range (*invf[MAX_RADAR_VOLUMES])(float x);
 133   f[DZ_INDEX] = DZ_F;
 134   f[VR_INDEX] = VR_F;
 135   f[SW_INDEX] = SW_F;
 136   f[CZ_INDEX] = CZ_F;
 137   f[ZT_INDEX] = ZT_F;
 138   f[DR_INDEX] = DR_F;
 139   f[LR_INDEX] = LR_F;
 140
 141   invf[DZ_INDEX] = DZ_INVF;
 142   invf[VR_INDEX] = VR_INVF;
 143   invf[SW_INDEX] = SW_INVF;
 144   invf[CZ_INDEX] = CZ_INVF;
 145   invf[ZT_INDEX] = ZT_INVF;
 146   invf[DR_INDEX] = DR_INVF;
 147   invf[LR_INDEX] = LR_INVF;
 148
 149   if (radar == NULL) return NULL;
 150   for (i=0; i<radar->h.nvolumes; i++) {
 151         v = radar->v[i];
 152         if (v) {
 153           for (j=0; j<v->h.nsweeps; j++) {
 154                 s = v->sweep[j];
 155                 if (s) {
 156                   for (k=0; k<s->h.nrays; k++) {
 157                         r = s->ray[k];
 158                         if (r) {
 159                           r->h.f = f[i];
 160                           r->h.invf = invf[i];
 161                         }
 162                   }
 163                   s->h.f = f[i];
 164                   s->h.invf = invf[i];
 165                 }
 166           }
 167           v->h.f = f[i];
 168           v->h.invf = invf[i];
 169         }
 170   }
 171   return radar;
 172 }
 173
 174 Radar *RSL_read_radar(char *infile)
 175 {
 176   /* On disk each header buffer size is this big to reserve space for
 177    * any new members.  This will make older radar files readable as
 178    * development proceeds.
 179    */
 180   char header_buf[512];
 181   Radar_header radar_h;
 182   Radar *radar;
 183   FILE *fp;
 184   int i;
 185   int nradar;
 186   char title[100];
 187
 188   if ((fp = fopen(infile, "r")) == NULL) {
 189         perror(infile);
 190         return NULL;
 191   }
 192   fp = uncompress_pipe(fp);
 193   (void)fread(title, sizeof(char), sizeof(title), fp);
 194   if (strncmp(title, "RSL", 3) != 0) return NULL;
 195
 196   (void)fread(header_buf, sizeof(char), sizeof(header_buf), fp);
 197   memcpy(&radar_h, header_buf, sizeof(Radar_header));
 198   radar = RSL_new_radar(MAX_RADAR_VOLUMES);
 199   radar->h = radar_h;
 200
 201   (void)fread(&nradar, sizeof(int), 1, fp);
 202   if (radar_verbose_flag)
 203         fprintf(stderr,"Reading %d volumes.\n", nradar);
 204
 205   for (i=0; i<nradar; i++) {
 206         if (radar_verbose_flag)
 207           fprintf(stderr,"RSL_read_volume %d ", i);
 208         radar->v[i] = RSL_read_volume(fp);
 209   }
 210
 211   rsl_pclose(fp);
 212   radar = set_default_function_pointers(radar);
 213   return radar;
 214 }
 215
 216
 217 /**********************************************************************/
 218 /**********************************************************************/
 219 /*                                                                    */
 220 /*                           O U T P U T                              */
 221 /*                                                                    */
 222 /**********************************************************************/
 223 /**********************************************************************/
 224
 225 int RSL_write_ray(Ray *r, FILE *fp)
 226 {
 227   char header_buf[512];
 228   int n = 0;
 229   int zero = 0;
 230
 231   memset(header_buf, 0, sizeof(header_buf));
 232   if (r == NULL) {
 233         n += fwrite(header_buf, sizeof(header_buf), 1, fp) * sizeof(header_buf);
 234         n += fwrite(&zero, sizeof(int), 1, fp) * sizeof(int);
 235         return n;
 236   }
 237   memcpy(header_buf, &r->h, sizeof(r->h));
 238   n += fwrite(header_buf, sizeof(char), sizeof(header_buf), fp);
 239   n += fwrite(&r->h.nbins, sizeof(int), 1, fp) * sizeof(int);
 240   n += fwrite(r->range, sizeof(Range), r->h.nbins, fp) * sizeof(Range);
 241   return n;
 242 }
 243 int RSL_write_sweep(Sweep *s, FILE *fp)
 244 {
 245   char header_buf[512];
 246   int i;
 247   int n = 0;
 248   int zero = 0;
 249
 250
 251   memset(header_buf, 0, sizeof(header_buf));
 252   if (s == NULL) {
 253         n += fwrite(header_buf, sizeof(header_buf), 1, fp) * sizeof(header_buf);
 254         n += fwrite(&zero, sizeof(int), 1, fp) * sizeof(int);
 255         return n;
 256   }
 257   memcpy(header_buf, &s->h, sizeof(s->h));
 258   n += fwrite(header_buf, sizeof(char), sizeof(header_buf), fp);
 259   if (radar_verbose_flag)
 260         fprintf(stderr,"Expect to output %d rays.\n", s->h.nrays);
 261   n += fwrite(&s->h.nrays, sizeof(int), 1, fp) * sizeof(int);
 262   for (i=0; i<s->h.nrays; i++) {
 263         n += RSL_write_ray(s->ray[i], fp);
 264   }
 265   return n;
 266 }
 267 int RSL_write_volume(Volume *v, FILE *fp)
 268 {
 269   char header_buf[512];
 270   int i;
 271   int n = 0;
 272   int zero = 0;
 273
 274   memset(header_buf, 0, sizeof(header_buf));
 275   if (v == NULL) { /* Special case for missing volume.  Volume type
 276                     * is identified by it ordinal within the array.
 277                     * See DZ_INDEX, VR_INDEX, and SW_INDEX in volume.h
 278                     */
 279         /* Write a place holder volume. Just an empty header will do since
 280          * the reading code is data driven.
 281          */
 282         n += fwrite(header_buf, sizeof(header_buf), 1, fp) * sizeof(header_buf);
 283         n += fwrite(&zero, sizeof(int), 1, fp) * sizeof(int);
 284         return n;
 285   }
 286
 287   memcpy(header_buf, &v->h, sizeof(v->h));
 288   n += fwrite(header_buf, sizeof(char), sizeof(header_buf), fp);
 289
 290   if (radar_verbose_flag)
 291         fprintf(stderr,"Expect to output %d sweeps.\n", v->h.nsweeps);
 292   n += fwrite(&v->h.nsweeps, sizeof(int), 1, fp) * sizeof(int);
 293
 294   for (i=0; i<v->h.nsweeps; i++) {
 295         if (radar_verbose_flag)
 296           fprintf(stderr,"write_sweep %d ", i);
 297         n += RSL_write_sweep(v->sweep[i], fp);
 298   }
 299   return n;
 300 }
 301
 302 int RSL_write_radar_fp(Radar *radar, FILE *fp)
 303 {
 304   /* On disk each header buffer size is this big to reserve space for
 305    * any new members.  This will make older radar files readable as
 306    * development proceeds.
 307    */
 308   char header_buf[512];
 309   int i;
 310   int n = 0;
 311   int nradar;
 312   char title[100];
 313
 314   if (radar == NULL) return 0;
 315
 316   memset(title, 0, sizeof(title));
 317   (void)sprintf(title, "RSL v%s. sizeof(Range) %d", RSL_VERSION_STR, sizeof(Range));
 318   n += fwrite(title, sizeof(char), sizeof(title), fp);
 319
 320   memset(header_buf, 0, sizeof(header_buf));
 321   memcpy(header_buf, &radar->h, sizeof(radar->h));
 322   n += fwrite(header_buf, sizeof(char), sizeof(header_buf), fp);
 323
 324   nradar = radar->h.nvolumes;
 325   n += fwrite(&nradar, sizeof(int), 1, fp) * sizeof(int);
 326   if (radar_verbose_flag)
 327         fprintf(stderr,"Number of volumes to write: %d\n", nradar);
 328
 329   for (i=0; i<nradar; i++) {
 330         if (radar_verbose_flag)
 331           fprintf(stderr,"write_volume %d ", i);
 332         n += RSL_write_volume(radar->v[i], fp);
 333
 334   }
 335
 336   if (radar_verbose_flag)
 337         fprintf(stderr,"write_radar done.  Wrote %d bytes.\n", n);
 338   return n;
 339 }
 340 int RSL_write_radar(Radar *radar, char *outfile)
 341 {
 342   /* On disk each header buffer size is this big to reserve space for
 343    * any new members.  This will make older radar files readable as
 344    * development proceeds.
 345    */
 346   FILE *fp;
 347   int n;
 348
 349   if (radar == NULL) return 0;
 350
 351   if ((fp = fopen(outfile, "w")) == NULL) {
 352         perror(outfile);
 353         return -1;
 354   }
 355   n = RSL_write_radar_fp(radar, fp);
 356
 357   (void)fclose(fp);
 358
 359   return n;
 360 }
 361 int RSL_write_radar_gzip(Radar *radar, char *outfile)
 362 {
 363   /* On disk each header buffer size is this big to reserve space for
 364    * any new members.  This will make older radar files readable as
 365    * development proceeds.
 366    */
 367   FILE *fp;
 368   int n;
 369   if (radar == NULL) return 0;
 370
 371   if ((fp = fopen(outfile, "w")) == NULL) {
 372         perror(outfile);
 373         return -1;
 374   }
 375   fp = compress_pipe(fp);
 376   n = RSL_write_radar_fp(radar, fp);
 377
 378   rsl_pclose(fp);
 379
 380   return n;
 381 }
 382