3 This is the TRMM Office Radar Software Library.
4 Copyright (C) 1996, 1997
6 Space Applications Corporation
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.
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.
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.
23 /**********************************************************************/
32 /* RSL_write_volume */
35 /* By: John Merritt */
36 /* Space Applications Corporation */
38 /**********************************************************************/
43 extern int radar_verbose_flag;
44 /**********************************************************************/
45 /**********************************************************************/
49 /**********************************************************************/
50 /**********************************************************************/
52 Ray *RSL_read_ray(FILE *fp)
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");
64 if (nbins == 0) return NULL;
66 memcpy(&ray_h, header_buf, sizeof(Ray_header));
68 r = RSL_new_ray(ray_h.nbins);
71 if (fread(r->range, sizeof(Range), r->h.nbins, fp) != r->h.nbins) {
72 perror("RSL_read_ray: fread");
77 Sweep *RSL_read_sweep(FILE *fp)
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");
90 if (nrays == 0) return NULL;
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);
99 for (i=0; i<s->h.nrays; i++) {
100 s->ray[i] = RSL_read_ray(fp);
104 Volume *RSL_read_volume(FILE *fp)
106 char header_buf[512];
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");
117 if (nsweeps == 0) return NULL;
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);
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);
134 Radar *set_default_function_pointers(Radar *radar)
140 float (*f[MAX_RADAR_VOLUMES])(Range x);
141 Range (*invf[MAX_RADAR_VOLUMES])(float x);
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;
158 if (radar == NULL) return NULL;
159 for (i=0; i<radar->h.nvolumes; i++) {
162 for (j=0; j<v->h.nsweeps; j++) {
165 for (k=0; k<s->h.nrays; k++) {
183 Radar *RSL_read_radar(char *infile)
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.
189 char header_buf[512];
190 Radar_header radar_h;
197 if ((fp = fopen(infile, "r")) == NULL) {
201 fp = uncompress_pipe(fp);
202 if (fread(title, sizeof(title), 1, fp) != 1) {
203 perror("RSL_read_radar: fread");
206 if (strncmp(title, "RSL", 3) != 0) return NULL;
208 if (fread(header_buf, sizeof(header_buf), 1, fp) != 1) {
209 perror("RSL_read_radar: fread");
212 memcpy(&radar_h, header_buf, sizeof(Radar_header));
213 radar = RSL_new_radar(MAX_RADAR_VOLUMES);
216 if (fread(&nradar, sizeof(int), 1, fp) != 1) {
217 perror("RSL_read_radar: fread");
220 if (radar_verbose_flag)
221 fprintf(stderr,"Reading %d volumes.\n", nradar);
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);
230 radar = set_default_function_pointers(radar);
235 /**********************************************************************/
236 /**********************************************************************/
240 /**********************************************************************/
241 /**********************************************************************/
243 int RSL_write_ray(Ray *r, FILE *fp)
245 char header_buf[512];
249 memset(header_buf, 0, sizeof(header_buf));
251 n += fwrite(header_buf, sizeof(header_buf), 1, fp) * sizeof(header_buf);
252 n += fwrite(&zero, sizeof(int), 1, fp) * sizeof(int);
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);
261 int RSL_write_sweep(Sweep *s, FILE *fp)
263 char header_buf[512];
269 memset(header_buf, 0, sizeof(header_buf));
271 n += fwrite(header_buf, sizeof(header_buf), 1, fp) * sizeof(header_buf);
272 n += fwrite(&zero, sizeof(int), 1, fp) * sizeof(int);
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);
285 int RSL_write_volume(Volume *v, FILE *fp)
287 char header_buf[512];
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
297 /* Write a place holder volume. Just an empty header will do since
298 * the reading code is data driven.
300 n += fwrite(header_buf, sizeof(header_buf), 1, fp) * sizeof(header_buf);
301 n += fwrite(&zero, sizeof(int), 1, fp) * sizeof(int);
305 memcpy(header_buf, &v->h, sizeof(v->h));
306 n += fwrite(header_buf, sizeof(char), sizeof(header_buf), fp);
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);
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);
320 int RSL_write_radar_fp(Radar *radar, FILE *fp)
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.
326 char header_buf[512];
332 if (radar == NULL) return 0;
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);
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);
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);
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);
354 if (radar_verbose_flag)
355 fprintf(stderr,"write_radar done. Wrote %d bytes.\n", n);
358 int RSL_write_radar(Radar *radar, char *outfile)
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.
367 if (radar == NULL) return 0;
369 if ((fp = fopen(outfile, "w")) == NULL) {
373 n = RSL_write_radar_fp(radar, fp);
379 int RSL_write_radar_gzip(Radar *radar, char *outfile)
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.
387 if (radar == NULL) return 0;
389 if ((fp = fopen(outfile, "w")) == NULL) {
393 fp = compress_pipe(fp);
394 n = RSL_write_radar_fp(radar, fp);