Pileus Git - ~andy/rsl/blob - get_win.c

   1 /*
   2     NASA/TRMM, Code 910.1.
   3     This is the TRMM Office Radar Software Library.
   4     Copyright (C) 1996  Thuy Nguyen of International Database Systems
   5                         a NASA/GSFC on-site contractor.
   6
   7     This library is free software; you can redistribute it and/or
   8     modify it under the terms of the GNU Library General Public
   9     License as published by the Free Software Foundation; either
  10     version 2 of the License, or (at your option) any later version.
  11
  12     This library is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15     Library General Public License for more details.
  16
  17     You should have received a copy of the GNU Library General Public
  18     License along with this library; if not, write to the Free
  19     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include <stdio.h>
  23 #include <math.h>
  24 #include <stdlib.h>
  25
  26 #include "rsl.h"
  27
  28 extern int radar_verbose_flag;
  29
  30
  31 /***************************************************************************
  32  *                         RSL_get_window_from_radar
  33  *                         RSL_get_window_from_volume
  34  *                         RSL_get_window_from_sweep
  35  *                         RSL_get_window_from_ray
  36  *
  37  * These routines get window (area) defined by minimum range, maximum range,
  38  * low azimuth, and hi azimuth.
  39  *
  40  * By:  Thuy Nguyen
  41  *      International Database Systems
  42  *
  43  y***************************************************************************/
  44
  45 Radar *RSL_get_window_from_radar(Radar *r, float min_range, float max_range,
  46                                                                  float low_azim, float hi_azim)
  47 {
  48   int i;
  49   Radar *new_radar;
  50
  51   if (min_range > max_range || min_range < 0 || max_range < 0){
  52         if (radar_verbose_flag)
  53         fprintf(stderr,"Get win from radar: given invalid min range (%f) or max range (%f)\n",
  54                    min_range, max_range);
  55         return NULL;
  56   }
  57   if (!r) return NULL;
  58
  59   if ((new_radar = RSL_new_radar(r->h.nvolumes)) == NULL) return NULL;
  60   new_radar->h = r->h;
  61
  62   for (i = 0; i < r->h.nvolumes; i++) {
  63         if (radar_verbose_flag)
  64           fprintf(stderr,"Getting window from volume for v[%d] out of %d volumes\n",
  65                          i,r->h.nvolumes );
  66
  67         new_radar->v[i] = RSL_get_window_from_volume(r->v[i], min_range, max_range,
  68                                                                                   low_azim, hi_azim);
  69   }
  70   return new_radar;
  71 }
  72
  73
  74 Volume *RSL_get_window_from_volume(Volume *v, float min_range, float max_range,
  75                                                                  float low_azim, float hi_azim)
  76 {
  77   int i;
  78   Volume *new_volume;
  79   Sweep  *new_sweep;
  80
  81   if (min_range > max_range || min_range < 0 || max_range < 0){
  82         if (radar_verbose_flag)
  83         fprintf(stderr,"Get win from volume: given invalid min range (%f) or max range (%f)\n",
  84                    min_range, max_range);
  85         return NULL;
  86   }
  87   if (!v) return NULL;
  88
  89   if ((new_volume = RSL_new_volume(v->h.nsweeps)) == NULL) return NULL;
  90   new_volume->h = v->h;
  91
  92   for (i = 0; i < v->h.nsweeps; i++) {
  93         if (radar_verbose_flag)
  94           fprintf(stderr,"Getting window from sweep for s[%d] out of %d sweeps\n",
  95                          i,v->h.nsweeps);
  96
  97         new_sweep = RSL_get_window_from_sweep(v->sweep[i], min_range, max_range,
  98                                                                                   low_azim, hi_azim);
  99         new_volume->sweep[i] = new_sweep;
 100   }
 101
 102   if (radar_verbose_flag)
 103         fprintf(stderr,"Got win from volume: orig volume has %d sweeps, new "
 104                    "volume has %d sweeps\n",v->h.nsweeps,new_volume->h.nsweeps);
 105
 106   return new_volume;
 107 }
 108
 109 Sweep *RSL_get_window_from_sweep(Sweep *s, float min_range, float max_range,
 110                                                                  float low_azim, float hi_azim)
 111 {
 112   int   i;
 113   Sweep *new_sweep;
 114   Ray   *new_ray;
 115
 116   if (min_range > max_range || min_range < 0 || max_range < 0){
 117         if (radar_verbose_flag)
 118         fprintf(stderr,"Get win from sweep: given invalid min range (%f) or max range (%f)\n",
 119                    min_range, max_range);
 120         return NULL;
 121   }
 122   if (s == NULL) return NULL;
 123
 124   if ((new_sweep = RSL_new_sweep(s->h.nrays)) == NULL)
 125         return NULL;
 126
 127   new_sweep->h = s->h;
 128
 129   for (i = 0; i < s->h.nrays; i++) {
 130         new_ray = RSL_get_window_from_ray(s->ray[i], min_range, max_range,
 131                                                                                   low_azim, hi_azim);
 132                 new_sweep->ray[i] = new_ray;
 133
 134   }
 135
 136
 137   if (radar_verbose_flag)
 138         fprintf(stderr,"Got win from sweep: orig sweep has %d rays, new sweep "
 139                    "has %d rays.\n",s->h.nrays,new_sweep->h.nrays);
 140
 141   return new_sweep;
 142 }
 143
 144
 145 Ray *RSL_get_window_from_ray(Ray *r, float min_range, float max_range,
 146                                                                  float low_azim, float hi_azim)
 147 {
 148   float start_km, binsize;
 149   int start_index, end_index;
 150   Ray *new_ray;
 151   int i;
 152
 153   if (min_range > max_range || min_range < 0 || max_range < 0){
 154         if (radar_verbose_flag)
 155         fprintf(stderr,"Get win from ray: given invalid min range (%f) or max range (%f)\n",
 156                    min_range, max_range);
 157         return NULL;
 158   }
 159
 160   if (r == NULL || r->h.azimuth < low_azim || r->h.azimuth >= hi_azim)
 161         return NULL;
 162
 163   /* convert from meter to km */
 164   start_km = r->h.range_bin1/1000.0;
 165   binsize = r->h.gate_size/1000.0;
 166
 167   end_index = (int) ( (max_range - start_km) / binsize) + 1;
 168   if (end_index > r->h.nbins)
 169         end_index = r->h.nbins;
 170
 171   if (min_range == 0.0)
 172         start_index = 0;
 173   else
 174         start_index = (int) ( (min_range - start_km) / binsize);
 175
 176
 177   if ((new_ray = RSL_copy_ray(r)) == NULL) return NULL;
 178   if ((new_ray = RSL_clear_ray(new_ray)) == NULL) return NULL;
 179
 180
 181   for (i = start_index; i < end_index; i++) {
 182         new_ray->range[i] = r->range[i];
 183   }
 184   return new_ray;
 185 }
 186
 187
 188
 189
 190
 191
 192
 193
 194
 195
 196
 197
 198
 199
 200
 201
 202
 203
 204