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 (void)fread(header_buf, sizeof(char), sizeof(header_buf), fp);
60 (void)fread(&nbins, sizeof(int), 1, fp);
61 if (nbins == 0) return NULL;
63 memcpy(&ray_h, header_buf, sizeof(Ray_header));
65 r = RSL_new_ray(ray_h.nbins);
68 (void)fread(r->range, sizeof(Range), r->h.nbins, fp);
71 Sweep *RSL_read_sweep(FILE *fp)
79 (void)fread(header_buf, sizeof(char), sizeof(header_buf), fp);
81 (void)fread(&nrays, sizeof(int), 1, fp);
82 if (nrays == 0) return NULL;
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);
91 for (i=0; i<s->h.nrays; i++) {
92 s->ray[i] = RSL_read_ray(fp);
96 Volume *RSL_read_volume(FILE *fp)
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;
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);
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);
125 Radar *set_default_function_pointers(Radar *radar)
131 float (*f[MAX_RADAR_VOLUMES])(Range x);
132 Range (*invf[MAX_RADAR_VOLUMES])(float x);
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;
149 if (radar == NULL) return NULL;
150 for (i=0; i<radar->h.nvolumes; i++) {
153 for (j=0; j<v->h.nsweeps; j++) {
156 for (k=0; k<s->h.nrays; k++) {
174 Radar *RSL_read_radar(char *infile)
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.
180 char header_buf[512];
181 Radar_header radar_h;
188 if ((fp = fopen(infile, "r")) == NULL) {
192 fp = uncompress_pipe(fp);
193 (void)fread(title, sizeof(char), sizeof(title), fp);
194 if (strncmp(title, "RSL", 3) != 0) return NULL;
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);
201 (void)fread(&nradar, sizeof(int), 1, fp);
202 if (radar_verbose_flag)
203 fprintf(stderr,"Reading %d volumes.\n", nradar);
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);
212 radar = set_default_function_pointers(radar);
217 /**********************************************************************/
218 /**********************************************************************/
222 /**********************************************************************/
223 /**********************************************************************/
225 int RSL_write_ray(Ray *r, FILE *fp)
227 char header_buf[512];
231 memset(header_buf, 0, sizeof(header_buf));
233 n += fwrite(header_buf, sizeof(header_buf), 1, fp) * sizeof(header_buf);
234 n += fwrite(&zero, sizeof(int), 1, fp) * sizeof(int);
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);
243 int RSL_write_sweep(Sweep *s, FILE *fp)
245 char header_buf[512];
251 memset(header_buf, 0, sizeof(header_buf));
253 n += fwrite(header_buf, sizeof(header_buf), 1, fp) * sizeof(header_buf);
254 n += fwrite(&zero, sizeof(int), 1, fp) * sizeof(int);
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);
267 int RSL_write_volume(Volume *v, FILE *fp)
269 char header_buf[512];
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
279 /* Write a place holder volume. Just an empty header will do since
280 * the reading code is data driven.
282 n += fwrite(header_buf, sizeof(header_buf), 1, fp) * sizeof(header_buf);
283 n += fwrite(&zero, sizeof(int), 1, fp) * sizeof(int);
287 memcpy(header_buf, &v->h, sizeof(v->h));
288 n += fwrite(header_buf, sizeof(char), sizeof(header_buf), fp);
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);
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);
302 int RSL_write_radar_fp(Radar *radar, FILE *fp)
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.
308 char header_buf[512];
314 if (radar == NULL) return 0;
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);
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);
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);
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);
336 if (radar_verbose_flag)
337 fprintf(stderr,"write_radar done. Wrote %d bytes.\n", n);
340 int RSL_write_radar(Radar *radar, char *outfile)
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.
349 if (radar == NULL) return 0;
351 if ((fp = fopen(outfile, "w")) == NULL) {
355 n = RSL_write_radar_fp(radar, fp);
361 int RSL_write_radar_gzip(Radar *radar, char *outfile)
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.
369 if (radar == NULL) return 0;
371 if ((fp = fopen(outfile, "w")) == NULL) {
375 fp = compress_pipe(fp);
376 n = RSL_write_radar_fp(radar, fp);