def post_process_tile( tile: numpy.ndarray, mask: numpy.ndarray, rescale: str = None, color_formula: str = None, ) -> Tuple[numpy.ndarray, numpy.ndarray]: """Tile data post processing.""" if rescale: rescale_arr = (tuple(map(float, rescale.split(","))), ) * tile.shape[0] for bdx in range(tile.shape[0]): tile[bdx] = numpy.where( mask, linear_rescale(tile[bdx], in_range=rescale_arr[bdx], out_range=[0, 255]), 0, ) tile = tile.astype(numpy.uint8) if color_formula: if issubclass(tile.dtype.type, numpy.floating): tile = tile.astype(numpy.int16) # make sure one last time we don't have # negative value before applying color formula tile[tile < 0] = 0 for ops in parse_operations(color_formula): tile = scale_dtype(ops(to_math_type(tile)), numpy.uint8) return tile
def _postprocess( tile: numpy.ndarray, mask: numpy.ndarray, rescale: str = None, color_formula: str = None, ) -> Tuple[numpy.ndarray, numpy.ndarray]: """Post-process tile data.""" if rescale: rescale_arr = list(map(float, rescale.split(","))) rescale_arr = list(_chunks(rescale_arr, 2)) if len(rescale_arr) != tile.shape[0]: rescale_arr = ((rescale_arr[0]),) * tile.shape[0] for bdx in range(tile.shape[0]): tile[bdx] = numpy.where( mask, linear_rescale( tile[bdx], in_range=rescale_arr[bdx], out_range=[0, 255] ), 0, ) tile = tile.astype(numpy.uint8) if color_formula: # make sure one last time we don't have # negative value before applying color formula tile[tile < 0] = 0 for ops in parse_operations(color_formula): tile = scale_dtype(ops(to_math_type(tile)), numpy.uint8) return tile, mask
def _postprocess( tile: numpy.ndarray, mask: numpy.ndarray, tilesize: int, rescale: str = None, color_formula: str = None, ) -> Tuple[numpy.ndarray, numpy.ndarray]: if tile is None: # Return empty tile tile = numpy.zeros((1, tilesize, tilesize), dtype=numpy.uint8) mask = numpy.zeros((tilesize, tilesize), dtype=numpy.uint8) else: if rescale: rescale_arr = (tuple(map(float, rescale.split(","))), ) * tile.shape[0] for bdx in range(tile.shape[0]): tile[bdx] = numpy.where( mask, linear_rescale(tile[bdx], in_range=rescale_arr[bdx], out_range=[0, 255]), 0, ) tile = tile.astype(numpy.uint8) if color_formula: # make sure one last time we don't have # negative value before applying color formula tile[tile < 0] = 0 for ops in parse_operations(color_formula): tile = scale_dtype(ops(to_math_type(tile)), numpy.uint8) return tile, mask
def tiftile(): x = request.args.get('x') y = request.args.get('y') z = request.args.get('z') tifName = request.args.get('tname') tifPath1 = "d:\\data\\3010\\{}.tif".format(tifName) try: dataset = rasterio.open(tifPath1) tile, mask = reader.tile(dataset, int(x), int(y), int(z), tilesize=256) dataset.close() min = 0 max = 60 renderData = np.array([tile[0], tile[1]+tile[2]*0.3, tile[2]]) renderData = renderData.astype(np.uint8) mtdata = to_math_type(renderData) data = sigmoidal(mtdata, 10, 0.15)*255 buffer = render(data.astype(np.uint8), mask=mask) return send_file(io.BytesIO(buffer), mimetype="image/png", attachment_filename="{}_{}_{}.jpg".format(x, y, z)) except Exception as a: print(a) return abort(404) finally: pass
def arr_rgba(): return to_math_type( np.array([ [[1, 2], [3, 4]], # red [[5, 6], [7, 8]], # green [[9, 10], [11, 12]], # blue [[0, 0], [25.5, 25.5]], # alpha ]).astype("uint8") * 10)
def post_process( self, in_range: Optional[Tuple[NumType, NumType]] = None, out_dtype: Union[str, numpy.number] = "uint8", color_formula: Optional[str] = None, **kwargs: Any, ) -> "ImageData": """Post-process image data. Args: in_range (tuple): input min/max bounds value to rescale from. out_dtype (str, optional): output datatype after rescaling. Defaults to `uint8`. color_formula (str, optional): rio-color formula (see: https://github.com/mapbox/rio-color). kwargs (optional): keyword arguments to forward to `rio_tiler.utils.linear_rescale`. Returns: ImageData: new ImageData object with the updated data. Examples: >>> img.post_process(in_range=(0, 16000)) >>> img.post_process(color_formula="Gamma RGB 4.1") """ data = self.data.copy() mask = self.mask.copy() if in_range: rescale_arr = tuple(_chunks(in_range, 2)) if len(rescale_arr) != self.count: rescale_arr = ((rescale_arr[0]), ) * self.count for bdx in range(self.count): data[bdx] = numpy.where( self.mask, linear_rescale( data[bdx], in_range=rescale_arr[bdx], **kwargs, ), 0, ) data = data.astype(out_dtype) if color_formula: data[data < 0] = 0 for ops in parse_operations(color_formula): data = scale_dtype(ops(to_math_type(data)), numpy.uint8) return ImageData( data, mask, crs=self.crs, bounds=self.bounds, assets=self.assets, metadata=self.metadata, )
def arr(): return to_math_type( np.array([ # red [[1, 2], [3, 4]], # green [[5, 6], [7, 8]], # blue [[9, 10], [11, 12]], ]).astype("uint8") * 10)
def _postprocess_tile(tile, mask, rescale=None, color_ops=None): """Tile data post-processing.""" if rescale: rescale = (tuple(map(float, rescale.split(","))), ) * tile.shape[0] for bdx in range(tile.shape[0]): tile[bdx] = numpy.where( mask, linear_rescale(tile[bdx], in_range=rescale[bdx], out_range=[0, 255]), 0, ) tile = tile.astype(numpy.uint8) if color_ops: # make sure one last time we don't have # negative value before applying color formula tile[tile < 0] = 0 for ops in parse_operations(color_ops): tile = scale_dtype(ops(to_math_type(tile)), numpy.uint8) return tile, mask
def _postprocess(tile, mask, tilesize, rescale=None, color_formula=None): if tile is None: # Return empty tile tile = numpy.zeros((1, tilesize, tilesize), dtype=numpy.uint8) mask = numpy.zeros((tilesize, tilesize), dtype=numpy.uint8) else: if rescale: rescale = (tuple(map(float, rescale.split(","))), ) * tile.shape[0] for bdx in range(tile.shape[0]): tile[bdx] = numpy.where( mask, linear_rescale(tile[bdx], in_range=rescale[bdx], out_range=[0, 255]), 0, ) tile = tile.astype(numpy.uint8) if color_formula: for ops in parse_operations(color_formula): tile = scale_dtype(ops(to_math_type(tile)), numpy.uint8) return tile, mask
def _apply_color_operations(self, img, color_ops): for ops in parse_operations(color_ops): img = scale_dtype(ops(to_math_type(img)), numpy.uint8) return img
def test_scale_round_trip(arr): x = to_math_type(arr) y = scale_dtype(x, arr.dtype) assert np.array_equal(arr, y)
def test_to_math_type(arr): x = to_math_type(arr) assert x.dtype == math_type assert x.max() <= 1.0 assert x.min() >= 0.0
def main(source, reference, downsample, steps, plot): """Given a source image and a reference image, Find the rio color formula which results in an output with similar histogram to the reference image. Uses simulated annealing to determine optimal settings. Increase the --downsample option to speed things up. Increase the --steps to get better results (longer runtime). """ global fig, txt, imgs click.echo("Reading source data...", err=True) with rasterio.open(source) as src: if downsample is None: ratio = calc_downsample(src.width, src.height) else: ratio = downsample w = int(src.width // ratio) h = int(src.height // ratio) rgb = src.read((1, 2, 3), out_shape=(3, h, w)) orig_rgb = to_math_type(rgb) click.echo("Reading reference data...", err=True) with rasterio.open(reference) as ref: if downsample is None: ratio = calc_downsample(ref.width, ref.height) else: ratio = downsample w = int(ref.width / ratio) h = int(ref.height / ratio) rgb = ref.read((1, 2, 3), out_shape=(3, h, w)) ref_rgb = to_math_type(rgb) click.echo("Annealing...", err=True) est = ColorEstimator(orig_rgb, ref_rgb) if plot: import matplotlib.pyplot as plt fig = plt.figure(figsize=(20, 10)) fig.suptitle("Color Formula Optimization", fontsize=18, fontweight="bold") txt = fig.text(0.02, 0.05, "foo", family="monospace", fontsize=16) type(txt) axs = ( fig.add_subplot(1, 4, 1), fig.add_subplot(1, 4, 2), fig.add_subplot(1, 4, 3), fig.add_subplot(1, 4, 4), ) fig.tight_layout() axs[0].set_title("Source") axs[1].set_title("Current Formula") axs[2].set_title("Best Formula") axs[3].set_title("Reference") imgs.append(axs[0].imshow(reshape_as_image(est.src))) imgs.append(axs[1].imshow(reshape_as_image(est.src))) imgs.append(axs[2].imshow(reshape_as_image(est.src))) imgs.append(axs[3].imshow(reshape_as_image(est.ref))) fig.show() schedule = dict( tmax=25.0, # Max (starting) temperature tmin=1e-4, # Min (ending) temperature steps=steps, # Number of iterations updates=steps / 20, # Number of updates ) est.set_schedule(schedule) est.save_state_on_exit = False optimal, score = est.anneal() optimal["energy"] = score ops = est.cmd(optimal) click.echo("rio color -j4 {} {} {}".format(source, "/tmp/output.tif", ops))
band = rasterio.band(dataset, 1) print(band) tile, mask = reader.tile(dataset, 852, 418, 10, tilesize=1024) min = 0 max = 60 tile1 = (tile[0]-min)/max*255 tile2 = (tile[1]-min)/max*255 tile3 = (tile[2]-min)/max*255 tileList = np.array([tile[0], tile[1], tile[2]]) renderData = np.where(tileList > 255, 255, tileList) renderData = np.where(renderData < 0, 0, renderData) renderData = renderData.astype(np.uint8) mtdata = to_math_type(renderData) data = gamma(mtdata, 1.7) data = sigmoidal(mtdata, 10, 0)*255 buffer = render(data.astype(np.uint8), mask=mask) with open("reraster2.png", "wb") as f: f.write(buffer)