def __init__(self, core, polygon_geog, x0, y0): """ Initialises an TilingSystem class for a specified subgrid. Parameters ---------- core : TPSCoreProperty defines core parameters of the (sub-) grid polygon_geog : OGRGeometry geometry defining the extent/outline of the subgrid x0 : int lower-left x (right) coordinates of the subgrid y0 : int lower-left y (up) coordinates of the subgrid """ self.core = core self.x0 = x0 self.y0 = y0 self.xstep = self.core.tile_xsize_m self.ystep = self.core.tile_ysize_m self.polygon_proj = ptpgeometry.transform_geometry( polygon_geog, self.core.projection.osr_spref) self.bbox_proj = ptpgeometry.get_geometry_envelope( self.polygon_proj, rounding=self.core.sampling)
def __init__(self, core, polygon_geog, tilingsystem=None): """ Initialises a TiledProjection(). Parameters ---------- core : TPSCoreProperty defines core parameters of the (sub-) grid polygon_geog : OGRGeometry geometry defining the extent/outline of the subgrid. if not given, a single global subgrid is assigned to the grid. tilingsystem : TilingSystem optional; an instance of TilingSystem() if not given, a single global tile is assigned to the grid. """ self.core = core self.polygon_geog = ptpgeometry.segmentize_geometry(polygon_geog, segment=0.5) self.polygon_proj = ptpgeometry.transform_geometry( self.polygon_geog, self.core.projection.osr_spref) self.bbox_proj = ptpgeometry.get_geometry_envelope( self.polygon_proj, rounding=self.core.sampling) # does this use anybody? its justs makes problems with the antimeridian! # self.bbox_geog = ptpgeometry.get_geometry_envelope( # self.polygon_geog, rounding=self.core.sampling / 1000000.0) if tilingsystem is None: tilingsystem = GlobalTile(self.core, 'TG', self.get_bbox_proj()) self.tilesys = tilingsystem
def get_extent_geometry_geog(self): """ returns the extent-geometry of the tile in the lon-lat-space. Returns ------- OGRGeometry """ tile_geom = self.polygon_proj geo_sr = ptpgeometry.get_geog_spatial_ref() return ptpgeometry.transform_geometry(tile_geom, geo_sr, segment=25000)
def search_tiles_over_geometry(self, geometry, coverland=True): """ Search tiles of the subgrid that are overlapping with the geometry. Parameters ---------- geometry : OGRGeometry A point or polygon geometry representing the region of interest. coverland : Boolean option to search for tiles covering land at any point in the tile Returns ------- overlapped_tiles : list Return a list of the overlapped tiles' name. If not found, return empty list. """ overlapped_tiles = list() if geometry.GetGeometryName() in ['MULTIPOINT', 'POINT']: if geometry.Intersects(self.polygon_geog): # get intersect area with subgrid in latlon intersect_geometry = geometry.Intersection(self.polygon_geog) intersect_geometry = ptpgeometry.transform_geometry( intersect_geometry, self.projection.osr_spref) else: return overlapped_tiles if geometry.GetGeometryName() in ['POLYGON', 'MULTIPOLYGON']: # get intersect area with subgrid in latlon intersect = ptpgeometry.get_lonlat_intersection( geometry, self.polygon_geog) # check if geom intersects subgrid if intersect.Area() == 0.0: return overlapped_tiles # transform intersection geometry back to the spatial ref system of the subgrid. # segmentise for high precision during reprojection. projected = intersect.GetSpatialReference().IsProjected() if projected == 0: max_segment = 0.5 elif projected == 1: max_segment = 50000 else: raise Warning( 'Please check unit of geometry before reprojection!') intersect_geometry = ptpgeometry.transform_geometry( intersect, self.projection.osr_spref, segment=max_segment) # get envelope of the geometry envelope = ptpgeometry.get_geometry_envelope(intersect_geometry) # get overlapped tiles tiles = self.tilesys.identify_tiles_overlapping_xybbox(envelope) for tile in tiles: # get tile object t = self.tilesys.create_tile(tile) # get only tile that overlaps with intersect_geometry if t.polygon_proj.Intersects(intersect_geometry): # get only tile if coverland is satisfied if not coverland or self.tilesys.check_tile_covers_land( t.name): overlapped_tiles.append(t.name) return overlapped_tiles
def _search_tiles_in_roi(self, roi_geometry=None, subgrid_ids=None, coverland=False): """ Internal function: Search the tiles of the grid which intersect by the given area. Parameters ---------- roi_geometry : geometry a polygon or multipolygon geometry object representing the ROI sgrid_ids : string or list of strings subgrid IDs, e.g. specifying over which continent you want to search. Default value is None for searching all subgrids. coverland : Boolean option to search for tiles covering land at any point in the tile Returns ------- list return a list of the overlapped tiles' name. If not found, return empty list. """ # load lat-lon spatial reference as the default geog_sr = TPSProjection(epsg=4326).osr_spref geom_sr = roi_geometry.GetSpatialReference() if geom_sr is None: roi_geometry.AssignSpatialReference(geog_sr) elif not geom_sr.IsSame(geog_sr): projected = roi_geometry.GetSpatialReference().IsProjected() if projected == 0: max_segment = 0.5 elif projected == 1: max_segment = 50000 else: raise Warning( 'Please check unit of geometry before reprojection!') roi_geometry = ptpgeometry.transform_geometry(roi_geometry, geog_sr, segment=max_segment) if roi_geometry.GetGeometryName() == 'MULTIPOLYGON': roi_polygons = [] for i in range(roi_geometry.GetGeometryCount()): poly = roi_geometry.GetGeometryRef(i).Clone() poly.AssignSpatialReference(geog_sr) roi_polygons.append(poly) else: roi_polygons = [roi_geometry] overlapped_tiles = list() for roi_polygon in roi_polygons: # intersect the given grid ids and the overlapped ids overlapped_grids = self.locate_geometry_in_subgrids(roi_polygon) subgrid_ids = list(set(subgrid_ids) & set(overlapped_grids)) # finding tiles for sgrid_id in subgrid_ids: overlapped_tiles.extend( self.subgrids[sgrid_id].search_tiles_over_geometry( roi_polygon, coverland=coverland)) return list(set(overlapped_tiles))
def search_tiles_in_geometry(self, geom, coverland=True): """ Search the tiles which are overlapping with the subgrid Parameters ---------- geom : OGRGeometry A polygon geometry representing the region of interest. coverland : Boolean option to search for tiles covering land at any point in the tile Returns ------- overlapped_tiles : list Return a list of the overlapped tiles' name. If not found, return empty list. """ overlapped_tiles = list() # check if geom intersects subgrid if geom.Intersects(self.polygon_geog): # get intersect area with subgrid in latlon intersect = geom.Intersection(self.polygon_geog) else: return overlapped_tiles # get spatial reference of subgrid in grid projection grid_sr = self.projection.osr_spref # transform intersection geometry back to the spatial reference system # of the subgrid. # segmentise for high precision during reprojection. projected = intersect.GetSpatialReference().IsProjected() if projected == 0: max_segment = 0.5 else: raise Warning('Please check unit of geometry before reprojection!') intersect = geometry.transform_geometry(intersect, grid_sr, segment=max_segment) # get envelope of the Geometry and cal the bounding tile of the envelope = intersect.GetEnvelope() lon_min = int(envelope[0]) // self.core.tile_xsize_m \ * self.core.tile_xsize_m lon_max = (int(envelope[1]) // self.core.tile_xsize_m + 1) \ * self.core.tile_xsize_m lat_min = int(envelope[2]) // self.core.tile_ysize_m * \ self.core.tile_ysize_m lat_max = (int(envelope[3]) // self.core.tile_ysize_m + 1) * \ self.core.tile_ysize_m # get overlapped tiles lonr = np.arange( lon_min, lon_max + self.core.tile_xsize_m, self.core.tile_xsize_m) latr = np.arange( lat_min, lat_max + self.core.tile_ysize_m, self.core.tile_ysize_m) for lon, lat in itertools.product(lonr, latr): geom_tile = geometry.extent2polygon( (lon, lat, lon + self.core.tile_xsize_m, lat + self.core.tile_xsize_m), grid_sr) if geom_tile.Intersects(intersect): ftile = self.tilesys.point2tilename(lon, lat) if not coverland or self.tilesys.check_tile_covers_land(ftile): overlapped_tiles.append(ftile) return overlapped_tiles