def test_beam_height_n(self):
self.assertTrue(np.allclose(
georef.beam_height_n(np.arange(10., 101., 10.) * 1000., 2.),
np.array([354.87448647, 721.50702113, 1099.8960815,
1490.04009656, 1891.93744678, 2305.58646416,
2730.98543223, 3168.13258613, 3617.02611263,
4077.66415017])))
def test_beam_height_n(self):
self.assertTrue(np.allclose(georef.beam_height_n(np.arange(10., 101., 10.) * 1000., 2.),
np.array([354.87448647, 721.50702113, 1099.8960815,
1490.04009656, 1891.93744678, 2305.58646416,
2730.98543223, 3168.13258613, 3617.02611263,
4077.66415017])))
def maximum_intensity_projection(data, r=None, az=None, angle=None, elev=None, autoext=True):
"""
Computes the maximum intensity projection along an arbitrary cut through the ppi
from polar data.
Parameters
----------
data : array
Array containing polar data (azimuth, range)
r : array
Array containing range data
az : array
Array containing azimuth data
angle : float
angle of slice, Defaults to 0. Should be between 0 and 180.
0. means horizontal slice, 90. means vertical slice
elev : float
elevation angle of scan, Defaults to 0.
autoext : True | False
This routine uses numpy.digitize to bin the data.
As this function needs bounds, we create one set of coordinates more than
would usually be provided by `r` and `az`.
Returns
-------
xs : array
meshgrid x array
ys : array
meshgrid y array
mip : array
Array containing the maximum intensity projection (range, range*2)
"""
from wradlib.georef import beam_height_n as beam_height_n
# this may seem odd at first, but d1 and d2 are also used in several plotting
# functions and thus it may be easier to compare the functions
d1 = r
d2 = az
# providing 'reasonable defaults', based on the data's shape
if d1 is None:
d1 = np.arange(data.shape[1], dtype=np.float)
if d2 is None:
d2 = np.arange(data.shape[0], dtype=np.float)
if angle is None:
angle = 0.0
if elev is None:
elev = 0.0
if autoext:
# the ranges need to go 'one bin further', assuming some regularity
# we extend by the distance between the preceding bins.
x = np.append(d1, d1[-1] + (d1[-1] - d1[-2]))
# the angular dimension is supposed to be cyclic, so we just add the
# first element
y = np.append(d2, d2[0])
else:
# no autoext basically is only useful, if the user supplied the correct
# dimensions himself.
x = d1
y = d2
# roll data array to specified azimuth, assuming equidistant azimuth angles
ind = (d2 >= angle).nonzero()[0][0]
data = np.roll(data, ind, axis=0)
# build cartesian range array, add delta to last element to compensate for
# open bound (np.digitize)
dc = np.linspace(-np.max(d1), np.max(d1) + 0.0001, num=d1.shape[0] * 2 + 1)
# get height values from polar data and build cartesian height array
# add delta to last element to compensate for open bound (np.digitize)
hp = np.zeros((y.shape[0], x.shape[0]))
hc = beam_height_n(x, elev)
hp[:] = hc
hc[-1] += 0.0001
# create meshgrid for polar data
xx, yy = np.meshgrid(x, y)
# create meshgrid for cartesian slices
xs, ys = np.meshgrid(dc, hc)
# xs, ys = np.meshgrid(dc,x)
# convert polar coordinates to cartesian
xxx = xx * np.cos(np.radians(90. - yy))
# yyy = xx * np.sin(np.radians(90.-yy))
# digitize coordinates according to cartesian range array
range_dig1 = np.digitize(xxx.ravel(), dc)
range_dig1.shape = xxx.shape
# digitize heights according polar height array
height_dig1 = np.digitize(hp.ravel(), hc)
# reshape accordingly
height_dig1.shape = hp.shape
# what am I doing here?!
range_dig1 = range_dig1[0:-1, 0:-1]
height_dig1 = height_dig1[0:-1, 0:-1]
# create height and range masks
height_mask = [(height_dig1 == i).ravel().nonzero()[0] for i in range(1, len(hc))]
range_mask = [(range_dig1 == i).ravel().nonzero()[0] for i in range(1, len(dc))]
# create mip output array, set outval to inf
mip = np.zeros((d1.shape[0], 2 * d1.shape[0]))
mip[:] = np.inf
# fill mip array,
# in some cases there are no values found in the specified range and height
# then we fill in nans and interpolate afterwards
for i in range(0, len(range_mask)):
mask1 = range_mask[i]
found = False
for j in range(0, len(height_mask)):
mask2 = np.intersect1d(mask1, height_mask[j])
# this is to catch the ValueError from the max() routine when calculating
# on empty array
try:
mip[j, i] = data.ravel()[mask2].max()
if not found:
found = True
except ValueError:
if found:
mip[j, i] = np.nan
# interpolate nans inside image, do not touch outvals
good = ~np.isnan(mip)
xp = good.ravel().nonzero()[0]
fp = mip[~np.isnan(mip)]
x = np.isnan(mip).ravel().nonzero()[0]
mip[np.isnan(mip)] = np.interp(x, xp, fp)
# reset outval to nan
mip[mip == np.inf] = np.nan
return xs, ys, mip
def maximum_intensity_projection(data,
r=None,
az=None,
angle=None,
elev=None,
autoext=True):
"""
Computes the maximum intensity projection along an arbitrary cut
through the ppi from polar data.
Parameters
----------
data : :class:`numpy:numpy.ndarray`
Array containing polar data (azimuth, range)
r : :class:`numpy:numpy.ndarray`
Array containing range data
az : array
Array containing azimuth data
angle : float
angle of slice, Defaults to 0. Should be between 0 and 180.
0. means horizontal slice, 90. means vertical slice
elev : float
elevation angle of scan, Defaults to 0.
autoext : True | False
This routine uses numpy.digitize to bin the data.
As this function needs bounds, we create one set of coordinates more
than would usually be provided by `r` and `az`.
Returns
-------
xs : :class:`numpy:numpy.ndarray`
meshgrid x array
ys : :class:`numpy:numpy.ndarray`
meshgrid y array
mip : :class:`numpy:numpy.ndarray`
Array containing the maximum intensity projection (range, range*2)
"""
from wradlib.georef import beam_height_n as beam_height_n
# this may seem odd at first, but d1 and d2 are also used in several
# plotting functions and thus it may be easier to compare the functions
d1 = r
d2 = az
# providing 'reasonable defaults', based on the data's shape
if d1 is None:
d1 = np.arange(data.shape[1], dtype=np.float)
if d2 is None:
d2 = np.arange(data.shape[0], dtype=np.float)
if angle is None:
angle = 0.0
if elev is None:
elev = 0.0
if autoext:
# the ranges need to go 'one bin further', assuming some regularity
# we extend by the distance between the preceding bins.
x = np.append(d1, d1[-1] + (d1[-1] - d1[-2]))
# the angular dimension is supposed to be cyclic, so we just add the
# first element
y = np.append(d2, d2[0])
else:
# no autoext basically is only useful, if the user supplied the correct
# dimensions himself.
x = d1
y = d2
# roll data array to specified azimuth, assuming equidistant azimuth angles
ind = (d2 >= angle).nonzero()[0][0]
data = np.roll(data, ind, axis=0)
# build cartesian range array, add delta to last element to compensate for
# open bound (np.digitize)
dc = np.linspace(-np.max(d1), np.max(d1) + 0.0001, num=d1.shape[0] * 2 + 1)
# get height values from polar data and build cartesian height array
# add delta to last element to compensate for open bound (np.digitize)
hp = np.zeros((y.shape[0], x.shape[0]))
hc = beam_height_n(x, elev)
hp[:] = hc
hc[-1] += 0.0001
# create meshgrid for polar data
xx, yy = np.meshgrid(x, y)
# create meshgrid for cartesian slices
xs, ys = np.meshgrid(dc, hc)
# xs, ys = np.meshgrid(dc,x)
# convert polar coordinates to cartesian
xxx = xx * np.cos(np.radians(90. - yy))
# yyy = xx * np.sin(np.radians(90.-yy))
# digitize coordinates according to cartesian range array
range_dig1 = np.digitize(xxx.ravel(), dc)
range_dig1.shape = xxx.shape
# digitize heights according polar height array
height_dig1 = np.digitize(hp.ravel(), hc)
# reshape accordingly
height_dig1.shape = hp.shape
# what am I doing here?!
range_dig1 = range_dig1[0:-1, 0:-1]
height_dig1 = height_dig1[0:-1, 0:-1]
# create height and range masks
height_mask = [(height_dig1 == i).ravel().nonzero()[0]
for i in range(1, len(hc))]
range_mask = [(range_dig1 == i).ravel().nonzero()[0]
for i in range(1, len(dc))]
# create mip output array, set outval to inf
mip = np.zeros((d1.shape[0], 2 * d1.shape[0]))
mip[:] = np.inf
# fill mip array,
# in some cases there are no values found in the specified range and height
# then we fill in nans and interpolate afterwards
for i in range(0, len(range_mask)):
mask1 = range_mask[i]
found = False
for j in range(0, len(height_mask)):
mask2 = np.intersect1d(mask1, height_mask[j])
# this is to catch the ValueError from the max() routine when
# calculating on empty array
try:
mip[j, i] = data.ravel()[mask2].max()
if not found:
found = True
except ValueError:
if found:
mip[j, i] = np.nan
# interpolate nans inside image, do not touch outvals
good = ~np.isnan(mip)
xp = good.ravel().nonzero()[0]
fp = mip[~np.isnan(mip)]
x = np.isnan(mip).ravel().nonzero()[0]
mip[np.isnan(mip)] = np.interp(x, xp, fp)
# reset outval to nan
mip[mip == np.inf] = np.nan
return xs, ys, mip
def pcc_plot_cg_rhi(data, r=None, th=None, th_res=None, autoext=True, refrac=True,
rf=1., fig=None, subplot=111, **kwargs):
import numpy as np
from wradlib import georef as georef
import wradlib as wrl
# autogenerate axis dimensions
if r is None:
d1 = np.arange(data.shape[1], dtype=np.float)
else:
d1 = np.asanyarray(r)
if th is None:
# assume, data is evenly spaced between 0 and 90 degree
d2 = np.linspace(0., 90., num=data.shape[0], endpoint=True)
# d2 = np.arange(data.shape[0], dtype=np.float)
else:
d2 = np.asanyarray(th)
if autoext:
# extend the range by the delta of the two last bins
x = np.append(d1, d1[-1] + d1[-1] - d1[-2])
# RHIs usually aren't cyclic, so we best guess a regular extension
# here as well
y = np.append(d2, d2[-1] + d2[-1] - d2[-2])
else:
# hopefully, the user supplied everything correctly...
x = d1
y = d2
if th_res is not None:
# we are given a beam resolution and thus may not just glue each
# beam to its neighbor
# solving this still with the efficient pcolormesh but interlacing
# the data with masked values, simulating the gap between beams
# make a temporary data array with one dimension twice the size of
# the original
img = np.ma.empty((data.shape[0], data.shape[1] * 2))
# mask everything
img.mask = np.ma.masked
# set the data in the first half of the temporary array
# this automatically unsets the mask
img[:, :data.shape[1]] = data
# reshape so that data and masked lines interlace each other
img = img.reshape((-1, data.shape[1]))
# produce lower and upper y coordinates for the actual data
yl = d2 - th_res * 0.5
yu = d2 + th_res * 0.5
# glue them together to achieve the proper dimensions for the
# interlaced array
y = np.concatenate([yl[None, :], yu[None, :]], axis=0).T.ravel()
else:
img = data
# create curvelinear axes
cgax, caax, paax = wrl.vis.create_cg('RHI', fig, subplot)
# this is in fact the outermost thick "ring" aka max_range
cgax.axis["lon"] = cgax.new_floating_axis(1, np.max(x) / rf)
cgax.axis["lon"].major_ticklabels.set_visible(False)
# and also set tickmarklength to zero for better presentation
cgax.axis["lon"].major_ticks.set_ticksize(0)
if refrac:
# observing air refractivity, so ground distances and beam height
# must be calculated specially
# create coordinates for all vertices
xx, yy = np.meshgrid(x, y)
xxx = georef.arc_distance_n(xx, yy) / rf
yyy = georef.beam_height_n(xx, yy) / rf
# assign twin-axis/cartesian-axis as plotting axis
plax = caax
else:
# otherwise plotting to parasite axis will do
# create meshgrid for polar data
# please note that the data is plottet within a polar grid
# with 0 degree at 3 o'clock, hence the slightly other data handling
xxx, yyy = np.meshgrid(y, x)
yyy /= rf
img = img.transpose()
# assign parasite axis as plotting axis
plax = paax
# plot the stuff
pm = plax.pcolormesh(xxx, yyy, img, **kwargs)
# set bounds to maximum
cgax.set_ylim(0, np.max(x) / rf)
cgax.set_xlim(0, np.max(x) / rf)
# show curvelinear and cartesian grids
# makes no sense not to plot, if we made such a fuss to get that handled
cgax.grid(True)
caax.grid(True)
# return references to important and eventually new objects
return cgax, caax, paax, pm, xxx, yyy