示例#1
0
文件: rasters.py 项目: nens/gislib
    def _tiles(self, dataset, level, limit=False):
        """
        Return tile indices generator for the extent of dataset.

        If limit is true, do not return tiles that are fully outside
        the pyramids extent. This prevents creating lots and lots of
        empty datasets when datasets with extents much larger than our
        own are supplied to warpinto().
        """
        # Determine extent in pyramid projection from dataset
        dataset_geometry = DatasetGeometry.from_dataset(dataset)
        transformed_extent = utils.get_transformed_extent(
            extent=dataset_geometry.extent,
            source_projection=dataset.GetProjection(),
            target_projection=self.projection,
        )
        original_extent = np.array(dataset_geometry.extent)
        difference = (transformed_extent - original_extent).max()

        # If almost the same, take original because of rounding errors
        if difference:
            dataset_extent = transformed_extent
        else:
            dataset_extent = original_extent

        # Return extent, or intersected extent based on limit setting
        if limit:
            extent = np.array(utils.get_extent_intersection(self.extent,
                                                            dataset_extent))
        else:
            extent = np.array(dataset_extent)

        # Determine limits for the indices and return a generator
        delta = self._geometry(level).delta()
        x1, y1 = extent[:2] // delta
        # If extent upper bounds are on tile edge,
        # don't add neighbouring tiles.
        x2, y2 = np.where(
            extent[2:] // delta == extent[2:] / delta,
            extent[2:] // delta - 1,
            extent[2:] // delta,
        )
        # Return generator
        return ((x, y)
                for y in np.arange(y1, y2 + 1, dtype=np.int64)
                for x in np.arange(x1, x2 + 1, dtype=np.int64))
示例#2
0
文件: pyramids.py 项目: SiggyF/gislib
    def get_tiles_and_blocks(self, dataset):
        """ Return generator of tile and block indices. """
        tile_spacing = self.spacing
        dataset_extent = dataset2outline(dataset=dataset,
                                         projection=self.projection).extent

        for tile in get_tiles(spacing=tile_spacing, extent=dataset_extent):
            tile_extent = self.tile2extent(tile)
            intersection_extent = utils.get_extent_intersection(
                extent1=dataset_extent, extent2=tile_extent,
            )
            shifted_extent = (
                intersection_extent[0] - tile_extent[0],
                intersection_extent[1] - tile_extent[3],
                intersection_extent[2] - tile_extent[0],
                intersection_extent[3] - tile_extent[3],
            )
            block_spacing = tuple(c * b for c, b in zip(self.cell_size,
                                                        self.block_size))
            blocks = tuple(get_tiles(spacing=block_spacing,
                                     extent=shifted_extent))
            yield tile, blocks