def _get_process_area(self, area=None, bounds=None, area_fallback=None, bounds_fallback=None, area_crs=None, bounds_crs=None): """ Determine process area by combining configuration with instantiation arguments. In the configuration the process area can be provided by using the (1) ``area`` option, (2) ``bounds`` option or (3) a combination of both. (1) If only ``area`` is provided, output shall be the area geometry (2) If only ``bounds`` is provided, output shall be box(*self.bounds) (3) If both are provided, output shall be the intersection between ``area`` and ``bounds`` The area parameter can be provided in multiple variations, see _guess_geometry(). """ try: dst_crs = self.process_pyramid.crs if bounds is None and area is None: return area_fallback elif bounds is None: area, crs = _guess_geometry(area, base_dir=self.config_dir) # in case vector file has no CRS use manually provided CRS area_crs = crs or area_crs return reproject_geometry(area, src_crs=area_crs or dst_crs, dst_crs=dst_crs) elif area is None: return reproject_geometry(box(*validate_bounds(bounds)), src_crs=bounds_crs or dst_crs, dst_crs=dst_crs) else: area, crs = _guess_geometry(area, base_dir=self.config_dir) # in case vector file has no CRS use manually provided CRS area_crs = crs or area_crs bounds = validate_bounds(bounds) # reproject area and bounds to process CRS and return intersection return reproject_geometry( area, src_crs=area_crs or dst_crs, dst_crs=dst_crs).intersection( reproject_geometry(box(*validate_bounds(bounds)), src_crs=bounds_crs or dst_crs, dst_crs=dst_crs), ) except Exception as e: raise MapcheteConfigError(e)
def bounds_from_opts(wkt_geometry=None, point=None, bounds=None, zoom=None, raw_conf=None): """ Loads the process pyramid of a raw configuration. Parameters ---------- raw_conf : dict Raw mapchete configuration as dictionary. Returns ------- BufferedTilePyramid """ if wkt_geometry: return Bounds(*wkt.loads(wkt_geometry).bounds) elif point: x, y = point zoom_levels = get_zoom_levels( process_zoom_levels=raw_conf["zoom_levels"], init_zoom_levels=zoom) tp = raw_conf_process_pyramid(raw_conf) return Bounds(*tp.tile_from_xy(x, y, max(zoom_levels)).bounds) else: return validate_bounds(bounds) if bounds is not None else bounds
def clip_bounds(bounds=None, clip=None): """ Clips bounds by clip. Parameters ---------- bounds : bounds to be clipped clip : clip bounds Returns ------- Bounds(left, bottom, right, top) """ bounds = validate_bounds(bounds) clip = validate_bounds(clip) return Bounds(max(bounds.left, clip.left), max(bounds.bottom, clip.bottom), min(bounds.right, clip.right), min(bounds.top, clip.top))
def bounds(self): """Process bounds as defined in the configuration.""" if self._raw["bounds"] is None: return self.process_pyramid.bounds else: try: return validate_bounds(self._raw["bounds"]) except Exception as e: raise MapcheteConfigError(e)
def bounds_from_opts(wkt_geometry=None, point=None, point_crs=None, zoom=None, bounds=None, bounds_crs=None, raw_conf=None): """ Return process bounds depending on given inputs. Parameters ---------- wkt_geometry : string WKT geometry used to generate bounds. point : iterable x and y coordinates of point whose corresponding process tile bounds shall be returned. point_crs : str or CRS CRS of point (default: process pyramid CRS) zoom : int Mandatory zoom level if point is provided. bounds : iterable Bounding coordinates to be used bounds_crs : str or CRS CRS of bounds (default: process pyramid CRS) raw_conf : dict Raw mapchete configuration as dictionary. Returns ------- BufferedTilePyramid """ if wkt_geometry: return Bounds(*wkt.loads(wkt_geometry).bounds) elif point: x, y = point tp = raw_conf_process_pyramid(raw_conf) if point_crs: reproj = reproject_geometry(Point(x, y), src_crs=point_crs, dst_crs=tp.crs) x = reproj.x y = reproj.y zoom_levels = get_zoom_levels( process_zoom_levels=raw_conf["zoom_levels"], init_zoom_levels=zoom) return Bounds(*tp.tile_from_xy(x, y, max(zoom_levels)).bounds) elif bounds: bounds = validate_bounds(bounds) if bounds_crs: tp = raw_conf_process_pyramid(raw_conf) bounds = Bounds(*reproject_geometry( box(*bounds), src_crs=bounds_crs, dst_crs=tp.crs).bounds) return bounds else: return
def init_bounds(self): """ Process bounds this process is currently initialized with. This gets triggered by using the ``init_bounds`` kwarg. If not set, it will be equal to self.bounds. """ if self._raw["init_bounds"] is None: return self.bounds else: try: return validate_bounds(self._raw["init_bounds"]) except Exception as e: raise MapcheteConfigError(e)
def snap_bounds(bounds=None, pyramid=None, zoom=None): """ Snaps bounds to tiles boundaries of specific zoom level. Parameters ---------- bounds : bounds to be snapped pyramid : TilePyramid zoom : int Returns ------- Bounds(left, bottom, right, top) """ bounds = validate_bounds(bounds) pyramid = validate_bufferedtilepyramid(pyramid) lb = pyramid.tile_from_xy(bounds.left, bounds.bottom, zoom, on_edge_use="rt").bounds rt = pyramid.tile_from_xy(bounds.right, bounds.top, zoom, on_edge_use="lb").bounds return Bounds(lb.left, lb.bottom, rt.right, rt.top)
def _validate_bounds(ctx, param, bounds): return validate_bounds(bounds) if bounds else None