def test_jpg_pil(): pil_png = PILImage.open(rgb_file_png, mode="r") pil_jpg = PILImage.open(rgb_file_jpg, mode="r") img_rgb_jpg_true = np.asarray(pil_jpg) img_rgb_jpg_true = np.transpose(img_rgb_jpg_true, (2, 0, 1)) # Test equality when sending JPG buffer from PNG image jpg_buffer = io.BytesIO() pil_png.save(jpg_buffer, format='JPEG') jpg_bytes = jpg_buffer.getvalue() pesto_bytes_jpg = PestoImage.from_bytes(jpg_bytes).to_array() assert (np.all(pesto_bytes_jpg == img_rgb_jpg_true)) # Test equality when sending JPG buffer from JPG image png_buffer = io.BytesIO() pil_jpg.save(png_buffer, format='PNG') png_bytes = png_buffer.getvalue() pesto_bytes_jpg = PestoImage.from_bytes(png_bytes).to_array() assert (np.all(pesto_bytes_jpg == img_rgb_jpg_true)) # Test closeness of double comrpession buffer = io.BytesIO() pil_jpg.save(buffer, format='JPEG') pil_bytes = buffer.getvalue() pesto_bytes_jpg = PestoImage.from_bytes(pil_bytes).to_array() pil_bytes_jpg = PILImage.open(io.BytesIO(pil_bytes)) pil_bytes_jpg = np.asarray(pil_bytes_jpg).transpose((2, 0, 1)) assert np.all(np.isclose(pil_bytes_jpg, pesto_bytes_jpg))
def _get_result(uri, key_type): response = requests.get(uri) content_type = response.headers["Content-Type"] if key_type == "#/definitions/Images": driver = content_type.split("/")[-1] path = "{}.{}".format(NamedTemporaryFile().name, driver) result = Image.from_bytes(response.content).to_path(path) elif key_type == "#/definitions/Image": driver = content_type.split("/")[-1] path = "{}.{}".format(NamedTemporaryFile().name, driver) result = Image.from_bytes(response.content).to_path(path) elif key_type in [ "#/definitions/Metadata", "#/definitions/Metadatas", "#/definitions/Polygon", "#/definitions/Polygons", "#/definitions/Tag", "#/definitions/Tags", ]: result = response.json() elif key_type == "number": result = response.json() elif key_type == "string": result = response.text else: result = response.json() return result
def test_bytes_rio(): # Test RGB output_profile = dict( driver="GTiff", dtype=img_rgb_true.dtype, count=img_rgb_true.shape[0], height=img_rgb_true.shape[1], width=img_rgb_true.shape[2], ) with rasterio.MemoryFile() as memfile: with memfile.open(**output_profile) as dst: dst.write(img_rgb_true) bytes_buffer = memfile.read() pesto_bytes_rgb = PestoImage.from_bytes(bytes_buffer).to_array() # Test RGBN output_profile = dict( driver="GTiff", dtype=img_rgbn_true.dtype, count=img_rgbn_true.shape[0], height=img_rgbn_true.shape[1], width=img_rgbn_true.shape[2], ) with rasterio.MemoryFile() as memfile: with memfile.open(**output_profile) as dst: dst.write(img_rgbn_true) bytes_buffer = memfile.read() pesto_bytes_rgbn = PestoImage.from_bytes(bytes_buffer).to_array() assert np.all(img_rgb_true == pesto_bytes_rgb) assert np.all(img_rgbn_true == pesto_bytes_rgbn)
def _save_image(self, array: np.ndarray, key: str) -> None: image = Image(array=array) if image.bands() > 4: driver = "tif" else: driver = self._default_driver filename = os.path.join(self.job_path, "{}.{}".format(key, driver)) log.info("saving image : " + filename) image.to_path(filename)
def test_image_bytes_conversion(): data = get_image() img = Image.from_array(data) img_bytes = img.to_bytes() img_back = Image.from_bytes(img_bytes) data_back = img_back.array data = np.moveaxis(data, 0, -1) data_back = np.moveaxis(data_back, 0, -1) assert np.array_equal(data.shape, data_back.shape)
def _load_image(self, image_ref: Union[str, bytes]) -> np.ndarray: if isinstance(image_ref, str) and any( [image_ref.startswith(uri) for uri in self.URI_STRINGS]): image = Image.from_uri(image_ref, roi=self.roi) source = "uri" else: try: image = Image.from_bytes(image_ref) source = "bytes" except: image = Image.from_base64(image_ref) source = "base64" data = image.array log.info("loading image : {} : shape={}".format(source, data.shape)) return data
def test_uri_rio(): pesto_uri_rgb = PestoImage.from_uri("file://" + rgb_file_tif).to_array() pesto_uri_rgbn = PestoImage.from_uri("file://" + nir_file_tif).to_array() pesto_uri_rgb_png = PestoImage.from_uri("file://" + rgb_file_png).to_array() assert np.all(img_rgbn_true == pesto_uri_rgbn) assert np.all(img_rgb_true == pesto_uri_rgb) assert np.all(img_rgb_true == pesto_uri_rgb_png) # Ensure that the jpg driver of rasterio produces the same result as the PIL jpg decoder with PILImage.open(rgb_file_jpg, mode="r") as pil_jpg: img_rgb_jpg_true = np.asarray(pil_jpg) img_rgb_jpg_true = np.transpose(img_rgb_jpg_true, (2, 0, 1)) pesto_uri_rgb_jpg = PestoImage.from_uri("file://" + rgb_file_jpg).to_array() assert np.all(img_rgb_jpg_true == pesto_uri_rgb_jpg)
def test_image_roi(): data = os.path.abspath( os.path.join(os.path.dirname(__file__), 'resources/img_256x128.jpg')) data = "file://" + data roi = ImageROI({ "target_in": data, "target_out": data, 'lines': { 'first': 0, 'number': 100, 'margin': 10 }, 'columns': { 'first': 0, 'number': 200, 'margin': 15 } }) img_full = Image.from_uri(data).array img = Image.from_uri(data, roi).array assert (img.shape[0] == img_full.shape[0])
def process(self, payload: dict) -> Any: try: if self._unique_response(): log.info('response mode : stateless : unique response') result_id = list(self.schema.keys())[0] path, data_type = self.result_service.get_partial_result( result_id) if data_type == ResultType.image: return path, ResultType.image log.info('response mode : stateless') for key in payload.keys(): key_type = self.output_properties[key].get('$ref') if key_type == '#/definitions/Image': payload[key] = Image.from_array(payload[key]).to_base64() elif key_type == '#/definitions/Images': for index, img in enumerate(payload[key]): payload[key][index] = Image.from_array( payload[key][index]).to_base64() return payload, ResultType.json finally: job_path = os.path.join(JobListService.PESTO_WORKSPACE, self.job_id) shutil.rmtree(job_path, ignore_errors=True)
def test_roi_rio(): payload = { "target_in": nir_file_tif, "target_out": nir_file_tif.replace(".tif", "_out.tif"), "lines": { "first": 128, "number": 128, "margin": 32 }, "columns": { "first": 128, "number": 128, "margin": 32 } } roi = ImageROI(roi=payload) pesto_uri_rgbn = PestoImage.from_uri(uri=nir_file_tif, roi=roi).to_array() assert np.all(img_rgbn_true[:, (128 - 32):(128 + 128 + 32), (128 - 32):(128 + 128 + 32)] == pesto_uri_rgbn)
def _compare_vals(expected_v: Any, actual_v: Any) -> bool: if _is_file(expected_v) and _is_file(actual_v): expected_path = expected_v.replace("file://", "") response_path = actual_v.replace("file://", "") return filecmp.cmp(response_path, expected_path) elif (not _is_file(actual_v)) and (_is_file(expected_v) and _is_image(expected_v)): response_path = "{}{}".format(NamedTemporaryFile().name, os.path.splitext(expected_v)[1]) response_path = Image.from_base64(actual_v).to_path(response_path) response_path = response_path.replace("file://", "") expected_path = expected_v.replace("file://", "") return filecmp.cmp(response_path, expected_path) elif isinstance(expected_v, list): return all([ any([_compare_vals(v1, v2) for v2 in actual_v]) for v1 in expected_v ]) else: return expected_v == actual_v
def test_roi(): payload = create_payload( os.path.join(os.path.dirname(__file__), 'resources/img_256x128.jpg')) pesto = payload.pop('pesto') roi_conf = pesto.pop('roi') roi = ImageROI(roi_conf) payload = roi.compute_crop_infos().process(payload) # load images with cropping for _ in roi.target_in: payload[_] = Image.from_uri(payload[_], roi).array shape = payload[_].shape assert shape == (3, 50, 116) # remove margins payload = roi.remove_margin().process(payload) for _ in roi.target_out: shape = payload[_].shape assert shape == (3, roi.lines.number, roi.columns.number)
def open_url(url: str): with rasterio.Env(GDAL_HTTP_UNSAFESSL='YES'): image = Image.from_uri(url).to_array() return image
def load(self, file_path: str) -> str: image = Image.from_uri(file_path) return image.to_base64()