def test_ctoscan(self): obj = _transform.new() cartesian = _raveio.open(self.FIXTURE_CARTESIAN_PPI).object volume = _raveio.open(self.FIXTURE_VOLUME).object radardef = _radardef.new() radardef.id = volume.source radardef.description = "ctop test" radardef.longitude = volume.longitude radardef.latitude = volume.latitude radardef.height = volume.height elangles = [] nangles = volume.getNumberOfScans() for i in range(nangles): scan = volume.getScan(i) elangles.append(scan.elangle) radardef.elangles = elangles scan = volume.getScan(0) radardef.nrays = scan.nrays radardef.nbins = scan.nbins radardef.scale = scan.rscale radardef.beamwidth = scan.beamwidth elangle = scan.elangle result = obj.ctoscan(cartesian, radardef, elangle, "DBZH") rio = _raveio.new() rio.object = result rio.save("ctop_polarscan.h5")
def testDealiasScan(self): scan = _raveio.open(self.FIXTURE).object.getScan(0) dscan = _raveio.open(self.DEALIASED).object self.assertTrue(different(scan, dscan)) status = _dealias.dealias(scan) self.assertFalse(different(scan, dscan)) self.assertEqual("se.smhi.detector.dealias", scan.getParameter("VRADH").getAttribute("how/task"))
def testMergeOdimScans2Pvol(self): rb52odim.combineRB5FromTarball(self.RB5_TARBALL_DOPVOL1A, self.NEW_H5_TARBALL_DOPVOL1A) rb52odim.combineRB5FromTarball(self.RB5_TARBALL_DOPVOL1B, self.NEW_H5_TARBALL_DOPVOL1B) rb52odim.combineRB5FromTarball(self.RB5_TARBALL_DOPVOL1C, self.NEW_H5_TARBALL_DOPVOL1C) FILELIST_H5_TARBALL=[\ self.NEW_H5_TARBALL_DOPVOL1A,\ self.NEW_H5_TARBALL_DOPVOL1B,\ self.NEW_H5_TARBALL_DOPVOL1C,\ ] rio_arr = [_raveio.open(x) for x in FILELIST_H5_TARBALL] rb52odim.mergeOdimScans2Pvol(rio_arr, self.NEW_H5_MERGED_PVOL, interval=5, taskname='DOPVOL') new_rio = _raveio.open(self.NEW_H5_MERGED_PVOL) self.assertTrue(new_rio.objectType is _rave.Rave_ObjectType_PVOL) new_pvol = new_rio.object self.assertEqual(new_pvol.getNumberOfScans(), 3) validateMergedPvol(self, new_pvol, 0, self.RB5_TARBALL_DOPVOL1A) validateMergedPvol(self, new_pvol, 1, self.RB5_TARBALL_DOPVOL1B) validateMergedPvol(self, new_pvol, 2, self.RB5_TARBALL_DOPVOL1C) os.remove(self.NEW_H5_TARBALL_DOPVOL1A) os.remove(self.NEW_H5_TARBALL_DOPVOL1B) os.remove(self.NEW_H5_TARBALL_DOPVOL1C) os.remove(self.NEW_H5_MERGED_PVOL)
def testCombineRB5Tarballs2Pvol(self): ifiles = [self.RB5_TARBALL_DOPVOL1A, self.RB5_TARBALL_DOPVOL1B, self.RB5_TARBALL_DOPVOL1C] # Should not be necessary to write self.NEW_H5_MERGED_PVOL and then # read it for validation, but per-scan what/time validation fails if # rio_new is returned in memory and used instead. # This could be a bug in RAVE. rb52odim.combineRB5Tarballs2Pvol(ifiles, self.NEW_H5_MERGED_PVOL, False, 5, "DOPVOL") new_rio = _raveio.open(self.NEW_H5_MERGED_PVOL) ref_rio = _raveio.open(self.REF_H5_MERGED_PVOL) new_pvol, ref_pvol = new_rio.object, ref_rio.object self.assertTrue(new_rio.objectType is _rave.Rave_ObjectType_PVOL) self.assertEquals(new_pvol.getNumberOfScans(), ref_pvol.getNumberOfScans()) validateTopLevel(self, new_pvol, ref_pvol) for i in range(new_pvol.getNumberOfScans()): new_scan = new_pvol.getScan(i) ref_scan = ref_pvol.getScan(i) validateScan(self, new_scan, ref_scan) os.remove(self.NEW_H5_MERGED_PVOL)
def testCombineRB5Files(self): rb52odim.combineRB5(self.FILELIST_RB5, out_fullfile=self.NEW_H5_FILELIST) new_rio = _raveio.open(self.NEW_H5_FILELIST) ref_rio = _raveio.open(self.REF_H5_FILELIST) self.assertTrue(new_rio.objectType is _rave.Rave_ObjectType_SCAN) new_scan, ref_scan = new_rio.object, ref_rio.object validateTopLevel(self, new_scan, ref_scan) validateScan(self, new_scan, ref_scan) os.remove(self.NEW_H5_FILELIST)
def testCombineRB5FromTarball(self): rb52odim.combineRB5FromTarball(self.RB5_TARBALL_DOPVOL1B, self.NEW_H5_TARBALL_DOPVOL1B) new_rio = _raveio.open(self.NEW_H5_TARBALL_DOPVOL1B) ref_rio = _raveio.open(self.REF_H5_TARBALL_DOPVOL1B) self.assertTrue(new_rio.objectType is _rave.Rave_ObjectType_SCAN) new_scan, ref_scan = new_rio.object, ref_rio.object validateTopLevel(self, new_scan, ref_scan) validateScan(self, new_scan, ref_scan) os.remove(self.NEW_H5_TARBALL_DOPVOL1B)
def testSingleRB5Azi(self): rb52odim.singleRB5(self.GOOD_RB5_AZI,out_fullfile=self.NEW_H5_AZI) new_rio = _raveio.open(self.NEW_H5_AZI) ref_rio = _raveio.open(self.REF_H5_AZI) self.assertTrue(new_rio.objectType is _rave.Rave_ObjectType_SCAN) new_scan, ref_scan = new_rio.object, ref_rio.object validateTopLevel(self, new_scan, ref_scan) validateScan(self, new_scan, ref_scan) os.remove(self.NEW_H5_AZI)
def test_drDeriveParameter(self): zdr_offset = 0.0 rio = _raveio.open(self.FIXTURE) scan = rio.object _dr_qc.drDeriveParameter(scan, zdr_offset) #rio.save(self.DR_DERIVE_PARAMETER_FIXTURE) refio = _raveio.open(self.DR_DERIVE_PARAMETER_FIXTURE) ref_scan = refio.object status = different(scan, ref_scan, "DR") self.assertFalse(status)
def test_merge(self): scan_dbzh = _raveio.open(self.FIXTURE_1).object scan_vrad = _raveio.open(self.FIXTURE_1).object p = scan_vrad.removeParameter("DBZH") p.quantity="VRAD" scan_vrad.addParameter(p) classUnderTest = polar_merger.polar_merger() result = classUnderTest.merge([scan_dbzh,scan_vrad]) self.assertTrue("VRAD" in result.getParameterNames()) self.assertTrue("DBZH" in result.getParameterNames())
def test_create_dealiased_parameter(self): pvol = _raveio.open(self.FIXTURE).object dscan = _raveio.open(self.DEALIASED).object self.assertTrue(different(pvol.getScan(0), dscan)) param = _dealias.create_dealiased_parameter(pvol.getScan(0), "VRADH", "VRADDH") self.assertFalse(different_param(dscan.getParameter("VRADH"), param)) dscan.getParameter("VRADH").addAttribute("how/something", "jupp") # verify that created param is copy and not reference self.assertFalse(param.hasAttribute("how/something")) self.assertTrue(param.hasAttribute("how/dealiased")) self.assertTrue(param.quantity == "VRADDH")
def testDealiasPvol(self): pvol = _raveio.open(self.FIXTURE).object dscan = _raveio.open(self.DEALIASED).object self.assertTrue(different(pvol.getScan(0), dscan)) status = _dealias.dealias(pvol) for i in range(pvol.getNumberOfScans()): scan = pvol.getScan(i) if scan.hasParameter("VRADH") and scan.elangle < 2.0*math.pi/180.0: # Currently, max elev angle is 2.0 self.assertEqual("se.smhi.detector.dealias", scan.getParameter("VRADH").getAttribute("how/task")) self.assertFalse(different(pvol.getScan(0), dscan))
def testNoTH(self): convol = _raveio.open(self.FIXCONVOL).object dopvol = _raveio.open(self.REF_DOPVOL).object for i in range(convol.getNumberOfScans()): scan = convol.getScan(i) scan.removeParameter('TH') try: ec_dopvolqc.dopvolFilter(convol, dopvol) self.fail() except: self.assertTrue(True)
def test_generateNcar_pid(self): rio = _raveio.open(self.FIXTURE) scan = rio.object profile = ncarb.readProfile(self.PROFILE, scale_height=1000) ncarb.THRESHOLDS_FILE['nexrad'] = self.THRESHOLDS ncarb.pidScan(scan, profile, median_filter_len=7, pid_thresholds='nexrad', keepExtras=True) rio.object = scan ref = _raveio.open(self.REF_FIXTURE).object self.assertFalse(different(scan, ref)) self.assertFalse(different(scan, ref, "CLASS2"))
def testMergeDopvol(self): dopvol1a = _raveio.open(self.FIXDOPVOL1A).object dopvol1b = _raveio.open(self.FIXDOPVOL1B).object dopvol1c = _raveio.open(self.FIXDOPVOL1C).object dopvol2 = _raveio.open(self.FIXDOPVOL2).object dvol = ec_dopvolqc.mergeDopvol(dopvol1a, dopvol1b, dopvol1c, dopvol2) dopvol = _raveio.open(self.REF_DOPVOL).object this = dvol.getScan(0) ref = dopvol.getScan(0) status = different(this, ref, "VRADH") self.assertFalse(status)
def testDopvolFilter(self): convol = _raveio.open(self.FIXCONVOL).object dopvol = _raveio.open(self.REF_DOPVOL).object refvol = _raveio.open(self.REF_OUT).object ec_dopvolqc.dopvolFilter(convol, dopvol) cdat = convol.getScan(23) cref = refvol.getScan(23) status = different(cdat, cref) self.assertFalse(status)
def test_drQC(self): rio = _raveio.open(self.FIXTURE) scan = rio.object ec_drqc.drQC(scan, kernely=3, kernelx=3) refio = _raveio.open(self.DR_SPECKLE_FILTER_FIXTURE) ref_scan = refio.object status = different(scan, ref_scan, "DBZH") self.assertFalse(status) param = scan.getParameter("DR") self.assertEquals(ec_drqc.TASK, param.getAttribute("how/task")) self.assertEquals( "param_name=DBZH zdr_offset=0.00 kernely=3 kernelx=3 param_thresh=35.0 dr_thresh=-12.0", param.getAttribute("how/task_args"))
def test_drSpeckleFilter(self): zdr_offset = 0.0 param_name, param_thresh, dr_thresh = "DBZH", 35.0, -12.0 kernely = kernelx = 3 rio = _raveio.open(self.DR_DERIVE_PARAMETER_FIXTURE) scan = rio.object _dr_qc.drSpeckleFilter(scan, param_name, kernely, kernelx, param_thresh, dr_thresh) #rio.save(self.DR_SPECKLE_FILTER_FIXTURE) refio = _raveio.open(self.DR_SPECKLE_FILTER_FIXTURE) ref_scan = refio.object status = different(scan, ref_scan, param_name) self.assertFalse(status)
def testSingleRB5Vol(self): rb52odim.singleRB5(self.GOOD_RB5_VOL,out_fullfile=self.NEW_H5_VOL) new_rio = _raveio.open(self.NEW_H5_VOL) ref_rio = _raveio.open(self.REF_H5_VOL) self.assertTrue(new_rio.objectType is _rave.Rave_ObjectType_PVOL) new_pvol, ref_pvol = new_rio.object, ref_rio.object self.assertEquals(new_pvol.getNumberOfScans(), ref_pvol.getNumberOfScans()) validateTopLevel(self, new_pvol, ref_pvol) for i in range(new_pvol.getNumberOfScans()): new_scan = new_pvol.getScan(i) ref_scan = ref_pvol.getScan(i) validateScan(self, new_scan, ref_scan) os.remove(self.NEW_H5_VOL)
def testDealiasPvol_byEMAX_higher(self): pvol = _raveio.open(self.FIXTURE).object dscan = _raveio.open(self.DEALIASED).object self.assertTrue(different(pvol.getScan(0), dscan)) status = _dealias.dealias(pvol, "VRADH", 30.0) for i in range(pvol.getNumberOfScans()): scan = pvol.getScan(i) if scan.hasParameter("VRADH"): if scan.elangle <= 30.0*math.pi/180.0: self.assertEqual("se.smhi.detector.dealias", scan.getParameter("VRADH").getAttribute("how/task")) else: self.assertFalse(scan.getParameter("VRADH").hasAttribute("how/task")) self.assertFalse(different(pvol.getScan(0), dscan))
def testDealiasScan_VRADV(self): # Really not relevant but we don't force what parameter to use scan = _raveio.open(self.FIXTURE).object.getScan(0) dscan = _raveio.open(self.DEALIASED).object scan.addParameter(copyParam(scan.getParameter("VRADH"), "VRADV")) dscan.addParameter(copyParam(dscan.getParameter("VRADH"), "VRADV")) self.assertTrue(different(scan, dscan)) self.assertTrue(different(scan, dscan, "VRADV")) status = _dealias.dealias(scan, "VRADV") self.assertTrue(different(scan, dscan, "VRADH")) self.assertFalse(different(scan, dscan, "VRADV")) self.assertFalse(scan.getParameter("VRADH").hasAttribute("how/task")) self.assertEqual("se.smhi.detector.dealias", scan.getParameter("VRADV").getAttribute("how/task"))
def test_merge_different_sizes(self): scan_dbzh = _raveio.open(self.FIXTURE_1).object scan_vrad = _raveio.open(self.FIXTURE_1).object p = scan_vrad.removeParameter("DBZH") p.quantity="VRAD" p.setData(numpy.zeros((10,10), numpy.uint8)) scan_vrad.addParameter(p) classUnderTest = polar_merger.polar_merger() try: result = classUnderTest.merge([scan_dbzh,scan_vrad]) self.fail("Expected an exception") except AttributeError: pass
def concatenate_topo(): ios1 = _raveio.open("./W020N90.h5") src1 = ios1.object data1 = src1.getParameter("TOPO").getData() ios2 = _raveio.open("./E020N90.h5") src2 = ios2.object data2 = src2.getParameter("TOPO").getData() #data2 = numpy.zeros((6000,4800), numpy.int16) a1 = array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], numpy.int16) data = concatenate((a1, a1), 1) print(concatenate((a1, a1), 1)) print(data) a = _area.new() a.id = "BALTRAD" a.projection = src1.projection a.extent = (src1.areaextent[0], src1.areaextent[1], src2.areaextent[2], src2.areaextent[3]) a.xsize = src1.xsize + src2.xsize a.ysize = src1.ysize a.xscale = (a.extent[2] - a.extent[0]) / (a.xsize - 1) a.yscale = (a.extent[3] - a.extent[1]) / (a.ysize - 1) print(a.id) print(a.projection.definition) print(a.extent) print(a.xsize, a.ysize) print(a.xscale, a.yscale) src = _cartesian.new() src.init(a, _rave.RaveDataType_SHORT) src.time = src1.time src.date = src1.date src.objectType = src1.objectType src.product = src1.product src.source = src1.source param1 = src1.getParameter("TOPO") param = _cartesianparam.new() param.quantity = param1.quantity param.gain = param1.gain param.offset = param1.offset param.nodata = param1.nodata param.setData(data) ios = _raveio.new() ios.object = src ios.filename = "./BALTRAD_topo.h5" ios.save()
def __init__(self, h5file, quantity="DBZH", **kw): self._gmappalette = None self._gain = None self._offset = None self._quant = None self._qinds = {} rio = _raveio.open(h5file) if rio.objectType == _rave.Rave_ObjectType_COMP: prod = rio.object.getImage( 0) # assume only one "composite" in this file elif rio.objectType == _rave.Rave_ObjectType_IMAGE: prod = rio.object self._quant = prod.getParameter(quantity) for i in range(self._quant.getNumberOfQualityFields()): qi = self._quant.getQualityField(i) task = qi.getAttribute("how/task") self._qinds[task] = qi if not "gain" in kw: self._gain = self._quant.gain if self._gain == 0.0: raise ValueError('gain == 0.0') else: self._gain = kw["gain"] if not "offset" in kw: self._offset = self._quant.offset else: self._offset = kw["offset"] self._gmappalette = GmapColorMap.PALETTES[SETTINGS[quantity].palette]
def testReadParameters(self): scan = rb52odim.readParameterFiles([self.CASRA_AZI_dBZ])[0] ref = _raveio.open(self.CASRA_H5_SCAN).object for pname in ref.getParameterNames(): if pname != 'DBZH': ref.removeParameter(pname) validateScan(self, scan, ref)
def testCombineRB5FilesReturnRIO(self): new_rio = rb52odim.combineRB5(self.FILELIST_RB5, return_rio=True) ref_rio = _raveio.open(self.REF_H5_FILELIST) self.assertTrue(new_rio.objectType is _rave.Rave_ObjectType_SCAN) new_scan, ref_scan = new_rio.object, ref_rio.object validateTopLevel(self, new_scan, ref_scan) validateScan(self, new_scan, ref_scan)
def testChainCompare_8bit_and_32bit_Restore(self): a = _raveio.open(self.PVOL_RIX_TESTFILE).object.getScan(0) b = _ropogenerator.new(_fmiimage.fromRave(a, "DBZH")) result8bit = b.speckNormOld(-20, 24, 8).emitter2(-30, 3, 3).softcut( 5, 170, 180).ship(20, 8).speck( -30, 12).restore(108).toPolarScan().getParameter("DBZH").getData() # Adjust the 8 bit data to be 16 bit instead p = a.getParameter("DBZH") d = p.getData().astype(numpy.int32) p.setData(d) p.undetect = 0.0 p.nodata = 255.0 a.addParameter(p) b = _ropogenerator.new(_fmiimage.fromRave(a, "DBZH")) result32bit = b.speckNormOld(-20, 24, 8).emitter2(-30, 3, 3).softcut( 5, 170, 180).ship(20, 8).speck( -30, 12).restore(108).toPolarScan().getParameter("DBZH").getData() self.assertEqual( numpy.int32, result32bit.dtype) # Result should be same type as when created result32bit = result32bit.astype(numpy.uint8) self.assertTrue( numpy.array_equal(result8bit.astype(numpy.int32), result32bit.astype(numpy.int32)))
def testClassify_reclassification(self): a = _raveio.open(self.PVOL_RIX_TESTFILE).object.getScan(0) b = _ropogenerator.new(_fmiimage.fromRave(a, "DBZH")) b.speck(-20, 5).emitter(3, 6).classify() self.assertEqual("fi.fmi.ropo.detector.classification", b.classification.getAttribute("how/task")) self.assertTrue( b.classification.getAttribute("how/task_args").find("SPECK:") >= 0) self.assertTrue( b.classification.getAttribute("how/task_args").find("EMITTER:") >= 0) self.assertEqual("fi.fmi.ropo.detector.classification_marker", b.markers.getAttribute("how/task")) self.assertTrue( b.markers.getAttribute("how/task_args").find("SPECK:") >= 0) self.assertTrue( b.markers.getAttribute("how/task_args").find("EMITTER:") >= 0) b.clutter(-5, 5).classify() self.assertEqual("fi.fmi.ropo.detector.classification", b.classification.getAttribute("how/task")) self.assertTrue( b.classification.getAttribute("how/task_args").find("SPECK:") >= 0) self.assertTrue( b.classification.getAttribute("how/task_args").find("EMITTER:") >= 0) self.assertTrue( b.classification.getAttribute("how/task_args").find("CLUTTER:") >= 0)
def process(self, obj, reprocess_quality_flag=True, arguments=None): #_rave.setDebugLevel(_rave.Debug_RAVE_DEBUG) if not _polarvolume.isPolarVolume(obj): raise Exception, "Input object is not a polar volume. Bailing ..." # Using a dictionary lets us match tasks with payloads dpvol = {"dopvol1a" : None, "dopvol1b" : None, "dopvol1c" : None, "dopvol2" : None} for i in range(len(arguments)): dobj = _raveio.open(arguments[i]).object task = "".join(dobj.getAttribute('how/task').lower().split("_")) dpvol[task] = dobj dopvol = ec_dopvolqc.mergeDopvol(dopvol1a = dpvol["dopvol1a"], dopvol1b = dpvol["dopvol1b"], dopvol1c = dpvol["dopvol1c"], dopvol2 = dpvol["dopvol2"]) # Assume we always want spatial=1 filtering ec_dopvolqc.dopvolFilter(obj, dopvol) return obj
def testReadRB5Azi(self): rio = _rb52odim.readRB5(self.GOOD_RB5_AZI) self.assertTrue(rio.objectType is _rave.Rave_ObjectType_SCAN) scan = rio.object ref_scan = _raveio.open(self.REF_H5_AZI).object validateTopLevel(self, scan, ref_scan) validateScan(self, scan, ref_scan)
def testCombineRB5FromTarballReturnRIO(self): new_rio = rb52odim.combineRB5FromTarball(self.RB5_TARBALL_DOPVOL1B, None, return_rio=True) ref_rio = _raveio.open(self.REF_H5_TARBALL_DOPVOL1B) self.assertTrue(new_rio.objectType is _rave.Rave_ObjectType_SCAN) new_scan, ref_scan = new_rio.object, ref_rio.object validateTopLevel(self, new_scan, ref_scan) validateScan(self, new_scan, ref_scan)
def test_raveio2radar_pvol(): rio = _raveio.open(PVOL_FILENAME) radar = bridge.raveio2radar(rio) # latitude, longitude, altitude assert round(radar.latitude['data'], 2) == 58.11 assert round(radar.longitude['data'], 2) == 15.94 assert round(radar.altitude['data'], 2) == 222.0 # metadata assert radar.metadata['source'] == ( 'WMO:02570,PLC:Norrk\xc3\xb6ping,RAD:SE53,NOD:senkp') assert radar.metadata['original_container'] == 'odim_h5' # sweep_start_ray_index, sweep_end_ray_index # radar consists of 6 sweeps each containing 361 rays assert_array_equal(radar.sweep_start_ray_index['data'], np.arange(6) * 361) assert_array_equal(radar.sweep_end_ray_index['data'], np.arange(6) * 361 + 360) # sweep_number, sweep_mode, scan_type assert_array_equal(radar.sweep_number['data'], np.arange(6)) assert_array_equal(radar.sweep_mode['data'], ['azimuth_surveillance'] * 6) assert radar.scan_type == 'ppi' # fixed_angle assert_allclose(radar.fixed_angle['data'], [0.0, 1.1, 23.5, 28.2, 33.7, 40.0]) # elevation, check each sweep assert np.allclose(radar.elevation['data'][:361], 0.0) assert np.allclose(radar.elevation['data'][361:722], 1.1) assert np.allclose(radar.elevation['data'][722:1083], 23.5) assert np.allclose(radar.elevation['data'][1083:1444], 28.2) assert np.allclose(radar.elevation['data'][1444:1805], 33.7) assert np.allclose(radar.elevation['data'][1805:], 40.0) # range assert_allclose(radar.range['data'], np.arange(800) * 250) # azimuth assert round(radar.azimuth['data'][10], 2) == 10.04 assert round(radar.azimuth['data'][361 + 10], 2) == 10.03 assert round(radar.azimuth['data'][722 + 10], 2) == 10.01 assert round(radar.azimuth['data'][1083 + 10], 2) == 10.03 assert round(radar.azimuth['data'][1444 + 10], 2) == 10.04 assert round(radar.azimuth['data'][1805 + 10], 2) == 10.02 # time assert radar.time['units'] == 'seconds since 2012-02-26T10:27:51Z' assert radar.time['data'][0] == 0 assert radar.time['data'][-1] == 236 # additional radar attributes assert radar.nsweeps == 6 assert radar.ngates == 800 assert radar.nrays == 2166
def test_raveio2radar_scan(): rio = _raveio.open(SCAN_FILENAME) radar = bridge.raveio2radar(rio)