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