def get_tiles(ds, width, height): """ Takes as input the a tile and returns chips. ========================================== :width: Desired width of each chip. :height: Desired height of each chip. :out_path: Desired output file storage folder. :in_path: Folder where the input tile is stored. :input_filename: Name of the input tile :output_filename: Desired output file pattern =========================================== """ ncols = ds.meta["width"] nrows = ds.meta["height"] offsets = product(range(0, ncols, width), range(0, nrows, height)) big_window = windows.Window(col_off=0, row_off=0, width=ncols, height=nrows) for col_off, row_off in offsets: window = windows.Window( col_off=col_off, row_off=row_off, width=width, height=height, ).intersection(big_window) transform = windows.transform(window, ds.transform) yield window, transform
def get_tiles(src, nr_tiles): if nr_tiles < 36: scale = int(np.ceil(np.sqrt(nr_tiles))) size = int(src.meta['width'] / scale) #get original image dimension ncols, nrows = src.meta['width'], src.meta['height'] #define offsets (iterator) based on specified tile size offsets = product(range(0, ncols, size), range(0, nrows, size)) #create a large tile from original image dimension big_window = windows.Window(col_off=0, row_off=0, width=ncols, height=nrows) #find intersection with the large tile and get the tile dimension and affine tiles = [] for col_off, row_off in offsets: tile = windows.Window(col_off=col_off, row_off=row_off, width=size, height=size).intersection(big_window) tile_affine = windows.transform(tile, src.transform) tiles.append((tile, tile_affine)) return tiles else: print('Try number of tiles < 36')
def get_tiles(dataset, tile_a, tile_b): """Creates rasterio.windows for a given Band with the size of tile_a x tile_b :parameter: Open Source, tile-width in m, tile-height in m, :returns: rasterio window """ # calculate Width and Height as Distance from Origin tile_x, tile_y = (dataset.bounds.left + tile_a, dataset.bounds.top - tile_b) height, width = dataset.index(tile_x, tile_y) # get max rows and cols of dataset nols, nrows = dataset.meta['width'], dataset.meta['height'] # create offset for the window processing offsets = product(range(0, nols, width), range(0, nrows, height)) # create big_window around the whole dataset big_window = windows.Window(col_off=0, row_off=0, width=nols, height=nrows) # create custom set blocks for col_off, row_off in offsets: # get windows with the custom parameters # until it intersects with # the boundaries of the source dataset window = windows.Window(col_off=col_off, row_off=row_off, width=width, height=height).intersection(big_window) transform = windows.transform(window, dataset.transform) yield window, transform
def get_tiles(datasource, width=64, height=64, fold=1, extension=16): """Function to create the product matrix for the tiles from the big picture. Width & Height corresponds to the tile dimensions, whereas fold refers to the overlap of the tiles. 1 = no overlap, 2 = overlapping by a half tile, and so on.""" ncols, nrows = datasource.meta['width'], datasource.meta['height'] offsets = product(range(0, ncols, width//fold), range(0, nrows, height//fold)) # control the level of overlap big_window = windows.Window(col_off=0, row_off=0, width=ncols, height=nrows) # defining window and transfor functions (original and extended) for col_off, row_off in offsets: # creating the original tile window_original = windows.Window(col_off=col_off, row_off=row_off, width=width, height=height).intersection(big_window) transform_original = windows.transform(window_original, datasource.transform) # creating the extended boundary tile col_off_extended = col_off - extension row_off_extended = row_off - extension width_extended = width + extension*2 height_extended = height + extension*2 # windowing with the extended tile window_extended = windows.Window(col_off = col_off_extended, row_off = row_off_extended, width = width_extended, height = height_extended).intersection(big_window) transform_extended = windows.transform(window_extended, datasource.transform) yield window_original, transform_original, window_extended, transform_extended
def generate_tiles(input_tif, width=500, height=500): n_cols, n_rows = input_tif.meta['width'], input_tif.meta['height'] offsets = product(range(0, n_cols, width), range(0, n_rows, height)) full_window = windows.Window(col_off=0, row_off=0, width=n_cols, height=n_rows) for col_off, row_off in offsets: window=windows.Window(col_off=col_off, row_off=row_off, width=width, height=height).intersection(full_window) transform = windows.transform(window, input_tif.transform) yield window, transform
def get_tiles(ds, width, height): nols, nrows = ds.meta['width'], ds.meta['height'] offsets = product(range(0, nols, width), range(0, nrows, height)) big_window = windows.Window(col_off=0, row_off=0, width=nols, height=nrows) for col_off, row_off in offsets: window =windows.Window(col_off=col_off, row_off=row_off, width=width, height=height).intersection(big_window) transform = windows.transform(window, ds.transform) yield window, transform
def get_tiles(ds, width=256, height=256): nols, nrows = ds.meta['width'], ds.meta['height'] offsets = product(range(0, nols, int(width / 2)), range(0, nrows, int(height / 2))) big_window = windows.Window(col_off=0, row_off=0, width=nols, height=nrows) for col_off, row_off in offsets: window = windows.Window(col_off=col_off, row_off=row_off, width=width, height=height).intersection(big_window) if window.width == width and window.height == height: transform = windows.transform(window, ds.transform) yield window, transform
def _get_window_transform(width, height): num_rows, num_cols = src.meta['height'], src.meta['width'] offsets = itertools.product(range(0, num_cols, width), range(0, num_rows, height)) big_window = windows.Window(col_off=0, row_off=0, width=num_cols, height=num_rows) for col_off, row_off in offsets: window = windows.Window(col_off=col_off, row_off=row_off, width=width, height=height).intersection(big_window) transform = windows.transform(window, src.transform) yield window, transform
def _get_window_transform(width, height, transform, num_tile_subdivisions): dst_width = width // num_tile_subdivisions dst_height = height // num_tile_subdivisions offsets = itertools.product(range(0, width, dst_width), range(0, height, dst_height)) big_window = windows.Window(col_off=0, row_off=0, width=width, height=height) for col_off, row_off in offsets: dst_window = windows.Window(col_off=col_off, row_off=row_off, width=dst_width, height=dst_height).intersection(big_window) dst_transform = windows.transform(dst_window, transform) yield dst_window, dst_transform
def open_chosen_bands(dirpath, chosen_bands, size, position): # the directory should only contain 13 image files # representing bands sensed by sentinel-2 # the files should be named according to the bands # they represent: B01.jp2, B02.jp2 ... bands = listdir(dirpath) bands.sort() bands = [Path(dirpath, band) for n, band in enumerate(bands)] # TODO: check image limits coef_h, coef_w, mh, mw = get_size_coefs(dirpath) tile_layers = [] for band in chosen_bands: with rasterio.open(bands[band]) as src: # Size and position are set for the tile from the band with # the lowest resolution (among the chosen), thus the bands # with higher resolutoins have proportionally bigger tiles. img = src.read(1, window=windows.Window(\ position[0] // coef_h[band], position[1] // coef_w[band], size[0] // coef_h[band], size[1] // coef_w[band])) # resize tiles to the size of the biggest tile img = cv2.resize( img, (img.shape[1] * coef_h[band], img.shape[0] * coef_w[band])) resid_y = size[0] - img.shape[0] resid_x = size[1] - img.shape[1] img = np.pad(img, ((0, resid_y), (0, resid_x)), 'constant', constant_values=((0, 0), (0, 0))) tile_layers.append(img) return tile_layers
def test_window_rt_north_down(dataset): """Get correct window for full dataset extent""" left, top = dataset.transform * (0, 0) right, bottom = dataset.transform * (dataset.width, dataset.height) assert_windows_almost_equal( dataset.window(left, bottom, right, top), windows.Window(0, 0, dataset.width, dataset.height))
def get_values(self, window=None, band=None, **kwargs): i = 1 if band is None else band window = windows.Window(0, 0, self._src.shape[1], self._src.shape[0]) \ if window is None else window if window is not None: assert isinstance(window, windows.Window) return self._src.read(i, window=window, **kwargs)
def get_iter_windows(width, height, chunk_size=0, overlap=0, row_off=0, col_off=0): h = chunk_size for i in range(int(row_off), int(row_off + height + chunk_size), chunk_size): if i + h > row_off + height: h = height - i if h <= 0: break w = chunk_size for j in range(int(col_off), int(col_off + width + chunk_size), chunk_size): if j + w > col_off + width: w = width - j if w <= 0: break o = overlap while j + w + o > width: o -= 1 w += o o = overlap while i + h + o > height: o -= 1 h += o yield windows.Window(j, i, w, h)
def values(self, *i, **kwargs): window = kwargs.pop('window', None) window = windows.Window(0, 0, self._src.shape[1], self._src.shape[0]) \ if window is None else window if window is not None: assert isinstance(window, windows.Window) return self._src.read(*i, window=window, **kwargs)
def get_window_tiles(ds: rasterio.io.DatasetReader, height: int = 128, width: int = 128, **kwargs) -> List[rasterio.windows.Window]: """a generator for rasterio specific slices given a rasterio dataset Args: ds (rasterio.io.DatasetReader): a rasterio dataset object height (int): the height for the slice width (int): the width for the slice Yields: window (rasterio.windows.Window): slicing """ # extract the row height from the dataset n_columns, n_rows = ds.meta["width"], ds.meta["height"] # create the offsets offsets = product(range(0, n_columns, width), range(0, n_rows, height)) list_of_windows = [] for col_offset, row_offset in offsets: iwindow = windows.Window(col_off=col_offset, row_off=row_offset, width=width, height=height, **kwargs) list_of_windows.append(iwindow) return list_of_windows
def test_window(): with rasterio.open('tests/data/RGB.byte.tif') as src: left, bottom, right, top = src.bounds dx, dy = src.res eps = 1.0e-8 assert_window_almost_equals( src.window(left + eps, bottom + eps, right - eps, top - eps), windows.Window(0, 0, src.width, src.height)) assert src.index(left + 400, top - 400) == (1, 1) assert src.index(left + dx + eps, top - dy - eps) == (1, 1) assert_window_almost_equals( src.window(left, top - 400, left + 400, top), windows.Window(0, 0, 400 / src.res[0], 400 / src.res[1])) assert_window_almost_equals( src.window(left, top - 2 * dy - eps, left + 2 * dx - eps, top), windows.Window(0, 0, 2, 2))
def test_get_tiles(self): for idx, each in enumerate(self.img.get_tiles(5, 5, 1)): self.assertIsInstance(each, windows.Window) if idx == 2578: self.assertEqual(each, windows.Window(col_off=79, row_off=649, width=7, height=7)) self.assertEqual(idx, 20807)
def test_window_no_exception(): with rasterio.open('tests/data/RGB.byte.tif') as src: left, bottom, right, top = src.bounds left -= 1000.0 assert_window_almost_equals( src.window(left, bottom, right, top), windows.Window(-1000 / src.res[0], 0, src.width + 1000 / src.res[0], src.height))
def get_tiles(ds, width=256, height=256): out_window = [] out_transform = [] ncols, nrows = ds.meta['width'], ds.meta['height'] offsets = product(range(0, ncols, width), range(0, nrows, height)) big_window = windows.Window(col_off=0, row_off=0, width=ncols, height=nrows) for col_off, row_off in offsets: window = windows.Window(col_off=col_off, row_off=row_off, width=width, height=height).intersection(big_window) out_window.append(window) out_transform.append(windows.transform(window, ds.transform)) return out_window, out_transform
def get_tile(self, file, width=512, height=512, col_off=0, row_off=0): with rio.open(file, dtype='float32') as data: meta = data.meta.copy() return data.read().transpose(1, 2, 0).astype(rio.float32), meta ncols, nrows = meta['width'], meta['height'] offsets = product(range(0, ncols, width), range(0, nrows, height)) big_window = wnd.Window(col_off=0, row_off=0, width=ncols, height=nrows) window = wnd.Window(col_off=col_off * width, row_off=row_off * height, width=width, height=height).intersection(big_window) transform = wnd.transform(window, data.transform) meta['transform'] = transform meta['width'], meta['height'] = window.width, window.height return data.read(window=window).transpose(1, 2, 0).astype(rio.float32), meta
def get_window(file_path, width=512, height=512, col_off=0, row_off=0): with rio.open(file_path) as data: meta = data.meta.copy() ncols, nrows = meta['width'], meta['height'] offsets = product(range(0, ncols, width), range(0, nrows, height)) full_image = wnd.Window(col_off=0, row_off=0, width=ncols, height=nrows) window = wnd.Window(col_off=col_off * width, row_off=row_off * height, width=width, height=height).intersection(full_image) transform = wnd.transform(window, meta['transform']) meta['transform'] = transform meta['width'], meta['height'] = window.width, window.height return data.read(window=window).transpose(1, 2, 0), meta
def get_x(self, window=None): window = windows.Window(0, 0, self._src.shape[1], self._src.shape[0]) \ if window is None else window if window is not None: assert isinstance(window, windows.Window) width = window.width else: width = self.shape[0] x0, y0, x1, y1 = self.get_array_bounds(window) return np.linspace(x0, x1, width)
def get_y(self, window=None): window = windows.Window(0, 0, self._src.shape[1], self._src.shape[0]) \ if window is None else window if window is not None: assert isinstance(window, windows.Window) height = window.height else: height = self.shape[1] x0, y0, x1, y1 = self.get_array_bounds(window) return np.linspace(y1, y0, height)
def get_tiles(ds, tile_a, tile_b): """Tiles a band into blocks with the dimension of tile_a x tile_b :parameter: Band, tile-width and tile-height :returns: rasterio window """ # calculate Width and Height as Distance from Origin x, y = (ds.bounds.left + tile_a, ds.bounds.top - tile_b) height, width = ds.index(x, y) nols, nrows = ds.meta['width'], ds.meta['height'] offsets = product(range(0, nols, width), range(0, nrows, height)) big_window = windows.Window(col_off=0, row_off=0, width=nols, height=nrows) # create custom set blocks for col_off, row_off in offsets: window = windows.Window(col_off=col_off, row_off=row_off, width=width, height=height).intersection(big_window) transform = windows.transform(window, ds.transform) yield window, transform
def get_patch_windows(img_size: ImageSize, patch_size: PatchSize, patch_residue: PatchResidue = None, img_transform=None) -> Iterator: img_w, img_h = img_size big_window = windows.Window( col_off=0, row_off=0, width=img_w, height=img_h) offsets = get_patch_offsets((img_w, img_h), patch_size, patch_residue) patch_w, patch_h = normalize_patch_size(patch_size) for col_off, row_off in offsets: window = windows.Window( col_off=col_off, row_off=row_off, width=patch_w, height=patch_h ).intersection(big_window) if img_transform: transform = windows.transform(window, img_transform) yield window, transform else: yield window
def get_tiles(dataset, width=utils.constants.width, height=utils.constants.height): """ Implementation from https://github.com/jesseniagonzalezv/App_segmentation_water_bodies :param dataset: data reader :param width: patch expected width :param height: patch expected height :return: crop windows and Affine transform """ nols, nrows = dataset.meta['width'], dataset.meta['height'] offsets = product(range(0, nols, width), range(0, nrows, height)) big_window = windows.Window(col_off=0, row_off=0, width=nols, height=nrows) for col_off, row_off in offsets: window = windows.Window(col_off=col_off, row_off=row_off, width=width, height=height).intersection(big_window) transform = windows.transform(window, dataset.transform) yield window, transform
def overlapping_blocks(src, overlap=0, band=1, boundless=False): big_window = windows.Window(col_off=0, row_off=0, width=src.meta['width'], height=src.meta['height']) for ji, window in src.block_windows(band): if overlap == 0: yield window else: window = windows.Window(col_off=window.col_off - overlap, row_off=window.row_off - overlap, width=window.width + overlap * 2, height=window.height + overlap * 2) if boundless: yield window else: yield window.intersection(big_window)
def overlapping_tiles(src, overlap, width, height, boundless=False): """"width & height not including overlap i.e requesting a 256x256 window with 1px overlap will return a 258x258 window (for non edge windows)""" offsets = product(range(0, src.meta['width'], width), range(0, src.meta['height'], height)) big_window = windows.Window(col_off=0, row_off=0, width=src.meta['width'], height=src.meta['height']) for col_off, row_off in offsets: window = windows.Window(col_off=col_off - overlap, row_off=row_off - overlap, width=width + overlap * 2, height=height + overlap * 2) if boundless: yield window else: yield window.intersection(big_window)
def test_write_window(self): name = os.path.join(self.tempdir, "test_write_window.tif") a = np.ones((50, 50), dtype=rasterio.ubyte) * 127 with rasterio.open( name, 'w', driver='GTiff', width=100, height=100, count=1, dtype=a.dtype) as s: s.write(a, indexes=1, window=windows.Window(10, 30, 50, 50)) # subprocess.call(["open", name]) info = subprocess.check_output(["gdalinfo", "-stats", name]) self.assertTrue( "Minimum=0.000, Maximum=127.000, " "Mean=31.750, StdDev=54.993" in info.decode('utf-8'), info)
def crop(pixel_collection, data_format, offsets): data, (bounds, data_crs), _ = pixel_collection left, bottom, right, top = offsets if _isimage(data_format): width, height, _ = data.shape t = transform.from_bounds(*bounds, width=width, height=height) data = data[top:height - bottom, left:width - right, :] cropped_window = windows.Window(left, top, width, height) cropped_bounds = windows.bounds(cropped_window, t) return PixelCollection(data, Bounds(cropped_bounds, data_crs)) _, height, width = data.shape t = transform.from_bounds(*bounds, width=width, height=height) data = data[:, top:height - bottom, left:width - right] cropped_window = windows.Window(left, top, width, height) cropped_bounds = windows.bounds(cropped_window, t) return PixelCollection(data, Bounds(cropped_bounds, data_crs))