3 This is the TRMM Office Radar Software Library.
4 Copyright (C) 1996 John H. Merritt
5 Space Applications Corporation
6 Vienna, Virginia, a NASA/GSFC on-site contractor.
8 This library is free software; you can redistribute it and/or
9 modify it under the terms of the GNU Library General Public
10 License as published by the Free Software Foundation; either
11 version 2 of the License, or (at your option) any later version.
13 This library is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Library General Public License for more details.
18 You should have received a copy of the GNU Library General Public
19 License along with this library; if not, write to the Free
20 Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 /* Are we building the library? */
30 #define RSL_VERSION_STR "v1.42"
32 /**********************************************************************/
33 /* Configure: Define USE_TWO_BYTE_PRECISION to have RSL store internal*/
34 /* values with two bytes. Otherwise, use one byte. */
35 /* It is a good idea to use two byte precision. */
36 /* See 'makefile' for an additional explaination. */
38 /**********************************************************************/
39 #define USE_TWO_BYTE_PRECISION
42 /**********************************************************************/
43 /* Configure: Define the file name of the red,green, and blue color */
44 /* color tables. This maps reflectance to color. */
45 /* This should be $(LIBDIR)/colors, from the makefile */
46 /* so you shouldn't have to modify anything here. */
47 /**********************************************************************/
49 #define COLORDIR "/usr/local/trmm/GVBOX/lib/colors"
52 /* These are the color table indexes. See RSL_set/get_color_table. */
53 #define RSL_RED_TABLE 0
54 #define RSL_GREEN_TABLE 1
55 #define RSL_BLUE_TABLE 2
57 /* The default color tables for reflectivity, velocity, spectral width,
58 * height, rainfall, and zdr.
60 #define REFL_RED_FILE COLORDIR "/red_reflectivity.clr"
61 #define REFL_GREEN_FILE COLORDIR "/grn_reflectivity.clr"
62 #define REFL_BLUE_FILE COLORDIR "/blu_reflectivity.clr"
63 #define VEL_RED_FILE COLORDIR "/red_velocity.clr"
64 #define VEL_GREEN_FILE COLORDIR "/grn_velocity.clr"
65 #define VEL_BLUE_FILE COLORDIR "/blu_velocity.clr"
66 #define SW_RED_FILE COLORDIR "/red_spectral_width.clr"
67 #define SW_GREEN_FILE COLORDIR "/grn_spectral_width.clr"
68 #define SW_BLUE_FILE COLORDIR "/blu_spectral_width.clr"
69 #define HEIGHT_RED_FILE COLORDIR "/red_height.clr"
70 #define HEIGHT_GREEN_FILE COLORDIR "/grn_height.clr"
71 #define HEIGHT_BLUE_FILE COLORDIR "/blu_height.clr"
72 #define RAINFALL_RED_FILE COLORDIR "/red_rainfall.clr"
73 #define RAINFALL_GREEN_FILE COLORDIR "/grn_rainfall.clr"
74 #define RAINFALL_BLUE_FILE COLORDIR "/blu_rainfall.clr"
76 /* Added by D. Wolff 07/31/97 */
77 #define ZDR_RED_FILE COLORDIR "/red_zdr.clr"
78 #define ZDR_GREEN_FILE COLORDIR "/grn_zdr.clr"
79 #define ZDR_BLUE_FILE COLORDIR "/blu_zdr.clr"
81 /*************************************************************************/
82 /* You should not have to change anything below this line.
83 * The rest is my fault.
85 /*************************************************************************/
89 * Magic numbers. These are used to uniquely identify the type of
90 * values present in a particular structure: Volume, Sweep, Ray.
91 * The magic numbers V_DZ, V_VR, V_SW, etc. represent Volume magic
92 * numbers for the field types DZ, VR, SW, etc. Similiar magic numbers
93 * are implimented for Sweep, and Ray. The magic number is the first word
94 * of the data structure. These magic number may determine which conversion
95 * function is used, see volume.c and the end of this file for the
96 * conversion functions. (As of v0.39 -- NOT YET IMPLEMENTED.)
99 V_DZ, V_VR, V_SW, V_CZ, V_ZT, V_DR, V_LR,
100 S_DZ, S_VR, S_SW, S_CZ, S_ZT, S_DR, S_LR,
101 R_DZ, R_VR, R_SW, R_CZ, R_ZT, R_DR, R_LR
104 /* File format types recognized by RSL. */
105 enum File_type {UNKNOWN, WSR88D_FILE, UF_FILE, LASSEN_FILE,
106 TOGA_FILE, NSIG_FILE_V1, NSIG_FILE_V2,
107 RSL_FILE, MCGILL_FILE, HDF_FILE, RAPIC_FILE,
108 RADTEC_FILE, EDGE_FILE, DORADE_FILE, RAINBOW_FILE};
110 /* Pick a BADVAL that is out of range. That is, the range
111 * of the conversion cannot include these reserved values.
112 * Typically, pick a number that cannot be stored in the Range data type.
114 #ifdef USE_TWO_BYTE_PRECISION
115 typedef unsigned short Range;
116 #define BADVAL (float)0x20000
118 typedef unsigned char Range;
119 #define BADVAL (float)0500 /* non-meaningful value (500 octal) */
122 #define RFVAL (BADVAL-1) /* Range folded value. See rfival. */
123 #define APFLAG (BADVAL-2)
124 #define NOTFOUND_H (BADVAL-3)
125 #define NOTFOUND_V (BADVAL-4)
126 #define NOECHO (BADVAL-5) /* For nsig and UF -32, for kwaj -30 */
127 #define RSL_SPEED_OF_LIGHT 299792458.0 /* m/s */
130 int month; /* Time for this ray; month (1-12). */
131 int day; /* Time for this ray; day (1-31). */
132 int year; /* Time for this ray; year (eg. 1993). */
133 int hour; /* Date for this ray; hour (0-23). */
134 int minute;/* Date for this ray; minute (0-59).*/
135 float sec; /* Date for this ray; second + fraction of second. */
136 float unam_rng; /* Unambiguous range. (KM). */
137 float azimuth; /* Azimuth angle (degrees). Must be positive.
138 * 0=North, 90=east, -90/270=west.
139 * This angle is the mean azimuth for the whole ray.
140 * E.g. for NSIG the beginning and end azimuths are averaged.
142 int ray_num; /* Ray no. within elevation scan. */
143 float elev; /* Elevation angle. (degrees). */
144 int elev_num; /* Elevation no. within volume scan. */
146 int range_bin1; /* Range to first gate.(meters) */
147 int gate_size; /* Data gate size (meters)*/
149 float vel_res; /* Doppler velocity resolution */
150 float sweep_rate; /* Sweep rate. Full sweeps/min. */
152 int prf; /* Pulse repetition frequency, in Hz. */
153 int prf2; /* Second PRF, for Sigmet dual PRF */
154 float azim_rate; /* Sweep rate in degrees/sec. */
155 float fix_angle; /* Elevation angle for the sweep. (degrees). */
156 float pitch; /* Pitch angle. */
157 float roll; /* Roll angle. */
158 float heading; /* Heading. */
159 float pitch_rate; /* (angle/sec) */
160 float roll_rate; /* (angle/sec) */
161 float heading_rate; /* (angle/sec) */
162 float lat; /* Latitude (degrees) */
163 float lon; /* Longitude (degrees) */
164 int alt; /* Altitude (m) */
165 float rvc; /* Radial velocity correction (m/sec) */
166 float vel_east; /* Platform velocity to the east (negative for west) (m/sec) */
167 float vel_north; /* Platform velocity to the north (negative south) (m/sec) */
168 float vel_up; /* Platform velocity toward up (negative down) (m/sec) */
169 int pulse_count; /* Pulses used in a single dwell time. */
170 float pulse_width; /* Pulse width (micro-sec). */
171 float beam_width; /* Beamwidth in degrees. */
172 float frequency; /* Carrier freq. GHz. */
173 float wavelength; /* Wavelength. Meters. */
174 float nyq_vel; /* Nyquist velocity. m/s */
175 float (*f)(Range x); /* Data conversion function. f(x). */
176 Range (*invf)(float x); /* Data conversion function. invf(x). */
177 int nbins; /* Number of array elements for 'Range'. */
183 Range *range; /* range[0..nbins-1]
185 * 0..460 for reflectivity, 0..920 for velocity and
191 typedef struct _azimuth_hash {
193 struct _azimuth_hash *next, *ray_high, *ray_low;
197 Azimuth_hash **indexes;
203 int sweep_num; /* Integer sweep number. This may be redundant, since
204 * this will be the same as the Volume.sweep array index.*/
205 float elev; /* Elevation angle (mean) for the sweep. Value is -999 for
207 float azimuth; /* Azimuth for the sweep (RHI). Value is -999 for PPI. */
208 float beam_width; /* This is in the ray header too. */
209 float vert_half_bw; /* Vertical beam width divided by 2 */
210 float horz_half_bw; /* Horizontal beam width divided by 2 */
213 float (*f)(Range x); /* Data conversion function. f(x). */
214 Range (*invf)(float x); /* Data conversion function. invf(x). */
219 Ray **ray; /* ray[0..nrays-1]. */
223 char *type_str; /* One of:'Reflectivity', 'Velocity' or 'Spectrum width' */
225 float calibr_const; /* Calibration constant. HDF specific. */
226 float (*f)(Range x); /* Data conversion function. f(x). */
227 Range (*invf)(float x); /* Data conversion function. invf(x). */
231 Volume_header h; /* Specific info for each elev. */
232 /* Includes resolution: km/bin. */
233 Sweep **sweep; /* sweep[0..nsweeps-1]. */
238 typedef Range Carpi_value;
239 typedef Range Cappi_value;
242 int month; /* (1-12). */
243 int day; /* (1-31). */
244 int year; /* (eg. 1993). */
245 int hour; /* (0-23). */
246 int minute; /* (0-59).*/
247 float sec; /* second + fraction of second. */
248 float dx, dy; /* Size of cell in km. */
249 int nx, ny; /* Number of cells. */
250 int radar_x, radar_y; /* Location of center of radar. */
251 float height; /* Height of this Carpi. */
252 float lat, lon; /* Lat/lon of lower left corner of Carpi. */
253 char radar_type[50]; /* Radar types. */
254 int field_type; /* Same as for Radar. */
255 int interp_method; /* ??? string describing interpolation method. */
256 float (*f)(Carpi_value x); /* Data conversion function. f(x). */
257 Carpi_value (*invf)(float x); /* Data conversion function. invf(x). */
258 Carpi_value **data; /* data[ny][nx] */
261 /** Cappi data structure info **/
262 /* Paul A. Kucera **/
264 /* Element in location array of Cappi data structure.
265 * Each element is elvation and range to data value.
269 float elev; /* elevation angle */
270 float srange; /* slant range !!! */
274 /* Cappi data structure.
277 int month; /* Begin time for this Cappi; month (1-12). */
278 int day; /* Begin time for this Cappi; day (1-31). */
279 int year; /* Begin time for this Cappi; year (eg. 1993). */
280 int hour; /* Begin date for this Cappi; hour (0-23). */
281 int minute; /* Begin date for this Cappi; minute (0-59).*/
282 float sec; /* Begin date for this Cappi; second + frac. of second.*/
283 float height; /* Height for this Cappi in m */
286 int field_type; /* Value of Constant ??_INDEX */
287 char radar_type[50]; /* Value of Constant radar->h.radar_type */
288 int interp_method; /* ??? string describing interpolation method. */
289 Er_loc *loc; /* elevation and range coordinate array */
290 Sweep *sweep; /* Pointers to rays of data */
293 /* The Cube data type. */
295 typedef Range Cube_value;
296 typedef Range Slice_value;
304 Carpi **carpi; /* Pointers to carpi[0] thru carpi[nz-1] */
312 float (*f)(Slice_value x); /* Data conversion function. f(x). */
313 Slice_value (*invf)(float x); /* Data conversion function. invf(x). */
314 Slice_value **data; /* data[ny][nx]. */
326 enum scan_mode {PPI, RHI};
329 int month, day, year;
331 float sec; /* Second plus fractional part. */
332 char radar_type[50]; /* Type of radar. Use for QC-ing the data.
333 * Supported types are:
334 * "wsr88d", "lassen", "uf",
336 * "kwajalein", "rsl", "toga",
337 * "rapic", (rapic is Berrimah Austrailia)
338 * "radtec", (SPANDAR radar at Wallops Is, VA)
342 * Set by appropriate ingest routine.
346 int number; /* arbitrary number of this radar site */
347 char name[8]; /* Nexrad site name */
348 char radar_name[8]; /* Radar name. */
349 char project[24]; /* Project identifier. */
350 char city[15]; /* nearest city to radar site */
351 char state[3]; /* state of radar site */
353 int latd; /* degrees of latitude of site */
354 int latm; /* minutes of latitude of site */
355 int lats; /* seconds of latitude of site */
356 int lond; /* degrees of longitude of site */
357 int lonm; /* minutes of longitude of site */
358 int lons; /* seconds of longitude of site */
359 int height; /* height of site in meters above sea level*/
360 int spulse; /* length of short pulse (ns)*/
361 int lpulse; /* length of long pulse (ns) */
362 int scan_mode; /* 0 = PPI, 1 = RHI */
363 int vcp; /* Volume Coverage Pattern (for WSR-88D only) */
369 Volume **v; /* Array 0..nvolumes-1 of pointers to Volumes.
370 * 0 = DZ_INDEX = reflectivity.
371 * 1 = VR_INDEX = velocity.
372 * 2 = SW_INDEX = spectrum_width.
373 * 3 = CZ_INDEX = corrected reflectivity.
374 * 4 = ZT_INDEX = uncorrected reflectivity.
375 * 5 = DR_INDEX = differential refl.
376 * 6 = LR_INDEX = another differential refl.
377 * 7 = ZD_INDEX = another differential refl.
378 * 8 = DM_INDEX = received power.
379 * 9 = RH_INDEX = RhoHV: Horz-Vert power corr coeff
380 *10 = PH_INDEX = PhiDP: Differential phase angle
381 *11 = XZ_INDEX = X-band reflectivity.
382 *12 = CD_INDEX = Corrected DR.
383 *13 = MZ_INDEX = DZ mask for 1C-51 HDF.
384 *14 = MR_INDEX = DR mask for 1C-51 HDF.
385 *15 = ZE_INDEX = Edited reflectivity.
386 *16 = VE_INDEX = Edited velocity.
387 *17 = KD_INDEX = KDP: Specific differential phase, deg/km.
388 *18 = TI_INDEX = TIME (unknown) for MCTEX data.
394 *24 = SQ_INDEX = Signal Quality Index (Sigmet)
395 *25 = VS_INDEX = Radial Velocity Combined (DORADE)
396 *26 = VL_INDEX = Radial Velocity Combined (DORADE)
397 *27 = VG_INDEX = Radial Velocity Combined (DORADE)
398 *28 = VT_INDEX = Radial Velocity Combined (DORADE)
399 *29 = NP_INDEX = Normalized Coherent Power (DORADE)
400 *30 = HC_INDEX = HydroClass (Sigmet)
401 *31 = VC_INDEX = Radial Velocity Corrected (Sigmet)
402 *32 = V2_INDEX = Radial Velocity for VCP 121 second Doppler cut.
403 *33 = S2_INDEX = Spectrum Width for VCP 121 second Doppler cut.
404 *34 = V3_INDEX = Radial Velocity for VCP 121 third Doppler cut.
405 *35 = S3_INDEX = Spectrum Width for VCP 121 third Doppler cut.
411 * DZ Reflectivity (dBZ), may contain some DZ_INDEX
412 * signal-processor level QC and/or
413 * filters. This field would contain
414 * Darwin's CZ, or WSR88D's standard
415 * reflectivity. In other words, unless
416 * the field is described otherwise, it
417 * should always go here. In essence, this
418 * is the "cleanest" reflectivity field
421 * VR Radial Velocity (m/s) VR_INDEX
423 * SW Spectral Width (m2/s2) SW_INDEX
425 * CZ QC Reflectivity (dBZ), contains
426 * post-processed QC'd data CZ_INDEX
428 * ZT Total Reflectivity (dBZ) ZT_INDEX
429 * Reflectivity unfiltered for clutter...
430 * This is UZ in UF files.
432 * DR Differential reflectivity DR_INDEX
433 * DR and LR are for dual-polarization
434 * radars only. Unitless or in dB.
436 * LR Another form of differential ref LR_INDEX
437 * called LDR, not sure of units
439 * ZD ZDR: Reflectivity Depolarization Ratio ZD_INDEX
440 * ZDR = 10log(ZH/ZV) (dB)
442 * DM Received power measured by the radar. DM_INDEX
445 * RH RhoHV: Horz-Vert power correlation RH_INDEX
446 * coefficient. (0 to 1) See volume.c
448 * PH PhiDP: Differential phase angle. PH_INDEX
449 * (0 to 180 deg in steps of 0.71)
452 * XZ X-band reflectivity XZ_INDEX
454 * CD Corrected ZD reflectivity (differential) CD_INDEX
455 * contains QC'ed data
457 * MZ DZ mask volume for HDF 1C-51 product. MZ_INDEX
459 * MD ZD mask volume for HDF 1C-51 product. MD_INDEX
461 * ZE Edited Reflectivity. ZE_INDEX
463 * VE Edited Velocity. VE_INDEX
465 * KD KDP (deg/km) Differencial Phase KD_INDEX
468 * TI TIME (unknown) for MCTEX data. TI_INDEX
470 * SQ SQI: Signal Quality Index. (Sigmet) SQ_INDEX
471 * Decimal fraction from 0 to 1, where 0
472 * is noise, 1 is noiseless.
474 * VS Radial Velocity, Short PRT (m/s) (DORADE) VS_INDEX
476 * VL Radial Velocity, Long PRT (m/s) (DORADE) VL_INDEX
478 * VG Radial Velocity, combined (m/s) (DORADE) VG_INDEX
480 * VT Radial Velocity, combined (m/s) (DORADE) VT_INDEX
482 * NP Normalized Coherent Power. (DORADE) NP_INDEX
484 * HC HydroClass: enumerated class. (Sigmet) HC_INDEX
486 * VC Radial Velocity corrected for (Sigmet) VC_INDEX
491 * The number of *_INDEX must never exceed MAX_RADAR_VOLUMES.
492 * Increase MAX_RADAR_VOLUMES appropriately, for new ingest formats.
494 * Also, when adding new *_INDEXes, you must update the following three arrays
495 * located near the end of this file: RSL_ftype, RSL_f_list, and RSL_invf_list.
496 * You also need to modify volume.c, updating the initialization of array
497 * rsl_qfield by adding a '1' for each new volume index.
500 #define MAX_RADAR_VOLUMES 42
546 /* Prototypes for functions. */
547 /* Alphabetical and grouped by object returned. */
550 Radar *RSL_africa_to_radar(char *infile);
551 Radar *RSL_anyformat_to_radar(char *infile, ...);
552 Radar *RSL_dorade_to_radar(char *infile);
553 Radar *RSL_EDGE_to_radar(char *infile);
554 Radar *RSL_fix_radar_header(Radar *radar);
555 Radar *RSL_get_window_from_radar(Radar *r, float min_range, float max_range,float low_azim, float hi_azim);
556 Radar *RSL_hdf_to_radar(char *infile);
557 Radar *RSL_hdf_to_radar_unQC(char *infile);
558 Radar *RSL_kwaj_to_radar(char *infile);
559 Radar *RSL_lassen_to_radar(char *infile);
560 Radar *RSL_mcgill_to_radar(char *infile);
561 Radar *RSL_new_radar(int nvolumes);
562 Radar *RSL_nsig_to_radar(char *infile);
563 Radar *RSL_nsig2_to_radar(char *infile);
564 Radar *RSL_prune_radar(Radar *radar);
565 Radar *RSL_radtec_to_radar(char *infile);
566 Radar *RSL_rainbow_to_radar(char *infile);
567 Radar *RSL_rapic_to_radar(char *infile);
568 Radar *RSL_read_radar(char *infile);
569 Radar *RSL_sort_radar(Radar *r);
570 Radar *RSL_toga_to_radar(char *infile);
571 Radar *RSL_uf_to_radar(char *infile);
572 Radar *RSL_uf_to_radar_fp(FILE *fp);
573 Radar *RSL_wsr88d_to_radar(char *infile, char *call_or_first_tape_file);
575 Volume *RSL_clear_volume(Volume *v);
576 Volume *RSL_copy_volume(Volume *v);
577 Volume *RSL_fix_volume_header(Volume *v);
578 Volume *RSL_get_volume(Radar *r, int type_wanted);
579 Volume *RSL_get_window_from_volume(Volume *v, float min_range, float max_range, float low_azim, float hi_azim);
580 Volume *RSL_new_volume(int max_sweeps);
581 Volume *RSL_prune_volume(Volume *v);
582 Volume *RSL_read_volume(FILE *fp);
583 Volume *RSL_reverse_sweep_order(Volume *v);
584 Volume *RSL_sort_rays_in_volume(Volume *v);
585 Volume *RSL_sort_sweeps_in_volume(Volume *v);
586 Volume *RSL_sort_volume(Volume *v);
587 Volume *RSL_volume_z_to_r(Volume *z_volume, float k, float a);
589 Sweep *RSL_clear_sweep(Sweep *s);
590 Sweep *RSL_copy_sweep(Sweep *s);
591 Sweep *RSL_fix_sweep_header(Sweep *sweep);
592 Sweep *RSL_get_closest_sweep(Volume *v,float sweep_angle,float limit);
593 Sweep *RSL_get_eth_sweep(Volume *v,float et_point,float max_range);
594 Sweep *RSL_get_first_sweep_of_volume(Volume *v);
595 Sweep *RSL_get_sweep(Volume *v, float elev);
596 Sweep *RSL_get_window_from_sweep(Sweep *s, float min_range, float max_range, float low_azim, float hi_azim);
598 Sweep *RSL_new_sweep(int max_rays);
599 Sweep *RSL_prune_sweep(Sweep *s);
600 Sweep *RSL_read_sweep (FILE *fp);
601 Sweep *RSL_sort_rays_in_sweep(Sweep *s);
602 Sweep *RSL_sort_rays_by_time(Sweep *s);
603 Sweep *RSL_sweep_z_to_r(Sweep *z_sweep, float k, float a);
605 Ray *RSL_clear_ray(Ray *r);
606 Ray *RSL_copy_ray(Ray *r);
607 Ray *RSL_get_closest_ray_from_sweep(Sweep *s,float ray_angle,float limit);
608 Ray *RSL_get_first_ray_of_sweep(Sweep *s);
609 Ray *RSL_get_first_ray_of_volume(Volume *v);
610 Ray *RSL_get_closest_ray_from_sweep(Sweep *s,float ray_angle,float limit);
611 Ray *RSL_get_next_ccwise_ray(Sweep *s, Ray *ray);
612 Ray *RSL_get_next_cwise_ray(Sweep *s, Ray *ray);
613 Ray *RSL_get_ray(Volume *v, float elev, float azimuth);
614 Ray *RSL_get_ray_above(Volume *v, Ray *current_ray);
615 Ray *RSL_get_ray_below(Volume *v, Ray *current_ray);
616 Ray *RSL_get_ray_from_sweep(Sweep *s, float azim);
617 Ray *RSL_get_window_from_ray(Ray *r, float min_range, float max_range, float low_azim, float hi_azim);
618 Ray *RSL_new_ray(int max_bins);
619 Ray *RSL_prune_ray(Ray *ray);
620 Ray *RSL_ray_z_to_r(Ray *z_ray, float k, float a);
621 Ray *RSL_read_ray (FILE *fp);
624 float RSL_area_of_ray(Ray *r, float lo, float hi, float min_range, float max_range);
625 float RSL_fraction_of_ray(Ray *r, float lo, float hi, float range);
626 float RSL_fraction_of_sweep(Sweep *s, float lo, float hi, float range);
627 float RSL_fraction_of_volume(Volume *v, float lo, float hi, float range);
628 float RSL_fractional_area_of_sweep(Sweep *s, float lo, float hi, float min_rng, float max_rng);
629 float RSL_get_echo_top_height(Volume *v,float azim,float grange, float et_point);
630 float RSL_get_linear_value(Volume *v,float srange,float azim,float elev,float limit);
631 float RSL_get_nyquist_from_radar(Radar *radar);
632 float RSL_get_range_of_range_index(Ray *ray, int index);
633 float RSL_get_value(Volume *v, float elev, float azimuth, float range);
634 float RSL_get_value_at_h(Volume *v, float azim, float grnd_r, float h);
635 float RSL_get_value_from_cappi(Cappi *cappi, float rng, float azm);
636 float RSL_get_value_from_ray(Ray *ray, float r);
637 float RSL_get_value_from_sweep(Sweep *s, float azim, float r);
638 float RSL_z_to_r(float z, float k, float a);
640 int RSL_fill_cappi(Volume *v, Cappi *cap, int method);
641 int RSL_get_ray_index_from_sweep(Sweep *s, float azim,int *next_closest);
642 int RSL_get_sweep_index_from_volume(Volume *v, float elev,int *next_closest);
643 int RSL_radar_to_hdf(Radar *radar, char *outfile);
644 int RSL_write_histogram(Histogram *histogram, char *outfile);
645 int RSL_write_ray(Ray *r, FILE *fp);
646 int RSL_write_sweep(Sweep *s, FILE *fp);
647 int RSL_write_radar(Radar *radar, char *outfile);
648 int RSL_write_radar_gzip(Radar *radar, char *outfile);
649 int RSL_write_volume(Volume *v, FILE *fp);
651 unsigned char *RSL_rhi_sweep_to_cart(Sweep *s, int xdim, int ydim, float range,
653 unsigned char *RSL_sweep_to_cart(Sweep *s, int xdim, int ydim, float range);
655 void RSL_add_dbz_offset_to_ray(Ray *r, float dbz_offset);
656 void RSL_add_dbz_offset_to_sweep(Sweep *s, float dbz_offset);
657 void RSL_add_dbz_offset_to_volume(Volume *v, float dbz_offset);
658 void RSL_bscan_ray(Ray *r, FILE *fp);
659 void RSL_bscan_sweep(Sweep *s, char *outfile);
660 void RSL_bscan_volume(Volume *v, char *basename);
661 void RSL_find_rng_azm(float *r, float *ang, float x, float y);
662 void RSL_fix_time (Ray *ray);
663 void RSL_float_to_char(float *x, Range *c, int n);
665 void RSL_free_cappi(Cappi *c);
666 void RSL_free_carpi(Carpi *carpi);
667 void RSL_free_cube(Cube *cube);
668 void RSL_free_histogram(Histogram *histogram);
669 void RSL_free_ray(Ray *r);
670 void RSL_free_slice(Slice *slice);
671 void RSL_free_sweep(Sweep *s);
672 void RSL_free_radar(Radar *r);
673 void RSL_free_volume(Volume *v);
674 void RSL_get_color_table(int icolor, char buffer[256], int *ncolors);
675 void RSL_get_groundr_and_h(float slant_r, float elev, float *gr, float *h);
676 void RSL_get_slantr_and_elev(float gr, float h, float *slant_r, float *elev);
677 void RSL_get_slantr_and_h(float gr, float elev, float *slant_r, float *h);
678 void RSL_load_color_table(char *infile, char buffer[256], int *ncolors);
679 void RSL_load_height_color_table();
680 void RSL_load_rainfall_color_table();
681 void RSL_load_refl_color_table();
682 void RSL_load_vel_color_table();
683 void RSL_load_sw_color_table();
684 void RSL_load_zdr_color_table();
685 void RSL_load_red_table(char *infile);
686 void RSL_load_green_table(char *infile);
687 void RSL_load_blue_table(char *infile);
688 void RSL_print_histogram(Histogram *histogram, int min_range, int max_range,
690 void RSL_print_version();
691 void RSL_prune_radar_on();
692 void RSL_prune_radar_off();
693 void RSL_radar_to_uf(Radar *r, char *outfile);
694 void RSL_radar_to_uf_gzip(Radar *r, char *outfile);
695 void RSL_radar_verbose_off(void);
696 void RSL_radar_verbose_on(void);
697 void RSL_read_these_sweeps(char *csweep, ...);
698 void RSL_rebin_velocity_ray(Ray *r);
699 void RSL_rebin_velocity_sweep(Sweep *s);
700 void RSL_rebin_velocity_volume(Volume *v);
701 void RSL_rebin_zdr_ray(Ray *r);
702 void RSL_rebin_zdr_sweep(Sweep *s);
703 void RSL_rebin_zdr_volume(Volume *v);
704 void RSL_rhi_sweep_to_gif(Sweep *s, char *outfile, int xdim, int ydim, float range,
706 void RSL_select_fields(char *field_type, ...);
707 void RSL_set_color_table(int icolor, char buffer[256], int ncolors);
708 void RSL_sweep_to_gif(Sweep *s, char *outfile, int xdim, int ydim, float range);
709 void RSL_sweep_to_pgm(Sweep *s, char *outfile, int xdim, int ydim, float range);
710 void RSL_sweep_to_pict(Sweep *s, char *outfile, int xdim, int ydim, float range);
711 void RSL_sweep_to_ppm(Sweep *s, char *outfile, int xdim, int ydim, float range);
712 void RSL_volume_to_gif(Volume *v, char *basename, int xdim, int ydim, float range);
713 void RSL_volume_to_pgm(Volume *v, char *basename, int xdim, int ydim, float range);
714 void RSL_volume_to_pict(Volume *v, char *basename, int xdim, int ydim, float range);
715 void RSL_volume_to_ppm(Volume *v, char *basename, int xdim, int ydim, float range);
716 void RSL_write_gif(char *outfile, unsigned char *image,
717 int xdim, int ydim, char c_table[256][3]);
718 void RSL_write_pgm(char *outfile, unsigned char *image,
720 void RSL_write_pict(char *outfile, unsigned char *image,
721 int xdim, int ydim, char c_table[256][3]);
722 void RSL_write_ppm(char *outfile, unsigned char *image,
723 int xdim, int ydim, char c_table[256][3]);
726 Cappi *RSL_new_cappi(Sweep *sweep, float height);
727 Cappi *RSL_cappi_at_h(Volume *v, float height, float max_range);
729 Carpi *RSL_cappi_to_carpi(Cappi *cappi, float dx, float dy,
730 float lat, float lon,
731 int nx, int ny, int radar_x, int radar_y);
732 Carpi *RSL_new_carpi(int nrows, int ncols);
733 Carpi *RSL_volume_to_carpi(Volume *v, float h, float grnd_r,
734 float dx, float dy, int nx, int ny,
735 int radar_x, int radar_y, float lat, float lon);
737 Cube *RSL_new_cube(int ncarpi);
738 Cube *RSL_volume_to_cube(Volume *v, float dx, float dy, float dz,
739 int nx, int ny, int nz, float grnd_r,
740 int radar_x, int radar_y, int radar_z);
742 Slice *RSL_new_slice(int nrows, int ncols);
743 Slice *RSL_get_slice_from_cube(Cube *cube, int x, int y, int z);
746 Histogram *RSL_allocate_histogram(int low, int hi);
747 Histogram *RSL_get_histogram_from_ray(Ray *ray, Histogram *histogram,
748 int low, int hi, int min_range,
750 Histogram *RSL_get_histogram_from_sweep(Sweep *sweep, Histogram *histogram,
751 int low, int hi, int min_range,
753 Histogram *RSL_get_histogram_from_volume(Volume *volume, Histogram *histogram,
754 int low, int hi, int min_range,
756 Histogram *RSL_read_histogram(char *infile);
758 int no_command (char *cmd);
759 FILE *uncompress_pipe (FILE *fp);
760 FILE *compress_pipe (FILE *fp);
761 int rsl_pclose(FILE *fp);
763 /* Carpi image generation functions. These are modified clones of the
764 corresponding sweep image generation functions.
766 unsigned char *RSL_carpi_to_cart(Carpi *carpi, int xdim, int ydim,
768 void RSL_carpi_to_gif(Carpi *carpi, char *outfile, int xdim, int ydim,
770 void RSL_carpi_to_pict(Carpi *carpi, char *outfile, int xdim, int ydim,
772 void RSL_carpi_to_ppm(Carpi *carpi, char *outfile, int xdim, int ydim,
774 void RSL_carpi_to_pgm(Carpi *carpi, char *outfile, int xdim, int ydim,
777 /* Internal storage conversion functions. These may be any conversion and
778 * may be dynamically defined; based on the input data conversion.
814 Range DZ_INVF(float x);
815 Range VR_INVF(float x);
816 Range SW_INVF(float x);
817 Range CZ_INVF(float x);
818 Range ZT_INVF(float x);
819 Range DR_INVF(float x);
820 Range LR_INVF(float x);
821 Range ZD_INVF(float x);
822 Range DM_INVF(float x);
823 Range RH_INVF(float x);
824 Range PH_INVF(float x);
825 Range XZ_INVF(float x);
826 Range CD_INVF(float x);
827 Range MZ_INVF(float x);
828 Range MD_INVF(float x);
829 Range ZE_INVF(float x);
830 Range VE_INVF(float x);
831 Range KD_INVF(float x);
832 Range TI_INVF(float x);
833 Range DX_INVF(float x);
834 Range CH_INVF(float x);
835 Range AH_INVF(float x);
836 Range CV_INVF(float x);
837 Range AV_INVF(float x);
838 Range SQ_INVF(float x);
839 Range VS_INVF(float x);
840 Range VL_INVF(float x);
841 Range VG_INVF(float x);
842 Range VT_INVF(float x);
843 Range NP_INVF(float x);
844 Range HC_INVF(float x);
845 Range VC_INVF(float x);
846 Range SD_INVF(float x);
849 /* If you like these variables, you can use them in your application
850 * by defining USE_RSL_VARS before #include "rsl.h"
853 static char *RSL_ftype[] = {"DZ", "VR", "SW", "CZ", "ZT", "DR",
854 "LR", "ZD", "DM", "RH", "PH", "XZ",
855 "CD", "MZ", "MD", "ZE", "VE", "KD",
856 "TI", "DX", "CH", "AH", "CV", "AV",
857 "SQ", "VS", "VL", "VG", "VT", "NP",
858 "HC", "VC", "V2", "S2", "V3", "S3",
859 "CR", "CC", "PR", "SD", "ZZ", "RD"};
861 static float (*RSL_f_list[])(Range x) = {DZ_F, VR_F, SW_F, CZ_F, ZT_F, DR_F,
862 LR_F, ZD_F, DM_F, RH_F, PH_F, XZ_F,
863 CD_F, MZ_F, MD_F, ZE_F, VE_F, KD_F,
864 TI_F, DX_F, CH_F, AH_F, CV_F, AV_F,
865 SQ_F, VS_F, VL_F, VG_F, VT_F, NP_F,
866 HC_F, VC_F, VR_F, SW_F, VR_F, SW_F,
867 DZ_F, CZ_F, PH_F, SD_F, DZ_F, DZ_F};
869 static Range (*RSL_invf_list[])(float x)
870 = {DZ_INVF, VR_INVF, SW_INVF, CZ_INVF, ZT_INVF, DR_INVF,
871 LR_INVF, ZD_INVF, DM_INVF, RH_INVF, PH_INVF, XZ_INVF,
872 CD_INVF, MZ_INVF, MD_INVF, ZE_INVF, VE_INVF, KD_INVF,
873 TI_INVF, DX_INVF, CH_INVF, AH_INVF, CV_INVF, AV_INVF,
874 SQ_INVF, VS_INVF, VL_INVF, VG_INVF, VT_INVF, NP_INVF,
875 HC_INVF, VC_INVF, VR_INVF, SW_INVF, VR_INVF, SW_INVF,
876 DZ_INVF, CZ_INVF, PH_INVF, SD_INVF, DZ_INVF, DZ_INVF};
878 /* Secret routines that are quite useful and useful to developers. */
879 void radar_load_date_time(Radar *radar);
880 int big_endian(void);
881 int little_endian(void);
882 void swap_4_bytes(void *word);
883 void swap_2_bytes(void *word);
884 Hash_table *hash_table_for_sweep(Sweep *s);
885 int hash_bin(Hash_table *table,float angle);
886 Azimuth_hash *the_closest_hash(Azimuth_hash *hash, float ray_angle);
887 Hash_table *construct_sweep_hash_table(Sweep *s);
888 double angle_diff(float x, float y);
889 int rsl_query_field(char *c_field);
892 /* Debugging prototypes. */
893 void poke_around_volume(Volume *v);
895 /* SYSTEM: left out prototypes? */
896 extern int pclose (FILE *f); /* From stdio.h */