def test_attributes_to_image(self):
obj = _cartesianvolume.new()
obj.xscale = 200.0
obj.yscale = 200.0
obj.areaextent = (1.0, 2.0, 3.0, 4.0)
obj.projection = _projection.new(
"x", "y", "+proj=latlong +ellps=WGS84 +datum=WGS84")
obj.date = "20100101"
obj.time = "100000"
obj.source = "PLC:1234"
image = _cartesian.new()
image.product = _rave.Rave_ProductType_CAPPI
obj.addImage(image)
self.assertAlmostEqual(200.0, image.xscale, 4)
self.assertAlmostEqual(200.0, image.yscale, 4)
self.assertEqual("20100101", image.date)
self.assertEqual("100000", image.time)
self.assertEqual("PLC:1234", image.source)
self.assertAlmostEqual(1.0, image.areaextent[0], 4)
self.assertAlmostEqual(2.0, image.areaextent[1], 4)
self.assertAlmostEqual(3.0, image.areaextent[2], 4)
self.assertAlmostEqual(4.0, image.areaextent[3], 4)
def test_attribute_visibility(self):
attrs = ['id', 'description', 'definition']
obj = _projection.new("x", "y",
"+proj=latlong +ellps=WGS84 +datum=WGS84")
alist = dir(obj)
for a in attrs:
self.assertEqual(True, a in alist)
def add(id,
description,
projection_id,
extent,
xsize,
ysize,
xscale,
yscale,
filename=AREA_REGISTRY):
reg = _arearegistry.load(filename)
reg.removeByName(id) # Is silent if entry doesn't exist
a = _area.new()
a.id, a.description, a.pcsid = id, description, projection_id
a.extent = extent
a.xsize, a.ysize = xsize, ysize
a.xscale, a.yscale = xscale, yscale
p = rave_projection.pcs(a.pcsid)
pid = p.id
pname = p.name
if isinstance(pid, bytes): pid = pid.decode()
if isinstance(pname, bytes): pname = pname.decode()
a.projection = _projection.new(pid, pname, " ".join(p.definition))
reg.add(a)
reg.write(filename)
def _create_lon_lat_extent(self, carg):
pj = _projection.new("x", "y", carg.area_definition.pcsdef)
lllon, lllat = pj.inv(
(carg.area_definition.extent[0], carg.area_definition.extent[1]))
urlon, urlat = pj.inv(
(carg.area_definition.extent[2], carg.area_definition.extent[3]))
return (lllon, lllat, urlon, urlat)
def test_attributes_from_image(self):
obj = _cartesianvolume.new()
obj.xscale = 200.0
obj.yscale = 200.0
image = _cartesian.new()
a = _area.new()
a.xsize = 10
a.ysize = 10
a.xscale = 100.0
a.yscale = 100.0
a.extent = (1.0, 2.0, 3.0, 4.0)
a.projection = _projection.new(
"x", "y", "+proj=latlong +ellps=WGS84 +datum=WGS84")
image.init(a)
image.date = "20100101"
image.time = "100000"
image.source = "PLC:1234"
image.product = _rave.Rave_ProductType_CAPPI
self.assertEqual(0, obj.xsize)
self.assertEqual(0, obj.ysize)
obj.addImage(image)
self.assertEqual(10, obj.xsize)
self.assertEqual(10, obj.ysize)
self.assertEqual(1, obj.getNumberOfImages())
def readCT(filename):
ct, cp = _cartesian.new(), _cartesianparam.new()
nodelist = _pyhl.read_nodelist(filename)
for n in NODENAMES:
nodelist.selectNode(n)
nodelist.fetch()
ct.defaultParameter = "CT"
ct.projection = _projection.new("MSG", "no description",
nodelist.getNode("/PROJECTION").data())
cp.setData(nodelist.getNode("/CT").data())
ysize = nodelist.getNode("/CT/N_LINES").data()
xsize = nodelist.getNode("/CT/N_COLS").data()
ULx = nodelist.getNode("/XGEO_UP_LEFT").data()
ULy = nodelist.getNode("/YGEO_UP_LEFT").data()
LRx = nodelist.getNode("/XGEO_LOW_RIGHT").data()
LRy = nodelist.getNode("/YGEO_LOW_RIGHT").data()
yscale = (ULy - LRy) / ysize
xscale = (LRx - ULx) / xsize
xoffset, yoffset = xscale / 2, yscale / 2 # Offsets to adjust LL and UR corners
LLx = LRx - (xsize * xscale) - xoffset
LLy = ULy - (ysize * yscale) - yoffset
URx = LRx + xoffset
URy = ULy + yoffset
ct.areaextent = (LLx, LLy, URx, URy) # Differs ~5 cm from PPS and PyTROLL
ct.xscale, ct.yscale = xscale, yscale
cp.quantity = "CT"
cp.gain, cp.offset = 1.0, 0.0
cp.nodata, cp.undetect = -1.0, 0.0
ct.addParameter(cp)
return ct
def testTransformx_cartesianToLonLat(self):
cproj = _projection.new(
"cartesian", "cartesian",
"+proj=stere +ellps=bessel +lat_0=90 +lon_0=14 +lat_ts=60 +datum=WGS84"
)
llproj = _projection.new("lonlat", "lonlat",
"+proj=longlat +ellps=WGS84 +datum=WGS84")
inx = 60.0 * math.pi / 180.0
iny = 14.0 * math.pi / 180.0
x, y = llproj.transformx(cproj, (inx, iny))
x, y = cproj.transformx(llproj, (x, y))
outx = x * 180.0 / math.pi
outy = y * 180.0 / math.pi
self.assertAlmostEqual(60.0, outx, 4)
self.assertAlmostEqual(14.0, outy, 4)
def test_new(self):
obj = _projection.new("x", "y",
"+proj=latlong +ellps=WGS84 +datum=WGS84")
istransform = str(type(obj)).find("ProjectionCore")
self.assertNotEqual(-1, istransform)
self.assertEqual("x", obj.id)
self.assertEqual("y", obj.description)
self.assertEqual("+proj=latlong +ellps=WGS84 +datum=WGS84",
obj.definition)
def create_area(self):
a = _area.new()
a.id = "eua_gmaps"
a.xsize = 800
a.ysize = 1090
a.xscale = 6223.0
a.yscale = 6223.0
a.extent = (-3117.83526,-6780019.83039,4975312.43200,3215.41216)
a.projection = _projection.new("x", "y", "+proj=merc +lat_ts=0 +lon_0=0 +k=1.0 +x_0=1335833 +y_0=-11000715 +a=6378137.0 +b=6378137.0 +no_defs +datum=WGS84")
return a
def test_add(self):
if not _rave.isXmlSupported():
return
import _projectionregistry
registry = _projectionregistry.load(self.FIXTURE)
newproj = _projection.new("testid", "something",
"+proj=latlong +ellps=WGS84 +datum=WGS84")
registry.add(newproj)
self.assertEqual(6, registry.size())
self.assertEqual("testid", registry.getByName("testid").id)
self.assertEqual("something", registry.getByName("testid").description)
def test_projection(self):
obj = _radardef.new()
self.assertEqual(None, obj.projection)
obj.projection = _projection.new("x", "y", "+proj=latlong +ellps=WGS84 +datum=WGS84")
self.assertEqual("x", obj.projection.id)
obj.projection = None
self.assertEqual(None, obj.projection)
def write(filename=PROJECTION_REGISTRY):
check = [] # Used to avoid duplicate entries
new_registry = _projectionregistry.new()
for p in keys():
if p not in check:
tmp = pcs(p)
new_registry.add(
_projection.new(tmp.id, tmp.name, " ".join(tmp.definition)))
check.append(p)
else:
print("Duplicate entry for id %s. Ignored." % p)
new_registry.write(filename)
def test_isArea(self):
obj = _area.new()
self.assertEqual(True, _area.isArea(obj))
self.assertEqual(
False,
_area.isArea(
_projection.new("x", "y",
"+proj=latlong +ellps=WGS84 +datum=WGS84")))
self.assertEqual(False, _area.isArea("abc"))
self.assertEqual(False, _area.isArea(None))
def test_write_2(self):
if not _rave.isXmlSupported():
return
import _projectionregistry
registry = _projectionregistry.load(self.FIXTURE)
newproj = _projection.new("testid", "something",
"+proj=latlong +ellps=WGS84 +datum=WGS84")
registry.add(newproj)
registry.write(self.TEMPORARY_FILE)
nreg = _projectionregistry.load(self.TEMPORARY_FILE)
self.assertEqual(6, nreg.size())
self.assertEqual("testid", nreg.get(5).id)
self.assertEqual("something", nreg.get(5).description)
self.assertEqual("+proj=latlong +ellps=WGS84 +datum=WGS84",
nreg.get(5).definition)
def test_write(self):
if not _rave.isXmlSupported():
return
import _projectionregistry
registry = _projectionregistry.load(self.FIXTURE)
newproj = _projection.new("testid", "something",
"+proj=latlong +ellps=WGS84 +datum=WGS84")
registry.add(newproj)
registry.write(self.TEMPORARY_FILE)
tree = ElementTree.parse(self.TEMPORARY_FILE)
projs = tree.findall("projection")
self.assertEqual(6, len(projs))
self.assertEqual("testid", projs[5].get('id'))
self.assertEqual("something",
projs[5].find("description").text.strip())
self.assertEqual("+proj=latlong +ellps=WGS84 +datum=WGS84",
projs[5].find("projdef").text.strip())
def test_init(self):
obj = _cartesian.new()
a = _area.new()
a.xsize = 10
a.ysize = 10
a.xscale = 100.0
a.yscale = 100.0
a.extent = (1.0, 2.0, 3.0, 4.0)
a.projection = _projection.new(
"x", "y", "+proj=latlong +ellps=WGS84 +datum=WGS84")
obj.init(a)
self.assertEqual(10, obj.xsize)
self.assertEqual(10, obj.ysize)
self.assertAlmostEqual(100.0, obj.xscale, 4)
self.assertAlmostEqual(100.0, obj.yscale, 4)
self.assertAlmostEqual(1.0, obj.areaextent[0], 4)
self.assertAlmostEqual(2.0, obj.areaextent[1], 4)
self.assertAlmostEqual(3.0, obj.areaextent[2], 4)
self.assertAlmostEqual(4.0, obj.areaextent[3], 4)
self.assertEqual("x", obj.projection.id)
def test_isValid_asImage_no_date(self):
obj = _cartesian.new()
param = _cartesianparam.new()
param.quantity = "DBZH"
param.setData(numpy.zeros((10, 10), numpy.uint8))
a = _area.new()
a.xsize = 10
a.ysize = 10
a.xscale = 100.0
a.yscale = 100.0
a.extent = (1.0, 2.0, 3.0, 4.0)
a.projection = _projection.new(
"x", "y", "+proj=latlong +ellps=WGS84 +datum=WGS84")
obj.init(a)
obj.time = "100000"
obj.source = "PLC:1234"
obj.product = _rave.Rave_ProductType_CAPPI
obj.addParameter(param)
self.assertEqual(False, obj.isValid(_rave.Rave_ObjectType_IMAGE))
def testFwd_gnom(self):
cproj = _projection.new(
"gnom", "gnom",
"+proj=gnom +R=6371000.0 +lat_0=56.3675 +lon_0=12.8544")
xy = cproj.fwd(deg2rad((12.8544, 56.3675)))
self.assertAlmostEqual(0.0, xy[0], 4)
self.assertAlmostEqual(0.0, xy[1], 4)
xy = cproj.fwd(deg2rad((12.8544, 56.5675)))
self.assertAlmostEqual(0.0, xy[0], 4)
self.assertTrue(xy[1] > 0.0)
xy = cproj.fwd(deg2rad((12.8544, 56.1675)))
self.assertAlmostEqual(0.0, xy[0], 4)
self.assertTrue(xy[1] < 0.0)
xy = cproj.fwd(deg2rad((12.8744, 56.3675)))
self.assertTrue(xy[0] > 0.0)
xy = cproj.fwd(deg2rad((12.8344, 56.3675)))
self.assertTrue(xy[0] < 0.0)
def getarea(self, areaid):
if not areaid in self._registry.keys():
self._loadarea(areaid)
if areaid in self._registry.keys():
result = self._registry[areaid]
else:
a = area.area(areaid)
p = a.pcs
pyarea = _area.new()
pyarea.id = a.Id
pyarea.xsize = a.xsize
pyarea.ysize = a.ysize
pyarea.xscale = a.xscale
pyarea.yscale = a.yscale
pyarea.extent = a.extent
pyarea.projection = _projection.new(p.id, str(p.name),
' '.join(p.definition))
self._registry[pyarea.id] = pyarea
result = pyarea
return result
def test_zsize(self):
obj = _cartesianvolume.new()
a = _area.new()
a.xsize = 10
a.ysize = 10
a.xscale = 100.0
a.yscale = 100.0
a.extent = (1.0, 2.0, 3.0, 4.0)
a.projection = _projection.new(
"x", "y", "+proj=latlong +ellps=WGS84 +datum=WGS84")
try:
obj.zsize = 2
fail("Expected AttributeError")
except AttributeError:
pass
self.assertEqual(0, obj.zsize)
image1 = _cartesian.new()
image2 = _cartesian.new()
image1.init(a)
image2.init(a)
image1.date = "20100101"
image1.time = "100000"
image1.source = "PLC:1234"
image1.product = _rave.Rave_ProductType_CAPPI
image2.date = "20100101"
image2.time = "100000"
image2.source = "PLC:1234"
image2.product = _rave.Rave_ProductType_CAPPI
obj.addImage(image1)
obj.addImage(image2)
self.assertEqual(2, obj.getNumberOfImages())
self.assertEqual(2, obj.zsize)
def create_cartesian_with_parameter(self, xsize, ysize, xscale, yscale,
extent, projstr, dtype, value,
quantity):
obj = _cartesian.new()
a = _area.new()
a.xsize = xsize
a.ysize = ysize
a.xscale = xscale
a.yscale = yscale
a.extent = extent
a.projection = _projection.new("x", "y", projstr)
obj.init(a)
for i in range(len(quantity)):
data = numpy.zeros((ysize, xsize), dtype)
data = data + value[i]
param = _cartesianparam.new()
param.setData(data)
param.nodata = 255.0
param.quantity = quantity[i]
obj.addParameter(param)
return obj
def test_createParameter(self):
obj = _cartesian.new()
a = _area.new()
a.xsize = 10
a.ysize = 10
a.xscale = 100.0
a.yscale = 100.0
a.extent = (1.0, 2.0, 3.0, 4.0)
a.projection = _projection.new(
"x", "y", "+proj=latlong +ellps=WGS84 +datum=WGS84")
obj.init(a)
param = obj.createParameter("DBZH", _rave.RaveDataType_UCHAR)
self.assertEqual(10, param.xsize)
self.assertEqual(10, param.ysize)
self.assertEqual("DBZH", param.quantity)
param = obj.createParameter("MMH", _rave.RaveDataType_UCHAR)
self.assertEqual(10, param.xsize)
self.assertEqual(10, param.ysize)
self.assertEqual("MMH", param.quantity)
self.assertTrue(obj.hasParameter("DBZH"))
self.assertTrue(obj.hasParameter("MMH"))
def testInv_gnom(self):
cproj = _projection.new(
"gnom", "gnom",
"+proj=gnom +R=6371000.0 +lat_0=56.3675 +lon_0=12.8544")
ll = rad2deg(cproj.inv((0.0, 0.0)))
self.assertAlmostEqual(12.8544, ll[0], 4)
self.assertAlmostEqual(56.3675, ll[1], 4)
ll = rad2deg(cproj.inv((0.0, 1000.0)))
self.assertAlmostEqual(12.8544, ll[0], 4)
self.assertTrue(ll[1] > 56.3675)
ll = rad2deg(cproj.inv((0.0, -1000.0)))
self.assertAlmostEqual(12.8544, ll[0], 4)
self.assertTrue(ll[1] < 56.3675)
ll = rad2deg(cproj.inv((1000.0, 0.0)))
self.assertTrue(ll[0] > 12.8544)
self.assertAlmostEqual(56.3675, ll[1], 4)
ll = rad2deg(cproj.inv((-1000.0, 0.0)))
self.assertTrue(ll[0] < 12.8544)
self.assertAlmostEqual(56.3675, ll[1], 4)
def read_topo():
for tile in ["W020N90", "E020N90"]:
# extract meta-data
fnm = "../db/topo/" + tile + "/" + tile + ".HDR"
fid = open(fnm, "r")
byteorder = fid.readline().split()[1]
layout = fid.readline().split()[1]
nrows = int(fid.readline().split()[1])
ncols = int(fid.readline().split()[1])
nbands = int(fid.readline().split()[1])
nbits = int(fid.readline().split()[1])
bandrowbytes = int(fid.readline().split()[1])
totalrowbytes = int(fid.readline().split()[1])
bandgapbytes = int(fid.readline().split()[1])
nodata = int(fid.readline().split()[1])
# longitude of the center of the upper-left pixel (decimal degrees)
ulxmap = float(fid.readline().split()[1])
# latitude of the center of the upper-left pixel (decimal degrees)
ulymap = float(fid.readline().split()[1])
# x dimension of a pixel in geographic units (decimal degrees)
xdim = float(fid.readline().split()[1])
# y dimension of a pixel in geographic units (decimal degrees)
ydim = float(fid.readline().split()[1])
fid.close()
# extract topography
fnm = "../db/topo/" + tile + "/" + tile + ".DEM"
fid = open(fnm, "r")
data = fid.read()
data = fromstring(data, short).byteswap()
data = data.reshape(nrows, ncols)
print("data type and shape: ", data.dtype, data.shape)
fid.close()
# longitude of the lower-left corner of the lower-left pixel (decimal degrees)
llxmap = ulxmap - xdim / 2
# latitude of the lower-left corner of the lower-left pixel (decimal degrees)
llymap = (ulymap - ydim / 2) - ((nrows - 1) * ydim)
# longitude of the lower-left corner of the upper-right pixel (decimal degrees)
urxmap = llxmap + ((ncols - 1) * xdim)
# latitude of the lower-left corner of the upper-right pixel (decimal degrees)
urymap = llymap + ((nrows - 1) * ydim)
a = _area.new()
a.id = tile
a.projection = _projection.new("longlat_wgs84", "Plate Caree WGS84",
"+proj=eqc +ellps=WGS84 +datum=WGS84")
(llx, lly) = a.projection.fwd(deg2rad((llxmap, llymap)))
(urx, ury) = a.projection.fwd(deg2rad((urxmap, urymap)))
a.extent = (llx, lly, urx, ury)
a.xsize = ncols
a.ysize = nrows
a.xscale = (urx - llx) / (ncols - 1)
a.yscale = (ury - lly) / (nrows - 1)
print("%f,%f,%f,%f" % (llxmap, llymap, urxmap, urymap))
print("%f,%f,%f,%f" % a.extent)
print("%f,%f" % (a.xscale, a.yscale))
src = _cartesian.new()
src.init(a, _rave.RaveDataType_SHORT)
src.time = "000000"
src.date = "20100101"
src.objectType = _rave.Rave_ObjectType_IMAGE
src.product = _rave.Rave_ProductType_COMP
src.source = "GTOPO30 topography"
param = _cartesianparam.new()
param.quantity = "TOPO"
param.gain = 1.0
param.offset = 0.0
param.nodata = -9999.0
param.setData(data)
src.addParameter(param)
src.defaultParameter = "TOPO"
ios = _raveio.new()
ios.object = src
ios.filename = "./" + tile + ".h5"
ios.save()
def add(id, description, definition, filename=PROJECTION_REGISTRY):
reg = _projectionregistry.load(filename)
reg.removeByName(id) # Is silent if entry doesn't exist
reg.add(_projection.new(id, description, definition))
reg.write(filename)
def generate(self, dd, dt, tid):
comp = compositing.compositing()
comp.xscale = self.xscale
comp.yscale = self.yscale
comp.detectors = self.detectors
comp.ignore_malfunc = self.ignore_malfunc
comp.prodpar = self.prodpar
comp.product = self.product
comp.height = self.height
comp.elangle = self.elangle
comp.range = self.range
comp.selection_method = self.selection_method
comp.interpolation_method = self.interpolation_method
comp.qitotal_field = self.qitotal_field
comp.applygra = self.applygra
comp.zr_A = self.zr_A
comp.zr_b = self.zr_b
comp.applygapfilling = self.applygapfilling
comp.applyctfilter = self.applyctfilter
comp.quantity = self.quantity
comp.gain = self.gain
comp.offset = self.offset
comp.minvalue = self.minvalue
comp.filenames = self.filenames
comp.verbose = self.verbose
comp.reprocess_quality_field = self.reprocess_quality_field
comp.dump = self.dump
comp.dumppath = self.dumppath
comp.radar_index_mapping = self.radar_index_mapping
pyarea = _area.new()
pyarea.id = "tiled area subset %s" % tid
pyarea.xsize = self.area_definition.xsize
pyarea.ysize = self.area_definition.ysize
pyarea.xscale = self.area_definition.xscale
pyarea.yscale = self.area_definition.yscale
pyarea.extent = self.area_definition.extent
pyarea.projection = _projection.new("dynamic pcsid",
"dynamic pcs name",
self.area_definition.pcsdef)
logger.info("Generating composite for tile %s" %
self.area_definition.id)
result = comp.generate(dd, dt, pyarea)
if result == None:
logger.info("No composite for tile %s could be generated.",
self.area_definition.id)
return (tid, None)
else:
logger.info("Finished generating composite for tile %s",
self.area_definition.id)
fileno, outfile = rave_tempfile.mktemp(suffix='.h5', close="True")
rio = _raveio.new()
rio.object = result
rio.filename = outfile
rio.save()
return (tid, rio.filename)
def test_invalid_projection(self):
try:
_projection.new("x", "y", "+proj=unknown + ellps=WGS84")
self.fail("Expected ValueError")
except ValueError:
pass
def test_combine_tiles_with_two_parameters(self):
pyarea = _area.new()
pyarea.extent = (971337.728807, 7196461.17902, 3015337.72881,
11028461.179)
pyarea.xscale = 511000.0
pyarea.yscale = 958000.0
pyarea.xsize = 4
pyarea.ysize = 4
pyarea.projection = _projection.new(
"x", "y",
"+proj=merc +lat_ts=0 +lon_0=0 +k=1.0 +R=6378137.0 +nadgrids=@null +no_defs"
)
ul = self.create_cartesian_with_parameter(
2, 2, pyarea.xscale, pyarea.yscale,
(971337.728807, 9112461.1790100001, 1993337.7288084999,
11028461.179), pyarea.projection.definition, numpy.uint8, [2, 12],
["DBZH", "TH"])
ul.getParameter("DBZH").addQualityField(
self.create_quality_field(2, 2, numpy.uint8, 22,
"se.some.how.task.1"))
ul.getParameter("TH").addQualityField(
self.create_quality_field(2, 2, numpy.uint8, 32,
"se.some.how.task.1"))
ur = self.create_cartesian_with_parameter(
2, 2, pyarea.xscale, pyarea.yscale,
(1993337.7288084999, 9112461.1790100001, 3015337.72881,
11028461.179), pyarea.projection.definition, numpy.uint8, [3, 13],
["DBZH", "TH"])
ur.getParameter("DBZH").addQualityField(
self.create_quality_field(2, 2, numpy.uint8, 23,
"se.some.how.task.1"))
ur.getParameter("TH").addQualityField(
self.create_quality_field(2, 2, numpy.uint8, 33,
"se.some.how.task.1"))
ll = self.create_cartesian_with_parameter(
2, 2, pyarea.xscale, pyarea.yscale,
(971337.728807, 7196461.17902, 1993337.7288084999,
9112461.1790100001), pyarea.projection.definition, numpy.uint8,
[4, 14], ["DBZH", "TH"])
ll.getParameter("DBZH").addQualityField(
self.create_quality_field(2, 2, numpy.uint8, 24,
"se.some.how.task.1"))
ll.getParameter("TH").addQualityField(
self.create_quality_field(2, 2, numpy.uint8, 34,
"se.some.how.task.1"))
lr = self.create_cartesian_with_parameter(
2, 2, pyarea.xscale, pyarea.yscale,
(1993337.7288084999, 7196461.17902, 3015337.72881,
9112461.1790100001), pyarea.projection.definition, numpy.uint8,
[5, 15], ["DBZH", "TH"])
lr.getParameter("DBZH").addQualityField(
self.create_quality_field(2, 2, numpy.uint8, 25,
"se.some.how.task.1"))
lr.getParameter("TH").addQualityField(
self.create_quality_field(2, 2, numpy.uint8, 35,
"se.some.how.task.1"))
t = _transform.new()
result = t.combine_tiles(pyarea, [ul, ur, ll, lr])
self.assertEqual(4, result.xsize)
self.assertEqual(4, result.ysize)
self.assertEqual(511000.0, result.xscale, 4)
self.assertEqual(958000.0, result.yscale, 4)
self.assertEqual(971337.728807, result.areaextent[0], 4)
self.assertEqual(7196461.17902, result.areaextent[1], 4)
self.assertEqual(3015337.72881, result.areaextent[2], 4)
self.assertEqual(11028461.179, result.areaextent[3], 4)
self.assertEqual(
"+proj=merc +lat_ts=0 +lon_0=0 +k=1.0 +R=6378137.0 +nadgrids=@null +no_defs",
result.projection.definition)
self.assertEqual(ul.date, result.date)
self.assertEqual(ul.time, result.time)
self.assertEqual(ul.startdate, result.startdate)
self.assertEqual(ul.starttime, result.starttime)
self.assertEqual(ul.enddate, result.enddate)
self.assertEqual(ul.endtime, result.endtime)
self.assertEqual(ul.product, result.product)
self.assertEqual(ul.objectType, result.objectType)
param = result.getParameter("DBZH")
self.assertEqual(
[[2, 2, 3, 3], [2, 2, 3, 3], [4, 4, 5, 5], [4, 4, 5, 5]],
param.getData().tolist())
self.assertEqual([[22, 22, 23, 23], [22, 22, 23, 23], [24, 24, 25, 25],
[24, 24, 25, 25]],
param.getQualityFieldByHowTask(
"se.some.how.task.1").getData().tolist())
param = result.getParameter("TH")
self.assertEqual([[12, 12, 13, 13], [12, 12, 13, 13], [14, 14, 15, 15],
[14, 14, 15, 15]],
param.getData().tolist())
self.assertEqual([[32, 32, 33, 33], [32, 32, 33, 33], [34, 34, 35, 35],
[34, 34, 35, 35]],
param.getQualityFieldByHowTask(
"se.some.how.task.1").getData().tolist())
def _generate(self, dd, dt, area=None):
self._debug_generate_info(area)
if self.verbose:
self.logger.info("Fetching objects and applying quality plugins")
self.logger.debug(
"Generating composite with date and time %sT%s for area %s", dd,
dt, area)
objects, nodes, how_tasks = self.fetch_objects()
objects, algorithm, qfields = self.quality_control_objects(objects)
objects = objects.values()
if self.dump:
self._dump_objects(objects)
generator = _pycomposite.new()
if area is not None:
if _area.isArea(area):
pyarea = area
else:
pyarea = my_area_registry.getarea(area)
else:
if self.verbose:
self.logger.info("Determining best fit for area")
A = rave_area.MakeAreaFromPolarObjects(objects, self.pcsid,
self.xscale, self.yscale)
pyarea = _area.new()
pyarea.id = "auto-generated best-fit"
pyarea.xsize = A.xsize
pyarea.ysize = A.ysize
pyarea.xscale = A.xscale
pyarea.yscale = A.yscale
pyarea.extent = A.extent
pcs = rave_projection.pcs(A.pcs)
pyarea.projection = _projection.new(
pcs.id, pcs.name, string.join(pcs.definition, ' '))
if len(objects) == 1:
try:
tmpid = odim_source.NODfromSource(objects[0])
pyarea.id = "auto_%s_%s" % (A.pcs, tmpid)
except:
pass
if type(self.quantity) is types.StringType:
generator.addParameter(self.quantity, self.gain, self.offset)
else:
for quantity in self.quantity:
generator.addParameter(quantity, self.gain, self.offset)
generator.product = self.product
if algorithm is not None:
generator.algorithm = algorithm
if len(objects) == 0:
self.logger.info("No objects provided to the composite generator.")
if dd is None or dt is None:
self.logger.error(
"Can not create a composite without specifying a valid date / time when no objects are provided."
)
raise Exception, "Can not create a composite without specifying a valid date / time when no objects are provided."
for o in objects:
generator.add(o)
generator.selection_method = self.selection_method
generator.date = o.date if dd is None else dd
generator.time = o.time if dt is None else dt
generator.height = self.height
generator.elangle = self.elangle
generator.range = self.range
if self.qitotal_field is not None:
generator.quality_indicator_field_name = self.qitotal_field
if self.prodpar is not None:
self._update_generator_with_prodpar(generator)
if self.verbose:
self.logger.info("Generating cartesian composite")
result = generator.nearest(pyarea, qfields)
if self.applyctfilter:
if self.verbose:
self.logger.debug("Applying ct filter")
ret = rave_ctfilter.ctFilter(result, self.quantity)
if self.applygra:
if not "se.smhi.composite.distance.radar" in qfields:
self.logger.info(
"Trying to apply GRA analysis without specifying a quality plugin specifying the se.smhi.composite.distance.radar q-field, disabling..."
)
else:
if self.verbose:
self.logger.info(
"Applying GRA analysis (ZR A = %f, ZR b = %f)" %
(self.zr_A, self.zr_b))
grafield = self._apply_gra(result, dd, dt)
if grafield:
result.addParameter(grafield)
else:
self.logger.warn("Failed to generate gra field....")
if self.applygapfilling:
if self.verbose:
self.logger.debug("Applying gap filling")
t = _transform.new()
gap_filled = t.fillGap(result)
result.getParameter(self.quantity).setData(
gap_filled.getParameter(self.quantity).getData())
# Fix so that we get a valid place for /what/source and /how/nodes
plc = result.source
result.source = "%s,CMT:%s" % (CENTER_ID, plc)
result.addAttribute('how/nodes', nodes)
if self.use_site_source and len(objects) == 1:
try:
result.source = objects[0].source
if result.source.find("NOD:") == -1:
tmpid = odim_source.NODfromSource(objects[0])
result.source = "%s,NOD:%s,CMT:%s" % (
self.remove_CMT_from_source(result.source), tmpid, plc)
else:
result.source = "%s,CMT:%s" % (self.remove_CMT_from_source(
result.source), plc)
except:
self.logger.exception("Failed to get source from object")
if how_tasks != "":
result.addAttribute('how/task', how_tasks)
if self.verbose:
self.logger.debug("Returning resulting composite image")
return result
def _generate(self, dd, dt, area=None):
self._debug_generate_info(area)
if self.verbose:
self.logger.info("Fetching objects and applying quality plugins")
self.logger.debug(
"Generating composite with date and time %sT%s for area %s", dd,
dt, area)
objects, nodes, how_tasks, all_files_malfunc = self.fetch_objects()
if all_files_malfunc:
self.logger.info(
"Content of all provided files were marked as 'malfunc'. Since option 'ignore_malfunc' is set, no composite is generated!"
)
return None
objects, algorithm, qfields = self.quality_control_objects(objects)
self.logger.debug("Quality controls for composite generation: %s",
(",".join(qfields)))
if len(objects) == 0:
self.logger.info(
"No objects provided to the composite generator. No composite will be generated!"
)
return None
objects = list(objects.values())
if self.dump:
self._dump_objects(objects)
generator = _pycomposite.new()
if area is not None:
if _area.isArea(area):
pyarea = area
else:
pyarea = my_area_registry.getarea(area)
else:
if self.verbose:
self.logger.info("Determining best fit for area")
A = rave_area.MakeAreaFromPolarObjects(objects, self.pcsid,
self.xscale, self.yscale)
pyarea = _area.new()
pyarea.id = "auto-generated best-fit"
pyarea.xsize = A.xsize
pyarea.ysize = A.ysize
pyarea.xscale = A.xscale
pyarea.yscale = A.yscale
pyarea.extent = A.extent
pcs = rave_projection.pcs(A.pcs)
pcsname = pcs.name
if not is_py27:
pcsname = pcsname.decode()
pyarea.projection = _projection.new(pcs.id, pcsname,
' '.join(pcs.definition))
if len(objects) == 1:
try:
tmpid = odim_source.NODfromSource(objects[0])
pyarea.id = "auto_%s_%s" % (A.pcs, tmpid)
except:
pass
generator.addParameter(self.quantity, self.gain, self.offset,
self.minvalue)
generator.product = self.product
if algorithm is not None:
generator.algorithm = algorithm
for o in objects:
generator.add(o)
# We want to ensure that we get a proper indexing of included radar
sourceid = o.source
try:
osource = odim_source.ODIM_Source(o.source)
if osource.wmo:
sourceid = "WMO:%s" % osource.wmo
elif osource.rad:
sourceid = "RAD:%s" % osource.rad
elif osource.nod:
sourceid = "NOD:%s" % osource.nod
except:
pass
if not sourceid in self.radar_index_mapping.keys():
self.radar_index_mapping[sourceid] = self.get_next_radar_index(
)
generator.selection_method = self.selection_method
generator.interpolation_method = self.interpolation_method
generator.date = o.date if dd is None else dd
generator.time = o.time if dt is None else dt
generator.height = self.height
generator.elangle = self.elangle
generator.range = self.range
if self.qitotal_field is not None:
generator.quality_indicator_field_name = self.qitotal_field
if self.prodpar is not None:
self._update_generator_with_prodpar(generator)
if self.verbose:
self.logger.info("Generating cartesian composite")
generator.applyRadarIndexMapping(self.radar_index_mapping)
result = generator.generate(pyarea, qfields)
if self.applyctfilter:
if self.verbose:
self.logger.debug("Applying ct filter")
rave_ctfilter.ctFilter(result, self.quantity)
if self.applygra:
if not "se.smhi.composite.distance.radar" in qfields:
self.logger.info(
"Trying to apply GRA analysis without specifying a quality plugin specifying the se.smhi.composite.distance.radar q-field, disabling..."
)
else:
if self.verbose:
self.logger.info(
"Applying GRA analysis (ZR A = %f, ZR b = %f)" %
(self.zr_A, self.zr_b))
grafield = self._apply_gra(result, dd, dt)
if grafield:
result.addParameter(grafield)
else:
self.logger.warn("Failed to generate gra field....")
# Hack to create a BRDR field if the qfields contains se.smhi.composite.index.radar
if "se.smhi.composite.index.radar" in qfields:
bitmapgen = _bitmapgenerator.new()
brdr_field = bitmapgen.create_intersect(
result.getParameter(self.quantity),
"se.smhi.composite.index.radar")
brdr_param = result.createParameter("BRDR",
_rave.RaveDataType_UCHAR)
brdr_param.setData(brdr_field.getData())
if self.applygapfilling:
if self.verbose:
self.logger.debug("Applying gap filling")
t = _transform.new()
gap_filled = t.fillGap(result)
result.getParameter(self.quantity).setData(
gap_filled.getParameter(self.quantity).getData())
# Fix so that we get a valid place for /what/source and /how/nodes
plc = result.source
result.source = "%s,CMT:%s" % (CENTER_ID, plc)
result.addAttribute('how/nodes', nodes)
if self.use_site_source and len(objects) == 1:
try:
result.source = objects[0].source
if result.source.find("NOD:") == -1:
tmpid = odim_source.NODfromSource(objects[0])
result.source = "%s,NOD:%s,CMT:%s" % (
self.remove_CMT_from_source(result.source), tmpid, plc)
else:
result.source = "%s,CMT:%s" % (self.remove_CMT_from_source(
result.source), plc)
except:
self.logger.exception("Failed to get source from object")
if how_tasks != "":
result.addAttribute('how/task', how_tasks)
if self.verbose:
self.logger.debug("Returning resulting composite image")
return result
