[feat] handle prompt point as lat-lng coordinates

events/payload_point.json

@@ -3,7 +3,7 @@
   "sw": {"lat": 30.1, "lng": 148.492},
   "prompt": [{
     "type": "point",
-    "data": [500, 600],
+    "data": {"lat": 36.91, "lng": 136.854},
     "label": 0
   }],
   "zoom": 6,

src/app.py

@@ -7,6 +7,7 @@ from aws_lambda_powertools.event_handler import content_types
 from aws_lambda_powertools.utilities.typing import LambdaContext
 
 from src import app_logger
+from src.io.coordinates_pixel_conversion import get_point_latlng_to_pixel_coordinates, get_latlng_to_pixel_coordinates
 from src.prediction_api.predictors import samexporter_predict
 from src.utilities.constants import CUSTOM_RESPONSE_MESSAGES
 from src.utilities.utilities import base64_decode
@@ -26,7 +27,7 @@ def get_response(status: int, start_time: float, request_id: str, response_body:
         str: json response
 
     """
-    app_logger.info(f"response_body:{response_body}.")
+    app_logger.debug(f"response_body:{response_body}.")
     response_body["duration_run"] = time.time() - start_time
     response_body["message"] = CUSTOM_RESPONSE_MESSAGES[status]
     response_body["request_id"] = request_id
@@ -45,17 +46,27 @@ def get_parsed_bbox_points(request_input: Dict) -> Dict:
     app_logger.info(f"try to parsing input request {request_input}...")
     ne = request_input["ne"]
     sw = request_input["sw"]
-    bbox = [
-        [float(ne["lat"]), float(ne["lng"])],
-        [float(sw["lat"]), float(sw["lng"])]
-    ]
-    app_logger.info(f"bbox {bbox}.")
-
-    app_logger.info(f"unpacking {request_input}...")
+    ne_latlng = [float(ne["lat"]), float(ne["lng"])]
+    sw_latlng = [float(sw["lat"]), float(sw["lng"])]
+    bbox = [ne_latlng, sw_latlng]
+    zoom = int(request_input["zoom"])
+    for prompt in request_input["prompt"]:
+        app_logger.info(f"current prompt: {type(prompt)}, value:{prompt}.")
+        data = prompt["data"]
+        app_logger.info(f"current data point: {type(data)}, value:{data}.")
+
+        diff_pixel_coordinates_ne = get_latlng_to_pixel_coordinates(ne, data, zoom)
+        app_logger.info(f'current data by current prompt["data"]: {type(data)}, {data} => {diff_pixel_coordinates_ne}.')
+        prompt["data"] = [diff_pixel_coordinates_ne["x"], diff_pixel_coordinates_ne["y"]]
+
+    app_logger.debug(f"bbox {bbox}.")
+    app_logger.debug(f'request_input["prompt"]:{request_input["prompt"]}.')
+
+    app_logger.info(f"unpacking elaborated {request_input}...")
     return {
         "bbox": bbox,
         "prompt": request_input["prompt"],
-        "zoom": int(request_input["zoom"])
+        "zoom": zoom
     }
 
 
@@ -67,8 +78,8 @@ def lambda_handler(event: dict, context: LambdaContext):
         app_logger.info(f"event version: {event['version']}.")
 
     try:
-        app_logger.info(f"event:{json.dumps(event)}...")
-        app_logger.info(f"context:{context}...")
+        app_logger.debug(f"event:{json.dumps(event)}...")
+        app_logger.debug(f"context:{context}...")
 
         try:
             body = event["body"]
@@ -76,19 +87,19 @@ def lambda_handler(event: dict, context: LambdaContext):
             app_logger.error(f"e_constants1:{e_constants1}.")
             body = event
 
-        app_logger.info(f"body: {type(body)}, {body}...")
+        app_logger.debug(f"body, #1: {type(body)}, {body}...")
 
         if isinstance(body, str):
             body_decoded_str = base64_decode(body)
-            app_logger.info(f"body_decoded_str: {type(body_decoded_str)}, {body_decoded_str}...")
+            app_logger.debug(f"body_decoded_str: {type(body_decoded_str)}, {body_decoded_str}...")
             body = json.loads(body_decoded_str)
 
-        app_logger.info(f"body:{body}...")
+        app_logger.info(f"body, #2: {type(body)}, {body}...")
 
         try:
             body_request = get_parsed_bbox_points(body)
             body_response = samexporter_predict(body_request["bbox"], body_request["prompt"], body_request["zoom"])
-            app_logger.info(f"body_response::output:{body_response}.")
+            app_logger.info(f"output body_response:{body_response}.")
             response = get_response(HTTPStatus.OK.value, start_time, context.aws_request_id, body_response)
         except Exception as ex2:
             app_logger.error(f"exception2:{ex2}.")

src/io/coordinates_pixel_conversion.py

@@ -0,0 +1,53 @@
+import math
+from typing import TypedDict, List
+
+from src import app_logger
+from src.utilities.constants import TILE_SIZE
+
+
+class PixelCoordinate(TypedDict):
+    x: int
+    y: int
+
+
+def get_latlng2pixel_projection(latlng) -> PixelCoordinate:
+    app_logger.info(f"latlng: {type(latlng)}, value:{latlng}.")
+    app_logger.info(f'latlng lat: {type(latlng["lat"])}, value:{latlng["lat"]}.')
+    app_logger.info(f'latlng lng: {type(latlng["lng"])}, value:{latlng["lng"]}.')
+    try:
+        sin_y: float = math.sin(latlng["lat"] * math.pi / 180)
+        app_logger.info(f"sin_y, #1:{sin_y}.")
+        sin_y = min(max(sin_y, -0.9999), 0.9999)
+        app_logger.info(f"sin_y, #2:{sin_y}.")
+        x = TILE_SIZE * (0.5 + latlng["lng"] / 360)
+        app_logger.info(f"x:{x}.")
+        y = TILE_SIZE * (0.5 - math.log((1 + sin_y) / (1 - sin_y)) / (4 * math.pi))
+        app_logger.info(f"y:{y}.")
+
+        return {"x": x, "y": y}
+    except Exception as e_get_latlng2pixel_projection:
+        app_logger.error(f'e_get_latlng2pixel_projection:{e_get_latlng2pixel_projection}.')
+        raise e_get_latlng2pixel_projection
+
+
+def get_point_latlng_to_pixel_coordinates(latlng, zoom: int) -> PixelCoordinate:
+    try:
+        world_coordinate: PixelCoordinate = get_latlng2pixel_projection(latlng)
+        app_logger.debug(f"world_coordinate:{world_coordinate}.")
+        scale: int = pow(2, zoom)
+        app_logger.debug(f"scale:{scale}.")
+        return PixelCoordinate(
+            x=math.floor(world_coordinate["x"] * scale),
+            y=math.floor(world_coordinate["y"] * scale)
+        )
+    except Exception as e_format_latlng_to_pixel_coordinates:
+        app_logger.error(f'format_latlng_to_pixel_coordinates:{e_format_latlng_to_pixel_coordinates}.')
+        raise e_format_latlng_to_pixel_coordinates
+
+
+def get_latlng_to_pixel_coordinates(latlng_origin, latlng_current_point, zoom):
+    latlng_map_origin = get_point_latlng_to_pixel_coordinates(latlng_origin, zoom)
+    latlng_map_current_point = get_point_latlng_to_pixel_coordinates(latlng_current_point, zoom)
+    diff_coord_x = abs(latlng_map_origin["x"] - latlng_map_current_point["x"])
+    diff_coord_y = abs(latlng_map_origin["y"] - latlng_map_current_point["y"])
+    return PixelCoordinate(x=diff_coord_x, y=diff_coord_y)

src/io/tms2geotiff.py

@@ -14,19 +14,19 @@ import concurrent.futures
 from PIL import Image
 from PIL import TiffImagePlugin
 
+from src import PROJECT_ROOT_FOLDER, app_logger
 from src.utilities.constants import EARTH_EQUATORIAL_RADIUS, WKT_3857, DEFAULT_TMS
 
-
 Image.MAX_IMAGE_PIXELS = None
 
-
 try:
     import httpx
+
     SESSION = httpx.Client()
 except ImportError:
     import requests
-    SESSION = requests.Session()
 
+    SESSION = requests.Session()
 
 SESSION.headers.update({
     "Accept": "*/*",
@@ -40,14 +40,14 @@ re_coords_split = re.compile('[ ,;]+')
 def from4326_to3857(lat, lon):
     xtile = math.radians(lon) * EARTH_EQUATORIAL_RADIUS
     ytile = math.log(math.tan(math.radians(45 + lat / 2.0))) * EARTH_EQUATORIAL_RADIUS
-    return (xtile, ytile)
+    return xtile, ytile
 
 
 def deg2num(lat, lon, zoom):
     n = 2 ** zoom
     xtile = ((lon + 180) / 360 * n)
     ytile = (1 - math.asinh(math.tan(math.radians(lat))) / math.pi) * n / 2
-    return (xtile, ytile)
+    return xtile, ytile
 
 
 def is_empty(im):
@@ -69,12 +69,12 @@ def mbtiles_init(dbname):
     cur.execute("BEGIN")
     cur.execute("CREATE TABLE IF NOT EXISTS metadata (name TEXT PRIMARY KEY, value TEXT)")
     cur.execute("CREATE TABLE IF NOT EXISTS tiles ("
-        "zoom_level INTEGER NOT NULL, "
-        "tile_column INTEGER NOT NULL, "
-        "tile_row INTEGER NOT NULL, "
-        "tile_data BLOB NOT NULL, "
-        "UNIQUE (zoom_level, tile_column, tile_row)"
-    ")")
+                "zoom_level INTEGER NOT NULL, "
+                "tile_column INTEGER NOT NULL, "
+                "tile_row INTEGER NOT NULL, "
+                "tile_data BLOB NOT NULL, "
+                "UNIQUE (zoom_level, tile_column, tile_row)"
+                ")")
     cur.execute("COMMIT")
     return db
 
@@ -89,13 +89,13 @@ def paste_tile(bigim, base_size, tile, corner_xy, bbox):
         base_size[0] = size[0]
         base_size[1] = size[1]
         newim = Image.new(mode, (
-            size[0]*(bbox[2]-bbox[0]), size[1]*(bbox[3]-bbox[1])))
+            size[0] * (bbox[2] - bbox[0]), size[1] * (bbox[3] - bbox[1])))
     else:
         newim = bigim
 
     dx = abs(corner_xy[0] - bbox[0])
     dy = abs(corner_xy[1] - bbox[1])
-    xy0 = (size[0]*dx, size[1]*dy)
+    xy0 = (size[0] * dx, size[1] * dy)
     if mode == 'RGB':
         newim.paste(im, xy0)
     else:
@@ -113,7 +113,8 @@ def get_tile(url):
         try:
             r = SESSION.get(url, timeout=60)
             break
-        except Exception:
+        except Exception as request_tile_exception:
+            app_logger.error(f"retry {retry}, request_tile_exception:{request_tile_exception}.")
             retry -= 1
             if not retry:
                 raise
@@ -127,7 +128,7 @@ def get_tile(url):
 
 def print_progress(progress, total, done=False):
     if done:
-        print('Downloaded image %d/%d, %.2f%%' % (progress, total, progress*100/total))
+        print('Downloaded image %d/%d, %.2f%%' % (progress, total, progress * 100 / total))
 
 
 class ProgressBar:
@@ -175,7 +176,7 @@ def mbtiles_save(db, img_data, xy, zoom, img_format):
     else:
         current_format = 'image/' + im.format.lower()
     x, y = xy
-    y = 2**zoom - 1 - y
+    y = 2 ** zoom - 1 - y
     cur = db.cursor()
     if img_format is None or img_format == current_format:
         cur.execute("REPLACE INTO tiles VALUES (?,?,?,?)", (
@@ -196,10 +197,10 @@ def mbtiles_save(db, img_data, xy, zoom, img_format):
 
 
 def download_extent(
-    source, lat0, lon0, lat1, lon1, zoom,
-    mbtiles=None, save_image=True,
-    progress_callback=print_progress,
-    callback_interval=0.05
+        source, lat0, lon0, lat1, lon1, zoom,
+        mbtiles=None, save_image=True,
+        progress_callback=print_progress,
+        callback_interval=0.05
 ):
     x0, y0 = deg2num(lat0, lon0, zoom)
     x1, y1 = deg2num(lat1, lon1, zoom)
@@ -241,7 +242,7 @@ def download_extent(
         cur.execute("REPLACE INTO metadata VALUES ('bounds', ?)", (
             ",".join(map(str, bounds)),))
         cur.execute("REPLACE INTO metadata VALUES ('center', ?)", ("%s,%s,%d" % (
-            (lon_max + lon_min)/2, (lat_max + lat_min)/2, zoom),))
+            (lon_max + lon_min) / 2, (lat_max + lat_min) / 2, zoom),))
         cur.execute("""
             INSERT INTO metadata VALUES ('minzoom', ?)
             ON CONFLICT(name) DO UPDATE SET value=excluded.value
@@ -267,7 +268,7 @@ def download_extent(
     with concurrent.futures.ThreadPoolExecutor(5) as executor:
         for x, y in corners:
             future = executor.submit(get_tile, source.format(z=zoom, x=x, y=y))
-            futures[future] = (x, y) 
+            futures[future] = (x, y)
         bbox = (math.floor(x0), math.floor(y0), math.ceil(x1), math.ceil(y1))
         bigim = None
         base_size = [256, 256]
@@ -316,11 +317,11 @@ def download_extent(
 
     xfrac = x0 - bbox[0]
     yfrac = y0 - bbox[1]
-    x2 = round(base_size[0]*xfrac)
-    y2 = round(base_size[1]*yfrac)
-    imgw = round(base_size[0]*(x1-x0))
-    imgh = round(base_size[1]*(y1-y0))
-    retim = bigim.crop((x2, y2, x2+imgw, y2+imgh))
+    x2 = round(base_size[0] * xfrac)
+    y2 = round(base_size[1] * yfrac)
+    imgw = round(base_size[0] * (x1 - x0))
+    imgh = round(base_size[1] * (y1 - y0))
+    retim = bigim.crop((x2, y2, x2 + imgw, y2 + imgh))
     if retim.mode == 'RGBA' and retim.getextrema()[3] == (255, 255):
         retim = retim.convert('RGB')
     bigim.close()
@@ -411,7 +412,7 @@ def save_image_fn(img, filename, matrix, **params):
     elif ext == '.png':
         img_params['optimize'] = True
     elif ext.startswith('.tif'):
-        if img_memorysize(img) >= 4*1024*1024*1024:
+        if img_memorysize(img) >= 4 * 1024 * 1024 * 1024:
             # BigTIFF
             return save_geotiff_gdal(img, filename, matrix)
         img_params['compression'] = 'tiff_adobe_deflate'
@@ -437,14 +438,14 @@ def save_geotiff_gdal(img, filename, matrix):
     imgbands = len(img.getbands())
     driver = gdal.GetDriverByName('GTiff')
     gdal_options = ['COMPRESS=DEFLATE', 'PREDICTOR=2', 'ZLEVEL=9', 'TILED=YES']
-    if img_memorysize(img) >= 4*1024*1024*1024:
+    if img_memorysize(img) >= 4 * 1024 * 1024 * 1024:
         gdal_options.append('BIGTIFF=YES')
-    if img_memorysize(img) >= 50*1024*1024:
+    if img_memorysize(img) >= 50 * 1024 * 1024:
         gdal_options.append('NUM_THREADS=%d' % max(1, os.cpu_count()))
 
     gtiff = driver.Create(filename, img.size[0], img.size[1],
-        imgbands, gdal.GDT_Byte,
-        options=gdal_options)
+                          imgbands, gdal.GDT_Byte,
+                          options=gdal_options)
     gtiff.SetGeoTransform(matrix)
     gtiff.SetProjection(WKT_3857)
     for band in range(imgbands):
@@ -589,12 +590,12 @@ def gui():
             return
         root_tk.update()
         try:
-            img, matrix = download_extent(
+            img, matrix_projection = download_extent(
                 *args, progress_callback=update_progress, **kwargs)
             b_download.configure(text='Saving...', state='disabled')
             root_tk.update()
             if filename:
-                save_image_auto(img, filename, matrix)
+                save_image_auto(img, filename, matrix_projection)
             reset()
         except TaskCancelled:
             reset()
@@ -632,7 +633,6 @@ def gui():
 
 
 def downloader(input_args, input_parser):
-
     download_args = [input_args.source]
     try:
         if input_args.extent:
@@ -652,11 +652,11 @@ def downloader(input_args, input_parser):
     download_args.append(bool(input_args.output))
     progress_bar = ProgressBar()
     download_args.append(progress_bar.print_progress)
-    img, matrix = download_extent(*download_args)
+    img_geo, matrix = download_extent(*download_args)
     progress_bar.close()
     if input_args.output:
         print(f"Saving image to {input_args.output}.")
-        save_image_auto(img, input_args.output, matrix)
+        save_image_auto(img_geo, input_args.output, matrix)
     return 0
 
 
@@ -670,8 +670,8 @@ def main():
     parser.add_argument("-f", "--from", metavar='LAT,LON', help="one corner")
     parser.add_argument("-t", "--to", metavar='LAT,LON', help="the other corner")
     parser.add_argument("-e", "--extent",
-        metavar='min_lon,min_lat,max_lon,max_lat',
-        help="extent in one string (use either -e, or -f and -t)")
+                        metavar='min_lon,min_lat,max_lon,max_lat',
+                        help="extent in one string (use either -e, or -f and -t)")
     parser.add_argument("-z", "--zoom", type=int, help="zoom level")
     parser.add_argument("-m", "--mbtiles", help="save MBTiles file")
     parser.add_argument("-g", "--gui", action='store_true', help="show GUI")
@@ -690,8 +690,8 @@ if __name__ == '__main__':
     # sys.exit(main())
     pt0 = 45.699, 127.1
     pt1 = 30.1, 148.492
-    img_output_filename = "/Users/trincuz/workspace/segment-geospatial/tmp/japan_out_main.png"
-    img, matrix = download_extent(DEFAULT_TMS, pt0[0], pt0[1], pt1[0], pt1[1], 6)
+    geo_img_output_filename = PROJECT_ROOT_FOLDER / "tmp" / "japan_out_main.png"
+    geo_img, projection_matrix = download_extent(DEFAULT_TMS, pt0[0], pt0[1], pt1[0], pt1[1], 6)
 
-    print(f"Saving image to {img_output_filename}.")
-    save_image_auto(img, img_output_filename, matrix)
+    print(f"Saving image to {geo_img_output_filename}.")
+    save_image_auto(geo_img, geo_img_output_filename, projection_matrix)

src/prediction_api/predictors.py

@@ -62,7 +62,7 @@ def samexporter_predict(bbox: input_float_tuples, prompt: list[dict], zoom: floa
         models_instance = models_dict[model_name]["instance"]
 
         for coord in bbox:
-            app_logger.info(f"bbox coord:{coord}, type:{type(coord)}.")
+            app_logger.debug(f"bbox coord:{coord}, type:{type(coord)}.")
         app_logger.info(f"start download_extent using bbox:{bbox}, type:{type(bbox)}, download image...")
 
         pt0 = bbox[0]
@@ -70,30 +70,28 @@ def samexporter_predict(bbox: input_float_tuples, prompt: list[dict], zoom: floa
         img, matrix = download_extent(DEFAULT_TMS, pt0[0], pt0[1], pt1[0], pt1[1], zoom)
 
         app_logger.info(f"img type {type(img)}, matrix type {type(matrix)}.")
-        app_logger.info(f"matrix values: {serialize(matrix)}.")
+        app_logger.debug(f"matrix values: {serialize(matrix)}.")
         np_img = np.array(img)
-        app_logger.info(f"np_img type {type(np_img)}.")
-        app_logger.info(f"np_img dtype {np_img.dtype}, shape {np_img.shape}.")
+        app_logger.debug(f"np_img type {type(np_img)}.")
+        app_logger.debug(f"np_img dtype {np_img.dtype}, shape {np_img.shape}.")
         app_logger.info(f"geotiff created with size/shape {img.size} and transform matrix {str(matrix)}, start to initialize SamGeo instance:")
-        app_logger.info(f"use fastsam_model, ENCODER model {MODEL_ENCODER_NAME} and {MODEL_DECODER_NAME} from {MODEL_FOLDER})...")
-
-        app_logger.info(f"model instantiated, creating embedding...")
+        app_logger.info(f"use {model_name} model, ENCODER model {MODEL_ENCODER_NAME} and {MODEL_DECODER_NAME} from {MODEL_FOLDER}): model instantiated, creating embedding...")
         embedding = models_instance.encode(np_img)
         app_logger.info(f"embedding created, running predict_masks...")
         prediction_masks = models_instance.predict_masks(embedding, prompt)
-        app_logger.info(f"predict_masks terminated")
-        app_logger.info(f"prediction masks shape:{prediction_masks.shape}, {prediction_masks.dtype}.")
+        app_logger.debug(f"predict_masks terminated...")
+        app_logger.info(f"predict_masks terminated, prediction masks shape:{prediction_masks.shape}, {prediction_masks.dtype}.")
 
         mask = np.zeros((prediction_masks.shape[2], prediction_masks.shape[3]), dtype=np.uint8)
         for m in prediction_masks[0, :, :, :]:
             mask[m > 0.0] = 255
 
         mask_unique_values, mask_unique_values_count = serialize(np.unique(mask, return_counts=True))
-        app_logger.info(f"mask_unique_values:{mask_unique_values}.")
-        app_logger.info(f"mask_unique_values_count:{mask_unique_values_count}.")
+        app_logger.debug(f"mask_unique_values:{mask_unique_values}.")
+        app_logger.debug(f"mask_unique_values_count:{mask_unique_values_count}.")
 
         transform = load_affine_transformation_from_matrix(matrix)
-        app_logger.info(f"image/geojson origin matrix:{matrix}, transform:{transform}.")
+        app_logger.info(f"image/geojson origin matrix:{matrix}, transform:{transform}: create shapes_generator...")
         shapes_generator = ({
             'properties': {'raster_val': v}, 'geometry': s}
             for i, (s, v)

src/utilities/constants.py

@@ -26,7 +26,10 @@ MODEL_ENCODER_NAME = "mobile_sam.encoder.onnx"
 MODEL_DECODER_NAME = "sam_vit_h_4b8939.decoder.onnx"
 ZOOM = 13
 SOURCE_TYPE = "Satellite"
-
+TILE_SIZE = 256
 EARTH_EQUATORIAL_RADIUS = 6378137.0
 DEFAULT_TMS = 'https://tile.openstreetmap.org/{z}/{x}/{y}.png'
-WKT_3857 = 'PROJCS["WGS 84 / Pseudo-Mercator",GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563,AUTHORITY["EPSG","7030"]],AUTHORITY["EPSG","6326"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.0174532925199433,AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4326"]],PROJECTION["Mercator_1SP"],PARAMETER["central_meridian",0],PARAMETER["scale_factor",1],PARAMETER["false_easting",0],PARAMETER["false_northing",0],UNIT["metre",1,AUTHORITY["EPSG","9001"]],AXIS["X",EAST],AXIS["Y",NORTH],EXTENSION["PROJ4","+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs"],AUTHORITY["EPSG","3857"]]'
+WKT_3857 = 'PROJCS["WGS 84 / Pseudo-Mercator",GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563,AUTHORITY["EPSG","7030"]],AUTHORITY["EPSG","6326"]],PRIMEM["Greenwich",0,'
+WKT_3857 += 'AUTHORITY["EPSG","8901"]],UNIT["degree",0.0174532925199433,AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4326"]],PROJECTION["Mercator_1SP"],PARAMETER["central_meridian",0],'
+WKT_3857 += 'PARAMETER["scale_factor",1],PARAMETER["false_easting",0],PARAMETER["false_northing",0],UNIT["metre",1,AUTHORITY["EPSG","9001"]],AXIS["X",EAST],AXIS["Y",NORTH],EXTENSION["PROJ4",'
+WKT_3857 += '"+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs"],AUTHORITY["EPSG","3857"]]'