def test_get_wradlib_data_path(self):
wrl_data_path = os.environ.get('WRADLIB_DATA', None)
del os.environ['WRADLIB_DATA']
with self.assertRaises(EnvironmentError):
util.get_wradlib_data_path()
filename = 'rainbow/2013070308340000dBuZ.azi'
os.environ['WRADLIB_DATA'] = os.path.join(wrl_data_path, filename)
with self.assertRaises(EnvironmentError):
util.get_wradlib_data_path()
os.environ['WRADLIB_DATA'] = wrl_data_path
filename = os.path.join(wrl_data_path, "test.dat")
with self.assertRaises(EnvironmentError):
util.get_wradlib_data_file(filename)
def test_get_vector_coordinates(self):
filename = util.get_wradlib_data_file("shapefiles/agger/" "agger_merge.shp")
ds, layer = wradlib.io.open_vector(filename)
# this also tests equality with `ogr_to_numpy`
x, attrs = georef.get_vector_coordinates(layer, key="FID")
assert attrs == list(range(13))
x, attrs = georef.get_vector_coordinates(layer)
y = []
layer.ResetReading()
for i in range(layer.GetFeatureCount()):
feature = layer.GetNextFeature()
if feature:
geom = feature.GetGeometryRef()
y.append(georef.ogr_to_numpy(geom))
y = np.array(y)
for x1, y1 in zip(x, y):
np.testing.assert_allclose(x1, y1)
layer.ResetReading()
x, attrs = georef.get_vector_coordinates(
layer, source_srs=self.proj, dest_srs=self.wgs84
)
layer.ResetReading()
x, attrs = georef.get_vector_coordinates(layer, dest_srs=self.wgs84)
class TestKNMIVolume(MeasuredDataVolume):
if has_data:
name = "hdf5/knmi_polar_volume.h5"
format = "ODIM"
volumes = 1
sweeps = 14
moments = ["DBZH"]
elevations = [
0.3,
0.4,
0.8,
1.1,
2.0,
3.0,
4.5,
6.0,
8.0,
10.0,
12.0,
15.0,
20.0,
25.0,
]
azimuths = [360] * sweeps
ranges = [320, 240, 240, 240, 240, 340, 340, 300, 300, 240, 240, 240, 240, 240]
data = io.read_generic_hdf5(util.get_wradlib_data_file(name))
dsdesc = "dataset{}"
mdesc = "data{}"
def setUp(self):
filename = 'geo/bonn_new.tif'
geofile = util.get_wradlib_data_file(filename)
self.ds = open_raster(geofile)
(self.data, self.coords,
self.proj) = georef.extract_raster_dataset(self.ds)
self.x_sp, self.y_sp = self.coords[1, 1] - self.coords[0, 0]
class TestGamicVolume(MeasuredDataVolume):
if has_data:
name = "hdf5/DWD-Vol-2_99999_20180601054047_00.h5"
format = "GAMIC"
volumes = 1
sweeps = 10
moments = [
"DBZH",
"DBZV",
"DBTH",
"DBTV",
"ZDR",
"VRADH",
"VRADV",
"WRADH",
"WRADV",
"PHIDP",
"KDP",
"RHOHV",
]
elevations = [28.0, 18.0, 14.0, 11.0, 8.2, 6.0, 4.5, 3.1, 1.7, 0.6]
azimuths = [361, 361, 361, 360, 361, 360, 360, 361, 360, 360]
ranges = [360, 500, 620, 800, 1050, 1400, 1000, 1000, 1000, 1000]
data = io.read_generic_hdf5(util.get_wradlib_data_file(name))
dsdesc = "scan{}"
mdesc = "moment_{}"
def test_ogr_copy_layer_by_name(self):
filename = util.get_wradlib_data_file("shapefiles/agger/" "agger_merge.shp")
src_ds, layer = wradlib.io.open_vector(filename)
ds = wradlib.io.gdal_create_dataset("Memory", "test", gdal_type=gdal.OF_VECTOR)
georef.ogr_copy_layer_by_name(src_ds, "agger_merge", ds)
assert isinstance(ds.GetLayer(), ogr.Layer)
with pytest.raises(ValueError):
georef.ogr_copy_layer_by_name(src_ds, "agger_merge1", ds)
def setUp(self):
filename = 'geo/bonn_new.tif'
geofile = util.get_wradlib_data_file(filename)
self.ds = open_raster(geofile)
(self.data,
self.coords,
self.proj) = georef.extract_raster_dataset(self.ds)
self.x_sp, self.y_sp = self.coords[1, 1] - self.coords[0, 0]
def test_correct_attenuation_hb(self):
filestr = "dx/raa00-dx_10908-0806021655-fbg---bin.gz"
filename = util.get_wradlib_data_file(filestr)
gateset, attrs = io.read_dx(filename)
atten.correct_attenuation_hb(gateset, mode='warn')
atten.correct_attenuation_hb(gateset, mode='nan')
atten.correct_attenuation_hb(gateset, mode='zero')
with self.assertRaises(atten.AttenuationOverflowError):
atten.correct_attenuation_hb(gateset, mode='except')
def test_dump_raster(self):
proj = osr.SpatialReference()
proj.ImportFromEPSG(31466)
filename = util.get_wradlib_data_file('shapefiles/agger/'
'agger_merge.shp')
test = zonalstats.DataSource(filename, proj)
self.assertRaises(AttributeError, test.dump_raster(
tempfile.NamedTemporaryFile(mode='w+b').name, 'netCDF',
pixel_size=100.))
def test_dump_raster(self):
proj = osr.SpatialReference()
proj.ImportFromEPSG(31466)
filename = util.get_wradlib_data_file('shapefiles/agger/'
'agger_merge.shp')
test = zonalstats.DataSource(filename, proj)
test.dump_raster(tempfile.NamedTemporaryFile(mode='w+b').name,
driver='netCDF',
pixel_size=100.)
def test_correct_attenuation_hb(self):
filestr = "dx/raa00-dx_10908-0806021655-fbg---bin.gz"
filename = util.get_wradlib_data_file(filestr)
gateset, attrs = io.read_dx(filename)
atten.correct_attenuation_hb(gateset, mode="warn")
atten.correct_attenuation_hb(gateset, mode="nan")
atten.correct_attenuation_hb(gateset, mode="zero")
with pytest.raises(atten.AttenuationOverflowError):
atten.correct_attenuation_hb(gateset, mode="except")
def test_filter_gabella(self):
filename = util.get_wradlib_data_file('misc/polar_dBZ_fbg.gz')
data = np.loadtxt(filename)
clutter.filter_gabella(data,
wsize=5,
thrsnorain=0.,
tr1=6.,
n_p=8,
tr2=1.3)
def test_get_geom_properties(self):
proj = osr.SpatialReference()
proj.ImportFromEPSG(31466)
filename = util.get_wradlib_data_file('shapefiles/agger/'
'agger_merge.shp')
test = zonalstats.DataSource(filename, proj)
np.testing.assert_array_equal([[76722499.98474795]],
test.get_geom_properties(['Area'],
filt=('FID',
1)))
def setUp(self):
filename = 'geo/bonn_new.tif'
geofile = util.get_wradlib_data_file(filename)
self.ds = wradlib.io.open_raster(geofile)
(self.data, self.coords,
self.proj) = georef.extract_raster_dataset(self.ds)
filename = 'hdf5/belgium.comp.hdf'
geofile = util.get_wradlib_data_file(filename)
self.ds2 = wradlib.io.open_raster(geofile)
(self.data2, self.coords2,
self.proj2) = georef.extract_raster_dataset(self.ds, mode="edge")
self.corner_gdalinfo = np.array([[3e5, 1e6], [3e5, 3e5], [1e6, 3e5],
[1e6, 1e6]])
self.corner_geo_gdalinfo = np.array([[-0.925465, 53.6928559],
[-0.266697, 47.4167912],
[9.0028805, 47.4160381],
[9.6641599, 53.6919969]])
def test_dump_raster(self):
proj = osr.SpatialReference()
proj.ImportFromEPSG(31466)
filename = util.get_wradlib_data_file('shapefiles/agger/'
'agger_merge.shp')
test = zonalstats.DataSource(filename, srs=proj)
test.dump_raster(tempfile.NamedTemporaryFile(mode='w+b').name,
driver='netCDF', pixel_size=100.)
test.dump_raster(tempfile.NamedTemporaryFile(mode='w+b').name,
driver='netCDF', pixel_size=100., attr='FID')
def test_get_geom_properties(self):
proj = osr.SpatialReference()
proj.ImportFromEPSG(31466)
filename = util.get_wradlib_data_file('shapefiles/agger/'
'agger_merge.shp')
test = zonalstats.DataSource(filename, proj)
np.testing.assert_array_equal(
[[76722499.98474795]],
test.get_geom_properties(['Area'],
filt=('FID', 1)))
def get_wradlib_data_file(file, file_or_filelike):
datafile = util.get_wradlib_data_file(file)
if file_or_filelike == "filelike":
_open = open
if datafile[-3:] == ".gz":
gzip = util.import_optional("gzip")
_open = gzip.open
with _open(datafile, mode="r+b") as f:
yield sio.BytesIO(f.read())
else:
yield datafile
class TestClassifyEchoFuzzyTest:
if has_data:
rhofile = util.get_wradlib_data_file("netcdf/TAG-20120801"
"-140046-02-R.nc")
phifile = util.get_wradlib_data_file("netcdf/TAG-20120801"
"-140046-02-P.nc")
reffile = util.get_wradlib_data_file("netcdf/TAG-20120801"
"-140046-02-Z.nc")
dopfile = util.get_wradlib_data_file("netcdf/TAG-20120801"
"-140046-02-V.nc")
zdrfile = util.get_wradlib_data_file("netcdf/TAG-20120801"
"-140046-02-D.nc")
mapfile = util.get_wradlib_data_file("hdf5/TAG_cmap_sweeps"
"_0204050607.hdf5")
# We need to organize our data as a dictionary
dat = {}
dat["rho"], attrs_rho = io.read_edge_netcdf(rhofile)
dat["phi"], attrs_phi = io.read_edge_netcdf(phifile)
dat["ref"], attrs_ref = io.read_edge_netcdf(reffile)
dat["dop"], attrs_dop = io.read_edge_netcdf(dopfile)
dat["zdr"], attrs_zdr = io.read_edge_netcdf(zdrfile)
dat["map"] = io.from_hdf5(mapfile)[0][0]
@requires_data
def test_classify_echo_fuzzy(self):
weights = {
"zdr": 0.4,
"rho": 0.4,
"rho2": 0.4,
"phi": 0.1,
"dop": 0.1,
"map": 0.5,
}
clutter.classify_echo_fuzzy(self.dat, weights=weights, thresh=0.5)
def setUp(self):
filename = 'dx/raa00-dx_10908-0806021655-fbg---bin.gz'
dx_file = util.get_wradlib_data_file(filename)
self.data, metadata = io.read_dx(dx_file)
radar_location = (8.005, 47.8744, 1517)
elevation = 0.5 # in degree
azimuths = np.arange(0, 360) # in degrees
ranges = np.arange(0, 128000., 1000.) # in meters
polargrid = np.meshgrid(ranges, azimuths)
coords, rad = georef.spherical_to_xyz(polargrid[0], polargrid[1],
elevation, radar_location)
self.x = coords[..., 0]
self.y = coords[..., 1]
def setUp(self):
# read the radar volume scan
filename = 'hdf5/20130429043000.rad.bewid.pvol.dbzh.scan1.hdf'
filename = util.get_wradlib_data_file(filename)
pvol = io.read_opera_hdf5(filename)
nrays = int(pvol["dataset1/where"]["nrays"])
nbins = int(pvol["dataset1/where"]["nbins"])
val = pvol["dataset%d/data1/data" % (1)]
gain = float(pvol["dataset1/data1/what"]["gain"])
offset = float(pvol["dataset1/data1/what"]["offset"])
self.val = val * gain + offset
self.rscale = int(pvol["dataset1/where"]["rscale"])
elangle = pvol["dataset%d/where" % (1)]["elangle"]
coord = georef.sweep_centroids(nrays, self.rscale, nbins, elangle)
sitecoords = (pvol["where"]["lon"], pvol["where"]["lat"],
pvol["where"]["height"])
coord, proj_radar = georef.spherical_to_xyz(coord[..., 0],
coord[..., 1],
coord[..., 2],
sitecoords,
re=6370040.,
ke=4. / 3.)
filename = 'hdf5/SAFNWC_MSG3_CT___201304290415_BEL_________.h5'
filename = util.get_wradlib_data_file(filename)
sat_gdal = io.read_safnwc(filename)
val_sat = georef.read_gdal_values(sat_gdal)
coord_sat = georef.read_gdal_coordinates(sat_gdal)
proj_sat = georef.read_gdal_projection(sat_gdal)
coord_sat = georef.reproject(coord_sat,
projection_source=proj_sat,
projection_target=proj_radar)
coord_radar = coord
interp = ipol.Nearest(coord_sat[..., 0:2].reshape(-1, 2),
coord_radar[..., 0:2].reshape(-1, 2))
self.val_sat = interp(val_sat.ravel()).reshape(val.shape)
timelag = 9 * 60
wind = 10
self.error = np.absolute(timelag) * wind
def test_get_wradlib_data_path(self):
wrl_data_path = os.environ.get('WRADLIB_DATA', None)
del os.environ['WRADLIB_DATA']
self.assertRaises(EnvironmentError,
lambda: util.get_wradlib_data_path())
filename = 'rainbow/2013070308340000dBuZ.azi'
os.environ['WRADLIB_DATA'] = os.path.join(wrl_data_path, filename)
self.assertRaises(EnvironmentError,
lambda: util.get_wradlib_data_path())
os.environ['WRADLIB_DATA'] = wrl_data_path
filename = os.path.join(wrl_data_path, "test.dat")
self.assertRaises(EnvironmentError,
lambda: util.get_wradlib_data_file(filename))
def test_maximum_intensity_projection(self):
angle = 0.0
elev = 0.0
filename = util.get_wradlib_data_file("misc/polar_dBZ_tur.gz")
data = np.loadtxt(filename)
# we need to have meter here for the georef function inside mip
d1 = np.arange(data.shape[1], dtype=np.float) * 1000
d2 = np.arange(data.shape[0], dtype=np.float)
data = np.roll(data, (d2 >= angle).nonzero()[0][0], axis=0)
# calculate max intensity proj
georef.maximum_intensity_projection(data, r=d1, az=d2, angle=angle, elev=elev)
georef.maximum_intensity_projection(data, autoext=False)
def test_roll2d_polar(self):
filename = util.get_wradlib_data_file("misc/polar_dBZ_tur.gz")
data = np.loadtxt(filename)
result1 = util.roll2d_polar(data, 1, axis=0)
result2 = util.roll2d_polar(data, -1, axis=0)
result3 = util.roll2d_polar(data, 1, axis=1)
result4 = util.roll2d_polar(data, -1, axis=1)
np.testing.assert_equal(result1, np.roll(data, 1, axis=0))
np.testing.assert_equal(result2, np.roll(data, -1, axis=0))
np.testing.assert_equal(result3[:, 1:],
np.roll(data, 1, axis=1)[:, 1:])
np.testing.assert_equal(result4[:, :-1],
np.roll(data, -1, axis=1)[:, :-1])
def test_roll2d_polar(self):
filename = util.get_wradlib_data_file('misc/polar_dBZ_tur.gz')
data = np.loadtxt(filename)
result1 = util.roll2d_polar(data, 1, axis=0)
result2 = util.roll2d_polar(data, -1, axis=0)
result3 = util.roll2d_polar(data, 1, axis=1)
result4 = util.roll2d_polar(data, -1, axis=1)
np.testing.assert_equal(result1, np.roll(data, 1, axis=0))
np.testing.assert_equal(result2, np.roll(data, -1, axis=0))
np.testing.assert_equal(result3[:, 1:],
np.roll(data, 1, axis=1)[:, 1:])
np.testing.assert_equal(result4[:, :-1],
np.roll(data, -1, axis=1)[:, :-1])
def test_maximum_intensity_projection(self):
angle = 0.0
elev = 0.0
filename = util.get_wradlib_data_file('misc/polar_dBZ_tur.gz')
data = np.loadtxt(filename)
# we need to have meter here for the georef function inside mip
d1 = np.arange(data.shape[1], dtype=np.float) * 1000
d2 = np.arange(data.shape[0], dtype=np.float)
data = np.roll(data, (d2 >= angle).nonzero()[0][0], axis=0)
# calculate max intensity proj
util.maximum_intensity_projection(data, r=d1, az=d2,
angle=angle, elev=elev)
util.maximum_intensity_projection(data, autoext=False)
class TestGamicVolume(MeasuredDataVolume):
name = 'hdf5/DWD-Vol-2_99999_20180601054047_00.h5'
format = 'GAMIC'
volumes = 1
sweeps = 10
moments = [
'DBZH', 'DBZV', 'DBTH', 'DBTV', 'ZDR', 'VRADH', 'VRADV', 'WRADH',
'WRADV', 'PHIDP', 'KDP', 'RHOHV'
]
elevations = [28.0, 18.0, 14.0, 11.0, 8.2, 6.0, 4.5, 3.1, 1.7, 0.6]
azimuths = [361, 361, 361, 360, 361, 360, 360, 361, 360, 360]
ranges = [360, 500, 620, 800, 1050, 1400, 1000, 1000, 1000, 1000]
data = io.read_generic_hdf5(util.get_wradlib_data_file(name))
dsdesc = 'scan{}'
mdesc = 'moment_{}'
def test_dump_raster(self):
proj = osr.SpatialReference()
proj.ImportFromEPSG(31466)
filename = util.get_wradlib_data_file("shapefiles/agger/"
"agger_merge.shp")
test = zonalstats.DataSource(filename, srs=proj)
test.dump_raster(
tempfile.NamedTemporaryFile(mode="w+b").name,
driver="netCDF",
pixel_size=100.0,
)
test.dump_raster(
tempfile.NamedTemporaryFile(mode="w+b").name,
driver="netCDF",
pixel_size=100.0,
attr="FID",
)
def setUp(self):
filename = util.get_wradlib_data_file('misc/msf_xband.gz')
msf = io.get_membership_functions(filename)
self.msf_idp = msf[0, 0, :, 0]
self.msf_obs = msf[..., 1:]
self.hmca = np.array([[4.34960938, 15.68457031, 14.62988281],
[7.78125, 5.49902344, 5.03808594],
[0.49659729, 0.22286987, 0.86561584],
[-9.11071777, -1.60217285, 11.15356445],
[25.6, 25.6, 25.6]])
self.msf_val = classify.msf_index_indep(self.msf_obs, self.msf_idp,
self.hmca[0])
self.fu = classify.fuzzyfi(self.msf_val, self.hmca)
self.w = np.array([2., 1., 1., 1., 1.])
self.prob = classify.probability(self.fu, self.w)
def setUp(self):
f = 'gpm/2A-CS-151E24S154E30S.GPM.Ku.V7-20170308.20141206-S095002-E095137.004383.V05A.HDF5' # noqa
gpm_file = util.get_wradlib_data_file(f)
pr_data = read_generic_hdf5(gpm_file)
pr_lon = pr_data['NS/Longitude']['data']
pr_lat = pr_data['NS/Latitude']['data']
zenith = pr_data['NS/PRE/localZenithAngle']['data']
wgs84 = georef.get_default_projection()
a = wgs84.GetSemiMajor()
b = wgs84.GetSemiMinor()
rad = georef.proj4_to_osr(
('+proj=aeqd +lon_0={lon:f} ' +
'+lat_0={lat:f} +a={a:f} +b={b:f}' + '').format(lon=pr_lon[68, 0],
lat=pr_lat[68, 0],
a=a,
b=b))
pr_x, pr_y = georef.reproject(pr_lon,
pr_lat,
projection_source=wgs84,
projection_target=rad)
self.re = georef.get_earth_radius(pr_lat[68, 0], wgs84) * 4. / 3.
self.pr_xy = np.dstack((pr_x, pr_y))
self.alpha = zenith
self.zt = 407000.
self.dr = 125.
self.bw_pr = 0.71
self.nbin = 176
self.nray = pr_lon.shape[1]
self.pr_out = np.array([[[[-58533.78453556, 124660.60390174],
[-58501.33048429, 124677.58873852]],
[[-53702.13393133, 127251.83656509],
[-53670.98686161, 127268.11882882]]],
[[[-56444.00788528, 120205.5374491],
[-56411.55421163, 120222.52300741]],
[[-51612.2360682, 122796.78620764],
[-51581.08938314, 122813.06920719]]]])
self.r_out = np.array(
[0., 125., 250., 375., 500., 625., 750., 875., 1000., 1125.])
self.z_out = np.array([
0., 119.51255112, 239.02510224, 358.53765337, 478.05020449,
597.56275561, 717.07530673, 836.58785786, 956.10040898,
1075.6129601
])
class TestKNMIVolume(MeasuredDataVolume):
name = 'hdf5/knmi_polar_volume.h5'
format = 'ODIM'
volumes = 1
sweeps = 14
moments = ['DBZH']
elevations = [
0.3, 0.4, 0.8, 1.1, 2.0, 3.0, 4.5, 6.0, 8.0, 10.0, 12.0, 15.0, 20.0,
25.0
]
azimuths = [360] * sweeps
ranges = [
320, 240, 240, 240, 240, 340, 340, 300, 300, 240, 240, 240, 240, 240
]
data = io.read_generic_hdf5(util.get_wradlib_data_file(name))
dsdesc = 'dataset{}'
mdesc = 'data{}'
def setUp(self):
f = 'gpm/2A-CS-151E24S154E30S.GPM.Ku.V7-20170308.20141206-S095002-E095137.004383.V05A.HDF5' # noqa
gpm_file = util.get_wradlib_data_file(f)
pr_data = read_generic_hdf5(gpm_file)
pr_lon = pr_data['NS/Longitude']['data']
pr_lat = pr_data['NS/Latitude']['data']
zenith = pr_data['NS/PRE/localZenithAngle']['data']
wgs84 = georef.get_default_projection()
a = wgs84.GetSemiMajor()
b = wgs84.GetSemiMinor()
rad = georef.proj4_to_osr(('+proj=aeqd +lon_0={lon:f} ' +
'+lat_0={lat:f} +a={a:f} +b={b:f}' +
'').format(lon=pr_lon[68, 0],
lat=pr_lat[68, 0],
a=a, b=b))
pr_x, pr_y = georef.reproject(pr_lon, pr_lat,
projection_source=wgs84,
projection_target=rad)
self.re = georef.get_earth_radius(pr_lat[68, 0], wgs84) * 4. / 3.
self.pr_xy = np.dstack((pr_x, pr_y))
self.alpha = zenith
self.zt = 407000.
self.dr = 125.
self.bw_pr = 0.71
self.nbin = 176
self.nray = pr_lon.shape[1]
self.pr_out = np.array([[[[-58533.78453556, 124660.60390174],
[-58501.33048429, 124677.58873852]],
[[-53702.13393133, 127251.83656509],
[-53670.98686161, 127268.11882882]]],
[[[-56444.00788528, 120205.5374491],
[-56411.55421163, 120222.52300741]],
[[-51612.2360682, 122796.78620764],
[-51581.08938314, 122813.06920719]]]])
self.r_out = np.array([0., 125., 250., 375., 500., 625., 750., 875.,
1000., 1125.])
self.z_out = np.array([0., 119.51255112, 239.02510224, 358.53765337,
478.05020449, 597.56275561, 717.07530673,
836.58785786, 956.10040898, 1075.6129601])
def setUp(self):
self.proj = osr.SpatialReference()
self.proj.ImportFromEPSG(31466)
self.wgs84 = georef.get_default_projection()
self.npobj = np.array([[2600000., 5630000.], [2600000., 5630100.],
[2600100., 5630100.], [2600100., 5630000.],
[2600000., 5630000.]])
self.lonlat = np.array([[7.41779154, 50.79679579],
[7.41781875, 50.79769443],
[7.4192367, 50.79767718],
[7.41920947, 50.79677854],
[7.41779154, 50.79679579]])
self.ogrobj = georef.numpy_to_ogr(self.npobj, 'Polygon')
self.ogrobj.AssignSpatialReference(None)
self.projobj = georef.numpy_to_ogr(self.npobj, 'Polygon')
self.projobj.AssignSpatialReference(self.proj)
filename = util.get_wradlib_data_file('shapefiles/agger/'
'agger_merge.shp')
self.ds, self.layer = open_vector(filename)
def setUp(self):
self.proj = osr.SpatialReference()
self.proj.ImportFromEPSG(31466)
self.wgs84 = georef.get_default_projection()
self.npobj = np.array([[2600000., 5630000.], [2600000., 5630100.],
[2600100., 5630100.], [2600100., 5630000.],
[2600000., 5630000.]])
self.lonlat = np.array([[7.41779154, 50.79679579],
[7.41781875, 50.79769443],
[7.4192367, 50.79767718],
[7.41920947, 50.79677854],
[7.41779154, 50.79679579]])
self.ogrobj = georef.numpy_to_ogr(self.npobj, 'Polygon')
self.ogrobj.AssignSpatialReference(None)
self.projobj = georef.numpy_to_ogr(self.npobj, 'Polygon')
self.projobj.AssignSpatialReference(self.proj)
filename = util.get_wradlib_data_file('shapefiles/agger/'
'agger_merge.shp')
self.ds, self.layer = open_vector(filename)
def setUp(self):
rhofile = util.get_wradlib_data_file('netcdf/TAG-20120801'
'-140046-02-R.nc')
phifile = util.get_wradlib_data_file('netcdf/TAG-20120801'
'-140046-02-P.nc')
reffile = util.get_wradlib_data_file('netcdf/TAG-20120801'
'-140046-02-Z.nc')
dopfile = util.get_wradlib_data_file('netcdf/TAG-20120801'
'-140046-02-V.nc')
zdrfile = util.get_wradlib_data_file('netcdf/TAG-20120801'
'-140046-02-D.nc')
mapfile = util.get_wradlib_data_file('hdf5/TAG_cmap_sweeps'
'_0204050607.hdf5')
# We need to organize our data as a dictionary
dat = {}
dat["rho"], attrs_rho = io.read_edge_netcdf(rhofile)
dat["phi"], attrs_phi = io.read_edge_netcdf(phifile)
dat["ref"], attrs_ref = io.read_edge_netcdf(reffile)
dat["dop"], attrs_dop = io.read_edge_netcdf(dopfile)
dat["zdr"], attrs_zdr = io.read_edge_netcdf(zdrfile)
dat["map"] = io.from_hdf5(mapfile)[0][0]
self.dat = dat
def test__check_src(self):
filename = util.get_wradlib_data_file('shapefiles/agger/'
'agger_merge.shp')
self.assertEqual(len(zonalstats.DataSource(filename).data), 13)
self.assertRaises(RuntimeError,
lambda: zonalstats.DataSource('test_zonalstats.py'))
def test__check_src(self):
filename = util.get_wradlib_data_file('shapefiles/agger/'
'agger_merge.shp')
self.assertEqual(len(zonalstats.DataSource(filename).data), 13)
self.assertRaises(RuntimeError,
lambda: zonalstats.DataSource('test_zonalstats.py'))
def test_histo_cut_test(self):
filename = util.get_wradlib_data_file('misc/annual_rainfall_fbg.gz')
yearsum = np.loadtxt(filename)
clutter.histo_cut(yearsum)
def test_get_wradlib_data_path_requires(self):
filename = os.path.join(util.get_wradlib_data_path(), "test.dat")
with pytest.raises(EnvironmentError):
util.get_wradlib_data_file(filename)
from pcc import get_my_cmap
my_cmap2 = get_my_cmap()
def read_and_overview(filename):
"""Read NetCDF using read_generic_netcdf and print upper level dictionary keys
"""
test = read_generic_netcdf(filename)
print("\nPrint keys for file %s" % os.path.basename(filename))
for key in test.keys():
print("\t%s" % key)
pfad = ('/automount/ags/velibor/gpmdata/nicht3dComposit/*.nc')
pfad_3d = sorted(glob.glob(pfad))[1]
comp3d = get_wradlib_data_file(pfad_3d)
#read_and_overview(comp3d)
from netCDF4 import Dataset
import numpy as np
comp3d = Dataset(pfad_3d, mode='r')
x = comp3d.variables['x'][:][300:600]
y = comp3d.variables['y'][:][300:600]
z = comp3d.variables['z'][:][1:60]
zh = comp3d['cband_oase_zh'][1:60,300:600,300:600]
#rwdata = np.ma.masked_equal(rwdata, -9999) / 2 - 32.5
'''
def read_and_overview(filename):
"""Read NetCDF using read_generic_netcdf and print upper level dictionary keys
"""
test = read_generic_netcdf(filename)
print("\nPrint keys for file %s" % os.path.basename(filename))
for key in test.keys():
print("\t%s" % key)
pfad = ('/automount/ags/velibor/gpmdata/nicht3dComposit/*.nc')
pfad_3d = sorted(glob.glob(pfad))[1]
comp3d = get_wradlib_data_file(pfad_3d)
#read_and_overview(comp3d)
from netCDF4 import Dataset
import numpy as np
comp3d = Dataset(pfad_3d, mode='r')
x = comp3d.variables['x'][:][300:600]
y = comp3d.variables['y'][:][300:600]
z = comp3d.variables['z'][:][1:60]
zh = comp3d['cband_oase_zh'][1:60, 300:600, 300:600]
#rwdata = np.ma.masked_equal(rwdata, -9999) / 2 - 32.5
'''
def get_measured_volume(file, get_loader, format):
h5file = util.get_wradlib_data_file(file)
yield io.xarray.open_odim(h5file, loader=get_loader, flavour=format)
