def regrid_data(lons, lats, target_lons, target_lats, array): """ Regrids the irregular lons and lats produced by the reprojection so that imshow can handle it :param lons: an array of irregular longitude values produced by the reprojection function :param lats: an array of irregular latitude values produced by the reprojection function :param array: an array BTs or RGB values for each pixel :return: the array on an interpolated regular grid """ # Define a target grid XI = target_lons YI = target_lats XI, YI = np.meshgrid(XI, YI) # Resample BT data def_a = SwathDefinition(lons=XI, lats=YI) def_b = SwathDefinition(lons=lons, lats=lats) interp_dat = resample_nearest(def_b, array, def_a, radius_of_influence=7000) return interp_dat
def test_type_preserve(self): """Check that the type of resampled datasets is preserved.""" from satpy.resample import resample_dataset import xarray as xr import dask.array as da import numpy as np from pyresample.geometry import SwathDefinition source_area = SwathDefinition( xr.DataArray(da.arange(4, chunks=5).reshape((2, 2)), dims=['y', 'x']), xr.DataArray(da.arange(4, chunks=5).reshape((2, 2)), dims=['y', 'x'])) dest_area = SwathDefinition( xr.DataArray(da.arange(4, chunks=5).reshape((2, 2)) + .0001, dims=['y', 'x']), xr.DataArray(da.arange(4, chunks=5).reshape((2, 2)) + .0001, dims=['y', 'x'])) expected_gap = np.array([[1, 2], [3, 255]]) data = xr.DataArray(da.from_array(expected_gap, chunks=5), dims=['y', 'x']) data.attrs['_FillValue'] = 255 data.attrs['area'] = source_area res = resample_dataset(data, dest_area) self.assertEqual(res.dtype, data.dtype) self.assertTrue(np.all(res.values == expected_gap)) expected_filled = np.array([[1, 2], [3, 3]]) res = resample_dataset(data, dest_area, radius_of_influence=1000000) self.assertEqual(res.dtype, data.dtype) self.assertTrue(np.all(res.values == expected_filled))
def _make_area_from_coords(self, coords): """Create an appropriate area with the given *coords*.""" if len(coords) == 2: lon_sn = coords[0].attrs.get('standard_name') lat_sn = coords[1].attrs.get('standard_name') if lon_sn == 'longitude' and lat_sn == 'latitude': key = None try: key = (coords[0].data.name, coords[1].data.name) sdef = self.coords_cache.get(key) except AttributeError: sdef = None if sdef is None: sdef = SwathDefinition(*coords) if key is not None: self.coords_cache[key] = sdef sensor_str = '_'.join(self.info['sensors']) shape_str = '_'.join(map(str, coords[0].shape)) sdef.name = "{}_{}_{}_{}".format(sensor_str, shape_str, coords[0].attrs['name'], coords[1].attrs['name']) return sdef else: raise ValueError( 'Coordinates info object missing standard_name key: ' + str(coords)) elif len(coords) != 0: raise NameError("Don't know what to do with coordinates " + str( coords))
def test_numpy_basic_ewa(self, input_shape, input_dims, maximum_weight_mode): """Test EWA with basic xarray DataArrays.""" from pyresample.geometry import SwathDefinition output_shape = (200, 100) if len(input_shape) == 3: output_shape = (input_shape[0], output_shape[0], output_shape[1]) swath_data, source_swath, target_area = get_test_data( input_shape=input_shape, output_shape=output_shape[-2:], input_dims=input_dims, ) swath_data = swath_data.data.astype(np.float32).compute() source_swath = SwathDefinition(*source_swath.get_lonlats()) resampler = DaskEWAResampler(source_swath, target_area) new_data = resampler.resample(swath_data, rows_per_scan=10, maximum_weight_mode=maximum_weight_mode) assert new_data.shape == output_shape assert new_data.dtype == np.float32 assert isinstance(new_data, np.ndarray) # check how many valid pixels we have band_mult = 3 if len(output_shape) == 3 else 1 assert np.count_nonzero(~np.isnan(new_data)) == 468 * band_mult
def get_generic_projection_from_proj4(lat, lon, proj4_srs): """Short summary. Parameters ---------- lat : type Description of parameter `lat`. lon : type Description of parameter `lon`. proj4_srs : type Description of parameter `proj4_srs`. Returns ------- type Description of returned object. """ try: from pyresample.utils import proj4_str_to_dict from pyresample.geometry import SwathDefinition except ImportError: print('please install pyresample to use this functionality') swath = SwathDefinition(lats=lat, lons=lon) area = swath.compute_optimal_bb_area(proj4_str_to_dict(proj4_srs)) return area
def _make_area_from_coords(self, coords): """Create an appropriate area with the given *coords*.""" if len(coords) == 2: lon_sn = coords[0].attrs.get('standard_name') lat_sn = coords[1].attrs.get('standard_name') if lon_sn == 'longitude' and lat_sn == 'latitude': key = None try: key = (coords[0].data.name, coords[1].data.name) sdef = self.coords_cache.get(key) except AttributeError: sdef = None if sdef is None: sdef = SwathDefinition(*coords) if key is not None: self.coords_cache[key] = sdef sensor_str = '_'.join(self.info['sensors']) shape_str = '_'.join(map(str, coords[0].shape)) sdef.name = "{}_{}_{}_{}".format(sensor_str, shape_str, coords[0].attrs['name'], coords[1].attrs['name']) return sdef else: raise ValueError( 'Coordinates info object missing standard_name key: ' + str(coords)) elif len(coords) != 0: raise NameError("Don't know what to do with coordinates " + str(coords))
def combine_info(self, all_infos): """Combine metadata for multiple datasets. When loading data from multiple files it can be non-trivial to combine things like start_time, end_time, start_orbit, end_orbit, etc. By default this method will produce a dictionary containing all values that were equal across **all** provided info dictionaries. Additionally it performs the logical comparisons to produce the following if they exist: - start_time - end_time - start_orbit - end_orbit - satellite_altitude - satellite_latitude - satellite_longitude - orbital_parameters Also, concatenate the areas. """ combined_info = combine_metadata(*all_infos) new_dict = self._combine(all_infos, min, 'start_time', 'start_orbit') new_dict.update(self._combine(all_infos, max, 'end_time', 'end_orbit')) new_dict.update(self._combine(all_infos, np.mean, 'satellite_longitude', 'satellite_latitude', 'satellite_altitude')) # Average orbital parameters orb_params = [info.get('orbital_parameters', {}) for info in all_infos] if all(orb_params): # Collect all available keys orb_params_comb = {} for d in orb_params: orb_params_comb.update(d) # Average known keys keys = ['projection_longitude', 'projection_latitude', 'projection_altitude', 'satellite_nominal_longitude', 'satellite_nominal_latitude', 'satellite_actual_longitude', 'satellite_actual_latitude', 'satellite_actual_altitude', 'nadir_longitude', 'nadir_latitude'] orb_params_comb.update(self._combine(orb_params, np.mean, *keys)) new_dict['orbital_parameters'] = orb_params_comb try: area = SwathDefinition(lons=np.ma.vstack([info['area'].lons for info in all_infos]), lats=np.ma.vstack([info['area'].lats for info in all_infos])) area.name = '_'.join([info['area'].name for info in all_infos]) combined_info['area'] = area except KeyError: pass new_dict.update(combined_info) return new_dict
def resample( in_lat, in_lon, out_lat, out_lon, data, method="inv_square", neighbours=8, radius_of_influence=500000, nprocs=4, ): masked_lat = in_lat.view(np.ma.MaskedArray) masked_lon = in_lon.view(np.ma.MaskedArray) masked_lon.mask = masked_lat.mask = data.view(np.ma.MaskedArray).mask input_def = SwathDefinition(lons=masked_lon, lats=masked_lat) target_def = SwathDefinition(lons=out_lon, lats=out_lat) if method == "inv_square": res = resample_custom( input_def, data, target_def, radius_of_influence=radius_of_influence, neighbours=neighbours, weight_funcs=lambda r: 1 / np.clip(r, 0.0625, np.finfo(r.dtype).max)**2, fill_value=None, nprocs=nprocs, ) elif method == "bilinear": res = resample_custom( input_def, data, target_def, radius_of_influence=radius_of_influence, neighbours=4, weight_funcs=lambda r: 1 / np.clip(r, 0.0625, np.finfo(r.dtype).max), fill_value=None, nprocs=nprocs, ) elif method == "nn": res = resample_nearest( input_def, data, target_def, radius_of_influence=radius_of_influence, fill_value=None, nprocs=nprocs, ) else: raise ValueError("Unknown resample method: %s", method) if type(res.mask) == bool: res.mask = np.tile(res.mask, len(res)) return res
def test_match_integers(self): from pyresample.geometry import SwathDefinition from pyresample.kd_tree import get_neighbour_info lon = np.array([0, 10, 25]) source_def = SwathDefinition(*(lon, lon)) target_def = SwathDefinition(*(lon, lon)) valid_in, valid_out, indices_int, distances = get_neighbour_info(source_def, target_def, 1000, neighbours=1) lon = np.array([0, 10, 25]).astype(np.float64) source_def = SwathDefinition(*(lon, lon)) target_def = SwathDefinition(*(lon, lon)) valid_in, valid_out, indices_float, distances = get_neighbour_info(source_def, target_def, 1000, neighbours=1)
def crop(self, st, et, delta): # Crop data every 'delta' and split into IC and CG scn = Scene(glob.glob(entln_path + 'LtgFlashPortions' + st.strftime('%Y%m%d') + '.csv'), reader='entln') vname = 'timestamp' # any name in data is OK, because we just bin the counts scn.load([vname]) # ---- loop through hour and delta interval ----- # for h in range(st.hour, et.hour): for m in range(0, 60, delta): # 1. -----Crop by delta----- # timestamp = scn[vname].timestamp.values.astype('datetime64[s]') if m + delta < 60: cond = (timestamp >= st.replace(hour=h, minute=m)) & ( timestamp < st.replace(hour=h, minute=m + delta)) else: cond = (timestamp >= st.replace(hour=h, minute=m)) & ( timestamp < st.replace(hour=h + 1, minute=0)) # 2. -----Crop by type ----- # self.ic = copy.deepcopy(scn) self.cg = copy.deepcopy(scn) cond_cg = (scn[vname].type != 1) & (cond) cond_ic = (scn[vname].type == 1) & (cond) self.cg[vname] = self.cg[vname][cond_cg] # if we only use CG data, IC is eaual to CG here # and the constant ratio: IC/CG = iccg_ratio is used later if only_cg: self.ic[vname] = self.ic[vname][cond_cg] else: self.ic[vname] = self.ic[vname][cond_ic] # Correct attrs area_ic = SwathDefinition(lons=self.ic[vname].coords['longitude'], \ lats=self.ic[vname].coords['latitude'] ) area_cg = SwathDefinition(lons=self.cg[vname].coords['longitude'], \ lats=self.cg[vname].coords['latitude'] ) self.correct_attrs(self.ic, area_ic, vname) self.correct_attrs(self.cg, area_cg, vname) # 3. -----Crop by WRF_grid ----- # self.resample_WRF() if only_cg: self.tl = (self.ic[vname] * iccg_ratio + self.cg[vname]) / cg_de else: self.tl = self.ic[vname] / ic_de + self.cg[vname] / cg_de self.save(vname, h, m)
def get_dataset(self, key, info): """Get a dataset from the file.""" if key.name in CHANNEL_NAMES: dataset = self.calibrate([key])[0] else: # Get sun-sat angles if key.name in ANGLES: if isinstance(getattr(self, ANGLES[key.name]), np.ndarray): dataset = Projectable( getattr(self, ANGLES[key.name]), copy=False) else: dataset = self.get_angles(key.name) else: logger.exception( "Not a supported sun-sensor viewing angle: %s", key.name) raise # TODO get metadata if self.lons is None or self.lats is None: self.navigate() if self.area is None: self.area = SwathDefinition(self.lons, self.lats) self.area.name = 'wla' if not self._shape: self._shape = dataset.shape dataset.info['area'] = self.area return dataset
def test_call(self): """Test atmospherical correction.""" from pyresample.geometry import SwathDefinition from satpy.modifiers import PSPAtmosphericalCorrection # Patch methods lons = np.zeros((5, 5)) lons[1, 1] = np.inf lons = da.from_array(lons, chunks=5) lats = np.zeros((5, 5)) lats[1, 1] = np.inf lats = da.from_array(lats, chunks=5) area = SwathDefinition(lons, lats) stime = datetime(2020, 1, 1, 12, 0, 0) orb_params = { "satellite_actual_altitude": 12345678, "nadir_longitude": 0.0, "nadir_latitude": 0.0, } band = xr.DataArray(da.zeros((5, 5)), attrs={ 'area': area, 'start_time': stime, 'name': 'name', 'platform_name': 'platform', 'sensor': 'sensor', 'orbital_parameters': orb_params }, dims=('y', 'x')) # Perform atmospherical correction psp = PSPAtmosphericalCorrection(name='dummy') res = psp(projectables=[band]) res.compute()
def test_areas_pyproj(self): """Test all areas have valid projections with pyproj.""" import pyproj from pyresample import parse_area_file from pyresample.geometry import SwathDefinition from satpy.resample import get_area_file import numpy as np import xarray as xr lons = np.array([[0, 0.1, 0.2], [0.05, 0.15, 0.25]]) lats = np.array([[0, 0.1, 0.2], [0.05, 0.15, 0.25]]) lons = xr.DataArray(lons) lats = xr.DataArray(lats) swath_def = SwathDefinition(lons, lats) all_areas = parse_area_file(get_area_file()) for area_obj in all_areas: if hasattr(area_obj, 'freeze'): try: area_obj = area_obj.freeze(lonslats=swath_def) except RuntimeError: # we didn't provide enough info to freeze, hard to guess # in a generic test so just skip this area continue proj_dict = area_obj.proj_dict _ = pyproj.Proj(proj_dict)
def write_geotiff(lonm, latm, datam, FILE_NAME): # Define SwathDefinition. swathDef = SwathDefinition(lons=lonm, lats=latm) # Define GridDefinition. cellSize = 1 x0, xinc, y0, yinc = (-180, cellSize, 90, -cellSize) nx, ny = (360, 180) x = np.linspace(x0, x0 + xinc*nx, nx) y = np.linspace(y0, y0 + yinc*ny, ny) lon_g, lat_g = np.meshgrid(x, y) grid_def = GridDefinition(lons=lon_g, lats=lat_g) # Set radius_of_influence. ri = 50000 result = resample_nearest(swathDef, datam, grid_def, radius_of_influence=ri, epsilon=0.5, fill_value=np.nan) [cols, rows] = result.shape driver = gdal.GetDriverByName("GTiff") outdata = driver.Create(FILE_NAME+".tif", rows, cols, 1, gdal.GDT_Float32) geotransform = ([x0, 1, 0, y0, 0, -1 ]) outdata.SetGeoTransform(geotransform) srs = osr.SpatialReference() res = srs.ImportFromEPSG(4326) if res != 0: logger.info('Could not import from EPSG') outdata.SetProjection(srs.ExportToWkt()) outdata.GetRasterBand(1).SetNoDataValue(np.nan) outdata.GetRasterBand(1).WriteArray(result) # Save to disk. outdata.FlushCache() outdata = None
def reprojection_bucket(var,lats,lons): ''' Larmbert conformal projection bucket method see more information in https://pyresample.readthedocs.io/en/latest/api/pyresample.bucket.html?highlight=bucket ''' width = 179 height = 199 area_id = 'Lambert_conformal' description = 'Lambert_conformal over Australia' # make the projection proj_dict = {'proj': 'lcc', 'lat_0': -26., 'lon_0': 135., 'lat_1' = -0.6, 'lat_2'= -38.0, 'a': 6371228.0, 'units': 'm'} # create WRF domain area_def = create_area_def(area_id, proj_dict, center=(0,0) ,shape= (width, height), resolution=25000.0 units="m", description=description) # create gridinfo domain swath_def = SwathDefinition(lons=lons, lats=lats) result = resample_nearest(swath_def, var, area_def, radius_of_influence=20000, fill_value=None) return result, area_def
def lonlat_to_swathdefinition(longitude=None, latitude=None): """Short summary. Parameters ---------- longitude : type Description of parameter `longitude`. latitude : type Description of parameter `latitude`. Returns ------- type Description of returned object. """ from pyresample.geometry import SwathDefinition from numpy import vstack if len(longitude.shape) < 2: lons = vstack(longitude) lats = vstack(latitude) else: lons = longitude lats = latitude return SwathDefinition(lons=lons, lats=lats)
def _make_area_from_coords(self, coords): """Create an apropriate area with the given *coords*.""" if (len(coords) == 2 and coords[0].info.get('standard_name') == 'longitude' and coords[1].info.get('standard_name') == 'latitude'): from pyresample.geometry import SwathDefinition sdef = SwathDefinition(*coords) sensor_str = sdef.name = '_'.join(self.info['sensors']) shape_str = '_'.join(map(str, coords[0].shape)) sdef.name = "{}_{}_{}_{}".format(sensor_str, shape_str, coords[0].info['name'], coords[1].info['name']) return sdef elif len(coords) != 0: raise NameError("Don't know what to do with coordinates " + str(coords))
def test_partial_filter(viirs_sdr_i01_scene): """Test that resampling completes even when coverage filters some datasets.""" # make another DataArray that is shifted away from the target area # orig_lons, orig_lats = viirs_sdr_i01_scene['I01'].attrs['area'].get_lonlats() new_i01 = viirs_sdr_i01_scene["I01"].copy() orig_lons = new_i01.attrs["area"].lons orig_lats = new_i01.attrs["area"].lats new_lons = orig_lons + 180.0 new_swath_def = SwathDefinition(new_lons, orig_lats) new_i01.attrs["name"] = "I01_2" new_i01.attrs["area"] = new_swath_def new_scn = Scene() new_scn["I01"] = viirs_sdr_i01_scene["I01"] new_scn["I01_2"] = new_i01 with dask.config.set(scheduler=CustomScheduler(2)): scenes_to_save = resample_scene( new_scn, ["211e"], ["grids.conf"], None, is_polar2grid=True, grid_coverage=0.05, ) assert len(scenes_to_save) == 1 new_scn, data_ids = scenes_to_save[0] assert len(new_scn.keys()) == 1 # I01
def setup(self): """Set up the test case.""" chunks = 20 self.src_area = AreaDefinition( 'euro40', 'euro40', None, { 'proj': 'stere', 'lon_0': 14.0, 'lat_0': 90.0, 'lat_ts': 60.0, 'ellps': 'bessel' }, 102, 102, (-2717181.7304994687, -5571048.14031214, 1378818.2695005313, -1475048.1403121399)) self.dst_area = AreaDefinition( 'omerc_otf', 'On-the-fly omerc area', None, { 'alpha': '8.99811271718795', 'ellps': 'sphere', 'gamma': '0', 'k': '1', 'lat_0': '0', 'lonc': '13.8096029486222', 'proj': 'omerc', 'units': 'm' }, 50, 100, (-1461111.3603, 3440088.0459, 1534864.0322, 9598335.0457)) self.lons, self.lats = self.dst_area.get_lonlats(chunks=chunks) xrlons = xr.DataArray(self.lons.persist()) xrlats = xr.DataArray(self.lats.persist()) self.dst_swath = SwathDefinition(xrlons, xrlats)
def get_lonlats(self): if self.area is not None: return self.area from pyorbital.orbital import Orbital from pyorbital.geoloc import compute_pixels, get_lonlatalt from pyorbital.geoloc_instrument_definitions import avhrr if self.times is None: self.times = time_seconds(self._data["timecode"], self.year) scanline_nb = len(self.times) scan_points = np.arange(0, 2048, 32) # scan_points = np.arange(2048) sgeom = avhrr(scanline_nb, scan_points, apply_offset=False) # no attitude error rpy = [0, 0, 0] s_times = sgeom.times(self.times[:, np.newaxis]).ravel() # s_times = (np.tile(sgeom._times[0, :], (scanline_nb, 1)).astype( # 'timedelta64[s]') + self.times[:, np.newaxis]).ravel() orb = Orbital(self.platform_name) pixels_pos = compute_pixels(orb, sgeom, s_times, rpy) lons, lats, alts = get_lonlatalt(pixels_pos, s_times) self.lons, self.lats = geo_interpolate( lons.reshape((scanline_nb, -1)), lats.reshape((scanline_nb, -1))) self.area = SwathDefinition(self.lons, self.lats) self.area.name = '_'.join([self.platform_name, str(self.start_time()), str(self.end_time)]) return self.area
def test_basic1(self): from pyresample.ewa import ll2cr from pyresample.geometry import SwathDefinition, AreaDefinition from pyresample.utils import proj4_str_to_dict lon_arr = create_test_longitude(-95.0, -75.0, (50, 100), dtype=np.float64) lat_arr = create_test_latitude(18.0, 40.0, (50, 100), dtype=np.float64) swath_def = SwathDefinition(lon_arr, lat_arr) grid_info = static_lcc.copy() cw = grid_info["cell_width"] ch = grid_info["cell_height"] ox = grid_info["origin_x"] oy = grid_info["origin_y"] w = grid_info["width"] h = grid_info["height"] half_w = abs(cw / 2.) half_h = abs(ch / 2.) extents = [ ox - half_w, oy - h * abs(ch) - half_h, ox + w * abs(cw) + half_w, oy + half_h ] area = AreaDefinition('test_area', 'test_area', 'test_area', proj4_str_to_dict(grid_info['proj4_definition']), w, h, extents) points_in_grid, lon_res, lat_res, = ll2cr(swath_def, area, fill=np.nan, copy=False) self.assertEqual(points_in_grid, lon_arr.size, "all points should be contained in a dynamic grid") self.assertIs(lon_arr, lon_res) self.assertIs(lat_arr, lat_res) self.assertEqual(points_in_grid, lon_arr.size, "all these test points should fall in this grid")
def get_lonlats(self): if self.area is None: if self.lons is None or self.lats is None: self.lons, self.lats = self.get_full_lonlats() self.area = SwathDefinition(self.lons, self.lats) self.area.name = '_'.join([self.platform_name, str(self.start_time), str(self.end_time)]) return self.area
def get_lonlats(self): """Get lonlats.""" if self.area is None: lons, lats = self.get_full_lonlats() self.area = SwathDefinition(lons, lats) self.area.name = '_'.join([self.platform_name, str(self.start_time), str(self.end_time)]) return self.area
def _call_ll2cr(lons, lats, target_geo_def): """Wrap ll2cr() for handling dask delayed calls better.""" new_src = SwathDefinition(lons, lats) swath_points_in_grid, cols, rows = ll2cr(new_src, target_geo_def) if swath_points_in_grid == 0: return (lons.shape, np.nan, lons.dtype), (lats.shape, np.nan, lats.dtype) return np.stack([cols, rows], axis=0)
def test_3d_ewa(self, ll2cr, fornav): """Test EWA with a 3D dataset.""" import numpy as np import dask.array as da import xarray as xr from satpy.resample import resample_dataset from pyresample.geometry import SwathDefinition, AreaDefinition from pyresample.utils import proj4_str_to_dict lons = xr.DataArray(da.zeros((10, 10), chunks=5)) lats = xr.DataArray(da.zeros((10, 10), chunks=5)) ll2cr.return_value = (100, np.zeros( (10, 10), dtype=np.float32), np.zeros((10, 10), dtype=np.float32)) fornav.return_value = ([100 * 200] * 3, [np.zeros((200, 100), dtype=np.float32)] * 3) sgd = SwathDefinition(lons, lats) proj_dict = proj4_str_to_dict('+proj=lcc +datum=WGS84 +ellps=WGS84 ' '+lon_0=-95. +lat_0=25 +lat_1=25 ' '+units=m +no_defs') tgd = AreaDefinition( 'test', 'test', 'test', proj_dict, 100, 200, (-1000., -1500., 1000., 1500.), ) input_data = xr.DataArray(da.zeros((3, 10, 10), chunks=5, dtype=np.float32), dims=('bands', 'y', 'x'), attrs={ 'area': sgd, 'test': 'test' }) new_data = resample_dataset(input_data, tgd, resampler='ewa') self.assertTupleEqual(new_data.shape, (3, 200, 100)) self.assertEqual(new_data.dtype, np.float32) self.assertEqual(new_data.attrs['test'], 'test') self.assertIs(new_data.attrs['area'], tgd) # make sure we can actually compute everything new_data.compute() previous_calls = ll2cr.call_count # resample a different dataset and make sure cache is used input_data = xr.DataArray(da.zeros((3, 10, 10), chunks=5, dtype=np.float32), dims=('bands', 'y', 'x'), attrs={ 'area': sgd, 'test': 'test' }) new_data = resample_dataset(input_data, tgd, resampler='ewa') self.assertEqual(ll2cr.call_count, previous_calls) new_data.compute()
def regrid_data_to_regular(lons, lats, array): """ Regrids the irregular lons and lats produced by the reprojection so that imshow can handle it :param lons: an array of irregular longitude values produced by the reprojection function :param lats: an array of irregular latitude values produced by the reprojection function :param array: an array BTs or RGB values for each pixel :return: the array on an interpolated regular grid """ # Define the average interval in the existing lons and lats intervals_lon = (np.max(lons) - np.min(lons)) / len(lons[0]) intervals_lat = (np.max(lats) - np.min(lats)) / len(lats) # Define a regular grid XI = np.arange(np.min(lons), np.max(lons), intervals_lon) YI = np.arange(np.min(lats), np.max(lats), intervals_lat) XI, YI = np.meshgrid(XI, YI) # Resample BT data def_a = SwathDefinition(lons=XI, lats=YI) def_b = SwathDefinition(lons=lons, lats=lats) interp_dat_0 = resample_nearest(def_b, array[:, :, 0], def_a, radius_of_influence=7000) interp_dat_1 = resample_nearest(def_b, array[:, :, 1], def_a, radius_of_influence=7000) interp_dat_2 = resample_nearest(def_b, array[:, :, 2], def_a, radius_of_influence=7000) # Recombine into a single array interp_dat_BTs = array interp_dat_BTs[:, :, 0] = interp_dat_0 interp_dat_BTs[:, :, 1] = interp_dat_1 interp_dat_BTs[:, :, 2] = interp_dat_2 return interp_dat_BTs
def get_dataset(self, key, info): """Load a dataset """ logger.debug('Reading %s.', key.name) if key.name in chans_dict: m_data = self.read_dataset(key, info) else: m_data = self.read_geo(key, info) m_data.info.update(info) if self.lons is None or self.lats is None: self.lons, self.lats = self.navigate(key) m_area_def = SwathDefinition( np.ma.masked_where(m_data.mask, self.lons, copy=False), np.ma.masked_where(m_data.mask, self.lats, copy=False)) m_area_def.name = 'yo' m_data.info['area'] = m_area_def return m_data
def _make_area_from_coords(self, coords): """Create an apropriate area with the given *coords*.""" if (len(coords) == 2 and coords[0].info.get('standard_name') == 'longitude' and coords[1].info.get('standard_name') == 'latitude'): from pyresample.geometry import SwathDefinition return SwathDefinition(*coords) elif len(coords) != 0: raise NameError("Don't know what to do with coordinates " + str(coords))
def combine_info(self, all_infos): """Combine metadata for multiple datasets. When loading data from multiple files it can be non-trivial to combine things like start_time, end_time, start_orbit, end_orbit, etc. By default this method will produce a dictionary containing all values that were equal across **all** provided info dictionaries. Additionally it performs the logical comparisons to produce the following if they exist: - start_time - end_time - start_orbit - end_orbit Also, concatenate the areas. """ combined_info = combine_info(*all_infos) if 'start_time' not in combined_info and 'start_time' in all_infos[0]: combined_info['start_time'] = min(i['start_time'] for i in all_infos) if 'end_time' not in combined_info and 'end_time' in all_infos[0]: combined_info['end_time'] = max(i['end_time'] for i in all_infos) if 'start_orbit' not in combined_info and 'start_orbit' in all_infos[0]: combined_info['start_orbit'] = min(i['start_orbit'] for i in all_infos) if 'end_orbit' not in combined_info and 'end_orbit' in all_infos[0]: combined_info['end_orbit'] = max(i['end_orbit'] for i in all_infos) try: area = SwathDefinition( lons=np.ma.vstack([info['area'].lons for info in all_infos]), lats=np.ma.vstack([info['area'].lats for info in all_infos])) area.name = '_'.join([info['area'].name for info in all_infos]) combined_info['area'] = area except KeyError: pass return combined_info
def combine_info(self, all_infos): """Combine metadata for multiple datasets. When loading data from multiple files it can be non-trivial to combine things like start_time, end_time, start_orbit, end_orbit, etc. By default this method will produce a dictionary containing all values that were equal across **all** provided info dictionaries. Additionally it performs the logical comparisons to produce the following if they exist: - start_time - end_time - start_orbit - end_orbit - satellite_altitude - satellite_latitude - satellite_longitude Also, concatenate the areas. """ combined_info = combine_metadata(*all_infos) new_dict = self._combine(all_infos, min, 'start_time', 'start_orbit') new_dict.update(self._combine(all_infos, max, 'end_time', 'end_orbit')) new_dict.update( self._combine(all_infos, np.mean, 'satellite_longitude', 'satellite_latitude', 'satellite_altitude')) try: area = SwathDefinition( lons=np.ma.vstack([info['area'].lons for info in all_infos]), lats=np.ma.vstack([info['area'].lats for info in all_infos])) area.name = '_'.join([info['area'].name for info in all_infos]) combined_info['area'] = area except KeyError: pass new_dict.update(combined_info) return new_dict
def _make_area_from_coords(self, coords): """Create an apropriate area with the given *coords*.""" if len(coords) == 2: lon_sn = coords[0].info.get('standard_name') lat_sn = coords[1].info.get('standard_name') if lon_sn == 'longitude' and lat_sn == 'latitude': sdef = SwathDefinition(*coords) sensor_str = sdef.name = '_'.join(self.info['sensors']) shape_str = '_'.join(map(str, coords[0].shape)) sdef.name = "{}_{}_{}_{}".format(sensor_str, shape_str, coords[0].info['name'], coords[1].info['name']) return sdef else: raise ValueError( 'Coordinates info object missing standard_name key: ' + str(coords)) elif len(coords) != 0: raise NameError("Don't know what to do with coordinates " + str(coords))