From 6c5758188852966b42ed0b954522b50ddd4b96c4 Mon Sep 17 00:00:00 2001 From: YongmingFrankGe Date: Sat, 1 Jan 2022 15:42:03 -0800 Subject: [PATCH 01/26] set up initial test framework for scenic store --- apperception/scenic_context.py | 115 ++++++++ apperception/scenic_util.py | 181 ++++++++++++ apperception/scenic_video_context_executor.py | 56 ++++ apperception/scenic_world.py | 168 +++++++++++ apperception/scenic_world_executer.py | 159 +++++++++++ apperception/video_util.py | 21 +- apperception/world.py | 2 +- apperception/world_executor.py | 4 - scenic_test.ipynb | 269 ++++++++++++++++++ 9 files changed, 969 insertions(+), 6 deletions(-) create mode 100644 apperception/scenic_context.py create mode 100644 apperception/scenic_util.py create mode 100644 apperception/scenic_video_context_executor.py create mode 100644 apperception/scenic_world.py create mode 100644 apperception/scenic_world_executer.py create mode 100644 scenic_test.ipynb diff --git a/apperception/scenic_context.py b/apperception/scenic_context.py new file mode 100644 index 00000000..5d109ade --- /dev/null +++ b/apperception/scenic_context.py @@ -0,0 +1,115 @@ +import ast +import inspect +import os +from typing import Callable +import uncompyle6 +import psycopg2 +from video_util import * +import datetime + + +# Camera node +class ScenicCamera: + def __init__(self, cam_id, video_file, metadata_id): + self.cam_id = cam_id + self.video_file = video_file + self.metadata_id = metadata_id + self.properties = {} + + # Contain objects that still have yet to be added to the backend + # If user calls recognize, those items will have already been + # stored in the backend. These are reserved for objects that users + # have not added to the camera. + self.items = [] + self.object_recognition = None + + + def add_item(self, item): + # Add item + self.items.append(item) + + def add_property(self, properties, property_type, new_prop): + # Add property + self.properties[property_type].append(new_prop) + + # Add a default add_recog_obj = True + def recognize(self, scenic_data_dir): + # Create object recognition node + object_rec_node = ScenicObjectRecognition(scenic_data_dir) + self.object_recognition = object_rec_node + return object_rec_node + +# Object Recognition node +class ScenicObjectRecognition: + def __init__(self, scenic_data_dir): + self.scenic_data_dir = scenic_data_dir + self.properties = {} + + def add_properties(self, properties): + self.properties = properties + +class ScenicVideoContext: + def __init__(self, name, units): + self.root = self + self.name = name + self.units = units + self.camera_nodes = {} + self.start_time = datetime.datetime(2021, 6, 8, 7, 10, 28) + + # Connect to the database + def connect_db(self, host='localhost', + user=None, + password=None, + port=5432, + database_name=None): + self.conn = psycopg2.connect(database=database_name, user=user, + password=password, host=host, port=port) + + def get_name(self): + return self.name + + def get_units(self): + return self.units + + # Establish camera + def scenic_camera(self, cam_id, video_file, metadata_id): + camera_node = self.__get_camera(cam_id) + if not camera_node: + camera_node = ScenicCamera(cam_id, video_file, metadata_id) + self.__add_camera(cam_id, camera_node) + return camera_node + + def properties(self, cam_id, properties, property_type): + camera_node = self.__get_camera(cam_id) + if not camera_node: + return None + + camera_node.add_properties(properties, property_type) + # Display error + + + + def get_camera(self, cam_id): + return self.__get_camera(cam_id) + + # Get camera + def __get_camera(self, cam_id): + if cam_id in self.camera_nodes.keys(): + return self.camera_nodes[cam_id] + return None + + # Add camera + def __add_camera(self, cam_id, camera_node): + self.camera_nodes[cam_id] = camera_node + + # Remove camera + def remove_camera(self, cam_id): + camera_node = self.__get_camera(cam_id) + self.camera_nodes.remove(camera_node) + + # Clear + def clear(self): + self.camera_nodes = [] + + + diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py new file mode 100644 index 00000000..979a3220 --- /dev/null +++ b/apperception/scenic_util.py @@ -0,0 +1,181 @@ +import ast +import psycopg2 +import numpy as np +import datetime +import cv2 +from object_tracker import yolov4_deepsort_video_track +from video_util import * + +# Create a camera table +def create_or_insert_scenic_camera_table(conn, world_name, camera): + #Creating a cursor object using the cursor() method + cursor = conn.cursor() + ''' + Create and Populate A camera table with the given camera object. + ''' + ### TODO: Modify the following codes to for scenic cameras + #Doping Cameras table if already exists. + cursor.execute("DROP TABLE IF EXISTS Cameras") + #Creating table with the first camera + sql = '''CREATE TABLE IF NOT EXISTS Scenic_Cameras( + cameraId TEXT, + worldId TEXT, + ratio real, + origin geometry, + focalpoints geometry, + fov INTEGER, + skev_factor real + );''' + cursor.execute(sql) + print("Camera Table created successfully........") + insert_scenic_camera(conn, world_name, camera) + return sql + +# Helper function to insert the camera +def insert_scenic_camera(conn, world_name, camera_node): + #Creating a cursor object using the cursor() method + cursor = conn.cursor() + lens = camera_node.lens + focal_x = str(lens.focal_x) + focal_y = str(lens.focal_y) + cam_x, cam_y, cam_z = str(lens.cam_origin[0]), str(lens.cam_origin[1]), str(lens.cam_origin[2]) + cursor.execute('''INSERT INTO Scenic_Cameras (cameraId, worldId, ratio, origin, focalpoints, fov, skev_factor) '''+ \ + '''VALUES (\'%s\', \'%s\', %f, \'POINT Z (%s %s %s)\', \'POINT(%s %s)\', %s, %f);''' \ + %(camera_node.cam_id, world_name, camera_node.ratio, cam_x, cam_y, cam_z, focal_x, focal_y, lens.fov, lens.alpha)) + print("New camera inserted successfully.........") + conn.commit() + +def scenic_recognize(video_file, scenic_data_dir): + ### TODO: Read all attributes from the + ### return formatted_result: {object: {bboxes: [[top_left:3d np.array, bottom_right:3d np.array]], + # attributes: {*attr_name: *attr_value}} + # } + return {} + +def add_scenic_recognized_objs(conn, formatted_result, start_time, default_depth=True): + clean_tables(conn) + ### TODO: Modify the following code to store the recognized formatted result into the database + ### TODO: Update the database schema to include all new fields + for item_id in formatted_result: + object_type = formatted_result[item_id]["object_type"] + recognized_bboxes = np.array(formatted_result[item_id]["bboxes"]) + tracked_cnt = formatted_result[item_id]["tracked_cnt"] + top_left = np.vstack((recognized_bboxes[:,0,0], recognized_bboxes[:,0,1])) + if default_depth: + top_left_depths = np.ones(len(recognized_bboxes)) + else: + top_left_depths = self.__get_depths_of_points(recognized_bboxes[:,0,0], recognized_bboxes[:,0,1]) + + # Convert bottom right coordinates to world coordinates + bottom_right = np.vstack((recognized_bboxes[:,1,0], recognized_bboxes[:,1,1])) + if default_depth: + bottom_right_depths = np.ones(len(tracked_cnt)) + else: + bottom_right_depths = self.__get_depths_of_points(recognized_bboxes[:,1,0], recognized_bboxes[:,1,1]) + + top_left = np.array(top_left.T) + bottom_right = np.array(bottom_right.T) + obj_traj = [] + for i in range(len(top_left)): + current_tl = top_left[i] + current_br = bottom_right[i] + obj_traj.append([current_tl.tolist(), current_br.tolist()]) + + scenic_bboxes_to_postgres(conn, item_id, object_type, "default_color" if item_id not in properties['color'] else properties['color'][item_id], start_time, tracked_cnt, obj_traj, type="yolov4") + # bbox_to_tasm() + +# Insert bboxes to postgres +def scenic_bboxes_to_postgres(conn, item_id, object_type, color, start_time, timestamps, bboxes, type='yolov3'): + ### TODO: Modify the following codes to add recognized scenic objects to the database + if type == 'yolov3': + timestamps = range(timestamps) + + converted_bboxes = [bbox_to_data3d(bbox) for bbox in bboxes] + pairs = [] + deltas = [] + for meta_box in converted_bboxes: + pairs.append(meta_box[0]) + deltas.append(meta_box[1:]) + postgres_timestamps = convert_timestamps(start_time, timestamps) + create_or_insert_scenic_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs) + print(f"{item_id} saved successfully") + + +# Create general trajectory table +def create_or_insert_scenic_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs): + cursor = conn.cursor() + ''' + Create and Populate A Trajectory table using mobilityDB. + Now the timestamp matches, the starting time should be the meta data of the world + Then the timestamp should be the timestamp regarding the world starting time + ''' + + ### TODO: Modify the table fields to match scenic schema + create_itemtraj_sql ='''CREATE TABLE IF NOT EXISTS Scenic_Item_General_Trajectory( + itemId TEXT, + objectType TEXT, + color TEXT, + trajCentroids tgeompoint, + largestBbox stbox, + PRIMARY KEY (itemId) + );''' + cursor.execute(create_itemtraj_sql) + cursor.execute("CREATE INDEX IF NOT EXISTS traj_idx ON Scenic_Item_General_Trajectory USING GiST(trajCentroids);") + conn.commit() + #Creating table with the first item + create_bboxes_sql ='''CREATE TABLE IF NOT EXISTS Scenic_General_Bbox( + itemId TEXT, + trajBbox stbox, + FOREIGN KEY(itemId) + REFERENCES Scenic_Item_General_Trajectory(itemId) + );''' + cursor.execute(create_bboxes_sql) + cursor.execute("CREATE INDEX IF NOT EXISTS item_idx ON Scenic_General_Bbox(itemId);") + cursor.execute("CREATE INDEX IF NOT EXISTS traj_bbox_idx ON Scenic_General_Bbox USING GiST(trajBbox);") + conn.commit() + #Insert the trajectory of the first item + insert_scenic_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs) + + +# Insert general trajectory +def insert_scenic_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs): + ### TODO: Modify the insert based on the new table schema + #Creating a cursor object using the cursor() method + cursor = conn.cursor() + #Inserting bboxes into Bbox table + insert_bbox_trajectory = "" + insert_format = "INSERT INTO Scenic_General_Bbox (itemId, trajBbox) "+ \ + "VALUES (\'%s\'," % (item_id) + # Insert the item_trajectory separately + insert_trajectory = "INSERT INTO Scenic_Item_General_Trajectory (itemId, objectType, color, trajCentroids, largestBbox) "+ \ + "VALUES (\'%s\', \'%s\', \'%s\', " % (item_id, object_type, color) + traj_centroids = "\'{" + min_ltx, min_lty, min_ltz, max_brx, max_bry, max_brz = float('inf'), float('inf'), float('inf'), float('-inf'), float('-inf'), float('-inf') + # max_ltx, max_lty, max_ltz, min_brx, min_bry, min_brz = float('-inf'), float('-inf'), float('-inf'), float('inf'), float('inf'), float('inf') + for i in range(len(postgres_timestamps)): + postgres_timestamp = postgres_timestamps[i] + ### Insert bbox + # print(bboxes[i]) + tl, br = bboxes[i] + min_ltx, min_lty, min_ltz, max_brx, max_bry, max_brz = min(tl[0], min_ltx), min(tl[1], min_lty), min(tl[2], min_ltz),\ + max(br[0], max_brx), max(br[1], max_bry), max(br[2], max_brz) + # max_ltx, max_lty, max_ltz, min_brx, min_bry, min_brz = max(tl[0], max_ltx), max(tl[1], max_lty), max(tl[2], max_ltz),\ + # min(br[0], min_brx), min(br[1], min_bry), min(br[2], min_brz) + current_bbox_sql = "stbox \'STBOX ZT((%s, %s, %s, %s), (%s, %s, %s, %s))\');" \ + %(tl[0], tl[1], tl[2], postgres_timestamp, br[0], br[1], br[2], postgres_timestamp) + insert_bbox_trajectory += insert_format + current_bbox_sql + ### Construct trajectory + current_point = pairs[i] + tg_pair_centroid = "POINT Z (%s %s %s)@%s," \ + %(str(current_point[0]), str(current_point[1]), str(current_point[2]), postgres_timestamp) + traj_centroids += tg_pair_centroid + traj_centroids = traj_centroids[:-1] + traj_centroids += "}\', " + insert_trajectory += traj_centroids + insert_trajectory += "stbox \'STBOX Z((%s, %s, %s),"%(min_ltx, min_lty, min_ltz)\ + +"(%s, %s, %s))\'); "%(max_brx, max_bry, max_brz) + cursor.execute(insert_trajectory) + cursor.execute(insert_bbox_trajectory) + # Commit your changes in the database + conn.commit() + \ No newline at end of file diff --git a/apperception/scenic_video_context_executor.py b/apperception/scenic_video_context_executor.py new file mode 100644 index 00000000..1065146a --- /dev/null +++ b/apperception/scenic_video_context_executor.py @@ -0,0 +1,56 @@ +from scenic_context import * +from scenic_util import * + +import json + +class ScenicVideoContextExecutor: + def __init__(self, conn, new_video_context:ScenicVideoContext=None, tasm=None): + if new_video_context: + self.context(new_video_context) + self.conn = conn + self.tasm = tasm + + def context(self, video_context:ScenicVideoContext): + self.current_context = video_context + return self + + def visit(self): + video_query = self.visit_world() + return video_query + + def visit_world(self): + # Query to store world in database + name, units = self.current_context.name, self.current_context.units + world_sql = create_or_insert_world_table(self.conn, name, units) + + all_sqls = [] + cameras = self.current_context.camera_nodes + if len(cameras) != 0: + for c in cameras.values(): + camera_sql = self.visit_camera(c) + all_sqls.append(camera_sql) + return all_sqls + + def visit_camera(self, camera_node): + world_name = self.current_context.name + camera_sql = create_or_insert_scenic_camera_table(self.conn, world_name, camera_node) + if camera_node.object_recognition is not None: + self.visit_obj_rec(camera_node, camera_node.object_recognition) + if self.tasm: + video_data_to_tasm(camera_node.video_file, camera_node.metadata_id, self.tasm) + return camera_sql + + def visit_obj_rec(self, camera_node, object_rec_node): + cam_id = camera_node.cam_id + video_file = camera_node.video_file + + start_time = self.current_context.start_time + + tracking_results = scenic_recognize(video_file, object_rec_node.scenic_data_dir) + add_scenic_recognized_objs(self.conn, tracking_results, start_time) + if self.tasm: + metadata_to_tasm(tracking_results, camera_node.metadata_id, self.tasm) + + def execute(self): + query = self.visit() + diff --git a/apperception/scenic_world.py b/apperception/scenic_world.py new file mode 100644 index 00000000..1a88d7ff --- /dev/null +++ b/apperception/scenic_world.py @@ -0,0 +1,168 @@ +from typing import Callable +import psycopg2 +from metadata_context import * +from scenic_context import * +import copy +from world_executor import WorldExecutor +import matplotlib.pyplot as plt + +BASE_VOLUME_QUERY_TEXT = "stbox \'STBOX Z(({x1}, {y1}, {z1}),({x2}, {y2}, {z2}))\'" +world_executor = WorldExecutor() +class ScenicWorld: + + def __init__(self, name, units, enable_tasm=False): + self.ScenicVideoContext = ScenicVideoContext(name, units) + self.MetadataContext = MetadataContext(single_mode=False) + self.MetadataContext.start_time = self.ScenicVideoContext.start_time + self.GetVideo = False + self.enable_tasm = enable_tasm + # self.AccessedVideoContext = False + + def get_camera(self, cam_id=[]): + # Change depending if you're on docker or not + if self.enable_tasm: + world_executor.connect_db(port=5432, user="docker", password="docker", database_name="mobilitydb") + else: + world_executor.connect_db(user="docker", password="docker", database_name="mobilitydb") + return world_executor.get_camera(cam_id) + +######################### +### Video Context #### +######################### + def get_lens(self, cam_id=""): + return self.get_camera(cam_id).lens + + def get_name(self): + return self.VideoContext.get_name() + + def get_units(self): + return self.VideoContext.get_units() + + def item(self, item_id, cam_id, item_type, location): + new_context = copy.deepcopy(self) + new_context.VideoContext.item(item_id, cam_id, item_type, location) + return new_context + + def scenic_camera(self, cam_id, video_file, metadata_identifier): + new_context = copy.deepcopy(self) + new_context.ScenicVideoContext.scenic_camera(cam_id, video_file, metadata_identifier) + return new_context + + def add_properties(self, cam_id, properties, property_type): + new_context = copy.deepcopy(self) + new_context.VideoContext.properties(cam_id, properties, property_type) + return new_context + + def recognize(self, cam_id, scenic_data_dir): + new_context = copy.deepcopy(self) + new_context.ScenicVideoContext.camera_nodes[cam_id].recognize(scenic_data_dir) + return new_context + +######################### +### Metadata Context #### +######################### + + def get_columns(self, *argv, distinct = False): + new_context = copy.deepcopy(self) + new_context.MetadataContext.get_columns(argv, distinct) + return new_context + + def predicate(self, p, evaluated_var = {}): + new_context = copy.deepcopy(self) + new_context.MetadataContext.predicate(p, evaluated_var) + return new_context + + def selectkey(self, distinct = False): + new_context = copy.deepcopy(self) + new_context.MetadataContext.selectkey(distinct) + return new_context + + def get_trajectory(self, interval = [], distinct = False): + new_context = copy.deepcopy(self) + new_context.MetadataContext.get_trajectory(interval, distinct) + return new_context + + def get_geo(self, interval = [], distinct = False): + new_context = copy.deepcopy(self) + new_context.MetadataContext.get_geo(interval, distinct) + return new_context + + def get_time(self, distinct = False): + new_context = copy.deepcopy(self) + new_context.MetadataContext.get_time(distinct) + return new_context + + def get_distance(self, interval = [], distinct = False): + new_context = copy.deepcopy(self) + new_context.MetadataContext.distance(interval, distinct) + return new_context + + def get_speed(self, interval = [], distinct = False): + new_context = copy.deepcopy(self) + new_context.MetadataContext.get_speed(interval, distinct) + return new_context + + def get_video(self, cam_id=[]): + # Go through all the cameras in 'filtered' world and obtain videos + new_context = copy.deepcopy(self) + new_context.GetVideo = True + ## get camera gives the direct results from the data base + new_context.get_video_cams = self.get_camera(cam_id) + return new_context + + def interval(self, time_interval): + new_context = copy.deepcopy(self) + new_context.MetadataContext.interval(time_interval) + return new_context + + def execute(self): + world_executor.create_world(self) + if self.enable_tasm: + world_executor.enable_tasm() + print("successfully enable tasm during execution time") + # Change depending if you're on docker or not + world_executor.connect_db(port=5432, user="docker", password="docker", database_name="mobilitydb") + else: + world_executor.connect_db(user="docker", password="docker", database_name="mobilitydb") + return world_executor.execute() + + def select_intersection_of_interest_or_use_default(self, cam_id, default=True): + print(self.VideoContext.camera_nodes) + camera = self.VideoContext.camera_nodes[cam_id] + video_file = camera.video_file + if default: + x1, y1, z1 = 0.01082532, 2.59647246, 0 + x2, y2, z2 = 3.01034039, 3.35985782, 2 + else: + vs = cv2.VideoCapture(video_file) + frame = vs.read() + frame = frame[1] + cv2.namedWindow("Frame", cv2.WINDOW_NORMAL) + cv2.resizeWindow('Frame', 384, 216) + initBB = cv2.selectROI("Frame", frame, fromCenter=False) + print(initBB) + cv2.destroyAllWindows() + print("world coordinate #1") + tl = camera.lens.pixel_to_world(initBB[:2], 1) + print(tl) + x1, y1, z1 = tl + print("world coordinate #2") + br = camera.lens.pixel_to_world((initBB[0]+initBB[2], initBB[1]+initBB[3]), 1) + print(br) + x2, y2, z2 = br + return BASE_VOLUME_QUERY_TEXT.format(x1=x1, y1=y1, z1=0, x2=x2, y2=y2, z2=2) + + def overlay_trajectory(self, cam_id, trajectory): + camera = self.VideoContext.get_camera(cam_id) + video_file = camera.video_file + for traj in trajectory: + current_trajectory = np.asarray(traj[0]) + frame_points = camera.lens.world_to_pixels(current_trajectory.T).T + vs = cv2.VideoCapture(video_file) + frame = vs.read() + frame = cv2.cvtColor(frame[1], cv2.COLOR_BGR2RGB) + for point in frame_points.tolist(): + cv2.circle(frame,tuple([int(point[0]), int(point[1])]),3,(255,0,0)) + plt.figure() + plt.imshow(frame) + plt.show() diff --git a/apperception/scenic_world_executer.py b/apperception/scenic_world_executer.py new file mode 100644 index 00000000..0a012123 --- /dev/null +++ b/apperception/scenic_world_executer.py @@ -0,0 +1,159 @@ +from metadata_context_executor import * +from metadata_context import * +from scenic_video_context_executor import * +from video_util import * +import numpy as np + +class ScenicWorldExecutor: + def __init__(self, world=None): + if world: + self.create_world(world) + self.tasm = None + + def connect_db(self, + host='localhost', + user=None, + password=None, + port=25432, + database_name=None): + + self.conn = psycopg2.connect(database=database_name, user=user, password=password, host=host, port=port) + + def create_world(self, world): + self.curr_world = world + return self + + def enable_tasm(self): + import tasm + if not self.tasm: + self.tasm = tasm.TASM() + + def get_camera(self, cam_id = []): + assert self.curr_world, self.conn + cameras = fetch_camera(self.conn, self.curr_world.get_name(), cam_id) + ### each camera appear like: + ### (cameraId, ratio, origin3d, focalpoints2d, fov, skev_factor) + + return cameras + + def tasm_get_video(self, metadata_results): + ### Get the metadata context executing query text, let tasm get video call it + ### the tasm would execute the query to get the ids, bboxes and timestamps + ### then it can use these to tile the video and get it + cam_nodes = self.curr_world.get_video_cams + tasm = self.curr_world.fetch_tasm() + for cam_node in cam_nodes: + current_metadata_identifier = cam_node.metadata_id + current_video_file = cam_nodes.video_file + tasm.activate_regret_based_tiling(current_video_file, current_metadata_identifier) + for label, timestamps in metadata_results.items(): + tasm.get_video_roi( + f'./output/{label}.mp4', # output path + current_video_file, # name in TASM + current_metadata_identifier, # metadata identifier in TASM + label, # label name + timestamps[0], # first frame inclusive + timestamps[-1] # last frame exclusive + ) + tasm.retile_based_on_regret(current_video_file, current_metadata_identifier) + + + def get_video(self, metadata_results): + start_time = self.curr_world.VideoContext.start_time + # print("Start time is", start_time) + ### The cam nodes are raw data from the database + ### TODO: I forget why we used the data from the db instead of directly fetch + ### from the world + cam_nodes = self.curr_world.get_video_cams + video_files = [] + for i in range(len(cam_nodes)): + cam_id, ratio, cam_x, cam_y, cam_z, focal_x, focal_y, fov, skew_factor = cam_nodes[i] + cam_video_file = self.curr_world.VideoContext.camera_nodes[cam_id].video_file + + transform_matrix = create_transform_matrix(focal_x, focal_y, cam_x, cam_y, skew_factor) + + for item_id, vals in metadata_results.items(): + world_coords, timestamps = vals + # print("timestamps are", timestamps) + world_coords = reformat_fetched_world_coords(world_coords) + + cam_coords = world_to_pixel(world_coords, transform_matrix) + + vid_times = convert_datetime_to_frame_num(start_time, timestamps) + # print(vid_times) + + vid_fname = './output/'+self.curr_world.VideoContext.camera_nodes[cam_id].metadata_id + item_id + '.mp4' + # print(vid_fname) + get_video_roi(vid_fname, cam_video_file, cam_coords, vid_times) + video_files.append(vid_fname) + print("output video files", ','.join(video_files)) + return video_files + + def execute(self): + # Edit logic for execution here through checks of whether VideoContext or MetadataContext is being used + video_executor = ScenicVideoContextExecutor(self.conn, self.curr_world.VideoContext, self.tasm) + video_executor.execute() + + if self.curr_world.MetadataContext.scan.view == None: + return + + if self.curr_world.GetVideo: + if self.tasm: + metadata_executor = MetadataContextExecutor(self.conn, self.curr_world.MetadataContext.get_columns(primarykey, time)) + metadata_results = video_fetch_reformat_tasm(metadata_executor.execute()) + return self.tasm_get_video(metadata_results) + else: + metadata_executor = MetadataContextExecutor(self.conn, self.curr_world.MetadataContext.get_columns(primarykey, geometry, time)) + metadata_results = video_fetch_reformat(metadata_executor.execute()) + return self.get_video(metadata_results) + + metadata_executor = MetadataContextExecutor(self.conn, self.curr_world.MetadataContext) + return metadata_executor.execute() + +def create_transform_matrix(focal_x, focal_y, cam_x, cam_y, skew_factor): + alpha = skew_factor + + transform = np.array([[focal_x, alpha, cam_x, 0], + [0, focal_y, cam_y, 0], + [0, 0, 1, 0] + ]) + + return transform + +def reformat_fetched_world_coords(world_coords): + return np.array(world_coords) + +def world_to_pixel(world_coords, transform): + tl_x, tl_y, tl_z, br_x, br_y, br_z = world_coords.T + + tl_world_pixels = np.array([tl_x, tl_y, tl_z, np.ones(len(tl_x))]) + tl_vid_coords = transform @ tl_world_pixels + + br_world_pixels = np.array([br_x, br_y, br_z, np.ones(len(br_x))]) + br_vid_coords = transform @ br_world_pixels + + return np.stack((tl_vid_coords[0], tl_vid_coords[1], br_vid_coords[0], br_vid_coords[1]), axis=0) + +def video_fetch_reformat_tasm(fetched_meta): + result = {} + for meta in fetched_meta: + item_id, timestamp = meta[0], meta[1] + if item_id in result: + result[item_id]['tracked_cnt'].append(timestamp) + else: + result[item_id] = {'tracked_cnt':[timestamp]} + + return result + + +def video_fetch_reformat(fetched_meta): + result = {} + for meta in fetched_meta: + item_id, coordinates, timestamp = meta[0], meta[1:-1], meta[-1] + if item_id in result: + result[item_id][0].append(coordinates) + result[item_id][1].append(timestamp) + else: + result[item_id] = [[coordinates],[timestamp]] + + return result \ No newline at end of file diff --git a/apperception/video_util.py b/apperception/video_util.py index beac6e1d..f573c799 100644 --- a/apperception/video_util.py +++ b/apperception/video_util.py @@ -127,6 +127,8 @@ def create_or_insert_world_table(conn, name, units: Units): """ Create and Populate A world table with the given world object. """ + # Doping Worlds table if already exists. + cursor.execute("DROP TABLE IF EXISTS Worlds;") # Creating table with the first world sql = """CREATE TABLE IF NOT EXISTS Worlds( worldId TEXT PRIMARY KEY, @@ -157,6 +159,8 @@ def create_or_insert_camera_table(conn, world_name, camera): """ Create and Populate A camera table with the given camera object. """ + # Doping Cameras table if already exists. + cursor.execute("DROP TABLE IF EXISTS Cameras") # Creating table with the first camera sql = "\n".join( [ @@ -292,7 +296,6 @@ def add_recognized_objs( ) # bbox_to_tasm() - def convert_timestamps(start_time, timestamps): """Helper function to convert the timestam to the timestamp formula pg-trajectory uses""" return [str(start_time + datetime.timedelta(seconds=t)) for t in timestamps] @@ -331,6 +334,22 @@ def bbox_to_postgres( print(f"{item_id} saved successfully") +# Insert bboxes to postgres +def scenic_bboxes_to_postgres(conn, item_id, object_type, color, start_time, timestamps, bboxes, type='yolov3'): + ### TODO: Modify the following codes to add recognized scenic objects to the database + if type == 'yolov3': + timestamps = range(timestamps) + + converted_bboxes = [bbox_to_data3d(bbox) for bbox in bboxes] + pairs = [] + deltas = [] + for meta_box in converted_bboxes: + pairs.append(meta_box[0]) + deltas.append(meta_box[1:]) + postgres_timestamps = convert_timestamps(start_time, timestamps) + create_or_insert_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs) + print(f"{item_id} saved successfully") + def clean_tables(conn): cursor = conn.cursor() cursor.execute("DROP TABLE IF EXISTS General_Bbox;") diff --git a/apperception/world.py b/apperception/world.py index 4e818657..a2cb23a9 100644 --- a/apperception/world.py +++ b/apperception/world.py @@ -52,7 +52,7 @@ def item(self, item_id, cam_id, item_type, location): new_context = copy.deepcopy(self) new_context.VideoContext.item(item_id, cam_id, item_type, location) return new_context - + def camera(self, cam_id, location, ratio, video_file, metadata_identifier, lens): new_context = copy.deepcopy(self) new_context.VideoContext.camera( diff --git a/apperception/world_executor.py b/apperception/world_executor.py index 152159c4..27eedeca 100644 --- a/apperception/world_executor.py +++ b/apperception/world_executor.py @@ -62,10 +62,6 @@ def tasm_get_video(self, metadata_results): def get_video(self, metadata_results): start_time = self.curr_world.VideoContext.start_time - # print("Start time is", start_time) - # The cam nodes are raw data from the database - # TODO: I forget why we used the data from the db instead of directly fetch - # from the world cam_nodes = self.curr_world.get_video_cams video_files = [] for i in range(len(cam_nodes)): diff --git a/scenic_test.ipynb b/scenic_test.ipynb new file mode 100644 index 00000000..ba4b088c --- /dev/null +++ b/scenic_test.ipynb @@ -0,0 +1,269 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "source": [ + "import os\n", + "import sys\n", + "sys.path.append(os.path.join(os.getcwd(),\"apperception\"))\n", + "\n", + "### IMPORTS\n", + "import cv2\n", + "\n", + "from scenic_world import *\n", + "from world_executor import *\n", + "from video_util import *\n", + "from metadata_util import *\n", + "import lens\n", + "import point\n", + "\n" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "In /home/yongming/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", + "The text.latex.preview rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", + "In /home/yongming/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", + "The mathtext.fallback_to_cm rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", + "In /home/yongming/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: Support for setting the 'mathtext.fallback_to_cm' rcParam is deprecated since 3.3 and will be removed two minor releases later; use 'mathtext.fallback : 'cm' instead.\n", + "In /home/yongming/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", + "The validate_bool_maybe_none function was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", + "In /home/yongming/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", + "The savefig.jpeg_quality rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", + "In /home/yongming/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", + "The keymap.all_axes rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", + "In /home/yongming/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", + "The animation.avconv_path rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", + "In /home/yongming/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", + "The animation.avconv_args rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 2, + "source": [ + "### Let's define some attribute for constructing the world first\n", + "name = 'ScenicWorld' # world name\n", + "units = 'metrics' # world units\n", + "cam_id = 'CAM_FRONT'\n", + "video_file = os.path.join(\"sample\",cam_id,\"n003-2018-01-03-12-03-23+0800__CAM_BACK__1514952316316487.jpg\") #example video file, using image file for now\n", + "user_data_dir = os.path.join(\"v1.0-mini\")\n", + "lens_attrs = {'fov': 120, \n", + " 'cam_origin': (0, 0, 0), \n", + " 'skew_factor': 0}\n", + "point_attrs = {'p_id': 'p1', \n", + " 'cam_id': 'cam1', \n", + " 'x': 0,\n", + " 'y': 0, \n", + " 'z': 0,\n", + " 'time': None, \n", + " 'type':'pos'}\n", + "camera_attrs = {'ratio': 0.5}\n", + "fps = 30\n" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 3, + "source": [ + "scenic_world = ScenicWorld(name=name, units=units)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 4, + "source": [ + "### Ingest the camera to the world\n", + "scenic_world = scenic_world.scenic_camera(cam_id=cam_id, \n", + " video_file=video_file, \n", + " metadata_identifier=name+\"_\"+cam_id)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 5, + "source": [ + "### Call execute on the world to run the detection algorithm and save the real data to the database\n", + "recognized_scenic_world = scenic_world.recognize(cam_id, scenic_data_dir=user_data_dir)\n", + "recognized_scenic_world.execute()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 7, + "source": [ + "### Example Test Query\n", + "filtered_world = scenic_world.predicate(lambda obj:obj.object_type == \"car\")\n", + "filtered_world.get_trajectory().execute()" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "{'cam1': }\n", + "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='object_type', ctx=Load()), ops=[Eq()], comparators=[Str(s='car')]))])\n", + "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load()), ops=[In()], comparators=[Name(id='volume', ctx=Load())]))])\n", + "Module(body=[Return(value=Compare(left=Call(func=Name(id='Tmin', ctx=Load()), args=[Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load())], keywords=[]), ops=[GtE()], comparators=[Name(id='start', ctx=Load())]))])\n", + "Module(body=[Return(value=Compare(left=Call(func=Name(id='Tmax', ctx=Load()), args=[Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load())], keywords=[]), ops=[Lt()], comparators=[Name(id='end', ctx=Load())]))])\n", + "Worlds Table created successfully........\n", + "New world inserted successfully........\n", + "Camera Table created successfully........\n", + "New camera inserted successfully.........\n", + "SELECT distinct on(itemId) Item_General_Trajectory.itemId From Item_General_Trajectory INNER JOIN General_Bbox USING(itemId) Where Item_General_Trajectory.objectType='car' AND overlap(General_Bbox.trajBbox, stbox 'STBOX Z((0.01082532, 2.59647246, 0),(3.01034039, 3.35985782, 2))')=true AND Tmin(General_Bbox.trajBbox)>='2021-06-08 07:10:28' AND Tmax(General_Bbox.trajBbox)<'2021-06-08 07:12:28';\n", + "\n", + "filtered_ids are [['car-1']\n", + " ['car-12']\n", + " ['car-15']\n", + " ['car-17']\n", + " ['car-2']]\n", + "5\n", + "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='object_id', ctx=Load()), ops=[In()], comparators=[Name(id='id_array', ctx=Load())]))])\n", + "Worlds Table created successfully........\n", + "New world inserted successfully........\n", + "Camera Table created successfully........\n", + "New camera inserted successfully.........\n", + "atPeriodSet(Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}')\n", + "asMFJSON(atPeriodSet(Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}'))::json->'coordinates'\n", + "SELECT distinct on(itemId) asMFJSON(atPeriodSet(Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}'))::json->'coordinates' From Item_General_Trajectory Where Item_General_Trajectory.itemId IN ('car-1','car-12','car-15','car-17','car-2');\n", + "\n" + ] + }, + { + "output_type": "display_data", + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='object_id', ctx=Load()), ops=[In()], comparators=[Name(id='id_array', ctx=Load())]))])\n", + "Worlds Table created successfully........\n", + "New world inserted successfully........\n", + "Camera Table created successfully........\n", + "New camera inserted successfully.........\n", + "Module(body=[Return(value=Compare(left=Call(func=Name(id='Tmin', ctx=Load()), args=[Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load())], keywords=[]), ops=[GtE()], comparators=[Name(id='start', ctx=Load())]))])\n", + "Module(body=[Return(value=Compare(left=Call(func=Name(id='Tmax', ctx=Load()), args=[Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load())], keywords=[]), ops=[Lt()], comparators=[Name(id='end', ctx=Load())]))])\n", + "Xmin(General_Bbox.trajBbox)\n", + "Ymin(General_Bbox.trajBbox)\n", + "Zmin(General_Bbox.trajBbox)\n", + "Xmax(General_Bbox.trajBbox)\n", + "Ymax(General_Bbox.trajBbox)\n", + "Zmax(General_Bbox.trajBbox)\n", + "Tmin(General_Bbox.trajBbox)\n", + "SELECT Item_General_Trajectory.itemId, Xmin(General_Bbox.trajBbox), Ymin(General_Bbox.trajBbox), Zmin(General_Bbox.trajBbox), Xmax(General_Bbox.trajBbox), Ymax(General_Bbox.trajBbox), Zmax(General_Bbox.trajBbox), Tmin(General_Bbox.trajBbox) From Item_General_Trajectory INNER JOIN General_Bbox USING(itemId) Where Item_General_Trajectory.itemId IN ('car-1','car-12','car-15','car-17','car-2') AND Tmin(General_Bbox.trajBbox)>='0001-01-01 00:00:00' AND Tmax(General_Bbox.trajBbox)<'9999-12-31 23:59:59.999999';\n", + "\n", + "(121, 4)\n", + "(121, 4)\n", + "(13, 4)\n", + "(100, 4)\n", + "(66, 4)\n", + "output video files ./output/traffic_scene_cam1car-1.mp4,./output/traffic_scene_cam1car-2.mp4,./output/traffic_scene_cam1car-12.mp4,./output/traffic_scene_cam1car-15.mp4,./output/traffic_scene_cam1car-17.mp4\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [], + "outputs": [], + "metadata": {} + } + ], + "metadata": { + "celltoolbar": "Raw Cell Format", + "kernelspec": { + "name": "python3", + "display_name": "Python 3.6.9 64-bit" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.9" + }, + "interpreter": { + "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file From 38135495f9c53f2a50fea8cac28b947113399299 Mon Sep 17 00:00:00 2001 From: eeeeenchanted <597380714@qq.com> Date: Sun, 23 Jan 2022 21:43:45 -0800 Subject: [PATCH 02/26] Use mongoDB for quick query in nuScenes dataset --- apperception/scenic_util.py | 100 ++++++++++++++++++- apperception/scenic_world.py | 4 +- apperception/scenic_world_executer.py | 2 +- scenic_test.ipynb | 135 +++++++++++++------------- 4 files changed, 168 insertions(+), 73 deletions(-) diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py index 979a3220..017f697c 100644 --- a/apperception/scenic_util.py +++ b/apperception/scenic_util.py @@ -5,6 +5,10 @@ import cv2 from object_tracker import yolov4_deepsort_video_track from video_util import * +from pymongo import MongoClient +from pyquaternion import Quaternion +import json +import os # Create a camera table def create_or_insert_scenic_camera_table(conn, world_name, camera): @@ -28,7 +32,7 @@ def create_or_insert_scenic_camera_table(conn, world_name, camera): );''' cursor.execute(sql) print("Camera Table created successfully........") - insert_scenic_camera(conn, world_name, camera) + # insert_scenic_camera(conn, world_name, camera) return sql # Helper function to insert the camera @@ -45,11 +49,105 @@ def insert_scenic_camera(conn, world_name, camera_node): print("New camera inserted successfully.........") conn.commit() +# create collections in db and set index for quick query +def insert_scenic_data(scenic_data_dir, db): + with open(os.path.join(scenic_data_dir, 'v1.0-mini', 'sample_data.json')) as f: + sample_data_json = json.load(f) + db['sample_data'].insert_many(sample_data_json) + db['sample_data'].create_index('token') + db['sample_data'].create_index('filename') + + with open(os.path.join(scenic_data_dir, 'v1.0-mini', 'attribute.json')) as f: + attribute_json = json.load(f) + db['attribute'].insert_many(attribute_json) + db['attribute'].create_index('token') + + with open(os.path.join(scenic_data_dir, 'v1.0-mini', 'calibrated_sensor.json')) as f: + calibrated_sensor_json = json.load(f) + db['calibrated_sensor'].insert_many(calibrated_sensor_json) + db['calibrated_sensor'].create_index('token') + + with open(os.path.join(scenic_data_dir, 'v1.0-mini', 'category.json')) as f: + category_json = json.load(f) + db['category'].insert_many(category_json) + db['category'].create_index('token') + + with open(os.path.join(scenic_data_dir, 'v1.0-mini', 'ego_pose.json')) as f: + ego_pose_json = json.load(f) + db['ego_pose'].insert_many(ego_pose_json) + db['ego_pose'].create_index('token') + + with open(os.path.join(scenic_data_dir, 'v1.0-mini', 'instance.json')) as f: + instance_json = json.load(f) + db['instance'].insert_many(instance_json) + db['instance'].create_index('token') + + with open(os.path.join(scenic_data_dir, 'v1.0-mini', 'sample_annotation.json')) as f: + sample_annotation_json = json.load(f) + db['sample_annotation'].insert_many(sample_annotation_json) + db['sample_annotation'].create_index('token') + +def get_box(translation, size, orientation): + """ + return: . First four corners are the ones facing forward. + The last four are the ones facing backwards. + """ + center = np.array(translation) + wlh = np.array(size) + w, l, h = wlh + + # 3D bounding box corners. (Convention: x points forward, y to the left, z up.) + x_corners = l / 2 * np.array([1, 1, 1, 1, -1, -1, -1, -1]) + y_corners = w / 2 * np.array([1, -1, -1, 1, 1, -1, -1, 1]) + z_corners = h / 2 * np.array([1, 1, -1, -1, 1, 1, -1, -1]) + corners = np.vstack((x_corners, y_corners, z_corners)) + + # Rotate + corners = np.dot(orientation.rotation_matrix, corners) + + # Translate + x, y, z = center + corners[0, :] = corners[0, :] + x + corners[1, :] = corners[1, :] + y + corners[2, :] = corners[2, :] + z + + return [corners[:, 1], corners[:, 7]] + def scenic_recognize(video_file, scenic_data_dir): ### TODO: Read all attributes from the ### return formatted_result: {object: {bboxes: [[top_left:3d np.array, bottom_right:3d np.array]], # attributes: {*attr_name: *attr_value}} # } + + # connect mongoDB + client = MongoClient("mongodb+srv://apperception:apperception@cluster0.gvxkh.mongodb.net/cluster0?retryWrites=true&w=majority") + db = client['apperception'] + + if len(db.list_collection_names()) == 0: + insert_scenic_data(scenic_data_dir, db) + else: + print('already exists') + + formatted_result = {} + + # get bboxes and categories of all the objects appeared in the image file + file_data = db['sample_data'].find_one({'filename': video_file}) + sample_token = file_data['sample_token'] + all_annotations = db['sample_annotation'].find({'sample_token': sample_token}) + for annotation in all_annotations: + instance = db['instance'].find_one({'token': annotation['instance_token']}) + if not instance: + continue + item_id = instance['token'] + if item_id not in formatted_result: + formatted_result[item_id] = {'bboxes': [], 'attributes': {}} + category = db['category'].find_one({'token': instance['category_token']}) + formatted_result[item_id]['attributes']['cat_name'] = category['name'] + formatted_result[item_id]['attributes']['cat_desc'] = category['description'] + + bbox = get_box(annotation['translation'], annotation['size'], Quaternion(annotation['rotation'])) + formatted_result[item_id]['bboxes'].append(bbox) + return {} def add_scenic_recognized_objs(conn, formatted_result, start_time, default_depth=True): diff --git a/apperception/scenic_world.py b/apperception/scenic_world.py index 1a88d7ff..21ff4426 100644 --- a/apperception/scenic_world.py +++ b/apperception/scenic_world.py @@ -3,11 +3,11 @@ from metadata_context import * from scenic_context import * import copy -from world_executor import WorldExecutor +from scenic_world_executer import ScenicWorldExecutor import matplotlib.pyplot as plt BASE_VOLUME_QUERY_TEXT = "stbox \'STBOX Z(({x1}, {y1}, {z1}),({x2}, {y2}, {z2}))\'" -world_executor = WorldExecutor() +world_executor = ScenicWorldExecutor() class ScenicWorld: def __init__(self, name, units, enable_tasm=False): diff --git a/apperception/scenic_world_executer.py b/apperception/scenic_world_executer.py index 0a012123..b3596808 100644 --- a/apperception/scenic_world_executer.py +++ b/apperception/scenic_world_executer.py @@ -91,7 +91,7 @@ def get_video(self, metadata_results): def execute(self): # Edit logic for execution here through checks of whether VideoContext or MetadataContext is being used - video_executor = ScenicVideoContextExecutor(self.conn, self.curr_world.VideoContext, self.tasm) + video_executor = ScenicVideoContextExecutor(self.conn, self.curr_world.ScenicVideoContext, self.tasm) video_executor.execute() if self.curr_world.MetadataContext.scan.view == None: diff --git a/scenic_test.ipynb b/scenic_test.ipynb index ba4b088c..2942f947 100644 --- a/scenic_test.ipynb +++ b/scenic_test.ipynb @@ -3,6 +3,9 @@ { "cell_type": "code", "execution_count": 1, + "id": "ac69e379", + "metadata": {}, + "outputs": [], "source": [ "import os\n", "import sys\n", @@ -18,41 +21,20 @@ "import lens\n", "import point\n", "\n" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "In /home/yongming/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", - "The text.latex.preview rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", - "In /home/yongming/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", - "The mathtext.fallback_to_cm rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", - "In /home/yongming/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: Support for setting the 'mathtext.fallback_to_cm' rcParam is deprecated since 3.3 and will be removed two minor releases later; use 'mathtext.fallback : 'cm' instead.\n", - "In /home/yongming/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", - "The validate_bool_maybe_none function was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", - "In /home/yongming/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", - "The savefig.jpeg_quality rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", - "In /home/yongming/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", - "The keymap.all_axes rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", - "In /home/yongming/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", - "The animation.avconv_path rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", - "In /home/yongming/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", - "The animation.avconv_args rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n" - ] - } - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, + "id": "c3bd0bc2", + "metadata": {}, + "outputs": [], "source": [ "### Let's define some attribute for constructing the world first\n", "name = 'ScenicWorld' # world name\n", "units = 'metrics' # world units\n", "cam_id = 'CAM_FRONT'\n", - "video_file = os.path.join(\"sample\",cam_id,\"n003-2018-01-03-12-03-23+0800__CAM_BACK__1514952316316487.jpg\") #example video file, using image file for now\n", + "video_file = os.path.join(\"samples\",cam_id,\"n008-2018-08-01-15-16-36-0400__CAM_FRONT__1533151603512404.jpg\") #example video file, using image file for now\n", "user_data_dir = os.path.join(\"v1.0-mini\")\n", "lens_attrs = {'fov': 120, \n", " 'cam_origin': (0, 0, 0), \n", @@ -66,54 +48,63 @@ " 'type':'pos'}\n", "camera_attrs = {'ratio': 0.5}\n", "fps = 30\n" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 7, + "id": "8721832d", + "metadata": {}, + "outputs": [], "source": [ "scenic_world = ScenicWorld(name=name, units=units)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 8, + "id": "b09a2632", + "metadata": {}, + "outputs": [], "source": [ "### Ingest the camera to the world\n", "scenic_world = scenic_world.scenic_camera(cam_id=cam_id, \n", " video_file=video_file, \n", " metadata_identifier=name+\"_\"+cam_id)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 9, + "id": "38170a10", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Worlds Table created successfully........\n", + "New world inserted successfully........\n", + "Camera Table created successfully........\n", + "already exists\n" + ] + } + ], "source": [ "### Call execute on the world to run the detection algorithm and save the real data to the database\n", "recognized_scenic_world = scenic_world.recognize(cam_id, scenic_data_dir=user_data_dir)\n", "recognized_scenic_world.execute()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 7, - "source": [ - "### Example Test Query\n", - "filtered_world = scenic_world.predicate(lambda obj:obj.object_type == \"car\")\n", - "filtered_world.get_trajectory().execute()" - ], + "id": "9fe17cfc", + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "{'cam1': }\n", "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='object_type', ctx=Load()), ops=[Eq()], comparators=[Str(s='car')]))])\n", @@ -144,7 +135,6 @@ ] }, { - "output_type": "display_data", "data": { "image/png": "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", "text/plain": [ @@ -153,10 +143,10 @@ }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" }, { - "output_type": "display_data", "data": { "image/png": "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", "text/plain": [ @@ -165,10 +155,10 @@ }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" }, { - "output_type": "display_data", "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAADfCAYAAAAN+JPJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9WaxlS5rfh/1iWNMezpgnT453qLpVXVVd3dXVbJHNQTIt2YBI2Og3ajAEUSDQIEDCMNoPIvwiP9IvNgjIoNGGBZOAYUqQbUgwKNESwZnqptjV1dU13brzvTnnmfewphj8EGvts84+e++zT2be7mQjv4u8Z++114oVK1bEP77v/33xhfDe80beyBt5I2/kj5bIP+wKvJE38kbeyBt59fIG3N/IG3kjb+SPoLwB9zfyRt7IG/kjKG/A/Y28kTfyRv4IyhtwfyNv5I28kT+C8gbc38gbeSNv5I+gfCngLoT4t4UQ7wshPhRC/LUv4x5v5I28kTfyRpaLeNVx7kIIBfwM+J8DD4D/Efj3vPc/fqU3eiNv5I28kTeyVL4Mzf2PAx967z/23lfA3wF+7Uu4zxt5I2/kjbyRJaK/hDLvAl90vj8A/sSqC/r9vt/Z2Vn4mxDi1dVsRfmtBfNl3+9F5IXrtOZ1F8666hrvWWTriWvc76p6LC1/viovUPayMsSCYyvLa07yYnX5q2Sh1fyH1f/m6uKXHO/2xT+s1e3/Kq2qf9m6XnX9gwcPDrz3e4t++zLAfS0RQvw68OsA29vb/MZv/Eb3t4Wf565fes5VDSKEuPBvWbmr7n+d36W8bCA559Yq13s/K2Pduri575fOa9rHN7+3Za8z0XnvF9Z9nfotquuFMtry589du9SL13jOQUoteNcAtnlW1Xl2t2QC69ZlHtyXir943aKHudBfu/16rpjZRDT3nubLWfScQoil7buoDOcc3vsL9xCAnAP3tv3kgvu+KLB177vsWbvS9sfuOe24uVAuHjyItmXnmulF6tvep712voy2HZfdY9k958tdds1v/MZvfLasbl8GuD8E7ne+32uOXRDv/W8Cvwlw//59/yo15qvKWgS2i6572Tp1AXO+rLYOi4By/rr5DtItwwOuHQgr6t4dLK45V3gPQuCdgwVtMj9A5usgpbxyklomiwbfvKzS5NvfFwJgA87dNlz0zmd16A6+TtnrDvWrzruyLCEWPsf8NS/SHxf26StA7FVpxi+j5c8D27Jn997P+mH3mpVt5XklwH7lfbj8HKuuX/S8iya3dfvBlwHu/yPwNSHEuwRQ/3eBf/9LuM9Mrnqh8wN7mWaz6vdF8jLg3167CCCXTQTXEe/9QqpkpmHQ9G/v8Q3Az7fBoo7ZTjRtnaSUS7WWq9rnqg57FbgvLbctrwHNK0GmmfCW3X+hrPnqffNfuGR+Onq1cpVy0rXolmnGbZ9ZOKbmNPnZfZprXoW0726dyZ/OuYsAfu17fsk0z3x7L7vfKitlHQtmXl45uHvvjRDirwJ/D1DAf+a9/9G6179KDb4LilcB+pcl84C5CABbgFzVoZdRJNB4xee0v0vXd69b9lt3gDdafXv+/DVtXWdU0NwE1T7TrN7t+Rcf6kJ9XswGuCyr2mqde6xqx3mlbxFcL7DFaEiBK7n/ZaJmzyTwYrlVJbvvZE2NsVtLGs2+a1nO+mzTf9vnEBfqdT3p1rFbyxei4DoAP69oXJycwIsvF8gX1a39246RdbX5ZSC/LsB/KZy79/7vAn933fMXcd+rzl1HrssBX6f869Z1FT3THaTLzumWt6jTrjZBl2haK7536wbLwb3byeYtEO8coju5Lrnvpdp1aIPuxLBI5ieLV6GBzWuuC39fUI8LdZjjqcMktraqv/RmF552XuPu9jW4QEvNF9e9Rff6riUnWExbLZJ1tMrratSraJhV5V9N9Ykv03haqsB1rV246CdY1jbL2nXdtvxDc6heJS+jVXeBfR1O7MuQZZPLPBCs0ylfhDJaJS806S062NHGF2mllyBtrj/O6IolGn23nAuY9wdscbWySPtvAfECv3+dGy0Zo10934eCL9Ztzq9wqf6d31xD0V1Fcy2cbDu/0dZjCZ12HX55/tgyim6hQ5HLc2D3eVdeuybd8zKyDOC7degCfbdOiyjOVRPGKnltwf268mW+sLUdNUuuveq3l6n7iziqrivLrhAEDR0hgrbLHKB322xVO6yom587Z2U9X4BvXVDISkvhUrTDgrqt28be+6UPJujQK1wErxbsW+16/t4XrJn565qy1mmnqzTK61yzzr1WHZ+nhtYpq0uFrLrPqol8XVmktM2XtQ7l2rWI1wH4VfJagvuLgt0qeue6dMuqsKp1QHkRFbOu5rKuXJej70qrOXQ70svUpeV3W63qKiLikua1Atjlknp1r2i1WTlXzjzYXdULzmmUTj2uuO8LT82LBmzn/uu8hQv9svl7gXZZcd3M6b5CpBDYrnKzZp3W7UOzd9/l8pcAY1vf+XDMRXXqUiHrct3z18/XYV2Zv88lemxF/+qOwUXl/KE6VF9GXlb7XgXuL1uXFgyvokhetAMt6wDdl73SWbSkPotknrbqOkfnJ7V16t51irXH5RWgJ1Z5F9tzVtxzWZ2WDfRlZXblKj532T1eWFtldR+6ar3CpbK4OLmuVwkxW/ewqEzoOMdhacTM8uLXUBg6zuB1yppNYkuUm/kJYT5g4WWt3XWtnmVyFWUDy8OMr1P/1wbc1xq4zYMtms3mZ7x17rdqdp0/vgjcl9XhRUyoRee2z9yWZ629dllw2Wm7zKJY1LZX1bGrFcHFaI21tLyllZ79r73hGqVdrNurlOtqY+vIKspDCIFihfbuF0SZzNepPbX5O2N5m7adh45l9RGdv3i/dN3Foufofl/Ggc//Pq/0XDeyZFVZ8+GSL8LBv+hkPl/nVpb1q2XWw7r1fW3AfZVcNftfV2Nfh1ZpZR4Yl1133cG+zu/zoZxKqZXayjzQrrpnV5OZb991Ot+qSW+tN9GetKwdxNol/YHJlzFprHOv68DIMh9Fq9VfcIZyPcrBe49fA9ivI8v68lUW8qJzVlEYXQVs3UCGdet9HUt91YS+SiFcpNheJa8tuM9rmMsebBH4dstYdN6L1OU6x9v7LavnOvda9EyrJrmrnr37eVUHWQTW3YlgVZ1eVHtdpmktO/+q866rVX6Zsqq+y6yBZRPlBU19WZ/snCs6/7plXOWkFnDJKvDdv1coW4vkZR2Ui35fBobzbT7fxq32vqjfde+77urr61jqq7T+RRPPonHY/b5KXmtwX7SydNkqtHUohBetx3Utg+49l5mHq65ZJesA81V1aXnI+futuv5lLZEv65oXMZEXTUSvUhvtyqtqty4gi87nReUte5ZVTtELADh/jvfh35yV1wXIqzTL67R3d+yvWnV6lcY7T/m0f7sKzCpwn6/vuj6oq2SdyXHR5DY/Dq+afF47cL+uRrYMeNY9dlVdlFIrwe0qLmxd821+oHSvedWa5oukM3hV8irey8teNy9fNrC/isnnwu9t+YsvvlDOsvJXfV90/jyNN6+stH239QvNy1W0yXxZrXRXnS6r6zrgv0gbvgprli06WvZ8q+Q61M38NS/aj147cIfLL7jbubrndD9/GSD4qkF21fWrHLbLZu75369z/1cBqNfpbK8S1F/22pe5z7rOvVfeF0PBF2PV562Y5t7rRsu8CFWyiipYVd46VOKi39flmdfpl4s09UX1WKRgXZUkr7U2uvd+0aR6i+rbree6FOZrB+7LTOZlzsJFs/CXDWLLZtLrDup5Teiql/Yq6IRXqSWvW5dl7+xV1eNly3gRk/pFy38RK6HLo1/Q2hsg95znF6Jz7lJOfY6muPL+CwB9HrhelfWzaAJ5kTK6dVoX1K+6fpXFex2L4qr7r2PhrLq+ldcO3OGyk23emTevIX1ZwN524kWde9l1L6K1XafOyyaA6/ggrqrDfHnrlrWOJrbs+HW1s+vIl6nlr6tFdevyMkC4DF66YC7n7vEi77IryzT1PyhpteaXue+LPvc6Clf393ncehVylQa/TF5bcJ//vIgrW6UhvSptsQvW6wL3ugN+XktZNjlcpbGv4lBfNSCu27FWlbXKCniRSerLAO9FzrhXdf950FinLa8a3GLut+vUZb6s69TlVZQ3f938OH5RkLyu5nxdPn8eG14VJbNIkXyRCfa1BPeuLOOblwHEy/Kd89fOL9Nfdu/2nEUm73UmhPly2u9dWmpRp2zP7a7GW2RGLuusL9JuVz3fOlTOdX//g5K2nSaTCYeHh0RRxNbWFkmSXJlKet3yX0Zmbc9l+mUVGL0Kf8D8RjOLFC/n3AsB3KusZ7c+17n3y5SxDHjXoWBedZ1eW3Bf1jGuApJXQctcdc9VHW/eJLvOhNM+cwvQF1LoLjH15su9akBd1+k1f591+MDrgP38vV/mnV1f62/btHNNc7SuKo6OjxmdnVHkBUVZ8PjxY7IsY2dnh42NDZIkeSUW4nzbLvs+q/UVbb7MjH9ZSmj+PvOT3KLf5n1ly+reVUqWnfcHIS9iSXWv7Y6/RX1jWSKzq8beonF3VV97bcG9lfbFv6i5eZ1zF2nFV2np68oq8OqCevf7i3ay9j6vAjC797nOJDdfl/b8RccXnfOiVsT1xXX+eoyxnJ6ccXJyTG1MyIHjLMKBqWtGdc3obITWiuHGBltbWwyHQ+I4vmDlvQzIr5J1KbeX1UJfpG/Pf++Op4Wbf1xxn9cB7JfJMgtj1a5v89Z09/nWpZCuMz5ee3CXUq4dl/2iA2oRqK9T3rpc7KoX131ZLxs6tazsbl1eVNaZ9K7bhm37KaWAy5PaOh25+4zWWrz3s7UJ60tYVj8ajzg+PKIoiu5PeNfk9Onc09SG4+NjTk9OUVoxHA7Z3d1lOBzOnmfRwH0RpaNbxnWsn1Ua/zLtftn3Rfear9Mqrfwq8JqnM14lmF/HYnmVls06v72Ib2Lda64EdyHEfwb8L4Bn3vtvN8d2gP8ceAf4FPgL3vtjEWr/N4A/D0yBv+i9/951Kj0/Cy7rqNeVZbRC+/dVUTiLyl5HXqWWPa8tXFdbW+eadSaOdbX67r+WjrpOp7fWcnBwcAFwsiwjyzLiOF5eHx+eI59OOTw6YDqdgPWzreOMtYwnY4q8wHqBjiK01kgpEELiPThnsc5yeHjI8fExcRyzsbHB7u4uWZah9avTn9axgK5z/SKgWGVNzZ+3zjtqlbOrzl2k/b+MZbxq/F2laF1HXjXl9SontXV63v8d+E+Bv9059teAv++9/+tCiL/WfP+PgT8HfK359yeAv9n8XSldzm0eaNvfukC/zsuZN5teRDO/7nmvQq4L8ldphS9i9Sz7fF15UYdrl39dx+E0Ho8ZjUZsbm7OrsmnOaPRCK01vV6PjY2NS3WrqoqTowPOzs7w3kLTV5yz5HlBVVX0emGCKIqaytRhAgDiOCGO09D+nANRVVUcHBxwdHREEsdsbm2xtbVFr9e79C7WebZXcXzReevSAYvKXZcu7I679j6LwhpX+RbWsUKWXdMtd1U45VXHXqRdVx1bJq+aeroS3L33/1gI8c7c4V8D/mzz+W8B/5AA7r8G/G0favlbQogtIcRt7/3jq+6ziFefB5l1tOFuY85zWovKnZcX1YquuubLniBW3fOqe7+IdXRdgFhWz2XUw3W0+CiKiKIoeEK9oI0Gl1LNysALEBJwWGs5OTnh5PgYW5fgHUIA3jOdjinLiiztsbGxxeHRAT99/32Gm5vcun2bXr+Hd566NkwmE4QUJHECUgIeIQV4sM4yNTn5NOfZk6ekWcbm1iZ7e3skSXLtdlr33JfRPteR67znRYoacMl5Oj9m5+szv/H1upNL957dfrQuwHd/+7IUwatWvr6MvKjNuN8B7CfAfvP5LvBF57wHzbErwb0ry0ypVSC0jFK4SrOdP74OUC0r78ugdpbVZdHEd937v6iGvug9LKvrVfdYNpm273EdLd47j5ThXGv9efiLFyDafCcC7xzj0SlHx4dUZRUWqLngSM2LKUVRkCQJ21tbHB+f8Vu/9dv8+Kc/YTKdIKRkMNzg9u3bvH3/Lfb398myHiAwxmDKEu89cRyjtT63HAFjDNPJJEwGQnD37t2l7bGOzPfxF9EWX4QCuC49s24du5P5Kk19VX2XteUiQO/2sXUsiPa3q5iDVfdfdvw6wROtrPvuXpoQ9N57IcS11QUhxK8Dvw6ws7Nz1T3W6kDd7+uYWouAp8vbLrq22xGX1eFVyjplr8pL8zLlXuea63Kki65d9A7mB3sbP30BOPBoKSmnU4xxxHGMECJw51Ig8EwnpxwfH5FPp+fvEqjqknw6QUaaze0tRmdj/uU/++f86Ec/ZDKezDbxds5ydnbC2dkpH/zsZ/QHA27t3+Ltt9/m1q1bpGmKJ/D/06JEAFrHaHUO9AjArQfE8/34ukD8KgF+1dhbNl7Wsa7nQynngbYLgC9KWSwbx1ed9wchi4B93XG0zjkvCu5PW7pFCHEbeNYcfwjc75x3rzl2Sbz3vwn8JsDbb7/tm2MrtetFWvmSsi9ds2zmXgTyizSjZZPIlwHs69Ao81rGq+oQ696/+/dlzMqWNrnKKlsVP+ytIT87Znx2Sl6URFqTZhn9/hCdplTOcVKVF0DCWtvQKjDcGDLJp/zWb/82v/+DH3J2eoYU0MsSjHOUVXXef7zHec9odMpoNOKjjz+i1+tx8+ZN3nnnHW7dusVgMAAPprbkeY4QAq01cRwH0HINfdPIvD9pUVt0sy2ua1muI6sA/svQJrvnX3Vs/r2/jKwz0X0Z8iLt8jKKUldeFNz/a+A/BP568/e/6hz/q0KIv0NwpJ6uw7fDcrOnCyDrrgycB7/rNtYyYJ+v17rWxLr36t6z/W1Rh5+Z/Asmp+vWZ9mkddX5XcrkZcX7QJ1orRdqql0t7nLf8EzGJxTTE7yrwVbUtqIup0zOTtnc3UNpjZCBcnfWMZlM8N4zGPYpypLvff/3+P7vfZ/j4xMUgq3hgG984+f42ntfZTqZ8Oz5cx48eMjB4SGTPMc6CPaCw1nHeHzGaHw2A/pbN2/yztvvcOvOXfq9PgJJXddMJhM+/fRT8iLna1//+gU6bR7QRZMSzFqLMQbvgxNXCIFtQjNflba5ij5Z59pldMYyrf46dZpfIf6q+el16/eiz9FeC8upqfnf18GPV0LLCCH+nwTn6Q0hxAPgPyGA+n8hhPhLwGfAX2hO/7uEMMgPCaGQ/9GVNVhS4UUm+nUeflGnu8p07ALn/N9V2vurlIUDfYmW8yq19Vausp7mKaB167HOfVeBwaLj4Xzw3uKxCGERsuknHhB+FptunWU6nWKtJU0zvHP86Ec/4ne+97shjFLAcDjk53/uPb719fcYDAZ474mVYHMw4L133qEoCp4fHvLw8VOePn3G6fgM6xwOj0DgkEwnEz755GM+/fRT0jRj7+ZN3rr3Nnfv3mM4HAKgtJ7FwnefpSt1VVAUBXmeE0URpycjkjRld+8GURSt3MTiZeRFgH7Z+Jo/tq72vAgHulTOvGLzZTkku/Iymv86tFt77DpW1FV1Wida5t9b8tO/teBcD/yVq8pc457A5Qbrmu/L8qasknVNwXkzudUsv2x5FUD5slbDda9dVzu7amJeFbK5aCBcZY15wnszxjA5G2G8od/vobXmww8/5He/932ePXuOs4at4YD3vv4eP/+tb7AxzJDCIRBYK5BSgRRYZ8j6KW/17nL/7l2quubo+ITHT5/w6PEjTs5GVNaF9a4+xMDnec7nn3/B559/QZqk7O3d5N133uWtt9+ePcN8uznnOD09wVTlBcVCKU1dG8ajMXEck6TJ2mGuLyqrwLYrL0PfLKNGF92je163jPmV3cvuO3/dyzzL5Wvb7775F46F8lofj8D79r0317jzc/yFa9v6tGW2k1y336wev6/9CtV5aTnadhZf9MJXabzLZBGoz//+KrWkZVbDKq15GaBdx6JZdv9VssjXsYwbni9/fpJc517zltIqzaf5NvvbnquVZjSa8M9/63d48PAh2ze2+drXvsbu7g6PHj3EY9nY6PHeO2/x7Z//FoPhIAw+IRmNxxRFwe7ODgZ4+PgxWmtu7u0hASEtkYy4desmt27d5Bd//hucno148vyAR4+ecHA0YloUFwarkJBlKTdu3MATEpKlaXqp/xpjGhrmomZaVjnGGM7OTiiKkt6gz9bW1tIcN69S1lGa1pnkX2Rczt9jUZ0WafXr1KEb1QRQ1zWw2tpor+9OJC11hvcorUOUViOuAXIhmms9OG9DX2voPbwDAYJ2krLQAfEWl7o+I2PMv3rb7C0zP+bNxfkHf9mOsyx/zarOsghsrwaii0C+iDpapMWseq5V4HoVFdU9vuw5r9Kq5p8FuPBe2t+cc0stoO6Evch5GqgW33DRjRUnJWEUNPAuBAJFUZT89P0f8eMf/4xxnpOkKW/1e9zY2ebBgwd8+vFn3Ll9k+/863+aGze2w0BDc3o24vj0lPd/9jP2tne4sb2D956DoyOs8zx9dsLx0Qnf/MZ7JHHMxkYfKQQax872FjvbW3zza19lPC14+vw5jx4/ZTwtuP/WO7zzla+wMdxECsmjhw959vQpb7/zDvv7++eD3oVB38ae1VVFWYbFVNYG4HE+hF6OTs84Oz1Fac1wMGRrOwB9d0VuV7r9e93ok1WT61XXtHIdKmaZArMIbBf116WU0nwVBCilLu2lOk/xtGN/UXtZGxa9SalwzlLXNcbUgCCOI6y1WFsjpSTPC4wxaB0jhcJ6Q13V1HUVVj/bGiEEUZTgfZhkyrJs0mm4mS9qNBo15cccHR1dySa8duC+VFozRHQPBbqkC4DrgP38b8sArzuJLJpg1qV55q/p1u+qTa2vOnaVrALzFyl/XqO+alKYfzfXyVp5eSA7nLWMRiOePXuGkJrhxgZVXYIAieTjjz/jd773u5yejYjjmJ//9td5772vcvj8iM8/+4wnT59zY2ebn//G19ndDmA7ykuOjo/55ONPKYqcb33rG2z2NxAIpBBh8VKvx/Onpzir+fizz3j+/Dnf+Lmv8a2f+ybGVRfyqW8MemwM3ua9d97CCo1OBggZnb9rD6Y2OGsDyAgJ3mG8x9Q108mUqphgrem0gWsvBfzMvK/LiqPykOPjI6I4ZnNzk83NTYbDYVjY1Wn7VsJ6gKtpxnYstTl7VsmyfnDdPrWqP3UVrXXPmZXb+R1EA77njmlr7YXQROccVSdKyhhDVVUURcFoNMJZ21B3IepqOp3OzhdCUBQFZTkljmPG4zHOuVkqCmPM7N4t1axUu+CuxQiFlOcaf/tcWsckyUWLb5m8XuDevC8h5yo+o7Au8kzzL7irzS9LVtQ14RZpnIvK7H5epxO2v3f/zl97XU18layial6ltJ2+6wycB+Clk15zTqQ1xlqqskRpvdC/seze08mEw4MDiiJnOs0pq5rj42MiUaMJJvDe3g6/8svfYXQ24s69u4ymOf/kn/wWk8mUP/WnfpX/2f/0z5KkEiUkElBC8OjxE85GE+7du4t3gt3dbRSyrTSRToh0SpLU3LixRZTc4P69OzhvkUrM0gRfemYhSeIIISW1NTgLCImUQWs8OT4h6/UY9PtMx2OOj48aILDIhtIRIrSnsQGAauOoyhrTRBe1gOE9VGXJ8+fPOHj+nCRN2dzcnFE383maruq/LyIvoum3111lsS8bo4sUjC64ex+SwpnaNIBbXqBfqrpmPBpRliFUNs/zkDhOCE7PTvHeE0URdV1TVRUQVkRLIYmjiCRJiON4lhm0/R4mVNCN83zekm0n3IvH2zaUCCGb791AEglcTKT43/7//t7Sdn1twP1FGMNloDZv1i8C5PmFMIs62CqOb9n9l9VtGe1y1fN0QXPde8//Pv8c3oe8KsYYoiiaZVFcRBPNl7mq7vN1c85xfHyM955YR8RxjHOOp0+fcnB4iI40w+GQfr9Pv98njuOFGR3LsuTg4IDx2QnOmeaom/muhAh0jRAw3BgwHPax1nJ4dMTmxoBf/qWf5+beDe7evYsQCmOnyFkXEbx9/22sM5weF4zGBVVd0c+ygO0epNTNwDpPadDv9zHWIEWA4ctUAngEtjYoKiKpQSmcVzgbkpI9f3bA4eEhG8MBSnT4ee9Bhn5sTI1zHik1SmosBpwliTTWWYqimml+WmvwQd0r8hBt8/z5c9I05Stf+cqF/DrrWlwvIlddu0rDX9RX58/rWtNwrlW32vZkMqEoCp4+fTqjAqfjcEyI8zUH7eTYjgEpJVtbW6RpynAz+DJ0o4B0/ymlEICSau3nnZ98Fu9B6/DezUC8TUN9PllBd6PFf3U0d3FOuVyq9DX7Wdt4i3ZRasuf1zKXAfm8LEpBvOzaRZPFqnzPy55l/vu1Bp4HcZHLoq4qvnjwgMPDQ7TWZFlGv9en1++RZRlJnKD04rS5876JRbyklBLnPQ8fPGAymbC7u8u0rjk4eN7wxxZjasqqZDIJibiUUsRxTL/XZzAcMOj3SeKYs7MzTk5Og5PJOXCeuq6piwrvggP0/Bmb0EhAKsne3h4ewc7uNr0sw9NoU2iE1DhbI4QnTVIqU6G1J44k41FBP+3RKu+SlpPVKKExNgC+dI6lnbPpzi3wC+GoypKgecUoEWLvHQHAZaTAhwVSzjm8sXg8kY6oa8Ozp8/46OOP+ezTzymrkrt37nLv/j329veJ4xhrbZOqWKB1jNJq5mCcTqeUZRmq1VUWZl2r6VMdjbL7fl+ZtJb5nK3TflrU160NfHaY6Azj8ZijoyPyPMc5R13XjMfjmaLSgnGWZWxubtLv9+llGWkaEsBFUQD0duUw7fh3Ducbv44QRHEEQszue8mqbNpPdHCrfbrZU3VOF6IF5yBSCtxstXIb0rs4GqjTky61zyp5fcCdL59n7soqkFz227IUxOto4uuC8rqm7dogL6CbHKIsKx4/fkCRT7BNZEZZFJwcHQMBZKM4Is0yBoMBWZbR6/VIkoQoihZaJPPafgv2dcMpm6omzydUVQCYuq6w1oA4BxFnLWVeUExzjg4PwwCNdWPiMpuU8J5IayoZeGqcATxCKQQXNTrfDgghMV4iRYRG4b3FWI/ABo1fZgSOMyGKFJPJKXbb4qUC4ZBYhIckzrBWIawK95St1bDkHQkPQlHZGmF9mJysw1HihUQqhYwSvDdUJmiYUkq01lgDh4cHfPLJp3z88cccHR2GzUOaZzr92YiffPA+/cGA27du89Zbb3H71i2SJMVaR1UWSAlKaaSMwF2kBaWUeAfeOzyWsqpQOr7kkF1Fla0jF/pGg1HN67ygGFjnKMqCs7MzRqMReZ7PQLssy1n/ay2UjY0N+v0+aZrOtPB2w5RV9Z0pZ77tH00dfKNJi6AYIM6drKt8FN77cC4t9M5NADNxtFq395YWrH1jec5ujmx+s81n0fntevLagPu8KXhtDZXVgDsPyutqzO15y/K3vIz5ukpeVbndUsqy5OnTp+R5McuxIoS4AP4BZC1FUXJ6chKcikoSx3HghwcDelmPfr9H3OwnKoRACnk+QCBoQN7jrePs9BSPwzsXFuYUBcZaEMGsnZXRrXijtSHAmDqsYFWBKzcmx9RjrAWpNEIqlFLYeWftTFOU9PoD8qIiShTOGLxwswgbgLLIESJBiBitU8raEMcSIQVSK4TQaC2wzuG9wBrbVn+5eHj0+BFSx2xtbZJECqH0LL+MMwYnJdJo0iRFKMHh0RGffvopH3/4IScnJwwHA+7fv8c7d/d59Pgxh0fHVHWN9R6HYDRqVsd++GFYHXvrNm+99Q77+3tkWdxQFTkffPgBXsD+/v5MG3UmRGN4Z8mnU/LqlBs3boQ8OXMW2XX64zL+3DlHXVZUVcV0OuXk5ITj42PKMsT0IwNlsrm5yc2bN7l///4MvLvUYfcey+jUZVRmy4F3Lc3ufq/zlgssc0B3rI/ZRLGwMWgnECHas1ZNlnNWje/Wv73XVWUEeW3Avcu1zjtErpJux5unDV4WJNv7t1rVi0w68/VYRhO9aHmrxANSBO/9kydPmkEVeHBnL0+is0HUXOzxWGPJbU6RFxwfHs3Oi+KYLE3p9/tkDaXTalFlMcXWZaA+PNRVSVHkRHGMrUqKoibp9dGRbupisc5fmESV1uRlTiQVWiuECSGBztV4W+MNWGPwKsE5cam/CCFRUYKKYoRKSNII6Wqc9LMFJc4JnDBUZYXUfZJMoeIdDo+e0u/vUlvD0dERg0FElAxQSmIij2cEqAvWx6V35OHBoy94djAh6/Uoy5xf+eU/zu7WJrH2WFMhcdi65CcffchPf/JTDo8P6WUZb9+/w5/+1e+yu7NDHMVMp1O++fX3mEwnPD845ItHj3l+eMgkL7De4XzIa//hhx/x8cefkmUpe3s7TWKzuyQNSLZUR1WWKO/wBI5XosAF/r4FulWRTYustfZvO3mUZTmLJBmNRlRVRV3VRFrT7/cZDAZ89atfnVmGUsoLWvM6953/vPRdiHMH5rx231pLLZW7iDrVWs/omaYms7Hj8Y01sqDOArzz4EVIUgogg8WEV41u0QL6PPXiZ76e5uvFgq+Q1wbc50O14JxzuyoqpTvbruPkfFHa5jJ4XJ1OuFtHuOzI/dLFQ1lVPH36hOl0wvHxCXEc8fnnnyOkZtAfzAaWECIsumi3q5MS3wB9l1sUogkly3OKPOf45Biad5AkCWmaIkUAbG8d0+kUgUcqxfd/93f5vd/7AVVtGWxusrExYGdnl5t7+9y4sYtSetbOSirSSOOtwZYVwlVIARKP8Mxi3qXoOoNDPaMopjcY0h/sYr3HOAcWLApUgnAOTw0i8NxRlFFZR1EGHl2IBOc1xnqOT04ZDO9RljWmtggc1lUkabTcKUkzXL2nqmqQBU+fHjCa1PQSyLYinClxtcHUNf1ewntffYtf2fgF9m7skCYSIRSeYB4ooUBLNoYRG8NN3n33bfIi5/DojIePHvP02QGj8QRrHDjLdDLhs+kZDx8+Ym9vn3/j3/if0Ov1wnv0jcHfvFLRzORCXnZWtu+7/XuB9mqAvCxL8jwP2w6enoV4fRHisbMso9/vzyyCuIk06U4Kl/nl5QpPe3yZld/9vCoooPuv9YXNb1DfLb/FofP7hDbzHUDu3redJMNeAuflhD7h2t5xwR/W5eVDWYLLTXO+1uMqeW3AfZlGvI5X/yrQfhGue9E1XUftjNIQYmEdFzkd58taV152Mqhrw3h8NtsG7p/983/K+z97H0HQjvv9ARsbQ7a2ttnc2mFzOGCYZXgZI0QUNA/aTS9k2GZOdt5Xw6O6Bsjz6ZTNQR9rDGVdE8URXzz4gt/+7d/m6ZOnYTAhOD58yvHBIw4e94m//W32dxJsEXjHOElRosfhs6dsbWyF9pYiaOgNjySaUEFwIBxCClSckG1ss7G5SxwngCCf5kjpiWXQpp3v4ZzFVGOkzxlPKqo6AiERokJ6wd7OPlpYkijmK2+/R5r1GY9LrA/gX+SCo+Nn7O/tM29Kz4uxFcqC1gIlIpAxXjqE8IFKkorNzS1u3dpHN5OpcZaiqCmrMZtbmzhgUnviuI/AokRNvx/RS4fcu3Wb2tacnp3w9PFTHj95jhOaW3fucufuPW7c2OeP//F/jSRNg9MOCdZifE1Z5ownZ5yejEj722xtb1/yrXTB3BjDaDRiMplwdnY2i0AJzssBt2/dJUkSlL6sWXvf+ic68HQ+u1ySeeVp2dhcR4vvWuDted0yZ1q4P187053MhBCzdnHOYbEg5Gxi6G6n2J4zK7PRW6VvraG2FUTzuQX7wL+fQ0Pbvxc/y1Xy2oB7t0FbuUpjn5dlL38dKmXdBmsBHi5aGOvUfV365UWpn0UihKCuK05PT4gizT/6x/+IDz/6YDbQjDVUZcHJ8QGuLimnp3wynuIdqCghywbcuHGDjc0Ner0+aZIRgN4iBLNFF0o2WoYQSKWYTqZoJSmLnH/8T/4RH374EVVd02orUkCsFV997yv80i/+AlsbW9R1SVUWYbIwUFUJzjpqW3F2NuVHP/599vdv8bX37gdDeNZEAeDjJGNz7yZR2mt+E8EcblaxAo1prJCqMb9t6xRzaB3Ri1N6mUIrQ10VYC2bwxgd1WRRRG0j8rImirfgtAgO4ys0qaC9V2itkFIhZsvTPUWR44Via2uLYloSRwmPnz7l6PiUu/duoVXIU+MReCkxVpFPDM5NSFLJVr+PqQriSLG3u8Pezg7f+Oa38DImSjOUilFSMx6P0UmEVoqzo2ccP3vItMxx3qG0wjnBNA8blrScdMs1B438FGMMQgiSJKHX6/HWW2+RZdnFJGi+dQi2/5ipo7PXdaFrC+Z7ehdw2z68THmaV8raz6vG2vwq1GX3bJ237dqOrvXdHrftQrQO5dNatnCe0qBV8OctBFhEJ15spFWK4yp5bcAdVtMeXVk1Oy8y29b9/brSDoB167nuBPIqfQZFkfPBR+/jvOcf/Pd/n88++yxoA/7cBRRrxS9861v84i/8PFVV4rynNsGpOp5MGI2OefTgU6qqRihNkiRsbQ25des2g+GAJ48ek6Ux/X6fKElJkpQ0SfnJj3/Mv/zd73E2HgWAbbag00Lx1t3bfPeXvsXtWzdRMmi+IYlucIBWxrIRR0R7N/jg/Q94+MUTnj07YXNrJyB0A9htgjDvw8bWcdynjTjwLbAjQRh8CzwCvBNNG0iGaYSLIY1ACAN+inchSkZ6j6urZmISSCkYJIJhT7O7fR/hwy5PCzX3GYYHakbrONBOiACCXnJ2Oqa/sROWsdsphYe8KCirnCyNgwnfUF5agBIaJQwqkmGCjGNMnRO0P0BItFLoNMFKMK7COcvPPnif+LOwgrUeH2GKCf2tXYabt9BxTBRrkIKqqvjiiy/49NNPqeua27dvc+NGWCNwCciZH6MCmjUH0gdKwnfovCBXJztbNEa7YD6/SLGddOYpo0Wy7JyuQ3V+zLXPPF/m/CKk+dDrC+UEUj5QYSJEW53TM1dj2ovI6wPu3i80z7ovcRlPt4iWOTcBgSt4unCgc9NrtOW8Fn8dOac1fPfg5d+7co16ikaL9t7x3//9v8+TR49DR2xc7h5Pr5fxq3/sV/i5r70XjhlAQqQtWZKwvTkMmqMPS6PLqmYyHocc5kdPMfkZx8+f8tko7D2qtCZNM4aDIaaquHd7H2N2OR2PmBZT+mnGd3/hO7z79n2iOIQzSs/M2RSUltDxhRQgJONJgReCQX+DZl5qNCFxgX8Us78e58HWFfnkmPFk2kTUhFA/0fgSvDBY70gjiTUO58vA59P2nfNQtFl/c80UZINjdmomM7haNMnf2N1lPDU8e/480BVSz57TA3leIKMy2DNSEsUJoj1BCqRQSNU4bttoCyGJdYScrcTqaK0E015isSYsspJSgPOUueN5WZLKikGa0R/ucTaecnT0OU+fPeGLhw94+PAhT548oSgKvvnNb/KX//JfZnd3d9YGC5WYhZ0z+EKaZTiruuna0jo2u2B7pZZ/gcO+rOF3Py/Cl0VW+XyumdaP1o2o6aY36DxBU5f282X/2yItfb5ui85bJK8PuBP4XLFggVB3VoQ16Y2OMvGHJdeadVsLlldHyXjvQ/yvTnjr3lukOuL09JQyL6jKks3NHn/6T/0qd+/cw1qHdR6U5OhsjPCWSEcIKcLCj0QjPPSilF6WcnNvm7IsSLMQC++Moa5rrHOUZcV4NMaakv29Hd56K5RvasNwY0iaZSFEzziSqFmJ51t+MSCbIPDjkpCHZXR2xtnRlHfe2mtwT9D6qtrB4vHgplRFSVkW5PmE09Mjnj19Tm8wDAu0kgSlQkoBrQRSOJwrm0mveRECvFcBxKVCoEJ0TggMh8bfIDvvrW3vrgjg6195l6999WuMJxPyombQi4ikR7owiVjrOT454/6920gESii0UOACN962hsSjpMD5sHBLaI1UjWY8uxvnjmbn8bbCeYfzCiEkMuohvMQ7T1EW/Iv/7r/hX37v+xwdH2ONQShFkibcvnObr3zlK3z3l345RDqVVVhyLwVeLMifLgDfcskNdSGaFWCYtnHaVmKdQbloDMxrxlf6slZARJdLnz/WSgvOXcqldZJe2upxjgrqlhWc2L6xMttnax33XCpjnbZYBwNfG3BvNZll3PUyM+2lxF+cAZYY1xfruarx5y8W3XvM/bDkt7Wcv91bLatwU4wUgl/6zne5f+8uDz7/CGMqnHFMJ1NiLRgM+oEdlQItJXVdUhsDzlDVNbWpUVHEcGODPC/YGPSJlMBbQmRMlgYwtHVYXdloLLvb22RZxsbmgKKYAj7wv5GmMhZnPUkaI4SdmauXLTc/i8EXIiTxogGvVvlp31zg/w2nR08om7DPH//oZ3z86QOqqmT/zh7f+c53SHTMw4cPuXnzBvfv3aafJQHEvWzqEFEZi6kNUaRASmojSdMtnHUgLZ4cZ8x5qqMVnKh3DoRhkKUMsgQlKqRwGBOAQ+uI5wcns5fWNoMQssFMP7NqW6D3Hhxiphmfv+5zCqTIa1AKpZoFO94hmp2jUMFvdHNnyK9855uURYGOYrJen62dHfobG6AURZ7zwQcfEEURw+GQ7Z1thhsbs4Rk7bOGOrnzyJHZ83c495ccri0H3qVfWpBd6Ztra7HglGWWSPtbK10wn9f2l1kCCx6A7srctomu6wu84Jy+4trXBtyB2RMvi365XoRJexGNtnWxLNH+9go6nZi9uDlZWt3Ojdt6vaDTZHGlLn6VwHR8ynh0jLUBlCIlGfT7KEAlKdI5XB34Y2eZAYpzoBpAMbXB1C7ws41GNosqEIJebxPnbUio5RVZopudkcSMLiiqCiEjkiTGCxr36nmnv/hKxOz1OQcq0gwGvXBUuAtne+9xpubDjz/g937wEx48eYJWmrfv3+G9975KkkR4BJ989DHT6ZRb+zfQWuGFxxPjhKeuPWVR4YUlUhod7CgqU+HcgLL0CBmjIo8QBZHWxJHCFhOWv2wx45HCPGAwGHzjN/AIxpNpiKEmLCpSzaKxkMfGzawKIRVKaLR2zIc/n+vv4X2cjmsqV7Kzs02WJhT5GbbO0UqHHiEc+3tb7O9tA1AWJVXtOTwKfWSwsYmMAklVVRUHBwccHB4SJzFf/epX2d7ePr+/98hmRdfldZwhlvu8e6+ntbda+rJU3IuAfZHltPQeXHRuriOLKKAutXp+e98agJfvKmZqLPN9ZpXjuHvf+ePL5LUA96CFrTZHVs1g8+dekEZruKD1X/h94a0X17Mz6VyyIloNc72iLp130flyPWC/rO9263UeEy48CCfAO7ywDb8sZsqnaAaoazQ9KUTj4vSAw7t2+fu5SCFRUuGsQcqIw+MRsVbs7W4jXIn3FoFEqxjrLM6BMVVYUCMaDYSLg6bbBgKIIsm9e7d556132NvNwFfMHIgdsc7TH2zw7W9/k69//Stsb29TViU/e/9DJpOc7/7yL/Nn/vSfJIp04C8IvH5RGCpbo2VYDJX1QgglwjUWA8EpgKSqHMJZPCWCiv2be9hivJCbvfg2Zjpb542Flb3et/HMwUeSpilZFXKqeGdxaYbzHmsdiJCaVgqJ1sFBfN5STT1F2MpPe4MXAqmi5v074kg1FMrFWvnG1/DZp5/y0Wef0x9u8O5X3uPtr7zXWWCkKMsSY8yFdSXOudn7kgsUMN9aZp3vVylqXYBfRX/Mf+6eswxkQ1OLGcC313T/rqI9lmHNTJ9cqdQtli63vpJquoass4fqfeBvA/tN7X7Te/83hBA7wH8OvAN8CvwF7/2xCE/+Nwh7qU6Bv+i9/96qe3TZOOfDsvVlFMy16Rl5rlNfpE/OUX1dKuZcS4cLXeYabX+pvi9vsV7gnWf/P8eP4IsjtOssprbp/AIXtGM8WkWzcsJ7CBMBPjgoPR4vXBOwG7RE58Da8+NCOIyzOCFQBG1dCDfr8AJJXVXBhPeyoWU67dN6Vr1HeoEQhl/+ztebXCgeicE1UBS8q+2Voax+L6Pfy8BbxpMJG8M+v/zHfpHNrU0G/S28dThT0y4/kQh0EoOR4GOkrBGymexkU3gT5ukbcy/ko2n3Drj4+uejNgCU1DjXZjJp2r3JAikkM2bdI3CuZpJPyPNpAB8hkU0fUTIKWSVdSaCDPZnuvve2P4d84L55P/iwbWDW65NPJ2RpTLfjtS5kLxxf+/pXuX3vDr//wx/z4Isv6PWH3Lh5kzRLm67gefbsGVtbW/T7/UvP291fAc6BfF7DXkSnzMbXwknyYvteCb7eN20a2rn7llpl5rzlzsel860L+Lqj8rzfnk8ybk5Pu6jdd9vlOj7FdSZHWE9zN8D/1nv/PSHEEPgdIcR/B/xF4O977/+6EOKvAX8N+I+BPwd8rfn3J4C/2fxdKs5ZyqpEqjgkU6Jtp8uz9Cvh2i+g3xWnXgL2S9C+dhlXHbuOzEClM18t4/GccCGrYiBfO8/hOY/A8AgCWKVpj8pIhKvxyjRGZFdnP6dQvNAk2ZC6jvBCk+c1OlY4Qqie9A584HqFCLaCbWPLPXQT28gu1zBTgwyRtHhvzpdv0wJt65DqNka7JFwyGAwQIuSfUaqHpQFvZZFIXLPJhpAKKT3OyRChIh3ey/NuIoOPISgfDi0EKgrgiVxtYYIgilO8VFRFETj4dmoRnu2dIW9VtwLN4kJ+nuHGkCzN2BwOwkpfZ/HOEmuHFzVyCEJFOO9mb2VmPbaVlgpbN4ukmvTIUqmmrbqzaQMWQBRHDDcG7N+6jdYRn3z+BT/60feZfq9mZ3ePW7dusb+/P1uws0iznt/xqQXxeUBqKZGusjYfOLEoSmT++va6VUDv/UVwb1/r/Hvy/nw6WDTJrLOD1UXrYbkGPm8pLEpBfl7O9dOTwHobZD8GHjefR0KInwB3gV8D/mxz2t8C/iEB3H8N+Ns+1Oa3hBBbQojbTTkLZTqd8sknn7C9s0ea9YijmDiOiNudZGb/Y+nL/jKkqyVI2bmvP3djXcTRc5N7ZhZ2NQbRNclfpmIX63de9sUJUAiBtYbnz581W3RdLqcFTGc9Xnq881gjsDVo7dGRblKlhvehtJqBfW+wzWCzTRkQgO+r7w0oq4ooTpAOvI1xosJTzfTToLWI2V6SLShfrNplwJwd8S2Y++7RTp/ws998E8WhdI/Hjw+4e2sbJSXOizD4BIhZvpHGaSvEhYVGYU4MzmLnHCrSpBtDqqK6UM+2Dl0Lz3lNWXvABDBusFU0E9Jw2GdjuIk3BbGS9NKYXroTTvL1OSfsLbY8w4sxSghwCt1smn1xMg9tKaWgNpaqrhAibZ6jndI77TabFIO1JpUiShJu3t5n++YNJpMp//Af/zMmkwmj0WiW0KvV2i91qTlQ6o6hS+0jLkbeLJok58tpz1vbkclFqzacv/L00AdaTbzTL8NCvZCqt11/MC/t2eE9i+bvZZBf9qzt853X/XL/WnR8kVyLcxdCvAN8F/htYL8D2E8ItA0E4P+ic9mD5tgFcBdC/Drw6wD9fo/j4yOskwyHJmT4s5ZIa7Y2N+kPeih1/YRg6/BnK551rixotzrDu9nsfhGs550/vnm5y/PJdMtYq4atgtYB8Nnd5zQp7z2T8YR/8S/+BcLkbA17nZqd/wuaoUPqc6gytqaqxuBtWMAjNWVZYYwlUgohJcONHeI48MEOj/CStKdIsrCKFR/jrIfxGEzYxUaqwBPXlUHriAva96VnnXEhC+RiJ9daY+z5NmneB4BrHZdKSExVIoTH2rCwhxl1JMLuX1YQEjW5zgR6biXNpg4pqITDiYXju/OqJJNJTe00Fodjws7OFko4hLH4Zqs2fMhXI6TDu7LRHpu0wqIF5Za3buI/rcXZav6G0Gjhvb4i7m2Bl3jXRrKsakqHsSHj5aQoODk7xXvJzZu3+Ct/5X/Nrdt3GAyHs02ll3HdF4r1neRaC3wS4R0t3nNhFXh3Nf5FNJj37eS1akQtWpfim/e/Ytm/n7N8WunoArNDc31jNQasj1PrWv1rg7sQYgD8v4D/jff+bO4lebGoNVaI9/43gd8EuHlzz29vb+GFYTx5ThIPUSqmqioeP35Cr5eyubVBr9e7sC/ksllt0WfRUBKdJ+IioPiOqd+O6PlwI3l+aajEhb9LTb1LP7SD4uK5C05Z+PMqjWn+t8l0ysHBEXf2NjpH/fyURKQDTQGeGzs9nIuo64y6qrAu7KRUSjlL2hU0GzEHGh0IbM4RM148tLetDcV0ysagj5bdAXiuLYX2b4oRIFTcbNbR1t1fGLpCEKKAGnCbledliIYREqQkSUPYphQhugdv8MTnjTt7ve1S87CwSGuFQ6FUTV1bTkenFKMJ/SxjZzCY1bu9dws8zjvCgixBUZbUZsSgn+CtY6Pfo7at1i3Dtm1pghMOiWnqpAGPVDJQSUo1FpINeexnzd18ENDSXM5MEMIhiCmLGu+b5FeLAE9AG30kZIQQMVVtmUymvP3OBl/96nvEaXqpf833tTbn0rm1u3j/A+DCnqXzvy+iY9vj5xO3vATql55p1hXF5fG06JKZkjGvVfvZLN/6Tq4jbV/yl6zNi3jkG7Bo67tI678Oc7EWuAshIgKw/z+89//v5vDTlm4RQtwGnjXHHwL3O5ffa44tFeccT548IS9zdAyRTuj3h/SzbYSXnJwc8ejxQzY2NtjY2Jg5c1otYpG0DTlrBG+bGGxDVdUYY2cmbYgECC+v18uI4yRkyHMXO/Kssy3ZXsv7eYhuJ6Bm4DQDudGX26tm5y4S0f20pibQ1tMYw8HBAfv7+0hfMN/D2ylJSYe3DlPnWFcDFcJ7Ei1JozRcJT29m9sIIcOCFwHWFJTVhCLPcQh0FKFUhJIapaKwv6gITtv21mkac2t/l+EgCxqqczNQOvcFiE7391AHy2eSV8SJRorzIRiAgLCa1XTaRCqkiukN+gihQWmywRCPBiIkDidUA4uiiSqRKC3xPoCgRDRUjMALi05AekNVTVFaUlQFlbNh443mObqA5LzDNx4kpSIQMVJIjHNIoZESzkYjvFdsbm0yrQxZllJZz2RaBI3dOTY3N7FekhuJUr3gWPYTokghsZiqpINknHtUBFDPxkI3Q+GFfhBeMB7H1tYNonQDKwWjs7PgC1igSF0qY44WnOfSu31zEdVyVZldbtq30Tm+A75zFF1z4fnzzVnUARuYu6YF4Pbe7XlN2UJyKQT38l2XPU2nXdp2uHh/f6GdCAyBOw8uXZXqZJGsEy0jgP8b8BPv/f+x89N/DfyHwF9v/v5XneN/VQjxdwiO1NNVfDuE3WJ2dvapjW9ygkcYW1IVBXleYK0lTTPKsuTBgwc8ffqUwSBjONxgZ2ebfm+AUpr25XjvsVVNWZcUxZTT0xPK6YQ8zzGmJooiqrKiKMtmN6KwKURla5Ik4ebNm+zf3OfG7h5xkkADAuuaQ53Gaz8ALbUDs05zfuLiyy98CN1omYnbSlfrUUqR5zk/+fFP+MVvfaVT4sXrTJ3T+Pc69WrbEoSQaBHila0zCG+RCKajQw4PT/joo49BSPr9Ab1+jzTNSLKUJE1I4ghn6hmAp6kiEwowzWR4OSzv4l/JWVHx0QdfcHp6zK/+6i8i9fwq5uZcKVBRSpxm9AYbJGkflSTkeYG3gp2dBJzFKQ2uh6ynCMxsIFtrmrz9rvGxnA9u5y0ykUgcWI9SwTmcu4ok0fiivrCU4hxIQ7ipFBIv1GxACyEQXnJ0eIaIeuzcSKmLM6bOcVrmHB0e8Nad2zMaq9VEnYXp2KCjAuNgo9ej9uehhudg01ie3V62Ivd8ODekSs6yHmn/Pvs3gyP3Iv24WJOcT5M7v4n6VdEf89+7dEur4c8mBk+Lfs001jo6ZfvkF8tbfNfuU8yOXJiIaC140WzBd05vFVWOR5K2O1ddV51fIMFwaJ5bEFx7S6ived5+kayjuf9p4D8Afl8I8f3m2P+OAOr/hRDiLwGfAX+h+e3vEsIgPySEQv5HV93AuRprz/A+oq6hriYgIEt7DIebjEcTTk5OmUymTKcTlBIcHoaNaqMoYmOwyc3dm0gpOT49ZTwaMR6fhgEqRQB0JWcpO4siZzoZM82nTCYB9MOu5Qmml/GzowM++MlPuH3rFptbOww2N7l37z5x2pu9gEVc3/IpvDULL0eczJ+2+HP40l2hNy/LHKv/2q/8Cr/0C7/Iw8/e5+Hnn8zdr3X4CLxQOAxSa6xLsL5GEJa837v/Nts7e1hrKcuCIp8ymYx4+OghURpz/923qMuwu87h4XNqY6jrAAx3bu1x987tUO9GY5EX6KxzjdO3INY8j28ieIyDk9EZwsuQVXEhHwo6Tri5cwudxoSYfYnD43xDD4gwu0rC4iBsFSy6WURHA4giAKHwAZQjrXCAaTh84wy2tggJRZ0Ti2hW7/P3IxprpD0ucRascSFenUAPGeMp65DvHhE2qxjc2EImGqRuuHaPpAkN9QLhPVpplOhw1m0jNBNHrz8kn+aBl5fNxt5uMS3jOx9a3BSN/6gNOxVcpOC6TtEuwHf7IlyOMOlSK90dkLoafTcDY9uebYillHK2k1UA9cbSmylA5/2h/T7vGzvXzrss3uVUAOFDCCsV3s/CJJ2r+eFPfw8fJ/zCV79BGgVqT1zi8Tv9e77NF47hi88Qqn2xbbttdZWsEy3zT1kOW//WgvM98FeuvHNHjJ1ydPxDpMrIkh5x0gMko7FG6RglUrY2E7SOcVubTKchU+HZyQnG1Jz2jnn++AlFkWNNjY40VV1inaU/3AgO2trhvcU2OcedNSgpSaKILI45PTtjOp5ydnqCbwZPPp0i1af0+n2ePHrI2+9+lZ3dXbJeHyU1yNZZtUj7aD4IZoOOuQ54fsI55TLbNMOF+PJWE2vTisL1ZnEpJUmaNCsTF3QID8YqTs9GRFGMl5qnzwo++fx9pKy5eWOPw5Mph0f/A8bWaJ1wY3eXm7ducev+10kixWQ8pi4mGFNh6irQNni0EgwGKVVZ46xF+ACOVe04Ox1hnWN/f3sONuZFoFQT9nYhXOyyfialJI57C8mn9lkvXNHQQKIhT5RWRIkgTsLvdVXhrSFWILUgFx6EDdu+aY11lrPTEdnWFqnWgQcPCwJm2vMsVBGoqpqyCukfZhqZlFTTOmTKFVA5y3haoSNNmA2D9iiknMXbBzCTSNn2qxZEWg3Uk+dlsIlmDkKoy/LCrpzz7YyH6XiM84H/VyqCJm3BhTOX8O7d/jj/r3vOPLB3y+pmWu2WeWEi6dBfYSa63HvO+fPZnec+d4i/TlHtPUUH+Z2zFFVJmmbgPU8On/H87AAfKR4dbPLu7bfRMoSZipnC1FocnXwzTcew1jItpvTSXoeAbOrVTjztc3TG/HUiZeA1WaHqnSLPQ56RuipQoxDV4AWBn/QJziiq0uKsCDmShZtRD8V0zKg6pqoqNjYGSKlI05gkSRiNxnggjWNKZ5lOp2ETYA91USK8pzY1g16fM6aznNvT6ZTRwQEAN2/e5NmTx4xHZ2xsbjLc2GRra4ed3T36/UFYKHWpwbsafWcGn4H97EdmUNDpwG1ObdE53p4DF03XVS/eWsvR0XPGk8lc/c7Nv7w0FOWUOElxWJSKkRKKYspkMubx40eAYDQeo7Xm8NlDPv34p01+lvvkRYG1ns2tTZL+AK0jFI4kblKbnp1SFQU4T1UZTsYTRmenDAcDhFcg7Hx2iE67BO46z3NcXeEsKDlbCXF+atPmXtJkmQwap7VBU25zMQrELADHi7AwKlUuaKiuBG3BukYTtnhncMZhqxNcqnDSEEXnG0mbuqbGE0USWbYu0ADCUng2+imWhNIYnM+Ct8Xac8AUgrPRFIvHCng+OuWsnJIlKXd2bjQBQyKAf7OptZMCtMSrQEW1S24aHQ+E4HRkQVqGGxkKh61KJA4dKaQIKclmU2pjIeE9P/nhD6idZXfvBptbG2xsbALv4TsAPw/i88fnz+nmZmkBfJnmOe887cbKX/ZxiQv4vcx5e/Ea3/nbasMrLGEsh8fP+Oijj/jWt38BKQSfPvkUox1VVfLg8CG3926zmcRYbGethr9AVYXQyVDuk4NH/OTj9/mVb/9xhtl5SGl4IxeDHeYn0lVRRPPyWoA7SJyNUCpFipQyLymLEillWCouNbUpsI3DrNfPqKqwA8xoNCaJYzY3NhkOBwyHA2pjKG3NZDKhcpZYa4SAPM8pioKyLImUJstSyrLE44mTlMxBbSqSJMF7z+72Nnfu3KUsC05Pz3j+/BmTyRhT5hw8eURZG+699RZf+erX6PUGCNWE9uHPdwuao298o41ba1CqcQj7c6AKTsUgSsoZDzgP6u3nVpZpOsbUlEXJJX1NnC/IinREmma0UYBSSvqDIc5PiZOIwaBHFMUMN/rc2L3Brf2b4Erw0EsyJJLaTPHe8dMf/xjnHO997WucnlYzzTXtbxMnPXQksdEpSEXSLAQSM2eE53ygnde3rmtqU2HKiqoO4HouITa/5WKFd3hTU9uKssgx9ZTJNJ/BXxRHzc45MdIZhPOYKj9P29v8/zxySkKsIIo5m4w4Pj5impcIcW5lGbdJtnsDahMWazWLwQJeFkBFohW3bwwCqAqFMTasAhZQ12HFrheAEvT6vRlIhD1FQ12kFNgmdvp87mv7hr+AUc55HJaqqhj2e9iqQCmNkk2ul3ZynGMO0jTh4NEjDg6fc/v2HX7u5/pNPMBi62oV2MwidDr9f10nanv9pfL9+XlSSkK+zMsZbZb5oxbVs6UMF/HbZVXywQcfcHxyxGdffMb+/k2MMzjr2Rps00/75NMpfRnzk08+4L233yXLstnYuuA78J7xdMxP33+fvM45Oj5kkJ2/a++7vX79+i+T1wLcvQNbCCwlkZVkUjIc9hFCkRcFzhoGvcFMC0vThEpLjDH09m7QH/SxzmG9BRwjmzMqCorphCiKsM7z4OFDrDH0+316vR7GWkYuZOjb3dtFCEllKo6OTrG2ptfrMR6P+PTTj3nnnXe4desmR4eHlHnB+OyMW7dvY63j6cMHPHrwkHe/8h733/4KWa+PUCFP+SJNwjnH2WjED3/8+3zrm99ie3MbvGIWLRJGXhhMAooqTDah7zV89RUD5ZIW786h64IjtgF4KXXDcxLGuxD00gF1fYJSgjgJaQkUPkQVBT0TBDhR4XzY6BnnOTk6Js8nfOsb32CQDrFUjMYTyumIk+ODYBUoTb+/wXDQJ44iIukwtkBWYaLFd9YLeKgqQ7+f0d/ZaxznFy2f9lxnDaOjLzBVTV2WHB2f8ODxI54/P2Rra5s7d+7Q62VUdUWSxAwHGVkSg2s2CRGBNT0PrReAwjuPqW2Io/eCXtbHWINS4cS6KLG1CaGdTRbGYHWJhq/24MIK28DaSlyzdaGU0O+nSKk5MyWTMgcpGPSHKKWRNCt3vQ+pCKKIJBEoVaM0IT7f07FGHNIrpI6CdStabtkTpxmTyYg0S1CXCQEg5J+/99bb1KZA4pDedhZ0nfevRZZidzXq/HmL+ukyAG7/zedDr6qK8XjMzs5OQ1e0ocbrR5DM6tMOgXbLzLk6uWYl8ZMnTzg5OQmpmUen+Njz9NlTclNhrWXQ6+OF5dMnn/HJg4+x0vGt975JJMJaEDrKmKsdT549ZTQNlOSnX3zO1tYO24M2THl+Y+5zZWfdNu3KawHuUkKkHNZInBA4rakArSS9rQ1Us6FuXQdt1zmLkgorLNPphIODA6QOuagn5ZSJq0myHkmaYsuQvXBjcwOaLeGiKCLb22QsKjZViqw8Tgo2NodkccyTg+eMx2M2hxskScLnn3+Oc440Thj0+5RlxXQyJYoiyrLk+PSM05NTPvnkY9756ld5772vBe2yofbOHTiBYnj/g/d59PQxSku++53vksY9ZjN1y/tJwcHRIT/56U/49s9/m36/z9OnT7h35y6qCcVcpEoZY3h+8Ixb+7eB0EmPj59STk4vAjvMVAUpJWourDRJeyRVEvhur0JyMG8DuLZav29WtjY+BQ/ESdhsQrQcJKAEOFPSjwRpP+NsUnB2dsRkcoJWsvF99MiybXb3EowpKco8lOEcuzs7/Kk/+atkcYwUpgkPa1RXf96+1lqePPycDz74iC8+f0hR12zubHH/3j1u3bjBxrDPo4cP+fyzz/nKe++w0X8LcIHC8SKkJEBjXOvAAyE1tbM4oVBKk2YZx8en3Ll9C6lliJl3Booq7M8qaPy2nXDAGZnLzKkc+kNDiUeCwhtyUyKkQEdxs4WboXaeREd4PNYYnK+oSoOKXJizW6OnceC20vY129D7gapfHE0ye+dJTBTH9AcDzsYWTN0JB+5y1P4SXx6602Xg6TpKu8fbOi7Sos/PC3x4XkxxzvHw4UMePHjIL33nO+zt7TULxZvVoktkvj6u8ZEJ2S5Yu0h7dOtUVRVZlrG9vc3B8RG1rXl8+Ix4kEGtKauSzx9/TlHllNOc3Od88vhTeoM+7955m1ioWfnehy0tz85OGU/GKKWJ4ojJdEo/ScP6nTkrKlTjsjXUHr1qOnstwB0UQg+obIEzFTYWxF4gRUw+KRDCU9clpmoWbuCDtqkFcRwxnU4wDoZpConG5nWjZYFpTMpelkJVY61FDxJcX+OLiom2KO+oFdiqoJieYX14sc6eNjsLpeR5weHhMXfu3GY43ODg+BglJePJmGmeE2lNmU95/0c/5Pj5M7797W+zsbkd+FJEACohKOuCk/IUkcKz06c8fPaQd+++i5Ia33jVPFDVNR98+jOenz3l+fFNRtOE3//J76O15M7+bcLSIxngs1244j1fPPqCTx9+wubmBsPeBraq+OmPf0g/EmxsDC8AS/jgESpEmgg8qrYkWYKIJNbvoZUhaTq89R4dxyAUECG0Jk6HZP3tkANeCu699RbT6RQdhS3iJGrmUvRNAnQtI7LUkyUx/SxGeIMxjrPTAyaTAhUrknRAlikGwyFJklNXoW/4ZqsoT0gXEEqWSCeprSWONO++8xZv3b9Lrz9AKMHZ6RlFMWF7Z5Nv/NzP8fPf/HoIWRaB5bQ+obYhuVlVVnhfESlBmmqc8JQKiMEUhuOTo2AZFAW1DZt/60jjN3rYwqKcm4HNDKgW9PgA7IKbt3aIb2yRVyEdbzxIgrbjHLk39JMIL4JFmkQyZNWUFuHAG4+PHJ6OleA9TgYtv6yqoD2Khu8VsjnLddwUjQaCD+PPCczZmIPDI6QXvPvOTRCaeeRZpj1ehxO+KuqjXU38k09+xMlkjJmUVKXh4cMH3Lixg5hHwwX1WHgPL4O1jESIkATustPXkOdjPvzkQw5OniMiRTZI+eCzD5mWE/qDAYPGvzetctCgs4hxMebh8SNu7+0TRb2ZJey9Y5KPOJ2cYrzFeSjqgryeUtoBUgsU55PBrC6d8M5gpbTRUR5WTGrw2oC7R0jP9rCH70vGriKVCeUkZ5oXDcXhZ+t+qio48NIsJuv3uXPnLiqJEVpxODmlKiu00DPNOQxiiJMY7R1lXVBOKipnkFKQJDGjyYg4jdi6tcfJo2MA6qpmmueMx2Nu3bqFkoqTk1OU0mxvbQEhPKqsDVaCjyTeOp4dPeef/dY/5969t7lz5w46itBRgowUT06eMrU5uh/jasd4MqauK2SsLwQ9nJ6dcnh8hJBgfc2jJweMp2OePn3Krb39oEHPHErB+B/nY97/4iOQjnE1pd8bMhxu8uf//P+S5w8/4/MvPr3U7hAiMZSUYcGOdxRFiXMCJcN6g8FgEBI14UnS4I9QErZ3b5H0hjjniZux8d7Xt88dwY1DkmkO2JmGr7VG+bDUu6GNiSJFlsXBke4dphxzfATPnoLUks3NTQa9TZI0TKJ5brCubqbCcy2+zYMDgauXSrG3t0d/0A8OY+PwtjxvaBS1ERjvkM16hjiOUWJGqASr0RhG4xH4kGrh+cHz2W2Hm0M2hgPIIjAWURp8J7InS8Mq1qKYtGp9k2HRkSUJKlNMvWM6mVAaM6Pfhv0+w/2bYVclZ8FPkORsDiO8UAgVUi1flED2Z1lE4RRd1b2Fry4N0YU95yzOSYQMXPN0VPD1n0svnOj84g0y1uHRL2jqM4dlp/hZEX4WSHB4csTR9BTrLaqn2Uh7TIscYwyxjrhi/rhw3/be1lkOnx+wd7PdvzfUx7f18uF58mLK8ckRzjv6vQHj6ZjBxpDtdAtjLKenpxRFwWAwCPntG7OtNhWVKXEqbVI6B0uwqirefuctjsenSKUpbcWHn30E3nP/1l2UDmRZVztvJ9X2MWeho+3AWSGvBbgLAGepTI0xisLXVLZmGCcIp1BxzOj5MZOTMUVZEMcR+7dusbO9xWg85uzslP5wAxsrrLNoJZvl2bKJBPN4KciGPWocToGgJkYiI0UlPFEchXBDH7G9d4NyMqGc5mF3eh8mFOcMtTGcnB6jdcg6GMcxw+EQkcaU1nB0cEAWxQx6fX764x/yyUcfoLTAS0/Uz7CppLQlrjakKsYaQ1nXKGWRTVy0tY6j4+eNI9FweHTA0fExzhmKYkqZF/QHUQCJBqRqW/PwyReMpieoRDIpzzDuBs4Yfvbxh6RyeX4bRLNniAxAH2uJMWBlTFFZnPMYWzXWjEUohaf56wMYB9wOaCelbCaesHAH0VnQIs5ThUlCKmGJv6CRBOpMsbW9FSKo6pwyP+DBYYmxPiS2urXPEElRTBG25nyD6OY+gI6Dgxsh8TrBigipLMLXAT6anPZaa4R3AdiQCOVpvctSgFKSvK4RMmxvFzUTom6AwRiLy0uEjBpr5ZwWQQpKUyKQs1w00gdlxguBa2ips8MjrAs5cnSzAMhZi6sNXkUIH5LA4T2WKjxXff4KZ0vPZLuD05idftgvti6L8I7aKKBl49ArdJSg44Qsy5AiCnmDvKf1FszHpsM51z4fqruwv3U2he68rg691Hz1YL3n0fEznp8eoZVikPapy4qNzX1eRFolbzI54/0Pf0Rpcu7duY8QMJmOSNMM5UPbl0XF4eEBOEsURxgcUZxQjysODo6wxjAYbnBje4coijBVSNUspKQoS6ZlwXa8cf5ehCBJEg4eHjR7CBSIsiROYg6PDrixvUMcJRcovdAs7UQsmlQa4Xe1lFw7l9cC3BGgYo2TDovD2LAZQJV4auFRykMvITGOvf2b3LlzmzRNEEIwzXMqayg01HUJQpAmSYiCMAH4pJJ4PGVdYYXHShUATUm01kynU2ZLQQTNsnEYDMIWcdZaNjb2qJOK05MTnDEUZUFVVSG2Os1wUuA89Pp9qAxlWaK1pijC3qTGWQbCo+KIui6wlSXtxTx58ph8VBDrlCiKsSZEThyeHIP3aKU4PDpkMpmglebw+IDv/+h7xFFCEicM+kOyrE+Uxjw9eoaIBF44vnj0OTv9fZ4+fsTT4wM2Un15om8OSCmIogRT5xTWsNlv9oukR2VuNwtgYJD0yNKwa5NAoDyIkNCdkAFPNHw8DR0VOqdvCcKG04y0QinRgFg76TTkuXezDtzGn0daEvV7DPtpw8HWfPHhR5TGsLV7g73dXbIsRUwn5PYIZy3ehpuKBjWEzDg4PGZ/e4DQMcYLhJs2uWtEx8MmkLL1FgTt2tmwmClL05DfxUEUaSIVNiqpbQ1JhFMaVRm8DRudCAdHR2OMU6RZL4TnpjHYNjeMQ9SeWlT0N4Yk1pOXU2KlQ+bJKKL0jsE5tjKn686xEk1skmsucE265Zl662kjby70Ad9eLdjeuUGcBIuvqip0HM3OXhbCeHB4SBRFbG5uroScEO1ykS2eTfYXLhQgHHk+5fD4kDgKi5pMXWHKmoPD5xwdH3Fzd+/SRDIflXM5fNDx+OljDsfHxM8ec3Nvn6oq+J0f/g98/b1f4M72Leqy5uD5c54+fYIQAus8SoiAE0pwY3cX5xxxkhLHIQeW854kTamriul0wtl4zK3+jVmI73Q65aOPPuLBw4cYEUK441g31qHj8OgQ4QQb/Y1Lk2J47eeml/e+2afiXwHN3TlPSY0aJkhvSHUaAFYHdrAuS3rbPUajM5599CGfffZZszw8aEfbe7tEGpJ+D1eBMTVahhWGHo+zYISnNh6VRXgfsiAKqXDOksQRRVlS5TV6kNDf7hNJyenRKWl/QKQjxtOczeEGaa/H40ePGI3G3Ny9QZImiDhiggm76MiM6mxMpCRVWSCVoqhrdC/BR4rahF10vPLBaqgtR6NnSGvQMqYsS4RWWBTGO4RqdgISYbs37z1uAoWpqI7GmLwmSzNu3ttnZMuwSAaDGXo+f/IJn3/0cdC2kowLziPOnaKingYAsAZcjcM00RyghAMnkV6SRRLR1EFIqIoTXO45OT4BwkQZNhJWqCgKuVpUcIqGOGpH1ORoCWDf5BpvdRPRgmobARLAWYkU601Ta0caa3Y2h1S2pipGfPHpKc5LkrTP3q39ZgHaGcX4LGiKzWIg4QNXj5MIUeGaVZhCSJQFRKAkhHAgJE56TKoRQiJNTexjvJQU04I4imfRMgqN9R6nBQKFN6BMoKaOTyecnFpUNGa4qbh1ax+sZ2PQp7IjvFJ4oShHZ0zzHOssU2Mpy5Lbt28hBwMmSiCTBGkUUqZ4DM7mASidxXt7Dpodqg4Ie7A2FoP3tm34C+NP0IZXhp2ppI7oRTFZX2BNhRMh/rqFyFn8thA8evKI7/3g++zduMF3f/GXieY2uA8SJhshPJWxqEij2g20Z3OUvzBfVcbyyaPPODg5oDA5Uiq2+pskSUxRFTx+/jisq9DxjMoQol3Zeu73mD1jA/LOW04mJ3hgWk4ZTU45PH3O0eSU7//0d+l9908RuxA8YL3FS0h6CT4Sgeqt4Ww0BiHoSYltUv/qSKOFYNjvIaWmLKfk5ZRe1sM7x+HJIcdnx3gZ/ITeB+sgjmPKusTikTpqDN52wvXUdcHB8RH7ezfD2FB+hmvG1KyS1wPcvUPHisrVnI1HRHFMnCYgPEkaYRuNcLi9yZCE4WBAFMeUVUVdV6AlIk2YFjm2Mgx6fbAW6zzWO6RUIUbYOZQQqCRGu/BCnLdMphPihhO31oCOSbOEdP8WT54+xnjXZOwDJRV3bt/m9PhkFsMrmpWDtQ2TinOWvCzp9/qY2jDopaQ7G5DFjPMzkjShFBWWFrwlmoTjozO8cPSHfZBhz1I8CBU6kfceESksjiSN8IlGGsj6KVY4jK3p9/ugPGeTEaayFKYkixKUVguigQEE3lvkTCsMMdpuZha2cftNrpSZ9iA4PHhGXdc8efwkLK5xbRIvCRKiOGZjuMnGxmazMlKE5CjSQwP2gYaZAxwfOnjLgRa25ujkjPHZGXfv7hOroNlJAUkcsb3ZQyvNaJLz4c9+glKK7d0b7N26B7ZmPMmDhZWk7NzYR0URZ2dHFGcHtBkm6TwtoXYo60MMvgp9xTiNsiFxVdhqThNFEUmSEGkFxmGkJxLnVkxdG/KiJhYCFcV4EXLYeOFBK86mBUVliLMQqTIajxiNRighmZyNGegEFWcIbylMSERWVwrvqrDBeT+lzKezibHxoqB0jKlLQohtsMSsrWfW0wV873w+z1Wu8PZ8pb8nrJJuc8Y45zg+OeQHP/4+4+IE8yzn9vPb3Nu/c3HTlfYWImRU/PjzT9nd3+fm5vaFeweHoW/6I9TWMs7H9Ic9YheRJhnKSVxlEMCzo2fcHt3mxvYestlYZcYMrpDRZMzR8WHg7NMELz3j6QiLZ5SPefD8EV+79xXiNMZ6j9ASqRVWwjSfcnh4RJHnSC0xzoZ2NQaldbM+xpJlGV+9/Q5ZlgEwycc4b7ixf4PRwwmT6ZSiKJBIrLEhP40MazCeP3/OjRu7eB+sw5PTE3724QfEUUSaJERac3JyTGkDe7BKXgtwD47JYNonSUxdG6YTS9bLiLXCK4mxlqSXkBCD8YzHYyKtSZMUlcZUwtGLEkTWR3iojcXDLAGUtx4rBcZZyqoOg8ybxjmoscZijUU6KG2BmZRkMmNjY4PK1EEDAvKiQEhBvL3B0dEJN7MUIT0SSaSCCRsPe+ja0UvS4DRUEhcpcleHLeiaZGjWWHpZD6cUzks2t7coypJRUVI7y3A4wBFMOq11yGrpLN4pTO2J0gQlYmSWMqkKSlOhVaBynHDUvmJrZ4M722/hygkno/xS7/eAF5IKEZKC6ZiqjBnlR2gtSOIIJWUzabVRGQEApFBsDDOSKJ2FmIHH2SY3OLC5GWJ4nTHNr6LZKs5jnCfWfuGADIuSgvNyNJ7yu9/7AVJ47t27fYHHDB9AKuj1Ivb8AOcc09ERP3ryiDjtcff+Oww3N0EqdJoSJQliUoQ0vhhaxnrGWEiBFzL4A4zHV5aDo0OSNKYuK/r9PnEcM52OOTw8JEmCwjGI4xDlZR3SBn7UueB0D+2lZ20uBIjaIb0nG/YwzlAUBQ7Y2dlBN4640hp2CYoJQoN3WGPRWtCujehOjcIH7TtOQi5950K6X984+oRX3Tn6Ul84O3lOnk+IoxQlQyis8J3yZzSHZzQZM5qeYWxNXlrOJsfUZo9EJ3PGgUB6ycHRM37409/nfn7G7nd+GdmkOg7KV5PCt+0XccTt/X2enT7HVobj8SGJSsnSjEme4xI4GY/YHGwT65DEDR/ok6WRPNbx+NEj8iJHa8XB4fOwgEw44iSjNjWPnj3CloZMh3eal9MQwjiZcHx2gkCyublFkqYkaUQSx+CgqisQIVVGlCQ8OXxOTw3YG+6QpX12NgWPnj8jn+Z459jZ3kbrqMlzZDk+OqQuKp4+eczd0V0mozG/+Au/wMnpMUWV83s//X2ElKRZyngyDlFaKFbJawHuMtb4fkwxHaGUpNdLGU0m1HWJ1grrmq3e4pjxeML44JhEx/Rv3CDt96iEw7oKU1tcUQRL31ikl2FxkwOkR0cKU9c4D3EvRkeSySRnOpmGSIsoOCmdllQYYmNol0tbY3j44AF7N2/S2xjitCAa9hmVBYONpNFcg7+g18uQ04peLyWKE0rvKGNPkY/whCgOU9f0eyFtcV3VeOeIkKT9HmUBsQ5+gboKiyV0k1tmOp0QaYVOE0Ts8N7gpMMLR5alWB9y5yAEKg2UQxKllGV+TtnOjexp4Tk6PmRzGEIlT04LfvSz93GuZmdrg7qquLF7g7Is2L2xw96N3ZCQSklEFCGcQzqHjqJZUjDhBUkcIxVMJxOg0ToNHJ9NOD09IUk09+7cuFwhYBbeIQRKBnpAqBAz32WdZ/HQBB5SxhotNYPNlLtxhkVyeHTCFw8esb29w+bWgNT7sImIUAgMSgiclCAVUUNjeOGwAoRWaCRJHHN8fEqRh3bs9XpsbYWJqygKjLH4TOKlxgqPqw3SWFTjMJVK4VzTl7zDSY9LNFk/Ia8qhFUza6nX7880ZCEkORalLXgFLqQiECrklpmtaJ41YdCaR5MS7wVRlAbqxlUIAWmSgbAsanOP54P3f8rhyRmDwYDd7RvcvXMXOjbfLOLEOsbTCV5AkqR4PA8fP2J3uMfe9g20VueKhPeMphN+9P5PcMJyfHzA8fER21s7RFE80/SFaDz7DnIz4enBAdZ7sjSjl/bwFnQcI7XCCcE4n4SFi6JVBrgE7F2AbwMCojRhMpngq4IoibDOMZqOERJGYsze9j5379zh8PkTJsaiophelpH1M4q8pKpqYqmwecV4Ws4oK6UVutdDSkleFTw5fkoaxWihefD0CbU1YetHKTA25MtXQhEnEaejk7B3bl3wyWef4ErD9tYWBwfPMabGuKCIlnlObWtsHSHqFVk+eU3AHecpxznToqCocra2tknSdNbBkzQNaXm9QPRjZD8hjXoY7zDOcTI9IzcVCkGkwvJyj8S6kItbS4WQnto6VCVQFryvyKWjKisiFaG9IOuFLf78pGR8cIKRBWmvF5IZKcXO3g7TKieTAxAw3Npo8sLboL1LhSbQEpOywNV1yJ+SJdRApDTT6YR8MiVWEaqnsaXFVy5oWYmmNhV1XeK8JonjsFwcwXQclvcrrZEqOGIsFqEIDk6lqIxlNDrDSUcSx3gL0SDFW4s3NlAMvuW4W547REnHUeDLnQ2hgIPBkOn0hCSJMKYiLyfUJkTvNMYz4EN0hlSNDyPi0ZOnCCTvvvUWsfJ4XzdUR1hxY52nNBXIEKE0n+FRiPO6hbj/hrH1jrp2TWKp5uQZz+yQwhNHMf2teyGffLPQy0uI0wF7xjKZTDg9OWV4byPs1Stl4zwPXLW1lroyxELipUMhsJXhJJ8yno5BwObmJlVVU5Ulk3FYjKJ0FCwy58EYpHNIF4Z8XYVUGmk2oCprrLENzQUeST4pgyWpPCfHx3ggyzJ0FBFFwWpyUkAk0S7C+wglQpZHpJ05sJkRX8GBfXIyBeUZDPsMspRqWgenuTVEuqHfZrZW0/YI7t1/i7v3JVUdksC5YsSTx59TlRIvJXs3b7Kxucnx8RFHhwfYOmzlZ4zBVZ4nT58w7A8YxMNmy8Lg1/ri0QOePn2GcZYsC5NXJGUn6iPM2s45xpMJnz78lJPJCB1HVHnO0dExcZQwHG42zn/Lo0eP2d3c5e5eoIJCPzl/mnNcD3Hmpa2xAqbjKXGSoKKwcbk1lkFvwCSfMM1zTs6O+MlHFWf5FFNbpLQkw4TKhWCH09EZPs9D9JwUaCXZ2NwMi8bGY2JTE6mYjWTAwycPqGuL0pppPiWwFKGeOgoZj2pTY6wlI0Rmee+wwvHBZx9isSBDmGqImKpx1mCsx5aLidZWXg9wF4LcBs/8zrA/22bPmJDFUUcO60IO8ayfEu3uYMclpamYnpbU1pKlgbM0tWkyNQoQMugxPgQUSSFRMgJnKKYF0zqnKoI5tdnrU0cV5bRAlY5hf4gUEuvtLMRrsDFkM1YIQgSCkBIdhZSw1jpKY0KHQdDb2mRydIw9OaF4XhPvDNCRIiMmTRXSS+qTAksZAC3SgeCMFGkSFrJIpZicnHF2dkaso1mEkLOOOJUgNDrRCBcWPRljEUhiBKaoqX3FlCmfP/sZsa9pfVjnEnq/1oE79g1PjNT0en2cmxDFmtSFzUu0VrOFPy24tyVKH1aIfvHwIfl0yu1bd4h7CuEdCEeSRFR1HZyXShE3i38WOfjmOgemydli6pLa1Kg4On+CNtIjvG50FKiwCyv5fHACDodDbuxuB448ysmbZwgOdt/QGH5WqBcCqwUikvSHYc+AuqyQolkTYF3odzJMXFXD47rah3BHBxvDPrWNkUpQFlPyicJbg9gahA3IpyVFUeG0ZWtzEy9CYjzvPXmeA4GmSZAhXNO3oYgzL+lFsrlxxHkvQjRGw7dLFRGngXqIs4g4jlBSzfaM7Q8t1ofQ1V7S59GjB3z/n/wT/ld/7pu45z/g//v+iAeTmu9891f4pV/6JdI04e7tO6RpOsuxo5Tm9v4t4iSajTlrA92kpObt+1+hNDVSSkxlscYR8umH8RWmWQe+pphOGI9GFLYCY9je2CSKY5QQGAuJDhp/ZU0AStWUMVs525p4TYw7gtFkwsHxId57pkXBQA9oc+3neU4SJVhrOTk+4sQchrBfB8oa8lHJ6fiE09GYvCgZSEldVZRKEPV7F9KaVKYGPNPJhFM7wlSGSEWUVcFoPEZIQZQkJEmMqWuqssY76GcZNJOQl55plSN0oJZNWSKVRuskOPKdQ8l/FRYxCUh7KaPJmJOTE+I4pKiNk5goDs5A4STCBQeHl4HHvLG9i04TxlVY7NS+WOfPNzOWqIbXCyFHxlQorUiiLKQ1UBlKaCbjEdIJ+hubHEwPwDg2+8PZGJJCoIVBWIvwowbcZODYXD/sxOM89UgwLmqSNCPSmr3tXQ4Pj7HTChlH9IWkNgEYhNKEjevCC8zPRggBmzf38MZg8oKejkl2dpFNDLrDIaTEVgbjDUIovA1cZRLHQT+uKpASVzjGxZjxyYi7ezv05GKOTkqJbnPFE7TkXtanNnGTvC1YQ8acxzK3tIlzFt8sMpPek8Zx2Cmpu7TbByoqOE/Db1rrCxs6zKI7OitoW8UrLKqCujJUpSHtgLuYYVwAZdHZuLgD7w110ay0Ne2CKo9qVvoC6FiSaIFWDisEpTMgJWVRcXR8EpasEyinliMej0eNZibJtSS9cxulZRO6KHj7rfu8/W7YpMPYQCHUrsbpkEBMqwytBKdnR3jvMSaAYa93vt9tv9dD9VJ0JlAVqCrkpInjmMFwgyTJ0EqjdUQchTDKez4iysKm5okOConUEUKq80RVtpNtUUCNB6GRDrRO+NafPuRPvpUGymok+L9+pMiyjNPTExCWjcEGG4ON8wR3gELgqoq8MrM5RwrJvbv3uHv77iyXPUCeVwhRNw58FyZW4XHOcH//HoNkSH84bPIJ0ayn8DgcVVVR1jbw+52c7jOfgG/7gGcymeC84+DogMrUDDc2KeuK0dmIXq9HmqXBv1PVxEkSbCAFsY7RsaIwFeVZSSQi9vf2kbGkODrGW89JWYSd24RoqxEcz1pRVEXwMeHJqyllVWKMmWnsuJC0zxpPaUqm+TTsOxFLbF2HhXS2wltP5EEYD3WFdw7nbGcsLpbXAtyddQgf4so3NjYQQnF0eIT3IJCYqkbHGltbTLN45sbWDhu9AbWtib0kyfqBx5pOMfZ88AaM8SHRk5cIBdaEcCJsAJ2izIm15tFHX3Bjr8JUBVpHuAzG4zHeObI0wxQh6qauJWVZEvdisiwOA9UrpPBEGKw0xLGgyi3HJ0ds7+xgfdgZKo5iRtMQilnYglqEsqMsIyIlH48Z5xNSIXFlTewVXkryoiDqJSQ6whUVFR6pJUKDQ4ScPJXB1RZhfLBenMci6A8HJGmKXxI6JURYCyCFaNhVR5b1yMsYIcRsO0NrbbOKLsgsMkNqnAchFVnaC3t+SgBLmxrhfJGTb7L5aZRatLnBecmtJEnMN7/5c/TSmMGgxwz2mxngPIzbg7cztsaaGqzB5FNAATpkkKQFCodwIKXBiyY8VjiMs+DluaOrNiRJjHWONEmQzUTYRo/Y2gYHuTfYqka5xoyQEm8tmNCqzdYbgWopCqQCYRymnNLr90OSu7oOkRRSEseh/afjMdo5VLxJWVnywpCkiht7e9zcDStYi7KirmqMNdjaU5kJJ+MmD49zjM7OKKs6TE4yKD91GaxWrVRIq1zXWO+RPuTR+bfvZHhfIEoQZYEwih/84Af83g8s1lYoKYmkJIrjWeSYijS9fo9eb4D3DlPXKKXRKgqxSEIw6A9I07RpQ0kcJyRJ0JrrukLKkBF1mKQkUqPjNIRotpuBCNckUzvvI3VdnzvEvTifCJynqixCCu7fe5fNzW2qumI8nZAXxaw/bqUDjDPUzlKWYRMXKk9d1kjn6fkYVIxUEUoLrFTEWUq2s81odMrR4RGbdpN+r0caJ3jjMdMq9BUJ3toQracVaUM5O2MDVrmwA10Uh+0fqWsoS5z3pCoiUTEq0hRFwaSYYuowCZ1vWrJYXgtwV1IiZHAQlWVFVdZkWYapDOVoGnbCKQxaarT1aBHhrOXw8ABjw8bBkQqLSjKp0crjlaAyBmtCyJxUAqzHO4PQerayUoiQoc8Yy/7N2xjjyNJ+iF/3IsQzNxZeVVdYa9BaUVYV2XADa3WgejykWUIca5JqSmVL0kRTTKZM8rA588awj1aSyXSEx5EqjbM11bQgQbExGBAnCdOixqYaLSCTTTinckCJLexs+y2nJE5HnE2neA+DNMMag3YhpltgG3ZdolWMN2FRS7u7TxsEqKQiShK884gadKRR0YBdeRso0TqsvMzzaUg/AAihGGxskqYDQDZ7VEi+/o0+dV0SpwOcsOA1XtTQRKUIqYjiGLycrcQEOPcKNtFNs8Uunr3dDfZ2N5vj9SylRhjMTabL5knz8WnYLNsbvLUYUzEejQCJ0ilbWz3U5kbYXrGs0NpjXZMSWRAWZnmFabT/LOthZcloMkVHEVmvN9spSGkdopiaRGO1CZuJ10KgrUN2UjnDef50H0hzPGCEw3qPraoAAM2OQ/iQK957z3AwJEpTRAjloizGVKXi008+5/OPPsPWddB8bdjoAgGTaUleVcRas7uzhamDNWltSRI3dF4WNdFkYSOROJYYC0pnHJ0c8w8+rfC1whZTfuuJpxaKCM/e/g2KKmc0HjHxFleNcd4hESQqpi4sp+MTtAxZXctmS0sQVFWIPIt0iHXXKiKOE+I4xhhDXVcICVHjc4ijhMHGcBbOLEWIEx8MB/TTHrGOMK7xd8WBbpIiKCpKKZQQDHoZ7crnQXorkD++id33EPYqbVb/NrRX2H7ThOAHE95tVVXkRUllStQwrDwejXMSNM5XqEmBKTxGNk7n2pKlA5SOwAk2B0OEktS1wZia6aQgSRJ6vWy2GY1vdpeKewOUlAyyjHpaIhCUpiKKUgaDTZxznJ6ersTVdfZQTYF/DCTN+f+l9/4/EUK8C/wdYBf4HeA/8N5XQogE+NvAHwMOgX/He//pFTfBeIs3jrIIYJIkKYn2lEdn6NKEDHiZxuKQwnI6zZmMR/STjF6aYeqSKI7xZU1EGDyFMVjrkVqHDRycR8uwH2hpK3CgREhOJXxY0musDdRPCLlh0AsmW57nHBwdsLm5iQMGm5ukWcbz5wcoqcmyjGG/x+nJiKzXYyMbMs2npP2I2lWYYkxVj4i0RamcJPMIaYmLErxCyxHObVDUAxASC6SZR/knKFdjLCF0KjF4p7FW4H2EqwxppIl0jHclUjocunG+RmQ65e17X2EQaeqioCyLkErBW2Sz5ZDwCiEUtjLN4ooC42qq2lKbSZNwLGi0renphSTpbaF00mjOEuugv5GEiQeHxeN9ihV5EzvtGo22ccm25nOHcj/fuyjE1gcONkwMIQbfBSrqUjSExFnH6PQJz58fcHBw0ESxGLI05eb+TW7s3gRvcM5R1XmYAETriAxLQGskpfAUwmOdxUrBZDpF6UB3TKZTYq3DTkxFEcAdP9uHV2U9nFTUqQqO1doga4IzWxJmDxk21Chqw9OTo9mS85ZWlFKiGr+Bc47JZIKSkrQfIZVndysjjh1SxqRKUTWOOppFX97D1nCAaajJJEmopCfJNFVRkjYrhJuhB4TlB9570rSP0ANGkxH//Hu/z48+G3L71j5RlOCp0LGmv9lDlB4fhUzqeZ5T1yFNdhJrYq3RzSrMtOgFZ2vzBsejCaPRiEHWY5hkeAtbW9tMJ1OUCmGak+mYoiwZ5xPcZMyzg+cYY4NFBU2aDhHGstJY65tJQpNmKb00JU0SNjc3AsUbaWRDA0ZR1GjO4Xvwz4XtJIUM4cxtf2r7V/jXOvmZhbY6woRaFBVVOaUqC+oaTk6PMKaiqoLPpCjKQAtLQV3VlEWBdQ6tVQiwyKckSYyWkjhqFsQh6CnNZDxlOppQl8Giu337NnVd8+zZs1kOpWWyjuZeAv+m934shIiAfyqE+G+A3wD+T977vyOE+L8Afwn4m83fY+/9e0KIfxf4PwD/zqobOBfMLKFlMNdkANc4jZHDPtXzU2ItkdMKpT1Z1qc/2GAQZ0RxTBrHeGvo9wecnJwER5QP3JdrcryDCtSDjvBSkMYZWilipdBSobUmThKMM0zLnNFoDAQnoUQQRcFEHo1G7O/fIk0ztIrY3NhqVjmG1abDjQ0+//wBb7/9Fjdv7lPVFc+ePmU6yYkijZCSLNtAWomzOZGeImQdVkzKirIqUTLGWkFVWyKZIFFo5ZEiQqLxskTpKrB54iQk7fIRSEWtBF7GREkIpezFAx598SlJlDIcbOK8IunvkGYpaZyRxEnwxvsCUzvqoiIZhCXU01xRVCF6o6oqlKqRUuObyBeQeC8bn167q/t5tAu4NstsAzzhF+lFE61yUbNt5cLy69kpnu5q1va67rnBCR9CUd955+0ZrSGgceAmaB2cuJFW+CgipPxVYZGYEBRCUjXOe60Eo9qQpinDKEZFEc4E525ZFkyLgixN0UlCFGnqumYyneCUYpMeqln9KuKQwEvYQJlZEVY+CiHY2t7GNStStdZEWs+eK0mSkF+orMBZinxMJDRp0myd585XLYdwRQ+Nw9vbAkVIpWDrItBVzabd5zv5homgdUB7H/YtVsmQnZ2bxCqmnOQ8evCIja0ddJrhnWN0dExtKpCCvC5ndZ+MJ9goJtrYDAu0RmFBolQKYw1FUeKlYOvGDSIVdjwTxnJyekBdGQa9IcONDbZ3NjgbjZg0qX7zSYGOI6JeGiz1kDKfPJ+G1NoG6rLGexiNz3j65BHO2tlmOM4FP0yShjj5wWDA5uZmmPSqqsnvHxFpTW8wbCaBmF6/12xwIpGyXX0twxabNFq2FKRRD4ZbHUR7F2tdExASMtFWdcmkmGK9pSgKijLHmJrJZBzyzEhFXVYkKiMWjjKfcnZ2jCI42J8/fw7eM9wYcnZ6Rr/fZzIer4LVtfZQ9UBbStT888C/Cfz7zfG/BfzvCeD+a81ngP8S+E+FEMKvShvngzOwtgbnLXVZNmFRKdo7okhjq5qz41N6vT6j0xF5ntMfDPBAr5eFPOsnZZP/ITglUiuImsxxwguUbBJdGUsaa2IVeE2tFePJlLzIGWxssDHcIk1DugMBDPsDJtMp+43JVpYVvd4A5zxRFHJL9HohwsV4y81bt/n408+4c/sWWZKwtbGFrQ0HB4dIpXhSPCNJEu7dv4dMQi4JLTxGSNKsZDqZYKiQxETREOlKEAbrPaZWeBcjWnD0LjgRAYQn8h4hamSziMjLkuFmgjSOo8PPmExzrAlmaaTDjkYCgVQxvcGAOOnhlaK3mbG7/xaD3jeakMXz3CL5dEKRj4mTCO8IawWKaQBaF+KSpZINJe4a3l00GhL0kwihdNDCm+XzbdTGjMmfxctDC0eyjX6YReqE792JQang9Ot2NylD+l6lVchbj7sQW51XJvChpNS1QQgbNOxEEvdSoiyjqkNK4yzLODo8xjnL+OwMZwx9IfBKoWTIXuldjZGgaoeug5KikzTEVgMmFtgocMbm9Iw8z/Heh2gQpRqKMmj3cRpyfUcqRH45ESZTWRukaVYNnyeeufDc3TRhnsD7ziJN5+bPc64rbNqytbnJztZWSPWhoCgNd+6/Hbh1JVE65vnBc87G4xmA9tIM6UP6D2NDcrN8nGMFHJ2eUFUlURIzTDRCa4y3FNMRlBVKaKaTMcaU6Fg3jxUsDxREaRT4+TSmrArqqiTJEuIoRnjBcHNIEse4ouT06DREP7WWEILpZEJVVpwVJYfPn2NM4MPxHmMdzjX+ozisNE3TOEQpJUnjd4qb42mY7Ad9kigK+xfQOlPbdBZhbYaMFDR5cZzrsbmxjYfZXgGe4G9sNyEydUlVFUynI05OThiPRigheP7sWdhfIY4pSkOc9ZlWFVF/sBRSYU3OXYSt5H8HeA/4PwMfASc+JNcGeADcbT7fBb5oOpoRQpwSqJuDuTJ/Hfh1CJEyzrrmn20WMvWIlMb5AhKLczkbOwIpJiit2NpLAYPDIUWNUyF7YzwQKBURqSGRjZiMqyYELzj+bu7tUhUlxtQkiSaKw+pUpRWjk1MePX7Mjf199vZucGt/H2sMRV6ElLPDIaPRiEePnyAE6ChCSUeSpBwdHZElGRsbveC0c/CjH/6I6WTCoN9j/9Y+WZqidMTu7i6PHz/m0ZPHbO5tEycJiVY4B2VV0ev10IlGOo/UimrqKKY1SgeHoKkg0j2UipBCNeGeYXwKIYl0jNQh8VQiMvZ236aYHGPLgliEmAYpwuYkUgTnorVQVIbTs6cUtcFaF2LaXcgNLoQgzVL6/QFxmrK1uU0UaXpZn7yY8uFHP+Phw4doIfnX/8yfIYo81pQY53DOzCgDhEHpczBy0iEb7f98x5+GCyWkDtMywthz64ALID+7AjrfL2bWUzi5ibUh7jqwdudxoVLGCFmHXFtCIlKJlQ4tLLFUHJ2e8fTZ8xnFc3o6Io4jjDFMp1PGk0nYmrDXY3M4JI4irIJSe6zymKqGokYJASoAuxVQ5QXGhQ23ozhGNzRBlRdMphPyvGB3dydYG3FEgmqydzaRSJGE2oHruKB92x7NwzV/lJJ4ZxEEf8z5gv1mz9m2rZwFHxbvbW/v8Mknn+K8Z+/mHoKwGYwzlnE+QkrJ3o0bITIkL2YavJBhQxzbpABRQBLHJHGMkIJ8PKWUORvDIZt7O0xPzihOJ6SxojYV0zI4DXWzOUrpwspx6Tw2L9FKIHVIP+IxeAOj8ow8Unhj6WV9QFCVZbDWkSF/VJWDhHwyQYmwlsB5HxZknY2QSqOajVKOj484OTlGIDDWhEVqXszAvd/vcXN3l+EwLGSrjUE0ikUcJ2GxUgP0/f5gZkVIIQIH30QpeQnEBCrTJcAQzx5vvR3GgLUWU1XY2uCspSiDD6Nd3Pjf/r1/sAS11wR3HzIO/ZIQYgv4/wDfWOe6K8r8TeA3AYbbQz8dTSlNEUKzlGAyOiOSil6iyLZi5FAHbcsGOgBiqspSTHMQiihK0HGMSgKPvLuxS5kblAzJeaQMsbBSgBQxTx6fcHp2zJ07dxonYUjmNM2nPH74xf+fuj+LsTRN8/uw37t8+1kjMiL32quX6p7uWXo2DpchRXEZUaZNkRBtwxYgwbo1YBg2dOcL+cLwhW1AgAwBvCAFGITtGxICJBlch8NlTM4MZ3qml+rq2jIrK5dYz/Zt7+KL5z0nsmq6e4YQaTS/QmZlZkScOPEtz/u8/+e/sL6+ZLGYk2UZ1uZsLi6Zzeac3jpFG8vqekUI0nHNZjOsVkzqknazE6aNGyFG3v7Cm6zXaz786EO6rmW2mFM3DZN5Q1lV5FWONzCmMOm6Fj8K7wQm0KakqUtwKzbtjjzLyUwgNznWZrhxZLNZC3PBWIqyoMg0ZSldINGjgk/PcYIJiHIeEIonWqOsolTik9GU0tEf0BCAIMXe7S7ZXY08e/QBo/NkWYmxlmeffsqjjz7m1q0lVVMxXx5RlBVGa9zQ0223dLsNEq4kBmU6DonqotP7ujEYQ8nDHLVm9A4fBDoQVOVmGLw/1Gfe7OcPhY+Wy8tLTu7fFUzzQLWMoLQAPkbcSTFOqIYBtpsdq8sriGCNxTlPURTJN94miqiTrbyxhFG8ibQXJs4QIxdX1zz95Dl3ThbcuXsLohbujtEsZlMi0A0yPLVKc73d0rUt280GFSO3Tk7El0aLTYWKEJzYPJTapOnGzc+qtaGZNGy2W0J4Ca4RDCbh7GkxlO2ddJ/Rc3H+jIAmKs2Ls+e8/sabHN1aElWk7ToinqvNmk0ris5h6FPTETBa0fU71CZS143YWfc9zosDZl7khCDDW6UsQz9SmIxMachzylpYMeN2TQiRru+x2qJ9T+xzXDfStS1FKb7/xnt8NxLRKEZ8vyPPStrdGu8EOptMJhJSYjRmmuE1ZGMu91YAk+XYXCIayzKnqhqBGW8tGEcxq3POMbgRH+T8jX7kenvB2cVzdMzQMWXFGpOwfEtdV1SVaDmOj25RVTVlWUgCU5bJXNFmhzlAllmM+lxmrNIYm5HbDJVYXlNuPueHWnin41+JLRNjvFJK/X3gF4GFUsqm7v0B8En6tE+Ah8BjpZQF5shg9YcfKjEIgsKa7MBXLScNXT9gQo5qPTbKMNSNgXbXsd2tqcpKlF+65eTeHQbEIa8NDpNlZBiC9/R9l4q7cLGPbx0Rg2ccR4q8oqkaMpszmS949PgJjz95zKefPuXOnTuUZUmMkQ8++JC7d+9yeucOfT/w4rlIg/M859bxMZkV9kHXtUxnNcbC448/pplM+NKXvige2VoJc0ApMJpuHClsmYZfEhsYQqQoCowxbPuO/nJNu1pjmpIiszR1wbxpKIqc7XYDDGTWUhUV0+mUF8/PGIaB4+Nj8ryg79eMruWAU3/uxhi9ph3GZB1gePrsknbYyg6qrPDBU9cV3nuqomZRZ6jgBGYpS1brDYvFnNunp9RNze/93rfkZ8gteV7S1BNu377DYnkHmxmKIic6xzi0DP2WsduKJ7qKBGUEt48C6SgUq/WO3/nmNwku8Au/+LPkeZJQ7TnaUaG0BXfjNa7UDXVuD+vczAb2EFCaAWhFjBawaOfJrEIHsXpdtVuyqiSmTtQoTaWNxAOm8Oq971BEuvEKiW1WIfL4k0+5uOq4f/8+daWJ2oCLFEpjvGK12/H08kJgn2RsF7z8HHt9QV1VorgN8OzTM148O+PtNx5irdgtfNalPaac3o0wctKiKa29oqmblwbUv38x7LqWXT+w2ba8uHhBVlR0ruXo6IiIYvSO0hbMF6LI7HppyJokqzcJS8casiKjD14skRVsd4KR73cofd+TK9AEgnZs2ssUzl5hdMCN4ELLMLSoaKiqmaRe7ZluKHRUGKPoBxjHSIgafCC4kcJalvM5WW5Zh5bt2KEzKBaG8boVvF6DNpaiKvGxR2cKhWYcPCE6tLFEHXFhpCgtZZ2jbU1hc0pTcry8BTHwySdP2Ox6rlZr2rbj2bMrnJfdYFF+SFmWB9fULMtEo1A3Qp0sK6azKXVVUZRCSBBbX4NN9gyZsQIjsffL+tGFHf5wbJkTYEyFvQL+XWRI+veBv4wwZv4j4G+lL/nb6e//NH387/1IvB3ZImc2SzFsEiTrg2O7Wcv2rjKUKMJuwPmItrmEUGvNttuRFxn1tKbXAaLGu8CjZ894/L1HWGX42jtfpKpr2t2W6B0EmM/mUtiLXPjNGIrc0DvPbDrn9qlnvV4zDgFrZVtWVRWbzZbJumU5PaLKazbrNSqCUZpm0rDIl3Rdx9nZC1bX10TnmJYlk6rm9M5tur4nXFxyvVoxOVqQWeG+uhDZbLZpWyed8zDIgLVYNphFJR7pAdquZzmbkWU5k2bKbDKlbVusEpe5+Xwu2+dErXr29BHGilxHTKRubowQI7tdy+VqxWK+ZAwj52c7LlZP8b5nuViy3W5YLOf0vXjMPHhwLxVLhdUyTC7zgjKXAWCe57z64CGZ6nHjyNnliu98+yljEPtdozPquuHu/QcsFlOmx3fIs5xu17PZrvFeZifojKg0PiquVxsJFUy4vFIvGY6ppDJ9GabZF/7PHOnzEs0wfbEMN4M8UCm4kFEFgoJq0hD6gV27ou06Tk9OKIpCVINupChLUMKzJgjVU/BihQ7Qrba4NrK92oEz5MYy9iP1dCr47/U1uclESmUMKiafEm2EkRHFJO/EZAz9yPXZOU8fP+a1B3fIkxr3pakzCvAx8M1vvcsrr7/OtKkprGXsO/K8pG13lEX2Q0qDYjqZcnpnyna74+JqxYvzc9p+w2a34d69V8mLkmbW0PYdfgyHBXQYB2yWgVZ4HwkqUpqCshTHTJ+cNFUQXnlUJG98j/Mju35L1zryrMA50gwiw1qNaQIaj/Nroo2YLMcYK9BNJrRkVbUUjfDTIxllITGP1/GcjJJBG8Y4UqgMO6vQqifELVEPhGiR3HXNaHuUB5WJNcLoOpSNzI9qMmPYXLf0/Y7T4yNU6TmaH3Fx/gQDVKXF5HMiyxTUomF0BCeiq6vLq2RBIHCLSa6i2lqmsxlNU5OlxSukJK+6bsiznPl0Rt00UveA6XSayAE//PjDdO53gb+ecHcN/D9jjP+NUupbwN9USv3nwG8Bfy19/l8D/mul1HvABfBX/6BvsIdiVBRfhaIo0KrA5Eq8IgZHRGGakspWmJix2WyxWcZsfkRWZIRcs/UjKqn8ghcq1na9ZUw49iuvvIrRltXVNTEqFsu5WAxnJePo6fuR69U1fd+zWCyo6wmr1TUff/QEYwU2OTs749133+Xtt76A845J07Bar3nx4gVf+OIXMNZwdXXFar1hMpkyrSoWsxll4pGDoiormqahw+PVKHQ65wW/i6Ko895TlAUmMzgFLgSMsXRtS6NyhmFk0kzIcxkWudEzpET2qq4OmJ/RhrKshL7l3O877zp1uEVZSthzlO13WRQ4t4eJpHBYa1LKEuyVQ/uvf/H8jMePH1M1Be+++23unp5QNZbMRObTkvmsxnmhZ67WO9aba77//WtCDGKeZHPyrOT41jG3797m+OQOVktUYlE13Lp9l+1qJdgJMTF2XmbPyPGDApb3MMS+/ElXL3mVMUFAB4veDAYdcMon+mdMEJx00l3XieikruTBTMrEPM9xg2SqemOJpA5cGzKbYVRJ9CP4gHdB8gUULI+WYl0xDvI9clEF7ymM3ifB2zCwvlqxur5mu93+8L4t1fnNdpcStDxlJo+51kZcEOMBof/clwohdLvpuLi4pq4qaVAIHL91nF5bIvhiiImyLLGGLsXIdVvxMM+1TYwj6TbHXQtphqS1kSKWMGhdFLghEr1Ql/tWoa0hKyuCsnSdQpkRUyhiFgmFYhg7nPdkpcPlYo0dnCX6iM1hNOL5iTWoqsD1I+MwkucZo4dZc5cCzfZ6S/CRvC7ZeEnoyq2l23RcX25w48ByuWDceFabFefn5zSTCdmp5dbRMbmxvHj+nGdPn+OAZjEDvWfmgUETgmO1vuTWYkKYybNvjKUdHO0wir3xbsPFxRkhCOPLB9E7ZDY//H8ymVBWFdoYaTLK4kfW1T8MW+Z3gJ/6Af/+PvBzP+DfO+Cv/EGv+7mvEnc3KzxTk7jPHk+W5wQnZkLuugOnsEqED1kmRlvVtGanI8YUGKXxoxMjqTKj3xii93TbDfbOPXy0+Kh59vQJ6rkMII+Ob7FrO549f453nrbvmE6nzOdzyqZk027pu47ZpMYNAx9//Ihvf+t30VbzzjtfZjKp2e1ann36hBhH5ssl82lD17aUTcP1eoW2Gu89z84uyTLD7fu35UYbAkF5tFXsNh3b7RbnRvGLdgPToxnGajJrybKc7eUKX+Y8O3vOxx9+QF3XnN6+jc1znHJgDNpm6CynbXfYCG3n0Cpg9f5sp7KY+MKZachy2QaOPnBxdcl8KZ72WolCNKgoIjJjDqlVMUbwjuAds+WSV+YWNQwUUWAErQU3N0o8Q0wEYxR5kbE0E8oyZzltiNHR947zyw2PPv4e33/v24Bi0sy5ffcO0/mCP/PnfwUFGKsZuhancvrNCu/kgfQRSfXRN4yFfVcb04JgrEUjpmvWWAY0kTSPiFLYjBEbWkPGqt/SD6NoG3xg9J7oPe2uxY0OY0TZa1/C3t04clRUKCuL4Omdu2hmBK9o++eM0UGhcIWhyhs2mzW9G9hstzRNI1YQ1pJl5tCZ7Yvx/GTJAxROqQQB6t+3O9mDLUGTcgYCUemUV6KSYdlLA9jDIdTLfggMo2cYO1SMfPkLX8SrSFbl9L5logp0VFxcSQ6ozQyKyHa7I8aYvGsq6jxLQ21xwSyqEqO1QA4hstu2osAsJTUty0ryuUrhURGTG0xuUCajzErZGRkYQodzGqVLijwyrFvW1y1DP2JtwXJ+RBwCzWyCjZ48y9g5x/XVCu89XdszKWvyumBZNDx+/zGjG7n3+usMQ4vWGXjPOPRcnr9gUk9YXV4zdC1933P79ITvfe97vHL/LrPJjE+efMjHH33EerujaGaYwZEVsjjbKJYnJjMUVcFmfS2CJT/i/IiaNOQqo1SamZ+jo4eUydy7gd22xblAcJ6xD5xdXuCeCxnh0aOPaZqaH3X8WChUgw/4YURXOV3XkRthW9Z1hc2EPxtbT3CBdtOynB+za3fkec7oHNvtljEXVaH3njg66qoUC1qtefr0KbPZhNffEk+OECW9PnrP7PhYejolEIUymuVSKEvKCD52fHKLy4sLYgic3Drm/PyC1WrDZFpzdXXNO+98hY8//ojHnzymKjMWSzGnIor6FqXo+4GynnB0tOTF2XNUiuVTWnIu8eLw1zSNDF4y8afo4yBujOOI6TvqaYPBUmU506oiRhgGTww9ZVEwm80JIfLRRx+RZRnLpWClWZYT/XA456kJS/BFSkxKDJSuaylHsYPQxmBlHEJ0yc8iJntVxHlPacUrv/QKf+V/9Sbv/ea7/LP/8ncR7PeGU+2d5+VyorVKhTQZsNUlWmcHNWEIkagM5+fP+PZ3v0M3OE5PT7h9+w4nJ7e59/AtdHS4sWPsW/q2ZXCBrLHsfRJVYvl0XU9Uitl8llhFe2qmAhUFc08T1hADXkVGAljDfDYjxChCFOcYh4Gu2wCRqpqKHYNOVMC6xlpDiAoTA2b0DKsdXmVC25vW2FlFnuT+/a6VpiVBftZaYZh4T9fJud5bHMQkRT8+Psa7iKnyz+oEXq7USuGDF0qiTR+IewbSDx47K6XohwHvFdpYYQPFwKtvvk6+rAk2YkLEuMjFSpKIvHc4P6TFUih/RVkwJP8TFyPX19dcr64prChOvfPJZsDJM9KPqG4Qm2NrUwqZQuWaXbclKxS5KdhtZfhuCkNMxIDd1ZpPPn7MsBs4PlpycndBkRmBbaJnHHvGIbIZdonynBTFPjIQuNyuePzpJ0xnc7pxYLvZklUV2gWuzl5QFDm3Tm7hvefajRwfHQEi8huHkUePHvP8xXOcV0Qs51dXlMFz7/69pNWRc5llSiCVKDvk6+0GW5coN4A1jM4RRoffdEyrhnk9wWeB8aplXk+wmSQ0lWWFc4HRjQzDwGaz/ZF19ceiuBPB2pyhG+k2O15cr0V2PK1pigbvRqpFjcoMUSmqyZTjumY6W3J2/ZRt16GQQGEVIy4ExnFkOpvRb3p2XSfT/t2WerIUFWb0XF1fcHTvjpj5pAuvtWaxWOC8x1rLZDIRt7dxZHtxSVbkvPHqQ54+PePF5QVPnz7n/v17NE3N1eUlZdmw27b4sKUsUjCE1mzbHbYoGH3gervmxcUZqsrFD90L3lo3NX3b4Z2nmUwwuUY5RV2WrHcb3NBTlDWuG2kj+HbLG6+8weq6Z725ZBw6Fos5XSdFvG1b5vNweBB/oM1QoucZLCqqQ3c8jp4sL9GZwShLiBHHgLV2T6BDaYsxOUZ5Jq9MaU4GTl49ZXI0Q5uMSMAjDA8ZZPrEGdYQC7QyiOdLRIjCe08gWRSb6ZSj5ZLoM37v29/l8uyCse346P33xa8kzzg5PeHevXssbz/A2gzvxc9+6Aacd2KvqtIAMXXzMQrTJABE0SbEMOCiYSBiQyADeu94fnFOluUHi4GhF9GOYKLQNI3sGBRcXDylKApOT04hLyALLO+fEIJYLgSj8Qi91MVI50bqenLowF82guq6fcrOjZVvlmycq6a8GYrHlwbkL422xmFgvV2DmjJrAj4I7vtDH8FU/EPa/Whr6boeN3rKw1Yg0jNQTSuKiXTTm/WaYRhZLpeYtNPIioJ+HOg7McqaNhMx5vIhKX1zUWgrxbDZUYRAkwt916PZDcJM2XUdjVKMRtxgPY4xBrq2p64rHn/4IY8ef8JPvPNljpcLzs+fA5F79++yut6QTyvspMS0nrDbses68jyjyHJ2/Y4hKlpG7h4vGRFbb1GtRspJTaYM2hpMZrlz7x53bp/yyccfA7DetQzuGevNGhc8tsh5/dWH2CKXpic1PgGx87CZpZ5MuL66ZoieyWTCLjhCsjmosoJionH9QNeJ2drJ0ZLV9RXrywvG0XN6epflco6dVUIxPlnyj37th5fVH4virq0hGrn5sspyXCwOWG6wkbKuiFoxndSo+YJKNRg0RyenXHQX2BQVkyWsMmsaCB6VwabdMc2FnrTZbCjKGSFEjLEMo6yAeS4kPGPkIVwsFowJ98oTBnpyckJ/vSbGwGw+Y9Is2P3e73J1ec23vvUt3nnnHeq6YTaTwaNL6U2TyZSiLNjtnChUDdx7cB9Kgylsei9icbzZpA50GOj6jvnxXDh+xqC94WR+h7qseNo/JRIpJw0+4au/8Rv/gtPTW9y+fQeQh/3q6orT09sCvWS5KBXT8XL3JpiexSfhU1WWRDxZXojlb1kC0O1aMSxCgdLU0xk6z9BD5Hv/3Ud8+ugJ3Vnk7eOvYm2Biw4h/fXsLcm0EqaJ1hxgInkTAhYcZqSJpqeAV+4veXD35wVaykTtuLpesdkOPHv8ER+//z2MtRwdnfDK628ym805uiUhxru2xcfA2Pc3WHO8aXQ1ARUU0RmMMlg3oIpA7x0uBmbzOUYb4RaP46HztNaI22AIlHWNtZbFYilMkDFgYqAYArnWYCPK9ATAB7lHOz8KdxkZrgEvBXTITmA/VLPGYI1itVnTdwOPH33CT3/la3Id480Yeb8bUwreeO01qkoYGuznD8TPLAA3534/c4iUeYE2NdZmKJ3TTKf07Y5oLFkhjI2h71OX7xO1TxoJpcTKNgJFUTCbTomTJsEwIiISBojk6xZFjkoD6+vNmqEdcGNE1SVVPqVpaomqS1hSv5NoyhBEEzNEz9e++lXu3T5ls16jleLs7IJ2t6PtO+699RDrJvTjgM0sk+mELBNfqjA4+rbj6PYJZSPD0mYyQec55IEmLxiSn1BRFFS5zBb2O6kPP/yQ6WxKM2kwmRV/nLIUoaETa2ZxP9UMXq6j846r9TWbocNlhmo2YQwSs1fWFf31htVqxXQyJYbIbDpJ94KE9cznc2HYDQNEmM3mP7Ku/lgUd/EKzzhayITbWn1QEAYAJ6HWLl2UpplLwJSSEO3oIkM/oKyR5Bujsdri88Dp7SW6d9RljdV5CjnQlHVNXlZcXl5x78ED2t2OohI1oM0zmfwfhnOKup6QVxXtbktZaubHc+7eu8e3vvtdnj4/ZzJ7wnw6Z7PbcXp6AiBzgaJgtliijGW92ZEZS8w1Sis22x2ZzXEu4EZHZgzVckFQospzamC73TJZTLGNgjxS2AJbZNgQheYZIijDpK4py5Kr6yuOjk6pqhqN2NWe3nsIY8tmaG8w2sMePUL06Y/imbFarejHgemk4fhoSpGJenh0YlAVVbLW1YZIwWxmaZolYQ0U+zCdCBjxuTmoQZN0JjFbYlQoJYpRqbaeQ3iHUvLxGMisT7qlCDisjhSZwc4q5rOaosgIMXB5veV3v/kbbLcd0+mCV159ldPT29w5PUUpxXa7JS9KIjCOnhAQ/QOOsYgMoccZcRDUaLZXgrkbbbi4uJCGQ2maSlz9hmFgt93S9n1itoqCtTy9A9YwKIExjBeGTjAKr8EnT9lJXdOnhUKk7SnEOUTatjvAMkopok/MHK1RmabtW7QtKLL8kG97U+Qjbzx4wD4UJIxj0gEk8Zj6wQU+KtCZxZgCWxTcbSaMriO4gWgEXpTAlCj867zAajkPbRJeTY0lM5nAfWkOMY4DXoEuMjJtUEqCdNrtFms0WWYJpYiH1t2K3EUqJdTKtu/IjFg7+CDOimUtNuBf/6mvU3oJy7BW8fz5MzGJM4pmPuf49BS0YjJp2Gx34hyZdjtZLi6Vzjuwmp2XXYYfOuGdK03R1GgPVZYxmzSURUFTF1RlwWa9wWYaYy2TacN0uSAkR3qTCWVbpem21ppsUvHs4oLn1+cUVY3JRUw3aRq5N9ud2Ea7gTo63nzzC+A9RZ5CZQI8f/EpGMXJrTvUlYWX7JN/0PFjUdxBVv6h6w6ui3ue994utOt25DZjuZihjaXtOkKIaGPo+l6Csr2mKoST7nzEj57j5ZKzT59xeXUl7BBjKKuKcqhYLpdcX14xXy4E/1ZK3O20Th7S4usAkGc59+7fp9ttic5xvDzma1+bsjw5IQDL+ZIsk450Npvhg6T6ZEUlAhQMY9+J2kyBMooirzHRsF2vpTvLNKMfGPxA0UiVLJoS5x1D16GD4ag4pqpLfDdiSPahVqxLrbW0u5awCEwmUxbLJRcXl9x98Drh86HF6kbir3VIyn9DaTPe+fLbjN4zmRTMFrUwfXxkzHPy3BBxsrBCKioyANfcbO85oAQhOZPKIE0RyazGWCTvkhtKo1Ky0H/22AeDcJgCqgPAtBdzROoip65r7mDph5HLyys+eO9bfOt3f5vZbM7JyR1u3TqhqZrDAx68GIOhPEWMlES8sgyj59OrS2EtJXy+KEuRzuU50QvUlef5niifqG3ymhfn51RVxVFVg1E4Y9jLrrIQsT6SR82z7YaRvce9PAPCJMnouv5Gym4M07pit92hM8M7P/EORVAYL8k8L5f1w9pNsqWIENnbGZBMyn7AA7i/RkBQMTH1ObwHl/QDAk2J4MoUBT7KTqbvOjarNW70LBYLCbkxmn6UXajWyeclRlTyuQkJl9+f1+16QzNtOLp1i9043OQMILOoYRCmz+DE2nhW1iyyCkWg7YSaGmPkzu07LE6PmS+XXHXXrFZrnj9/QYyR6XRKZq2ks0VoZjNsnrHr2hQ8Is0fvSSIzRKkRLxx6dwLt7LMCN8/maRpq3Ex4p24SsYYyTKLI6KJXFxdUlQlr7z+Ks1sBkan+YMw5vLMUjcNnz57zptvfonN9vyQzHR9vaKqajrXc+f2Qy4vz5nPlj+ypv5YFPfgpVtUUfjGY+fZrVthPgDTiWK1OeeombPdBjbDGt864vErjCFSNhOK4BidkxXVWqq6wmpL3I0oFRn9QLtbMY538V7CnfO8YJcWCWMNk8mU0bm0sAhkEhJWKfiqeIlvVmuuVisG53jx7FOePH3OG69/gcvLc7JCcf/+HabTKYUt6JRGG01IN17VTGj7NfPpFO8jY9dRlgVay6WwmYJMUVQFOlP4UfJV8yynaWqJxOsc1kxx3Q6rDcv5lHv3H3B5dYEbA8Erbt+5Q900XK/Wh23/Z6CYz/xZOjsdwSrN22/cSWaNkb1bIhYoclJVlMUh9DK46np8cOlVbzBi6cL1QfAEYE2ktIlVq+LhXR2Ag736TqvUCSXKYzQ3HedLb/7G7ldEQ9H3mBhYTmumTcngRq6vNjz68F3ee/dbTGZLfuInvkJuC9kVoPEhpsD0SOsGzncbeh2p6pq+7xODRYb81hjqKiXujAPj6BhHx3a9JgbHndNT2TUGx6bvaLICG2UYuX/7TsHa9ThNik4T+huIQZX34u+999BXQJ+cBb1zdBFqUwIqaRleGqymbj3GPTMmBWib5MOvPnvlUTHZysj5U25AxR6lDYEgC19eCCsqirVHXgpU0I8jCnFMDTHQTBoRfq1W2NaQZzLHKvOSEJBCnZoo78X2Vit1M3i0OXmWScZxlqcAno6qKA9CwhhF4BdCQMVIl1gtq9U1WmsePnzI8dGC6dGMIYwJZ8958ODBYaEM3suOJ0SackIMYjG82+1o2w5jLbfmS3KlGfqOYddR5RnnZ1esNxt2ux1lNaEsaz7+6GPu3r9HbjO2Yy9aDhBvpXQ9gnNcrNdcXa8kv7XtcIDzgbqpqSqxX7leXcvOydpkOjaAErw+ywRaXjQNzbTmow+/Q7vtf2Rd/bEo7hBpmlo6m8yilJFV3SUFaVlRuwqnI2vfoqOm7wJdGry0bUe328g0PWVjjmEksxZd59TTCW1YE6IjBDAmZ7k8YTpdMJ/fOmDsIQZ2u44PPviAoihZLo+4vLzEe9kBRAXX11eMQ3uQCk+amtxaRjfSdh0vzi/pui3z2YJX7j/E9Y6TkxO2o1h7fvL8CVs3kM0KirzA6oyyrrA6E+9oPzItG3Qmw7fBQDtsWa/WVHnN1ASePjtjOvF89UtfxETDZvNcCtHQ07cDF2dnnJyccHR8jDaGvl+RvRRy/PlDOm4OhVxGGHv8+3MwDjIIC4AfOlAWP3RiKUDCytX+TyoN2dLH0kBzL0Q6XP3P8PLi4d/2cnkoEqM9BTJ8DlXYd5fejXS7Lu0UDHmRU9iM2d0G89Dgg6KeH3N6+zZXF9eQaTaMjCrQh5SSFB26zJmZOnHFw8GIbK8Y1ZmBIdJUU/quJx/lPl1dXbDdbrl3ekcsexXEwtIjOyPlpYAGpTBFSe0swQW6ZB2cZaLO9j5graWua4EjvMelhSLz0OrIYBW5MYxRoZ1CO4mEkx2ZwZoM76XTVfvzG1P2arw51+qwMMiC3LdblOpk8Kw0MdPYugDnGUZPO/T0o9gAxODFbdPagwOn1jYtVIF2J0GGAs9Ipx5DILP2cL9oZLbmjEMBm/WGeZHTDqMUtDKn77qDudowjoShJ7MZ27Gl7cTfp65rFm8uxTF2VjFmii6MeAKb9YY8L6Rrz+Q5G4ZBFlKtsJll2G4pioLJROwg8NKOrDcbCm05Pz/n7OwFm80Kayxd1wKKo+Mjbp2esgdIbDJ+i/Fmxxm8pxsGgWnzMqlwp6mIy/vP85xJVfPs4kmys7DJr0ZTVSVETV1P2LY7ssxydHSL3ab9oc80/JgU9xihLipMLluQoXfkyau4KismeUORS2yXKTOCU0S95cmLJ0QjDnR5kUkclc0pilK0LgS0ChijOLp1RFk1aKMZ+44BEWOcnZ3x6NFH3Do5Zr6Y8vTTT0ApHtx/QIye1fW1mP4slbAiQMRFWjIj5/Mpr7z2kA8/esxuu6PvO86CQwdF9cZbInjILc20wWvPsjriwVfusn3xjDEiC9XQsd22Yi8cYRJrsjFDa0Ndi+BhcjShriYQFHGSc7Y7593H7/OVN9+RIZXJqOoJda3o257zi3MevPIqWhs+/ugRD++e/PDzjwFliHEEZXBESGZfe5QkJpzFqKThjDF1teJrfcMn57D3r0tx3Nzudjgn6uEYDc4ruTaIJzfK/X56XiQN0rTwswmIxfC+Un2uA5WpYNohKCKeoe8ODJlC10QlSkClLVErgg646Gl9RAexf9Y6Q6ddyND2bNYb9rGAMYr6dne1ZrPdSsiy1rx4/gKrNXXVEFHsdi3HzUyi0QbPmBu8lsE4WuM6Gba3u5bNZkvXtVRlRVHk1HWVGhzBq2PyLTFZxhgixuQUAfKYoaISLDyLBC8YrA5iBZwVBbHd2/zKIFUrRZGJL0visia46KUCrxU2y2QImP7VRY/KLVYrquQn03cto3PM5ndlMKpSXKPNZS4TxO8mRumKJRBHzK/2C7Fk6eaJmhqhKJjfylBak1cSnOG8o55OMVr0K1liDZEGyUVdY6yiynKC81irGYNjcLDut5ydnzEOI8a0Yu5XVayuV0QfOD6+xWK+wBrNrdMTxl7okFppdJ5Ld01A+ZGx7Xn24jnddis5yaNju90wmYslgvNyz2gjWQoqcBDSeRR9L4tjNctYHi3Jipx210qhb4Ry7IeR+cktjL3CB7Epz8uGqp5R16NcnyZnGANFlaM+D7V+7vixKO5aKbTN8GE8QAh9GtJY7TB5ycX6BdPJhMJ7cl2wOJ5wPDviyfkn1JMGHQNucOzWrVjyNvKwqFxR1CWFySjqmm3X8vHHH/HKqw85Olqy2Vxzdb2jru/jRlElXl9ds5jP6YeB7W5Dnm7YdtcKJ7ksxf+5KGi7HdV0ytVqRZ4Zdjsjw99hZLNZMZnW9H2Lj47zqwuihuzTitzURDyeSD+OoBQmsxR1hp1lUuxUZD1scN5TFDLQarsWnWuOFse0buDp5XOUlWm9BIVXjOVAPwysrlcYY+mHnq7vMYcm/CbpKEbFar1luxsompy26/nnv/3b1HmBUjCdTmi7jrqZ4MaR5XTGvbt3UPQQFEEJC0OjCMpwverwPnJ8NMdmwmMHDtzzbduy2uwYhp6myLl/+/SzdfqlQ0KrA7vdwKMnj9HK88brr6Yw5KQuPXyySt4xHAq8rEGBgKLzsN1tOQky3FTJpCuPGW7ogYAfJKc1yxUX7Zpd16G0pm2FZbTf1u8phV3b4UaBFkLySi+rmrYf2GYd0yzn8vkVPjR4FVDGM1/OuN5c046d2DYbQ16UeO9l7jSkwPSEkyulDsZk1li+89H3efbpM/7oz/0sdVnQlBnBj0JfRHZhLmo++PBDZvM5RZaTaYF3UNC2HVV9Ywz38mxVKYEKhr5nvWvZ9T3zW0cSxBwDw+hY72QxEl+djO2upR8EMgopTEPSqcIB1hRI6+ZZ3zN4QpBdS1mUVHmO7zui0oRMLBRQQhEenSMaI8NhxOrBaJljOBMppzWNyfjW7/4ei9NbLJtbol41hjt3bqOVZNj2fU/fd5ycnBwcSIdBHBaNNkQXsVZ8b1xiMimFGKANHVVdYrXier1FWUNeFSxPjnF+ZPBe5gleLD8S74kY4cWLF7z77nsUdcGtk1vYPBMGjBXmVNt2QplWkDcVlXeM3pOXNdu2J8s0V1cvIMC27+F2Tte1bNf/NnTuIeLWrXRnIYgzXDtitYx13OgS7zcyxpqyjMzqCbPJhOe7jHHo6LY9V5dXEBVViq26iSxTWCN2o1ly89vttlR1RZkYMm3b0jQNTdPw+PFjzl+8IMtEVBWrhqHrGMeRvu/IM1FguhR0PQwtt46PWdmc5dERfduxurwUm1jvmE2mNMsZzXyGnUngcAguDWoUxmq0kZve5kbMkKyS7miEzWoL8ymTRrzSi1igrdA3vQ8ptEEecFFLKtqu59Gjjymrino+QedWshk/dygFMUhnrAIE57i8vMQeLYjeM5lUjGNP2ybPFdezN2067O9TnNw4DHz//Xdp25Zv/MwvMJ+W3ExBZdAaQ8AHmYPcROn9sCMQoqftB7773ffIM8Vrr74C5mXIBg4l/XNMP/mc9FEHV+dXOCeMoHEYSGloWJ2B8nSjo/UdYxQoJa9KYrKg3itHxZnSpMHaIIyOrmPoe6azGc47mrrGacWg4WK35fL8mhACJ7dnlLMKnVvRb4SA9p4suSrK99grbIUpM47ukGGrtebOwztgFaawaKslys/LYrWnzMQQ+P73P+BLX35HIhTzTNxUxd9Z9jmfh7bSf1LYAt1my9NnLyiKinm+wCWvnn3+p0+iO20k8MQmBbZznt2uZbfdMZ/PpStNrJn9zhQf9ub8B7aNVRpb5jgC7VZYXVVdi4BsK55Le1HibrulKMs00Jbnvbu8xkWPzjO8VmSI2IlCmDbd0OG8aB+mkxmZlkQmrWRIvNu2RBWFmTOMSd2taDdrGBzj0ENUXF+vuV6tuXf/HkdHR1SFvA/f9zjvRR1vhCq8Vwgvj4/4ylffIS8LTKYZhwGbqJVd34mhmnNURUGRWex0hi1yzp+vCc5TFKIBms/mgGG+mDF0Z0wm/xr83P9NHwoIbc/gHMMwkmV5itUacdFTHc8oygplkym+VYRM4bUi6EhQgTGOTKcTtEnWwMh2NssLfCZeHzphvT543n//fUIMOC+DzvV6TVmW4t9Qljz6+GPu371HkRdkxuCd8NS1UXRty7RpZDCrDbNaiv12IxhjXTecvzjj/Q8+5OLijNPjW9xRDzAT8YUYE/XQaIt3LuHICkKk3fWYXmYG282GoR1odxK1VeiS6XwpjJL9hJ5ElzOGTGs22y2ZtRSFwFPGWvJGwnfd+DL2fQNtaC2Tf6U1gUg/OIzOyGxOZnPqqiYEsR8wKilZ08B13yfLIC9iM8NE15Km9xKOntlMgjBQwifP9MEg7YcdkZBMzoT5oTAIsLzfDZAKfIJvPueZsmd7gKiPh6FFKVlItdF4JTuXXke8hrFSkGc4kAcx5sTgsYYEzRi8EwxecOX98FeTlyXDKErirm15+PAho1bcee0ByzsDl5eXHJ3MyCqDVZNkhzuglKb3PWVVYa05rFf7NKA9nLEvjvPFjKOjJUXKIO2DR2Mh+MNiBaR8UqEcRtJ5TrCirICazy6ssniNHrRxlHXN8vYRxTQnZEFcKb2mXfVJiCbJZSgj5l5GH7p1YyTMfhwceqqTG6o+YO4+xf/Z5CAZo4S56yxDA1mRJ7W4IY6jwDAvibz2oSYRgYJiVFxeXjOdzsi1oTEl2mjWuw1+HNFacb3aoQvJP3jx/AVucMxmM+q6RKPxQ6TI8sPw3OiRzFiYTrh+cc52u2Nzdc3583PxbU+7LR+FcOF9YG9Wp/cU6jR7Uloznc9kJ2YVysiOJMQgUYRlgbG5+FdpmVuYzNB1Pf1uhytL2m1L13aoFA707PkzlrMfDrXCj0lxjwpUkZMbA0rjO2ExlHmFKSx1VRGyKUWeoax4f+uoUSpiMITeC3sm+ZnkRY42e4Mohc0zvIcsK3A+cn52Rt/t2K7WaGsPA7OyEOXfndu3aSdTFguhSMaoGMaBvJC80KzM5SJEnXDDjBgFBlpvNozDQEQUdsYqTk9O2e12TKc1KMltJQSGfpDtX4Sh75kvZzTTUrDuIaJUTZw2HOtjCJG8yKUo7DoGoMgKqKEfeqFe+h5rTMJAhV9uMssYPuv4/flDG4OJ+WHQ6T24lMiujCXLS0YnEXvGCta37/xCCIfBkYpQFFmC1mJyZ0/b31GoZQmcRWsOD+gPO0LCVX2QpBzvgtgEQNpy3Hy10kHi19IDto/X239GCDKMkyCViNKKIXicgmjkJxhGx9gPLOdzrseNBLcbfehK+34gz0Qr4b3AhuM4UqfitXfzG8eRi8tLTm+dEGPAVBnHzSlFmQsk5kRcdXV5dRgcS0iNoapLYiSFQ8gAdF/Y27Y9/Pl0viTPctAGVSiiB+0jysuC60LAh4gO4iwZgiSQmcNi/JknkKhC2tWI7YMtCtrzF3TdiMlynPfsupZtKx4yWgvLSBtD20qy0DAMhCAYflXVYgncdodrUhQFfd8Dgv9vd93h588zSVoqy1LUwONIt90K26YsU4IWlEUpbBnvZTHVmjYEnNU8fXzGbLpEDxFrFItswouzM55fnXPZ7+gRcSFaQjXGcWQcLZNmQl1KaM/Yj4S9MZwx5GVG17VcX16y2mzonePk9m0J7JhOUUYcL1GkXNp9MxGIYX8/puds3+14gbi6XuIDq6qSppQbyFRrzWQ2ZbO6RnUiCuu6nhB7iJ4iLyXU+0ccPxbFXeb0EZfM8PNcVnClBBe1RpO3EasUaoi4cSAbcsxcsbtqUWNgUtX4IPS0nfcUuXgmB6PBqKQuyxgHqMsCP+5o6oqT07tcrM64vrzEjyNNVfHw/gPZKhU511fXKGVo+x6b5+RVBdphiwxcFMuAQXj2y+WMq+srmRXkGUUUu4GnL55jq5xFBOuEIeBcQEUlg2OtiZOCfF4QwohzIz460FHCOXJZrIoyw3qFcpEcTR5FCTmoABqqSUaRy2Jns4LRRaLVFGXOAXD/zJHY11rEK3IxpEBtdi3L44W4+KmIUUGuSeLdpuC7VL59uo6QFRnKJb50FG9sGYyGNPAUR0abSRcTVPxMKpDU65RSE+Xzh9HhvFDK3CjXVl5/z+hJDB21f42XmDjIMuODZ3DCCY+JllhEQxU8Nhi8Uqwur7m+uiRDs243+CBUta4PEAR2enL1aRK11QzJA79p6gMEGGMk1sL8ur6+5qMPP2J1vUYbzU/91NepJxXr7RaTZzSTBvyNvatSit1uJ1Cb0ux2bYJmxhTwYA8KSe8cISgypVJ8nmBSMcYDLr3rOkqV01QSqxhGh804QFX7a6bUDayllQgBCV5gH6uJGkJEZkJR1Mp7eCaEwHbTs1qvWa9WZDZnuVxS1uXB0mN/9H1PlgmbzXuPzaSgKnTKuDXiS4PoS4zSZAmaGp3HK5HyG3UzixC+fU5xtOB4cBQTof8uZjPatuX64opMG+4e3cLHARuhXiwYM9lJGC12A0EHcaa1GuWFTtoHGQDXixm3QmAMnsXxLY7nR9RNTZYWepeaGSEiiXo2ppN8oyVJO6VAUtg6cis7CRUCMfT0Y0iUUMvoehnYZ4btWu7FvcVDbsU2ujD/wy1//40fMUZi79Axii2oQFboKB4juTKMyqK6SPARHTRORcKgMIOm20goclPV2DzHGktlM87OLiTL0GhyYw+FQCtFU9fsNhs4CUybCZdnZ3g3ostCbs5KvDP0Yo7Wht1Wwi72EEqMMQXnGi4vrsgzy2I25f69uzx79pz1BrLCJh+Mmk+ffMp2u+PN197g9u1Teq+4Wl+Lm12W4SV5C2MVeV5hs0AfR8Y+cHlxAWokHAWMzhi6FqUNrnOMzTHBaca+R5eR1u9ATYhBONPWKopYkfnAy84ieyaD7Bylk45eskyrqmJ0I0UuSsCizA9+5fvE9YgFnadMT3FWDAaWx/cSnJKx3ibPn5RPKcwVMNYcIIjP95EvZyztt+vb7YAPGudGhn6gaW6sTg+iKWS2ghavGgnt2HdR4IPDuYEblaYS7/GgGJVY8GbTklJN6PwgEYJJpBSTLUPf95yfXSRhnU3Ck/xAkxQqozoUeaXg+OQYiNw+PcHmlsE7lJFdh03CF508jaT77SHCMNwwZaSwG6zNRBOhlIR6KE1wEZwsvDrEw7BYKy3WwApik+7Z/fwjHeqzvwEKZS3aWOo6543FRNDC4CiMOIJmuWQSbzcbYoyM/cDZ2ZnASKmQd11HnnYpWutDDqlcK59UqzL/ybIMo0WF60PAKoNVWiyxk8z+eDojL0rOLi5ZX66Y1jVHszlHmcCFfbdjt+24e3zKcjrjvXffZbfaSDCPzYjeMVxsyWpDM6/I+kATDLtdyg1Qimo+w9gM5aVpGN1A8AFtxChvOplQvf0W9AHlUqarNfhD0lW6BYO0PFEJzUA67u6wgOe5PEulLSmNZbNak+XCJrp4ccZksURngaHdyaA8ihlbWUpYTp2VKCzTyYzg/y3o3IV5FzBWBoLi+ibZi5XNqLSmKBv6bkBlCjdEtA+EsaeJsmVpty2VtVRWY7XGhIANlqNoCf2IcT1hbCFMmJQVuyGw3lzTtlvm8yWL2YLN+oLpdEogCGadW+qqwLvA0HfoJCp5cf4CqxXL5Qm7zZaphwu/4+jkmOPlEW4YIAoFM0xGTk9Pub6+Is8M1gSi75iUBTrWtKYFpdh2HfpFkDSWacnoAnHwPFufpw6yEBtdYyimNVoJy6Z3nu1mx/nFOaf1LWwFee0xo8XGDNd1+Kr5rI8LLz3iKuHJRh4ucSTcsd066Rytoa4FtnLOJ2FZ2vonhkxEJbpipCwnh2vaDYCKZEpjVEjfUyT8xhrSvvUz0z310u/7Ark4avja179I6Ic0zHzp59jPD6LkrUZVElJzsD/cOBJi5M6duwcGhwue9djjDewQgQ6lZpJNpcvSoqYcup6h63nx/AW77Q4iuNEx9AOlKmnmNVqrA7NlHEemTU1EuuV60vDKG69KEJxzaf3RZFbmJVFpXKINDsNAPZmk4rc9zCTEG8jQ9z3eG8qmwSnPoCIhE//x4CMMHu2FrvrzP/vTYginLIZkBxFvVMk/mKKkxBslUfmUTuBamq9IVsJI1wsbKwwjwXuOFoubgbMyjG6k68S+uigKyUNOC5/3440uwYtTqNA+Pb0fKbKSKrOgIOBp6pLr9TOKwXD29CljPzDRtxmyUfjfxrC9PqMpc6K75jvf/A4ffvCEr371y0QcWmtm8yUvzs6wWnP2/Bmz8ojghPY4ny8EGlp39H4DKKqyRvWOzWZD1/dstlesNzvm8yXz2Yy6qtEafN9zcuc2m27Hrh+ETaUUQUOMLtlItId7eRxFuLWPx9wmrcDV1Y6hHxhXa1qfUS2nuHbL5nJFu9kxm9Zk2rBbb7Dasl2vmE5mQvX9EcePRXFXAEPAuMB0OhGRgRsZ/EiuDN24RfVbqhCxQUnnp0C5kfHFUyazDK0jC3pUK/1psIoci95tKI0hDLC9OGfjBxhHXrk9JfgdZXgO3TW3pz2+zqnVEzK3DxMOIkjQJZPmGqOuOZo6Xq8i2u7I3EcUy47qVknrNIW9xtaRcRZR3BIqsR5Rugb2W+8L4ALlc46yHqaBwSmecoJzgWHVMlzvMJkGFTiuG6rZlCzX1EVDaEfiGAgmUk4n6MKi7UgxqXj66XOO9YQx88wrOD875+joGGsURkVG9uyUVELVobdNf0n0tFZ8OJ49e8ZkUgtsEiI6kobV0qbs485iFJVjDOLbLofAMVorMNKPy3dOfOqU5fr78F91gxnEKH4tt2+V3Dm+IyZkUYa+PxhkCgRl0xA2GWURcUFEtXU9Ze/d0g0DPaJ/NQgeuocwq7zAhcDV9RWffvopwzDSJ1pkMykPWGqWZWLlnDJn27ZNIQtiUOVjPPyE1kcKDM4ogQq9px96nJxaxnHk+uqapq4x2rBer6mq6mAFHKNg+Xthk7ai9tSA0zLEi37vTQ9lISwWiKjoBDIIe2naHgZ7mfGUqEYh4L1g6WQajAXtCCnBKgaxiM7zApXlybrZpPfn8Mk0yxqD0fshq9wTAislO4NRFgDve9GRxMD1xacczQtCqfBhJAQ4/2Rge/0p87mi1DCd57TbJ1xd9EymJdvNSFFlxCDfP9rIvVc1MfseXRcoCsvj598jL8ExoesNRXYJeoeqHCFrcF7Cr4kNblQMYUs/eEyhqXMY/Y6yUtSTFeO4xXNEpCHqnEePP0bbKHkCFFyt1lRFJQ2RFzvysqjIcot3AyFYjNWEGJH5aWBc74ghMJ+V9H4kRs/6+ordbksMgaIosUYMz/quwzlHlhX48d+Czl2FgOoDWo3UTYPTmixqUIZCK/ToUQmHNkHjfcChGbcbhrEVf2tl8UOLUvsJvKZUYlK06wb8Zicik2IO40CuIKqWuPO0W8/UXqLMhCLsiEES0Y32eG8xdkIerwBNHAK1VfRhpM5KKq2JDBjjMToQxxUxrgVr9BkRjTYDrpebOGKJ6ZmBHJvdwnpHHAVO0M7j3cgYIx4oB0vRKVTX4neW4BVLU9NuO5p6gh4CWkXunp4y+JFtv8ONgVW3whrxcFd0KCwHSOLwu5TIIg8yxNMwbRr+zC//MaLWFHnOdDoRx7y8QEHKcZRibUxAk+GCRyUhSlR7rEeKhUZsmEnCmbIwFIWIdCJ7vro/CDI+gxJEJRBD+oiKe2xZpjT6sDpFUCJHF661wbPH7xUhOTGqpN5UWgzLcjSWiFeJr++FIql0xtX1NZfrlQyRTWAynR3wbpDivtltKEPJthV3yKZpmM/ndEMPQ4/NrWy5gUHdFProA24cGLwDrRg6hx89mckYOnFbLIriMFzzXqyQi6JiGBzDsCPXgl1XVYkxGkdAVxkupoAUH9FRIAV8xASLDnq/tN7MKpCu3gvhCGsMlbay0EfZzXXjSDvI8HjXChc9zzOM1sJw226JQTpVpSQDQUGKkNPkuZVON3XtB2FWei/7nIDbt18jy0BpT54pQtRk9UhWN+Rqg/Yr2p3ALX03EkIHsWS3HdHWS0QfYOLIerclzzK6AXY7yBvFto30Y8PorgCBWSX2TvByHSxo6PtzBjdQp8FtXgaUBpsNiVyxxVLgiXS7gFZbrlYDjx6X7MZAmYsj5nazJsaRqoSHD06xeYYqKowqJTQeR54NKLWmmUGd92yee9ADamxQKWugLCthq+U5zgeBcjKEcvkjjj90cU8xe/8C+CTG+BeUUq8j+anHwG8A/4sY46CUKoC/AfwMEoz9H8YYP/xRrx20Jl+UKGU5Vz2FMVTKoqJmEg01GRExEIpKunICnJ2fUxYFFkWmZUjpveB0RmumzYTr7RbnIto5YghYo7hcrfn+7wSkDAzMm4o/8lNvY4uK44evY+2M50/eJbiWjByTNUAPGMwYhIYYYDYZKHJxShxHx0jOdngTkx4ioTBYvMnotyPD2FFOSpRSBJNRVxOiyqitIq6+ic0NzXFN17f0XYt3A7G2tOyI40BhDH6n8P2Ooe8Yq5aVuWLbDkQ6TGakk0dDCDSNJK6v1xumZfUZ+iOp61ZKY2WqhtJQZopX799mbwYW03Y82XAiC4QwU8o8Q5lI34+g/WHZiEpBlOtlrEosFyBCZtSNCAmdOv0fcpMe8Jf9yF3wZIXgmuFznX8kErxLzethW3L4atk23wxtBxUZ4ijj4Cg7wlFlPN+tcEiBzbIM78uDvD4vcogcPN0hDciCZxh6Ls7PD0PDbMzInQzFtNYH/FZbg7EVWeo2jcoY1ZBcIaFOEIbWWganzhGVOvjc1FUlmL/WZFpjBD9hb3xnosJEeV+J7sVeFpDleTof4TNnXZAxL7CREg/1Mdn5aKUxTqNsRjHLGZxnOplijGZ0A30y/BtGUVHKLEJmECYXTYA1FqMU3vk0w1rhhpHFbI7RiqKoefrsKXqakdeFFLYQOfv0U8L4lCp3ZBZGH8lMKUlGQVhGVXOLalKh4ojVBaP1oFusFt3MOF4S9s8koHVBli2ICMwXfMRmmm5n0DonqlKgYQNjN5DlVaLCFigcIeyArUAlgwcTUNHTTGtquyC3JYWZcPb8m0ymjjfeCmT2I3bXGdopRjL6LQxugGak2yq0LvH9jnZrCUvHxdkGHw1lOcUHydQ9Oj5is2l59uwFx8dzUp/xQ49/lc79fw18G5ilv/+fgP9LjPFvKqX+78B/AvyX6f+XMca3lFJ/NX3ef/ijXljFQKEDtckYdMRqsfwtUoc4IDgiyspEn4CuKvwWmqok+FYGZiiCdwxdL5xsY9JEXQQ/gUg79oTaUuqbbalt4NJOMEpTeFkozrBoNaE2c5nQG40KCq8lLDsQ+LQdMT2UhcVYxTgqxhTXRhTObwxQ2opoFR8++oRoA9XMovKAvoLZZMnF9ozWjPgQKMYNMQOVK3IlMvl+gDiIVL4fPJnRBA2X11fMZguOl0e8OHvC2cU5RhsWiwXz2QStFNeXK0Y3kmkjzAqlPiNgOYA0L3fL+8KYOt8bbnTq9xNuO3Qt8cAvD8QEmUi6EVR1jTWR3dYlKuZeQ7nvG6UzVfth6OeOiARqx2Ag+qR2TeCOUp8t7FEYCU0pJd/Hm4i6IUrB2uPGVlsyY8mVZlQaHQPeBzJriMoyvPTaQs0TSCQECTOPBJqpwFXDMIj/fjey3W6p6xpja4pcOuoiL2VXECMqahG6JMOsoR9EnBf5DL107AfaRDncOxE20yku0SW32y0uz5iXNWqQj8uZFb/MqMBWDf2ugz1sFsWrSSuNKew+IuUzs5eYvvduu+Fiu0FlmtPTE2xmKJIQKvhI225RZQ1e2FpsO5rZlOlkyq7rUVpRZzlFnlFWJR9+8BEnt+7QWMvzF095+OBVNmHFl778RVw70LYrtC149MEHfOVrb+OHLe04Mow7zi+uKJoaUzR4gzx/0XAxKI4WU/rdgDIzhiFSZRnO55IBXC+IxkJQjGqgD+BjQVSanauYlAtcvGIMGZNa+OK66olB4cYBF3bsujVdZ6kKQ1nNsNmx7Pa9w9iIVhN8eMYQhM2yOLrL8u6XqIuSq/Mrwgc3aV8BxTA4Spvh3UZyYXFYYxi9AuUZhsDQajargY+ebPnCl75MXlhWw44iy9i1O1bbDb/zu9/mi196i7e/eO9HldU/XHFXSj0A/j3g/wj8b5Q83X8K+J+lT/nrwP8BKe5/Mf0Z4P8N/BdKKRVf5qf9gMMT2IWADVK4cmPJD3CgAh/k+VeiohOrDlF7mSidTUyuec6NKKPouw4dpFv1GnbtDp/PWbyxRNm9Vaq47j3fPiKoyHn/jCo/Zb1+TK2PmGYli5mmySqGoacbAheXA7tdK6k1SnE0Vdw6LmXY1I4ED+JZDsFHNruRvK549c03efbsCRdPz1FNoF7kVDGy8wNUmtzkaMzBDZMoJlJxGPHDgKGksDkxDoSoKYoJbTswDhesVitiiBwdH3FyfAub5Wk4KlhxnufEUVzkPnMhYqQffOoOVOoQHaMPeC9maiHBAs455rOZ8OhFbZ/gDo1RitW247vf/4DRO954/S3enDRYrQ4DWAi0XU8/OKwR2Ecgmh98a4jjYaI8psXF7OcFqSN9efhqVKRM9pbKeIGQInQ6ivMjCpuQCqWgiIqpEqdLlwbKn2wlgDr6iNGGrpdA7M1mI1j3tUoe5BmTyTRBPMIwgqQZ0Bo/joQgQhSTCRS0a1u8c+RK8ga0zbBTCQHX6FSAJcpPK3GkzK108SaJhmwSrKEiLtP0RggESu2Hy+CJbN0ONzqiC9RZhvYR7/csos8xlD632AeEdmyVxXiI2V4sFFHOsVtvuLU8FrNO7wnjiG+32KyisGLK1Q8aXEGeBXQceHDnLouq4tH77/POO18Ga/nSl77M97/7LqrRGKc4PTnheHEXskjbixXDeZHOmZlhM483ntEFvLJkzZS+X+Pw5CanD4Ztv2PX7chmx6AUYxiJRQNljVGW9nJFNi3ZqQC6AQyj6wm+Y58vsPYZMSsxpSjBvTEM1tIOHUrLjl97A1GxiQpbzHBuR2bEk78oS4y58UPqugqjI9oG1huPVxkuWPp+i2k112vJjMUZnIPdLvD8xTn3Xtnwx3/xFxLRYcR7x9XVNcvTO8yXE+7cn/6okvqH7tz/r8D/Dti/2jFwFWPcI/qPgfvpz/eBR+mBc0qp6/T5Zy+/oFLqPwX+U4Ayt0x2nrIqZYDpYQwOR8Bo8MFjCaggdDwTIm7oGWJDraFAQwo23g1jGgAKrumshEHECYylYbteQR0wSjwg9P5JBzFi8gH8iI4WrWZEZegGT1HCEODyumOzG3AOdAoR+GS3YTv0nJ7OudqtCM7jBkcI0mmVRUVvFPm05vTV1ygmCy4+fcr68TWT1z2ZqQRKIk3bk9IvRkWInhCFn/yd77zL7nrgZ3/mHQyaXbumqSesr9c8f/acvLS8+fpr9F3L1cUlmRWO9Gq7Y1k3lJn5nOxcfu62dwQUVivGGPnu99/n/OJCutlCghdsltG3O776zle4VdlDpz3gsQq0inTjyPfee5/Rjdy5/SoHO8KDIhYJX/YRF8UGuChEdfqDynsEurHn6sU13kfKzDCZ1EybhoOWaf9LgfOR3TgcIAqldRquCo+/R9TMIWkI1sql3UOgH0ec83Tekdkck+uDxa73AnEFsZtM3u2aru1omgYfReCWFXOIUGjBnNtRgq9tZtNgNJOmxUpQg1XQbdb0fc/RfImOBm8gzwxDP6IVGDSZzSGTbNgYo7CBFBR5iQsebyxZBFSyYnaBT977mMuzFYvZglfv3Ukyh8QvTlEq6qZvZ5+la40mzyMTJfetRtGNLT0OYiREx86tGWMLSWzUt1uaumJo1/ShTYt+xthuWA2fsm13/N1//Lc5OZlhTM4/+c2/y7YbiN9uUd3A8SdrNg8WEB0GyOsJ2ilm9YT1ZM3FasMrt94gK/ShyC3yI8o6o30xkFNTZSUxeja+JTjZCQYPgYALihgKPOIZ4z2SqYBJO+xBzk1i6AxDJ7CYaVBWdphD1KlaZkS1pw0EvC0pm4Zdrwjray4v/yVX5Smj35DnDu8Nt4+/gTGa9z/6Ll0G5bQkUyNFfYqvPKa8JpoZzfQIW1p+4qs/y0/+nOXNN7/Aa6+9JaiBiiIk225xbq+urfgv/s9/4wc8OXL8gcVdKfUXgOcxxt9QSv3yH/T5f9gjxvhfAf8VwGxax1WmWPsBokbpSIaiCpDZnKqu8f0avHSR3nmGEOljTmMkIk4ZGbtJWo5hGDxlYcXju8kYlxmVzbhzdIcX2x0gnXtIlDkNJE09XkVMVmFNBQiO6YP8+t577/H99x9hTMad2/f48MMP6fuOn/35r1BVhsm0YX29JeLIqwZtDc1sSaznPBsc6/OWEKawsOyeRh69+zG2iBgbyGwmSs6kZBMerZipqRDIRk9oO549fi4rfboRtbG88drr5KVlu9nQt+J5EvOCzWZHUTTE/Q96c12l4CqJOWyaKWHs6bc9i6MjqqamKms2qzVRKWwp/HptLYJop/cozYnwem+ILoLpqpvisfcjiUAzqclzS3T74nqzwH7uHiESGd3I9773PifHR9w+vUXTNL/vc+R7pl0eJNMxl6YEil3bEyN0Rz15FSQK0XuxiU+7PpNZaiN0XD+GAwMjeGF/iJhG6HWZtejEW67KicA1An2j0VgP01ixWq0YesfgWrKmZBh62tFxtJijUbx4/wmfPH7CL/3CHyHPLavNGp1lYntRCLf/ZDJl6Ee+/+hjSMNIrS3m9JRqUqJtFF1ISJ4/zjGuOnabkeVU34xP441f/ufnHFppGUIH8czZbFuMthibMW8meC3P3tD3HM1nZLms3UGBzSLBeUyuMErjowxo92ibV5HRRdwY8WPP+cUZIYPvfbSi2g3c/60rvqlPObo/J8QdL15ckkUoTUNdTBmaQlKfjCEzOVopFtMjjNKsnvUs5kcc3zrGO8e9ecd6dcVme8XiaMHVesWLdk1uC6yKGG0PXHTSnbyHH/d3ruD5OYQMVEzJY2mSc2Bzyd93250o1qPi+fkz7JizXM4JsSNGz2JxJEHqxqCMJXhHRsnbb73JpCp4drXjiw8m3L5zn+OjI6aTOUUxQZtMPN6vLtlsNuy2bTIQLJjP57gxyiL2I44/TOf+S8D/SCn1K0CJYO7/N2ChlLKpe38AfJI+/xPgIfBYKWWBOTJY/aFHDAG9G6iUguBlAEUkA5pqyuL0VT49OyMMjhAE+/zu4zMer57w6rzkK6/eTiwOhc0rPBanPC0K0zTERY03gV3nCMM1VV5gcoVKhvoqKozWIjfXRkQ3scEqQ/A9NmuIBEIYqWvDT379bW6d3GKxmPP227e4ur6mqgr6TgQozjuUBpU3VIsTdF5zMYx86/tPCN2ArS1HdYM5fcD96iFWbendhiyX4N6oIsYoMmvou57MZBRlBvkRrwyBhw/u4gmgNf/tf/MP2G46/uSf/kXmx3OsNmKlazNZLAbHxdmWoqiJ8fO8WOnfghfhWEyePDbLiEQWyzm73RbnPVoZumFMIQk3r6AAnZiUhJsBZwhOhqhpodq7fe75l0pxIE3KP6uXXvEwmoW4V6tGTCYhynsO+b4rP9SreOOhrfbfC6H34YW4HfYDTaUo0WilWA0DQ9uJ0nMM2LIkLzJyWxLCyGoYiNFhshyr5TUyK0HLVVViMo2JERMRdaOTYaWOEdYt69WGbTtwebXi/sPb4ANLW0swxc7BIE23juC6Ed17hmFN1dRkmYiHvO9x2566KcEolDZo78mDwjr5uWMQSp+OjiIrmVQGjU1IvFAUbzJXbxZoOXUxWe/KzvHi4pzrqyvefustThb30Nby7OlT3KD54z/3p8nznIuzc1bXG3bZlvt3XmFxcsJqu6aoCoIK9H3H9eqcV45zfFAM3Zqz3VOWsxOCVYx+RLWXtEc1i7XnonRcr55z5Tq0g2W9ZDWsCFbz5MUHZHmG1paqqCnLijIv6fwI2hKizNcm9Zyhg1df+SLeDZj4nOfZmocn76AU3Dt6k4DHq4Fh7OhdyzB2hCB+NyF6qiKjUXMyNAPpflcRjRGh9Z51Fr1YjYwBkymm85LVVUs+GTm6VePsAmUDn55fU+QF9x88oGxK7p7cYVlo8sLx1pvfQOtMCn/U7DaesxfP6FoZ2OdFxnQy4/btu1RVRZ58dfYpdT/q+AOLe4zxPwP+s/QA/jLwv40x/s+VUv8v4C8jjJn/CPhb6Uv+dvr7P00f/3t/EN6uQyTfduhi3xVGXBQ73KA1qsiJ2qCKkuA0zsPk1j2+cG/OojJsSot4kitUIfF4moBXwsRhAL8b2LUDO3fOz379TZqqwblAl+xw3SjWsIJTIit9aYlKOMh7Qckbb7yWlJ/iYzOd1jRNRdd1kqm5a1GIOdlFHwgbjVYdUYHpAuuQ88r0lNGNfPuTK3a3Jvzs7RlN3ohgpzlGG43zQk9UlQIdKW3O8VsPmNtChF46stpcs7pYEYBv/sb7HB/N+eLbb/DKw1OaZkKWWYZhZHXx4UsX9DP/S9f4xsyJCNvNlrzI2O52kh6T50zmOUPKsdxP3w5JP4kj/dnXlI76YBCQmnNhlQwHa4kfcMfxciP/+a5+r+R8+XsppYlBE0O4GdCyZ8nIIjEOI9erNa88fFXCMLRhYUvGOHJ1tSO2HQHP9cU1s2bCdDpleTph1ff81j/7F9y6fSTD0jxjfnIsW+UoBl3F4IV6CLLgpHUs6sS0DwE/OtZXG7azCVVZoKJmzxpVSh+KbozQ9T02DVi1T3MGFdFGApq1UilblVTUI8SX2S8KYzSTZopRsti//Aiql37/7CE7kePjY46Ob0FSYccgSuGhH9isNwQXyKqM7XrL2bMziJHjo1vsWs93fu9D/tgf+6MoYDNu+Bf/8nf4c3/+zzNdzHjy8XtcP7ni3tEbLE9vM/qB6/lzvhe/z52H95g3GcTAIgw8eu99iknJq/dnbMYBk2m82hLCSDdesd69wMdAMXO0/ozx8hqNoXMFedlw+849Hj36EGJk7B2Zznny6ROKIuPk9IQQvSRBmX2/ITYCPgT8LQdesRnO6NxOqMmhw4cRF8fENXLy3Lge73uqJlKVGfUMDD11M+dLX3qHo1tH7DYli/mCB/caiizD6ozd5pq2a1G6p+s3DH0POsPmIvo6OZlRluVnLCf2ebp7wdwfUFb/B/Hc//fA31RK/efAbwF/Lf37XwP+a6XUe8AF8Ff/oBeq51O+8qd+CZRGKSPwlyJlpGaM7Ji+8ZC+H3jxyTM23YaYW7zvudhqhquO4BwhCj89AqPzEANu7GWYiOby6ppbiyWvv3qfNpQM3tN1wqZpmoY807hNh7YSiF1UOZvNGrHCFpe+cRzx40BwCm0gOM8wujSsSqwIpVAYjB8YN8948ewTFsenNKcLNIpVe027WlGOK7qLM9rbr1FqGajlEYgS0LxnZ1RFxrwsyZWiySzWygma54b/5V/+H/P+o6d89/sfcXV9za//xm/y27+b8fprr/OVL36B6aTm5HhJpjXrVc9m21E1lSx/USWfG8fZ2TlNXaBQrNfXtOc9IUZePH9BlmWcX56zXm+4e/sOXhlMhH70jMFQGIVFJO9a7Z1m4GYl0anbAT86zp5d0EwqppOafF4nIk7qJ9OWN+7Nu4MYtOkoOyuQDld8y28ghhD2xXG/pKiX6pei7zyr640IbUJEkRw1kVQl1weyzNI0E4pENdwHh6MyrCpQHuosR7Ud4yic52qqxKYXXoKl9rsN2TQQwGpFbnJcH9C5QoUorK8IJip0COgYILFp8qpJqs5k66ugKBtsLjMkyeyUYex++C5rQJTPjwEt/rqE4OXPMcUVIu2PsJEgktKxlE87JaFuGhREx+nRHJsXjJsVpYLjaU1Z5UzKgktridFgcstyMmc5W1BXDSio6oaf+4Wf5+T2KVVdcf5cLHyrquLk1i127Q4d4IOPHqGamYjBosbvOt773nOar93mldN7NEqug97b6O4l/wlmMkbjvMMNydI6Gt57/xnOj1TTire+8DohOG6fnhCiCNpQskhKJkBAK8gSXdPYGuUD07rGR087dPR9nxq4HqUhywzogH3jlKwwVI1mUk+Y1DPUULFczKnymtF73t08ocw0MSh2u5FhbBNZoMK1HWVRMZ9OybKSzGYHH6F9Eb9xcZVjr9n411rcY4z/APgH6c/vAz/3Az6nA/7Kv8rrOg+XO8tqdUlZFEznx9gsSa+DWOOWTUnVaH739x7x27/9e+S5oW4aqmrO9fUZ3/iZnxbaI9BMplxeXvPpJ4/ZrK75k3/yl3nwyhv83X/wD7k8e8H8+Ijl8habtqXs+5RTGZN3d3awhC2KIjndBfYb/hglNktrg0++4F0/kBdCmdNaH6TW508ek2Ulk37Fx7/5Lb74zlc5ycVZMtaR733yiHW7Jfvya5hMVug8E/nzMDiyLCPPCiodmFhNrvRByBOjoyktP/eT7zBtGr7//nucnV9QlBWRCe9+733e/fZ3+OKbr5JNak6WcmNfr9Ysbx2JD0i6YaZNlXw8PApJ6/HOY61l8foblOWe561ZzpcyeCbKcDRErDJgSfaycODV8fv7w8V8Ql0VidYnNhOCY94ERe+b9Ru4JVEFlToMUD9/WGtTes3+Sz6rYl2vt+KqF+JhARH7YbGMNUborpUpKQqxfk31A2vFIApgc72iLjP8OGCyAjW5wftVTBBjgoMO7zVx8yV9qWM2rW5+sMhLVNIg4iBjJIA5F+O6xd63O4qXkbVZUobadI7DgUm63z/dPlkSKLAWrE2LTFoB9u/sRj3AS+cknW+koFgrkAHa8urrb5JZOU95kfOVr36V41t3+Ke//v9hGHrefPtV7pzeJi8LMZgjcvvOiQjUVCTLM/KyYjZfsJjPmEwnHC+X3Lt3V4b21hKiIkTFG2+8SVUVPH78iMvVFUqrg49LTAqH/VA4ixGrc7ZdS1lW9D2sd2uMDdw6WnD/wZS+6xiT8VyWiWZBIjkj2sgORaHT8x0xJjKMvcxtYqBQhrJs8IU0I5nN0BruvH4PhdBjldFkpsBMLJmt6AOMY+BoOQci663HGEueV+S5xdhC9A9aH7pyuRZ7VtMNS2n/6+XC/m+yc//XdizmS/7Cn/2L/Po//1Wm84o33/ipm6c73XTjOOJc4Nf+4T9GIZmM7W5gs32GH3t+93e+RZHfFnxRd7Rtz8XVU167d8zpoqHQjo8+eJ/LiwtePH3EtC5Q44ByfRL4WMDiqkhW5IllJ9muzo2E4Ag+kmU5mS1QShPiyOgjhbbkRUlZysUoS8HFJKyg5snTp2Air7/6UHIhrSXEwN17x+zaVhgpOkoAR4y4xLLpug5jNL22jGOkzhS11ojj+D6jVPPOF9/g+PSv8s3vfpdv/s63ePpc+O6v3bvDg8WMZxeX/Pp7H3P34UP+/b/0P+XpJ5/QlHBx/pzgHUVuKIoK5z2bTcsX33rjQMmr6/ozXQMAMbFbAglnl8mZVjCZTPHOp6ScG754aizJjKKapAVO0IbEAuHw6+XyrY1hMp/y6huvkBcl2mafweoPb+ll2OGlh0T+kIKmlWYcHUSPT2In9nh+ksajNNbYw8BNKYl6lIxTRXQ3OgFzyCNVifp6832V0gcL170lbFXVlIUM3+Q03lg4kIrpOIpCta5rcmPZrtZweidFEgqbSgy69jubAIbPQC9KKSZN/bmZhqUoLFobcSJM5r/7EhkjqKiZTiaYrACtuX16h6PjY2xRgLayc0o/r1KaooRqs2EYBc7Q1lA1lXTRfsRHT3CS7ISSBei1199mvlgSYnJKtBmNzQ/FSilDiHKuYvQcLebURjrsjz78gPnxESarCDGCTqEmyuKHHqMM26tLzq5GpospH77/AXX1OkUmq1vba4wSh748l2d4T2XtxhHvPHtqNCiitSitqfISrWSITkCcO0NIpm95uhYBrTOiEpXwukvZBcYyWy7QKXA8Sx05CmL0hJieAWXSJZXZCJ6UYmUP11Qp0aTpqAjhB7U4nz1+LIp722343e/+Ex4/eZ9Tf4svvtWTZTk+BGJM8nQdUMozjjveeeeLfPLkCVlW0487gjNMJyfcXvxxQhR/j3P1nBfn3+anfvLrfOnN1/j07EqYJVrRXl0yyUYyM5Jbh2LNGBRDiGzWSvi6ZUkzqTFGJ9OmAbRKbIwgviKjBAzkJsMYKy6KWuTWMQZsJiHNd+7c4datU0mqGUWshBa1Y5ZL/qJ34t+hUXTDgDUZRVFwdXVNWZZMpzN2DvoIdWYodLjBnqNnWuX8wje+xh/52Z/hk0fP+I3f/A2sivyTv/9r3H7wCs2kZLaY0Y0dL14857c+fI9bJwuqIqeZ1LxcbcU3KxBj2s5z0xEeEFulxMTLR7JMzMVuZzV/5s/8O1hjKIucsswJSYQjX7lvL5MXikowymEN/2wnEqMk/DRNw3I2STf0DehzMzSV96Nf2r7eFAv5u01RhHnK32zbFusc2ipikK393qkyy7I0gJXv09Qyv7BWFtQs14ToJOE+qhusPS1mKuExSsnHjNbovODWrYaytDS1qJT3P+04DGmHIF2xcwNVnVFXBV/+0tuSZOQN9+4sQUWMTrlJClQyX/vsDCKdk8Ml02S55fbtuzQp0F0C6EeGocf7yNBIcEhVleRFSVYUnJzcpZ7OQGn8S98g7GcbMTKZTvj6T/4Mi+WS69UZzgkLCaUlOQmdHDMNb7z5Nlq4hcIKS1iWSgYTsmOLhP2YRdgOmEygqTuzhrrO0UVO3/eUec733n2X05NTHn/wiNW25ZX7d/iXH36Ln//FX+Dy+RnTn/4yk6pB1RmfPH3Mrtswmdyi67aMbiQgHXxQspMVyb8U8sxaVJqlDP3A5eWGrutEYEaUGtE0BztfqzW5lsS3vbp4v7tQIRx2pmafWRyCsItCQHmPtcLMCzEIBJVo0fv/RyJxdJCLl9bva7o+d/xYFHdUJGSO177wGiF4fv2b/4RnHz3BZqDnGXF0+AjDZceTJx+jC8PgBormhLo+JrOyjb0I3yIqGfx88uI9QhjSiRl4tn3M13/hDaJVrGcd//iT38SrfYAwKG2oaCiGO1gnmL02kaIo0FpYK5v1WnymDVgrA8d210p32UwYujYNPmQrpZOPfPDiJy5xaTphn3sqVjJ3QuNGiXQzRjO4jn5saaoJPnrOL18wm8ypipLr0WFQlJkCrbABjFJYDEWe89brr/Dw3gkvzs74vekdLi4vub0suLWYsW1HijLj6vKcvLR869uPuXv7Lse3TsXOVVsMhltNwzf/xe8wf6uiWixRWoQ4mc2SZa8Ed/S9eNnn1lIrQyCijU4dpnTBR8enN1+rFV23kzzLoTsoMEnqWdQNO0Yp2YabBDuYRHcNcb8tv4F/Qvqcm6/dd8ew2fZoa6mbGUZL5zT6yNj21E2eeOsqbY+lGHXjDbNIx0gYU/ixSngreSpAIQWDv1RQX8JDj4+WLBdLmSdpI4PkZEtMDCzmM4ahJ7MGhaQAhdT5G6NRJuWzqkh2eFplTLwv3jcJVPJLK83y6IgsK8hyaRLyvGAymdz4ikfE9THcdO43WJr8LMbKQhOix4fIMEah+HmFiwOZlXDqN978EmhHJNA0M7TOU1C0vL6OEgby+WIk2oR9p4zYTKeg69EPGKNYr9ZcXVwwa2r+xfPHNJuG+9WCf/xr/4xf+Qu/wje/8x5fVhO23nO+2rI8cvTDCIjJ1tFySZlZgg/cOVkSg+dkXlOXUfJigwRneJVjbU6Mmn4Y2PU7ycjtO2FIOc92s8F7sTSISHjMOIwSwhLA4Qh9e7Bwjn6UhULl6R5VqUuXa2DMntaqD3kAxhiCC8TsBnbZF3iTfLMEsQmHZKofdvxYFPf1bs2v/fY/OBQ8jca92KFnJWa0eB3QRObOonCMoSevSr769Z/FVguRhycrTW0MV+eXPPnkAxQwBs+7zz/mWf+C5cMpIE6Fo3eC3MnuDhsUVk3E+jXdbsPQM5lM8F7sOoXlIR3GOA6MgxghlcmDZBwHUc2mgmWCUCyLMqfvBdffUwS1tQma3isGBedH7b0MBcNebVZkNqOpGvq+xzkvO4SsYN2PjKNnahWFyTEaUW6GgFGSZH9lFa9/5Ssc5ZHvfPSC3/z2c77y5hFFaem6gcXRCU9fnDM/vsM/+8f/X3753/mjdLuePLN8/O77/OTXvsorb3/xQGnc+7nvfWpucMBUeNX+RhQTqsOW/yWq4zQuIEZhIYyjBHh3HevNijwfD51TjDrd+OKEpwgH7OZl7keEwzB7/972BS8Cm7bFxwja0LUt19dXMlRNnf5iPpEOLm2XtVJstjuW8waI+NHR+UhTFWgL3jsp8Eoen7Af4HKoi4edg7V7YwB1WMQOwRrAgwf3ePjwwaFr11qKvNEZeVGIZ7cPwJBeWyXdIyidKLzWkmU5eZZTliVFWXJy6+QzD//+3BwG/iLsSJoKnYaTHKLwUIph6Lk6f44PA3luGMYMbRxhjPRhS2amlJnHhRxMj1KVBMuQC3SXDPiefvqYTx8/4ms//Y1U9CM+egnnGOR6d13HRx9+yN07d7i+OOdX/9Gv8id++Y/x+PEjvvkvv8m/+6f/FN//9AXzSc/kVsnVdctu57i62gCWrh3AGAbvRZdhlCyGMRDwdG4khAGjHE3eUGqhEoPF1DUBjfeR7ehwUTx5FHIPB+fIswzViO34ZtiCUhgt2g2hmAJezNM0e7sLJ7OamCBArKRM+XggjCh1g63vcXZIM6RkN/Ey1i5zKg5f86OOH4vijlKoKPhl1NA93+IuHeq1L/EwbFmNzzmuzyj0iMl6lC1QKsNkQhW6OD/n+uo5R8e3aWZLUSYCUQUen31Cv5gzpiJqEeolQR59jWznrbLEUMoWOk2VxnFEKc0w7Gi7HRHZLjl34zVirTAsvA8HD5KyLNOPlVKNNht5TSPFw/sgmRIvJQfFIBJ5m+lD97qnyDk/stquOJ4LBe/s/IymrphNZ4whcjGMFMYwzTR5lO4/L3OmzYRFkVNmmrffesjO59yNmjL3BN/j/YTnz59jjIQU182Ei4s1H3zwfe7+qT/KL/7Kr6AnC7bbjkmKCLy5ZDehFDJsTIOfkGCCtKUmURdfPuSGj+jMkGWlWPESOQm3D8VHay2pNTESwsgwjvRtR9e19GOPC6RO16KUGHft2RMHWEJJAdwPRiFwcXlJ2dQM/UCRtsknJ/NkbKZwfiREz+nxAoXsFl59eBtjDZkVpeBme4XRhrKoKbL8UKj3cqF9diZ7uAkRGe1xU60l/tCanMViycnJKTbLMUbxq7/692n7jjv3X+GN19/Au4G+H1ivtyluMEoiUpYfLIH3iUhKKYy2jOPAMHTJnvemoO+1Bofz+xIqv1+M9jF+PgZU2mlanUvurQGlLVE5lA/E4HE6JB2Ex7uWIisQK6CA1rI4eT+SZ4pxbNlcd1xeXnHr5Jir60v+zt/5O/yJP/4nUCj+9t/6W/y5P/tnKQvLk08+YbOSdKeuk5+lON/grlp25YQQPUWZEfDk1ki6WgzcvX3CV4Y3uX96yn/wF/89pmWOUR5jI4tipO9bcr0gIq6iERijZ3SRcQyJWKBZzBcYY2i3ElKdZxnRhxSt6BJ0JNbFzmmsydKZlHtRGX049/vuPATHPsBEpbD1l8//gY6s+Eyh33/8ZdbMPnT8Rx0/HsU9rUwxKkqT8+DOQx43gd8LgdtRMSWgu2c4PNHK4A4VUUaKS5Zn1PWcLCuIQTzYldEYY9n2G45CKQ+X1sJ9P2xBFSp5XFe6gTGlz6NSMIUUosvLK6FAKek4uq4/XCSJG9OMY/KR32OtWra0cgNIuDYqMvQuDYKkaz9MwhObQRpTJelBXmhaRhuUQXixpaKuK4Zh4Pr6islkgs0zeufp24HaKiZ5RgaUeUlRZvixQ0VPZgyzwrLaDvziL3yD9dYRhpbzqxVuHLm8PGMcHjA/mvFi2/Kdsxf88++8y92jJX/8j/0c282W11579fCe951DTJaPEuacFj2t0fkNTPHyuRHWy42T4R4vx3z2hldK4CajCzJbiGVz+n4xYZMKePH8Gauri4PXz8sMhCBYDdFHopaQjs12w3q7Jm+E0UEUvrrSCmssEQ2FSoNhzXJZ77lSifFiUEhM4n4gDBwCn0mDOGuNKCttJpmbzUS6wbyiqJsUQ5cGnEoRg5OBcfTkVUMzW2ISinIHGaIKni3/Zl7q3MaUo6u1TfbLQ7LYJV2bcIOVH+h1MbExwqHw94k9FoiMKQC+qkrcGBIQplN4ekOeVdg8YlJ6kUpe7UPX8vz5GcvlCX275uzFc2KIvPu973J1veYf/aN/xH/8n/zHGKP45PEjVteXNFXDbr1i7HoMI+22k2sRxNfok6fP+N1vfYeyLHjjjdeYTRuMhp/7xk/z4M4xX337Dg5Nk1e8+dorqOhZTgpiGIlRGGCvP7wtts7eM4SMwTnavmP0ARd0YsqJTXEIMfmvxwODJs9ynJNkrKgEpjO2wOZSa7SSTOD9cFRzcy+qPYMqmd9551CfY8iIhkETVPhMbCPcFPM9q+jfNM/9X/thjWaRN/zaex/SBcMvH7/NdtgxUQtUvMcYPyGGyHR6ymbXCX5qNHVd05SVbLOMTdaqAe9uKBj7BxEl0IVKXZVSigyDDbXQkdhT4DwxCGeibVsRvhiVgovjZwrIPkarqqrDxRrHQb4vkJucPLNMJg1jObDd9RJskSAehXSEMYZUhNRnCmYIDuUVufL0w0DX75g1UyZ1w2azRSmxNzZZRucdQzvQ5DlW52gUk9LILiX2ZEYzKRWv3n8dozXvvPEGv/Evf4+inqDCiNWap4+fsDw+wY+eYRhppjN+67e/yXvvvc9f+Q/+Et/5znf4+te/Rl3XHLjgGJyT/NcYIzGZKGkjdLt9cTmoTY3FaIM1ibUROSgo94fwkG82DEony1wt9EUdNUpr5rMjjDJ0fU9VBbRWZLlN9MjIi7MrKd6ZIUZP3/fstltOZwtU1AfOSPouCWLaS6BucFKjJU9UG433DpNlnN55QJYLxlrkBVmW08xmgiUrJYuvERop+wEyGm0yQLo1lNwnIcosx2aVWF5ET/QRkBxbpbUosfc7k4TVWmNEh5rgMe8cXduhiPI+jXzevoOU+/dme78/w95LUXHey1AQoYrmWUkwkX4U7UOWZ4xOiAE5OYbAr/7DX+f41glffueLXJxd8Df++v+D/8lf+veZT2fstluiVuyuW/q2Zbtecf7iBTYzdLsdCihyYczMphNEKeFQOlKWBZO6oN9t+MmvfIXz8wt+8itf5Rtf/0nKPOeXvvENMTjTkj+qoxHxY/SEMDAMTuYrY6AfPbvB0Y0eh9hMaFVgrHTgo/MoH1IsozCqghvluvtwGPhrrQUHiIHgI0pZrM3S7m9vTQ1oySzYs3IyrRAX1Rv4y6RCvb8+ALkVM7t9dsC+zghEk2IuX2qufmg9/UPU3P+/HFFFMqPZXG754NE5KigWZoF9Y8p8coQPJ7z/8YS++5jm9oy27zEmYHJD8CMhSHDyMI4S6ab2drHSbZlE25PvlTpGIytqoaeoMcdY6a73+a1akSiYDoWW4NsgJ72ua3mtl7rYPM+x1qZU9RE/SsDunrssASAZxEFCIYwmpG16lgJ799QRrWUFB4lu08ZAIQtSiI7tdoMbHEfLJZvNjqfPnh3CIpTOuB5GFIH5fM5sIu3fG6+cyI3lSnSIWB3Jcssf+cZP0vaOaf3nudqsmRQ5NiiOpnPaqzUXF1cUVcbRrXs8fXHBP/xH/4RXXn2V3/yt36YuLT/xE18jBo8Pnr4f5Ka3QrszUTM6l0I0brrGrusoypwQs8Qi2DOR+EzXYoxJxVWCO14uTDEqggtUVU1V1YcFZByFBSJJP56HD5I1qtZ8/OSpuD6GwOuvvYmOIpPvXvJn34dggGIyOky6rnmWMfQ9ZxfPCN4zXx7x8PW3MHkmuxUj3XVRpIxXFRPEp29olyHKjkPJwzw6J66EYaBvOwYfuHPvVdp+y/e+/x2aScVscoTROWVRSXeu0s6UvV9PSItjRCcocOh6nB9lgdV7mqXg2zZRKb13aQ4Q0vAzOT8q5Jr5SFVWKBQffvQRRVnQTBtc8Py3//1/T1U2/Mqf/3OA4vGjJ2xWHV/6wtuMfU/XtlxdXFAVGUVRsnMDk9mUXMmAetrUeD9CkB2lIlLmOVbDdDLhl37+Z5hVObe+/EW+9tYbvP/hR3z5zTf50FqaIqcoNNF5DAZjFdaWYvTmhe7a9p71pmW7a+mdxyuZTRhbSfyld4n33pHnOUEp+lHU6jFGsr1ZevCHeM2Q4Mvdbie779TgueAZslF2TWkoKtCwqNhdiOTWkFlD8OBcojgmFsweW9/feyiBYn2KBnOjk/mKMRgttaQois+Ej/+g48eiuEcF0WoZXpjIH33rizB4wvMt3/gjP4NeHvHr31lzuSvo/Q7hhWh0dFw8+5R3v/sdbIic3r3De997D23ADS0h0eaUTui6gqD2LAOVOmuNiROCN6hsTzETybVstdKDHpMRlVKUVSWBBqN0qmr/wChZzfcXIvggCtZBzMC22wRPxDTgSjuJPda237oRI1oZ6Qh9QBuVeNgyKXc+EMOI6x1udBRFyXw+4+rqms1mzXJ5RDNpCCFwdHqK0rAKGVVWUBh5fedHGegQiUpTVzlfeOMhbb/jzVcf8tGnZ3TjAIy07ZrJ7IQPP3rE6689YDqbEZXi29/5DifHS+7ff4Vf+7V/yk/91NdZzGfEAEF/FsOVYBD5efuu51f/4d/j6z/9NR7cuU9Ush31aSi67zAVELzY4GotAyxj7YEzv98y7wuWSlyzwhiKsmI6SylDabFwIfz/qPuzYNuy7DwP++acq93N6W9/s8+svgqFhgQKREuIIEGKpGSClKgwTVIKMcIhKew3MfzoJ77ySWGGIywpbFkSbdGiKAqUTYESCIoAgUKhKVRWZXfz9qdvdrP6Of0w5lxr7XNvZpUjJEdqRWSee87ZZ++1ZjPmGP/4xz84Oj1nVdRMJ3Puv/KGT2IjGv0eAmia1nv9YnzRvnjIGJqqlCSvtUwmU7a3diWhqkWjByXz5RS0TSVKhG2gHbY0TcW6WOGUMLHWvouTUO9SvvjVr3Pr5h2KYukPhJq2dVjdoXXjk/YGpwzOef2huhHj4DpiJRTiohLPXWlFlia+UC/kH3xuBPm37cSJsH7tnp5c8Iff+S4//ENfJ0lyqrriV/7RP+L+K/f5qZ/+Y7RdS1EWrJYVlxcLrLWcn58Txyln52fUdeNZJClxoqnajsUyYmdrQqTXGOewdYXWlrdfu09mYGuS8m/+lb/M3vY2cWT4hZ/5KdpGeoyiNPdv7vH7px+QJTFFURJHUz93mqKzNGVJURYsFyVlI/xxkxiiNCdOHapt5L6LNV1nBzaSVqyLNW3rufqeTRRkLlorUUzXdtRtI4l5I3CsUqLnL8ZZpKt7+qJzntLoYRzrKIuKrkNo3j7xu4mtO5wzNE2HdZ0Xp/PNWHpm2PAZ13H569dnwrgrJNLs2ponxxd8/AfHlGXN+v5d/ujeDeYHd7Hv/gGv39/l3d/zcqrLgvf+xT+jfXZJ5iwmzTg6VZhih+mtY1ZRS5cKb1mMeODMBdMgYW6sMlSXoFWf36SpG6q6JE5i4QF7PL1tW9IsRWlFVVcUxRpAOpq3IiFcWTHoAt9oqdZT0FpLs5bXm8gMXp0esuGyaTtoLdIODv/6yMNACmdF1a7zCoDOWdbrBUUB29u7VFXF2ckx69WSnf19kiynrTrO1y3rWDOPFYmW0vTQ08g52+P/sYnZnqTc3d+h6xqutibs79+gqGtsJxv27OyMoihR2nDj5m2ulive/d77fO4Ln6O1Ld/87d/lp//YTzDxfG7wnjki+KW05vVXXmOSzWhaK/CBktxHiIS6rsN1FmOsMJt88jqyncdiBwinL/TQ44pLMVSyiXxi1QdGk8kE5STpHCUZnXUkSvWYZuLC2DrPxBmwao1CGyMcbqVp25LKVnQOinVB065pujXWOuqyQxvF3s4dLi6foVVOnGjSLCOKE3Z29lmtLiUa1BHGxKAUcZxgVe7nOeiIQNN1rMuSODZ0nYT8eZ5wdXFJHEu7x9jk0olLG2xbo7Whblsi/zxlWQrvPJGIqWka/uv/+ld4/fU3+fLXvoTFsS5Lfvtbv8fnPvclZluOy8WC5XrN5dWCy6srlHIsrhbk2YyyXElUajuiVOodinXR7+vYJDRth3VTokizvT3jT/zCT5EnkKU5/9pf+PMiz2Bg98aObxouGHfn38SiiaKENErZ3TrAuojLwlJ1DVVzSd12WCt9XeMkY2ueEMfSS3dVrLi8vERrycXVTU1RSou96XRKbGKiOJK14iO9LMuY5Dm1p/k6kKY5jXRd097LTpIElKJph1qOcDnfZNzEvvl82xDHKVGkmM+3aJqWsq77dRVUU7vOomjAKVRkuDo/5fGDD7l3/xVmO3t0Jmgvqf+FwDIOVGOpsVxcFhyfXQpTYWeL6e4BBo2tSm7uHxD5Hbou1jx+9Ii7yR7z+ZRSzViczFlXUF08xbqOKNYeJhuMhlLKNwSSzvORmtFVSOERgrU3bYkxiu3tbawVD8tay2QyEdqWTzqlaQZIgqMsy96QmciHy64TQcKuw0Si1+EQTHg6n9J2LVXTobVCEBlvVFDYTgocYp0I7t5ZWtUSGV+y7NvdoTqUdtRNzenZIfP5Fnfu3Ob0/JTj4ydsbe0wn+4SuYi2qTmrW7IkITOK3EiDC6k4DbxwhxRFZbx95yZv3b5JPt3ivQ8/JtERqXLQtcRGYbuOJ08fs7+3xySfMZvNODk75r0PPuQnfvzHWSyW/OZvfpMvf/VL7O/v4rPIxCZi94uf45+rhj/mHHOhktBa1xtSmbWeed2Hr07wB/GOPBOmp3j7BiJhnm1re2xUxwmr1QoQKuN6VaKNnxPPmjGIcN1YrEzCd0ddFTRNy+X5CUmWk04nLFYLvvPe79KYmlu37rEuC9quJE+mGAU7O9tEseZg7xaoFqNyohhQBq1jIp2RZY0Uu3gmjFJCmW3rWiI/V6GV9N5FGcqyAJfSNIDTZGlMWVd0ncJEFuUa8jSlriuWiyvySc58PpMm3J3lv/qv/yE3b97k53/+53FI0+uLiyUnJ5e0rcUpy+XVFUVRc3W1YDabMJlOaJqaNEnI0wynZB7i2JCkmqr0hUs+4RtFhrffeYMsiUmAO7s7LK+W7M53uDmNuX9nz0evVprpOIfrHMqJxLBVeOVG65vGxNg455V33qFu4LQocEVJlGQkyYydaUQUJV5vxxB7SnHXWdo2QuGoqpoOi9OQpKmIvumINPbOWlX1TDdpSC25i3ApLa0r21b2stJSxGfiCLsSx0Mb7esGZD2K0ypVqs4NOafFYik4u3dYrLVUZSnwYprwB7//myhr+PKXf4Tz4+f8/rf+KWn+s+zcuNM7PiFa+LTrs2HcARzsbu3wEz/8No++/V8SOfj8vbuYKKO1jqZekxjJNl9dXdF2HbVtKQ4SZjd3cU3DVnaCWi5YLBbS19DICAedbeu533iue2xjIjfDKoXTJsi5EyUis5okEcVaoJg4Fly1LEvqtun53iDeD4gBCq/TSqMN4hWYwUtynnfbNi237+7x5PERnRpRm4KiYGzRytBp56sJWxJlUKZFK99kAEfnHCLb1eBwXF5dslqv2d3bQytYrQrSZEu40FkmbI+qpmgcVayYJBArMC748dA56+ll0pvFYvnCG3f44uu3uFwu+ckf+TLbk0ikB1xHnsdcLmTcbduxs7tLmk85vbjkN37zd7n/6qvs7u/ywQcfYVDcf+s+V23BP6srvp7P2dJKSvHtJqNGItHB4PcJWQY4QWmNbRu0EfEwrQ3j5FTIhxSNzJtzlroSWKG1HcY2Pp8op4PD0fmqz6ZpcXS0raOsL4jjjKJZ8rkvf53YFxtleUJrS27uvc4ivqTt1iQmR+kOHaWAGIg0TelahbUNXefQ2pImmfTK7Vqc61DkOGryrKMuVlR1g9YNcTSlaTsinVBXtS+DF+ErrOX0+JA0jtjZ3cKpFU25oqgK/u7f+3v8zM/8NF/9ypfpLLQO1nXD6cUVRd0QKcditeJyecFeeYfVuiRJhaIJitl8xmzmBcysJTIQGSUwkAJNh+saIu34xo/9MLs7OySuJZ3G/Ov/yr9EjFBkk3nMt4sF5xcxNya5FOkgKWutxZg7FE2naBWUbUtRViyWFXXTUTUNymiiNCXOIxI1HPsCySU+zyHFX7JeZM0Y3yWsaRppUWLEGGinMcqQZ5LHqH2VsFKGLMvROOqqElkHFE6D1V7sVyk6Zymbkp2dbaaznLbtWK1LOtchonTKV6oaUq87tV6vfQQa6MP4fJ4wrRQdTbHk+UfvoZzhi5/7Enfu3uKP/+xPMb/zGhiD8evZmJjQPOaTrs+EcVco3nn98/zRL36D1YXj//P3/3ts2zCdzfCoMLvzKfNJRhIbtra2iI+l0e9qdcnq4SXZlsZMYH8n5na6R5rc4HvffYRKI1ykPW1ODScqikRN6UoJ63uaVyTMhK6zxHHCWXElDIK2pfLJFh28cBcKPoRNoUMhTydeZZqkvYESmpqwPYyWxMzTJ8+kpD6oHSqN80lU0WYJGt2BOSI4ngviV87IJHfAqIS7ri1Hh2fMt6Zsb+9jIvH4iqJge3ubLE9p25ZFW7EqYJ4YpkYTOeHfyx3ovrweLDqW5hQ304Q/+4s/R2UVX3rrTabTDIPyUYowhk5PT7m6uqSqCmZbW0ymU5qu49d+/deZZzk3377LvOm4UxS4DtrZNtKBW/VsjuvCSWMZgR7HAw9naZq2QStDURT9QRkKQGTclNQidI6Li3OWq5KrxRXaiBpk14laYOc6mqZhOp0QxaKJb4wDZkwn2ywXK+JE1Puc08RxROsqFAlxlGBdJRWddQWtw7mGWQ5FsUaRQqiKRkL1qqro2oagF965sg/PbWd9xbIUTD1/9ox1cUWaSgl/WVasS8Ov/uqvUhUl/8a/8a9htdBKy6qkLCsuLq7oWuFn103FarVkMpFkpnOWLM1QSpNNUra2ZjgnuSacGPKuazCRJssT4khj6Ei15hd/7mcxwKSTfrA/9cNflIO3a7HKN+1opHeu1hHb2xlNLdoxA+deukrVHVRNS7VcsvJRgNBEE6I8JppK8reuK085lmh5MplIE25fACR1JRJBKBWK2lRfEFQ2NUpr2VujqmKciAGGnIt422E/SX6i8wnrsCaFz25ZrwucdRL1EGixARwUpzBNE5qm7ddw53McaFFRNUrmOFKOfF3yJ7/8deHBdwv+n7/9a1xUljcuG37ph2bofJvOr+kkGRzMl12fCeM+zWf87I/8aYzVFO6cGzcOmM1nxJOJhyQcn3v1Dnv7BxzsZkSRJp+kvPHaq6yaS155fR8bddINSHv+b2d4//0nvtUaQycVfCGJUyTMqK0lCUU12opAmPIHAYaqLqjrTQ676ywtjRhjf3gGo+9EaRhjIpEdRvDe0ExEOaGngaKrfNgWkr09R94Itmc1VqqtcA66znltbes9jIz5bAtrFev1FXVd0dpATXSsVwVVWfHmm2+hVMLZ2THr9YKt2VzadKUTmqZhUTasjWUaGVJlSYzqObrO991UzneEVHLwxM7yx3/6x1AYjs9OeeuVO+zMctal0OXSVBprXCyuuLi8REeaum3YvXGfqVXMlhX/yrMzovkUtneQlLemaxXOtX3FnlJqUDx0UlgWJRG17Yi08VAW4ml3klhsmqbf0HEc45xopOdJhnO+9FsbVssl2ljySS5ji6azNXXVgKqJ4ow4SiQK80Jok8kc6zocLU3jaNqKuluTp7tUTUFZrol0QtuVYmBoe6zbuRajveiTM0wmte9TK4bdxIq2cnz04CPm05zpdI4xUiRktOa/+Yf/kPPzU/43f+0vk6cp0yzjwuurr5cltnY0tqJpG7DQ1g1JlLFaFGRZitHOw2IxaRKTJgnL5VJYSs63l1SK2Gi251vgLLFRTNOYv/Kv/yUMHYlr0caxc/cmylq6ppS903W+4Kz1LJIYFftD33WkuqFYVdRuB+scVaMpypqqawSSVBCnKfl81ifH26ZluVqwKpZEkWg3TaYTmrqk61qqqhSSAbKPehqiCgxoL3CWpsxnM1ivpAZGKWwjDKG2bWnb2jO6JEKu6xqVRH2yVCJ7yXM1bSNFTW3LvYtL6jTlcGcbfKWwDlbGG+wsk+r1tu1eqMHAR6HiqGiyYkX3K79G/MEh0XRC96e/zvHpCQ9Lx/H5BT987y737k4xcUqaxESR+VS7+pkw7nkyIenEoMVRRJ6n7Oxsc+PgJoHv/cq9OygdkcSGNNbs7E545a0bLG2GM5bOe7wK6ZupnSKOhYrU47KeoKKVIrIZtjE95U40XyCkGeM4IU3Ew7VWFAXFULgBEjCbQlWdT/YJnibKiAGLs06y/tpFdF39QgJGOqxEUgHXVqDxlKogzi8YZWB+5FnOzRs3RIvEQpZFXFycs1qtsFY8myzLxHhfLYiiiJs3brBYLLi4vGS9XrO7u89kMsX5XqsXZUUaJeSxIafxokmDdK5zwh5ouw7lkJJsAzd3d/hrf/mXQcP7Hz9iOs2Fioqjsy0mNuzsbhNHEatijV4U2N96n9v/9F3if+1nKJ0wzUW3Yxhj7TfDJMtpfPga6KKxlmgsiiIa2xGbCOVk8wUDL5IQDcGDWq3WpGkqvUGNI88znGv92EqBWtvWws5pLUrFKKRisbMdWTpnuVxhIoH16rpFKU3dVnL/rXiXTkPT1pjIYF3rcVJJHCt/b0ZD13ZkSdbjr0kS8+jRKf/xf/R/5U/9yV/kz/yZP0scS2HR1dWSrpM6B9s5Li8vibS0/lutlmiluLy6Yj6fkHiJYqU0aRJz42CXdVFgjFdCVCJ10dSVFxS7yXSai2GyLW++cot/+6/+RbbzhMw4psYw2d2layqaspAuWL6OwzhwvgGDVgoRVvRa8p7RU7ewvTtn0hmenq1FesAY4iQlST0DatQLQeQdYlCBTKBofZSzWC6JtMhg5PnUs1TA2W4w8ghcCGI3kyQRNpKJfP9ZhVPC5AqMt0ATlb3dSUtAT1G0OKyHDI11vHFyyv/qt77JXlnx8MYN/u7P/CRFkNB2wUkDYxIvL6z7QjZhfkXeWQjgUodylnp1xfr4hO3Fimq1Jj+94sfuv0r18BkqyXF5TlMumM+2erLAp12fCeNe18L7jmND16yZ5zk//iNfZ39vD0dLKMcHx3SScPfuTd75ofs8vHok2HQfBoHS4mFao3jn668SxRKaK58jk6a4EanboqkbsiT3Ub40bVY46W6fREJ9sq30UNSjAoYRBSlU+gmVrKW1goXHccokz4njBIf1FCxJsA58YvHSJ5MZ09kWZVkKy6YWQyP37ReMs9S2QzlHEhumed4XfqAhTXPieEVnl3ROusFnmbSFa6uWuqhYLi7Z299jmk85OT3j7OyEolixtb1DkmaYWAzPZdlSJwm51uSuQTvJV+AGyQGjvaaLTxynUUznOt66d4v//V//10knUx4+P0arBusanBPPaHl1hXt8xPqDR+hySboq6YEynzRVWjZIEsWywbx8Ln3uQ/T0sY6m6UizlLYSaMMYabeWpilVVfl6BkVVVqRpTOdanNKUxSWnx0fM5xOslXxErCPqqqOtO3CapoXOVmgSrJOeu2VZgxHjVJQ1kY5o2wasSAkrf1BFUUKaJIChWC8EokN0h/7Rr/wKx0cn/MW/8K9y7+4dtra2hAudJGCFdlcUlYirlZbFcknbdrRdg7OW1bIk1uASxfZ8jsGhI5jPp8RGkcQRz6sCa1uaqqIqCvI4ZbFas79/wHxnC2c7sljTtQ1/5Zf/LBpFrAGEBqyTjLZraJuOxhcveXxQ9PydldwEgFMYp6QZtU5oWjhfWcq2FvaYc+g0IU8ykiT1DJOaoiwpFiVt15HECbPpzEMNEkHX9Zr1akFRrolMRNsKhdF6bD3IF0NosD6u2hycJ3F0JhRlRe2hmSiSeWu6qG+0I9RDRxQpsjRmkmcUSmSY7x6f8qWHD7lzcsbuumB/XfCtL3yeD1+5h9rZIe66XlPKp4swOiI2sURlaih87KzD+e8l6jQ0XUXZlURv36J1Qqg4KSu+8sodZsR0Zodb81ssL8/JtgpaZ7m6uvpUu/qZMO5d17BcnLOzu8fe3i5/9a/8r5lMc7SCuqoEdffG8C/+uT/Nd55/jw9PP6LVHcrrROMEv7JIkYtzjsls4k9wnyz0VYLaRSgbAwMODgG/FT81SRPhknqt7YDPheTeGBvWOngLssjSNGM229ooNIgiw3K5FM9r5LXHccx0OmF7Z0a8ViyXEoJqxDMNxTHhc7uuYz6fkabZQNdzQUUwIpTCixJggkJTVzXWSpLx6PCQJMvZ3dmhaSqqYs1hUTHf3mY6laYczkZUdUVVa8o4JVMNkZN5MMpHFIQqPo9t+nGMI0MST+ms4WBnxi//y3+CN+4coLo2dIzg8r2PpelIGtHkxlfrIeXb3mMXCYgGHUU9fo7HatM0pqpaqRqOpJVgEsd0rbQBTNOUoii99DI0VUOeZSyLJUWxFikJIE0TqrLELTtMUtK0ljyPSbRhkuZoph0eGQAAiIlJREFUndFR0bQCxcla7VBYrBKpAuGn5zjbEkcR04lIE3dtS7Ve0NQN9XpNVdUkcUqaRCyvLjg5OaYqS7qmoSlryrrhdH1CW1fYpqUqCh4+eECW5WxtzYm1ke5Nvho5TyOKYo3tOjEmDmbTnKpY47qW2TRnd3eL6TQDOtpmxe4s4S//q3+GKDKk2mFcA8aJ+mNIQvu6AaOhqTtJWHsDTTDmvmChc5rKQesUVeVYFy1tp0BZlHHEccwkyYliOaTLsqRcXFE3NQ6FiWOSLCOyHV3T+QrnYV8qJftmOp1K/sR6umrXkiSJZ58NKRjnodewvYKWj0KTpSl5nktlrc9lhPoSafLiyCcT8jTFaENRlNirNV959Ii3P/qIdx49pokMrTa8+9qr/N2v/kucbm/JuPicXE+Z9dBPZCLvDMq+DcJ/Do321Gfw+bSuI8vn7Ly5xfR+glXw6+9/TPdxxa/++m9Q2gl33/oS92/f43J5RVWVjMzIS68fyLgrpR4AC4TL0TrnfkwptQf8Z8DrwAPgLznnzpW42H8b+NPAGvhrzrlvfvr7d1TFCru9RWg0gA/TLc7T82Tini2O+ej8MY0WqVCngmgTPjR03oPyVYGevy2UGenykqsZtjHEJu4Xs9S/yObpmoZpPqVpOrq2E6lWFO1I+AfC34XM/YCzzWZzZrMZWZYRx9I1B7XNXtN4yphcTdNweXVBkuY465jNJkynKefntU+wASgSj+XVXU0UJWRJTmRinBu44bIRIvFsGythbxwL5961XrRIFnO5LqirSuRob9/m+PSCi4sLlkslWPxkSppNabuOddNQKkUST0icZeIatAX0SF3QDQnVznvcWml2pjN+4od/iK6tqTt45WCPJE+JS0jv3sIeFly2FRMt4I/rII4jqkqqBjvrsE1DEidYrxEexzFVWaG1hNhtW5OmKW1TC3OCiGJdkKQJXScHQJwIXTCOU4H5PDBbVRWxlr6hVV1LhbLTUuWsa9q6QMeaNJ+QZlO0U+xsbdHY2tccSA4kiTKuLi5IUo8JVzXEsLQXYGCa5rR165P1vp7CWcqy4OOHD5lN5ygdc3CwL9GYbUnjiP3dHaI4IktjYYg1HcopqnLNJJkRR4a6aphkE5q6oipWTPOMYrVkbz7n3/4rf4Uk0qSRrKWImjwRqYvQj0l4/K1Qbb2GfeKTHAILRiht6JqG1ipKq6mblqa1lFXDuhZ40sSGdJKRehjRWkdVFZxdnHntdkWe52SpiH011rIqV9RVhXOWxBjSNO6pgxDowWL8wj6N4wQdSzI1JMzDcwTj7m3WQKl1oh2UGNkf67UUMjkXCuHEOC8WC9qqYltr3nj8lNe++x6vPX5M3Las45j/7stf5Ht3b3MxnaKNwXn2S9BaV55aqz0rJzDq5DWdz5u1OEx/v6FxR5wmUFaY538Aa2EHvdG2fPN0hiPhYl1wcnbKfJZJh6jeJn7y9f+L5/7zzrmT0fd/E/jHzrm/pZT6m/77fx/4JeAd/9+PA/+B//qJl7Ut03zWh/3B+xSvFPCMmQ+efcC3Hv4hjWok0Ygk+pSnHYXJNVbgAkmSuv5BXeeInSbRQi1Ls7S/hzEjBUA5xWKxCmeK4IzjYhYfYskEiWeyszvnxs0DdrZ3ybLJYNgRLF9syvBs1loePX5IcGpVZ9jb36UoBk97EArSPQ83zyeDcXeDup80pEiw2F6wqos7KqphPD3/yHaWy8sL2rbm9u3bXC3XnJwe8ezZM5Qy3L17jzzPiaKYtm0oqpoWg00zMjpyJzSxQR2y6yOLTvl0tDLEnraZAH/hz/wi2hgu/6tfJ4sNDzPF50vDZdsRRymddTRN7UNmT0GNBIaJ45jGdj6hGlOUteROokgaN2QZzjmW65UYe1+QlKYpVV0PY1g3fQFP27bM5jPfKUiM/LooSFPRiNGIQcZriBTrNQapIIyzBKthvr2LBpq6JZ9OsZ2lcTVGR9guCMH5+beeR+HbFE5nM+bTCTNfTdzUa7qmASf4fdvUlMWaNsuoyjWus8QmIjKK5fKK2WSCM5Y/96f/BEZBploiW7E1ibBN5ysbvdyB09BKbYf3ZKSdpHIBKqbzyRWrPOyiY+pWc7FsWJU1ZV37qmXI0owkm7E7j3Fe8mBdFJTFyiePLWk6YTKfY1qR8CjrhtVqJYeuvy9rO5EvVkrogH5/aB1hraIoC+q2RroaJUJhNiL1IXkV7fNycinV/3PYy9CvlSSOKVDUTSNzrDXOiSc9u7jk57/3Pm+cnpKvC96/eYP/8XNv8+69O5xOclZxLFLA1vYHFkoJjGV0bxNEnXOwD6EYbiBwMvzcuT6vpuOIplpTn9aUjcMZh9LiGCVxTJJEVHWBc50vkPqfjy3z54Gf8//+j5Deqv++//l/7GRk/7lSakcpdcc59+wT38nBbL7Va6kLt1k2g3KCsT04fMy3PvodaipcKOBxIfSSk1476RYP4qgPpEdQncJ0isTMcU0ETvjH1nu9Fi/g5By2tSRpTnu+wvnuSOHgEYqW70geG687Ds8Pz/j6j3yNvb3d3nAXxYqiWLNcrSiLkrIqKUppAlCW8t/rr73B7u6esCjahqaEPJ3QuYaiKHwiN8WYjqZpyTIJc5XS/UKRh1We75vj6IiiBIiIkxwTl9K+izAmfoycY71es/z4Adu7e9y6cZPj42NOz8758MMPuX37Nnt70m81ijRN3bIsK0oDdRKROEVivTSAkgpa66l+2ji0snRtJyXbSsrgtdIsUGzdPmAnU2ytOmot3qBTGoz20scJ0En+IEl9JyxHZCLKopDCkE6ak+eTnLZuaNqWzPe9VUirtrIUj91ECZeXl3S2w3aaxWJNHGfUraWxlnwyY12UdG2DijOWyxWz6YQoigdHwDmyLCGO59R1jQZiYyS682F409U4pJRdWFGWzjlaC7Gzoq7oOqGaauU9Oi970Fms59231tJ2Nev1kqpaksUxv/jzP0FnHVt5hOosqaqZpBrS3AvhdTTWUbeOpsXzxzUWQ+jerTz9TgMTK7kTY6BTmsZJ0VBdO+rOUtYNdddKPiBNSdKY3VkuuHFnqaqaq9WSoix7vDnPU/LJFJBuS2enx773qdpktDiLcnZk2GMik6KQZjfCBkuJVjGFF+bTWsa5UdpHqb6gT5neIZR17e3D6FIokiQla1vKuKRtG6nlMJrZ1Yq733ufu+cX3FgXKBPxOz/5DX5rf5dTHI0Rppr1VdPhxJbamfD+A3VSa02cJJg48Uwg53sFOJzP4WknyWZv/lBak8xm2OkOs+2Gsq5wDv7Fux9wtu54/Y03mOc5zx5+QFssef3Nt7lz+/4nmlT4wY27A/5bJZnD/5Nz7u8At0YG+zlwy//7HvBo9LeP/c82jLtS6m8AfwNgb2cmOJW3VqHxgvMe85OzJ/zuR79F4dYSzviEhHSQH5omC+YuoVpkg664PzB8x/uEGXXdeZ6y609fXOhd6DxjR2R1Ix9q4SdAWobFkoFPxVP+gz/4NkfHR7Rdy7vvvsv773/A1dUVi8WS9XrFer2mqkq6zkphjBsKk/b3v8Nf+Av/KrfvHNB1iroWjq/pedz0nmiWSdJtHH4G7yRweqXRRSwywT7CMJG08uuTzuH1fuC61nJ6ckKSJNy8eZN8MuXps+ccHh5ydXXFjRsHkqxLIoxW1E3NVdkSGcPEJCQ4clt77DMwiJw3WkHQSrzBtutYRC13b+9w6/4O5R8+I3eWOIopfOMDpQ1d22ISgzaK5WolTSm0piwLkiTpMc40Takr8SYnec66WKOVIk0TiqIgSTKiOObicsF7770nzSFMCigeP3nKzYM9ptOcsqqoqprZNBe8vG2ETdP4Bgxas/QVrkopiqKQPqdxStGWRJEkfbu2oeskMS+KjKZXW3QuKAv6BHxnvcCZJAfLQvj1P/fTP8ndG/vYcsU0EkOY2Ia37x2gdQSqQ3ttebz3d3xywZPDE9okw8Q5UZITezlq7QY3R2lf2asUqzZU/kqisrWKsm5wnRySWTZhkkSYyNC0ost+eXnRF+OYKCJJc2azKXVdi9rmetVHTcGTDdHr9fXqPPkg8k2/A2c95LfCXjN+D/YV4D4hKk2l/Xq2vfAE9A1wXrzSJCVLM6q6Yruu+PHfeY97Hz/C1TUP793hox/9YU7feIc21hQnx7RXl0KgCG3vnDgsYa13gX0zerZw70Jp9veklMfYhzwZOE+XTAhieGbrBlFzhqk1GRlWrzFU3LlzF9fUfPiHv0fsKvZmOa++8sWXPmO4flDj/lPOuSdKqZvA/1sp9e74l8455w3/D3z5A+LvALz+ym0XBiYkH6xvRXe2POe33/tNFu0lofRcEm4O7VTocSOnqn9vZUU2FzeoEGqlUNEUXIqzNcYESEa88nGmXZlYcMW66kWp0jQVlohXZMvyjJ3dLVbrku9+9z3efPM1yqLgv/gv/l8cH59I4VPTeTEsDyEphdbyXhK6wuHzY/67/+6/55d/+c+TZRlaVxgjXedjE1M3NbERVoCzSkrRneqLNV6Y0CjCubhn9azXa99YxAeGbhC4DQeo0DiFi/3kyRMm0xlvvPEGJycnrNdrHj16xHw24dat2+STHBOL8mVdVSy6ljyO6HRKoi2uU2gn1bWSYxWNjfB51oH74musD7Y4Xl9xdNPxFQMa4dnnkaFsakyWsKg7XCt4aVPXlKUkkwW7tORZTlWWKCVCTqtiDdoQxxGrQjRUdGS4vLrk5OSM/+Q/+7s4o0jTnKau+ee/8ev8b//Gv8k7b79JsVyQ5TkozbpYEXuxrca2THwXrMXikkk+oW5q1qslk0lGXRVUdUUSx5TrNYurKxwtylm6tvEt2vz4K0UUKfIkY5KkpHGE0h22rSUyiCzzNOeX/vgfw7Sg6Hw0C6hW8htKdIs6RD+9qzoePnnOel1xsLdP3bT8xu//Ho+fHzPZ2mJ/b5eDvT1u3bzFdCZNZS7PLnn85AnHpyf+4JWqzFu3bvt+v7tC9Wxq1uWKyWTaY9JN25DluRdWk0Y04rh0GxBwwLwD1qx11Huqg6lQPVlCnKhBhjg4XnEU9zUL/XtrvYHLw/DZCoWJpdWgOFKD/oqylrhzvHJ2zueePuYbf/gudj7n+e3bfPvebY7u3Cadz6Ui1zsc2mgZayRqx7k+1wKi2R5uOgjegc/HjQfECXtGKYmitI7Ymm2TZRlFsfJUbE2ST2C7gaYj66RHs8Gwvb1FPp/yk3/sx4kWZ6jZDMf/BFRI59wT//VIKfX3gD8KHAa4RSl1BzjyL38CvDL68/v+Z594aS3i9s4OlYk4OF8u+M0//A2uykspLPItrLAhISTkf4t4MNaJUTdestf7KrKELKTMsFaMhVaDCp4UWrS995vnOUmckKQJSSpViEHHIfDHt7e32N3f5vT0I9Ik55VX7/Ptb3+HJ0+eb4jqSyXgwPaZzcSjlC4qiq61vPvuu3zrW2/wkz/5DSaTnDSNieKYxVUhWLyKRMslAqW0r3CTQRpj+OH+RPNZeLzr1Yq6KodNw3AkyH1J2b71injWWp49e0aWX3L79m22t7c5Ojrk8uKS1WrF/sEBe3t7vbxx2zSsqppCa7IkJ44MnW3InPVNI0JF35ATObh/m04pDna22N/b8b+zfTVuqhyubZgojYkSzpcLbGs9vbH1DIoZVVlirSPLYqqqAice07ooRPcjilit10SxYOl109BUlnVRSoJOwfmFeKLg/3a17udutV5hWzF+dV15rRHnG1pbjNbUdUVdiyRAWaxZL5ckWYzrGpGI7rqeSVRWNfF0wp/6k38cbMfuNEY5JVTGpiQ3km2NXKiwFDBNgcfvxQW3XYtVmovLKz748Cn7ewe88fodurZheXTKx48fcbmuOL264sHDj3HA7u4u3/jGN/jow4948OAjlsslbduws7NLlglL6snTx9y5c4cf/uEfBqBpKra25n2+orNTzi8qLi4ve6aJrMGwsj45xyeqoIHN4ufb17Bon3wMyUV5TFmpSZr0kStIniQyCUmSge+9IMV1jjhxmMiJrG7jJS0AbS13P/6YO48eETUNe48fUSvHamebj37o67z/5ltc1WuJcsxAnQ4RA64bNGP8z/GvQw1FdjBEruMK1/BrrWPhuCvDfD4njhPOz85JkgjtI/K2rTFZTuNa8thy59ZtFuunvP3qK3R6jZtG6MuOyc6MSg19fl92fV/jrpSaAto5t/D//kXg/wj8feCvAn/Lf/0v/Z/8feDfVUr9p0gi9fJT8XaE7C8mx1cbYliWK37jD36Ns9WhKCX6Mn/8Sal94YRCidJjcHC8gbbB8HldmcilGDdhXdZMex0K6eok1cTKh4cRs+mEtm28XoWUn8dxIo2hTUyepWxtTYlig4liTAxvvvkW/+F/+H9nXRT9czln0RpCAdRkMiXPc6yds7Ozy87ODpdXC7SG1XpF27VkWcrh4QWLxYo8n0ulp6x54mjcYEGuQSpYLq2NX/jy2jhJqMqCvpITr3NP8K5CUxA7hL7OUZUFjx5+zM2bN3n7zTc5Ojrk7OyM46MjyqJgb3+fyWTS5yCauqOoCiqlyJMUtAhgaRqZJxdazEGuIVKaSIFDWjM4hUBoDvCVC9oBrmFvklLVLeu6ZTqbg7asFguk+jDp8d4syyg9XJPnc5aLBTiI4pTnxyee8hYWtnzU88NDPve5t8nznKoqqZua6SQkOBvSJGW9ls5NeZZRVTXLlTSYWK1WrFZrabKhHcVK8ihSE2ERJZIO7WAWORLtSLuS+f6USEHXtGCR6E6H+exETsLTarWn86H8aDaW52drTi4uuTq/5NX7r2BtzW9861t89PEjDo9PWDYd3Sj8t8D+wQHf/d73+N73vicRrU8krlYFZeET7kBZVLzz9ueYz+dsb+0QxxFNXYuaYrES+mbbejrvEG3LPYrDtenBBxLB2PgPyobgSIzkrpRnxjnl+lyYcMWjviWeMYY8nWFM7CNhSBLp4tZ1lrpwOGvAaXTb8upHH/LqB++zc3pKmU84vH+Pyy9+gQf7e5Q3btLN5+AcOam3K8bfqkTpJopQAUr1hIGACEhHNT0Ycv+MRhuMCkyeoQbHGM3u7i5N07JeLblsGuHWm0QgntZSJxMc0C4LXKo4uJGzuCrYjyr+h+WSeHfG1197hffqkuTowQu2dHz9IJ77LeDveQMSAf+Jc+5XlFL/AvjPlVL/FvAx8Jf86/8hQoN8H6FC/vXv9wEO0dp2nmdbrJf8xu//OkeL53SuRmGFDqUGzQYbPAYVmChi4H2hqmeFeKxdKeJojrMRVuL8XrtZK0WeZzSNNJ+Nk5jpJMPazhtWJcY9iX3VnyIyvh8iQqH7qZ/6cZ48fsrDhx+TTzKm0ynT6ZSD/T1u3rjB3bt32drakirUSJo5zGYzUZn0pdYBI2+bkoMb+yRJhrUa6LxB7zDROKSVS12z9uI5mN6TT9OUK5+0C80urJXRGXteWg8hNIimjXWWo8PnLK4uuXv3LpPJhNPTU6qy4vnz50wmEw4ODjycFGOaiLouWFUlVRxRmojYOWLbESlLpPEHlZOkuBPp4852Ho4bDippTCAFKspZlGlJUgV2TdV0TNOMxjrKsuqjqbKWMvL5bN6Lh02yCV1neX505GUoZP2Elff0+SFRmqKN4Pmxx3KDRk0cG5arJU1TM5sK5bBpaqb5BOUsZVnRdZYskjFLYkOuLXQt09RgtKPrSrJYoVSHth3aCsUwHKyhOrfzTZmVC3OiB6xcGax1rKuKb7/3IU+fH5NkKb/93fc4Pz8X2QcgCoUxnlLogN3tbebzOd/85jf7cRGNHk1Z1WRJQhzH7OzscP/+feI4YbVa8+jRQ7I05fU3XsP5PahG6yyMowifWZRGoEPvJAy5l1FEju7HXikxeEkcY7Si7VoUZsMT1h5mU63YCat9sRfyWdZZikL3TkFerJhdXHL78RPml1ccHD6nyjKevPYa737ta6ymMyxWeqkmOdp/WBQUFt1gqI0RZ081Q+9bZ6w02tG6r5sJz2pxaGOII+k5G1a6InjzAmeen58RZH6jWPa/NPip+GcfHvPGa2+zs2uospofvf9V3nntLmlieZbPeEjCbxpLM0t59Wr9qXb1+xp359yHwA+95OenwC+85OcO+He+3/te+yu/IDVFU/BP//Cf8fTsAR0dKNsv+NAUQS4V8hQ4JdoP+CSOw/kqOifdlkxMzBZt1REZDb6tXUg4JkmCUtKpPkkSptM5Ck0+mUgyqG804cBBmqXSpalumE0zbr95h2/9zh/wJ/6ln+HVV19l/2Cfra1tptMpSRJ7SQKvg6DshvctJdP0iSFjIqbTOWC4uLhEOYiM6xtZhM3yg16B4SMNAAZaVj9+WuhwsTLCK7deVsB7/tIJyfH82VPmszmv3LvHYrnk4uqC1XJJVZZsb++wvb1DnMRE8UxE1uqCoiqZpBmpjkk1oCyJLxVWTvgF1uGV91wfSQTFvM52/ebAd7WJIk0WaTrEUJpYNLObpsQoxZZP7tV1RZ6mKKAsC05OjvFB3ZCpcIqrqyVJklAWBbaDJItoWmmKMZ/P+42nlRyGrrXEOGJl0bYhUZY4ViRtTaIss1RJLKIdVhkvWKclseYcnRPXRMeuNw7O+/iq6wgei1Fe19wBGGpnKMqW02XHjbtvkM1vcHJ+xlZnsKTY8zNhCSlfeu/EE1RG88abb/LBBx/IKHqHJooituZTdnZ2uXf3Lrdu3mQ6nXomjBwASZz4g25N42UZgiEPUXSAIJyXrA6LuycrBMitT6TaDaMfmajXRXfW4lRoc9ivYOI4wxjJqYXCNUluBgE9x3S15M13v8Otp0/BOjpjKCcT3v3KV3n45psUk9xDPv5zI4EuQxTLiO0S7tNoI8qdVU3jWiKf8G0bafyhkVyB8Ynf1gpVNfEyJdZ1fY7OOZEdDu0PnZVzJDQ3DwegzW6yVnPmN27R5hG3sn1e2Zth0RycH/GgWrA2Ca5zbO/e/tS9/5moUJXLYduO33r3t3l8/jHEorfg16kPUUUvA6V6jQjLwCFVvp1ZB2A0xp/02qXQGqq6ZJLnHtOTRZimCdPplK5LBMaIE+JYEp4hdJfN6fDaAXzve+9jdMu9117n1VfvkcSGn/7pb4w8juGOguEOPw8JzJBhh7DgWv9s4s1meUZel5Srht0DR9N1XJxEONu7n594jb15pURbo2sbOufLo/049YbTbxDpZ+F82bwNkbTgn9axuLqkKgtu37nD7t4Oz58/pyxrzs/OWBdrdnf3mM3mKG1I0hwTCVfbOmiThCaOaVxH5hTQ9Y07kljkczsbRNW8kBr0Spsw6Mo4X+A1MZ6PTUUeR1jnqKsFcduSGo0xlrJpMXTUvlfnkHSQp18tV1RXC5y1ZHFMqqUFWxZpEu1QXUVCh6EjakoirZnPMuJIAw06Rlo4dg1dGMr+/xINWc8aUh52Mibu2RZhLWq/brvOgonpVExtHataktB1V7MuKlqnyaczsumM/VtCUGvbjuVqwcX5mVBZT0+5vLykqRteffU1Sl8U9qf+5J/k6dOnNE3D7dt32NndF6zbr8G2bX2i3/XrSHI4IaoLLJRQfxIG03nJZSkUDGs6VHwPjdRdn1SFoYOW/2UvuT3+fKWEwtgn/kd9YJWzbJ2dMVsu+cLv/R75akUTx3z3y1/l7OAGy/mMLjL+PmU9j/NfAll1G1FIv1P9ayMjEgKhWxbGYPOcphOBtMgYJlkuh1PbSPGgZ/Foo4jiwDTq+jyNaCbF4iSOuPBKR/zoH/lxlO2YZimxNmjrcNoQJ1PeUOecdWsKW1J1jrdUwq9/ih34TBh35xzrtuJ33/0dPnj0LlY3grODxxplzag4cGNkFXQKnBbDE+ydU3gsTIGSEDXvtr3FH1pUGS3JkjyfEMeSHFRYn9WnT1pKdau/FSeb8Vvf+l1+/o9/g/v374MS6dbxtu7/QP7KZ4iGELx/32uvDKwahwXlBAdeNZwcOqbzFBO1NNVQYanC+6uxpsbYa/IfjfFQjV+0PiQOEA0+Me28nPB4MyjlF5//tLKq+fjhQ7Z3dnjllVe5vLzyUE3N0eEJi8Wavd09sjzDRR3EKU1VU1Y1RdWQJQm1iciUousqTNdB67MtDqzrUMr1SfY+rA9Kmm0z4LhKeRVMjdIWrSCPNcQJOHmeKFFMkox/48//GX7zt36b33n3fa4WCyb5hJ2dLd567RXmRpFOpQjKKGnM7CKNstLIfCcx2CSIY0GkAdf5pJ+jcbYfS7ETnquNVygN1F2vh6LQCF1aktmNhdYaahXRaEVVWcq2kC5VLohZiWFUYdVoYYQ4a0liw8H+Pndu3+JLX/oydV1xfn7B8fEx860tPvr4Q95553MopXnrrbfJMjGWTdOxWi6pff/YvtrSOd8rdMX9+/fYUTtEUQo0RFFLG5qmIF626vecRbsB6xcP2/XFeOFvwhq1VpHECUpHgOkdjRDFjfdQ+DaKIkzbcv+jj7j15Al7R0esp1Ms8ME7b/O9L32JOk7FgZEGAf1aH7/f4FhZNnCgjUsJ5h9L68I4TnD+Wdq2ldaXceKbvQvfPokS8nzCzvY2XWd7Ib9QnCnUx4w4zqTfxGjPivFXEu0aT/JWCqViXAfvfPiMNy/OWKVyMM4+uvyE+/Zj9am//f/j9fvv/x7vPvk9Wt0IDOJUYCj6pFI4aZ33c8LPlHjUvvBOkA/xCMFhXIbuMt9eLOm9AdloEUmSSbGUN3DaU5W6tmNsgMXOyD00bYvxDJrWV9uxYawHtciANV7Hxj8JWgksAmct1rVo7aiqlqZK2NmJOT+taOp+i6O0NEQYezvj95evWsbMhWSXPNHwfBq8KqZmwEYdAcaRuQjJW4Pm8vKKqqq5efMm9+7d5+hIDPxysaJYl+zs7LCzs4XWhihJUEZLwrJtqFsoIoNRMaky5NqLVtkaTxzGofvqSTH20UvHLYToYX0EI2u99LG1AuW98+ptvvj6n+XPXa04vzhne3ub2WwqYbUGJzWTvvuRHOjKaGH8WDk4nPPNqa3MsdZe/kF5fSIl6846kfXV/mBvW+FJiz5OQkNE0UneZ93UFE1HUXde9iB4s5I8aptuxI7Cn+WaJApN17uec668F2iimK3tbSZTSQz/8M6PoJCq7aZp+jaJbTOiF47WTVVVfPe732W1WpFmKbdu30YRoZT1XYUqL2EL1kquSNnQltD18yI6+W3//ptrMxwMBhOlPgfkza7ZXMOjR2f79JSv/Yt/wf7z51xub7PKc9790uep8ozz3X2s1hLxj5wot5Fn8fts49uX7UWfwI1i4jiltR1JlGC1tOFrutb3nsVXDUvl8PbWNvt7eywWC4qiGO0xD/5oTZZNhnXqtauUUmTGkChQtsF1GnSE8LMUUdsw+dZ75B88Zq0ssTIk9pMOJbk+E8a9qAr+8OHvU6kOzCCEheRIsQpRd/Rhr/WeEA6RpQ3wjA1Ka1K4oR2kbAOGtuvIU9P3HtVGE0UaY5R4yhDc3BHNa7iCBx+KM6YTaZMXKFrXl8eAjw/fS89VoVqOXzd4NRIxPH3yjMPDU1bLNa+9ck9426sS5xJspzcWfWgWsvm5m9+70d15ZjHeRdrwjsMSrGsve+t1p5XSOF+VaLR0mMJZaTjy9Cl5PuX+/Xus12ueHx7SNDVnZ8eslhdsb28zn0nuIXSpatuWpq4pmobCxBRx7I1shIk0seswShEpvBZL60GukFNBNHq8V2bV+HHUcNC6ILcgeROc4mB3wsHeVH6qDJ0LHqvMVdfaPiqSNn2yASPfjEWbYV06pBNW45s8aKWxXddzup0W3FyH5K91VEVH2Yp6aNO2XujOYEzCLM3J0hRjDA8ffkiW5bKWTYAN/BNuiNZpTyEUzFpqGrzmP4OxXq9WrFcrYRb5mgupkh0gk7Dmnz8Xctv+wT6Hh4d85ctf7aM97ZuBhDWrPWNkcCYGQ95rv6jQzDnsM9NHX+Fw7rxWih4dAuFr5BxxXbN3fMxb3/kOW2dnfPCFL/Ddz3+edZ7T9ciduubADFH3gI0O9/n9ruAwRFGEacSAO62JTESe5TgceZqRxglZPiHLJyLOd3ws8iej2wrzFzRhnIehhGqpSBNDGilsWfXCeb1d0JqmqFDnC9LO0dCRAQn65Tfur8+EcV9VKxpbARarBJJAWRyaSEcoa7GthFi684moOBoeXoFx0nADC9qCdh1axWhE0zxkvqXRhSRUkzQWGiSdRADO05hCkoMBmxtgc/GShHvb+I8cDoKxoR53g0EJM8A5SdB1XUfT1JTlmtV6TV213L59l+Wy4L33PuLs9IqLi0tu3jggioWetVp2HpIaW3O5p0+8+sNjuD8f+PaGz6M8WAedk6441opBUwgUgbIoLRFSKJcPWOVyueTBgw+5f/8eb771Bh999ICmLmmqluOjNZfnEbP5DtPZtihe6ohsEhNbOUTrtqaoSqGxKinQSuKENIrQBmIrVDjjJOch46owKGnkJqcNysq9Wi3On3OWCPx8e90PD3mBaBqFJg39PHusNBgfWRc+rPYbs/PiY85qWgWt02JwtXxO1SmaTgC2xjrKtqJqG6zHXrWJySYTplkulc6JHHpVVVHWFcV6zcnJsQhtZVOU0n2ys2dzWEtrbV+hbfEJaD/RtutYLBZcXl72HcTCpRh6F4x71oYFdXl1wd2796nr0q8NJXgz4hAVZYVuJbE6LjzCj3W4xMuXnIDkWKS4TXnZBaWMdx6C1+8PB+8RT9ZrpqsVn/vud2mShCrLON/b43tf+hKHd++KCEnIwzh3bVv0GOR1p/3a9hiNy7VkcPid1lqSy1q049MklcSygtl0yo2DGySJSCqvVqtrOa9wUPmx8XvRWUdnrXSzSjMiY7BtC4F4ARJeOCeaP5GmBjq0KMYi33/a9Zkw7iD65XjPgDDBFkwkBpvWYnx45QBshw54GkoweqM9Bi9hcKxmxCql6EqM761J720okiTuF4Gcq6KKmGY55+encmcbcIv4+HmWi6BVKxoi4YDpPXUfYXSd9GYs1gVXV5eUZUVZVjx48IAnT5+yXCyxFrIsZW9/l1/4hT/O++8/4OHDR2RZwle++g43buxRllVvlMeY5csu1XsJYWTpD6rx9t6INZzrmTSBIaN9TiJIQWileg5yGLO2lc5CKEVdVTx48DH5dMbNmzdpm4qL0xPqRposrIsjzNkl09mUrfkWW9tbJDrxeGwk3OkWr7Ft6dqWZROCUvHgrceo0yRBm0iolQq0M/6JOt8LVvXyDSYYaSQ5r/x46H4txSg9JL6d30zOWc9mkVxFazta5cAJfNB0HcoZOqXolKGrO5q2wbmOuhUdIDTeKEhjinQq1Y9YcSKsx7YXl5cslwvKoqDtOmJP7dRK8+DBA95997tsb21x69Yt7ty5x97uHkkUo5AaxTB3EOQEOi4vL0VLpwtNK0Yw3EugLWlN2LAuChaLBd0tiWBirzQqBCbxvo1PJHYWn7PxNRQjo6a1Ioo0CkPbQBxr9va3mG/nXJyvOTlao5TxrJXNyDcrCnZPT9m6vGT78pJsueTyzh3ODg44uXcPF5KwL0TXm+/UO+3X9sgnQ6Ju49/BMGst3ZxClBNFMUmSkWYZ9+7dBwenZ2c0bcf1qGMMz47lwpVSJJEii2MUVkyWE9vllKUL+1VLpEYS47JEwMMkxjVOuvN+SgTy2TDuCohkoQifXcqVVctQvGTkhVYrnJZOR8qpvrQdB9o56aauFM4ZVDentS1d2zDd2pKXOddv5CSwQrwPi5J2eHUtfTBfwOkApwzz2RZdbfnexx9wtVgQRVIefOfuLbqu5ff/4Ns8+Phjjo9Pubi49OyE20wnOfPZAVuzHW5//R51U7Narzg7P2U6nTCZ5HzpS5/nC194h6IoOD464tHjj7lxcHu0UAcvXK6xSJLDOd0nT0E8hFAeLt7aUPI9XLo/PISRMBwivRfiS66dNqIw6Ly+RvBiFTinubq64uzsjFfv3+PNt9/h6OgQgPnWLtPZlmfPWNbFirJcU67XpFFMkqaYJCXNMyazCSiHbeUeQ8ccOuHHV02H7hyFbcSLV94LbcF1wjWWw0kqPWGYydZDbnEcC2tBSc6icx0hhGnbBmultZ1Tok459K4Vj6vxqoDGGF+E57n5kSGPYTrVvQZR8E6tlQRbsRLlxJU35kpJv9Lt3S3iOObhw4e4zuI0TCdT5tMZJ8cnPHv6jG//wbf5+g99nbfefFMqa7XyydWhEXNRFD1rZnt7u6fi9bOth3vTWlNVUmXb2YbVasl6vebk5JDt7W329w/Qxu8RJxtRKYNCNGEs4oWLno4/YE1EEsUksSadxBwcZJio5fJiyUfvXVBVwoiK47Rfiwow1rJ/dMIrjz9mNZvRxjEPX3uN1WzGYmsLhxAWzcjwjiPl8P0LtuUa4eCTrrFBH3JzA0wUfh5Fc/b2Dui6jrOz4QDtNahGBv36uINUG+vIkSUGRWjk7STtpXyrQqUln2Y0zkemJo2xxpG+epP2g2ckt2/BsyM+6fpsGHcnBSAoLZi4cwLH4PzCFWPeOuupgBIG40Se1CpH7PmqVos7l9s5sZtRtxWo0DFIJs94b0Spcasqh9awLgqqqvCh+ssxrddfu8/jZ8d8+zuPKauS+Tzj3fce8PWvfYHJNOV73/seSZrx1lvvkCYTlFLcu3eP73zn2zRNx+Vlwa/+6j9hvV4znU14/Y3X+MLn3+Hk+JjLywUfffSA7333fY6OjvmFX/hZDvZv9ffoXvBDxhWBm78TqqglJE9tYHWEdxmtd8FvByzyxQTwS/B8b1iDkcvzCUmWk6YpezvbxHHE/fuvsVyuWK2XnJ2fUZYlTdPSNDVai3ccdOvxGH8SR6JCGKcbKpxJEveeXn9PPinV2g5rpMmxJC7Dxu96jnpofhIodU5rGheotMrrhVjaVgx3KFRRWmEw6DhwsK3Hlo0vTPOqpH7MgrEsioL1es3W1pZEhGnKarVmXZQ0dUWWJeRT0SWvy1IE5uqasiwxSvPo8QPSJOfnfu7nWK1WPH/+jMViwe07t1guFiyXS2rb9mMVimSePXvGt771LdbrNbdu3eKdd97p5yg0kKnrWvTLfc4oFNY9ePCgl8+o65Lbt2/1PX9DE3iBW1S/3KTSW2G7DhMZ5rOM23f2yPOUpq45Ob7k9PyKtmu9H6JADfh63DTcen7Izvk5SV1T5DkXW1sc3rkjHcDCZDPkwwKFcFgLLxrvT/r9ddLB+AoQ3fX1H/5O2vvlcjivVv3BPch/6xfer2/i4d83ibwSp89r9VGV32PWOWKlpCezMT1s2mQRVWKI8oiGhq0vvwPPvv3CfYbrM2HcHfTdS5wDOs9x1ppADnQSlw+vwZ+unYiaEhssArYaBYoM20Bdt+R57g8DX0ChIEnT0SQOgy99SkWqdRz1BVBEK0WSZmR5yvnlMc+fP2N/f5ud3S2KuuD23RvcvXeff/pr/8xnzIVmNp/Pefvtt8gyUTT8iZ/4oxwcHDCfzzFeVqBYF/zDf/Df8OTJcwAODvZ5/bXXXsBEX7w2G+VeX7RxImyErrOYCKIkIjERbVP55gGBEjlURm567kPuwCgp9JpMp+zt7ZPnE6y1pImwN1brksVywfPD56yWS5pGcObW86TlkJD3NMah49Bk3EEnHnFTOhZXV6ACNOQ7UkUJWZb3OiTigUa+UbB47FmekeXZhlZO17U9vGStVFpG/nAXTr1ATl3X4QjJdOUbYw9GxDpH2zTUjZTrW1uzWq1oG0lAt531CpB1b4SU0hwdReS5CK/dv3+PN15/lcuLc8q65ujklMPDI5qm7r3QfDLh7PSE54dPubpY8LWvfZnPf/5tsizm8ePHFMWKSBuSNCJWEU4pL2shQl7vvvsuWZYxmUw4Pj7mrbfeYjIRJ2O9XvcN35MkYWdnp9cJQll+9Ed/lDfffJOmadjf35X+AB7+7PzzBQNoXYDohPKZJin37x+QTyPW64bVaQedpq4FnomMkyQzMVo7YmPYPz3l3tkF0/WSJo4539vh+e07FHkuK/0TjPYnQShjvHwMVYV/h+5Hw9p++Z65DmGF8azrmsvLy7559nWDHtbq+G/7pHXXEUdAZ2lb6G/FOxi4kZyIDmw1gRCVVZR5REPLfDahUQq1t/3C2Iyvz4RxB3y3JTuEI3K4y8NZ5U98jYuUQDhBx0L50mzEr9VtBy5FqYyuq3C+eXJvnREvTapShxJpkJZeUWT6BOSLIV5gNjv29qf8mX/552ibBqWlk4uzcH5+zp3bt/m5n/vZPirIsoydnR2m01n/fdu2fPObv8O7736Xsir4whfe4c6dO/zMz/wMT5484+7dO7z11ps+5LV+gXx6aPlJdMiw2PIso+tamkZ6qkY+cTjg+QNs5VygbWWkaUqeT5hMJsxnc+IkAS20wJPTMxZXV9RV1ePlYkBdz9ZwTvRdsjQnaJjXTUXX1bR1A0ixkkK8v87XIZh4YIWAwDPr9donR4fq4jzPmM+noncznaFQLK4W1E3N6ekZ5+fnMtcgbQ6taMS/8sp9tubbOOebUC8WrFZLgeVsOzqMrE8Khu9hWFABCgM5ZN0okS6v67qWxeKK1eqKR48esDXfIs9yJrMZ9+7d5+bNm1xcXPgG52uaumZ3b48f//Gf4PxUtPWXS/Hcf/3Xf52trW2++uUvsbOzQ9t2zOZz4jhivRY45uzsjDffelMEzXyLu+Vy6dd41EcRcX/AhTsV47e/v++lOVxv2I1vRmFMRNsm1HXZJ4ids0S+YfPTx2doo5nMRBhL+zya+FS6V4/aLUu++PgJWTZha7Xm2d07PL99kybJYIN9M6z5scd+3bu+/rrws5fBItdhlvFnXadsBm89TVMWiwV1Xfd5DdiMJELB18tgGXFERAvHWUQFUw1xePDY0co3/VY9VTLIZujP36f5ve9hnKJFs64qPu36zBh3sc4aE8c+DPGhr9M0rsNFqjdwyg1GFmTRKCtCU6oxTKJ9EhKKVtQBxywCE4lkZBSZfuGOYY3AgXebRFj5rccGO2v5+MOP+c3f+hYW673HiO3tOa+99ipaR+zsbnFxcUWxLshyab92dHTWh3KXl5f8g3/w31BV0iXowUeP+cY3fpwvf/mL3L9/n6dPn/FP/sn/QLEu+JO/+Ivo2PRJ3U9b1KKdLX1j5fcKpR2dbSirksELl0Sk9tWggg2LMZ/NtknTTGSHo0T6qZYl63XBxcVFr4TYJ4iM7jcx1hJp0ZAXzrZ0f7euo6kLlJX+lVnslfBwNP7A6TqHjiLyNCXyXWa6rqVta6/DnjCZTJnNZkxnEzSK6XTC1taWNFlvGh58+IDlYsFq6Wl/Sgya9bmBoljStR21KXhkW1H33N0jSlJu3bzBZPo6p6cnPH78mOVy4Z8RP6YhlLvOEAnGpGMw8HjoJiQd5RCo64qT02NCkV2WT9jbu8H+3k1euf8aV1cLlssFl1cXrFcrsmwm+vJNSxSnfOkrX+Pk+JgHDx/yjXt3WBwdge246C4oq5rl4gqlFGmSYIxivjUjyxM5pH2xXngG6E8qnxC1goErUCHnZN3gFCkFKFHcNJq6sf3h3VpfGeEqjItYLa/8gRD2mdRvxA7uXlxwe7HCmIg6y/jWO5+jTL0Et4PA/nqZh34dx34ZfPJJ+HqvqTN6zfgzrr9vaJPZdR3n5+d9nmV8hfwFMGqQLWOr6aRhinMSW3cdWNVLlveFl/4eYm1QkQGNJEsB5RS2ERG5yatvcTr/DdqjSxITwcHeS58zXJ8J465QvqGAwtUt1kiD3lCuHbRGrEMSqJ0sEuUc1oBOtbRI7RxaRVibULdikLa2d9Da9IOu9MAO6GmKyACH1l1l+clSmmGBPX32jF/7tf9R3sNP+A99/Qu8/fabnJ8v+Ce/+t/z4MEjmqbl4MY+9+7eZbWqelpakiR87Ws/JF5cnjOdZqRZwvPnh3zve9/lm9/8FlEU80d+7McEXhgtwk/yWkIv2ICxXy+kCleSJEwmE7ZmcyaTCZPZjChKKcslXddSVQ2LxZXHjVfUdTOqMhzeO2C44Gjbxt+b99TA0z3XvgRfaIyxxxCbtvJyEqLGaeKELhFGU9O21E1DFMWkacJkkjOdzkTzR2vyLKduas5OTzg7O6Yo5LBxzgn/3clBb6IItBqFyl43XKk+Sjg7O+X8/Iw0z7h58xbT2YQ33niD3d1dTk5OODo64vLy0nvu/YhfWxWbYlghD6J8dBlqnK7PibUdV80Vi8WCp08fsbOzzf7ePjdv7XPr9k3atmW1WHByfMJytSTPc/b293nrzTcpihWLxZL5fIuHDz6mqBq2t3dYLBZUVcXR0RFJGpMkMXt7e5JXHK11STQPkJsbPZZiuFcxpnYUnYSkoiSsXTtg4UFzJvQPDj+Xlokwv1ryuWfPsQ7Wkykf37xJub9PpBSqaV7Aq6/tvI217kaGcYOpE56Fl2Pr8iybydjxgaGU6pvLx3FMWZYURfEC1AL4PFCyAR3K+/l14MAoB8rRuabXfnfOeaLIsBaMMV6eduy0hvkQKLnNcp7+0FcpH53y5iSn3d/6lPH6jBh35xxOKYwduzsMUr6R9mlBUNb2jBGlwKCxdedPe02sp8Ta99BEERrgOicqb9o3dnjZxIcQ7GU/Hy5LZzvu3LvDV776Jc7PL9AGXn/tVX7yj/1Rjo9P+W//0a9ydbVgZ2eHra0tdnd3yfMJd+9uMZlMesxYeK+y+bUeBJVef/0Nbt++y/b2Lvt7+1jnOdaem34dfhmPoxyICofpcenpxLA118ymE/I8ZzLJiCJDU7Usrq44en5MWZcUxZLSa6Q7Xzln7XgxR6Rp1hc3hatpmmEenRv9zSAaJVLegnF3/lCVw1qYFlpHmDQjSWO2t3bY3dklicM8dpRlyfHRc9pGDsiqrvqOOPhntgowEZFvaO56DEWiK9HCb3qj5WsDcc5RrNZ8/NFHPHt6yO7ePjdu3OCtt97inXc+x9npOY8efczxyRFFsR6tjZBY9XPj5GfhlqxTEESzRoaxn6+e+STJy6OjkuPjI6IoYppLTmOSTXnttdewXcd6LTzq84tzsly41l3b8fbnPgdK8fjJEz746H2MiYgTg1KWO3fuoJQU7uHht+EWxiwSh7CmFKJzNFpbTtFrEPln0NoQGQOJHwkrAgJODYVVoUgpV4qdqwVvHh7RKc3J9hZHd+/RpBltVdF5Pf2w/iOt5fDwB7H2SUufBeoZMEMUKnUgPcDa2/nxs8m8SGNsS2CIjT135XMXW1tblGXJ1dVV742P3y9460NOZ6Cbam2wnYOuI9LCgqoq0ZzRZhObD5BQn1TlJQeTnzvlHBWO48+9yvHNm6zP7/HOZCiGfNn1mTDuALq1qM7RGWEtKCfwh7agWin/VlrhjKZDeVxTgmClNdpEWKdJmKO7iKYpSVPxHsZJFpwjjuPeeIVLKWl7Np7McG0aeuicZTqZ8Mt/8c8RkgPOOc5PLzg9XfLDP/yjXi54WOAh+oBh4UsloQ/R+uIFRZbl5PmMKIqHCXdi2uUmNu+rr+SLIp8EjJhOp32bMueky9LlxTlnZ2dUVUFdVWhM3+WmqAuca7HWn5M+mZimSb+QA8uk9ri1MVG/wOmfAQboSKG1HBTOh/cBW0yShPl8zmw+J00zsjRnPt+msx3nF2esyzWLxQUX5+eUVU1ZVrR1QZZ6aKE/5B1pkgkNUAumK5z5Mb9b7k829iA+xcjoyngKW2r95AmHh4c8efKYg/0bpFnOl770Jar6LZ743y2XV/6gGE2If/bx9y7cA+4l6+q6AZLv67qmrVsWiyVJlLK1tcX+/j4HBwfcu3fPFzsVHJ0cc3x46NUgFbdv3+IrX/kKDx58TFmW3Lixz927d4f3H9JLo88cPGEJlIcXjGGM8WNt0AT9gtRaSYOLKO4xYwXsnl9w59lzoqLgKkl4vrPD0cEB+WTGJNp0pKyV7lVtU/frLChUBkZKIEQoj3FrrTEq7n+vtbCbrhtJyfuOC/o25yJNU7a3tzcgmJdVqQd56bB/A+Nuc24txlifs1DEsez/8YEZDoRQoRueP4yrsLucr8GQsZ3GET959xYfzVYc39rhzeR/vgbZ/9NdCjD4MmKH6dwQXvlFo7xxiBDda4dokKtIjIjtHHGXYm1C00mYvrO7i7yjBM5aSym3eJ3DaQ6gPETQ1JIYFe930BcfQmrFxfkV//TXfhfnpFT/7XfeYWu+DbZjZz7H9ok3N/o7ETJSKuizy2YaxINCIi5MtPMhbUMcG1B6uE+/iEMUME78SBJNioMury6oq4qqblivlhTrJYOYkhYN7VYLzp3nWNvStpYoyjAmprMNbVdS1R22c32lrxj6DtOXxXuE0clXtBkxHSThbTyFbDKdMp/PuXXrJvP5lLaVgpvVcsmThxecnZ+xWC98Gb/nqjtHYhRRmvSH9HgzNU0tdQlKQtue+YMX8nR2w5BuRjyhytkbP+twVgzs4eGKw6OnTPIpFxe3uXnzJvv7e8ymc1arFReXZ1xcXFBVQUNEvHdPBhrlc+yAI/TrTXB73UcXwdTKIe+QQ7ZuGk5OTzg7P+fhw4fs7krnpO3dLW7s77M12xJKZF1zcXHJ1772Q3zxi1/Cdp2HDEYWfQOeCBsvHH66N/WhH4DzkZZ1CovsQ5lujTEpxrQDxxtxvqIoReuE3YslexfnJFXB7uUlH967y4c725RtR2xM39lsPB9SM2CIkwTVuzKu74LknNQYBOlh20FbN3RdteE9h/cKdNYoMr1QoDBuHUq73vFKkoTZdIrtOi4vLmibFjXqpDRmzARn5rpBxlls16CtJJ9xtu8ZIa/renh4zNwJh9L4s3rqpFbea1c9pJabhC9sG1CKSF+HBzevz4RxV+BDFuO5xhJmox3ON0axNpTfKOI4ITEpSZQwzXKm6ZTUzDg8uqIqImxTyyR0nYcAfBMDpTAm9sY9JB2DvrvxGFszYGZcx+tkdbdtxx/8wbs459je3ubttz+PUhoVqvjcABvBJkYu8zgWEwsyqps44hACShVflmXs7u6KMp2D9XqNqFrmvhn34hruNxxcTVP13mvwsAf8VcLKzidjjTGUVUXbFlhbg2qITILC8HLPczSJSLTlWphOMrbmc89mEfpiYCLVdc2TJ084Pz+l8RWsIVqz1g4d5ZXX/XE+NFWbAmH9/XgNc2ctXRsOm8F/ltB3CKnHntbwPg7rnQsxyl58yimWywXvv7/g4cOP2ds74OaNOxwcHHBwY5+yLDg/P+Po6Ij1euWNTBhb7xQ4t7EWxus+oCXXKb7aSyYMUaelqkoOD6UoLH4mvP/ZfJvt7R3u3dshjmOeP38u97Ja0dSNdyjkfe1o3OTgNCPK6ODLysEy0I4lgna+elxG1owMtFLKa/JD1FluHx/z2uEhZZ6xmE54eP8eyzxDty3ald8HW5dBGcXKfQ8HsROmh06xwxoI6z5EZs6JM2K7jtp7/4HTD6CM9k7GLXCOj320E3JJ2mjfq1VUHPM874XaYIAig4FGKbRrpUdBGyq9I4ZR3Vx31z32cG3k1YZdiogaSkMTnOhmfb+21Z8J4w5iapW2YELTW4h0TBYnpFHGPJsyTSfM8hnTdMYkmpD60m6F4fyy4Oh5iVbShzDts+9iZcU3gSQROdDNGFWRJim7u/ucnJyMjMZwf2No58aNG/zSL/0SQN9/cngdQMTQ5MO7cj0eTnCP/AeINyFNsSPyfOo5tVMx5lHce8xN27BcrvoCmUDD+jT2gCz4DqWCcQ8+0cjTtFLWFDja1socSJ2Y6o0fQNd2EHlM2euDJIkU48jhEwvc4lsKnp+f8uzZU05PD1mvC9q2oapqiVrUUMARwvhxgjoMqPPKjoNhCokn2VRBpXh4lsG4D7CJHjaREuMVcjreXvn2dmHaxxizfK3risPD55yenjGdTrl16ya3bt1mZ/stXn/9Leq64sGDj3h+dOS55HInnRVJgd5LC/caql5xoEQyQ/VJzhCi2/5ZZYtL/qKpGuqqZHG15OT4hPl8i+2dbfb399nZ2enFwhaLhdRblAXWBsdF1r+1YuxCm7hxfsUPrdyL7bA2rFe5v9Dcpj9sreXu+QV3i5q51lRJwsN791lM0yFBqCREV0o6bI2jh/D7lzFXXrh6aGVY72MHykTSBSnJ0n4uHQ7bSQ+BOI65desWWmuWyyWnp6fUTd17663tfFNzy2w265OmY+ciwJlt29C0JbYu0baja1q017FqveR4aMfnAOusp6DK/hmeYbMidtP58EGlP8yMMRvQ0yddP5BxV0rtAP9n4CvIiv03ge8C/xnwOvAA+EvOuXMld/q3kVZ7a+CvOee++ekfoJllcybplEk6ZTfdYZ7PmSQ5WZSRRIksCDfgrMEYKAvOKY4OjyjLiroWg5dlos/NuHJMifD/JkYaDLf2PTFXL+Cg49eF99rd3d3wBPwLZNGNlPI2PiksSK9VMZlMySYCU+zs7EiloldkbJqG9XpNWdY0ddMnbgQqenHxvyxBPHyoMDNCniFow4yLn4JnHxaX0cPr7EhyNoq155XPmEympGnO3t6e9DZVitPTY46PjznsnnNxfkFRLEWAahSKysYeDtcwlzYYZjd4jS/jDPdfNwbA5wTcyAXtBz/IMfj39Em5/jDByyn4w3foFrT5uSHSatuGq6sLrq4uePr0Kbdv32F/b4+t7W2++tWvcd/rujx79oSLi3OwQ2HU4KG7vgjIuqB1Y+ms99d6XQ352of3DiKGUmLnoKlrTk9POTs/4+nTp+zt7XHz5k1m8zm379xBKcVqteLx48ecnp7Seo8+PJd4lD6P5aNW3xOHoan1oP0/jkKcc+i25ZXTc24ul0x1zNHdu5zv7bFOU3DtxkwJ9hygDfqDZmNeX4iWR9Ps56g3mhtJYT9iI2ek96OAKI7Z3d1lPp+TpinPnz9nuVwSx/GGgFkY7yzLeu56yMX1Kpz+XpSzqLZFW9FDUspJEaXrpGLXGOpK2GbKRJgownr5ivA5alSsN4Zphp7GEIrtBBZVG6/7pOsH9dz/NvArzrlfVkolwAT4PwD/2Dn3t5RSfxP4m8C/D/wS8I7/78eB/8B//cRrO9/mF7/yS9J5RGmM9U05nC8Z72xf6m6taIBotDRUVlBUJSeXwu9tmwacX7CIJxeqXyNjiCMjoX7wmPzVeRW9pm0IvVrdCFsbaGFjSCAsfOg9kA2MXj43TVPyyYTtrS3mc/EEtra2iKKIoiw4Pz/n+fOnXF1dsV6X0tZN4/U/MuIooU8k9TjucAVvtd94I883nPzd6N6VDQt42FwDRDSUQqMgTTPSNGdnZ4+9vX0pLooMSgmDZb0u+OCD91gXax9RlHRdS5JkmAAD+eEJMMUwXr4E3dnhmXrP3Wd2/RrAeYPTP1PgCXutHI8rDD10x5fUOY+hNumOZH3lslBNJQIIZTYO1EBtHJeQM8rFLBaXLBaXPIhj9vYOuHv3Ljs7e7z5xhu88cbrXFyc8/GDjzn23nw41IJxtU6UJ53PIyl/5lmPeYWukkH40zlHp/xggNcllz+y1lEUBY8fP+bJkydorXvHYW9vj/v37nOwv0/btBwfH7NYrmgbETuTPRBYMkO9B5gwg/4AGCjEWhkOioJXnz0nbVvK2YzvvP4m1XTmx00aqYTDzBhDltqA9HsGlYe/+iU7ePJh322u5eG1/qn7uRpeOLw+XHme8+qrrzKdTjk8fM7Tp49HmjCiZRXmOECJwTuX1/jIb9RQ3rYt2E4UHYl9Gz5F4hPFvRhfFPl8RIz2LLPhsBz2RUgQbzy7Z9SFGhbV71E9kk55+fV9jbtSahv4GeCv+ZuqgVop9eeBn/Mv+4+Af4IY9z8P/MdORvafK6V2lFJ3nHPPPukzjDbkUYa2g1GRjadQHoB1neikBd320KINDYcnZzRir+najjzP2cCdJasmnca16hsI9AMIA73PBcx1M2l3necqv9/0dkWXW+SAp9MpaZqSpsJ2GGN1RVnx7Pl7LJcLimLVswHGGXh84zXlebJBuGocuoGHF9wQzbhrxj0845jJEg4CaWTh4RmcL2KakudT5rMtX/wirBbnFHVdc3pywtXikvVaBKacG8ZGPHDnO9nTj2VQpUQNC7ePvpTC+ee3402pZPMH/FkOtsGz6v8dvvdnrVabBW7OBaE4vyHtAI85ZwWK8QZe5t3r8YU3HH3WeD0MYbr8vmlqDg+fcXx8yHS6zc2bN7hx8xZZnvO5d77AnVv3ePbsCWfnZ1S+mExp6dLk4xb5HMIw+ZMsGC0bnAXtja0aPaP1Fb7DcweM+exMkr6PHj5iNpuy7Xv7vvrqq7StpaxKlosFi4XkbYKWjqwUhUMS1ALBDV62aTtee/yY7PiQ6XLFxzdu8vi1V4nzqeDvfY5H1lp/qDvZu4Hz3UdT2u9upzxs83LDPv7ZQCcc560kEgtTFYgHN27coGka3nvvPa6uroB26FXgQoQCk8mkZwhtdpDyB2tnsY00FNI46XvrD66wFtqwF9E4LNprI1033FGkGUT7hp8PXrnsibYVOVPrrLQObVuU+XSmDPxgnvsbwDHwf1FK/RDw28D/Drg1MtjPgaBudQ94NPr7x/5nn2jcw3SNN1HA+5SSUl2nNRYrno6i97yvFmuePj+WlmGrNdposjyDDUMpmz5N08HQuOGDQ2IyZLPhxdDw+s+l04yEbvP53P99ROaFs+I4FkbFxQUffvhhX0EZjPxwOAyhmCRZhEcfeWXDsHiDHZPQcESbGt2T9/368QxGNxw6spAt1nuxUZoyn4uo1d7eLnFsiOOMrnOsVwVlueb58+d8/PHHrFaFL2G3PjEqn2tGrAKZS/E0JJqwfVIohMpD5OMxxJ4pMFoQTg5wZ8RLE811RxQlvlPW0OZtc45kFGQtXV9lY90cz0FHTCQhMlAiZ7Hh9ntPWmuv7c6modnER+XwWCzOWa4uefrsCbdu3WJnex8c3Ll7h739Paqq5OzsjLPzc9qu6r3BYFKlvkVw1c7ivfeAw3vW1fVbtF3v9StvNwWKA0nmNZyflZyfnZLECTvb27zy2qu8+so9jDEslysWV0vKsuL07ITF4orGdyOznSSbJSnt2D87480HD7j1/Bkf7+/zrc99nvPZjCSSZL+zgyc9QGwyTm3b+cNawQia853D+7kaG/KXwTTq2v4er6Hwt2ma9hDM2dkZy+XSQ6nyHJ03zM5BmsZMJgMbxjnXU0xlf4a+BqKJ1LWiNqsJe9dcu0/J4SilfX+AzWgkOFwhBzJUl4dDRJqld11gBoJGeRqv2SiC+qTrBzHuEfAjwL/nnPsNpdTfRiCY8YA79f1St9cupdTfAP4GwP7urkwUXFucQwLMx6riFSjAaMq65sNHj1lVDeuyZr0u2Nvb6yGVMMlBjzlJEvH4ndtYV+I1WopV6ftDDuHO2Jgbn6nXWvPKK6/4BJXcozGG42NpTCxVbSWtbwRxHacLX4PCYMDShA+LN4qBLTFKdPkzaYA3hp8HI8TI6IT77zoxGFmWE8Ux+WTiufQ5WZoxnU6pysLDQsdcXS05Oz2nrNZ+Q6s+bI3jCOe0H6Nri9kO0IcKyUqtBeYa7V1phhKMz2ZeIvjLsve9FwbUbUPTOrIs7xs6v8zAf9IV5mkjaQhor08fTL2gHD7gDyeqcr4Dk94c99F9jMc8JK+rcsXDjx/wPDlkNpuzu7sr0gnTGbPZnFu373ByesL56Tl1Vfrx6AgFQ10noEOknIfQRuPjNg1bD1X4qFN5yCtUBveHl3U0dcXpyTHnZ8ciAHdwwP7+Abfv3GJrPscBp6enfPTgY05Pz3DQ5122Vytee/gQrOXDV17j26/cZ2mMUBTUQOO83pd0jGWHed48RYe/cW4zSn7Z9aITFv6Wnos+n8+p65qjo6OX1K+E3IcULolzthlZhs5hMs6d6Ej5Q9S1woyRSt3B+95o4O11YqSk4sUDS2pFYu+wvbiO5SDSaGMwkVTxax3LXgsP+ynXD2LcHwOPnXO/4b//fyDG/TDALUqpO0AQFn4CvDL6+/v+ZxuXc+7vAH8H4PVXX3GSDJMQNVBzr2+igMODorGODx8/5WJd0baO9WrdG96gASGYlWzMyST3e9Zj7W6TbuWs6w145DHuNE29yNeg3V3XNVVVcnp6zGq1YLVa9TorodtT17nNBtuo/sBSwb0iJEfEK5QDwAhM4obwd3iPcKfyDD32HF43OqgED9XESdJXxaVJyvbWHKWg7STBulxccXJ4RFkW1HXl4SpN1znqpvXaIEOIaEyIrHwTjVGk5VzrzxbxyIz2Guhd65vLDIU88p7ecxtFao5RsY9FGq/gCPrh1oZORm7AnD1NMjx7DxGxCc+E8exhGbyqoZPD1IW1Ebx/P03WKYbORWE/DdGI8yJn4cAdxp/eGkvbQZE5mM1m7O/ts7+/x3w65ebBTeqq5uGjR6xWSy4uz0caJd4BvgarWWs9nBb2xPC543ViNAOs6eEQRXAsZOxWqwXL9RWPHn5Ekk44ODhge3uX6XTG3Tu32draEsG2YkVVFtw6fEAVRTy6d4+znR0pSBt508N63Tz4B4978/vr13BgDe8x1nkaR0qbl6yTGzcOuHv3DlVV8ezZs54ivLmf8Ps5YjKZbvSiHda07b92XYfrat/yUZzM2OsVjVk0sr4Gp1KiWuv7I9Ab/QDvSIOUepRM1aOxkfeL4qFxuNDBZRC1+p8Ac3fOPVdKPVJKfd45913gF4A/9P/9VeBv+a//pf+Tvw/8u0qp/xRJpF5+Gt7ef46vyNIeh9w4lfyuEo0VRdV2vP/wEc/PLiialsVygdKK+Xy+YXC01hitmU5z4iTqPQIZaNMLKW1vb7O1tUXTNOS5tD4rioKiKFgtV7RdI5KuXgXP2payLFivlxseiYkU2gj1zfjmIjLxjijyIZoWrn3oPTlUpvrXw/cJt4ax6eEs3xpQMP6MyMS9jKscRhW26zg8PGK1uqIo1lRliQKvqR28V0VgJCXJuDz7RU9qHI3I5tHecGifwJYkVWj4LR6kLNqQQDR92zGfwFZjrnfAQj3uroUz3HtBGDof9Vgc5pqBD5TC/uzrb90fnM5DMMgBYK1FmaDqF4bZHxZqGO1gGBwBalKeJjj8ToYlWDHb125YB4vLC5ZXlxw+f8rBwQG3bt0mz6a8/uprJGnM+eU5h4eHHB4eeo0j57HbAMGN5sF7h2JQVL/eXswL4cfOt6YMDUxUEOLTWGcpizWPHj3k8eMnxHHMdDpnb2+P2XzOm+clNz5+SJ2mPLp/n9V0CnVNN2KMDZ5vOJSvrVs//upT1vdwUDk8QZpNVtfLDXscG7a29tjf32exuOLZs6ejBtV6Y1yUEtbcdDrdiMQCDCMGW5wQay20JdoNDa2N8s28R5DkuE9AdA1jD9j9ED3i7VPw9tseftXa4HC0XesjXInklBXl1M6F+/p0ww4/OFvm3wP+b54p8yHw15Fd8p8rpf4t4GPgL/nX/kOEBvk+QoX86z/gZ/TXOFHWf4+cmquy5Lsff8zRxRWromZVVGin2N/b6xvyDtoWMJ1N+1L8JEl6XroYwLTHwY+OjkTtsGnAud6Qu9EiHWOrIQEbkqHGGEnYGt1DKuFUD6+11nkcPTzZ5sKVayg2GnsbwyUeR5ZlxL7Lz3QmUsJpmtK1HWVVUzc1l1eXouZYrCiLNXVVSOjv/f1IC99W6eBB+4Worp2t1zZU2Hwy3mIkrOsI3eyDLQxe4nUoJPjVvXeqpJKwc4NnMsbHh40RPCTVz41/eT/vDml+Pq5K3cTHe5Wi0X3IPdmue2HIw98brf1akHuzQaPEgVOD9zbuKarcOFIYheQ4irLg0eNHPH7ymPl8hzu3b/PKq69y//497ty5w9npGR8/fMjxybFw5vuIUzb5MCZjeGowIMoflIHiiMeGe+isPx/8mDoljDTvddd1zXp9xPn5GfvzOV/83d/j1nrN8z/yR3Cvv85Nv6ZDO78gtheMqOoT0v4Aubamvt/VR1AMX4e520xMZlnG1tYMnObhw4eU5Xrk1W5OqNbSjzYIm/X4Noy06zXOtbRNg20Kz/OX99J+rUIQfxuPt+vRA8AzuDq0E8dF+eppHRLm/tl6nSaPwTdNI2vYWu+AyPy1TupKAt9d+hh88vUDGXfn3LeAH3vJr37hJa91wL/zg7zv9av3ulyo8vQGBIngV+uCdz/4gKOrK5ariuVyRZQkbO/ui6xrn0DUPRf91u0b7O7uMplMqKoKpRRVVVGsSw4Pj8SrtdYbp/5OuB5W+mfrF3/wlMfsFW2U98zlz8OkBeMoFWsvTshmOCt/PDBxBqGiJElI04zpZEqSpESRIUkTmkZ4zqenUvE5luMFvAbKmL0gzyge6IgXjkPYIsrDHpuc5rYNDAMFSpJ14lGHCEC88lBJHKqEneeQD+Gu9cqMw7hirVT3+eIWa2Uce0+asfKgArxHHOAIJQGf9rxkZ5XXn7Eb8zd4ZMp39fKsHKcGp37k4YXoRlr7+o1vHUZ70TrrRt50oGh6FgThvr1xUj6R7SOEIGJ1cXnCYnnOs8Mn3Lt3nxs3bhPHKffvvcLNG7eo6orzs3Nh2pSVLz4aBPRk2Y+lNMbEhEBf3KwTCLZzDBu6INTXH3gW51q2j56zamq+efMm783nbNU1WSqibq+//npflxEKgiSiDZGBrLVNY/1yh2HzZz5PoxzQ+jEOxl3kCebzOTdv3qQs1yxXS5bLpXe2hshvfAWKo8Ah7Yb4HQzG2tkOXIvrKrqm7aMfKR7S2FH0HK7Wd1XquepKo2zH0dNHlGXNnVdfQ0VhLrre8ZP5C4VqIq2ilCL0J3M+ox6QKeekS5ZC034f5/2zUaHqT88+XPOeu1IS+nYozs4v+PDBYy7XJatlxXKxwmjD9myrL8tVqB7P3d3d9QyQmOVyydmZaKkHQSDbDR7VdVx20whuXr0BU/ReeB/K+aIKo6/hn/2p8aInvhEuIjSwyESkmVCdpOu96Q18XdVeV913tceKtso1qubmZwzDKv/wePRos8t9aByR/33wBP1mGXnRkpjDY+LBWAzQhPXJPjmfBobMJo3N9U2sr90tgV9ufXJRKdEnr5u2f68xxCbURdUb5nHyOgSBznn/xx9CxqjekMlmGjoLbRy2IbLpz3t51hBdOobIof8c76WKs6Jou85TNC3aKNEu0YM3H8Sxzs+Ftpgk77O7u8+dO3fY2tpirqbcvnWb9XrNs2fPOD4+YrVcMvZgw/OOMV/BePEssME50b6rGWp0EBDoewFikLmYVS1vPH3OxWzG9+7epWwa1s+fC0PEe+6SJJ6ys7PTs8TqqqasRHbbuiHCGI70TQdqvFYHzN4R4KZxJBsZw+7uHq+99hoOx/lHQmQY1v6L3npoOhOuIEzWOyv4/ecsna2IEKSgtcLuCXIEfbV0OBDdIEQ3KEXKvmnWBc8fPeb8VA7lt7/8tb6oUvbAUHsCvnexCknYEeQZDraA9DmH0Z/utcNnxbgzhN7Wev4ooLSjdYYnhyc8fnbEuqhZFWvW64oojtnZ2fEVZF56VYs65Gw+JUkjlitpejAYr82wVTyLQS5YNKuHjT324MaGMIS4xgzsEACFYZASZWRkwjPCeEEH+mOSJKKSONtCa9FgUQoWi4WwG9qGpmkpy5K6qYYJl3flpTZy4wqhbAiZ/cLBq25qjVPad4LR2A6RLZWt7qlcxhst1T+jZPNl84Veqm1r6bqKJDKgQ+QiLoa1jChjm30lNxb84NKLAfIHQZam/pnFgwsecb/9RwfIwGAQPDkkE31mwOOdA1tHKWEj9PorXkhMkshB2tc/q59FKYBy4uU5h1ISmSklhXJCjUQOTV+MglVY14maqb97hTCK5Pk7qmrN8+cFR0dP2Nvb4/btu2zN94jjhFdfu8+t2ze4ulxyfHzM1dUFkhtoRwZd5rhtXb8+Ao0yeMS6Xwu+vsIXCoYks1KKREd85fA5B1cLfufWHZZZ3jendtbSWOs7SF30GixpkvvcT06eT0U7qK5omoqyLOnazYhYhnSTajwwsQbYUiIux3Q6ZXf3Jmma8fTpY05OT/q2gTCGhfxBEEXMZrO+SXjfYOZaIhQnqrTUJREiAmatQCpJFKGNYOEuEidAyAcDuhD2etNIc2ujNWk+42tf+xq6K3l6dEVnAyKxKXImUIvFOWnKrkbP0uvoINFBF3oEj/7+k67PjHFXHpQbMx5Wq4qHz444u1iwLmoWyxWdbcnyjNlsdg2KkdZ5s9ms7yc59mLHxnr8swCBDN6CNxVu8Og3YRO5xjjy4E0GrHH4efAeQ/Y8LKrQMOPGjRs91ucsnJ2d0zRQFCuWK+lBan21bbgXNViz3sh/2kRfTyYFIz/grs4n/QYGSr/xrj2fdUMNghh4X4BEKwVirac4mk0FvHAohobWeA+yH/GwKREDK1i1bwjhed02FPp4D1lyBd4JtUrC15dFLowKxDz7p23CGHa9xy9rcHO+x2/Xw2tBJ0R+OFpHMv/etwdkXVrnOf9q+Nl1GGJzbQUpWTg6OuL09Iw0mbK3t8fe/q6H6GJef/11ymLNarXk7OyUq8UVznPbx3BLeM+N9eNedFpCDaFDJA5+9rvf5Rvvf8DDmzc5mW/JnFwrkR/P8XK5ZOmWaA9ZTicTkjRlaz5Hm23quqYsKoqi6OHQl0fJo7XsD9wsS7h79zZ7e/tcXqx4+uQpq/Wyj5xfNu/SHjL3+a6QzBwSzEAP7bmmwjYVyvcy0EZhogSsRD5WSOtS2Uygmmp0pPtBk6YkGqMjppNtUp1SXVmKxZr7916hsM43bnF9flCakcszB7ZdOKCttT3ccz0q+1+M5z54TaAsdE7x+OSYR0+esS5qlstC8Enk5J75BCLQay3EScR8Pt9otnF9w4Sfjy/Xh4yWUC4dvIVN2ELwrk2IZcBb+00zeqaQ7Nnf32d/f7/3HtbrNcvlkvl8jtaaZ8+esV6vqaqKpikJxU0ohbPeo5Y7YfDAByP8QsnyxvM5Lwg2rrbbwClk3JXpi17CM/V5CAsdHbazPbtmSBQGWEa49G3XEESSwv2Mh9xaKxWpWtGhRQM8RN1WEYrTlRoZJJ8WsHRe3zqMwSAt4QNbr8g3JF6VMr7y1TNz0BiTyH32mKXGMzj93HcE+iPWjhKN4ZmCFoBHg3qtFCt89N5RkMjQ2QFj1XqTuuiDJdxY2OzaOrXWUpUrnj8rOD05ZGt7m/29G8SRIYoNb7z1Jjdu3eLy4pKnT56wWi19Z6yw5gfIRmADTZBZGHu5zq+H2CQkKPbXBR/cuc0//tpXWCUa5Vq6zvSGabzmhrUl0XdRNFTV2vcfzdja2iFLc/Jswnw+p6qqnmLZtk3fSSvMR7CYWkfcuXWL/f09kjTi6OiYw+c+yRy0Jtjcq0F2IUmSHvISwztENiLa1uAstE2HsiUKK3UuWMmb+MYjxoljZjupEu8dykjgrTiOQYF2nYdkGupVgU5SpvkBk2QK0ZTI1izXZ3Ru0KiXQ9z262J8r4NnL9Cd0opIvVxN8mXXZ8K4u+Amas3i6ooPHj/l6PKCVVGwvFpirWMymbKzvdMbyHFolaQpW1uzDR7pxntf+9p7ccGF2cDc1cbrwr/HG3J4fWACaIzRxHFGluXs7+9LQ4Wy7FUSJ5MJ6/Wak5MT37at5enTp15AaIxHh5A0YG0BhwRCwtOf9ENm/8VqvpdHLaNDQgWv1wok0wXoJOCcbjN68f/bCGUZvg+JVK0jFEPxVZDONVpjTOype6a/DecbgPfJN++RB0lUpZRXAnA0XYNz+JBYicaNHu49bNrxAdwXhyiLowPnvbiNQ96X8juH7URVcHO8hsu5caepYdX0Ik+EiEfGsG031Q8HaGRg6XgnewNn3VzjcivWdtS15fjoiNOTM2azOTu7wjU3WrpkvfLqq2zNZ1xeXvLw4QOWy9WG02GtQyvbL+PrXq9QeiOyuuYqyzjdmnM+maFDpawLjtBwrwOp4PpYWeq6oqpKFosL4jghz+di5H3h0GSSkWaypy8uLrm4uKBpahSaOI64efMON2/epGkavvOdd1mvC5wNeZ1NWE+iY9MrOYbnEu9YxnJg0YhyPl1LrIPRdgJVeulr5fMwnW3p2k3ob+xENoEO6gv+kkhhi3PKLsYkGUrNaFqhWhqlwchhYK319MvhMBvbmjC24f4jE/vnHsOin3x9Jow7wLpuefL8mKfPj7laLblaLinKNeDI/Gk/ph6GAZ5MJmR5RtAOuX5dN+pw/cQLBUPDxnyZgZRNaDY/O58ynU3Z3t7GWSct4nw3l7quuby89F17lrz33nu0be35qbIIxlVpQygaPjt8Py7vH8Mr4m33v3NOPFfnKxN9IjQkY0NyTQ6LABuEZ9Z+XCPw+h6SpBwaiGvnfBVi8JasePzOGyfnQKuRNAE4H2pqHwm0bd3fb6CFit5PxEDzE966FIFJcimU9eObecexoS8u8bBQwKrGh7s8cwh7PXtCD2tBDp4OoyKCgJVEIOMDfjz+jus80bFx6edGe8ZT0AIyDmW81+xaf2766IQgcR3kd01vhDYPDLVxH9a2LBYXLBYXHD5/wu7uAQcHN8jSlP39fV555VXeevNtnh8+48GDDzg7OxPD5udRIi/XQ1YyQopIa7TqgJYf+ehDnu/u8XuvvYKLRCdF+chWogDDWLJDxn+czA5rOZTzF9R1yyUXvhH7DOccWZ6S5xOybML+3j7n5xeUZcVkMsE5+ODD90UOoW/nKPvkekQY+zxcSJKOo/WwB0RyWWHbDldXQIPtGoI8Qi9/3Lb+0Ja5tErRWovtWrI4kWjMRD0UqMRa+zWrwRgaOspOKlnXTcXq8pg8AzPNkWY8rV+nys+pRH8hEgwHf4jcXSNroqnbjbXxSddnwrjXTcfvvfsey2VBUZacX15QNw3GaOZbc/Js0j+wNAnQZFnOdDr1J+xmZRi86LmOv76Idw6e6eC10ttbhSKKo97b2NraYmdnh+lk3uN56/Watq15+PDhC5TEwduVjTk+ZMbe2uZkDfQx4Y9vHlDXr75IyCfPeo8P0esO1abiuPjn799K7k3GwMMuXYvgFuH+OqztvJRB5KOVTZlUZy30m13R2RANjApd1Mg79cVqRgsDQoTfxs06TH8QyOHji5Y8G0EOyAHbHzzIFzHtEF2EdSBQ0ub6UP7ZgzHoDbYKzAgICyPM50BpGypA7Sh6MMYIzbKHsvy9eK5y60Q3J44GTZPr8+ysu1Z4FNaFzF3TdBweHnJycsp8PqfrOqaTmU/uKd566y1eeeWVvuF3U1Ybe6IPLJysdZSiNIaT+Yx7Z6e8fnzMg1sHuH4+LFEUEtaDt/my/TWOdl1YIyjW6zVFsUYpRVkW5HlKkqTcvHG7hyuVkureqixH3uzwmePPMcb0bJ3xnAbpkbGmkwK6riLyc2oR2eSAd1sr8KPfDnL/bjhAwiERoBK8o6A9BKlwJGmKreU1rbW0XUM2SYgpabuWsmkl4vJc9f79+kjcx+/WvbCeA0wz7iPxsuszYdyruubo5JzVekXbymAkWcbu9vZGVjuwS2azKZNpjvCp7UaHmXC9iK1vbvTrPxPvVwwgShPFQx/Sru3Y2d1hkk/orHT8efb0kM4+QTrkVKxWa9p2s+/iy2AdpaLR92Od8cDYGTxz58YYeuC9X+fv2t5goMyAuFw7vIbPCAtQEWAl51qf+Gs8pi6YuXJCARMuu+jKiNaF9h6O64t5ggF33WDkwukhQkddALxQQBQ2gpNIoe26fj61Nh6qCWPX0TYt2vCCJELYCKLxYfo+qeNS8kGmdmTY+zBGDsOhh5wY+HHbts5ulqYPp6LPEXhPXCAP5SsYrSfABO9YWDsMMLEEO35e5HkV46Knfi2MEozj6GuYU7mapuX0tOLi4oLpdMqdO3fY2dnBOcVstsV0usWNG7e5urzk5OSE5eqSoO/jrEIZn3sAOqP5p5//PD/77nf5hd//Nv8g/yM839nBWoHenIv6uQnjtHEgjYzvWD01wGbDftVekVLm8eTklDyfMpvOe+dhb+8AcJRlxbpYU5brFyCJ2WwmDW18Y5vryeKBRaRo25q6WdE562nRQk1NU+nFihk47z333c+p0XJ4yPrwOLyW4qa2bWm7jtQkmCgm1hprFZ1SxCYGlZPFmqu6omk7jNelCeyXACXJIW+9aNig4z5myfS9bT/l+kwY97ZtOb+8wFpLkiQc7AmDRI02aRwLpih4WkygTwVtjXBdN+ryw2vfXjP0URSRZxNmsznWWt8JaYIxhrZtqaqK5UI63jRNQ9M00u6KTRjoZclM2Ky0HLw/8ciCkM64K5G8dtOjDIZnnMgcPsdDKf6xBggmvDf9e4YKxeABKhVoeKPuncqhlcFEkuxL09RXw3mqY9vS1dLCzOlAMfXvoSM0qv8MPeLCA0L1UqPSfz+HoerSWYvtJ8x5b92iTYh0xoUfA5wmibPNBNtgQCxRNHg5/aGLp0a+NCry0YdP5I/hkX79uPCyEJVJCN23thwfLp6KMnyGG7xErXynKb1xz/1rR7cV4IYhOlM9VBnWV+hNsFqtSNOUg4MDbty40cOYs9mMGzdvcnx8yMXFBcvlQqJMH6XIsGrev3uPm6s1P/Lhh9w8v+Bwd2+0Fof7CeOxGaUOYzoc0iFi3WxePt6PIvtRcn5+JpXYaSoS1PMZcZyQZSmdlYRsURQ9myTP8/49xgyTcA9DcwyRzI2UF2azAT4TTDw4kPLagbVSNS0miqR61DtAQRoZH7W1rXRhapqGy6Ll48Mjbt+8yyRJMRocEUpVWNuRZlmvvzR2CMPnC1OmIeS5wviOq/C/3/WZMO7h4ebzeQ+1AH0PQ20UW1siq+sLxn14N8Ax4+vF8FC81B7F1pokidnaFrnb6XRKkkjLvrIspZ3dYsH5xSVd11JX0h3JXvsc+YwXP/dlz/dSOEUNz/5JjBfnhiKJXuti9DoxCINxCX8zYMR4ZGXs6Ybse+hQxcgISRPvKKL/eVmu/f05f4goFBYTx4gB7NDaJxV15O2d3+TK4bpGDJ0CdGg3EPpueu8Z7RuyBO9ZC4vEjbo2uQ7jGTbOyUGkvBSrDoi59fBLD+047wXJPRgViYfatrg+ihkoeQM9LxSqiexuGNMxdmutUBxbG9jzFq0icMYn3wbNkM3L9fcVDmGhtkV0Xe1Dr6h3BLRTOHXNkWAzkb65biQKtNZSrNc8fPgRz549YXd3nxs3bvRVmlvbe0yn21RVxeXVFReXp9R1iXD1HUSa3339dWoT8bFvS3cdIhjfw/XcQ/h9v/9UcEAGmefNLbO5jpumputaVusV5xfS2lCawkd+Dye9AzbG18f9TcferiR4S9pyTeQrnNu2w2iFNqa3JeFwCOvBWksciWrreBcPInWgjBatGQXrtqNc1zx4/JB/9lu/z97ONru7O8Qm5Y984UCidywo08OU4b7HB7Z1lkgbIhMolwpGxUwvyfdvXJ8J46605saNG/2JOcZPJ5MJ863Zhm54OE3D9/0VoPJrCz6KIoyOpdrP07CiWCYrFEBcXFz0OGAI+yQEHRvdzfveDNGHz9v8/Yv/Ht/wdejmk147PrBe9uzBELyANfdsEfVCeCp/Z8UYqbHXGLjaw0Yed+kBI3ghAi1F0ajBslKDd96H5P53ztGGzjZ94wdZqc5aqXhVA1UtVAAHnrsaja/q/zd61tHPrLPXbIXzHlaHc4aAuA8Qx5gLHt5o2EHXx3XsVBgCpOQPtZHzcf3QHTxbRYDanJcwsLZl6HE63PfQoGPEsGGgMl43qLJmrU+qy2c1TcPJyQmnp6dMJhPu3LnD7t4Bzkj7uYODAw4ODri8vGC1XrFcipriejLhm5//XE85HXvDL0Y7m+O0+fsxJXa8Pze/H4/VeJyttVxc1FxdXfbt70LFaYBsA3wR8OvAEw/8cWs72kbIBGO6oTZRH10MkdEmQSOOIk9UGKITo4cDwfYRni+knGl+4cfe4v3vPeDZxYKdyZx1ccVFPUNHEXZ0CIX7D/8On5EmCT61hLUIfIRQLxV8X+/9M2Hcw4SEwTVGmi7P53OyTJgwDvfCgA8LWvUhrx7hU3k+Ic+zHoNL0oT1akVZVTSLeqOBxrAQJSTujZwTMaxxuD++NqGT4WeflPi8fo03/Cauywsb6fpnv5i44oXfj/89dG8fWsk5p9G+OnX8eUp5mVsX6J7h8wWTloJL53nnCtV7q/6g8QiJgr7DkrWBGQBOqcEk2o5By2YzzA9SyHJ42AHOCeOl6eEEraTS0jrbs2Kc3aTpKSxaCx9del76e1YBNvBrQEl3o84qlBbJ4R4LD3o1185ggZecj35ClOMIBjpUu4rTIN4sdD0sJoVOA+dZPs/I2Lgwjpu01s01APQefVAcHeVk/H0vl1e8994VWfaY7Z1tbhzckKSjdRwc3GCr2aYqS66uLinKose3w3oaG5VPikqvQ5/XHZ3r0M31119/n/C16zrfAUwKgabTKVtbWxt7JPyuj67cAO8qxNnrQoW0o2eXGa3p3OahGZKoISkb3rP/r5N1goYkjX2yX9a/rda8cnOb1+/fZns+4bSqKcOYjezd4LCpHioK+LsxGq0iOtvRth1xYuicFbmM7tNd98+EcQ9X0GeYzWZMJpPBU2BzgseLTNQYpdfozs4OZVn2p3Wo/Ly8vMK6tsfPXwbljK/hdz2o+omv/ySc/dPe/2Wf97K/+6QNMl7I10PisWc/fo9w0vcL3T/fSL5r9DwD/isFFoywczHQTm16V53fUArBVEMyMfD1g9EcRwdKe0jKz7HQz4fCrGFTeu/ad/AJrfCC5osiiJUNB5PFijDYtTkKsgDyCwn15KAY8bT9oRQSgVoZ71UPpeuMxr8fewd2hH+PaZRC1RUTLnIX1ysMPYWVIQpzLszrGL4I93kN7nEatA3xA85B1yKaKCrAXIHnLa8py4LqsOTi/JzZbMat23eZzWZ0XUeaZty6ndO2DavVivV6/UInsetjO/759d+9zMC/7N/XX//9DP24+vSleRH/enldKz2SuxY3Uo10zvW7QDlQI8q1tbanNgcPW+yOh046aZ3plMP6CDC03Ds7vyRCk8Upq/WS2imc8QqxbogAxvTucN9t2+Ks5LCMa2ntkIAdF2J92vWZMO7q/9veucZYll31/bf2OedWdVW3u6d7HhoCssfCQnLyASwkbBFFKCTGtpCtSAgZIcUGIqI8pDw+JB5ZQso3E6IoRIowVh6CyAETAsGyElmJgY9xAiQ4DjDxOLw8hpn2THd1V3VV3XvOWfmw1tp7n3tv9cPqmXrorlFP3XvOuefs11l7rf96QU4dcPny5SUDZJHODQJoaNuOnUuX2Nreou8XdF3HYt5zdHzIOI4s+jkH9+b0i0WVuhdqBlbSBAQzq1254vni/9ZLJ+sW7/pFH6JszTzXS/ZT1b1SWMMlKq0u+vgdsJaxZzU+JZIq0LgRqYYqrN8GDxQGaIw1FXOrenASxsh09LQDKKkzP+rhSA0bl8jmF8ypzhLoumbMihR3wxjLsDPo0JPE/NutYEGHak9kdFSMt4EgqSPh9WYTthE4c7UWeB6VwfFuQFQRCgQUQTJ5AEK8SOazH3CHyNSdNSTsMmnhqdMyDAa7NDkcN85jiebUZkmItekvug4gTew2WXtKnpwuG9hFs+YUbsPqBpdgBtHO3jUWcQhrGBbcuvUad/bvsruzy40bT7Kzu4NIR9t0PHnjKRZvWrDoe6+36oXkq/W6TCcx5WUmtu74SRrq8u+AXC0ppOo6ERgUWCc2JSums2AYR8vSOrj2l7VGExaINavJi7HoZGOLY6OODCizbuYzqgzjyNgvuHn7DomWG23HvaN95OoNkjsmNEmy9N56JtNx9PXUmLdaO+vQUZkvjmlmHd2sYxz6BwqnQWeCuacmZWs+lMUQaXXDi6aumLK7exkEryI0t6Ra7le+EswkoPVLaE/BGG6Vwimriv6zJRe6ZcyxpvvBI7Y5lFDwSHGwbrHW0kf+gdbfV5+5+rz6ePHJrvFedUgmBElFq4oxkTPa9EvjJ42r+s69XLIfGbDi0kqz1TK44bnJGGZIi4niETQSUayWZqF0dVVSxds4Qkih6hBGbMyA0oD7GqemJTUm4VvcTgl40aishCBiSeNUFQtlL9JtaUvBugvEQt6IJhkox2AMxe0vWLaG7UBaogjIZM2oZs2jzH/sduGb3XtQTbi0xk4SidDcjVWLZjvV+MyRIIyQZaytX+O44Hh+j5e++hUrYvOma+zsWKF3Kx4PV69eY3v7kpWSPDrk+PiQB63DlTUd47WkfZ60UZykDdfXxrxFFbYwpIaxNTRAsA2hwSshDX12tRj7KKCu4BKyIGgqeV8y9ONxGk3TWEFstwmmGO/Uce0bnqPvhX64S7+/z86V66iGoVecA4ULbCm3qarmRBfOFk2ia5IJIRVqcS4w97btsgU/VKgrV6wKjKoZP7a3t7l9+zY3b95EVblz5072OXex575UawNGjmcSbnvThVf/7n6L6n5SRcA6a9Zrbss67HGKfau/42GZb1auX3kpJt4iEFkvRROoaTGqavhi1iRKEYHywuPSyeDGTLWAHATULP0STBzPKCjm7phSQrLHR0n1IGKZFk3qdTglnpVzr8ecFAgnpchXE8ZeKilZLQcMYrXlAlch0YTPso+feSSGJiNExFS8rJHdsjYwl3q8kcdmyPcKbSeJ+AYR0AsUL6bC5Kbrz6+uNhAkoDDzJ28iQnIsYwhFIs3vd968NLfDtBzbiSytwMwcE8Qqmtlm4/eyFeL4sQAjt/dus7+/z/albS5tX2L70jZNk9jamrG1NePKmy6DmjPC/sH+JDZgWYM8CTJZPr56rozflCSPQ011ZG+0oxhUDSJMEhtfYmgbUtMgLvwNngeoz04LI4vesPWARRTzrlFfVzW+X0NEi9487bZ3t9lvtrjUdChqKbo92j01EfWuvhGVgh+jKqlp2HZjbqyzWJMnMhanM8HcZ7MZb37zm62s3cEBu7uWAW+xWPDVr341V3kpmeTqSa3FvnLP9cx2VTpfRyf91n633kNg3e+K5L/svrj+mTVFhF4tLZaQ5NX2TaUkV/Ozng6QTPpOvUndAoJlRFw2RkWll1D9TRKFWsMJh47sFlhlbGybxvJgLMxVMFwa/RfVOEJdSLlIomDMrs5bIl4kYQrdBNYdSaQK4GGePKrlHVC1bWHUgF0szWrYHeLJE+akriGIbQrjaJpG8hfTLzFjp7prZuC4UtpSty2k7TIOSkmW5fsTgmCGZCtasoqvBjSksZFoMfZGama7j9kqJFz+fFAiurdxqK8R8U1KcoK2cRy4d++Aw8N7bN2z0nS7u7se+7DF4b1jnnjiOru7lkpg784tqzOwTuiIFbBGYCr9Wcf8Sz4YO1XY1iStAGQMPmCU2BRzZsUhsZgvYBhQ7Vm4l0sjWN79FNHcNrdjb7j+oCOLfiAlu2/XtWiylRMV75aFvutPXkdQjg+PaK48zZAa2mTFh1DLwjmMfYWhk/tgdh13exSy2cpweHO5HB5QreOBzF1EvgX4VHXorcCPAT/rx98C/AHw/ap6S6yHP4mV2rsHfFhVf+t+zxjHka99zfIyt23L3t4er776KvP5fJLNcBXT1kBDsfFaVQOXper6mmXIpf7tmnFYOba8CFcZLgQzzuXnlu55Es44wXIzs4i6oquby+QeUsU0+odx6AGT2g2j7Gkbsu98SIHGGKaulpIkF4E2yXuaT1p80U2kbGc0BrsM7n8e423BUbXWkqdR6jlxX+NymOI1FekHwpvJNLi+n1s+Gkpq3XEEHVPZ6NQYZxhXy3iWgBvUDJyWO8Q0jCH7pUepxLFUL4o91F/aUCvGMTyKqPoV8wXQMPRW8DprkOJvs4xupK3XuN9rorq4N1keJL+3ju6VNNA13USitcRsxWg9DIMz9SZv+DEe0e7j42Pm8zl37tzh8uXLOdy/bVvHsgfa7kn6vufw3iGHR4csFiWfUOnDqivlsgY7xewDRw9BZ7o51hXPluNFgtmb8dUx+aajSU0uX4hIXlc6muY0qm9CgtXobVta3ySKIbcn14TwBVz7x6c00s97kiTaGnKuNtlUaYiCeDDUQNeFk4B5dY3IiZviSfQwBbJfAL7VB6sBXgJ+GfgI8DlV/ZiIfMS//0PgvcDb/N93AD/lf0+kvu9zJZWTGh9qT9Wu+DSZ7JMoFlM9QCcxyeXF9SCGv7JRuCqcIQuxuqrhmzxBUE5oC0zdzMqwlGfV+U/qz3W2PFzaHFUZdG5QlkMr4zDQpJao0h6BSpHcrLzgFigUudBXYamALRxKwUol9oMx3NpVsfQ7euPfAXG/YYNjLIIwfjJO1kZoCa4FeQlBdWm/782Wosml81FRz0QprW1eilo5NQBJrkCY9Jsa8Vw9/pywV2DpD4ahZxyK14xh/ck1nHJ9DgYawdCOVQFiHHv6QdlqZljit5FBe5I0iLu8UWk0qjAOCXwzUCQnoMIxd7NvuNF77EGEptnOEmHxMNGcd8hSS9hYBO4bEMfyOzkMA7dv32Zvb4+trS2uXb1G121lgWR35zKzbotv/ua3cefubV5++WUODg4mLsf3g2bKGol3Kvq1CnFOKrj59+JCa305OjoqPvEpQdOSdKRtRo9qhlnXZQRoVFAZOZofZ9vErOIJxc4SFdKqoDYta2Xse1QHRh3oLjUl02kyaGzoF0tCDiRPIdL3vW2clYE47j2OY06zcD96VFjmu4Evq+ofisgHgO/y4z8D/DrG3D8A/KzazPw3EbkmIs+q6p+cfNtShckGbRrCvCyxr1sYK5uCMpVgOXkR5Z+sWVj175avXWVy4Voo5oaX4qX051UQyPI9a/Wx7nOdKGq5PevGa909Q4JRdQnHVfdGrHJUDX3Uknf8DopxrizsVO7l4dt5jiieB5HNMXAiSaNLK3YuOdMfR8u7EtJ/8XoQIhTbgprcy6AykFkkXzKPohRjY8ZU23DCsGjGX8tuGYwYl3QjotYksdRg2sYYumHkYo8Nt87xM4WWirDhG14K2Kd4aQUjiP7WqzH6Z6kYHCJQT8qQNasYYzMCFok1Ip4bIrtnaFv1GikeGmWNhBQc19U5Wpbfw/h7eM/SBXTdjJ2dS1y//gSLhcWPvPLKK9y4cZ0/92efYX9/n5deeom9O7dzdsplTl3feyJkaRzz8fE51XFksejp+6HyYJIJoy2G1QUpzTCoyYzTEXE+9j044zXXmYFESesbHndx32Umv3w85tDWtWK5m1a1kjo/TIFhJTx+GcZIl23aVJLi+fSgdL/w6Mz9g8DP+ednKob9p8Az/vnPAH9c/eYrfuxk5q7L6uqUmU9VtJKX2V70k/xnUwVUQe2VEfQwTP4kZhzXTc5rgVFi9y7RPEX6Wu5PYb66skjWtWVZ/azvU7+o9SZQpxeWUPFG8+8O6320oyzeSHk6bbMZlYrbnyRhXCxIGlGCgmhL285YLCIDoSfWQkgNLoH4XBO+86O7akJsZuprY3R1eWvLIBgzWvpmFG3LG4zm30cRkiwEYBtSMHQ74tim++SPo0tXjbuJjmJeQZWHi+bfh3eEF0UG3CpbaTSF2RvTGcoakURKYUdyuMpb1bQNOmCBUaoMQ0iwlA2JyEyZMlRVM5/UGLOYzmtZO8Eklt+5mmqhaLo+i0Q9DAvu3p1zdHTAbLbFbLZN23YcHNxjPl/Qti1PP/00V65cYW9vj/39ffNsSTYr696v8n6Kw16BEcWzG+bHC3Z3NWsFXddNYJrQKOfzI8fSW1Jq6Oee/tgNl8fzBd1sRhIPgHINzOalxDfUG8by+NXYvzkKmLPIOA50qfEsneYqKdV73TUti7HPljlJBhn6vkbvieuSGDx6EpKwTA/N3EVkBrwfeH75nKqq1PXlHu5+Pwr8KFhOmdWcKfef8JAy10nyIpIDWKpflhczf7e/+TGaBf6lZxZj12rbyu/FDSz2v3HSztLGVSnb1PsK0lEmUjKsagrLeOUqnBTtKpJz07R+pgEdLF+J2mJr8sIULFlX9NcKA3svvEwe4MmuzANHrWiGWhBN23aIJhaLkGoiP7vmcRdxacWHy5i8EO6WBVpKIAPNiGGho5CakE69ilT2hCIz+NCURl2U+5iybFLtYvSSafgLM0BsNmpSl/3XGuwjZaNZ1nR0lKyNODiEUAchBWMv/S/aEbkvdUpi8zwRUk65HPBepFI2Q7LEZlBtJLZ2POClicyeaWW9QPETDyZaX7MMB8TxwuB9LlMiXGYt6rvn4OCQxbznqaeezL/d3t5GVTOjv3v3Lnfu3uHo6J63obwPE/gmvKbU+5FMowIcZoSum7kWM+aAo2DCXddxeHjgQoyNW9N2oCMMAwwDx/2C0QuHN461RzvC02ZZkw3Yp2z4BtuF+6UQuWnU8jg1VlymkZIqIXLI4Fp65hKxEYvYZuBa5qjmuWP4/OMLYnov8Fuq+rJ/fzngFhF5FnjFj78EfFP1u2/0YxNS1U8AnwB45plnXDu+v5/riuTgk58894Zdt96rIMLoV6RtyMw0mPK0CeEXrTDZv8QlxwL9FLfF9bj9Oi2hSNcmZRb4poTq11SnKFiW1JfvKVIkCoCmmaFqni1Nm9yv3e/RNNWupqQmeVBFovGkXiklNBUXTftrrnqLIfyC1arNqLk8WuGL2DSSpwsYzdM/NhQdGPqAdqL9DZZq2Fz0RDtg7s9sSSn80xOLYWTWtUi2F5A9CtQZeK1FqarBQ737GWMGVlJxpUMjY6BLwyrVJhIQgQcTSco5QDSvExsjW3duE8jMSwgPkOIGObpbo9Co5R5hhEGtiIqkCDf3d8Hv2wgZXkgpNIFE1xUIS1JLeCnFeqnzE2UhQkMbE9+wV9duCB3xffTUCcXDqhTKuLu/x/7BHVJKXH3TNZ5++pmcGmR7e5srV65w7d41bt68aX7zh4eTGAOpGGxsiKYRKyX1JhwdzpnNOiRpxqPrzazrWvb3FywWLV23hY6JQWY0qbe1PSrStCieStf5SES6WxviHXXIZAnbT+5wUAz8MOpAcom77+eoJI7mx3TdLGvEoVHlcpFaEpdlMcHTFRRHBSot9WR6FOb+AxRIBuDTwIeAj/nfX6mO/20R+XnMkLqn98XbjZa9XgoEUZjUqoSO45lSqt5IYjkt7jqIR0LEDh24um/TVAtKvFKO2ItsS8t3avdzVYcjqLSJWhWPPiwzfH+i79rLcItJhFrBDtYPk95wo6N4H+rK9lmVDUlMCxa5nDJ0Ok72t5wjLypJU9VTJD63jqF6Oohk/vQJK9dm0uqQ28YEpghmbpHHI7F5WX/KPLSuSfR5rkfvZ2pGmFThqjyHXHMZR2PhUwOUrwMfp3EcHYcePK99vNR1VsrpOoEw6IXdQmPqiudK1tpiTRchJdqQI3G1QAA1hBLSvy8v14YGgqnmdZ83nJTXMSSfQ2G6/u1v7TqoMR610LJGIS/vp99H1SNv63etCFPDMPDaa7e4fXuPnZ0drl69yrVr19jZ2WF3d5ft7W1ee+21LHXv7e15BGyZ06YxPSYLP1o0nfl8Ttd12fYzm3WTusGxVnN5xqZBRdB+IImt02as3AqFDF3GXAUzNqNo4UclajU8Z0xTMC3clkzbWhbItmmyQAVTH/1aYKvf09gw8Y0uDLz1WJ9ED8XcRWQX+MvAX68Ofwz4BRH5EeAPge/34/8Jc4N8EXOF/KGHeQYRVEJgiaUDNYOvpQbFNnDb4QFculnxnZ70xf6mwtXDR9gMGbHjS36ZU+OLeRSXkqJtyf2CQ/IvfujBUMfwk86QwTjtg89vvHyxYK2/4nBN9IXcNgmpEbKKGu2qmXrACUIyf+bRohnDwyLGND/bdKiKORgtp0/NUZ6pGH4DCpCxQaRxDwpQEcTzmauqwUEijCq0npEPHVwYC1xUXHJsQXtTpcfWGf9oeVPyOGqWogJ7jsRnYEErdbSxjxCjz6m9n1GcOBhV4OOx0swlcXSYIO5XG8pUvRi2198stqGYm5TnLKUWUcsdQmNzA4bh1jU/p1g4XjO2h8YTjFHsH2YjKVHA46g0rc13aFrL70H5XN65LFj54svvjBuRxdcNzsDI74AJPIrmdVvLMuM4cvfuXfb397l582Zm8ouFFbm5cuVKfn5EnMe5EGySx0yEcGcMts+CXkotkX4h/g1Dz2y2Zfc8PmJn5wqkxGIYWCyO81yFbcfmvxhmU2pzG0wIKIy+eBbZeOcka2pa4TD0MIyuEZgWMQy1kDSNVo5MkeEtY+vXg8tGh+LECoPM/dqT6KGYu6oeADeWjr2Kec8sX6vA33qY+9Y0gUo0gkzu7+aYFxkhDYWb3/S+655V5O+QqlNWQ2NDMS+EWETlt8uJisgvb9xbsgRdb1LxrBqznNyj/ujn18Et+TnVmC17PcSzIDwmwpWseOWUcRfQRNsUrUEqRhHXle9i8RWhPWVm7+OkII359irA3PK54AxjVMfnK6w8tJOmEdq2s5skzD89DFlD62NkGfzG0YywQj9h3uFOGZu9vfRj9QIXSCJ4dxm3iBAtGs7UxU0cslIMRkskMZvFYhHGtgJTTNddSMiNV/TxPP1tl42mkewupM6pl0toQQmJXEXJ6r8GhNF1XWbusTHUWsLy+zC99zReoob98ppHJueDMmafGqvRKlUMgAtsOoStJDGfz7l58ya3bt3i6tWrPPXUU4zjyK1bt1AthtHt7W0Wi4UHMA5FKJpouSa9b1/aIuwYtYYq0nDp0iXTDBYLuoXlQ+q2tpirZ0l1Y7YORStZN06WIrwrEa9+LiqT5XwxTQuDwSrDMNJrT7c9y22q5ze+h8QekE8ILMHoo+859me8P+YuDxLt3wgSkbvAC6fdjsdMTwJfO+1GPEba9Ods00XrD1y8Pr0e/Xmzqj617sSZSD8AvKCq337ajXicJCK/cZH6tOnP2aaL1h+4eH16o/uTHnzJhja0oQ1t6LzRhrlvaEMb2tAFpLPC3D9x2g14Heii9WnTn7NNF60/cPH69Ib250wYVDe0oQ1taEOPl86K5L6hDW1oQxt6jHTqzF1E3iMiL4jIi2Kpg888icg3icivicjviMj/EZG/48evi8h/EZEv+d8n/LiIyD/3Pn5BRN5xuj1YTyLSiMj/FJHP+PfnROTz3u5PieUXQkS2/PuLfv4tp9rwNSSWjfQXReT3ROR3ReRdF2B+/p6vty+KyM+JyPZ5miMR+dci8oqIfLE69shzIiIf8uu/JCIfOo2+VG1Z16ef8HX3BRH5ZRG5Vp173vv0goh8T3X88fPBCFo4jX9YnbsvYwVAZsBvA28/zTY9ZLufBd7hn68A/xd4O/CPgY/48Y8AP+6f3wf8Zyyk453A50+7Dyf06+8D/w74jH//BeCD/vnjwN/wz38T+Lh//iDwqdNu+5q+/Azw1/zzDLh2nucHy6z6+8Clam4+fJ7mCPgLwDuAL1bHHmlOgOvA//O/T/jnJ85Yn94NtP75x6s+vd153BbwnPO+5vXig6c92e8CPlt9fx54/rQX4dfRj1/B0jO8ADzrx57F/PcBfhr4ger6fN1Z+YclePsc8BeBz/hL9bVqkea5Aj4LvMs/t36dnHYfqr5cdUYoS8fP8/xEKu3rPuafAb7nvM0RVrmtZoSPNCdYjqufro5PrjsLfVo691eAT/rnCX+LOXq9+OBpwzIn5X4/N+Tq7rcBn+fRc9yfJfpnwD+gZGu6AdxW1agKULc598fP77GUnuKU6TngJvBvHGb6l2L5kc7t/KjqS8A/Af4Iq42wB/wm53eOgh51Ts78XC3RD2MaCLzBfTpt5n6uSUQuA/8B+Luqeqc+p7YFnwtXJBH5XuAVVf3N027LY6IWU5V/SlW/DTjAVP5M52l+AByL/gC2cX0DsAu851Qb9ZjpvM3Jg0hEPoqlMv3kaTz/tJn7Q+V+P4skIh3G2D+pqr/kh18Wy22PfB057k+RvhN4v4j8AfDzGDTzk8A1EYkUFXWbc3/8/FXg1TeywQ+grwBfUdXP+/dfxJj9eZ0fgL8E/L6q3lTVBfBL2Lyd1zkKetQ5OQ9zhYh8GPhe4Ad904I3uE+nzdz/B/A2t/jPMMPPp0+5TQ8kERHgXwG/q6r/tDoVOe5hNcf9X3UPgHfykDnu3yhS1edV9RtV9S3YHPyqqv4g8GvA9/lly/2Jfn6fX39mJC5V/VPgj0XkW/zQdwO/wzmdH6c/At4pIju+/qJP53KOKnrUOfks8G4RecK1mXf7sTNDIvIeDOJ8v6req059GvigezI9B7wN+O+8XnzwNA0Rvtbeh3mbfBn46Gm35yHb/Ocx9fELwP/yf+/DMM3PAV8C/itw3a8X4F94H/838O2n3Yf79O27KN4yb/XF9yLw74EtP77t31/082897Xav6ce3Ar/hc/QfMc+Kcz0/wD8Cfg/4IvBvMa+LczNHWLGfPwEWmHb1I1/PnGA49ov+74fOYJ9exDD04A0fr67/qPfpBeC91fHHzgc3Eaob2tCGNnQB6bRhmQ1taEMb2tDrQBvmvqENbWhDF5A2zH1DG9rQhi4gbZj7hja0oQ1dQNow9w1taEMbuoC0Ye4b2tCGNnQBacPcN7ShDW3oAtKGuW9oQxva0AWk/w99YgN6P+myWAAAAABJRU5ErkJggg==", "text/plain": [ @@ -177,10 +167,10 @@ }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" }, { - "output_type": "display_data", "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAADfCAYAAAAN+JPJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9WaxlS5rfh/1iWNMezpgnT453qLpVXVVd3dXVbJHNQTIt2YBI2Og3ajAEUSDQIEDCMNoPIvwiP9IvNgjIoNGGBZOAYUqQbUgwKNESwZnqptjV1dU13brzvTnnmfewphj8EGvts84+e++zT2be7mQjv4u8Z++114oVK1bEP77v/33xhfDe80beyBt5I2/kj5bIP+wKvJE38kbeyBt59fIG3N/IG3kjb+SPoLwB9zfyRt7IG/kjKG/A/Y28kTfyRv4IyhtwfyNv5I28kT+C8gbc38gbeSNv5I+gfCngLoT4t4UQ7wshPhRC/LUv4x5v5I28kTfyRpaLeNVx7kIIBfwM+J8DD4D/Efj3vPc/fqU3eiNv5I28kTeyVL4Mzf2PAx967z/23lfA3wF+7Uu4zxt5I2/kjbyRJaK/hDLvAl90vj8A/sSqC/r9vt/Z2Vn4mxDi1dVsRfmtBfNl3+9F5IXrtOZ1F8666hrvWWTriWvc76p6LC1/viovUPayMsSCYyvLa07yYnX5q2Sh1fyH1f/m6uKXHO/2xT+s1e3/Kq2qf9m6XnX9gwcPDrz3e4t++zLAfS0RQvw68OsA29vb/MZv/Eb3t4Wf565fes5VDSKEuPBvWbmr7n+d36W8bCA559Yq13s/K2Pduri575fOa9rHN7+3Za8z0XnvF9Z9nfotquuFMtry589du9SL13jOQUoteNcAtnlW1Xl2t2QC69ZlHtyXir943aKHudBfu/16rpjZRDT3nubLWfScQoil7buoDOcc3vsL9xCAnAP3tv3kgvu+KLB177vsWbvS9sfuOe24uVAuHjyItmXnmulF6tvep712voy2HZfdY9k958tdds1v/MZvfLasbl8GuD8E7ne+32uOXRDv/W8Cvwlw//59/yo15qvKWgS2i6572Tp1AXO+rLYOi4By/rr5DtItwwOuHQgr6t4dLK45V3gPQuCdgwVtMj9A5usgpbxyklomiwbfvKzS5NvfFwJgA87dNlz0zmd16A6+TtnrDvWrzruyLCEWPsf8NS/SHxf26StA7FVpxi+j5c8D27Jn997P+mH3mpVt5XklwH7lfbj8HKuuX/S8iya3dfvBlwHu/yPwNSHEuwRQ/3eBf/9LuM9Mrnqh8wN7mWaz6vdF8jLg3167CCCXTQTXEe/9QqpkpmHQ9G/v8Q3Az7fBoo7ZTjRtnaSUS7WWq9rnqg57FbgvLbctrwHNK0GmmfCW3X+hrPnqffNfuGR+Onq1cpVy0rXolmnGbZ9ZOKbmNPnZfZprXoW0726dyZ/OuYsAfu17fsk0z3x7L7vfKitlHQtmXl45uHvvjRDirwJ/D1DAf+a9/9G6179KDb4LilcB+pcl84C5CABbgFzVoZdRJNB4xee0v0vXd69b9lt3gDdafXv+/DVtXWdU0NwE1T7TrN7t+Rcf6kJ9XswGuCyr2mqde6xqx3mlbxFcL7DFaEiBK7n/ZaJmzyTwYrlVJbvvZE2NsVtLGs2+a1nO+mzTf9vnEBfqdT3p1rFbyxei4DoAP69oXJycwIsvF8gX1a39246RdbX5ZSC/LsB/KZy79/7vAn933fMXcd+rzl1HrssBX6f869Z1FT3THaTLzumWt6jTrjZBl2haK7536wbLwb3byeYtEO8coju5Lrnvpdp1aIPuxLBI5ieLV6GBzWuuC39fUI8LdZjjqcMktraqv/RmF552XuPu9jW4QEvNF9e9Rff6riUnWExbLZJ1tMrratSraJhV5V9N9Ykv03haqsB1rV246CdY1jbL2nXdtvxDc6heJS+jVXeBfR1O7MuQZZPLPBCs0ylfhDJaJS806S062NHGF2mllyBtrj/O6IolGn23nAuY9wdscbWySPtvAfECv3+dGy0Zo10934eCL9Ztzq9wqf6d31xD0V1Fcy2cbDu/0dZjCZ12HX55/tgyim6hQ5HLc2D3eVdeuybd8zKyDOC7degCfbdOiyjOVRPGKnltwf268mW+sLUdNUuuveq3l6n7iziqrivLrhAEDR0hgrbLHKB322xVO6yom587Z2U9X4BvXVDISkvhUrTDgrqt28be+6UPJujQK1wErxbsW+16/t4XrJn565qy1mmnqzTK61yzzr1WHZ+nhtYpq0uFrLrPqol8XVmktM2XtQ7l2rWI1wH4VfJagvuLgt0qeue6dMuqsKp1QHkRFbOu5rKuXJej70qrOXQ70svUpeV3W63qKiLikua1Atjlknp1r2i1WTlXzjzYXdULzmmUTj2uuO8LT82LBmzn/uu8hQv9svl7gXZZcd3M6b5CpBDYrnKzZp3W7UOzd9/l8pcAY1vf+XDMRXXqUiHrct3z18/XYV2Zv88lemxF/+qOwUXl/KE6VF9GXlb7XgXuL1uXFgyvokhetAMt6wDdl73SWbSkPotknrbqOkfnJ7V16t51irXH5RWgJ1Z5F9tzVtxzWZ2WDfRlZXblKj532T1eWFtldR+6ar3CpbK4OLmuVwkxW/ewqEzoOMdhacTM8uLXUBg6zuB1yppNYkuUm/kJYT5g4WWt3XWtnmVyFWUDy8OMr1P/1wbc1xq4zYMtms3mZ7x17rdqdp0/vgjcl9XhRUyoRee2z9yWZ629dllw2Wm7zKJY1LZX1bGrFcHFaI21tLyllZ79r73hGqVdrNurlOtqY+vIKspDCIFihfbuF0SZzNepPbX5O2N5m7adh45l9RGdv3i/dN3Foufofl/Ggc//Pq/0XDeyZFVZ8+GSL8LBv+hkPl/nVpb1q2XWw7r1fW3AfZVcNftfV2Nfh1ZpZR4Yl1133cG+zu/zoZxKqZXayjzQrrpnV5OZb991Ot+qSW+tN9GetKwdxNol/YHJlzFprHOv68DIMh9Fq9VfcIZyPcrBe49fA9ivI8v68lUW8qJzVlEYXQVs3UCGdet9HUt91YS+SiFcpNheJa8tuM9rmMsebBH4dstYdN6L1OU6x9v7LavnOvda9EyrJrmrnr37eVUHWQTW3YlgVZ1eVHtdpmktO/+q866rVX6Zsqq+y6yBZRPlBU19WZ/snCs6/7plXOWkFnDJKvDdv1coW4vkZR2Ui35fBobzbT7fxq32vqjfde+77urr61jqq7T+RRPPonHY/b5KXmtwX7SydNkqtHUohBetx3Utg+49l5mHq65ZJesA81V1aXnI+futuv5lLZEv65oXMZEXTUSvUhvtyqtqty4gi87nReUte5ZVTtELADh/jvfh35yV1wXIqzTL67R3d+yvWnV6lcY7T/m0f7sKzCpwn6/vuj6oq2SdyXHR5DY/Dq+afF47cL+uRrYMeNY9dlVdlFIrwe0qLmxd821+oHSvedWa5oukM3hV8irey8teNy9fNrC/isnnwu9t+YsvvlDOsvJXfV90/jyNN6+stH239QvNy1W0yXxZrXRXnS6r6zrgv0gbvgprli06WvZ8q+Q61M38NS/aj147cIfLL7jbubrndD9/GSD4qkF21fWrHLbLZu75369z/1cBqNfpbK8S1F/22pe5z7rOvVfeF0PBF2PV562Y5t7rRsu8CFWyiipYVd46VOKi39flmdfpl4s09UX1WKRgXZUkr7U2uvd+0aR6i+rbree6FOZrB+7LTOZlzsJFs/CXDWLLZtLrDup5Teiql/Yq6IRXqSWvW5dl7+xV1eNly3gRk/pFy38RK6HLo1/Q2hsg95znF6Jz7lJOfY6muPL+CwB9HrhelfWzaAJ5kTK6dVoX1K+6fpXFex2L4qr7r2PhrLq+ldcO3OGyk23emTevIX1ZwN524kWde9l1L6K1XafOyyaA6/ggrqrDfHnrlrWOJrbs+HW1s+vIl6nlr6tFdevyMkC4DF66YC7n7vEi77IryzT1PyhpteaXue+LPvc6Clf393ncehVylQa/TF5bcJ//vIgrW6UhvSptsQvW6wL3ugN+XktZNjlcpbGv4lBfNSCu27FWlbXKCniRSerLAO9FzrhXdf950FinLa8a3GLut+vUZb6s69TlVZQ3f938OH5RkLyu5nxdPn8eG14VJbNIkXyRCfa1BPeuLOOblwHEy/Kd89fOL9Nfdu/2nEUm73UmhPly2u9dWmpRp2zP7a7GW2RGLuusL9JuVz3fOlTOdX//g5K2nSaTCYeHh0RRxNbWFkmSXJlKet3yX0Zmbc9l+mUVGL0Kf8D8RjOLFC/n3AsB3KusZ7c+17n3y5SxDHjXoWBedZ1eW3Bf1jGuApJXQctcdc9VHW/eJLvOhNM+cwvQF1LoLjH15su9akBd1+k1f591+MDrgP38vV/mnV1f62/btHNNc7SuKo6OjxmdnVHkBUVZ8PjxY7IsY2dnh42NDZIkeSUW4nzbLvs+q/UVbb7MjH9ZSmj+PvOT3KLf5n1ly+reVUqWnfcHIS9iSXWv7Y6/RX1jWSKzq8beonF3VV97bcG9lfbFv6i5eZ1zF2nFV2np68oq8OqCevf7i3ay9j6vAjC797nOJDdfl/b8RccXnfOiVsT1xXX+eoyxnJ6ccXJyTG1MyIHjLMKBqWtGdc3obITWiuHGBltbWwyHQ+I4vmDlvQzIr5J1KbeX1UJfpG/Pf++Op4Wbf1xxn9cB7JfJMgtj1a5v89Z09/nWpZCuMz5ee3CXUq4dl/2iA2oRqK9T3rpc7KoX131ZLxs6tazsbl1eVNaZ9K7bhm37KaWAy5PaOh25+4zWWrz3s7UJ60tYVj8ajzg+PKIoiu5PeNfk9Onc09SG4+NjTk9OUVoxHA7Z3d1lOBzOnmfRwH0RpaNbxnWsn1Ua/zLtftn3Rfear9Mqrfwq8JqnM14lmF/HYnmVls06v72Ib2Lda64EdyHEfwb8L4Bn3vtvN8d2gP8ceAf4FPgL3vtjEWr/N4A/D0yBv+i9/951Kj0/Cy7rqNeVZbRC+/dVUTiLyl5HXqWWPa8tXFdbW+eadSaOdbX67r+WjrpOp7fWcnBwcAFwsiwjyzLiOF5eHx+eI59OOTw6YDqdgPWzreOMtYwnY4q8wHqBjiK01kgpEELiPThnsc5yeHjI8fExcRyzsbHB7u4uWZah9avTn9axgK5z/SKgWGVNzZ+3zjtqlbOrzl2k/b+MZbxq/F2laF1HXjXl9SontXV63v8d+E+Bv9059teAv++9/+tCiL/WfP+PgT8HfK359yeAv9n8XSldzm0eaNvfukC/zsuZN5teRDO/7nmvQq4L8ldphS9i9Sz7fF15UYdrl39dx+E0Ho8ZjUZsbm7OrsmnOaPRCK01vV6PjY2NS3WrqoqTowPOzs7w3kLTV5yz5HlBVVX0emGCKIqaytRhAgDiOCGO09D+nANRVVUcHBxwdHREEsdsbm2xtbVFr9e79C7WebZXcXzReevSAYvKXZcu7I679j6LwhpX+RbWsUKWXdMtd1U45VXHXqRdVx1bJq+aeroS3L33/1gI8c7c4V8D/mzz+W8B/5AA7r8G/G0favlbQogtIcRt7/3jq+6ziFefB5l1tOFuY85zWovKnZcX1YquuubLniBW3fOqe7+IdXRdgFhWz2XUw3W0+CiKiKIoeEK9oI0Gl1LNysALEBJwWGs5OTnh5PgYW5fgHUIA3jOdjinLiiztsbGxxeHRAT99/32Gm5vcun2bXr+Hd566NkwmE4QUJHECUgIeIQV4sM4yNTn5NOfZk6ekWcbm1iZ7e3skSXLtdlr33JfRPteR67znRYoacMl5Oj9m5+szv/H1upNL957dfrQuwHd/+7IUwatWvr6MvKjNuN8B7CfAfvP5LvBF57wHzbErwb0ry0ypVSC0jFK4SrOdP74OUC0r78ugdpbVZdHEd937v6iGvug9LKvrVfdYNpm273EdLd47j5ThXGv9efiLFyDafCcC7xzj0SlHx4dUZRUWqLngSM2LKUVRkCQJ21tbHB+f8Vu/9dv8+Kc/YTKdIKRkMNzg9u3bvH3/Lfb398myHiAwxmDKEu89cRyjtT63HAFjDNPJJEwGQnD37t2l7bGOzPfxF9EWX4QCuC49s24du5P5Kk19VX2XteUiQO/2sXUsiPa3q5iDVfdfdvw6wROtrPvuXpoQ9N57IcS11QUhxK8Dvw6ws7Nz1T3W6kDd7+uYWouAp8vbLrq22xGX1eFVyjplr8pL8zLlXuea63Kki65d9A7mB3sbP30BOPBoKSmnU4xxxHGMECJw51Ig8EwnpxwfH5FPp+fvEqjqknw6QUaaze0tRmdj/uU/++f86Ec/ZDKezDbxds5ydnbC2dkpH/zsZ/QHA27t3+Ltt9/m1q1bpGmKJ/D/06JEAFrHaHUO9AjArQfE8/34ukD8KgF+1dhbNl7Wsa7nQynngbYLgC9KWSwbx1ed9wchi4B93XG0zjkvCu5PW7pFCHEbeNYcfwjc75x3rzl2Sbz3vwn8JsDbb7/tm2MrtetFWvmSsi9ds2zmXgTyizSjZZPIlwHs69Ao81rGq+oQ696/+/dlzMqWNrnKKlsVP+ytIT87Znx2Sl6URFqTZhn9/hCdplTOcVKVF0DCWtvQKjDcGDLJp/zWb/82v/+DH3J2eoYU0MsSjHOUVXXef7zHec9odMpoNOKjjz+i1+tx8+ZN3nnnHW7dusVgMAAPprbkeY4QAq01cRwH0HINfdPIvD9pUVt0sy2ua1muI6sA/svQJrvnX3Vs/r2/jKwz0X0Z8iLt8jKKUldeFNz/a+A/BP568/e/6hz/q0KIv0NwpJ6uw7fDcrOnCyDrrgycB7/rNtYyYJ+v17rWxLr36t6z/W1Rh5+Z/Asmp+vWZ9mkddX5XcrkZcX7QJ1orRdqql0t7nLf8EzGJxTTE7yrwVbUtqIup0zOTtnc3UNpjZCBcnfWMZlM8N4zGPYpypLvff/3+P7vfZ/j4xMUgq3hgG984+f42ntfZTqZ8Oz5cx48eMjB4SGTPMc6CPaCw1nHeHzGaHw2A/pbN2/yztvvcOvOXfq9PgJJXddMJhM+/fRT8iLna1//+gU6bR7QRZMSzFqLMQbvgxNXCIFtQjNflba5ij5Z59pldMYyrf46dZpfIf6q+el16/eiz9FeC8upqfnf18GPV0LLCCH+nwTn6Q0hxAPgPyGA+n8hhPhLwGfAX2hO/7uEMMgPCaGQ/9GVNVhS4UUm+nUeflGnu8p07ALn/N9V2vurlIUDfYmW8yq19Vausp7mKaB167HOfVeBwaLj4Xzw3uKxCGERsuknHhB+FptunWU6nWKtJU0zvHP86Ec/4ne+97shjFLAcDjk53/uPb719fcYDAZ474mVYHMw4L133qEoCp4fHvLw8VOePn3G6fgM6xwOj0DgkEwnEz755GM+/fRT0jRj7+ZN3rr3Nnfv3mM4HAKgtJ7FwnefpSt1VVAUBXmeE0URpycjkjRld+8GURSt3MTiZeRFgH7Z+Jo/tq72vAgHulTOvGLzZTkku/Iymv86tFt77DpW1FV1Wida5t9b8tO/teBcD/yVq8pc457A5Qbrmu/L8qasknVNwXkzudUsv2x5FUD5slbDda9dVzu7amJeFbK5aCBcZY15wnszxjA5G2G8od/vobXmww8/5He/932ePXuOs4at4YD3vv4eP/+tb7AxzJDCIRBYK5BSgRRYZ8j6KW/17nL/7l2quubo+ITHT5/w6PEjTs5GVNaF9a4+xMDnec7nn3/B559/QZqk7O3d5N133uWtt9+ePcN8uznnOD09wVTlBcVCKU1dG8ajMXEck6TJ2mGuLyqrwLYrL0PfLKNGF92je163jPmV3cvuO3/dyzzL5Wvb7775F46F8lofj8D79r0317jzc/yFa9v6tGW2k1y336wev6/9CtV5aTnadhZf9MJXabzLZBGoz//+KrWkZVbDKq15GaBdx6JZdv9VssjXsYwbni9/fpJc517zltIqzaf5NvvbnquVZjSa8M9/63d48PAh2ze2+drXvsbu7g6PHj3EY9nY6PHeO2/x7Z//FoPhIAw+IRmNxxRFwe7ODgZ4+PgxWmtu7u0hASEtkYy4desmt27d5Bd//hucno148vyAR4+ecHA0YloUFwarkJBlKTdu3MATEpKlaXqp/xpjGhrmomZaVjnGGM7OTiiKkt6gz9bW1tIcN69S1lGa1pnkX2Rczt9jUZ0WafXr1KEb1QRQ1zWw2tpor+9OJC11hvcorUOUViOuAXIhmms9OG9DX2voPbwDAYJ2krLQAfEWl7o+I2PMv3rb7C0zP+bNxfkHf9mOsyx/zarOsghsrwaii0C+iDpapMWseq5V4HoVFdU9vuw5r9Kq5p8FuPBe2t+cc0stoO6Evch5GqgW33DRjRUnJWEUNPAuBAJFUZT89P0f8eMf/4xxnpOkKW/1e9zY2ebBgwd8+vFn3Ll9k+/863+aGze2w0BDc3o24vj0lPd/9jP2tne4sb2D956DoyOs8zx9dsLx0Qnf/MZ7JHHMxkYfKQQax872FjvbW3zza19lPC14+vw5jx4/ZTwtuP/WO7zzla+wMdxECsmjhw959vQpb7/zDvv7++eD3oVB38ae1VVFWYbFVNYG4HE+hF6OTs84Oz1Fac1wMGRrOwB9d0VuV7r9e93ok1WT61XXtHIdKmaZArMIbBf116WU0nwVBCilLu2lOk/xtGN/UXtZGxa9SalwzlLXNcbUgCCOI6y1WFsjpSTPC4wxaB0jhcJ6Q13V1HUVVj/bGiEEUZTgfZhkyrJs0mm4mS9qNBo15cccHR1dySa8duC+VFozRHQPBbqkC4DrgP38b8sArzuJLJpg1qV55q/p1u+qTa2vOnaVrALzFyl/XqO+alKYfzfXyVp5eSA7nLWMRiOePXuGkJrhxgZVXYIAieTjjz/jd773u5yejYjjmJ//9td5772vcvj8iM8/+4wnT59zY2ebn//G19ndDmA7ykuOjo/55ONPKYqcb33rG2z2NxAIpBBh8VKvx/Onpzir+fizz3j+/Dnf+Lmv8a2f+ybGVRfyqW8MemwM3ua9d97CCo1OBggZnb9rD6Y2OGsDyAgJ3mG8x9Q108mUqphgrem0gWsvBfzMvK/LiqPykOPjI6I4ZnNzk83NTYbDYVjY1Wn7VsJ6gKtpxnYstTl7VsmyfnDdPrWqP3UVrXXPmZXb+R1EA77njmlr7YXQROccVSdKyhhDVVUURcFoNMJZ21B3IepqOp3OzhdCUBQFZTkljmPG4zHOuVkqCmPM7N4t1axUu+CuxQiFlOcaf/tcWsckyUWLb5m8XuDevC8h5yo+o7Au8kzzL7irzS9LVtQ14RZpnIvK7H5epxO2v3f/zl97XU18layial6ltJ2+6wycB+Clk15zTqQ1xlqqskRpvdC/seze08mEw4MDiiJnOs0pq5rj42MiUaMJJvDe3g6/8svfYXQ24s69u4ymOf/kn/wWk8mUP/WnfpX/2f/0z5KkEiUkElBC8OjxE85GE+7du4t3gt3dbRSyrTSRToh0SpLU3LixRZTc4P69OzhvkUrM0gRfemYhSeIIISW1NTgLCImUQWs8OT4h6/UY9PtMx2OOj48aILDIhtIRIrSnsQGAauOoyhrTRBe1gOE9VGXJ8+fPOHj+nCRN2dzcnFE383maruq/LyIvoum3111lsS8bo4sUjC64ex+SwpnaNIBbXqBfqrpmPBpRliFUNs/zkDhOCE7PTvHeE0URdV1TVRUQVkRLIYmjiCRJiON4lhm0/R4mVNCN83zekm0n3IvH2zaUCCGb791AEglcTKT43/7//t7Sdn1twP1FGMNloDZv1i8C5PmFMIs62CqOb9n9l9VtGe1y1fN0QXPde8//Pv8c3oe8KsYYoiiaZVFcRBPNl7mq7vN1c85xfHyM955YR8RxjHOOp0+fcnB4iI40w+GQfr9Pv98njuOFGR3LsuTg4IDx2QnOmeaom/muhAh0jRAw3BgwHPax1nJ4dMTmxoBf/qWf5+beDe7evYsQCmOnyFkXEbx9/22sM5weF4zGBVVd0c+ygO0epNTNwDpPadDv9zHWIEWA4ctUAngEtjYoKiKpQSmcVzgbkpI9f3bA4eEhG8MBSnT4ee9Bhn5sTI1zHik1SmosBpwliTTWWYqimml+WmvwQd0r8hBt8/z5c9I05Stf+cqF/DrrWlwvIlddu0rDX9RX58/rWtNwrlW32vZkMqEoCp4+fTqjAqfjcEyI8zUH7eTYjgEpJVtbW6RpynAz+DJ0o4B0/ymlEICSau3nnZ98Fu9B6/DezUC8TUN9PllBd6PFf3U0d3FOuVyq9DX7Wdt4i3ZRasuf1zKXAfm8LEpBvOzaRZPFqnzPy55l/vu1Bp4HcZHLoq4qvnjwgMPDQ7TWZFlGv9en1++RZRlJnKD04rS5876JRbyklBLnPQ8fPGAymbC7u8u0rjk4eN7wxxZjasqqZDIJibiUUsRxTL/XZzAcMOj3SeKYs7MzTk5Og5PJOXCeuq6piwrvggP0/Bmb0EhAKsne3h4ewc7uNr0sw9NoU2iE1DhbI4QnTVIqU6G1J44k41FBP+3RKu+SlpPVKKExNgC+dI6lnbPpzi3wC+GoypKgecUoEWLvHQHAZaTAhwVSzjm8sXg8kY6oa8Ozp8/46OOP+ezTzymrkrt37nLv/j329veJ4xhrbZOqWKB1jNJq5mCcTqeUZRmq1VUWZl2r6VMdjbL7fl+ZtJb5nK3TflrU160NfHaY6Azj8ZijoyPyPMc5R13XjMfjmaLSgnGWZWxubtLv9+llGWkaEsBFUQD0duUw7fh3Ducbv44QRHEEQszue8mqbNpPdHCrfbrZU3VOF6IF5yBSCtxstXIb0rs4GqjTky61zyp5fcCdL59n7soqkFz227IUxOto4uuC8rqm7dogL6CbHKIsKx4/fkCRT7BNZEZZFJwcHQMBZKM4Is0yBoMBWZbR6/VIkoQoihZaJPPafgv2dcMpm6omzydUVQCYuq6w1oA4BxFnLWVeUExzjg4PwwCNdWPiMpuU8J5IayoZeGqcATxCKQQXNTrfDgghMV4iRYRG4b3FWI/ABo1fZgSOMyGKFJPJKXbb4qUC4ZBYhIckzrBWIawK95St1bDkHQkPQlHZGmF9mJysw1HihUQqhYwSvDdUJmiYUkq01lgDh4cHfPLJp3z88cccHR2GzUOaZzr92YiffPA+/cGA27du89Zbb3H71i2SJMVaR1UWSAlKaaSMwF2kBaWUeAfeOzyWsqpQOr7kkF1Fla0jF/pGg1HN67ygGFjnKMqCs7MzRqMReZ7PQLssy1n/ay2UjY0N+v0+aZrOtPB2w5RV9Z0pZ77tH00dfKNJi6AYIM6drKt8FN77cC4t9M5NADNxtFq395YWrH1jec5ujmx+s81n0fntevLagPu8KXhtDZXVgDsPyutqzO15y/K3vIz5ukpeVbndUsqy5OnTp+R5McuxIoS4AP4BZC1FUXJ6chKcikoSx3HghwcDelmPfr9H3OwnKoRACnk+QCBoQN7jrePs9BSPwzsXFuYUBcZaEMGsnZXRrXijtSHAmDqsYFWBKzcmx9RjrAWpNEIqlFLYeWftTFOU9PoD8qIiShTOGLxwswgbgLLIESJBiBitU8raEMcSIQVSK4TQaC2wzuG9wBrbVn+5eHj0+BFSx2xtbZJECqH0LL+MMwYnJdJo0iRFKMHh0RGffvopH3/4IScnJwwHA+7fv8c7d/d59Pgxh0fHVHWN9R6HYDRqVsd++GFYHXvrNm+99Q77+3tkWdxQFTkffPgBXsD+/v5MG3UmRGN4Z8mnU/LqlBs3boQ8OXMW2XX64zL+3DlHXVZUVcV0OuXk5ITj42PKMsT0IwNlsrm5yc2bN7l///4MvLvUYfcey+jUZVRmy4F3Lc3ufq/zlgssc0B3rI/ZRLGwMWgnECHas1ZNlnNWje/Wv73XVWUEeW3Avcu1zjtErpJux5unDV4WJNv7t1rVi0w68/VYRhO9aHmrxANSBO/9kydPmkEVeHBnL0+is0HUXOzxWGPJbU6RFxwfHs3Oi+KYLE3p9/tkDaXTalFlMcXWZaA+PNRVSVHkRHGMrUqKoibp9dGRbupisc5fmESV1uRlTiQVWiuECSGBztV4W+MNWGPwKsE5cam/CCFRUYKKYoRKSNII6Wqc9LMFJc4JnDBUZYXUfZJMoeIdDo+e0u/vUlvD0dERg0FElAxQSmIij2cEqAvWx6V35OHBoy94djAh6/Uoy5xf+eU/zu7WJrH2WFMhcdi65CcffchPf/JTDo8P6WUZb9+/w5/+1e+yu7NDHMVMp1O++fX3mEwnPD845ItHj3l+eMgkL7De4XzIa//hhx/x8cefkmUpe3s7TWKzuyQNSLZUR1WWKO/wBI5XosAF/r4FulWRTYustfZvO3mUZTmLJBmNRlRVRV3VRFrT7/cZDAZ89atfnVmGUsoLWvM6953/vPRdiHMH5rx231pLLZW7iDrVWs/omaYms7Hj8Y01sqDOArzz4EVIUgogg8WEV41u0QL6PPXiZ76e5uvFgq+Q1wbc50O14JxzuyoqpTvbruPkfFHa5jJ4XJ1OuFtHuOzI/dLFQ1lVPH36hOl0wvHxCXEc8fnnnyOkZtAfzAaWECIsumi3q5MS3wB9l1sUogkly3OKPOf45Biad5AkCWmaIkUAbG8d0+kUgUcqxfd/93f5vd/7AVVtGWxusrExYGdnl5t7+9y4sYtSetbOSirSSOOtwZYVwlVIARKP8Mxi3qXoOoNDPaMopjcY0h/sYr3HOAcWLApUgnAOTw0i8NxRlFFZR1EGHl2IBOc1xnqOT04ZDO9RljWmtggc1lUkabTcKUkzXL2nqmqQBU+fHjCa1PQSyLYinClxtcHUNf1ewntffYtf2fgF9m7skCYSIRSeYB4ooUBLNoYRG8NN3n33bfIi5/DojIePHvP02QGj8QRrHDjLdDLhs+kZDx8+Ym9vn3/j3/if0Ov1wnv0jcHfvFLRzORCXnZWtu+7/XuB9mqAvCxL8jwP2w6enoV4fRHisbMso9/vzyyCuIk06U4Kl/nl5QpPe3yZld/9vCoooPuv9YXNb1DfLb/FofP7hDbzHUDu3redJMNeAuflhD7h2t5xwR/W5eVDWYLLTXO+1uMqeW3AfZlGvI5X/yrQfhGue9E1XUftjNIQYmEdFzkd58taV152Mqhrw3h8NtsG7p/983/K+z97H0HQjvv9ARsbQ7a2ttnc2mFzOGCYZXgZI0QUNA/aTS9k2GZOdt5Xw6O6Bsjz6ZTNQR9rDGVdE8URXzz4gt/+7d/m6ZOnYTAhOD58yvHBIw4e94m//W32dxJsEXjHOElRosfhs6dsbWyF9pYiaOgNjySaUEFwIBxCClSckG1ss7G5SxwngCCf5kjpiWXQpp3v4ZzFVGOkzxlPKqo6AiERokJ6wd7OPlpYkijmK2+/R5r1GY9LrA/gX+SCo+Nn7O/tM29Kz4uxFcqC1gIlIpAxXjqE8IFKkorNzS1u3dpHN5OpcZaiqCmrMZtbmzhgUnviuI/AokRNvx/RS4fcu3Wb2tacnp3w9PFTHj95jhOaW3fucufuPW7c2OeP//F/jSRNg9MOCdZifE1Z5ownZ5yejEj722xtb1/yrXTB3BjDaDRiMplwdnY2i0AJzssBt2/dJUkSlL6sWXvf+ic68HQ+u1ySeeVp2dhcR4vvWuDted0yZ1q4P187053MhBCzdnHOYbEg5Gxi6G6n2J4zK7PRW6VvraG2FUTzuQX7wL+fQ0Pbvxc/y1Xy2oB7t0FbuUpjn5dlL38dKmXdBmsBHi5aGOvUfV365UWpn0UihKCuK05PT4gizT/6x/+IDz/6YDbQjDVUZcHJ8QGuLimnp3wynuIdqCghywbcuHGDjc0Ner0+aZIRgN4iBLNFF0o2WoYQSKWYTqZoJSmLnH/8T/4RH374EVVd02orUkCsFV997yv80i/+AlsbW9R1SVUWYbIwUFUJzjpqW3F2NuVHP/599vdv8bX37gdDeNZEAeDjJGNz7yZR2mt+E8EcblaxAo1prJCqMb9t6xRzaB3Ri1N6mUIrQ10VYC2bwxgd1WRRRG0j8rImirfgtAgO4ys0qaC9V2itkFIhZsvTPUWR44Via2uLYloSRwmPnz7l6PiUu/duoVXIU+MReCkxVpFPDM5NSFLJVr+PqQriSLG3u8Pezg7f+Oa38DImSjOUilFSMx6P0UmEVoqzo2ccP3vItMxx3qG0wjnBNA8blrScdMs1B438FGMMQgiSJKHX6/HWW2+RZdnFJGi+dQi2/5ipo7PXdaFrC+Z7ehdw2z68THmaV8raz6vG2vwq1GX3bJ237dqOrvXdHrftQrQO5dNatnCe0qBV8OctBFhEJ15spFWK4yp5bcAdVtMeXVk1Oy8y29b9/brSDoB167nuBPIqfQZFkfPBR+/jvOcf/Pd/n88++yxoA/7cBRRrxS9861v84i/8PFVV4rynNsGpOp5MGI2OefTgU6qqRihNkiRsbQ25des2g+GAJ48ek6Ux/X6fKElJkpQ0SfnJj3/Mv/zd73E2HgWAbbag00Lx1t3bfPeXvsXtWzdRMmi+IYlucIBWxrIRR0R7N/jg/Q94+MUTnj07YXNrJyB0A9htgjDvw8bWcdynjTjwLbAjQRh8CzwCvBNNG0iGaYSLIY1ACAN+inchSkZ6j6urZmISSCkYJIJhT7O7fR/hwy5PCzX3GYYHakbrONBOiACCXnJ2Oqa/sROWsdsphYe8KCirnCyNgwnfUF5agBIaJQwqkmGCjGNMnRO0P0BItFLoNMFKMK7COcvPPnif+LOwgrUeH2GKCf2tXYabt9BxTBRrkIKqqvjiiy/49NNPqeua27dvc+NGWCNwCciZH6MCmjUH0gdKwnfovCBXJztbNEa7YD6/SLGddOYpo0Wy7JyuQ3V+zLXPPF/m/CKk+dDrC+UEUj5QYSJEW53TM1dj2ovI6wPu3i80z7ovcRlPt4iWOTcBgSt4unCgc9NrtOW8Fn8dOac1fPfg5d+7co16ikaL9t7x3//9v8+TR49DR2xc7h5Pr5fxq3/sV/i5r70XjhlAQqQtWZKwvTkMmqMPS6PLqmYyHocc5kdPMfkZx8+f8tko7D2qtCZNM4aDIaaquHd7H2N2OR2PmBZT+mnGd3/hO7z79n2iOIQzSs/M2RSUltDxhRQgJONJgReCQX+DZl5qNCFxgX8Us78e58HWFfnkmPFk2kTUhFA/0fgSvDBY70gjiTUO58vA59P2nfNQtFl/c80UZINjdmomM7haNMnf2N1lPDU8e/480BVSz57TA3leIKMy2DNSEsUJoj1BCqRQSNU4bttoCyGJdYScrcTqaK0E015isSYsspJSgPOUueN5WZLKikGa0R/ucTaecnT0OU+fPeGLhw94+PAhT548oSgKvvnNb/KX//JfZnd3d9YGC5WYhZ0z+EKaZTiruuna0jo2u2B7pZZ/gcO+rOF3Py/Cl0VW+XyumdaP1o2o6aY36DxBU5f282X/2yItfb5ui85bJK8PuBP4XLFggVB3VoQ16Y2OMvGHJdeadVsLlldHyXjvQ/yvTnjr3lukOuL09JQyL6jKks3NHn/6T/0qd+/cw1qHdR6U5OhsjPCWSEcIKcLCj0QjPPSilF6WcnNvm7IsSLMQC++Moa5rrHOUZcV4NMaakv29Hd56K5RvasNwY0iaZSFEzziSqFmJ51t+MSCbIPDjkpCHZXR2xtnRlHfe2mtwT9D6qtrB4vHgplRFSVkW5PmE09Mjnj19Tm8wDAu0kgSlQkoBrQRSOJwrm0mveRECvFcBxKVCoEJ0TggMh8bfIDvvrW3vrgjg6195l6999WuMJxPyombQi4ikR7owiVjrOT454/6920gESii0UOACN962hsSjpMD5sHBLaI1UjWY8uxvnjmbn8bbCeYfzCiEkMuohvMQ7T1EW/Iv/7r/hX37v+xwdH2ONQShFkibcvnObr3zlK3z3l345RDqVVVhyLwVeLMifLgDfcskNdSGaFWCYtnHaVmKdQbloDMxrxlf6slZARJdLnz/WSgvOXcqldZJe2upxjgrqlhWc2L6xMttnax33XCpjnbZYBwNfG3BvNZll3PUyM+2lxF+cAZYY1xfruarx5y8W3XvM/bDkt7Wcv91bLatwU4wUgl/6zne5f+8uDz7/CGMqnHFMJ1NiLRgM+oEdlQItJXVdUhsDzlDVNbWpUVHEcGODPC/YGPSJlMBbQmRMlgYwtHVYXdloLLvb22RZxsbmgKKYAj7wv5GmMhZnPUkaI4SdmauXLTc/i8EXIiTxogGvVvlp31zg/w2nR08om7DPH//oZ3z86QOqqmT/zh7f+c53SHTMw4cPuXnzBvfv3aafJQHEvWzqEFEZi6kNUaRASmojSdMtnHUgLZ4cZ8x5qqMVnKh3DoRhkKUMsgQlKqRwGBOAQ+uI5wcns5fWNoMQssFMP7NqW6D3Hhxiphmfv+5zCqTIa1AKpZoFO94hmp2jUMFvdHNnyK9855uURYGOYrJen62dHfobG6AURZ7zwQcfEEURw+GQ7Z1thhsbs4Rk7bOGOrnzyJHZ83c495ccri0H3qVfWpBd6Ztra7HglGWWSPtbK10wn9f2l1kCCx6A7srctomu6wu84Jy+4trXBtyB2RMvi365XoRJexGNtnWxLNH+9go6nZi9uDlZWt3Ojdt6vaDTZHGlLn6VwHR8ynh0jLUBlCIlGfT7KEAlKdI5XB34Y2eZAYpzoBpAMbXB1C7ws41GNosqEIJebxPnbUio5RVZopudkcSMLiiqCiEjkiTGCxr36nmnv/hKxOz1OQcq0gwGvXBUuAtne+9xpubDjz/g937wEx48eYJWmrfv3+G9975KkkR4BJ989DHT6ZRb+zfQWuGFxxPjhKeuPWVR4YUlUhod7CgqU+HcgLL0CBmjIo8QBZHWxJHCFhOWv2wx45HCPGAwGHzjN/AIxpNpiKEmLCpSzaKxkMfGzawKIRVKaLR2zIc/n+vv4X2cjmsqV7Kzs02WJhT5GbbO0UqHHiEc+3tb7O9tA1AWJVXtOTwKfWSwsYmMAklVVRUHBwccHB4SJzFf/epX2d7ePr+/98hmRdfldZwhlvu8e6+ntbda+rJU3IuAfZHltPQeXHRuriOLKKAutXp+e98agJfvKmZqLPN9ZpXjuHvf+ePL5LUA96CFrTZHVs1g8+dekEZruKD1X/h94a0X17Mz6VyyIloNc72iLp130flyPWC/rO9263UeEy48CCfAO7ywDb8sZsqnaAaoazQ9KUTj4vSAw7t2+fu5SCFRUuGsQcqIw+MRsVbs7W4jXIn3FoFEqxjrLM6BMVVYUCMaDYSLg6bbBgKIIsm9e7d556132NvNwFfMHIgdsc7TH2zw7W9/k69//Stsb29TViU/e/9DJpOc7/7yL/Nn/vSfJIp04C8IvH5RGCpbo2VYDJX1QgglwjUWA8EpgKSqHMJZPCWCiv2be9hivJCbvfg2Zjpb542Flb3et/HMwUeSpilZFXKqeGdxaYbzHmsdiJCaVgqJ1sFBfN5STT1F2MpPe4MXAqmi5v074kg1FMrFWvnG1/DZp5/y0Wef0x9u8O5X3uPtr7zXWWCkKMsSY8yFdSXOudn7kgsUMN9aZp3vVylqXYBfRX/Mf+6eswxkQ1OLGcC313T/rqI9lmHNTJ9cqdQtli63vpJquoass4fqfeBvA/tN7X7Te/83hBA7wH8OvAN8CvwF7/2xCE/+Nwh7qU6Bv+i9/96qe3TZOOfDsvVlFMy16Rl5rlNfpE/OUX1dKuZcS4cLXeYabX+pvi9vsV7gnWf/P8eP4IsjtOssprbp/AIXtGM8WkWzcsJ7CBMBPjgoPR4vXBOwG7RE58Da8+NCOIyzOCFQBG1dCDfr8AJJXVXBhPeyoWU67dN6Vr1HeoEQhl/+ztebXCgeicE1UBS8q+2Voax+L6Pfy8BbxpMJG8M+v/zHfpHNrU0G/S28dThT0y4/kQh0EoOR4GOkrBGymexkU3gT5ukbcy/ko2n3Drj4+uejNgCU1DjXZjJp2r3JAikkM2bdI3CuZpJPyPNpAB8hkU0fUTIKWSVdSaCDPZnuvve2P4d84L55P/iwbWDW65NPJ2RpTLfjtS5kLxxf+/pXuX3vDr//wx/z4Isv6PWH3Lh5kzRLm67gefbsGVtbW/T7/UvP291fAc6BfF7DXkSnzMbXwknyYvteCb7eN20a2rn7llpl5rzlzsel860L+Lqj8rzfnk8ybk5Pu6jdd9vlOj7FdSZHWE9zN8D/1nv/PSHEEPgdIcR/B/xF4O977/+6EOKvAX8N+I+BPwd8rfn3J4C/2fxdKs5ZyqpEqjgkU6Jtp8uz9Cvh2i+g3xWnXgL2S9C+dhlXHbuOzEClM18t4/GccCGrYiBfO8/hOY/A8AgCWKVpj8pIhKvxyjRGZFdnP6dQvNAk2ZC6jvBCk+c1OlY4Qqie9A584HqFCLaCbWPLPXQT28gu1zBTgwyRtHhvzpdv0wJt65DqNka7JFwyGAwQIuSfUaqHpQFvZZFIXLPJhpAKKT3OyRChIh3ey/NuIoOPISgfDi0EKgrgiVxtYYIgilO8VFRFETj4dmoRnu2dIW9VtwLN4kJ+nuHGkCzN2BwOwkpfZ/HOEmuHFzVyCEJFOO9mb2VmPbaVlgpbN4ukmvTIUqmmrbqzaQMWQBRHDDcG7N+6jdYRn3z+BT/60feZfq9mZ3ePW7dusb+/P1uws0iznt/xqQXxeUBqKZGusjYfOLEoSmT++va6VUDv/UVwb1/r/Hvy/nw6WDTJrLOD1UXrYbkGPm8pLEpBfl7O9dOTwHobZD8GHjefR0KInwB3gV8D/mxz2t8C/iEB3H8N+Ns+1Oa3hBBbQojbTTkLZTqd8sknn7C9s0ea9YijmDiOiNudZGb/Y+nL/jKkqyVI2bmvP3djXcTRc5N7ZhZ2NQbRNclfpmIX63de9sUJUAiBtYbnz581W3RdLqcFTGc9Xnq881gjsDVo7dGRblKlhvehtJqBfW+wzWCzTRkQgO+r7w0oq4ooTpAOvI1xosJTzfTToLWI2V6SLShfrNplwJwd8S2Y++7RTp/ws998E8WhdI/Hjw+4e2sbJSXOizD4BIhZvpHGaSvEhYVGYU4MzmLnHCrSpBtDqqK6UM+2Dl0Lz3lNWXvABDBusFU0E9Jw2GdjuIk3BbGS9NKYXroTTvL1OSfsLbY8w4sxSghwCt1smn1xMg9tKaWgNpaqrhAibZ6jndI77TabFIO1JpUiShJu3t5n++YNJpMp//Af/zMmkwmj0WiW0KvV2i91qTlQ6o6hS+0jLkbeLJok58tpz1vbkclFqzacv/L00AdaTbzTL8NCvZCqt11/MC/t2eE9i+bvZZBf9qzt853X/XL/WnR8kVyLcxdCvAN8F/htYL8D2E8ItA0E4P+ic9mD5tgFcBdC/Drw6wD9fo/j4yOskwyHJmT4s5ZIa7Y2N+kPeih1/YRg6/BnK551rixotzrDu9nsfhGs550/vnm5y/PJdMtYq4atgtYB8Nnd5zQp7z2T8YR/8S/+BcLkbA17nZqd/wuaoUPqc6gytqaqxuBtWMAjNWVZYYwlUgohJcONHeI48MEOj/CStKdIsrCKFR/jrIfxGEzYxUaqwBPXlUHriAva96VnnXEhC+RiJ9daY+z5NmneB4BrHZdKSExVIoTH2rCwhxl1JMLuX1YQEjW5zgR6biXNpg4pqITDiYXju/OqJJNJTe00Fodjws7OFko4hLH4Zqs2fMhXI6TDu7LRHpu0wqIF5Za3buI/rcXZav6G0Gjhvb4i7m2Bl3jXRrKsakqHsSHj5aQoODk7xXvJzZu3+Ct/5X/Nrdt3GAyHs02ll3HdF4r1neRaC3wS4R0t3nNhFXh3Nf5FNJj37eS1akQtWpfim/e/Ytm/n7N8WunoArNDc31jNQasj1PrWv1rg7sQYgD8v4D/jff+bO4lebGoNVaI9/43gd8EuHlzz29vb+GFYTx5ThIPUSqmqioeP35Cr5eyubVBr9e7sC/ksllt0WfRUBKdJ+IioPiOqd+O6PlwI3l+aajEhb9LTb1LP7SD4uK5C05Z+PMqjWn+t8l0ysHBEXf2NjpH/fyURKQDTQGeGzs9nIuo64y6qrAu7KRUSjlL2hU0GzEHGh0IbM4RM148tLetDcV0ysagj5bdAXiuLYX2b4oRIFTcbNbR1t1fGLpCEKKAGnCbledliIYREqQkSUPYphQhugdv8MTnjTt7ve1S87CwSGuFQ6FUTV1bTkenFKMJ/SxjZzCY1bu9dws8zjvCgixBUZbUZsSgn+CtY6Pfo7at1i3Dtm1pghMOiWnqpAGPVDJQSUo1FpINeexnzd18ENDSXM5MEMIhiCmLGu+b5FeLAE9AG30kZIQQMVVtmUymvP3OBl/96nvEaXqpf833tTbn0rm1u3j/A+DCnqXzvy+iY9vj5xO3vATql55p1hXF5fG06JKZkjGvVfvZLN/6Tq4jbV/yl6zNi3jkG7Bo67tI678Oc7EWuAshIgKw/z+89//v5vDTlm4RQtwGnjXHHwL3O5ffa44tFeccT548IS9zdAyRTuj3h/SzbYSXnJwc8ejxQzY2NtjY2Jg5c1otYpG0DTlrBG+bGGxDVdUYY2cmbYgECC+v18uI4yRkyHMXO/Kssy3ZXsv7eYhuJ6Bm4DQDudGX26tm5y4S0f20pibQ1tMYw8HBAfv7+0hfMN/D2ylJSYe3DlPnWFcDFcJ7Ei1JozRcJT29m9sIIcOCFwHWFJTVhCLPcQh0FKFUhJIapaKwv6gITtv21mkac2t/l+EgCxqqczNQOvcFiE7391AHy2eSV8SJRorzIRiAgLCa1XTaRCqkiukN+gihQWmywRCPBiIkDidUA4uiiSqRKC3xPoCgRDRUjMALi05AekNVTVFaUlQFlbNh443mObqA5LzDNx4kpSIQMVJIjHNIoZESzkYjvFdsbm0yrQxZllJZz2RaBI3dOTY3N7FekhuJUr3gWPYTokghsZiqpINknHtUBFDPxkI3Q+GFfhBeMB7H1tYNonQDKwWjs7PgC1igSF0qY44WnOfSu31zEdVyVZldbtq30Tm+A75zFF1z4fnzzVnUARuYu6YF4Pbe7XlN2UJyKQT38l2XPU2nXdp2uHh/f6GdCAyBOw8uXZXqZJGsEy0jgP8b8BPv/f+x89N/DfyHwF9v/v5XneN/VQjxdwiO1NNVfDuE3WJ2dvapjW9ygkcYW1IVBXleYK0lTTPKsuTBgwc8ffqUwSBjONxgZ2ebfm+AUpr25XjvsVVNWZcUxZTT0xPK6YQ8zzGmJooiqrKiKMtmN6KwKURla5Ik4ebNm+zf3OfG7h5xkkADAuuaQ53Gaz8ALbUDs05zfuLiyy98CN1omYnbSlfrUUqR5zk/+fFP+MVvfaVT4sXrTJ3T+Pc69WrbEoSQaBHila0zCG+RCKajQw4PT/joo49BSPr9Ab1+jzTNSLKUJE1I4ghn6hmAp6kiEwowzWR4OSzv4l/JWVHx0QdfcHp6zK/+6i8i9fwq5uZcKVBRSpxm9AYbJGkflSTkeYG3gp2dBJzFKQ2uh6ynCMxsIFtrmrz9rvGxnA9u5y0ykUgcWI9SwTmcu4ok0fiivrCU4hxIQ7ipFBIv1GxACyEQXnJ0eIaIeuzcSKmLM6bOcVrmHB0e8Nad2zMaq9VEnYXp2KCjAuNgo9ej9uehhudg01ie3V62Ivd8ODekSs6yHmn/Pvs3gyP3Iv24WJOcT5M7v4n6VdEf89+7dEur4c8mBk+Lfs001jo6ZfvkF8tbfNfuU8yOXJiIaC140WzBd05vFVWOR5K2O1ddV51fIMFwaJ5bEFx7S6ived5+kayjuf9p4D8Afl8I8f3m2P+OAOr/hRDiLwGfAX+h+e3vEsIgPySEQv5HV93AuRprz/A+oq6hriYgIEt7DIebjEcTTk5OmUymTKcTlBIcHoaNaqMoYmOwyc3dm0gpOT49ZTwaMR6fhgEqRQB0JWcpO4siZzoZM82nTCYB9MOu5Qmml/GzowM++MlPuH3rFptbOww2N7l37z5x2pu9gEVc3/IpvDULL0eczJ+2+HP40l2hNy/LHKv/2q/8Cr/0C7/Iw8/e5+Hnn8zdr3X4CLxQOAxSa6xLsL5GEJa837v/Nts7e1hrKcuCIp8ymYx4+OghURpz/923qMuwu87h4XNqY6jrAAx3bu1x987tUO9GY5EX6KxzjdO3INY8j28ieIyDk9EZwsuQVXEhHwo6Tri5cwudxoSYfYnD43xDD4gwu0rC4iBsFSy6WURHA4giAKHwAZQjrXCAaTh84wy2tggJRZ0Ti2hW7/P3IxprpD0ucRascSFenUAPGeMp65DvHhE2qxjc2EImGqRuuHaPpAkN9QLhPVpplOhw1m0jNBNHrz8kn+aBl5fNxt5uMS3jOx9a3BSN/6gNOxVcpOC6TtEuwHf7IlyOMOlSK90dkLoafTcDY9uebYillHK2k1UA9cbSmylA5/2h/T7vGzvXzrss3uVUAOFDCCsV3s/CJJ2r+eFPfw8fJ/zCV79BGgVqT1zi8Tv9e77NF47hi88Qqn2xbbttdZWsEy3zT1kOW//WgvM98FeuvHNHjJ1ydPxDpMrIkh5x0gMko7FG6RglUrY2E7SOcVubTKchU+HZyQnG1Jz2jnn++AlFkWNNjY40VV1inaU/3AgO2trhvcU2OcedNSgpSaKILI45PTtjOp5ydnqCbwZPPp0i1af0+n2ePHrI2+9+lZ3dXbJeHyU1yNZZtUj7aD4IZoOOuQ54fsI55TLbNMOF+PJWE2vTisL1ZnEpJUmaNCsTF3QID8YqTs9GRFGMl5qnzwo++fx9pKy5eWOPw5Mph0f/A8bWaJ1wY3eXm7ducev+10kixWQ8pi4mGFNh6irQNni0EgwGKVVZ46xF+ACOVe04Ox1hnWN/f3sONuZFoFQT9nYhXOyyfialJI57C8mn9lkvXNHQQKIhT5RWRIkgTsLvdVXhrSFWILUgFx6EDdu+aY11lrPTEdnWFqnWgQcPCwJm2vMsVBGoqpqyCukfZhqZlFTTOmTKFVA5y3haoSNNmA2D9iiknMXbBzCTSNn2qxZEWg3Uk+dlsIlmDkKoy/LCrpzz7YyH6XiM84H/VyqCJm3BhTOX8O7d/jj/r3vOPLB3y+pmWu2WeWEi6dBfYSa63HvO+fPZnec+d4i/TlHtPUUH+Z2zFFVJmmbgPU8On/H87AAfKR4dbPLu7bfRMoSZipnC1FocnXwzTcew1jItpvTSXoeAbOrVTjztc3TG/HUiZeA1WaHqnSLPQ56RuipQoxDV4AWBn/QJziiq0uKsCDmShZtRD8V0zKg6pqoqNjYGSKlI05gkSRiNxnggjWNKZ5lOp2ETYA91USK8pzY1g16fM6aznNvT6ZTRwQEAN2/e5NmTx4xHZ2xsbjLc2GRra4ed3T36/UFYKHWpwbsafWcGn4H97EdmUNDpwG1ObdE53p4DF03XVS/eWsvR0XPGk8lc/c7Nv7w0FOWUOElxWJSKkRKKYspkMubx40eAYDQeo7Xm8NlDPv34p01+lvvkRYG1ns2tTZL+AK0jFI4kblKbnp1SFQU4T1UZTsYTRmenDAcDhFcg7Hx2iE67BO46z3NcXeEsKDlbCXF+atPmXtJkmQwap7VBU25zMQrELADHi7AwKlUuaKiuBG3BukYTtnhncMZhqxNcqnDSEEXnG0mbuqbGE0USWbYu0ADCUng2+imWhNIYnM+Ct8Xac8AUgrPRFIvHCng+OuWsnJIlKXd2bjQBQyKAf7OptZMCtMSrQEW1S24aHQ+E4HRkQVqGGxkKh61KJA4dKaQIKclmU2pjIeE9P/nhD6idZXfvBptbG2xsbALv4TsAPw/i88fnz+nmZmkBfJnmOe887cbKX/ZxiQv4vcx5e/Ea3/nbasMrLGEsh8fP+Oijj/jWt38BKQSfPvkUox1VVfLg8CG3926zmcRYbGethr9AVYXQyVDuk4NH/OTj9/mVb/9xhtl5SGl4IxeDHeYn0lVRRPPyWoA7SJyNUCpFipQyLymLEillWCouNbUpsI3DrNfPqKqwA8xoNCaJYzY3NhkOBwyHA2pjKG3NZDKhcpZYa4SAPM8pioKyLImUJstSyrLE44mTlMxBbSqSJMF7z+72Nnfu3KUsC05Pz3j+/BmTyRhT5hw8eURZG+699RZf+erX6PUGCNWE9uHPdwuao298o41ba1CqcQj7c6AKTsUgSsoZDzgP6u3nVpZpOsbUlEXJJX1NnC/IinREmma0UYBSSvqDIc5PiZOIwaBHFMUMN/rc2L3Brf2b4Erw0EsyJJLaTPHe8dMf/xjnHO997WucnlYzzTXtbxMnPXQksdEpSEXSLAQSM2eE53ygnde3rmtqU2HKiqoO4HouITa/5WKFd3hTU9uKssgx9ZTJNJ/BXxRHzc45MdIZhPOYKj9P29v8/zxySkKsIIo5m4w4Pj5impcIcW5lGbdJtnsDahMWazWLwQJeFkBFohW3bwwCqAqFMTasAhZQ12HFrheAEvT6vRlIhD1FQ12kFNgmdvp87mv7hr+AUc55HJaqqhj2e9iqQCmNkk2ul3ZynGMO0jTh4NEjDg6fc/v2HX7u5/pNPMBi62oV2MwidDr9f10nanv9pfL9+XlSSkK+zMsZbZb5oxbVs6UMF/HbZVXywQcfcHxyxGdffMb+/k2MMzjr2Rps00/75NMpfRnzk08+4L233yXLstnYuuA78J7xdMxP33+fvM45Oj5kkJ2/a++7vX79+i+T1wLcvQNbCCwlkZVkUjIc9hFCkRcFzhoGvcFMC0vThEpLjDH09m7QH/SxzmG9BRwjmzMqCorphCiKsM7z4OFDrDH0+316vR7GWkYuZOjb3dtFCEllKo6OTrG2ptfrMR6P+PTTj3nnnXe4desmR4eHlHnB+OyMW7dvY63j6cMHPHrwkHe/8h733/4KWa+PUCFP+SJNwjnH2WjED3/8+3zrm99ie3MbvGIWLRJGXhhMAooqTDah7zV89RUD5ZIW786h64IjtgF4KXXDcxLGuxD00gF1fYJSgjgJaQkUPkQVBT0TBDhR4XzY6BnnOTk6Js8nfOsb32CQDrFUjMYTyumIk+ODYBUoTb+/wXDQJ44iIukwtkBWYaLFd9YLeKgqQ7+f0d/ZaxznFy2f9lxnDaOjLzBVTV2WHB2f8ODxI54/P2Rra5s7d+7Q62VUdUWSxAwHGVkSg2s2CRGBNT0PrReAwjuPqW2Io/eCXtbHWINS4cS6KLG1CaGdTRbGYHWJhq/24MIK28DaSlyzdaGU0O+nSKk5MyWTMgcpGPSHKKWRNCt3vQ+pCKKIJBEoVaM0IT7f07FGHNIrpI6CdStabtkTpxmTyYg0S1CXCQEg5J+/99bb1KZA4pDedhZ0nfevRZZidzXq/HmL+ukyAG7/zedDr6qK8XjMzs5OQ1e0ocbrR5DM6tMOgXbLzLk6uWYl8ZMnTzg5OQmpmUen+Njz9NlTclNhrWXQ6+OF5dMnn/HJg4+x0vGt975JJMJaEDrKmKsdT549ZTQNlOSnX3zO1tYO24M2THl+Y+5zZWfdNu3KawHuUkKkHNZInBA4rakArSS9rQ1Us6FuXQdt1zmLkgorLNPphIODA6QOuagn5ZSJq0myHkmaYsuQvXBjcwOaLeGiKCLb22QsKjZViqw8Tgo2NodkccyTg+eMx2M2hxskScLnn3+Oc440Thj0+5RlxXQyJYoiyrLk+PSM05NTPvnkY9756ld5772vBe2yofbOHTiBYnj/g/d59PQxSku++53vksY9ZjN1y/tJwcHRIT/56U/49s9/m36/z9OnT7h35y6qCcVcpEoZY3h+8Ixb+7eB0EmPj59STk4vAjvMVAUpJWourDRJeyRVEvhur0JyMG8DuLZav29WtjY+BQ/ESdhsQrQcJKAEOFPSjwRpP+NsUnB2dsRkcoJWsvF99MiybXb3EowpKco8lOEcuzs7/Kk/+atkcYwUpgkPa1RXf96+1lqePPycDz74iC8+f0hR12zubHH/3j1u3bjBxrDPo4cP+fyzz/nKe++w0X8LcIHC8SKkJEBjXOvAAyE1tbM4oVBKk2YZx8en3Ll9C6lliJl3Booq7M8qaPy2nXDAGZnLzKkc+kNDiUeCwhtyUyKkQEdxs4WboXaeREd4PNYYnK+oSoOKXJizW6OnceC20vY129D7gapfHE0ye+dJTBTH9AcDzsYWTN0JB+5y1P4SXx6602Xg6TpKu8fbOi7Sos/PC3x4XkxxzvHw4UMePHjIL33nO+zt7TULxZvVoktkvj6u8ZEJ2S5Yu0h7dOtUVRVZlrG9vc3B8RG1rXl8+Ix4kEGtKauSzx9/TlHllNOc3Od88vhTeoM+7955m1ioWfnehy0tz85OGU/GKKWJ4ojJdEo/ScP6nTkrKlTjsjXUHr1qOnstwB0UQg+obIEzFTYWxF4gRUw+KRDCU9clpmoWbuCDtqkFcRwxnU4wDoZpConG5nWjZYFpTMpelkJVY61FDxJcX+OLiom2KO+oFdiqoJieYX14sc6eNjsLpeR5weHhMXfu3GY43ODg+BglJePJmGmeE2lNmU95/0c/5Pj5M7797W+zsbkd+FJEACohKOuCk/IUkcKz06c8fPaQd+++i5Ia33jVPFDVNR98+jOenz3l+fFNRtOE3//J76O15M7+bcLSIxngs1244j1fPPqCTx9+wubmBsPeBraq+OmPf0g/EmxsDC8AS/jgESpEmgg8qrYkWYKIJNbvoZUhaTq89R4dxyAUECG0Jk6HZP3tkANeCu699RbT6RQdhS3iJGrmUvRNAnQtI7LUkyUx/SxGeIMxjrPTAyaTAhUrknRAlikGwyFJklNXoW/4ZqsoT0gXEEqWSCeprSWONO++8xZv3b9Lrz9AKMHZ6RlFMWF7Z5Nv/NzP8fPf/HoIWRaB5bQ+obYhuVlVVnhfESlBmmqc8JQKiMEUhuOTo2AZFAW1DZt/60jjN3rYwqKcm4HNDKgW9PgA7IKbt3aIb2yRVyEdbzxIgrbjHLk39JMIL4JFmkQyZNWUFuHAG4+PHJ6OleA9TgYtv6yqoD2Khu8VsjnLddwUjQaCD+PPCczZmIPDI6QXvPvOTRCaeeRZpj1ehxO+KuqjXU38k09+xMlkjJmUVKXh4cMH3Lixg5hHwwX1WHgPL4O1jESIkATustPXkOdjPvzkQw5OniMiRTZI+eCzD5mWE/qDAYPGvzetctCgs4hxMebh8SNu7+0TRb2ZJey9Y5KPOJ2cYrzFeSjqgryeUtoBUgsU55PBrC6d8M5gpbTRUR5WTGrw2oC7R0jP9rCH70vGriKVCeUkZ5oXDcXhZ+t+qio48NIsJuv3uXPnLiqJEVpxODmlKiu00DPNOQxiiJMY7R1lXVBOKipnkFKQJDGjyYg4jdi6tcfJo2MA6qpmmueMx2Nu3bqFkoqTk1OU0mxvbQEhPKqsDVaCjyTeOp4dPeef/dY/5969t7lz5w46itBRgowUT06eMrU5uh/jasd4MqauK2SsLwQ9nJ6dcnh8hJBgfc2jJweMp2OePn3Krb39oEHPHErB+B/nY97/4iOQjnE1pd8bMhxu8uf//P+S5w8/4/MvPr3U7hAiMZSUYcGOdxRFiXMCJcN6g8FgEBI14UnS4I9QErZ3b5H0hjjniZux8d7Xt88dwY1DkmkO2JmGr7VG+bDUu6GNiSJFlsXBke4dphxzfATPnoLUks3NTQa9TZI0TKJ5brCubqbCcy2+zYMDgauXSrG3t0d/0A8OY+PwtjxvaBS1ERjvkM16hjiOUWJGqASr0RhG4xH4kGrh+cHz2W2Hm0M2hgPIIjAWURp8J7InS8Mq1qKYtGp9k2HRkSUJKlNMvWM6mVAaM6Pfhv0+w/2bYVclZ8FPkORsDiO8UAgVUi1flED2Z1lE4RRd1b2Fry4N0YU95yzOSYQMXPN0VPD1n0svnOj84g0y1uHRL2jqM4dlp/hZEX4WSHB4csTR9BTrLaqn2Uh7TIscYwyxjrhi/rhw3/be1lkOnx+wd7PdvzfUx7f18uF58mLK8ckRzjv6vQHj6ZjBxpDtdAtjLKenpxRFwWAwCPntG7OtNhWVKXEqbVI6B0uwqirefuctjsenSKUpbcWHn30E3nP/1l2UDmRZVztvJ9X2MWeho+3AWSGvBbgLAGepTI0xisLXVLZmGCcIp1BxzOj5MZOTMUVZEMcR+7dusbO9xWg85uzslP5wAxsrrLNoJZvl2bKJBPN4KciGPWocToGgJkYiI0UlPFEchXBDH7G9d4NyMqGc5mF3eh8mFOcMtTGcnB6jdcg6GMcxw+EQkcaU1nB0cEAWxQx6fX764x/yyUcfoLTAS0/Uz7CppLQlrjakKsYaQ1nXKGWRTVy0tY6j4+eNI9FweHTA0fExzhmKYkqZF/QHUQCJBqRqW/PwyReMpieoRDIpzzDuBs4Yfvbxh6RyeX4bRLNniAxAH2uJMWBlTFFZnPMYWzXWjEUohaf56wMYB9wOaCelbCaesHAH0VnQIs5ThUlCKmGJv6CRBOpMsbW9FSKo6pwyP+DBYYmxPiS2urXPEElRTBG25nyD6OY+gI6Dgxsh8TrBigipLMLXAT6anPZaa4R3AdiQCOVpvctSgFKSvK4RMmxvFzUTom6AwRiLy0uEjBpr5ZwWQQpKUyKQs1w00gdlxguBa2ips8MjrAs5cnSzAMhZi6sNXkUIH5LA4T2WKjxXff4KZ0vPZLuD05idftgvti6L8I7aKKBl49ArdJSg44Qsy5AiCnmDvKf1FszHpsM51z4fqruwv3U2he68rg691Hz1YL3n0fEznp8eoZVikPapy4qNzX1eRFolbzI54/0Pf0Rpcu7duY8QMJmOSNMM5UPbl0XF4eEBOEsURxgcUZxQjysODo6wxjAYbnBje4coijBVSNUspKQoS6ZlwXa8cf5ehCBJEg4eHjR7CBSIsiROYg6PDrixvUMcJRcovdAs7UQsmlQa4Xe1lFw7l9cC3BGgYo2TDovD2LAZQJV4auFRykMvITGOvf2b3LlzmzRNEEIwzXMqayg01HUJQpAmSYiCMAH4pJJ4PGVdYYXHShUATUm01kynU2ZLQQTNsnEYDMIWcdZaNjb2qJOK05MTnDEUZUFVVSG2Os1wUuA89Pp9qAxlWaK1pijC3qTGWQbCo+KIui6wlSXtxTx58ph8VBDrlCiKsSZEThyeHIP3aKU4PDpkMpmglebw+IDv/+h7xFFCEicM+kOyrE+Uxjw9eoaIBF44vnj0OTv9fZ4+fsTT4wM2Un15om8OSCmIogRT5xTWsNlv9oukR2VuNwtgYJD0yNKwa5NAoDyIkNCdkAFPNHw8DR0VOqdvCcKG04y0QinRgFg76TTkuXezDtzGn0daEvV7DPtpw8HWfPHhR5TGsLV7g73dXbIsRUwn5PYIZy3ehpuKBjWEzDg4PGZ/e4DQMcYLhJs2uWtEx8MmkLL1FgTt2tmwmClL05DfxUEUaSIVNiqpbQ1JhFMaVRm8DRudCAdHR2OMU6RZL4TnpjHYNjeMQ9SeWlT0N4Yk1pOXU2KlQ+bJKKL0jsE5tjKn686xEk1skmsucE265Zl662kjby70Ad9eLdjeuUGcBIuvqip0HM3OXhbCeHB4SBRFbG5uroScEO1ykS2eTfYXLhQgHHk+5fD4kDgKi5pMXWHKmoPD5xwdH3Fzd+/SRDIflXM5fNDx+OljDsfHxM8ec3Nvn6oq+J0f/g98/b1f4M72Leqy5uD5c54+fYIQAus8SoiAE0pwY3cX5xxxkhLHIQeW854kTamriul0wtl4zK3+jVmI73Q65aOPPuLBw4cYEUK441g31qHj8OgQ4QQb/Y1Lk2J47eeml/e+2afiXwHN3TlPSY0aJkhvSHUaAFYHdrAuS3rbPUajM5599CGfffZZszw8aEfbe7tEGpJ+D1eBMTVahhWGHo+zYISnNh6VRXgfsiAKqXDOksQRRVlS5TV6kNDf7hNJyenRKWl/QKQjxtOczeEGaa/H40ePGI3G3Ny9QZImiDhiggm76MiM6mxMpCRVWSCVoqhrdC/BR4rahF10vPLBaqgtR6NnSGvQMqYsS4RWWBTGO4RqdgISYbs37z1uAoWpqI7GmLwmSzNu3ttnZMuwSAaDGXo+f/IJn3/0cdC2kowLziPOnaKingYAsAZcjcM00RyghAMnkV6SRRLR1EFIqIoTXO45OT4BwkQZNhJWqCgKuVpUcIqGOGpH1ORoCWDf5BpvdRPRgmobARLAWYkU601Ta0caa3Y2h1S2pipGfPHpKc5LkrTP3q39ZgHaGcX4LGiKzWIg4QNXj5MIUeGaVZhCSJQFRKAkhHAgJE56TKoRQiJNTexjvJQU04I4imfRMgqN9R6nBQKFN6BMoKaOTyecnFpUNGa4qbh1ax+sZ2PQp7IjvFJ4oShHZ0zzHOssU2Mpy5Lbt28hBwMmSiCTBGkUUqZ4DM7mASidxXt7Dpodqg4Ie7A2FoP3tm34C+NP0IZXhp2ppI7oRTFZX2BNhRMh/rqFyFn8thA8evKI7/3g++zduMF3f/GXieY2uA8SJhshPJWxqEij2g20Z3OUvzBfVcbyyaPPODg5oDA5Uiq2+pskSUxRFTx+/jisq9DxjMoQol3Zeu73mD1jA/LOW04mJ3hgWk4ZTU45PH3O0eSU7//0d+l9908RuxA8YL3FS0h6CT4Sgeqt4Ww0BiHoSYltUv/qSKOFYNjvIaWmLKfk5ZRe1sM7x+HJIcdnx3gZ/ITeB+sgjmPKusTikTpqDN52wvXUdcHB8RH7ezfD2FB+hmvG1KyS1wPcvUPHisrVnI1HRHFMnCYgPEkaYRuNcLi9yZCE4WBAFMeUVUVdV6AlIk2YFjm2Mgx6fbAW6zzWO6RUIUbYOZQQqCRGu/BCnLdMphPihhO31oCOSbOEdP8WT54+xnjXZOwDJRV3bt/m9PhkFsMrmpWDtQ2TinOWvCzp9/qY2jDopaQ7G5DFjPMzkjShFBWWFrwlmoTjozO8cPSHfZBhz1I8CBU6kfceESksjiSN8IlGGsj6KVY4jK3p9/ugPGeTEaayFKYkixKUVguigQEE3lvkTCsMMdpuZha2cftNrpSZ9iA4PHhGXdc8efwkLK5xbRIvCRKiOGZjuMnGxmazMlKE5CjSQwP2gYaZAxwfOnjLgRa25ujkjPHZGXfv7hOroNlJAUkcsb3ZQyvNaJLz4c9+glKK7d0b7N26B7ZmPMmDhZWk7NzYR0URZ2dHFGcHtBkm6TwtoXYo60MMvgp9xTiNsiFxVdhqThNFEUmSEGkFxmGkJxLnVkxdG/KiJhYCFcV4EXLYeOFBK86mBUVliLMQqTIajxiNRighmZyNGegEFWcIbylMSERWVwrvqrDBeT+lzKezibHxoqB0jKlLQohtsMSsrWfW0wV873w+z1Wu8PZ8pb8nrJJuc8Y45zg+OeQHP/4+4+IE8yzn9vPb3Nu/c3HTlfYWImRU/PjzT9nd3+fm5vaFeweHoW/6I9TWMs7H9Ic9YheRJhnKSVxlEMCzo2fcHt3mxvYestlYZcYMrpDRZMzR8WHg7NMELz3j6QiLZ5SPefD8EV+79xXiNMZ6j9ASqRVWwjSfcnh4RJHnSC0xzoZ2NQaldbM+xpJlGV+9/Q5ZlgEwycc4b7ixf4PRwwmT6ZSiKJBIrLEhP40MazCeP3/OjRu7eB+sw5PTE3724QfEUUSaJERac3JyTGkDe7BKXgtwD47JYNonSUxdG6YTS9bLiLXCK4mxlqSXkBCD8YzHYyKtSZMUlcZUwtGLEkTWR3iojcXDLAGUtx4rBcZZyqoOg8ybxjmoscZijUU6KG2BmZRkMmNjY4PK1EEDAvKiQEhBvL3B0dEJN7MUIT0SSaSCCRsPe+ja0UvS4DRUEhcpcleHLeiaZGjWWHpZD6cUzks2t7coypJRUVI7y3A4wBFMOq11yGrpLN4pTO2J0gQlYmSWMqkKSlOhVaBynHDUvmJrZ4M722/hygkno/xS7/eAF5IKEZKC6ZiqjBnlR2gtSOIIJWUzabVRGQEApFBsDDOSKJ2FmIHH2SY3OLC5GWJ4nTHNr6LZKs5jnCfWfuGADIuSgvNyNJ7yu9/7AVJ47t27fYHHDB9AKuj1Ivb8AOcc09ERP3ryiDjtcff+Oww3N0EqdJoSJQliUoQ0vhhaxnrGWEiBFzL4A4zHV5aDo0OSNKYuK/r9PnEcM52OOTw8JEmCwjGI4xDlZR3SBn7UueB0D+2lZ20uBIjaIb0nG/YwzlAUBQ7Y2dlBN4640hp2CYoJQoN3WGPRWtCujehOjcIH7TtOQi5950K6X984+oRX3Tn6Ul84O3lOnk+IoxQlQyis8J3yZzSHZzQZM5qeYWxNXlrOJsfUZo9EJ3PGgUB6ycHRM37409/nfn7G7nd+GdmkOg7KV5PCt+0XccTt/X2enT7HVobj8SGJSsnSjEme4xI4GY/YHGwT65DEDR/ok6WRPNbx+NEj8iJHa8XB4fOwgEw44iSjNjWPnj3CloZMh3eal9MQwjiZcHx2gkCyublFkqYkaUQSx+CgqisQIVVGlCQ8OXxOTw3YG+6QpX12NgWPnj8jn+Z459jZ3kbrqMlzZDk+OqQuKp4+eczd0V0mozG/+Au/wMnpMUWV83s//X2ElKRZyngyDlFaKFbJawHuMtb4fkwxHaGUpNdLGU0m1HWJ1grrmq3e4pjxeML44JhEx/Rv3CDt96iEw7oKU1tcUQRL31ikl2FxkwOkR0cKU9c4D3EvRkeSySRnOpmGSIsoOCmdllQYYmNol0tbY3j44AF7N2/S2xjitCAa9hmVBYONpNFcg7+g18uQ04peLyWKE0rvKGNPkY/whCgOU9f0eyFtcV3VeOeIkKT9HmUBsQ5+gboKiyV0k1tmOp0QaYVOE0Ts8N7gpMMLR5alWB9y5yAEKg2UQxKllGV+TtnOjexp4Tk6PmRzGEIlT04LfvSz93GuZmdrg7qquLF7g7Is2L2xw96N3ZCQSklEFCGcQzqHjqJZUjDhBUkcIxVMJxOg0ToNHJ9NOD09IUk09+7cuFwhYBbeIQRKBnpAqBAz32WdZ/HQBB5SxhotNYPNlLtxhkVyeHTCFw8esb29w+bWgNT7sImIUAgMSgiclCAVUUNjeOGwAoRWaCRJHHN8fEqRh3bs9XpsbYWJqygKjLH4TOKlxgqPqw3SWFTjMJVK4VzTl7zDSY9LNFk/Ia8qhFUza6nX7880ZCEkORalLXgFLqQiECrklpmtaJ41YdCaR5MS7wVRlAbqxlUIAWmSgbAsanOP54P3f8rhyRmDwYDd7RvcvXMXOjbfLOLEOsbTCV5AkqR4PA8fP2J3uMfe9g20VueKhPeMphN+9P5PcMJyfHzA8fER21s7RFE80/SFaDz7DnIz4enBAdZ7sjSjl/bwFnQcI7XCCcE4n4SFi6JVBrgE7F2AbwMCojRhMpngq4IoibDOMZqOERJGYsze9j5379zh8PkTJsaiophelpH1M4q8pKpqYqmwecV4Ws4oK6UVutdDSkleFTw5fkoaxWihefD0CbU1YetHKTA25MtXQhEnEaejk7B3bl3wyWef4ErD9tYWBwfPMabGuKCIlnlObWtsHSHqFVk+eU3AHecpxznToqCocra2tknSdNbBkzQNaXm9QPRjZD8hjXoY7zDOcTI9IzcVCkGkwvJyj8S6kItbS4WQnto6VCVQFryvyKWjKisiFaG9IOuFLf78pGR8cIKRBWmvF5IZKcXO3g7TKieTAxAw3Npo8sLboL1LhSbQEpOywNV1yJ+SJdRApDTT6YR8MiVWEaqnsaXFVy5oWYmmNhV1XeK8JonjsFwcwXQclvcrrZEqOGIsFqEIDk6lqIxlNDrDSUcSx3gL0SDFW4s3NlAMvuW4W547REnHUeDLnQ2hgIPBkOn0hCSJMKYiLyfUJkTvNMYz4EN0hlSNDyPi0ZOnCCTvvvUWsfJ4XzdUR1hxY52nNBXIEKE0n+FRiPO6hbj/hrH1jrp2TWKp5uQZz+yQwhNHMf2teyGffLPQy0uI0wF7xjKZTDg9OWV4byPs1Stl4zwPXLW1lroyxELipUMhsJXhJJ8yno5BwObmJlVVU5Ulk3FYjKJ0FCwy58EYpHNIF4Z8XYVUGmk2oCprrLENzQUeST4pgyWpPCfHx3ggyzJ0FBFFwWpyUkAk0S7C+wglQpZHpJ05sJkRX8GBfXIyBeUZDPsMspRqWgenuTVEuqHfZrZW0/YI7t1/i7v3JVUdksC5YsSTx59TlRIvJXs3b7Kxucnx8RFHhwfYOmzlZ4zBVZ4nT58w7A8YxMNmy8Lg1/ri0QOePn2GcZYsC5NXJGUn6iPM2s45xpMJnz78lJPJCB1HVHnO0dExcZQwHG42zn/Lo0eP2d3c5e5eoIJCPzl/mnNcD3Hmpa2xAqbjKXGSoKKwcbk1lkFvwCSfMM1zTs6O+MlHFWf5FFNbpLQkw4TKhWCH09EZPs9D9JwUaCXZ2NwMi8bGY2JTE6mYjWTAwycPqGuL0pppPiWwFKGeOgoZj2pTY6wlI0Rmee+wwvHBZx9isSBDmGqImKpx1mCsx5aLidZWXg9wF4LcBs/8zrA/22bPmJDFUUcO60IO8ayfEu3uYMclpamYnpbU1pKlgbM0tWkyNQoQMugxPgQUSSFRMgJnKKYF0zqnKoI5tdnrU0cV5bRAlY5hf4gUEuvtLMRrsDFkM1YIQgSCkBIdhZSw1jpKY0KHQdDb2mRydIw9OaF4XhPvDNCRIiMmTRXSS+qTAksZAC3SgeCMFGkSFrJIpZicnHF2dkaso1mEkLOOOJUgNDrRCBcWPRljEUhiBKaoqX3FlCmfP/sZsa9pfVjnEnq/1oE79g1PjNT0en2cmxDFmtSFzUu0VrOFPy24tyVKH1aIfvHwIfl0yu1bd4h7CuEdCEeSRFR1HZyXShE3i38WOfjmOgemydli6pLa1Kg4On+CNtIjvG50FKiwCyv5fHACDodDbuxuB448ysmbZwgOdt/QGH5WqBcCqwUikvSHYc+AuqyQolkTYF3odzJMXFXD47rah3BHBxvDPrWNkUpQFlPyicJbg9gahA3IpyVFUeG0ZWtzEy9CYjzvPXmeA4GmSZAhXNO3oYgzL+lFsrlxxHkvQjRGw7dLFRGngXqIs4g4jlBSzfaM7Q8t1ofQ1V7S59GjB3z/n/wT/ld/7pu45z/g//v+iAeTmu9891f4pV/6JdI04e7tO6RpOsuxo5Tm9v4t4iSajTlrA92kpObt+1+hNDVSSkxlscYR8umH8RWmWQe+pphOGI9GFLYCY9je2CSKY5QQGAuJDhp/ZU0AStWUMVs525p4TYw7gtFkwsHxId57pkXBQA9oc+3neU4SJVhrOTk+4sQchrBfB8oa8lHJ6fiE09GYvCgZSEldVZRKEPV7F9KaVKYGPNPJhFM7wlSGSEWUVcFoPEZIQZQkJEmMqWuqssY76GcZNJOQl55plSN0oJZNWSKVRuskOPKdQ8l/FRYxCUh7KaPJmJOTE+I4pKiNk5goDs5A4STCBQeHl4HHvLG9i04TxlVY7NS+WOfPNzOWqIbXCyFHxlQorUiiLKQ1UBlKaCbjEdIJ+hubHEwPwDg2+8PZGJJCoIVBWIvwowbcZODYXD/sxOM89UgwLmqSNCPSmr3tXQ4Pj7HTChlH9IWkNgEYhNKEjevCC8zPRggBmzf38MZg8oKejkl2dpFNDLrDIaTEVgbjDUIovA1cZRLHQT+uKpASVzjGxZjxyYi7ezv05GKOTkqJbnPFE7TkXtanNnGTvC1YQ8acxzK3tIlzFt8sMpPek8Zx2Cmpu7TbByoqOE/Db1rrCxs6zKI7OitoW8UrLKqCujJUpSHtgLuYYVwAZdHZuLgD7w110ay0Ne2CKo9qVvoC6FiSaIFWDisEpTMgJWVRcXR8EpasEyinliMej0eNZibJtSS9cxulZRO6KHj7rfu8/W7YpMPYQCHUrsbpkEBMqwytBKdnR3jvMSaAYa93vt9tv9dD9VJ0JlAVqCrkpInjmMFwgyTJ0EqjdUQchTDKez4iysKm5okOConUEUKq80RVtpNtUUCNB6GRDrRO+NafPuRPvpUGymok+L9+pMiyjNPTExCWjcEGG4ON8wR3gELgqoq8MrM5RwrJvbv3uHv77iyXPUCeVwhRNw58FyZW4XHOcH//HoNkSH84bPIJ0ayn8DgcVVVR1jbw+52c7jOfgG/7gGcymeC84+DogMrUDDc2KeuK0dmIXq9HmqXBv1PVxEkSbCAFsY7RsaIwFeVZSSQi9vf2kbGkODrGW89JWYSd24RoqxEcz1pRVEXwMeHJqyllVWKMmWnsuJC0zxpPaUqm+TTsOxFLbF2HhXS2wltP5EEYD3WFdw7nbGcsLpbXAtyddQgf4so3NjYQQnF0eIT3IJCYqkbHGltbTLN45sbWDhu9AbWtib0kyfqBx5pOMfZ88AaM8SHRk5cIBdaEcCJsAJ2izIm15tFHX3Bjr8JUBVpHuAzG4zHeObI0wxQh6qauJWVZEvdisiwOA9UrpPBEGKw0xLGgyi3HJ0ds7+xgfdgZKo5iRtMQilnYglqEsqMsIyIlH48Z5xNSIXFlTewVXkryoiDqJSQ6whUVFR6pJUKDQ4ScPJXB1RZhfLBenMci6A8HJGmKXxI6JURYCyCFaNhVR5b1yMsYIcRsO0NrbbOKLsgsMkNqnAchFVnaC3t+SgBLmxrhfJGTb7L5aZRatLnBecmtJEnMN7/5c/TSmMGgxwz2mxngPIzbg7cztsaaGqzB5FNAATpkkKQFCodwIKXBiyY8VjiMs+DluaOrNiRJjHWONEmQzUTYRo/Y2gYHuTfYqka5xoyQEm8tmNCqzdYbgWopCqQCYRymnNLr90OSu7oOkRRSEseh/afjMdo5VLxJWVnywpCkiht7e9zcDStYi7KirmqMNdjaU5kJJ+MmD49zjM7OKKs6TE4yKD91GaxWrVRIq1zXWO+RPuTR+bfvZHhfIEoQZYEwih/84Af83g8s1lYoKYmkJIrjWeSYijS9fo9eb4D3DlPXKKXRKgqxSEIw6A9I07RpQ0kcJyRJ0JrrukLKkBF1mKQkUqPjNIRotpuBCNckUzvvI3VdnzvEvTifCJynqixCCu7fe5fNzW2qumI8nZAXxaw/bqUDjDPUzlKWYRMXKk9d1kjn6fkYVIxUEUoLrFTEWUq2s81odMrR4RGbdpN+r0caJ3jjMdMq9BUJ3toQracVaUM5O2MDVrmwA10Uh+0fqWsoS5z3pCoiUTEq0hRFwaSYYuowCZ1vWrJYXgtwV1IiZHAQlWVFVdZkWYapDOVoGnbCKQxaarT1aBHhrOXw8ABjw8bBkQqLSjKp0crjlaAyBmtCyJxUAqzHO4PQerayUoiQoc8Yy/7N2xjjyNJ+iF/3IsQzNxZeVVdYa9BaUVYV2XADa3WgejykWUIca5JqSmVL0kRTTKZM8rA588awj1aSyXSEx5EqjbM11bQgQbExGBAnCdOixqYaLSCTTTinckCJLexs+y2nJE5HnE2neA+DNMMag3YhpltgG3ZdolWMN2FRS7u7TxsEqKQiShK884gadKRR0YBdeRso0TqsvMzzaUg/AAihGGxskqYDQDZ7VEi+/o0+dV0SpwOcsOA1XtTQRKUIqYjiGLycrcQEOPcKNtFNs8Uunr3dDfZ2N5vj9SylRhjMTabL5knz8WnYLNsbvLUYUzEejQCJ0ilbWz3U5kbYXrGs0NpjXZMSWRAWZnmFabT/LOthZcloMkVHEVmvN9spSGkdopiaRGO1CZuJ10KgrUN2UjnDef50H0hzPGCEw3qPraoAAM2OQ/iQK957z3AwJEpTRAjloizGVKXi008+5/OPPsPWddB8bdjoAgGTaUleVcRas7uzhamDNWltSRI3dF4WNdFkYSOROJYYC0pnHJ0c8w8+rfC1whZTfuuJpxaKCM/e/g2KKmc0HjHxFleNcd4hESQqpi4sp+MTtAxZXctmS0sQVFWIPIt0iHXXKiKOE+I4xhhDXVcICVHjc4ijhMHGcBbOLEWIEx8MB/TTHrGOMK7xd8WBbpIiKCpKKZQQDHoZ7crnQXorkD++id33EPYqbVb/NrRX2H7ThOAHE95tVVXkRUllStQwrDwejXMSNM5XqEmBKTxGNk7n2pKlA5SOwAk2B0OEktS1wZia6aQgSRJ6vWy2GY1vdpeKewOUlAyyjHpaIhCUpiKKUgaDTZxznJ6ersTVdfZQTYF/DCTN+f+l9/4/EUK8C/wdYBf4HeA/8N5XQogE+NvAHwMOgX/He//pFTfBeIs3jrIIYJIkKYn2lEdn6NKEDHiZxuKQwnI6zZmMR/STjF6aYeqSKI7xZU1EGDyFMVjrkVqHDRycR8uwH2hpK3CgREhOJXxY0musDdRPCLlh0AsmW57nHBwdsLm5iQMGm5ukWcbz5wcoqcmyjGG/x+nJiKzXYyMbMs2npP2I2lWYYkxVj4i0RamcJPMIaYmLErxCyxHObVDUAxASC6SZR/knKFdjLCF0KjF4p7FW4H2EqwxppIl0jHclUjocunG+RmQ65e17X2EQaeqioCyLkErBW2Sz5ZDwCiEUtjLN4ooC42qq2lKbSZNwLGi0renphSTpbaF00mjOEuugv5GEiQeHxeN9ihV5EzvtGo22ccm25nOHcj/fuyjE1gcONkwMIQbfBSrqUjSExFnH6PQJz58fcHBw0ESxGLI05eb+TW7s3gRvcM5R1XmYAETriAxLQGskpfAUwmOdxUrBZDpF6UB3TKZTYq3DTkxFEcAdP9uHV2U9nFTUqQqO1doga4IzWxJmDxk21Chqw9OTo9mS85ZWlFKiGr+Bc47JZIKSkrQfIZVndysjjh1SxqRKUTWOOppFX97D1nCAaajJJEmopCfJNFVRkjYrhJuhB4TlB9570rSP0ANGkxH//Hu/z48+G3L71j5RlOCp0LGmv9lDlB4fhUzqeZ5T1yFNdhJrYq3RzSrMtOgFZ2vzBsejCaPRiEHWY5hkeAtbW9tMJ1OUCmGak+mYoiwZ5xPcZMyzg+cYY4NFBU2aDhHGstJY65tJQpNmKb00JU0SNjc3AsUbaWRDA0ZR1GjO4Xvwz4XtJIUM4cxtf2r7V/jXOvmZhbY6woRaFBVVOaUqC+oaTk6PMKaiqoLPpCjKQAtLQV3VlEWBdQ6tVQiwyKckSYyWkjhqFsQh6CnNZDxlOppQl8Giu337NnVd8+zZs1kOpWWyjuZeAv+m934shIiAfyqE+G+A3wD+T977vyOE+L8Afwn4m83fY+/9e0KIfxf4PwD/zqobOBfMLKFlMNdkANc4jZHDPtXzU2ItkdMKpT1Z1qc/2GAQZ0RxTBrHeGvo9wecnJwER5QP3JdrcryDCtSDjvBSkMYZWilipdBSobUmThKMM0zLnNFoDAQnoUQQRcFEHo1G7O/fIk0ztIrY3NhqVjmG1abDjQ0+//wBb7/9Fjdv7lPVFc+ePmU6yYkijZCSLNtAWomzOZGeImQdVkzKirIqUTLGWkFVWyKZIFFo5ZEiQqLxskTpKrB54iQk7fIRSEWtBF7GREkIpezFAx598SlJlDIcbOK8IunvkGYpaZyRxEnwxvsCUzvqoiIZhCXU01xRVCF6o6oqlKqRUuObyBeQeC8bn167q/t5tAu4NstsAzzhF+lFE61yUbNt5cLy69kpnu5q1va67rnBCR9CUd955+0ZrSGgceAmaB2cuJFW+CgipPxVYZGYEBRCUjXOe60Eo9qQpinDKEZFEc4E525ZFkyLgixN0UlCFGnqumYyneCUYpMeqln9KuKQwEvYQJlZEVY+CiHY2t7GNStStdZEWs+eK0mSkF+orMBZinxMJDRp0myd585XLYdwRQ+Nw9vbAkVIpWDrItBVzabd5zv5homgdUB7H/YtVsmQnZ2bxCqmnOQ8evCIja0ddJrhnWN0dExtKpCCvC5ndZ+MJ9goJtrYDAu0RmFBolQKYw1FUeKlYOvGDSIVdjwTxnJyekBdGQa9IcONDbZ3NjgbjZg0qX7zSYGOI6JeGiz1kDKfPJ+G1NoG6rLGexiNz3j65BHO2tlmOM4FP0yShjj5wWDA5uZmmPSqqsnvHxFpTW8wbCaBmF6/12xwIpGyXX0twxabNFq2FKRRD4ZbHUR7F2tdExASMtFWdcmkmGK9pSgKijLHmJrJZBzyzEhFXVYkKiMWjjKfcnZ2jCI42J8/fw7eM9wYcnZ6Rr/fZzIer4LVtfZQ9UBbStT888C/Cfz7zfG/BfzvCeD+a81ngP8S+E+FEMKvShvngzOwtgbnLXVZNmFRKdo7okhjq5qz41N6vT6j0xF5ntMfDPBAr5eFPOsnZZP/ITglUiuImsxxwguUbBJdGUsaa2IVeE2tFePJlLzIGWxssDHcIk1DugMBDPsDJtMp+43JVpYVvd4A5zxRFHJL9HohwsV4y81bt/n408+4c/sWWZKwtbGFrQ0HB4dIpXhSPCNJEu7dv4dMQi4JLTxGSNKsZDqZYKiQxETREOlKEAbrPaZWeBcjWnD0LjgRAYQn8h4hamSziMjLkuFmgjSOo8PPmExzrAlmaaTDjkYCgVQxvcGAOOnhlaK3mbG7/xaD3jeakMXz3CL5dEKRj4mTCO8IawWKaQBaF+KSpZINJe4a3l00GhL0kwihdNDCm+XzbdTGjMmfxctDC0eyjX6YReqE792JQang9Ot2NylD+l6lVchbj7sQW51XJvChpNS1QQgbNOxEEvdSoiyjqkNK4yzLODo8xjnL+OwMZwx9IfBKoWTIXuldjZGgaoeug5KikzTEVgMmFtgocMbm9Iw8z/Heh2gQpRqKMmj3cRpyfUcqRH45ESZTWRukaVYNnyeeufDc3TRhnsD7ziJN5+bPc64rbNqytbnJztZWSPWhoCgNd+6/Hbh1JVE65vnBc87G4xmA9tIM6UP6D2NDcrN8nGMFHJ2eUFUlURIzTDRCa4y3FNMRlBVKaKaTMcaU6Fg3jxUsDxREaRT4+TSmrArqqiTJEuIoRnjBcHNIEse4ouT06DREP7WWEILpZEJVVpwVJYfPn2NM4MPxHmMdzjX+ozisNE3TOEQpJUnjd4qb42mY7Ad9kigK+xfQOlPbdBZhbYaMFDR5cZzrsbmxjYfZXgGe4G9sNyEydUlVFUynI05OThiPRigheP7sWdhfIY4pSkOc9ZlWFVF/sBRSYU3OXYSt5H8HeA/4PwMfASc+JNcGeADcbT7fBb5oOpoRQpwSqJuDuTJ/Hfh1CJEyzrrmn20WMvWIlMb5AhKLczkbOwIpJiit2NpLAYPDIUWNUyF7YzwQKBURqSGRjZiMqyYELzj+bu7tUhUlxtQkiSaKw+pUpRWjk1MePX7Mjf199vZucGt/H2sMRV6ElLPDIaPRiEePnyAE6ChCSUeSpBwdHZElGRsbveC0c/CjH/6I6WTCoN9j/9Y+WZqidMTu7i6PHz/m0ZPHbO5tEycJiVY4B2VV0ev10IlGOo/UimrqKKY1SgeHoKkg0j2UipBCNeGeYXwKIYl0jNQh8VQiMvZ236aYHGPLgliEmAYpwuYkUgTnorVQVIbTs6cUtcFaF2LaXcgNLoQgzVL6/QFxmrK1uU0UaXpZn7yY8uFHP+Phw4doIfnX/8yfIYo81pQY53DOzCgDhEHpczBy0iEb7f98x5+GCyWkDtMywthz64ALID+7AjrfL2bWUzi5ibUh7jqwdudxoVLGCFmHXFtCIlKJlQ4tLLFUHJ2e8fTZ8xnFc3o6Io4jjDFMp1PGk0nYmrDXY3M4JI4irIJSe6zymKqGokYJASoAuxVQ5QXGhQ23ozhGNzRBlRdMphPyvGB3dydYG3FEgmqydzaRSJGE2oHruKB92x7NwzV/lJJ4ZxEEf8z5gv1mz9m2rZwFHxbvbW/v8Mknn+K8Z+/mHoKwGYwzlnE+QkrJ3o0bITIkL2YavJBhQxzbpABRQBLHJHGMkIJ8PKWUORvDIZt7O0xPzihOJ6SxojYV0zI4DXWzOUrpwspx6Tw2L9FKIHVIP+IxeAOj8ow8Unhj6WV9QFCVZbDWkSF/VJWDhHwyQYmwlsB5HxZknY2QSqOajVKOj484OTlGIDDWhEVqXszAvd/vcXN3l+EwLGSrjUE0ikUcJ2GxUgP0/f5gZkVIIQIH30QpeQnEBCrTJcAQzx5vvR3GgLUWU1XY2uCspSiDD6Nd3Pjf/r1/sAS11wR3HzIO/ZIQYgv4/wDfWOe6K8r8TeA3AYbbQz8dTSlNEUKzlGAyOiOSil6iyLZi5FAHbcsGOgBiqspSTHMQiihK0HGMSgKPvLuxS5kblAzJeaQMsbBSgBQxTx6fcHp2zJ07dxonYUjmNM2nPH74xf+fuj+LsTRN8/uw37t8+1kjMiL32quX6p7uWXo2DpchRXEZUaZNkRBtwxYgwbo1YBg2dOcL+cLwhW1AgAwBvCAFGITtGxICJBlch8NlTM4MZ3qml+rq2jIrK5dYz/Zt7+KL5z0nsmq6e4YQaTS/QmZlZkScOPEtz/u8/+e/sL6+ZLGYk2UZ1uZsLi6Zzeac3jpFG8vqekUI0nHNZjOsVkzqknazE6aNGyFG3v7Cm6zXaz786EO6rmW2mFM3DZN5Q1lV5FWONzCmMOm6Fj8K7wQm0KakqUtwKzbtjjzLyUwgNznWZrhxZLNZC3PBWIqyoMg0ZSldINGjgk/PcYIJiHIeEIonWqOsolTik9GU0tEf0BCAIMXe7S7ZXY08e/QBo/NkWYmxlmeffsqjjz7m1q0lVVMxXx5RlBVGa9zQ0223dLsNEq4kBmU6DonqotP7ujEYQ8nDHLVm9A4fBDoQVOVmGLw/1Gfe7OcPhY+Wy8tLTu7fFUzzQLWMoLQAPkbcSTFOqIYBtpsdq8sriGCNxTlPURTJN94miqiTrbyxhFG8ibQXJs4QIxdX1zz95Dl3ThbcuXsLohbujtEsZlMi0A0yPLVKc73d0rUt280GFSO3Tk7El0aLTYWKEJzYPJTapOnGzc+qtaGZNGy2W0J4Ca4RDCbh7GkxlO2ddJ/Rc3H+jIAmKs2Ls+e8/sabHN1aElWk7ToinqvNmk0ris5h6FPTETBa0fU71CZS143YWfc9zosDZl7khCDDW6UsQz9SmIxMachzylpYMeN2TQiRru+x2qJ9T+xzXDfStS1FKb7/xnt8NxLRKEZ8vyPPStrdGu8EOptMJhJSYjRmmuE1ZGMu91YAk+XYXCIayzKnqhqBGW8tGEcxq3POMbgRH+T8jX7kenvB2cVzdMzQMWXFGpOwfEtdV1SVaDmOj25RVTVlWUgCU5bJXNFmhzlAllmM+lxmrNIYm5HbDJVYXlNuPueHWnin41+JLRNjvFJK/X3gF4GFUsqm7v0B8En6tE+Ah8BjpZQF5shg9YcfKjEIgsKa7MBXLScNXT9gQo5qPTbKMNSNgXbXsd2tqcpKlF+65eTeHQbEIa8NDpNlZBiC9/R9l4q7cLGPbx0Rg2ccR4q8oqkaMpszmS949PgJjz95zKefPuXOnTuUZUmMkQ8++JC7d+9yeucOfT/w4rlIg/M859bxMZkV9kHXtUxnNcbC448/pplM+NKXvige2VoJc0ApMJpuHClsmYZfEhsYQqQoCowxbPuO/nJNu1pjmpIiszR1wbxpKIqc7XYDDGTWUhUV0+mUF8/PGIaB4+Nj8ryg79eMruWAU3/uxhi9ph3GZB1gePrsknbYyg6qrPDBU9cV3nuqomZRZ6jgBGYpS1brDYvFnNunp9RNze/93rfkZ8gteV7S1BNu377DYnkHmxmKIic6xzi0DP2WsduKJ7qKBGUEt48C6SgUq/WO3/nmNwku8Au/+LPkeZJQ7TnaUaG0BXfjNa7UDXVuD+vczAb2EFCaAWhFjBawaOfJrEIHsXpdtVuyqiSmTtQoTaWNxAOm8Oq971BEuvEKiW1WIfL4k0+5uOq4f/8+daWJ2oCLFEpjvGK12/H08kJgn2RsF7z8HHt9QV1VorgN8OzTM148O+PtNx5irdgtfNalPaac3o0wctKiKa29oqmblwbUv38x7LqWXT+w2ba8uHhBVlR0ruXo6IiIYvSO0hbMF6LI7HppyJokqzcJS8casiKjD14skRVsd4KR73cofd+TK9AEgnZs2ssUzl5hdMCN4ELLMLSoaKiqmaRe7ZluKHRUGKPoBxjHSIgafCC4kcJalvM5WW5Zh5bt2KEzKBaG8boVvF6DNpaiKvGxR2cKhWYcPCE6tLFEHXFhpCgtZZ2jbU1hc0pTcry8BTHwySdP2Ox6rlZr2rbj2bMrnJfdYFF+SFmWB9fULMtEo1A3Qp0sK6azKXVVUZRCSBBbX4NN9gyZsQIjsffL+tGFHf5wbJkTYEyFvQL+XWRI+veBv4wwZv4j4G+lL/nb6e//NH387/1IvB3ZImc2SzFsEiTrg2O7Wcv2rjKUKMJuwPmItrmEUGvNttuRFxn1tKbXAaLGu8CjZ894/L1HWGX42jtfpKpr2t2W6B0EmM/mUtiLXPjNGIrc0DvPbDrn9qlnvV4zDgFrZVtWVRWbzZbJumU5PaLKazbrNSqCUZpm0rDIl3Rdx9nZC1bX10TnmJYlk6rm9M5tur4nXFxyvVoxOVqQWeG+uhDZbLZpWyed8zDIgLVYNphFJR7pAdquZzmbkWU5k2bKbDKlbVusEpe5+Xwu2+dErXr29BHGilxHTKRubowQI7tdy+VqxWK+ZAwj52c7LlZP8b5nuViy3W5YLOf0vXjMPHhwLxVLhdUyTC7zgjKXAWCe57z64CGZ6nHjyNnliu98+yljEPtdozPquuHu/QcsFlOmx3fIs5xu17PZrvFeZifojKg0PiquVxsJFUy4vFIvGY6ppDJ9GabZF/7PHOnzEs0wfbEMN4M8UCm4kFEFgoJq0hD6gV27ou06Tk9OKIpCVINupChLUMKzJgjVU/BihQ7Qrba4NrK92oEz5MYy9iP1dCr47/U1uclESmUMKiafEm2EkRHFJO/EZAz9yPXZOU8fP+a1B3fIkxr3pakzCvAx8M1vvcsrr7/OtKkprGXsO/K8pG13lEX2Q0qDYjqZcnpnyna74+JqxYvzc9p+w2a34d69V8mLkmbW0PYdfgyHBXQYB2yWgVZ4HwkqUpqCshTHTJ+cNFUQXnlUJG98j/Mju35L1zryrMA50gwiw1qNaQIaj/Nroo2YLMcYK9BNJrRkVbUUjfDTIxllITGP1/GcjJJBG8Y4UqgMO6vQqifELVEPhGiR3HXNaHuUB5WJNcLoOpSNzI9qMmPYXLf0/Y7T4yNU6TmaH3Fx/gQDVKXF5HMiyxTUomF0BCeiq6vLq2RBIHCLSa6i2lqmsxlNU5OlxSukJK+6bsiznPl0Rt00UveA6XSayAE//PjDdO53gb+ecHcN/D9jjP+NUupbwN9USv3nwG8Bfy19/l8D/mul1HvABfBX/6BvsIdiVBRfhaIo0KrA5Eq8IgZHRGGakspWmJix2WyxWcZsfkRWZIRcs/UjKqn8ghcq1na9ZUw49iuvvIrRltXVNTEqFsu5WAxnJePo6fuR69U1fd+zWCyo6wmr1TUff/QEYwU2OTs749133+Xtt76A845J07Bar3nx4gVf+OIXMNZwdXXFar1hMpkyrSoWsxll4pGDoiormqahw+PVKHQ65wW/i6Ko895TlAUmMzgFLgSMsXRtS6NyhmFk0kzIcxkWudEzpET2qq4OmJ/RhrKshL7l3O877zp1uEVZSthzlO13WRQ4t4eJpHBYa1LKEuyVQ/uvf/H8jMePH1M1Be+++23unp5QNZbMRObTkvmsxnmhZ67WO9aba77//WtCDGKeZHPyrOT41jG3797m+OQOVktUYlE13Lp9l+1qJdgJMTF2XmbPyPGDApb3MMS+/ElXL3mVMUFAB4veDAYdcMon+mdMEJx00l3XieikruTBTMrEPM9xg2SqemOJpA5cGzKbYVRJ9CP4gHdB8gUULI+WYl0xDvI9clEF7ymM3ifB2zCwvlqxur5mu93+8L4t1fnNdpcStDxlJo+51kZcEOMBof/clwohdLvpuLi4pq4qaVAIHL91nF5bIvhiiImyLLGGLsXIdVvxMM+1TYwj6TbHXQtphqS1kSKWMGhdFLghEr1Ql/tWoa0hKyuCsnSdQpkRUyhiFgmFYhg7nPdkpcPlYo0dnCX6iM1hNOL5iTWoqsD1I+MwkucZo4dZc5cCzfZ6S/CRvC7ZeEnoyq2l23RcX25w48ByuWDceFabFefn5zSTCdmp5dbRMbmxvHj+nGdPn+OAZjEDvWfmgUETgmO1vuTWYkKYybNvjKUdHO0wir3xbsPFxRkhCOPLB9E7ZDY//H8ymVBWFdoYaTLK4kfW1T8MW+Z3gJ/6Af/+PvBzP+DfO+Cv/EGv+7mvEnc3KzxTk7jPHk+W5wQnZkLuugOnsEqED1kmRlvVtGanI8YUGKXxoxMjqTKj3xii93TbDfbOPXy0+Kh59vQJ6rkMII+Ob7FrO549f453nrbvmE6nzOdzyqZk027pu47ZpMYNAx9//Ihvf+t30VbzzjtfZjKp2e1ann36hBhH5ssl82lD17aUTcP1eoW2Gu89z84uyTLD7fu35UYbAkF5tFXsNh3b7RbnRvGLdgPToxnGajJrybKc7eUKX+Y8O3vOxx9+QF3XnN6+jc1znHJgDNpm6CynbXfYCG3n0Cpg9f5sp7KY+MKZachy2QaOPnBxdcl8KZ72WolCNKgoIjJjDqlVMUbwjuAds+WSV+YWNQwUUWAErQU3N0o8Q0wEYxR5kbE0E8oyZzltiNHR947zyw2PPv4e33/v24Bi0sy5ffcO0/mCP/PnfwUFGKsZuhancvrNCu/kgfQRSfXRN4yFfVcb04JgrEUjpmvWWAY0kTSPiFLYjBEbWkPGqt/SD6NoG3xg9J7oPe2uxY0OY0TZa1/C3t04clRUKCuL4Omdu2hmBK9o++eM0UGhcIWhyhs2mzW9G9hstzRNI1YQ1pJl5tCZ7Yvx/GTJAxROqQQB6t+3O9mDLUGTcgYCUemUV6KSYdlLA9jDIdTLfggMo2cYO1SMfPkLX8SrSFbl9L5logp0VFxcSQ6ozQyKyHa7I8aYvGsq6jxLQ21xwSyqEqO1QA4hstu2osAsJTUty0ryuUrhURGTG0xuUCajzErZGRkYQodzGqVLijwyrFvW1y1DP2JtwXJ+RBwCzWyCjZ48y9g5x/XVCu89XdszKWvyumBZNDx+/zGjG7n3+usMQ4vWGXjPOPRcnr9gUk9YXV4zdC1933P79ITvfe97vHL/LrPJjE+efMjHH33EerujaGaYwZEVsjjbKJYnJjMUVcFmfS2CJT/i/IiaNOQqo1SamZ+jo4eUydy7gd22xblAcJ6xD5xdXuCeCxnh0aOPaZqaH3X8WChUgw/4YURXOV3XkRthW9Z1hc2EPxtbT3CBdtOynB+za3fkec7oHNvtljEXVaH3njg66qoUC1qtefr0KbPZhNffEk+OECW9PnrP7PhYejolEIUymuVSKEvKCD52fHKLy4sLYgic3Drm/PyC1WrDZFpzdXXNO+98hY8//ojHnzymKjMWSzGnIor6FqXo+4GynnB0tOTF2XNUiuVTWnIu8eLw1zSNDF4y8afo4yBujOOI6TvqaYPBUmU506oiRhgGTww9ZVEwm80JIfLRRx+RZRnLpWClWZYT/XA456kJS/BFSkxKDJSuaylHsYPQxmBlHEJ0yc8iJntVxHlPacUrv/QKf+V/9Sbv/ea7/LP/8ncR7PeGU+2d5+VyorVKhTQZsNUlWmcHNWEIkagM5+fP+PZ3v0M3OE5PT7h9+w4nJ7e59/AtdHS4sWPsW/q2ZXCBrLHsfRJVYvl0XU9Uitl8llhFe2qmAhUFc08T1hADXkVGAljDfDYjxChCFOcYh4Gu2wCRqpqKHYNOVMC6xlpDiAoTA2b0DKsdXmVC25vW2FlFnuT+/a6VpiVBftZaYZh4T9fJud5bHMQkRT8+Psa7iKnyz+oEXq7USuGDF0qiTR+IewbSDx47K6XohwHvFdpYYQPFwKtvvk6+rAk2YkLEuMjFSpKIvHc4P6TFUih/RVkwJP8TFyPX19dcr64prChOvfPJZsDJM9KPqG4Qm2NrUwqZQuWaXbclKxS5KdhtZfhuCkNMxIDd1ZpPPn7MsBs4PlpycndBkRmBbaJnHHvGIbIZdonynBTFPjIQuNyuePzpJ0xnc7pxYLvZklUV2gWuzl5QFDm3Tm7hvefajRwfHQEi8huHkUePHvP8xXOcV0Qs51dXlMFz7/69pNWRc5llSiCVKDvk6+0GW5coN4A1jM4RRoffdEyrhnk9wWeB8aplXk+wmSQ0lWWFc4HRjQzDwGaz/ZF19ceiuBPB2pyhG+k2O15cr0V2PK1pigbvRqpFjcoMUSmqyZTjumY6W3J2/ZRt16GQQGEVIy4ExnFkOpvRb3p2XSfT/t2WerIUFWb0XF1fcHTvjpj5pAuvtWaxWOC8x1rLZDIRt7dxZHtxSVbkvPHqQ54+PePF5QVPnz7n/v17NE3N1eUlZdmw27b4sKUsUjCE1mzbHbYoGH3gervmxcUZqsrFD90L3lo3NX3b4Z2nmUwwuUY5RV2WrHcb3NBTlDWuG2kj+HbLG6+8weq6Z725ZBw6Fos5XSdFvG1b5vNweBB/oM1QoucZLCqqQ3c8jp4sL9GZwShLiBHHgLV2T6BDaYsxOUZ5Jq9MaU4GTl49ZXI0Q5uMSMAjDA8ZZPrEGdYQC7QyiOdLRIjCe08gWRSb6ZSj5ZLoM37v29/l8uyCse346P33xa8kzzg5PeHevXssbz/A2gzvxc9+6Aacd2KvqtIAMXXzMQrTJABE0SbEMOCiYSBiQyADeu94fnFOluUHi4GhF9GOYKLQNI3sGBRcXDylKApOT04hLyALLO+fEIJYLgSj8Qi91MVI50bqenLowF82guq6fcrOjZVvlmycq6a8GYrHlwbkL422xmFgvV2DmjJrAj4I7vtDH8FU/EPa/Whr6boeN3rKw1Yg0jNQTSuKiXTTm/WaYRhZLpeYtNPIioJ+HOg7McqaNhMx5vIhKX1zUWgrxbDZUYRAkwt916PZDcJM2XUdjVKMRtxgPY4xBrq2p64rHn/4IY8ef8JPvPNljpcLzs+fA5F79++yut6QTyvspMS0nrDbses68jyjyHJ2/Y4hKlpG7h4vGRFbb1GtRspJTaYM2hpMZrlz7x53bp/yyccfA7DetQzuGevNGhc8tsh5/dWH2CKXpic1PgGx87CZpZ5MuL66ZoieyWTCLjhCsjmosoJionH9QNeJ2drJ0ZLV9RXrywvG0XN6epflco6dVUIxPlnyj37th5fVH4virq0hGrn5sspyXCwOWG6wkbKuiFoxndSo+YJKNRg0RyenXHQX2BQVkyWsMmsaCB6VwabdMc2FnrTZbCjKGSFEjLEMo6yAeS4kPGPkIVwsFowJ98oTBnpyckJ/vSbGwGw+Y9Is2P3e73J1ec23vvUt3nnnHeq6YTaTwaNL6U2TyZSiLNjtnChUDdx7cB9Kgylsei9icbzZpA50GOj6jvnxXDh+xqC94WR+h7qseNo/JRIpJw0+4au/8Rv/gtPTW9y+fQeQh/3q6orT09sCvWS5KBXT8XL3JpiexSfhU1WWRDxZXojlb1kC0O1aMSxCgdLU0xk6z9BD5Hv/3Ud8+ugJ3Vnk7eOvYm2Biw4h/fXsLcm0EqaJ1hxgInkTAhYcZqSJpqeAV+4veXD35wVaykTtuLpesdkOPHv8ER+//z2MtRwdnfDK628ym805uiUhxru2xcfA2Pc3WHO8aXQ1ARUU0RmMMlg3oIpA7x0uBmbzOUYb4RaP46HztNaI22AIlHWNtZbFYilMkDFgYqAYArnWYCPK9ATAB7lHOz8KdxkZrgEvBXTITmA/VLPGYI1itVnTdwOPH33CT3/la3Id480Yeb8bUwreeO01qkoYGuznD8TPLAA3534/c4iUeYE2NdZmKJ3TTKf07Y5oLFkhjI2h71OX7xO1TxoJpcTKNgJFUTCbTomTJsEwIiISBojk6xZFjkoD6+vNmqEdcGNE1SVVPqVpaomqS1hSv5NoyhBEEzNEz9e++lXu3T5ls16jleLs7IJ2t6PtO+699RDrJvTjgM0sk+mELBNfqjA4+rbj6PYJZSPD0mYyQec55IEmLxiSn1BRFFS5zBb2O6kPP/yQ6WxKM2kwmRV/nLIUoaETa2ZxP9UMXq6j846r9TWbocNlhmo2YQwSs1fWFf31htVqxXQyJYbIbDpJ94KE9cznc2HYDQNEmM3mP7Ku/lgUd/EKzzhayITbWn1QEAYAJ6HWLl2UpplLwJSSEO3oIkM/oKyR5Bujsdri88Dp7SW6d9RljdV5CjnQlHVNXlZcXl5x78ED2t2OohI1oM0zmfwfhnOKup6QVxXtbktZaubHc+7eu8e3vvtdnj4/ZzJ7wnw6Z7PbcXp6AiBzgaJgtliijGW92ZEZS8w1Sis22x2ZzXEu4EZHZgzVckFQospzamC73TJZTLGNgjxS2AJbZNgQheYZIijDpK4py5Kr6yuOjk6pqhqN2NWe3nsIY8tmaG8w2sMePUL06Y/imbFarejHgemk4fhoSpGJenh0YlAVVbLW1YZIwWxmaZolYQ0U+zCdCBjxuTmoQZN0JjFbYlQoJYpRqbaeQ3iHUvLxGMisT7qlCDisjhSZwc4q5rOaosgIMXB5veV3v/kbbLcd0+mCV159ldPT29w5PUUpxXa7JS9KIjCOnhAQ/QOOsYgMoccZcRDUaLZXgrkbbbi4uJCGQ2maSlz9hmFgt93S9n1itoqCtTy9A9YwKIExjBeGTjAKr8EnT9lJXdOnhUKk7SnEOUTatjvAMkopok/MHK1RmabtW7QtKLL8kG97U+Qjbzx4wD4UJIxj0gEk8Zj6wQU+KtCZxZgCWxTcbSaMriO4gWgEXpTAlCj867zAajkPbRJeTY0lM5nAfWkOMY4DXoEuMjJtUEqCdNrtFms0WWYJpYiH1t2K3EUqJdTKtu/IjFg7+CDOimUtNuBf/6mvU3oJy7BW8fz5MzGJM4pmPuf49BS0YjJp2Gx34hyZdjtZLi6Vzjuwmp2XXYYfOuGdK03R1GgPVZYxmzSURUFTF1RlwWa9wWYaYy2TacN0uSAkR3qTCWVbpem21ppsUvHs4oLn1+cUVY3JRUw3aRq5N9ud2Ea7gTo63nzzC+A9RZ5CZQI8f/EpGMXJrTvUlYWX7JN/0PFjUdxBVv6h6w6ui3ue994utOt25DZjuZihjaXtOkKIaGPo+l6Csr2mKoST7nzEj57j5ZKzT59xeXUl7BBjKKuKcqhYLpdcX14xXy4E/1ZK3O20Th7S4usAkGc59+7fp9ttic5xvDzma1+bsjw5IQDL+ZIsk450Npvhg6T6ZEUlAhQMY9+J2kyBMooirzHRsF2vpTvLNKMfGPxA0UiVLJoS5x1D16GD4ag4pqpLfDdiSPahVqxLrbW0u5awCEwmUxbLJRcXl9x98Drh86HF6kbir3VIyn9DaTPe+fLbjN4zmRTMFrUwfXxkzHPy3BBxsrBCKioyANfcbO85oAQhOZPKIE0RyazGWCTvkhtKo1Ky0H/22AeDcJgCqgPAtBdzROoip65r7mDph5HLyys+eO9bfOt3f5vZbM7JyR1u3TqhqZrDAx68GIOhPEWMlES8sgyj59OrS2EtJXy+KEuRzuU50QvUlef5niifqG3ymhfn51RVxVFVg1E4Y9jLrrIQsT6SR82z7YaRvce9PAPCJMnouv5Gym4M07pit92hM8M7P/EORVAYL8k8L5f1w9pNsqWIENnbGZBMyn7AA7i/RkBQMTH1ObwHl/QDAk2J4MoUBT7KTqbvOjarNW70LBYLCbkxmn6UXajWyeclRlTyuQkJl9+f1+16QzNtOLp1i9043OQMILOoYRCmz+DE2nhW1iyyCkWg7YSaGmPkzu07LE6PmS+XXHXXrFZrnj9/QYyR6XRKZq2ks0VoZjNsnrHr2hQ8Is0fvSSIzRKkRLxx6dwLt7LMCN8/maRpq3Ex4p24SsYYyTKLI6KJXFxdUlQlr7z+Ks1sBkan+YMw5vLMUjcNnz57zptvfonN9vyQzHR9vaKqajrXc+f2Qy4vz5nPlj+ypv5YFPfgpVtUUfjGY+fZrVthPgDTiWK1OeeombPdBjbDGt864vErjCFSNhOK4BidkxXVWqq6wmpL3I0oFRn9QLtbMY538V7CnfO8YJcWCWMNk8mU0bm0sAhkEhJWKfiqeIlvVmuuVisG53jx7FOePH3OG69/gcvLc7JCcf/+HabTKYUt6JRGG01IN17VTGj7NfPpFO8jY9dRlgVay6WwmYJMUVQFOlP4UfJV8yynaWqJxOsc1kxx3Q6rDcv5lHv3H3B5dYEbA8Erbt+5Q900XK/Wh23/Z6CYz/xZOjsdwSrN22/cSWaNkb1bIhYoclJVlMUh9DK46np8cOlVbzBi6cL1QfAEYE2ktIlVq+LhXR2Ag736TqvUCSXKYzQ3HedLb/7G7ldEQ9H3mBhYTmumTcngRq6vNjz68F3ee/dbTGZLfuInvkJuC9kVoPEhpsD0SOsGzncbeh2p6pq+7xODRYb81hjqKiXujAPj6BhHx3a9JgbHndNT2TUGx6bvaLICG2UYuX/7TsHa9ThNik4T+huIQZX34u+999BXQJ+cBb1zdBFqUwIqaRleGqymbj3GPTMmBWib5MOvPnvlUTHZysj5U25AxR6lDYEgC19eCCsqirVHXgpU0I8jCnFMDTHQTBoRfq1W2NaQZzLHKvOSEJBCnZoo78X2Vit1M3i0OXmWScZxlqcAno6qKA9CwhhF4BdCQMVIl1gtq9U1WmsePnzI8dGC6dGMIYwJZ8958ODBYaEM3suOJ0SackIMYjG82+1o2w5jLbfmS3KlGfqOYddR5RnnZ1esNxt2ux1lNaEsaz7+6GPu3r9HbjO2Yy9aDhBvpXQ9gnNcrNdcXa8kv7XtcIDzgbqpqSqxX7leXcvOydpkOjaAErw+ywRaXjQNzbTmow+/Q7vtf2Rd/bEo7hBpmlo6m8yilJFV3SUFaVlRuwqnI2vfoqOm7wJdGry0bUe328g0PWVjjmEksxZd59TTCW1YE6IjBDAmZ7k8YTpdMJ/fOmDsIQZ2u44PPviAoihZLo+4vLzEe9kBRAXX11eMQ3uQCk+amtxaRjfSdh0vzi/pui3z2YJX7j/E9Y6TkxO2o1h7fvL8CVs3kM0KirzA6oyyrrA6E+9oPzItG3Qmw7fBQDtsWa/WVHnN1ASePjtjOvF89UtfxETDZvNcCtHQ07cDF2dnnJyccHR8jDaGvl+RvRRy/PlDOm4OhVxGGHv8+3MwDjIIC4AfOlAWP3RiKUDCytX+TyoN2dLH0kBzL0Q6XP3P8PLi4d/2cnkoEqM9BTJ8DlXYd5fejXS7Lu0UDHmRU9iM2d0G89Dgg6KeH3N6+zZXF9eQaTaMjCrQh5SSFB26zJmZOnHFw8GIbK8Y1ZmBIdJUU/quJx/lPl1dXbDdbrl3ekcsexXEwtIjOyPlpYAGpTBFSe0swQW6ZB2cZaLO9j5graWua4EjvMelhSLz0OrIYBW5MYxRoZ1CO4mEkx2ZwZoM76XTVfvzG1P2arw51+qwMMiC3LdblOpk8Kw0MdPYugDnGUZPO/T0o9gAxODFbdPagwOn1jYtVIF2J0GGAs9Ipx5DILP2cL9oZLbmjEMBm/WGeZHTDqMUtDKn77qDudowjoShJ7MZ27Gl7cTfp65rFm8uxTF2VjFmii6MeAKb9YY8L6Rrz+Q5G4ZBFlKtsJll2G4pioLJROwg8NKOrDcbCm05Pz/n7OwFm80Kayxd1wKKo+Mjbp2esgdIbDJ+i/Fmxxm8pxsGgWnzMqlwp6mIy/vP85xJVfPs4kmys7DJr0ZTVSVETV1P2LY7ssxydHSL3ab9oc80/JgU9xihLipMLluQoXfkyau4KismeUORS2yXKTOCU0S95cmLJ0QjDnR5kUkclc0pilK0LgS0ChijOLp1RFk1aKMZ+44BEWOcnZ3x6NFH3Do5Zr6Y8vTTT0ApHtx/QIye1fW1mP4slbAiQMRFWjIj5/Mpr7z2kA8/esxuu6PvO86CQwdF9cZbInjILc20wWvPsjriwVfusn3xjDEiC9XQsd22Yi8cYRJrsjFDa0Ndi+BhcjShriYQFHGSc7Y7593H7/OVN9+RIZXJqOoJda3o257zi3MevPIqWhs+/ugRD++e/PDzjwFliHEEZXBESGZfe5QkJpzFqKThjDF1teJrfcMn57D3r0tx3Nzudjgn6uEYDc4ruTaIJzfK/X56XiQN0rTwswmIxfC+Un2uA5WpYNohKCKeoe8ODJlC10QlSkClLVErgg646Gl9RAexf9Y6Q6ddyND2bNYb9rGAMYr6dne1ZrPdSsiy1rx4/gKrNXXVEFHsdi3HzUyi0QbPmBu8lsE4WuM6Gba3u5bNZkvXtVRlRVHk1HWVGhzBq2PyLTFZxhgixuQUAfKYoaISLDyLBC8YrA5iBZwVBbHd2/zKIFUrRZGJL0visia46KUCrxU2y2QImP7VRY/KLVYrquQn03cto3PM5ndlMKpSXKPNZS4TxO8mRumKJRBHzK/2C7Fk6eaJmhqhKJjfylBak1cSnOG8o55OMVr0K1liDZEGyUVdY6yiynKC81irGYNjcLDut5ydnzEOI8a0Yu5XVayuV0QfOD6+xWK+wBrNrdMTxl7okFppdJ5Ld01A+ZGx7Xn24jnddis5yaNju90wmYslgvNyz2gjWQoqcBDSeRR9L4tjNctYHi3Jipx210qhb4Ry7IeR+cktjL3CB7Epz8uGqp5R16NcnyZnGANFlaM+D7V+7vixKO5aKbTN8GE8QAh9GtJY7TB5ycX6BdPJhMJ7cl2wOJ5wPDviyfkn1JMGHQNucOzWrVjyNvKwqFxR1CWFySjqmm3X8vHHH/HKqw85Olqy2Vxzdb2jru/jRlElXl9ds5jP6YeB7W5Dnm7YdtcKJ7ksxf+5KGi7HdV0ytVqRZ4Zdjsjw99hZLNZMZnW9H2Lj47zqwuihuzTitzURDyeSD+OoBQmsxR1hp1lUuxUZD1scN5TFDLQarsWnWuOFse0buDp5XOUlWm9BIVXjOVAPwysrlcYY+mHnq7vMYcm/CbpKEbFar1luxsompy26/nnv/3b1HmBUjCdTmi7jrqZ4MaR5XTGvbt3UPQQFEEJC0OjCMpwverwPnJ8NMdmwmMHDtzzbduy2uwYhp6myLl/+/SzdfqlQ0KrA7vdwKMnj9HK88brr6Yw5KQuPXyySt4xHAq8rEGBgKLzsN1tOQky3FTJpCuPGW7ogYAfJKc1yxUX7Zpd16G0pm2FZbTf1u8phV3b4UaBFkLySi+rmrYf2GYd0yzn8vkVPjR4FVDGM1/OuN5c046d2DYbQ16UeO9l7jSkwPSEkyulDsZk1li+89H3efbpM/7oz/0sdVnQlBnBj0JfRHZhLmo++PBDZvM5RZaTaYF3UNC2HVV9Ywz38mxVKYEKhr5nvWvZ9T3zW0cSxBwDw+hY72QxEl+djO2upR8EMgopTEPSqcIB1hRI6+ZZ3zN4QpBdS1mUVHmO7zui0oRMLBRQQhEenSMaI8NhxOrBaJljOBMppzWNyfjW7/4ei9NbLJtbol41hjt3bqOVZNj2fU/fd5ycnBwcSIdBHBaNNkQXsVZ8b1xiMimFGKANHVVdYrXier1FWUNeFSxPjnF+ZPBe5gleLD8S74kY4cWLF7z77nsUdcGtk1vYPBMGjBXmVNt2QplWkDcVlXeM3pOXNdu2J8s0V1cvIMC27+F2Tte1bNf/NnTuIeLWrXRnIYgzXDtitYx13OgS7zcyxpqyjMzqCbPJhOe7jHHo6LY9V5dXEBVViq26iSxTWCN2o1ly89vttlR1RZkYMm3b0jQNTdPw+PFjzl+8IMtEVBWrhqHrGMeRvu/IM1FguhR0PQwtt46PWdmc5dERfduxurwUm1jvmE2mNMsZzXyGnUngcAguDWoUxmq0kZve5kbMkKyS7miEzWoL8ymTRrzSi1igrdA3vQ8ptEEecFFLKtqu59Gjjymrino+QedWshk/dygFMUhnrAIE57i8vMQeLYjeM5lUjGNP2ybPFdezN2067O9TnNw4DHz//Xdp25Zv/MwvMJ+W3ExBZdAaQ8AHmYPcROn9sCMQoqftB7773ffIM8Vrr74C5mXIBg4l/XNMP/mc9FEHV+dXOCeMoHEYSGloWJ2B8nSjo/UdYxQoJa9KYrKg3itHxZnSpMHaIIyOrmPoe6azGc47mrrGacWg4WK35fL8mhACJ7dnlLMKnVvRb4SA9p4suSrK99grbIUpM47ukGGrtebOwztgFaawaKslys/LYrWnzMQQ+P73P+BLX35HIhTzTNxUxd9Z9jmfh7bSf1LYAt1my9NnLyiKinm+wCWvnn3+p0+iO20k8MQmBbZznt2uZbfdMZ/PpStNrJn9zhQf9ub8B7aNVRpb5jgC7VZYXVVdi4BsK55Le1HibrulKMs00Jbnvbu8xkWPzjO8VmSI2IlCmDbd0OG8aB+mkxmZlkQmrWRIvNu2RBWFmTOMSd2taDdrGBzj0ENUXF+vuV6tuXf/HkdHR1SFvA/f9zjvRR1vhCq8Vwgvj4/4ylffIS8LTKYZhwGbqJVd34mhmnNURUGRWex0hi1yzp+vCc5TFKIBms/mgGG+mDF0Z0wm/xr83P9NHwoIbc/gHMMwkmV5itUacdFTHc8oygplkym+VYRM4bUi6EhQgTGOTKcTtEnWwMh2NssLfCZeHzphvT543n//fUIMOC+DzvV6TVmW4t9Qljz6+GPu371HkRdkxuCd8NS1UXRty7RpZDCrDbNaiv12IxhjXTecvzjj/Q8+5OLijNPjW9xRDzAT8YUYE/XQaIt3LuHICkKk3fWYXmYG282GoR1odxK1VeiS6XwpjJL9hJ5ElzOGTGs22y2ZtRSFwFPGWvJGwnfd+DL2fQNtaC2Tf6U1gUg/OIzOyGxOZnPqqiYEsR8wKilZ08B13yfLIC9iM8NE15Km9xKOntlMgjBQwifP9MEg7YcdkZBMzoT5oTAIsLzfDZAKfIJvPueZsmd7gKiPh6FFKVlItdF4JTuXXke8hrFSkGc4kAcx5sTgsYYEzRi8EwxecOX98FeTlyXDKErirm15+PAho1bcee0ByzsDl5eXHJ3MyCqDVZNkhzuglKb3PWVVYa05rFf7NKA9nLEvjvPFjKOjJUXKIO2DR2Mh+MNiBaR8UqEcRtJ5TrCirICazy6ssniNHrRxlHXN8vYRxTQnZEFcKb2mXfVJiCbJZSgj5l5GH7p1YyTMfhwceqqTG6o+YO4+xf/Z5CAZo4S56yxDA1mRJ7W4IY6jwDAvibz2oSYRgYJiVFxeXjOdzsi1oTEl2mjWuw1+HNFacb3aoQvJP3jx/AVucMxmM+q6RKPxQ6TI8sPw3OiRzFiYTrh+cc52u2Nzdc3583PxbU+7LR+FcOF9YG9Wp/cU6jR7Uloznc9kJ2YVysiOJMQgUYRlgbG5+FdpmVuYzNB1Pf1uhytL2m1L13aoFA707PkzlrMfDrXCj0lxjwpUkZMbA0rjO2ExlHmFKSx1VRGyKUWeoax4f+uoUSpiMITeC3sm+ZnkRY42e4Mohc0zvIcsK3A+cn52Rt/t2K7WaGsPA7OyEOXfndu3aSdTFguhSMaoGMaBvJC80KzM5SJEnXDDjBgFBlpvNozDQEQUdsYqTk9O2e12TKc1KMltJQSGfpDtX4Sh75kvZzTTUrDuIaJUTZw2HOtjCJG8yKUo7DoGoMgKqKEfeqFe+h5rTMJAhV9uMssYPuv4/flDG4OJ+WHQ6T24lMiujCXLS0YnEXvGCta37/xCCIfBkYpQFFmC1mJyZ0/b31GoZQmcRWsOD+gPO0LCVX2QpBzvgtgEQNpy3Hy10kHi19IDto/X239GCDKMkyCViNKKIXicgmjkJxhGx9gPLOdzrseNBLcbfehK+34gz0Qr4b3AhuM4UqfitXfzG8eRi8tLTm+dEGPAVBnHzSlFmQsk5kRcdXV5dRgcS0iNoapLYiSFQ8gAdF/Y27Y9/Pl0viTPctAGVSiiB+0jysuC60LAh4gO4iwZgiSQmcNi/JknkKhC2tWI7YMtCtrzF3TdiMlynPfsupZtKx4yWgvLSBtD20qy0DAMhCAYflXVYgncdodrUhQFfd8Dgv9vd93h588zSVoqy1LUwONIt90K26YsU4IWlEUpbBnvZTHVmjYEnNU8fXzGbLpEDxFrFItswouzM55fnXPZ7+gRcSFaQjXGcWQcLZNmQl1KaM/Yj4S9MZwx5GVG17VcX16y2mzonePk9m0J7JhOUUYcL1GkXNp9MxGIYX8/puds3+14gbi6XuIDq6qSppQbyFRrzWQ2ZbO6RnUiCuu6nhB7iJ4iLyXU+0ccPxbFXeb0EZfM8PNcVnClBBe1RpO3EasUaoi4cSAbcsxcsbtqUWNgUtX4IPS0nfcUuXgmB6PBqKQuyxgHqMsCP+5o6oqT07tcrM64vrzEjyNNVfHw/gPZKhU511fXKGVo+x6b5+RVBdphiwxcFMuAQXj2y+WMq+srmRXkGUUUu4GnL55jq5xFBOuEIeBcQEUlg2OtiZOCfF4QwohzIz460FHCOXJZrIoyw3qFcpEcTR5FCTmoABqqSUaRy2Jns4LRRaLVFGXOAXD/zJHY11rEK3IxpEBtdi3L44W4+KmIUUGuSeLdpuC7VL59uo6QFRnKJb50FG9sGYyGNPAUR0abSRcTVPxMKpDU65RSE+Xzh9HhvFDK3CjXVl5/z+hJDB21f42XmDjIMuODZ3DCCY+JllhEQxU8Nhi8Uqwur7m+uiRDs243+CBUta4PEAR2enL1aRK11QzJA79p6gMEGGMk1sL8ur6+5qMPP2J1vUYbzU/91NepJxXr7RaTZzSTBvyNvatSit1uJ1Cb0ux2bYJmxhTwYA8KSe8cISgypVJ8nmBSMcYDLr3rOkqV01QSqxhGh804QFX7a6bUDayllQgBCV5gH6uJGkJEZkJR1Mp7eCaEwHbTs1qvWa9WZDZnuVxS1uXB0mN/9H1PlgmbzXuPzaSgKnTKuDXiS4PoS4zSZAmaGp3HK5HyG3UzixC+fU5xtOB4cBQTof8uZjPatuX64opMG+4e3cLHARuhXiwYM9lJGC12A0EHcaa1GuWFTtoHGQDXixm3QmAMnsXxLY7nR9RNTZYWepeaGSEiiXo2ppN8oyVJO6VAUtg6cis7CRUCMfT0Y0iUUMvoehnYZ4btWu7FvcVDbsU2ujD/wy1//40fMUZi79Axii2oQFboKB4juTKMyqK6SPARHTRORcKgMIOm20goclPV2DzHGktlM87OLiTL0GhyYw+FQCtFU9fsNhs4CUybCZdnZ3g3ostCbs5KvDP0Yo7Wht1Wwi72EEqMMQXnGi4vrsgzy2I25f69uzx79pz1BrLCJh+Mmk+ffMp2u+PN197g9u1Teq+4Wl+Lm12W4SV5C2MVeV5hs0AfR8Y+cHlxAWokHAWMzhi6FqUNrnOMzTHBaca+R5eR1u9ATYhBONPWKopYkfnAy84ieyaD7Bylk45eskyrqmJ0I0UuSsCizA9+5fvE9YgFnadMT3FWDAaWx/cSnJKx3ibPn5RPKcwVMNYcIIjP95EvZyztt+vb7YAPGudGhn6gaW6sTg+iKWS2ghavGgnt2HdR4IPDuYEblaYS7/GgGJVY8GbTklJN6PwgEYJJpBSTLUPf95yfXSRhnU3Ck/xAkxQqozoUeaXg+OQYiNw+PcHmlsE7lJFdh03CF508jaT77SHCMNwwZaSwG6zNRBOhlIR6KE1wEZwsvDrEw7BYKy3WwApik+7Z/fwjHeqzvwEKZS3aWOo6543FRNDC4CiMOIJmuWQSbzcbYoyM/cDZ2ZnASKmQd11HnnYpWutDDqlcK59UqzL/ybIMo0WF60PAKoNVWiyxk8z+eDojL0rOLi5ZX66Y1jVHszlHmcCFfbdjt+24e3zKcjrjvXffZbfaSDCPzYjeMVxsyWpDM6/I+kATDLtdyg1Qimo+w9gM5aVpGN1A8AFtxChvOplQvf0W9AHlUqarNfhD0lW6BYO0PFEJzUA67u6wgOe5PEulLSmNZbNak+XCJrp4ccZksURngaHdyaA8ihlbWUpYTp2VKCzTyYzg/y3o3IV5FzBWBoLi+ibZi5XNqLSmKBv6bkBlCjdEtA+EsaeJsmVpty2VtVRWY7XGhIANlqNoCf2IcT1hbCFMmJQVuyGw3lzTtlvm8yWL2YLN+oLpdEogCGadW+qqwLvA0HfoJCp5cf4CqxXL5Qm7zZaphwu/4+jkmOPlEW4YIAoFM0xGTk9Pub6+Is8M1gSi75iUBTrWtKYFpdh2HfpFkDSWacnoAnHwPFufpw6yEBtdYyimNVoJy6Z3nu1mx/nFOaf1LWwFee0xo8XGDNd1+Kr5rI8LLz3iKuHJRh4ucSTcsd066Rytoa4FtnLOJ2FZ2vonhkxEJbpipCwnh2vaDYCKZEpjVEjfUyT8xhrSvvUz0z310u/7Ark4avja179I6Ic0zHzp59jPD6LkrUZVElJzsD/cOBJi5M6duwcGhwue9djjDewQgQ6lZpJNpcvSoqYcup6h63nx/AW77Q4iuNEx9AOlKmnmNVqrA7NlHEemTU1EuuV60vDKG69KEJxzaf3RZFbmJVFpXKINDsNAPZmk4rc9zCTEG8jQ9z3eG8qmwSnPoCIhE//x4CMMHu2FrvrzP/vTYginLIZkBxFvVMk/mKKkxBslUfmUTuBamq9IVsJI1wsbKwwjwXuOFoubgbMyjG6k68S+uigKyUNOC5/3440uwYtTqNA+Pb0fKbKSKrOgIOBp6pLr9TOKwXD29CljPzDRtxmyUfjfxrC9PqMpc6K75jvf/A4ffvCEr371y0QcWmtm8yUvzs6wWnP2/Bmz8ojghPY4ny8EGlp39H4DKKqyRvWOzWZD1/dstlesNzvm8yXz2Yy6qtEafN9zcuc2m27Hrh+ETaUUQUOMLtlItId7eRxFuLWPx9wmrcDV1Y6hHxhXa1qfUS2nuHbL5nJFu9kxm9Zk2rBbb7Dasl2vmE5mQvX9EcePRXFXAEPAuMB0OhGRgRsZ/EiuDN24RfVbqhCxQUnnp0C5kfHFUyazDK0jC3pUK/1psIoci95tKI0hDLC9OGfjBxhHXrk9JfgdZXgO3TW3pz2+zqnVEzK3DxMOIkjQJZPmGqOuOZo6Xq8i2u7I3EcUy47qVknrNIW9xtaRcRZR3BIqsR5Rugb2W+8L4ALlc46yHqaBwSmecoJzgWHVMlzvMJkGFTiuG6rZlCzX1EVDaEfiGAgmUk4n6MKi7UgxqXj66XOO9YQx88wrOD875+joGGsURkVG9uyUVELVobdNf0n0tFZ8OJ49e8ZkUgtsEiI6kobV0qbs485iFJVjDOLbLofAMVorMNKPy3dOfOqU5fr78F91gxnEKH4tt2+V3Dm+IyZkUYa+PxhkCgRl0xA2GWURcUFEtXU9Ze/d0g0DPaJ/NQgeuocwq7zAhcDV9RWffvopwzDSJ1pkMykPWGqWZWLlnDJn27ZNIQtiUOVjPPyE1kcKDM4ogQq9px96nJxaxnHk+uqapq4x2rBer6mq6mAFHKNg+Xthk7ai9tSA0zLEi37vTQ9lISwWiKjoBDIIe2naHgZ7mfGUqEYh4L1g6WQajAXtCCnBKgaxiM7zApXlybrZpPfn8Mk0yxqD0fshq9wTAislO4NRFgDve9GRxMD1xacczQtCqfBhJAQ4/2Rge/0p87mi1DCd57TbJ1xd9EymJdvNSFFlxCDfP9rIvVc1MfseXRcoCsvj598jL8ExoesNRXYJeoeqHCFrcF7Cr4kNblQMYUs/eEyhqXMY/Y6yUtSTFeO4xXNEpCHqnEePP0bbKHkCFFyt1lRFJQ2RFzvysqjIcot3AyFYjNWEGJH5aWBc74ghMJ+V9H4kRs/6+ordbksMgaIosUYMz/quwzlHlhX48d+Czl2FgOoDWo3UTYPTmixqUIZCK/ToUQmHNkHjfcChGbcbhrEVf2tl8UOLUvsJvKZUYlK06wb8Zicik2IO40CuIKqWuPO0W8/UXqLMhCLsiEES0Y32eG8xdkIerwBNHAK1VfRhpM5KKq2JDBjjMToQxxUxrgVr9BkRjTYDrpebOGKJ6ZmBHJvdwnpHHAVO0M7j3cgYIx4oB0vRKVTX4neW4BVLU9NuO5p6gh4CWkXunp4y+JFtv8ONgVW3whrxcFd0KCwHSOLwu5TIIg8yxNMwbRr+zC//MaLWFHnOdDoRx7y8QEHKcZRibUxAk+GCRyUhSlR7rEeKhUZsmEnCmbIwFIWIdCJ7vro/CDI+gxJEJRBD+oiKe2xZpjT6sDpFUCJHF661wbPH7xUhOTGqpN5UWgzLcjSWiFeJr++FIql0xtX1NZfrlQyRTWAynR3wbpDivtltKEPJthV3yKZpmM/ndEMPQ4/NrWy5gUHdFProA24cGLwDrRg6hx89mckYOnFbLIriMFzzXqyQi6JiGBzDsCPXgl1XVYkxGkdAVxkupoAUH9FRIAV8xASLDnq/tN7MKpCu3gvhCGsMlbay0EfZzXXjSDvI8HjXChc9zzOM1sJw226JQTpVpSQDQUGKkNPkuZVON3XtB2FWei/7nIDbt18jy0BpT54pQtRk9UhWN+Rqg/Yr2p3ALX03EkIHsWS3HdHWS0QfYOLIerclzzK6AXY7yBvFto30Y8PorgCBWSX2TvByHSxo6PtzBjdQp8FtXgaUBpsNiVyxxVLgiXS7gFZbrlYDjx6X7MZAmYsj5nazJsaRqoSHD06xeYYqKowqJTQeR54NKLWmmUGd92yee9ADamxQKWugLCthq+U5zgeBcjKEcvkjjj90cU8xe/8C+CTG+BeUUq8j+anHwG8A/4sY46CUKoC/AfwMEoz9H8YYP/xRrx20Jl+UKGU5Vz2FMVTKoqJmEg01GRExEIpKunICnJ2fUxYFFkWmZUjpveB0RmumzYTr7RbnIto5YghYo7hcrfn+7wSkDAzMm4o/8lNvY4uK44evY+2M50/eJbiWjByTNUAPGMwYhIYYYDYZKHJxShxHx0jOdngTkx4ioTBYvMnotyPD2FFOSpRSBJNRVxOiyqitIq6+ic0NzXFN17f0XYt3A7G2tOyI40BhDH6n8P2Ooe8Yq5aVuWLbDkQ6TGakk0dDCDSNJK6v1xumZfUZ+iOp61ZKY2WqhtJQZopX799mbwYW03Y82XAiC4QwU8o8Q5lI34+g/WHZiEpBlOtlrEosFyBCZtSNCAmdOv0fcpMe8Jf9yF3wZIXgmuFznX8kErxLzethW3L4atk23wxtBxUZ4ijj4Cg7wlFlPN+tcEiBzbIM78uDvD4vcogcPN0hDciCZxh6Ls7PD0PDbMzInQzFtNYH/FZbg7EVWeo2jcoY1ZBcIaFOEIbWWganzhGVOvjc1FUlmL/WZFpjBD9hb3xnosJEeV+J7sVeFpDleTof4TNnXZAxL7CREg/1Mdn5aKUxTqNsRjHLGZxnOplijGZ0A30y/BtGUVHKLEJmECYXTYA1FqMU3vk0w1rhhpHFbI7RiqKoefrsKXqakdeFFLYQOfv0U8L4lCp3ZBZGH8lMKUlGQVhGVXOLalKh4ojVBaP1oFusFt3MOF4S9s8koHVBli2ICMwXfMRmmm5n0DonqlKgYQNjN5DlVaLCFigcIeyArUAlgwcTUNHTTGtquyC3JYWZcPb8m0ymjjfeCmT2I3bXGdopRjL6LQxugGak2yq0LvH9jnZrCUvHxdkGHw1lOcUHydQ9Oj5is2l59uwFx8dzUp/xQ49/lc79fw18G5ilv/+fgP9LjPFvKqX+78B/AvyX6f+XMca3lFJ/NX3ef/ijXljFQKEDtckYdMRqsfwtUoc4IDgiyspEn4CuKvwWmqok+FYGZiiCdwxdL5xsY9JEXQQ/gUg79oTaUuqbbalt4NJOMEpTeFkozrBoNaE2c5nQG40KCq8lLDsQ+LQdMT2UhcVYxTgqxhTXRhTObwxQ2opoFR8++oRoA9XMovKAvoLZZMnF9ozWjPgQKMYNMQOVK3IlMvl+gDiIVL4fPJnRBA2X11fMZguOl0e8OHvC2cU5RhsWiwXz2QStFNeXK0Y3kmkjzAqlPiNgOYA0L3fL+8KYOt8bbnTq9xNuO3Qt8cAvD8QEmUi6EVR1jTWR3dYlKuZeQ7nvG6UzVfth6OeOiARqx2Ag+qR2TeCOUp8t7FEYCU0pJd/Hm4i6IUrB2uPGVlsyY8mVZlQaHQPeBzJriMoyvPTaQs0TSCQECTOPBJqpwFXDMIj/fjey3W6p6xpja4pcOuoiL2VXECMqahG6JMOsoR9EnBf5DL107AfaRDncOxE20yku0SW32y0uz5iXNWqQj8uZFb/MqMBWDf2ugz1sFsWrSSuNKew+IuUzs5eYvvduu+Fiu0FlmtPTE2xmKJIQKvhI225RZQ1e2FpsO5rZlOlkyq7rUVpRZzlFnlFWJR9+8BEnt+7QWMvzF095+OBVNmHFl778RVw70LYrtC149MEHfOVrb+OHLe04Mow7zi+uKJoaUzR4gzx/0XAxKI4WU/rdgDIzhiFSZRnO55IBXC+IxkJQjGqgD+BjQVSanauYlAtcvGIMGZNa+OK66olB4cYBF3bsujVdZ6kKQ1nNsNmx7Pa9w9iIVhN8eMYQhM2yOLrL8u6XqIuSq/Mrwgc3aV8BxTA4Spvh3UZyYXFYYxi9AuUZhsDQajargY+ebPnCl75MXlhWw44iy9i1O1bbDb/zu9/mi196i7e/eO9HldU/XHFXSj0A/j3g/wj8b5Q83X8K+J+lT/nrwP8BKe5/Mf0Z4P8N/BdKKRVf5qf9gMMT2IWADVK4cmPJD3CgAh/k+VeiohOrDlF7mSidTUyuec6NKKPouw4dpFv1GnbtDp/PWbyxRNm9Vaq47j3fPiKoyHn/jCo/Zb1+TK2PmGYli5mmySqGoacbAheXA7tdK6k1SnE0Vdw6LmXY1I4ED+JZDsFHNruRvK549c03efbsCRdPz1FNoF7kVDGy8wNUmtzkaMzBDZMoJlJxGPHDgKGksDkxDoSoKYoJbTswDhesVitiiBwdH3FyfAub5Wk4KlhxnufEUVzkPnMhYqQffOoOVOoQHaMPeC9maiHBAs455rOZ8OhFbZ/gDo1RitW247vf/4DRO954/S3enDRYrQ4DWAi0XU8/OKwR2Ecgmh98a4jjYaI8psXF7OcFqSN9efhqVKRM9pbKeIGQInQ6ivMjCpuQCqWgiIqpEqdLlwbKn2wlgDr6iNGGrpdA7M1mI1j3tUoe5BmTyTRBPMIwgqQZ0Bo/joQgQhSTCRS0a1u8c+RK8ga0zbBTCQHX6FSAJcpPK3GkzK108SaJhmwSrKEiLtP0RggESu2Hy+CJbN0ONzqiC9RZhvYR7/csos8xlD632AeEdmyVxXiI2V4sFFHOsVtvuLU8FrNO7wnjiG+32KyisGLK1Q8aXEGeBXQceHDnLouq4tH77/POO18Ga/nSl77M97/7LqrRGKc4PTnheHEXskjbixXDeZHOmZlhM483ntEFvLJkzZS+X+Pw5CanD4Ztv2PX7chmx6AUYxiJRQNljVGW9nJFNi3ZqQC6AQyj6wm+Y58vsPYZMSsxpSjBvTEM1tIOHUrLjl97A1GxiQpbzHBuR2bEk78oS4y58UPqugqjI9oG1huPVxkuWPp+i2k112vJjMUZnIPdLvD8xTn3Xtnwx3/xFxLRYcR7x9XVNcvTO8yXE+7cn/6okvqH7tz/r8D/Dti/2jFwFWPcI/qPgfvpz/eBR+mBc0qp6/T5Zy+/oFLqPwX+U4Ayt0x2nrIqZYDpYQwOR8Bo8MFjCaggdDwTIm7oGWJDraFAQwo23g1jGgAKrumshEHECYylYbteQR0wSjwg9P5JBzFi8gH8iI4WrWZEZegGT1HCEODyumOzG3AOdAoR+GS3YTv0nJ7OudqtCM7jBkcI0mmVRUVvFPm05vTV1ygmCy4+fcr68TWT1z2ZqQRKIk3bk9IvRkWInhCFn/yd77zL7nrgZ3/mHQyaXbumqSesr9c8f/acvLS8+fpr9F3L1cUlmRWO9Gq7Y1k3lJn5nOxcfu62dwQUVivGGPnu99/n/OJCutlCghdsltG3O776zle4VdlDpz3gsQq0inTjyPfee5/Rjdy5/SoHO8KDIhYJX/YRF8UGuChEdfqDynsEurHn6sU13kfKzDCZ1EybhoOWaf9LgfOR3TgcIAqldRquCo+/R9TMIWkI1sql3UOgH0ec83Tekdkck+uDxa73AnEFsZtM3u2aru1omgYfReCWFXOIUGjBnNtRgq9tZtNgNJOmxUpQg1XQbdb0fc/RfImOBm8gzwxDP6IVGDSZzSGTbNgYo7CBFBR5iQsebyxZBFSyYnaBT977mMuzFYvZglfv3Ukyh8QvTlEq6qZvZ5+la40mzyMTJfetRtGNLT0OYiREx86tGWMLSWzUt1uaumJo1/ShTYt+xthuWA2fsm13/N1//Lc5OZlhTM4/+c2/y7YbiN9uUd3A8SdrNg8WEB0GyOsJ2ilm9YT1ZM3FasMrt94gK/ShyC3yI8o6o30xkFNTZSUxeja+JTjZCQYPgYALihgKPOIZ4z2SqYBJO+xBzk1i6AxDJ7CYaVBWdphD1KlaZkS1pw0EvC0pm4Zdrwjray4v/yVX5Smj35DnDu8Nt4+/gTGa9z/6Ll0G5bQkUyNFfYqvPKa8JpoZzfQIW1p+4qs/y0/+nOXNN7/Aa6+9JaiBiiIk225xbq+urfgv/s9/4wc8OXL8gcVdKfUXgOcxxt9QSv3yH/T5f9gjxvhfAf8VwGxax1WmWPsBokbpSIaiCpDZnKqu8f0avHSR3nmGEOljTmMkIk4ZGbtJWo5hGDxlYcXju8kYlxmVzbhzdIcX2x0gnXtIlDkNJE09XkVMVmFNBQiO6YP8+t577/H99x9hTMad2/f48MMP6fuOn/35r1BVhsm0YX29JeLIqwZtDc1sSaznPBsc6/OWEKawsOyeRh69+zG2iBgbyGwmSs6kZBMerZipqRDIRk9oO549fi4rfboRtbG88drr5KVlu9nQt+J5EvOCzWZHUTTE/Q96c12l4CqJOWyaKWHs6bc9i6MjqqamKms2qzVRKWwp/HptLYJop/cozYnwem+ILoLpqpvisfcjiUAzqclzS3T74nqzwH7uHiESGd3I9773PifHR9w+vUXTNL/vc+R7pl0eJNMxl6YEil3bEyN0Rz15FSQK0XuxiU+7PpNZaiN0XD+GAwMjeGF/iJhG6HWZtejEW67KicA1An2j0VgP01ixWq0YesfgWrKmZBh62tFxtJijUbx4/wmfPH7CL/3CHyHPLavNGp1lYntRCLf/ZDJl6Ee+/+hjSMNIrS3m9JRqUqJtFF1ISJ4/zjGuOnabkeVU34xP441f/ufnHFppGUIH8czZbFuMthibMW8meC3P3tD3HM1nZLms3UGBzSLBeUyuMErjowxo92ibV5HRRdwY8WPP+cUZIYPvfbSi2g3c/60rvqlPObo/J8QdL15ckkUoTUNdTBmaQlKfjCEzOVopFtMjjNKsnvUs5kcc3zrGO8e9ecd6dcVme8XiaMHVesWLdk1uC6yKGG0PXHTSnbyHH/d3ruD5OYQMVEzJY2mSc2Bzyd93250o1qPi+fkz7JizXM4JsSNGz2JxJEHqxqCMJXhHRsnbb73JpCp4drXjiw8m3L5zn+OjI6aTOUUxQZtMPN6vLtlsNuy2bTIQLJjP57gxyiL2I44/TOf+S8D/SCn1K0CJYO7/N2ChlLKpe38AfJI+/xPgIfBYKWWBOTJY/aFHDAG9G6iUguBlAEUkA5pqyuL0VT49OyMMjhAE+/zu4zMer57w6rzkK6/eTiwOhc0rPBanPC0K0zTERY03gV3nCMM1VV5gcoVKhvoqKozWIjfXRkQ3scEqQ/A9NmuIBEIYqWvDT379bW6d3GKxmPP227e4ur6mqgr6TgQozjuUBpU3VIsTdF5zMYx86/tPCN2ArS1HdYM5fcD96iFWbendhiyX4N6oIsYoMmvou57MZBRlBvkRrwyBhw/u4gmgNf/tf/MP2G46/uSf/kXmx3OsNmKlazNZLAbHxdmWoqiJ8fO8WOnfghfhWEyePDbLiEQWyzm73RbnPVoZumFMIQk3r6AAnZiUhJsBZwhOhqhpodq7fe75l0pxIE3KP6uXXvEwmoW4V6tGTCYhynsO+b4rP9SreOOhrfbfC6H34YW4HfYDTaUo0WilWA0DQ9uJ0nMM2LIkLzJyWxLCyGoYiNFhshyr5TUyK0HLVVViMo2JERMRdaOTYaWOEdYt69WGbTtwebXi/sPb4ANLW0swxc7BIE23juC6Ed17hmFN1dRkmYiHvO9x2566KcEolDZo78mDwjr5uWMQSp+OjiIrmVQGjU1IvFAUbzJXbxZoOXUxWe/KzvHi4pzrqyvefustThb30Nby7OlT3KD54z/3p8nznIuzc1bXG3bZlvt3XmFxcsJqu6aoCoIK9H3H9eqcV45zfFAM3Zqz3VOWsxOCVYx+RLWXtEc1i7XnonRcr55z5Tq0g2W9ZDWsCFbz5MUHZHmG1paqqCnLijIv6fwI2hKizNcm9Zyhg1df+SLeDZj4nOfZmocn76AU3Dt6k4DHq4Fh7OhdyzB2hCB+NyF6qiKjUXMyNAPpflcRjRGh9Z51Fr1YjYwBkymm85LVVUs+GTm6VePsAmUDn55fU+QF9x88oGxK7p7cYVlo8sLx1pvfQOtMCn/U7DaesxfP6FoZ2OdFxnQy4/btu1RVRZ58dfYpdT/q+AOLe4zxPwP+s/QA/jLwv40x/s+VUv8v4C8jjJn/CPhb6Uv+dvr7P00f/3t/EN6uQyTfduhi3xVGXBQ73KA1qsiJ2qCKkuA0zsPk1j2+cG/OojJsSot4kitUIfF4moBXwsRhAL8b2LUDO3fOz379TZqqwblAl+xw3SjWsIJTIit9aYlKOMh7Qckbb7yWlJ/iYzOd1jRNRdd1kqm5a1GIOdlFHwgbjVYdUYHpAuuQ88r0lNGNfPuTK3a3Jvzs7RlN3ohgpzlGG43zQk9UlQIdKW3O8VsPmNtChF46stpcs7pYEYBv/sb7HB/N+eLbb/DKw1OaZkKWWYZhZHXx4UsX9DP/S9f4xsyJCNvNlrzI2O52kh6T50zmOUPKsdxP3w5JP4kj/dnXlI76YBCQmnNhlQwHa4kfcMfxciP/+a5+r+R8+XsppYlBE0O4GdCyZ8nIIjEOI9erNa88fFXCMLRhYUvGOHJ1tSO2HQHP9cU1s2bCdDpleTph1ff81j/7F9y6fSTD0jxjfnIsW+UoBl3F4IV6CLLgpHUs6sS0DwE/OtZXG7azCVVZoKJmzxpVSh+KbozQ9T02DVi1T3MGFdFGApq1UilblVTUI8SX2S8KYzSTZopRsti//Aiql37/7CE7kePjY46Ob0FSYccgSuGhH9isNwQXyKqM7XrL2bMziJHjo1vsWs93fu9D/tgf+6MoYDNu+Bf/8nf4c3/+zzNdzHjy8XtcP7ni3tEbLE9vM/qB6/lzvhe/z52H95g3GcTAIgw8eu99iknJq/dnbMYBk2m82hLCSDdesd69wMdAMXO0/ozx8hqNoXMFedlw+849Hj36EGJk7B2Zznny6ROKIuPk9IQQvSRBmX2/ITYCPgT8LQdesRnO6NxOqMmhw4cRF8fENXLy3Lge73uqJlKVGfUMDD11M+dLX3qHo1tH7DYli/mCB/caiizD6ozd5pq2a1G6p+s3DH0POsPmIvo6OZlRluVnLCf2ebp7wdwfUFb/B/Hc//fA31RK/efAbwF/Lf37XwP+a6XUe8AF8Ff/oBeq51O+8qd+CZRGKSPwlyJlpGaM7Ji+8ZC+H3jxyTM23YaYW7zvudhqhquO4BwhCj89AqPzEANu7GWYiOby6ppbiyWvv3qfNpQM3tN1wqZpmoY807hNh7YSiF1UOZvNGrHCFpe+cRzx40BwCm0gOM8wujSsSqwIpVAYjB8YN8948ewTFsenNKcLNIpVe027WlGOK7qLM9rbr1FqGajlEYgS0LxnZ1RFxrwsyZWiySzWygma54b/5V/+H/P+o6d89/sfcXV9za//xm/y27+b8fprr/OVL36B6aTm5HhJpjXrVc9m21E1lSx/USWfG8fZ2TlNXaBQrNfXtOc9IUZePH9BlmWcX56zXm+4e/sOXhlMhH70jMFQGIVFJO9a7Z1m4GYl0anbAT86zp5d0EwqppOafF4nIk7qJ9OWN+7Nu4MYtOkoOyuQDld8y28ghhD2xXG/pKiX6pei7zyr640IbUJEkRw1kVQl1weyzNI0E4pENdwHh6MyrCpQHuosR7Ud4yic52qqxKYXXoKl9rsN2TQQwGpFbnJcH9C5QoUorK8IJip0COgYILFp8qpJqs5k66ugKBtsLjMkyeyUYex++C5rQJTPjwEt/rqE4OXPMcUVIu2PsJEgktKxlE87JaFuGhREx+nRHJsXjJsVpYLjaU1Z5UzKgktridFgcstyMmc5W1BXDSio6oaf+4Wf5+T2KVVdcf5cLHyrquLk1i127Q4d4IOPHqGamYjBosbvOt773nOar93mldN7NEqug97b6O4l/wlmMkbjvMMNydI6Gt57/xnOj1TTire+8DohOG6fnhCiCNpQskhKJkBAK8gSXdPYGuUD07rGR087dPR9nxq4HqUhywzogH3jlKwwVI1mUk+Y1DPUULFczKnymtF73t08ocw0MSh2u5FhbBNZoMK1HWVRMZ9OybKSzGYHH6F9Eb9xcZVjr9n411rcY4z/APgH6c/vAz/3Az6nA/7Kv8rrOg+XO8tqdUlZFEznx9gsSa+DWOOWTUnVaH739x7x27/9e+S5oW4aqmrO9fUZ3/iZnxbaI9BMplxeXvPpJ4/ZrK75k3/yl3nwyhv83X/wD7k8e8H8+Ijl8habtqXs+5RTGZN3d3awhC2KIjndBfYb/hglNktrg0++4F0/kBdCmdNaH6TW508ek2Ulk37Fx7/5Lb74zlc5ycVZMtaR733yiHW7Jfvya5hMVug8E/nzMDiyLCPPCiodmFhNrvRByBOjoyktP/eT7zBtGr7//nucnV9QlBWRCe9+733e/fZ3+OKbr5JNak6WcmNfr9Ysbx2JD0i6YaZNlXw8PApJ6/HOY61l8foblOWe561ZzpcyeCbKcDRErDJgSfaycODV8fv7w8V8Ql0VidYnNhOCY94ERe+b9Ru4JVEFlToMUD9/WGtTes3+Sz6rYl2vt+KqF+JhARH7YbGMNUborpUpKQqxfk31A2vFIApgc72iLjP8OGCyAjW5wftVTBBjgoMO7zVx8yV9qWM2rW5+sMhLVNIg4iBjJIA5F+O6xd63O4qXkbVZUobadI7DgUm63z/dPlkSKLAWrE2LTFoB9u/sRj3AS+cknW+koFgrkAHa8urrb5JZOU95kfOVr36V41t3+Ke//v9hGHrefPtV7pzeJi8LMZgjcvvOiQjUVCTLM/KyYjZfsJjPmEwnHC+X3Lt3V4b21hKiIkTFG2+8SVUVPH78iMvVFUqrg49LTAqH/VA4ixGrc7ZdS1lW9D2sd2uMDdw6WnD/wZS+6xiT8VyWiWZBIjkj2sgORaHT8x0xJjKMvcxtYqBQhrJs8IU0I5nN0BruvH4PhdBjldFkpsBMLJmt6AOMY+BoOQci663HGEueV+S5xdhC9A9aH7pyuRZ7VtMNS2n/6+XC/m+yc//XdizmS/7Cn/2L/Po//1Wm84o33/ipm6c73XTjOOJc4Nf+4T9GIZmM7W5gs32GH3t+93e+RZHfFnxRd7Rtz8XVU167d8zpoqHQjo8+eJ/LiwtePH3EtC5Q44ByfRL4WMDiqkhW5IllJ9muzo2E4Ag+kmU5mS1QShPiyOgjhbbkRUlZysUoS8HFJKyg5snTp2Air7/6UHIhrSXEwN17x+zaVhgpOkoAR4y4xLLpug5jNL22jGOkzhS11ojj+D6jVPPOF9/g+PSv8s3vfpdv/s63ePpc+O6v3bvDg8WMZxeX/Pp7H3P34UP+/b/0P+XpJ5/QlHBx/pzgHUVuKIoK5z2bTcsX33rjQMmr6/ozXQMAMbFbAglnl8mZVjCZTPHOp6ScG754aizJjKKapAVO0IbEAuHw6+XyrY1hMp/y6huvkBcl2mafweoPb+ll2OGlh0T+kIKmlWYcHUSPT2In9nh+ksajNNbYw8BNKYl6lIxTRXQ3OgFzyCNVifp6832V0gcL170lbFXVlIUM3+Q03lg4kIrpOIpCta5rcmPZrtZweidFEgqbSgy69jubAIbPQC9KKSZN/bmZhqUoLFobcSJM5r/7EhkjqKiZTiaYrACtuX16h6PjY2xRgLayc0o/r1KaooRqs2EYBc7Q1lA1lXTRfsRHT3CS7ISSBei1199mvlgSYnJKtBmNzQ/FSilDiHKuYvQcLebURjrsjz78gPnxESarCDGCTqEmyuKHHqMM26tLzq5GpospH77/AXX1OkUmq1vba4wSh748l2d4T2XtxhHvPHtqNCiitSitqfISrWSITkCcO0NIpm95uhYBrTOiEpXwukvZBcYyWy7QKXA8Sx05CmL0hJieAWXSJZXZCJ6UYmUP11Qp0aTpqAjhB7U4nz1+LIp722343e/+Ex4/eZ9Tf4svvtWTZTk+BGJM8nQdUMozjjveeeeLfPLkCVlW0487gjNMJyfcXvxxQhR/j3P1nBfn3+anfvLrfOnN1/j07EqYJVrRXl0yyUYyM5Jbh2LNGBRDiGzWSvi6ZUkzqTFGJ9OmAbRKbIwgviKjBAzkJsMYKy6KWuTWMQZsJiHNd+7c4datU0mqGUWshBa1Y5ZL/qJ34t+hUXTDgDUZRVFwdXVNWZZMpzN2DvoIdWYodLjBnqNnWuX8wje+xh/52Z/hk0fP+I3f/A2sivyTv/9r3H7wCs2kZLaY0Y0dL14857c+fI9bJwuqIqeZ1LxcbcU3KxBj2s5z0xEeEFulxMTLR7JMzMVuZzV/5s/8O1hjKIucsswJSYQjX7lvL5MXikowymEN/2wnEqMk/DRNw3I2STf0DehzMzSV96Nf2r7eFAv5u01RhHnK32zbFusc2ipikK393qkyy7I0gJXv09Qyv7BWFtQs14ToJOE+qhusPS1mKuExSsnHjNbovODWrYaytDS1qJT3P+04DGmHIF2xcwNVnVFXBV/+0tuSZOQN9+4sQUWMTrlJClQyX/vsDCKdk8Ml02S55fbtuzQp0F0C6EeGocf7yNBIcEhVleRFSVYUnJzcpZ7OQGn8S98g7GcbMTKZTvj6T/4Mi+WS69UZzgkLCaUlOQmdHDMNb7z5Nlq4hcIKS1iWSgYTsmOLhP2YRdgOmEygqTuzhrrO0UVO3/eUec733n2X05NTHn/wiNW25ZX7d/iXH36Ln//FX+Dy+RnTn/4yk6pB1RmfPH3Mrtswmdyi67aMbiQgHXxQspMVyb8U8sxaVJqlDP3A5eWGrutEYEaUGtE0BztfqzW5lsS3vbp4v7tQIRx2pmafWRyCsItCQHmPtcLMCzEIBJVo0fv/RyJxdJCLl9bva7o+d/xYFHdUJGSO177wGiF4fv2b/4RnHz3BZqDnGXF0+AjDZceTJx+jC8PgBormhLo+JrOyjb0I3yIqGfx88uI9QhjSiRl4tn3M13/hDaJVrGcd//iT38SrfYAwKG2oaCiGO1gnmL02kaIo0FpYK5v1WnymDVgrA8d210p32UwYujYNPmQrpZOPfPDiJy5xaTphn3sqVjJ3QuNGiXQzRjO4jn5saaoJPnrOL18wm8ypipLr0WFQlJkCrbABjFJYDEWe89brr/Dw3gkvzs74vekdLi4vub0suLWYsW1HijLj6vKcvLR869uPuXv7Lse3TsXOVVsMhltNwzf/xe8wf6uiWixRWoQ4mc2SZa8Ed/S9eNnn1lIrQyCijU4dpnTBR8enN1+rFV23kzzLoTsoMEnqWdQNO0Yp2YabBDuYRHcNcb8tv4F/Qvqcm6/dd8ew2fZoa6mbGUZL5zT6yNj21E2eeOsqbY+lGHXjDbNIx0gYU/ixSngreSpAIQWDv1RQX8JDj4+WLBdLmSdpI4PkZEtMDCzmM4ahJ7MGhaQAhdT5G6NRJuWzqkh2eFplTLwv3jcJVPJLK83y6IgsK8hyaRLyvGAymdz4ikfE9THcdO43WJr8LMbKQhOix4fIMEah+HmFiwOZlXDqN978EmhHJNA0M7TOU1C0vL6OEgby+WIk2oR9p4zYTKeg69EPGKNYr9ZcXVwwa2r+xfPHNJuG+9WCf/xr/4xf+Qu/wje/8x5fVhO23nO+2rI8cvTDCIjJ1tFySZlZgg/cOVkSg+dkXlOXUfJigwRneJVjbU6Mmn4Y2PU7ycjtO2FIOc92s8F7sTSISHjMOIwSwhLA4Qh9e7Bwjn6UhULl6R5VqUuXa2DMntaqD3kAxhiCC8TsBnbZF3iTfLMEsQmHZKofdvxYFPf1bs2v/fY/OBQ8jca92KFnJWa0eB3QRObOonCMoSevSr769Z/FVguRhycrTW0MV+eXPPnkAxQwBs+7zz/mWf+C5cMpIE6Fo3eC3MnuDhsUVk3E+jXdbsPQM5lM8F7sOoXlIR3GOA6MgxghlcmDZBwHUc2mgmWCUCyLMqfvBdffUwS1tQma3isGBedH7b0MBcNebVZkNqOpGvq+xzkvO4SsYN2PjKNnahWFyTEaUW6GgFGSZH9lFa9/5Ssc5ZHvfPSC3/z2c77y5hFFaem6gcXRCU9fnDM/vsM/+8f/X3753/mjdLuePLN8/O77/OTXvsorb3/xQGnc+7nvfWpucMBUeNX+RhQTqsOW/yWq4zQuIEZhIYyjBHh3HevNijwfD51TjDrd+OKEpwgH7OZl7keEwzB7/972BS8Cm7bFxwja0LUt19dXMlRNnf5iPpEOLm2XtVJstjuW8waI+NHR+UhTFWgL3jsp8Eoen7Af4HKoi4edg7V7YwB1WMQOwRrAgwf3ePjwwaFr11qKvNEZeVGIZ7cPwJBeWyXdIyidKLzWkmU5eZZTliVFWXJy6+QzD//+3BwG/iLsSJoKnYaTHKLwUIph6Lk6f44PA3luGMYMbRxhjPRhS2amlJnHhRxMj1KVBMuQC3SXDPiefvqYTx8/4ms//Y1U9CM+egnnGOR6d13HRx9+yN07d7i+OOdX/9Gv8id++Y/x+PEjvvkvv8m/+6f/FN//9AXzSc/kVsnVdctu57i62gCWrh3AGAbvRZdhlCyGMRDwdG4khAGjHE3eUGqhEoPF1DUBjfeR7ehwUTx5FHIPB+fIswzViO34ZtiCUhgt2g2hmAJezNM0e7sLJ7OamCBArKRM+XggjCh1g63vcXZIM6RkN/Ey1i5zKg5f86OOH4vijlKoKPhl1NA93+IuHeq1L/EwbFmNzzmuzyj0iMl6lC1QKsNkQhW6OD/n+uo5R8e3aWZLUSYCUQUen31Cv5gzpiJqEeolQR59jWznrbLEUMoWOk2VxnFEKc0w7Gi7HRHZLjl34zVirTAsvA8HD5KyLNOPlVKNNht5TSPFw/sgmRIvJQfFIBJ5m+lD97qnyDk/stquOJ4LBe/s/IymrphNZ4whcjGMFMYwzTR5lO4/L3OmzYRFkVNmmrffesjO59yNmjL3BN/j/YTnz59jjIQU182Ei4s1H3zwfe7+qT/KL/7Kr6AnC7bbjkmKCLy5ZDehFDJsTIOfkGCCtKUmURdfPuSGj+jMkGWlWPESOQm3D8VHay2pNTESwsgwjvRtR9e19GOPC6RO16KUGHft2RMHWEJJAdwPRiFwcXlJ2dQM/UCRtsknJ/NkbKZwfiREz+nxAoXsFl59eBtjDZkVpeBme4XRhrKoKbL8UKj3cqF9diZ7uAkRGe1xU60l/tCanMViycnJKTbLMUbxq7/692n7jjv3X+GN19/Au4G+H1ivtyluMEoiUpYfLIH3iUhKKYy2jOPAMHTJnvemoO+1Bofz+xIqv1+M9jF+PgZU2mlanUvurQGlLVE5lA/E4HE6JB2Ex7uWIisQK6CA1rI4eT+SZ4pxbNlcd1xeXnHr5Jir60v+zt/5O/yJP/4nUCj+9t/6W/y5P/tnKQvLk08+YbOSdKeuk5+lON/grlp25YQQPUWZEfDk1ki6WgzcvX3CV4Y3uX96yn/wF/89pmWOUR5jI4tipO9bcr0gIq6iERijZ3SRcQyJWKBZzBcYY2i3ElKdZxnRhxSt6BJ0JNbFzmmsydKZlHtRGX049/vuPATHPsBEpbD1l8//gY6s+Eyh33/8ZdbMPnT8Rx0/HsU9rUwxKkqT8+DOQx43gd8LgdtRMSWgu2c4PNHK4A4VUUaKS5Zn1PWcLCuIQTzYldEYY9n2G45CKQ+X1sJ9P2xBFSp5XFe6gTGlz6NSMIUUosvLK6FAKek4uq4/XCSJG9OMY/KR32OtWra0cgNIuDYqMvQuDYKkaz9MwhObQRpTJelBXmhaRhuUQXixpaKuK4Zh4Pr6islkgs0zeufp24HaKiZ5RgaUeUlRZvixQ0VPZgyzwrLaDvziL3yD9dYRhpbzqxVuHLm8PGMcHjA/mvFi2/Kdsxf88++8y92jJX/8j/0c282W11579fCe951DTJaPEuacFj2t0fkNTPHyuRHWy42T4R4vx3z2hldK4CajCzJbiGVz+n4xYZMKePH8Gauri4PXz8sMhCBYDdFHopaQjs12w3q7Jm+E0UEUvrrSCmssEQ2FSoNhzXJZ77lSifFiUEhM4n4gDBwCn0mDOGuNKCttJpmbzUS6wbyiqJsUQ5cGnEoRg5OBcfTkVUMzW2ISinIHGaIKni3/Zl7q3MaUo6u1TfbLQ7LYJV2bcIOVH+h1MbExwqHw94k9FoiMKQC+qkrcGBIQplN4ekOeVdg8YlJ6kUpe7UPX8vz5GcvlCX275uzFc2KIvPu973J1veYf/aN/xH/8n/zHGKP45PEjVteXNFXDbr1i7HoMI+22k2sRxNfok6fP+N1vfYeyLHjjjdeYTRuMhp/7xk/z4M4xX337Dg5Nk1e8+dorqOhZTgpiGIlRGGCvP7wtts7eM4SMwTnavmP0ARd0YsqJTXEIMfmvxwODJs9ynJNkrKgEpjO2wOZSa7SSTOD9cFRzcy+qPYMqmd9551CfY8iIhkETVPhMbCPcFPM9q+jfNM/9X/thjWaRN/zaex/SBcMvH7/NdtgxUQtUvMcYPyGGyHR6ymbXCX5qNHVd05SVbLOMTdaqAe9uKBj7BxEl0IVKXZVSigyDDbXQkdhT4DwxCGeibVsRvhiVgovjZwrIPkarqqrDxRrHQb4vkJucPLNMJg1jObDd9RJskSAehXSEMYZUhNRnCmYIDuUVufL0w0DX75g1UyZ1w2azRSmxNzZZRucdQzvQ5DlW52gUk9LILiX2ZEYzKRWv3n8dozXvvPEGv/Evf4+inqDCiNWap4+fsDw+wY+eYRhppjN+67e/yXvvvc9f+Q/+Et/5znf4+te/Rl3XHLjgGJyT/NcYIzGZKGkjdLt9cTmoTY3FaIM1ibUROSgo94fwkG82DEony1wt9EUdNUpr5rMjjDJ0fU9VBbRWZLlN9MjIi7MrKd6ZIUZP3/fstltOZwtU1AfOSPouCWLaS6BucFKjJU9UG433DpNlnN55QJYLxlrkBVmW08xmgiUrJYuvERop+wEyGm0yQLo1lNwnIcosx2aVWF5ET/QRkBxbpbUosfc7k4TVWmNEh5rgMe8cXduhiPI+jXzevoOU+/dme78/w95LUXHey1AQoYrmWUkwkX4U7UOWZ4xOiAE5OYbAr/7DX+f41glffueLXJxd8Df++v+D/8lf+veZT2fstluiVuyuW/q2Zbtecf7iBTYzdLsdCihyYczMphNEKeFQOlKWBZO6oN9t+MmvfIXz8wt+8itf5Rtf/0nKPOeXvvENMTjTkj+qoxHxY/SEMDAMTuYrY6AfPbvB0Y0eh9hMaFVgrHTgo/MoH1IsozCqghvluvtwGPhrrQUHiIHgI0pZrM3S7m9vTQ1oySzYs3IyrRAX1Rv4y6RCvb8+ALkVM7t9dsC+zghEk2IuX2qufmg9/UPU3P+/HFFFMqPZXG754NE5KigWZoF9Y8p8coQPJ7z/8YS++5jm9oy27zEmYHJD8CMhSHDyMI4S6ab2drHSbZlE25PvlTpGIytqoaeoMcdY6a73+a1akSiYDoWW4NsgJ72ua3mtl7rYPM+x1qZU9RE/SsDunrssASAZxEFCIYwmpG16lgJ799QRrWUFB4lu08ZAIQtSiI7tdoMbHEfLJZvNjqfPnh3CIpTOuB5GFIH5fM5sIu3fG6+cyI3lSnSIWB3Jcssf+cZP0vaOaf3nudqsmRQ5NiiOpnPaqzUXF1cUVcbRrXs8fXHBP/xH/4RXXn2V3/yt36YuLT/xE18jBo8Pnr4f5Ka3QrszUTM6l0I0brrGrusoypwQs8Qi2DOR+EzXYoxJxVWCO14uTDEqggtUVU1V1YcFZByFBSJJP56HD5I1qtZ8/OSpuD6GwOuvvYmOIpPvXvJn34dggGIyOky6rnmWMfQ9ZxfPCN4zXx7x8PW3MHkmuxUj3XVRpIxXFRPEp29olyHKjkPJwzw6J66EYaBvOwYfuHPvVdp+y/e+/x2aScVscoTROWVRSXeu0s6UvV9PSItjRCcocOh6nB9lgdV7mqXg2zZRKb13aQ4Q0vAzOT8q5Jr5SFVWKBQffvQRRVnQTBtc8Py3//1/T1U2/Mqf/3OA4vGjJ2xWHV/6wtuMfU/XtlxdXFAVGUVRsnMDk9mUXMmAetrUeD9CkB2lIlLmOVbDdDLhl37+Z5hVObe+/EW+9tYbvP/hR3z5zTf50FqaIqcoNNF5DAZjFdaWYvTmhe7a9p71pmW7a+mdxyuZTRhbSfyld4n33pHnOUEp+lHU6jFGsr1ZevCHeM2Q4Mvdbie779TgueAZslF2TWkoKtCwqNhdiOTWkFlD8OBcojgmFsweW9/feyiBYn2KBnOjk/mKMRgttaQois+Ej/+g48eiuEcF0WoZXpjIH33rizB4wvMt3/gjP4NeHvHr31lzuSvo/Q7hhWh0dFw8+5R3v/sdbIic3r3De997D23ADS0h0eaUTui6gqD2LAOVOmuNiROCN6hsTzETybVstdKDHpMRlVKUVSWBBqN0qmr/wChZzfcXIvggCtZBzMC22wRPxDTgSjuJPda237oRI1oZ6Qh9QBuVeNgyKXc+EMOI6x1udBRFyXw+4+rqms1mzXJ5RDNpCCFwdHqK0rAKGVVWUBh5fedHGegQiUpTVzlfeOMhbb/jzVcf8tGnZ3TjAIy07ZrJ7IQPP3rE6689YDqbEZXi29/5DifHS+7ff4Vf+7V/yk/91NdZzGfEAEF/FsOVYBD5efuu51f/4d/j6z/9NR7cuU9Ush31aSi67zAVELzY4GotAyxj7YEzv98y7wuWSlyzwhiKsmI6SylDabFwIfz/qPuzYGuW7L4P+2XWvIczf/Nw5wZ6RDcIEgMBECREUOAoBUFKVJgmKYUY4ZAU9psYfvQTX/mkMMMRlhS2rMEWLUoiQdkSSIFNEyDRbEzdt/tO3zyc+Zw91JiZfliZVbXP993b7QjJcVUR957v7LP3rqqszJVr/dd//ReHJ2esyobpZM7de2/5JDai0e8hgLbtvNcvxhfti4eiiLauJMlrLZPJlO2tXUmoatHoQcnzcgq6thYlwi7QDjvatmZdrnBKmFhr38VJqHcZX/zq17lx/RZlufQbQkPXOaw2aN36pH2EUxHOef2hphXj4AyJEgpxWYvnrrQiz1JfqBfyDz43gvzbGnEirJ+7J8fnfOe73+MbP/Z10rSgbmp+9R/8A+7eu8vP/twfpjMdZVWyWtZcnC+w1nJ2dkaSZJyendI0rWeRZCSppu4Mi2XMztaEWK+JnMM2NVpb3n3jLnkEW5OMf/Mv/yX2trdJ4ohf/PmfpWulxyhKc/f6Hr978hF5mlCWFUk89c9OUxpLW1WUVclyUVG1wh+P0og4K0gyh+paue5yjTF2YCNpxbpc03Weq+/ZREHmorMSxZjO0HStJOYjgWOVEj1/Mc4iXd3TF53zlEYP41hHVdYYg9C8feJ3E1t3OBfRtgbrjBen881YembYcI6ruPzV43Nh3BUSaZqu4enROQ9/74iqaljfvc0f2rvG/OA29v3f4827u7z/O15OdVnywT/7J3TPL8idJcpyDk8UUbnD9MYRq7jDZMJbFiMeOHPBNEiYm6gcZVK06vObtE1L3VQkaSI8YI+nd11HlmcoraibmrJcA0hH804khGsrBl3gGy3Vego6a2nX8v4ojgavTg/ZcFm0BjqLtIPDvz/2MJDCWVG1M14B0DnLer2gLGF7e5e6rjk9PmK9WrKzv0+aF3S14WzdsU4080SRailNDz2NnLM9/p9ECduTjNv7OxjTcrk1YX//GmXTYI0s2NPTU8qyQumIa9dvcrlc8f73P+QLP/oFOtvxrd/6bX7uD/8UE8/nBu+ZI4JfSmvevPcGk3xG21mBD5TkPkIkZIzBGUsUWWE2+eR1bI3HYgcIpy/00OOKSzFUsoh8YtUHRpPJBOUk6RynOcY6UqV6TDN1YWydZ+IMWLVGoaNIONxK03UVta0xDsp1Sdutac0aax1NZdCRYm/nFucXz9GqIEk1WZ4TJyk7O/usVhcSDeqYKEpAKZIkxarCP+egIwKtMayriiSJMEZC/qJIuTy/IEmk3WMSFdKJS0fYrkHriKbriP39VFUlvPNUIqa2bflv/9tf5c033+bLX/sSFse6qvitb/8OX/jCl5htOS4WC5brNReXCy4uL1HKsbhcUOQzqmolUak1xJnUO5Trsl/XSZTSdgbrpsSxZnt7xh//xZ+lSCHPCv61P//nRJ4hgt1rO75puGDcxn+JRRPHKVmcsbt1gHUxF6WlNi11e0HTGayVvq5JmrM1T0kS6aW7KldcXFygteTimrahrKTF3nQ6JYkS4iSWueIjvTzPmRQFjaf5OpCmOa10XdPey07TFJSi7YZajnA432Q8Snzz+a4lSTLiWDGfb9G2HVXT9PMqqKYaY1G04BQqjrg8O+HJg4+5c/ces509TBS0l9T/QmAZB6q1NFjOL0qOTi+EqbCzxXT3gAiNrSuu7x8Q+xW6Ltc8efyY2+ke8/mUSs1YHM9Z11CfP8M6Q5xoD5MNRkMp5RsCSef5WM0wNVJ4hGDtbVcRRYrt7W2sFQ/LWstkMhHalk86ZVkOSIKjqqrekEWxD5edEUFCY4hi0etwCCY8nU/pTEfdGrRWCCLjjQoKa6TAIdGp4O7G0qmOOPIly77dHcqgtKNpG05OXzKfb3Hr1k1Ozk44OnrK1tYO8+kusYvp2obTpiNPU/JIUUTS4EIqTgMv3CFFUTnv3rrOOzevU0y3+ODjh6Q6JlMOTEcSKawxPH32hP29PSbFjNlsxvHpER989DE/9ZM/yWKx5Dd/81t8+atfYn9/F59FJolidr/4Bf6pavnDzjEXKgmddb0hlafWM6/78NUJ/iDekWfC9BRv30AkPGfb2R4b1UnKarUChMq4XlXoyD8Tz5qJEOG6sViZhO+Opi5p246Ls2PSvCCbTlisFnz3g9+mjRpu3LjDuirpTEWRTokU7OxsEyeag70boDoiVRAngIrQOiHWOXneSrGLZ8IoJZTZrmkk8nM1WknvXVREVZXgMtoWcJo8S6iaGmMUUWxRrqXIMpqmZrm4pJgUzOczacJtLP/1f/v3uH79On/0j/5RHNL0+vx8yfHxBV1nccpycXlJWTZcXi6YzSZMphPatiFLU4osxyl5DkkSkWaauvKFSz7hG8cR7773FnmakAK3dndYXi7Zne9wfZpw99aej16tNNNxDmccyonEsFV45Ubrm8Yk2KTg3nvv0bRwUpa4siJOc9J0xs40Jo5Tr7cTkXhKsTGWrotROOq6wWBxGtIsE9E3HZMl3lmr657pJg2pJXcRDqWldWXXyVpWWor4oiTGrsTx0JH2dQMyH8VplSpV54ac02KxFJzdOyzWWuqqEngxS/m93/1NlI348pd/nLOjF/zut/8xWfFH2Ll2q3d8QrTwWcfnw7gDONjd2uGnvvEuj3//vyJ28CN3bhPFOZ11tM2aNJJs8+XlJZ0xNLajPEiZXd/FtS1b+TFquWCxWEhfw0hGOOhsW8/9xnPdE5sQuxlWKZyOgpw7cSoyq2kaU64FikkSwVWrqqLp2p7vDeL9gBig8D6tNDpCvIJo8JKc5912bcfN23s8fXKIUSNqU1AUTCxaRRjtfDVhR6oiVNShlW8ygMM4h8h2tTgcF5cXrNZrdvf20ApWq5Is3RIudJ4L26NuKFtHnSgmKSQKIhf8eDDOenqZ9GaxWH70rVt88c0bXCyX/MyPf5ntSSzSA85QFAkXCxl32xl2dnfJiikn5xf8xm/+Nnfv32d3f5ePPvqECMXdd+5y2ZX8k6bm68WcLa2kFN9uMmokEh0Mfp+QZYATlNbYrkVHIh6mdcQ4ORXyIWUrz805S1MLrNBZQ2Rbn0+U3cHhML7qs207HIauc1TNOUmSU7ZLvvDlr5P4YqO8SOlsxfW9N1kkF3RmTRoVKG3QcQaIgciyDNMprG0xxqG1JUtz6ZVrOpwzKAocDUVuaMoVddOidUsST2k7Q6xTmrrxZfAifIW1nBy9JEtidna3cGpFW60o65L/4u/8HX7+53+Or37lyxgLnYN103JyfknZtMTKsVituFies1fdYrWuSDOhaIJiNp8xm3kBM2uJI4gjJTCQAo3BmZZYO376J77B7s4OqevIpgn/+r/yL5EgFNl0nvD75YKz84Rrk0KKdJCUtdZizB2K1ig6BVXXUVY1i2VN0xrqtkVFmjjLSIqYVA3bvkByqc9zSPGXzBeZM5HvEta2rbQoicQYaKeJVESRSx6j8VXCSkXkeYHG0dS1yDqgcBqs9mK/SmGcpWordna2mc4Kus6wWlcYZxBROuUrVSMyrzu1Xq99BBrow/h8njCtFIa2XPLikw9QLuKLX/gSt27f4I/9kZ9lfusNiCIiP5+jKCE0j/m043Nh3BWK9978Ef7QF3+a1bnj//13/xG2a5nOZnhUmN35lPkkJ00itra2SI6k0e9qdcHq0QX5liaawP5Ows1sjyy9xve/9xiVxbhYe9qcGnZUFKmaYioJ63uaVyzMBGMsSZJyWl4Kg6DrqH2yRQcv3IWCD2FT6FDIY8SrzNKsN1BCUxO2R6QlMfPs6XMpqQ9qh0rjfBJVtFmCRndgjgiO54L4lYvkIRtgVMLdNJbDl6fMt6Zsb+8TxeLxlWXJ9vY2eZHRdR2LrmZVwjyNmEaa2An/Xq5A9+X1YNGJNKe4nqX8mV/6BWqr+NI7bzOd5kQoH6UIY+jk5ITLywvqumS2tcVkOqU1hl//5jeZ5wXX373NvDXcKkucgW62jXTgVj2b46pw0lhGoMfxwMNZmrZr0SqiLMt+owwFIDJuSmoRjOP8/IzlquJycYmORA3SGFELNM7Qti3T6YQ4EU38KHLAjOlkm+ViRZKKep9zmiSJ6VyNIiWJU6yrpaKzqaFzONcyK6As1ygyCFXRSKhe1zWmawl64cZVfXhujfUVy1Iw9eL5c9blJVkmJfxVVbOuIn7t136Nuqz4N/6Nfw2rhVZa1RVVVXN+fonphJ/dtDWr1ZLJRJKZzlnyLEcpTT7J2Nqa4ZzkmnBiyI1piWJNXqQksSbCkGnNL/3CHyECJkb6wf7sN74oG6/psMo37Wild67WMdvbOW0j2jED5166SjUG6rajXi5Z+ShAaKIpcZEQTyX52zS1pxxLtDyZTKQJty8AkroSiSCUCkVtqi8IqtoGpbWsrVFVMU7EAEPORbztsJ4kP2F8wjrMSeGzW9brEmedRD0EWmwAB8UpzLKUtu36OWx8jgMtKqqRkmccK0exrvgTX/668ODNgv/Hb/0657XlrYuWX/6xGbrYxvg5naaDg/m643Nh3KfFjD/y43+SyGpKd8a1awfM5jOSycRDEo4v3L/F3v4BB7s5cawpJhlvvXGfVXvBvTf3sbGRbkDa839NxIcfPvWt1hg6qeALSZwiZUZjLWkoqtFWBMKU3wiIqJuSptnksDtj6WjFGPvNMxh9J0rDRFEsssMI3huaiSgn9DRQmNqHbSHZ23PkI8H2rMZKtRXOgTHOa2tb72HkzGdbWKtYry9pmprOBmqiY70qqauat99+B6VSTk+PWK8XbM3m0qYrm9C2LYuqZR1ZpnFEpixppHqOrvN9N5XzHSGVbDyJs/yxn/sJFBFHpye8c+8WO7OCdSV0uSyTxhrni0vOLy7QsabpWnav3WVqFbNlzb/y/JR4PoXtHSTlrTGdwrmur9hTSg2Kh04Ky+I0prGGWEceykI8bSOJxbZt+wWdJAnOiUZ6keY450u/dcRquURHlmJSyNiiMbahqVtQDXGSk8SpRGFeCG0ymWOdwdHRto62q2nMmiLbpW5LqmpNrFM6U4mBoeuxbuc6Iu1Fn1zEZNL4PrVi2KNE0dWOTx58wnxaMJ3OiSIpEoq05u//vb/H2dkJ/+u/+pcosoxpnnPu9dXXywrbOFpb03YtWOialjTOWS1K8jwj0s7DYglZmpClKcvlUlhKzreXVIok0mzPt8BZkkgxzRL+8r/+F4kwpK5DR46d29dR1mLaStaOMb7grPMskgSV+E3fGTLdUq5qGreDdY661ZRVQ21agSQVJFlGMZ/1yfGu7ViuFqzKJXEs2k2T6YS2qTCmo64rIRkg66inIarAgPYCZ1nGfDaD9UpqYJTCtsIQ6rqOrms8o0si5KZpUGncJ0slspc8V9u12E42phZF15USQSkhPehgZbzBznOpXu8680oNBj4KFUdFk5crzK/+OslHL4mnE8yf/DpHJ8c8qhxHZ+d8485t7tyeEiUZWZoQx9Fn2tXPhXEv0gmpEYOWxDFFkbGzs821g+sEvve9O7dQOiZNIrJEs7M74d4711jaHBdZjPd4FdI3UztFkggVqcdlPUFFK0Vsc2wb9ZQ70XyBkGZMkpQsFQ/XWlEUFEPhBkgg2hSqMj7ZJ3iaKCMGLM46yfprF2NM80oCRjqsxFIB19Wg8ZSqIM4vGGVgfhR5wfVr10SLxEKex5yfn7FarbBWPJs8z8V4Xy6I45jr166xWCw4v7hgvV6zu7vPZDLF+V6r51VNFqcUSURB60WTBulc54Q90BmDckhJdgTXd3f4q3/pV0DDhw8fM50WQkXFYWxHlETs7G6TxDGrco1elNh//iE3//H7JP/az1M5YZqLbscwxtovhkle0PrwNdBFEy3RWBzHtNaQRDHKyeILBl4kIVqCB7VarcmyTHqDRo6iyHGu82MrBWpd1wg7p7MolaCQikVjDXk2Z7lcEcUC6zVNh1Kapqvl+jvxLp2GtmuI4gjrOo+TSuJY+WuLNJjOkKd5j7+macLjxyf8x//R/4V/+U/8En/qT/0ZkkQKiy4vlxgjdQ7WOC4uLoi1tP5brZZopbi4vGQ+n5B6iWKlNFmacO1gl3VZEkVeCVGJ1EXb1F5Q7DrTaSGGyXa8fe8G//Zf+QtsFyl55JhGEZPdXUxb01aldMHydRyRA+cbMGilEGFFryXvGT1NB9u7cyYm4tnpWqQHoogkzUgzz4Aa9UIQeYcEVCATKDof5SyWS2ItMhhFMfUsFXDWDEYegQtB7GaapsJGimLff1bhlDC5AuMt0ERlbRtpCegpihaHDZAhaoO2mASWVsjTuOCkQRSlXl5Y94VswvyKvbMQwCWDcpZmdcn66JjtxYp6taY4ueQn7t6nfvQclRa4oqCtFsxnWz1Z4LOOz4VxbxrhfSdJhGnXzIuCn/zxr7O/t4ejI5Tjg2M6Sbl9+zrv/dhdHl0+Fmy6D4NAafEwbaR47+v3iRMJzZUfe2mKG5O5LdqmJU8LH+VL02aFk+72aSzUJ9tJD0U9KmAYUZBCpZ9QyTo6K1h4kmRMioIkSXFYT8GSBOvAJxYvfTKZMZ1tUVWVsGwaMTRy3X7COEtjDco50iRiWhR94QcasqwgSVYYu8Q46Qaf59IWrqs7mrJmubhgb3+PaTHl+OSU09NjynLF1vYOaZYTJWJ4LqqOJk0ptKZwLdpJvgI3SA5E2mu6+MRxFicYZ3jnzg3+d3/tXyebTHn04gitWqxrcU48o+XlJe7JIeuPHqOrJdmqogfKfNJUaVkgaZzIAvPyufS5D9HTxzra1pDlGV0t0EYUSbu1LMuo69rXMyjqqibLEozrcEpTlRecHB0yn0+wVvIRiY5pakPXGHCatgNjazQp1knP3apqIBLjVFYNsY7puhasSAkrv1HFcUqWpkBEuV4IRIfoDv2DX/1Vjg6P+Qt//l/lzu1bbG1tCRc6TcEK7a4saxFXqyyL5ZKuM3SmxVnLalmRaHCpYns+J8KhY5jPpySRIk1iXtQl1na0dU1dlhRJxmK1Zn//gPnOFs4a8kRjupa//Ct/Bo0i0QBCA9ZpTmdautbQ+uIljw+Knr+zkpsAcIrIKWlGrVPaDs5WlqprhD3mHDpLKdKcNM08w6ShrCrKRUVnDGmSMpvOPNQgEXTTrFmvFpTVmjiK6TqhMFqPrQf5YggN1sdVm4PzJI7OhLKqaTw0E8fy3FoT9412hHroiGNFniVMipxSKequQ/mai9hTYscGXnmmVdCU8ukiIh2TRIlEZWoofDTW4fzvEnVGtKamMhXxuzfonBAqjquar9y7xYwEE+1wY36D5cUZ+VZJ5yyXl5efaVc/F8bdmJbl4oyd3T329nb5K3/5f8VkWqAVNHUtqLs3hn/hz/5Jvvvi+3x88gmdNiivE40T/MoiRS7OOSazid/BfbLQVwlqF6NsAgw4OAT8VvzUNEuFS+q1tgM+F5J7Y2xY6+AtyCTLspzZbGuj0CCOI5bLpXheI689SRKm0wnbOzOStWK5lBBUI55pKI4J5zXGMJ/PyLJ8oOu5oCIYE0rhRQkwRaFp6gZrJcl4+PIlaV6wu7ND29bU5ZqXZc18e5vpVJpyOBtTNzV1o6mSjFy1xE6eQ6R8REGo4vPYph/HJI5IkynGRhzszPiVP/3HeevWAcp0oWMEFx88lKYjWUxbRL5aDynf9h67SEC06Dju8XM8VptlCXXdSdVwLK0E0yTBdNIGMMsyyrLy0svQ1i1FnrMsl5TlWqQkgCxLqasKtzREaUXbWYoiIdURk6xA6xxDTdsJFCdz1aCwWCVSBcJPL3C2I4ljphORJjZdR71e0DYtzXpN4GamZQAAiLlJREFUXTekSUaWxiwvzzk+PqKuKkzb0lYNVdNysj6ma2ps21GXJY8ePCDPC7a25iQ6ku5Nvhq5yGLKco01RoyJg9m0oC7XONMxmxbs7m4xneaAoWtX7M5S/tK/+qeI44hMOyLXQuRE/TEkoX3dQKShbYwkrL2BJhhzX7BgnKZ20DlFXTvWZUdnFCiLihxJkjBJC+JENumqqqgWlzRtg0MRJQlpnhNbg2mNr3Ae1qVSsm6m06nkT6ynq5qONE09+2xIwTgPvYblFbR8FJo8yyiKQiprfS4j1JdIkxdHMZlQZBmRjijLiqpsvRqq8UJiqmfABCcneM+dh3Wcp/oqPz/EGZT3BeE/h0Z76jP4fJox5MWcnbe3mN5NsQq++eFDzMOaX/vmb1DZCbff+RJ3b97hYnlJXVeMzMhrjx/KuCulHgALhMvROed+Qim1B/xnwJvAA+AvOufOlLjYfwv4k8Aa+KvOuW999vcb6nKF3d5CKWk0gA/TLc7T8+TBPV8c8cnZE1otUqFOBdEmfGjovAflqwI9f1soM9LlpVAzbBuRREk/mQU2k8Vj2pZpMaVtDaYz8oBRdCPhHxh27YD7BJxtNpszm83I85wkka45qG322tZTxuRo25aLy3PSrMBZx2w2YTrNODtrfIINQJF6LK8xDXGckqcFcZTg3MANl4UQi2fbWgl7k0Q4967zokUymat1SVPXIkd78yZHJ+ecn5+zXCrB4idTsnxKZwzrtqVSijSZkDrLxLVoC+iRuqAbEqrGe9xaaXamM37qGz+G6RoaA/cO9kiLjKSC7PYN7MuSi65mogX8cQaSJKaupWrQWIdtW9IkxXqN8CRJqKsarSXE7rqGLMvo2kaYE8SU65I0SzFGNoAkFbpgkmQC83lgtq5rEi19Q+umkQplp6XKWTd0TYlONFkxIcunaKfY2dqitY2vOZAcSBrnXJ6fk2YeE64bSGBpzyGCaVbQNZ1P1vt6CmepqpKHjx4xm85ROuHgYF+iMduRJTH7uzvESUyeJcIQaw3KKepqzSSdkcQRTd0yySe0TU1drpgWOeVqyd58zr/9l/8yaazJYplLMQ1FKlIXoR+T8Pg7odp6DfvUJzkEFoxROsK0LZ1VVFbTtB1tZ6nqlnUj8GSURGSTnMzDiNY66rrk9PzUa7criqIgz0Tsq7WWVbWiqWucs6RRRJYlPXUQAj1YjF9Yp0mSohNJpoaEebiPYNy9zRootU60g9JI1sd6LYVMzoVCOCFMLBYL2rqmKKRTVmc7iZjcoMuDdbSw4dwFrXXlqbXas3ICo07eY3zerMMR9dcbGnckWQpVTfTi92At7KC3uo5vncxwpJyvS45PT5jPcukQ1dvETz/+f/Hc/6hz7nj0+98A/nvn3N9USv0N//u/D/wy8J7/7yeB/8D//NTD2o5pMevD/uB9ilcKeMbMR88/4tuPvkOrWkk0Iok+5WlH4eFGVuACSZK6/kadcSROk2qhlmV51l/DmJECoJxisViFPUVwxnExiw+x5AGJZ7KzO+fa9QN2tnfJ88lg2BEsX2zKcG/WWh4/eURwapWJ2NvfpSwHT3sQCtI9D7coJoNxd4O6nzSkSLHYXrDKJIaaehhPzz+yxnJxcU7XNdy8eZPL5Zrjk0OeP3+OUhG3b9+hKAriOKHrWsq6oSPCZjk5hsIJTWzwYkzvyRjl09EqIvG0zRT483/ql9BRxMV//U3yJOJRrviRKuKiMyRxhrGOtm18yOwpqLHAMEmS0FrjE6oJZdVI7iSOpXFDnuOcY7leibH3BUlZllE3zTCGTdsX8HRdx2w+852CxMivy5IsE40YjRhkvIZIuV4TIRWESZ5iNcy3d9FA23QU0ynWWFrXEOkYa4IQnH/+1vMofJvC6WzGfDph5quJ22aNaVtwgt93bUNVrunynLpa44wliWLiSLFcXjKbTHCR5c/+yT9OpCBXHbGt2ZrE2Nb4ykYvd+A0dFLb4T0ZaSepXICKMT65YpWHXXRC02nOly2rqqFqGl+1DHmWk+YzducJzkserMuSqlz55LElyyZM5nOiTiQ8qqZltVrJpuuvy1oj8sVKCR3Qrw+tY6xVlFVJ0zUe606FwhyJ1IfkVbTPy8mhVP/PYS1DP1fSJKFE0bStPGOt/RqS+eCSpHfanLPSXEcN6z9IAYv8t4yjsxYd6d4miDrnYB9CMdxA4GR43bk+r6aTmLZe05w0VK3DRQ6lxTFKk4Q0jambEueML5D6n48t8+eAX/D//o+Q3qr/vn/9P3Yysv9UKbWjlLrlnHv+qd/kYDbf6rXUhdssi0E5wdgevHzCtz/5FzTUuFDA40KIJDu9dtItHsRRH0iPoIwiMoo0muPaGJzwj633ei1ewMk5bGdJs4LubIXz3ZHCxiMULd+RPIm87ji8eHnK13/8a+zt7faGuyxXlOWa5WpFVVZUdUVZSROAqpL/3nzjLXZ394RF0bW0FRTZBONayrL0idyMKDK0bUeeS5irlO4nitys8nzfAochjlMgJkkLoqSS9l2EMfFj5Bzr9Zrlwwds7+5x49p1jo6OODk94+OPP+bmzZvs7Um/1TjWtE3HsqqpImjSmNQpUuulAZRU0FpP9dORQyuL6YyUbCspg9dKs0CxdfOAnVyxtTI0WrxBpzRE2ksfp4CR/EGa+U5YjjiKqcpSCkOMNCcvJgVd09J2Hbnve6uQVm1VJR57FKdcXFxgrMEazWKxJklyms7SWksxmbEuK0zXopKc5XLFbDohjpPBEXCOPE9JkjlN06CBJIokuvNheGsaHFLKLqwoi3GOzkLirKgrOiNUU628R+dlD4zFet59Zy2daVivl9T1kjxJ+KU/+lMY69gqYpSxZKphkmnICi+EZ2ito+kcbYfnj2ssEaF7t/L0Ow1MrOROogiM0rROioaaxtEYS9W0NKaTfECWkWYJu7NCcGNjqeuGy9WSsqp6vLkoMorJFJBuS6cnR773qdpktDiLcnZk2BPiKEMhzW6EDZYRrxJKL8yntYxzq7SPUn1Bn4p6h1DmtbcPo0OhSNOMvOuokoqua0njiCyNMR2Usa9tyTLiOCeKlIc5G8mphQK7ICDm7yN0uxu6SflOTmlKlKSeCeR8rwCH8zk87STZ7M0fSmvS2Qw73WG23VI1Nc7BP3v/I07Xhjffeot5UfD80Ud05ZI3336XWzfvfqpJhR/euDvgv1OSOfw/Ouf+NnBjZLBfADf8v+8Aj0effeJf2zDuSqm/Dvx1gL2dmeBU3lqFxgvOe8xPT5/y25/8c0q3lnDGJySkg/zQNFkwdwnVYht0xf2G4Tvep8xoGuN5yq7ffXGhd6HzjB2R1Y19qIV/ANIyLJEMfCae8u/93u9zeHRIZzref/99PvzwIy4vL1kslqzXK9brNXVdYYyVwhg3FCbt73+XP//n/1Vu3jrAGEXTCMc36nnc9J5onkvSbRx+Bu8kcHolg5+ITLCPMKJYWvn1Sefwfj9wprOcHB+TpinXr1+nmEx59vwFL1++5PLykmvXDiRZl8ZEWtG0DZdVRxxFTKKUFEdhmw08MjAWwjMMneY7Y1jEHbdv7nDj7g7Vd55TOEsSJ5S+8YHSEabriNIIHSmWq5U0pdCaqipJ07THOLMso6nFm5wUBetyjVaKLEspy5I0zYmThPOLBR988IE0h4gyQPHk6TOuH+wxnRZUdU1dN8ymheDlXStsmtY3YNCapa9wVUpRlqX0OU0yyq4ijiXpa7oWYyQxL4qMUa+26FxQFvQJeGO9wJkkB6tS+PW/8HM/w+1r+9hqxTQWQ5jalnfvHKB1DMqgvbY83vs7Oj7n6ctjujQnSgritCDxctTaDW6O0r6yVylWXaj8lURlZxVV0+KMbJJ5PmGSxkRxRNuJLvvFxXlfjBPFMWlWMJtNaZpG1DbXqz5qCp5siF6vzlfnyQexb/odOOshvxXWWuTXYF8B7hOi0lTaz2fbC09A3wDn1SNLM/Isp25qkWROEjqlfMc13eeqwPY6+UJH9hRKJw5LmOsmsG9G9xauXSjN/ppUYNkMeTJwni4pEYlSEG1dI25PiRpNTo7VayJqbt26jWsbPv7O75C4mr1Zwf17X3ztPYbjhzXuP+uce6qUug78v5RS74//6Jxz3vD/0IffIP42wJv3browMCH5YH0rutPlGb/1wW+y6C56zEsSbg7tVOhxI6wN/93KimwublAh1Eqh4im4DGcboihAMuKVjzPtKkoEV2zqXpQqyzJhiXhFtrzI2dndYrWu+N73PuDtt9+gKkv+y//y/8nR0bEUPrXGi2F5CEkptJbvktAVXr444n/4H/4Rv/Irf448z9G6Joqk63wSJTRtQxIJK8BZJaXoTvXFGq880DjGuaRn9azXa99YxAeGbhC4DRuo0DiFi/306VMm0xlvvfUWx8fHrNdrHj9+zHw24caNmxSTgigR5cumrlmYjiKJMToj1RZnFNpJda3kWEVjI5zPOnBffIP1wRZH60sOrzu+EoFGePZFHFG1DVGesmgMrhO8tG0aqkqSyYJdWoq8oK4qlBIhp1W5Bh2RJDGrUjRUdBxxcXnB8fEp/8l/9l/gIkWWFbRNwz/9jW/yv/nr/ybvvfs25XJBXhSgNOtyReLFtlrbMfFdsBaLCybFhKZtWK+WTCY5TV1SNzVpklCt1ywuL3F0KGcxXetbtPnxV4o4VhRpziTNyJIYpQ22ayQyiC3zrOCX/9gfJupAYXw0C6hO8htKdIsMop9uasOjpy9Yr2sO9vZp2o7f+N3f4cmLIyZbW+zv7XKwt8eN6zeYzqSpzMXpBU+ePuXo5NhvvFKVeePGTd/vd1eonm3DuloxmUwHTLpryYvCC6tJIxpxXMwGBBww74A1ax33nupgKlRPlhAnapAhDo5XEid9zUL/3Vpv4PIwnFuhiBJpNSiO1GY3KqXE48+yTGQG4hR8e8M4GlMb5dw60jLWSNSOc32uBUSzPVx0ELwDn48bD4gT9oxSEkVpHbM12ybPc8pSZLtxmrSYwHYLrSE30qM5ImJ7e4tiPuVn/vBPEi9OUbMZjv8JqJDOuaf+56FS6u8Afwh4GeAWpdQt4NC//Slwb/Txu/61Tz20FnF7Z4fKRBycLRf85nd+g8vqQgqLfAsrbEgICfnfIh6MdWLUIy/Z630VmUIWMmZYK8ZCq0EFTwotut77LYqCNElJs5Q0kyrEoOMQ+OPb21vs7m9zcvIJWVpw7/5dfv/3v8vTpy82RPWlEnBg+8xm4lFKFxWF6Szvv/8+3/72W/zMz/w0k0lBliXEScLishQsXsWi5RKDUtpXuMkgjTH8cH2i+Sw83vVqRVNXw6Jh2BLkuqRs33pFPGstz58/Jy8uuHnzJtvb2xwevuTi/ILVasX+wQF7e3u9vHHXtqzqhlJr8rQgiSOMbcmd9U0jQkXfkBM5uHsToxQHO1vs7+34v9m+GjdTDte1TJQmilPOlgtsZz29sfMMihl1VWGtI88T6roGJx7TuixF9yOOWa3XxIlg6U3b0taWdVlJgk7B2bl4ouA/u1r3z261XmE7MX5NU3utEecbWlsirWmamqYRSYCqXLNeLknzBGdakYg2pmcSVXVDMp3wL/+JPwbWsDtNUE4JlbGtKCLJtsYuVFiK16jA4/figlvTYZXm/OKSjz5+xv7eAW+9eQvTtSwPT3j45DEX65qTy0sePHqIA3Z3d/npn/5pPvn4Ex48+ITlcknXtezs7JLnwpJ6+uwJt27d4hvf+AYAbVuztTXv8xXGTjk7rzm/uOiZJjIHw8z69ByfqIIGNot/3r6GRfvkY0guym3KTE2ztI9cQXDxOEpJ0xx87wUprnMkqSOKncjqtl7SYuMqJKIM2HuSiLHVWvkIQfTyA3U6RAw4M2jG+Nfx70MNRXYwRK7jCtfwZ60T4biriPl8TpKknJ2ekaYx2kfkXdcQ5QWt6ygSy60bN1msn/Hu/XsYvcZNY/SFYbIzo1YVn3X8QOOulJoC2jm38P/+JeD/APxd4K8Af9P//K/8R/4u8O8qpf5TJJF68Zl4O0L2l4H31YZELKsVv/F7v87p6qUoJfoyf/xOqX3hhEKJ0mNwcLyBtsHweV2Z2GVEbsK6apj2OhTS1UmqiZUPD2Nm0wld13q9Cik/T5JUGkNHCUWesbU1JU4iojghSuDtt9/hP/wP/2+sy7K/L+csWkMogJpMphRFgbVzdnZ22dnZ4eJygdawWq/oTEeeZ7x8ec5isaIo5lLpKXOeJB43WJBjkAqWQ+vIT3x5b5Km1FVJX8mJ17nHe1e+ojUY94CL1lXJ40cPuX79Ou++/TaHhy85PT3l6PCQqizZ299nMpn0OYi2MZR1Sa0URZqBFgEsTSvPyYUWc1BoiJUmVuCQ1gxOIRCaA3zlgnaAa9mbZNRNx7rpmM7moC2rxQKpPkx7vDfPcyoP1xTFnOViAQ7iJOPF0bGnvIWJLad68fIlX/jCuxRFQV1XNG3DdBISnC1ZmrFeS+emIs+p64blShpMrFYrVqu1NNnQjnIleRSpibCIEolBO5jFjlQ7MlMx358SKzBtBxaJ7nR4nkbkJDytVns6H8qPZmt5cbrm+PyCy7ML7t+9h7UNv/Htb/PJw8e8PDpm2RrMKPy3wP7BAd/7/vf5/ve/LxGtTySuViVV6RPuQFXWvPfuF5jP52xv7ZAkMW3TiJpiuRL6Ztd5Ou8Qbcs1isO16cEHEsHY+A/KhuBII8ldKc+Mc8r1uTDhisd9S7woiiiyGVGU+EgY0lS6uBljaUqHs9HIYx+bdx89JdJzNokS4a8rZM4qhSbyH5EoPYpjVIBSPWEgIALSUU0PhtyfK9IRkQpMnqEGJ4o0u7u7tG3HerXkom2FWx+lAvF0liad4IBuWeIyxcG1gsVlyX5c8z8ulyS7M77+xj0+aCrSwwd81vHDeO43gL/jDUgM/CfOuV9VSv0z4D9XSv1bwEPgL/r3/z2EBvkhQoX8az/oBA7R2naeZ1uul/zG736Tw8ULjGtQWF/iO2g22OAxKM9EQAy8L1T1rBCPtStFEs9xNsZKnN9rN2ulKIqctpXms0maMJ3kWGu8YVVi3NPEV/0p4sj3Q0QodD/7sz/J0yfPePToIcUkZzqdMp1OOdjf4/q1a9y+fZutrS2pQo0F35vNZqIy6cPAgJF3bcXBtX3SNMdaDRhv0A1RPA5p5VBXrL14DlHvyWdZxqVP2oVmF9b6OlxjePfpU7Ky5ru3brJWOYFY5qxAY4cvX7C4vOD27dtMJhNOTk6oq5oXL14wmUw4ODjwcFJC1MY0TcmqrqiTmCqKSZwjsYZYWWKN36icJMWdSB8bazwcN2xU0phAClSUs6ioI80U2DV1a5hmOa11VFXdR1NVI2Xk89m8Fw+b5BOMsbw4PPQyFDJ/wsx79uIlcZahI8HzE4/lBo2aJIlYrpa0bcNsKpTDtm2YFhOUs1RVjTGWPJYxS5OIQlswHdMsItIOYyryRKGUQVuDtkIxDJ5rqM41nomhvGELRS4imRFhrWNd1/z+Bx/z7MURaZ7xW9/7gLOzM5F9AOJQGOMphQ7Y3d5mPp/zrW99qx8X0ejRVHVDnqYkScLOzg53794lSVJWqzWPHz8izzLefOsNnF+DajTPwjiK8JlFaQQ69E7CkHsZReQMRlcpMXhpkhBpRWc6FNGGJ6w9zKY6sRNW+2Iv5FzWWcpSh6ykn7sBdw/XCrhgfMX5ExhogIrioLDoBkMdReLsqXbofesiK412tO7rZsK9Whw6ikhi6TkbZroiePMCZ56dnfrfIxEWVMo3+Kn5Jx8f8dYb77KzG1HnDX/g7ld5743bZKnleTHjESm/GVnaWcb9y/WnWFQ5fqBxd859DPzYa14/AX7xNa874N/5Qd975VN+QmrKtuQff+ef8Oz0AQYDyvYTPjRFkEOFjRinRPsBn8RxOF9F56TbUpSQsEVXG+JIg29rFxKOaZqilHSqT9OU6XSOQlNMJpIM6htNOHCQ5Zl0aWpaZtOcm2/f4tv/4vf44//Sz3P//n32D/bZ2tpmOp2SpomXJPA6CMpueN9SMk2fGIqimOl0DkScn1+gHMSR6xtZhMXywx6B4SMNAAZaVoh/t5crvvLRJ3zx4SMeXr/OP3v3HdokIWjwSCckx4vnz5jP5ty7c4fFcsn55Tmr5ZK6qtje3mF7e4ckTYiTmYisNSVlXTHJcjKdkGlAWVJfKqyc8AuswyvvuZ5+FhTzjDX94sB3tYljTR5rDGIoo0Q0s9u2IlKKLZ/ca5qaIstQQFWVHB8f4YO6IVPhFJeXS9I0pSpLrIE0j2k7aYoxn8/7haeVNEhwnSXBkSiLti2psiSJIu0aUmWZZUpiEe2wKvKCdVoSa85hnLgmOnG9cXDex1fGEDyWSHldcwcQ0biIsuo4WRqu3X6LfH6N47NTtkyEJcOenXp6ni+9d+IJqkjz1ttv89FHH8koeocmjmO25lN2dna5c/s2N65fZzqdeiaMbABpkvqNbk3rZRmCIQ9RdIAgnJesDpO7JysEyK1PpNoNox9Hca+L7qzFqdDmsJ/BJElOFElOLRSuSXIzUKUHyCQEFKpPZNKvGzk/4CxxnPgPBOhmgFHCdUY6EuXOuqF1HbFP+HatNP7QSK4g8onfzgpVNfUyJdaZPkfnnMgOh/aHzso+EpK2PWc+v85azZlfu0FXxNzI97m3N8OiOTg75EG9YB2lOOPY3r35mWv/c1GhKofDdoZ//v5v8eTsISSit+DnqQ9RRS8DpXqNCMvAIVW+nZkBiDSR3+m1y6CLqJuKSVF4TE8mYZalTKdTjEkFxkhSkkQSniF0l8Xp8NoBfP/7HxLpjjtvvMn9+3dIk4if+7mfHnkcwxUFwx1eDwnMkGGHgH13/t7Em82LnKKpqFYtuweO1hjOj2Oc7d3PTz3G3rxSoq1huhbjfHl0GCel+J333mGZ57zz9BnvPn9GXtf8w69+lS5S/ZpRSCJ7cXlBXZXcvHWL3b0dXrx4QVU1nJ2esi7X7O7uMZvNUToizQqiWLja1kGXprRJQusMuVOA6Rt3pInI5xobRNW8kBr0Spsw6Mo4X+A1iTwfm5oiibHO0dQLkq4jizRRZKnajghD43t1DkkH2TZWyxX15QJnLXmSkGlpwZbHmlQ7lKlJMUQY4rYi1pr5LCeJNdCiE6SFoxE+tN9+CR65tSKc1cMQDoEUCElHmYvaz1tjLEQJRiU01rFqJAndmIZ1WdM5TTGdkU9n7N8QglrXGZarBednp0JlPTnh4uKCtmm5f/8NKl8U9i//iT/Bs2fPaNuWmzdvsbO7L1i3n4Nd1/lEv+vnkeRwQmI0sFDGRlUMtUguS6FgmNOh4ntopO56TxmGDlr+j73k9vj8SgmFsU/8j/rAhg1iXLAk3zWGhoJhHzpPjT9jMRtRSP8pf744EgmB0C2LKMIWBa0RgbQ4ipjkhWxOXSvFg57FoyNFnASmkenzNKKZlIiTOOLCKx3zB/7gT6KsYZpnJDpCW4fTEUk65S11xqlZU9qK2jjeUSnf/Aw78Lkw7s451l3Nb7//L/jo8ftY3QrODh5rlDmjksCNkVlgFDgthifYO6fwWJgCJSFqYba9xR9aVEVakiVFMSFJJDmosD5Uo09aOucGI+cnzbe//dv80T/209y9exeUSLeOl/UmzhcyREMI3n/vlXcGVo3DgnKCA69ajl86pvOMKO5o66HCUoXvvzK5B6/Jn5rIQzV+0vqQ2DlHpTXfeeM+37t3j5//9m+T1C2/9Fvf4rv3bvPxjRso5SefP1tVNzx89IjtnR3u3bvPxcWlh2oaDl8es1is2dvdIy9yXGwgyWjrhqpuKOuWPE1pophcKYypiYyBzmdbHFhnUMr1SfY+rA9Kml074LhKeRVMjdIWraBINCQpOCluiVPFJM35N/7cn+I3//lv8S/e/5DLxYJJMWFnZ4t33rjHPFJkUymCipQ0ZnaxRllpZL6TRtg0iGNBrAFnfNLP0brgeQWo0HO18Qqlgbrr9VAUGqFLSzK7tdDZiEbFtFpR15aqK6VLlQtiVmIYVZg1WhghzlrSJOJgf59bN2/wpS99maapOTs75+joiPnWFp88/Jj33vsCSmneeedd8lyMZdsaVsslje8f21dbOud7ha64e/cOO2qHOM6Aljju6ELTFMTLVv2as2g3YP3iYbu+GC98JsxRaxVpkqJ0DHiuej8/x8Z2yDVd7Rsq3zsQDJw3Fsp3GMMNc338fYNjZdnAgTYOJZh/Iq0LkyTF+Xvpuk5aXyapb/YufPs0TimKCTvb2xhjeyG/UJwp1MecJMml38SV+4i0kmg38iRvpVAqwRl47+PnvH1+yiqTjXH2ycWnXLcfq8/86/8fj9/98Hd4/+nv0OlWYBCnAkPRJ5XCTuu8nxNeU+JR6wFbU1Y8QnBELkeb3LcXS3tvQBZaTJrmUiyFArRvhCHiTWMDLHZGrqHtOiLPoOl8tR0bxnpQiwxY41Vs/NOglcAicNZiXYfWjrruaOuUnZ2Es5OatumXOEpLQ4SxtzP+fvmpZcx6j0buaLg/jdUR3/zyV3jzyRO+8fHH/PT7H3BZTDnemuOQZxGStxGai4tL6rrh+vXr3Llzl8NDMfDLxYpyXbGzs8POzhZaR8Rpioq0JCy7lqaDMo6IVEKmIgrtRatsgycO49B99aQY+/i14xZC9DA/gpG1faJYoLz37t/ki2/+Gf7s5Yqz8zO2t7eZzaYSVmtwUjPpux/Jhq4iLYwfKxuHc745tZVnrLWXf1Ben0jJvLNOZH2139i7TnjSoo+T0hJTGsn7rNuGsjWUjfGyB8GbleRR15oROwq/l2vSODRdNz3nXHkvMIoTtra3mUwlMfyNnR9HIVXbbdv2bRK7dkQvHM2buq753ve+x2q1Isszbty8iSJGKeu7CtVewhaslVyRsn78/QqQIqPYR2KDFz48w7AxRERxJtCU9WY32pzDrzvGGxF0gy3AO2EjJ8pt5Fn8Otv49XXn8QncOCFJMjprSOMUq6UNX2s633sWXzUslcPbW9vs7+2xWCwoy3K0xjz4ozV5PhnmqdeuUkqRRxGpAmVbnNGgY4SfpYi7lsm3P6D46AlrZUlURGo/bVOS43Nh3Mu65DuPfpdaGYhC2KQDZIZViLqjD3ut94RwiCxtgGdsUFqTwg3tIGMbiOiMociivveojjRxrIkiJZ4yBDd3RPMajuDBh+KM6UTa5AWK1tXpMYSNw+/Sc1X12hXh9cGrkYjh2dPnvHx5wmq55o17d4S3vapwLsUavTHpQ7OQzfNu/u5GV+eZxXgXacM7LpOY79y/R7wu+ZGnT/nq9z/gd9+8z9H2DiaORXBJS4cpnJWGI8+eURRT7t69w3q95sXLl7Rtw+npEavlOdvb28xnknsIXaq6rqNtGsq2pYwSyiTxRjYmijWJM0RKESu8FkvnQa6QU0E0ery0qlXj21HDRuuC3ILkTXCKg90JB3tTeVVFGBc8VnlWprN9VCRt+mQBxr4Zi46GeemQTlitb/KglcYa0yfqnBbcXIfkr3XUpaHqRD207TovdBcRRSmzrCDPMqIo4tGjj8nzQuZyFGADf4cbonXaUwgFs5aaBq/5z2Cs16sV69VKmEW+5kKqZAfIJMz5Fy+E3LZ/sM/Lly/5ype/2kd72jcDCXNWe8bI4EwMhrzXflGhmXNYZ1EffYXN2XitFD3aBK7+fGVe9+ccwzBjB2aIugdsdLjOH3QEhyGOY6JWDLjTmjiKKfICh6PIcrIkJS8m5MVExPmOjkT+ZLik/vkFTRjnYSihWiqyNCKLFbaqe+G8/h61pi1r1NmCzDhaDDmQol9/4f74XBj3Vb2itTVgsUogCZTFoYl1jLIW21nxoIxPRCXxcPMKIicNN7CgLWhn0CpBI5rmIfMtjS4koZpmidAgMbLrO09jCkkOBmxugM3FSxLubetPOWwE40k37gaDEmaAc5KgM8bQtg1VtWa1XtPUHTdv3ma5LPngg084Pbnk/PyC69cOiBOhZ62WxkNSY2su1/SpR795DNfnA9/e8HmUR7BxB9+8d5dHRcGXjo/42sPHPLhZ8/07t1BaIqRQLh+wyuVyyYMHH3P37h3efuctPvnkAW1T0dYdR4drLs5iZvMdprNtUbzUMfkkIbGyiTZdQ1lXQmNVUqCVJilZHKMjSKxQ4SInOQ8ZV0WEkkZustugrMAmVovz55wlBv+8ve6Hh7xANI1Ck4b+OXusNBgfmRc+rPYL03jxMWc1nYLOaTG4Ws5TG0VrBGBrraPqauquxXrsVUcJ+WTCNC+k0jmVTa+ua6qmplyvOT4+EqGtfIpSuk929mwOa+ms7Su0LT4B7R+0NYbFYsHFxUXfQSwciqF3wbhnbZhQF5fn3L59l6ap/NxQgjcjDlFZ1ehOEqvjwiP8WIdDvHzJCUiORYrblJddUCryVabB6/ebg9mcz0O0vWn4B/lt3T+74S56DPKq035leYzG5UoyOPxNay3JZS3a8VmaSWJZwWw65drBNdJUJJVXq9WVnFe4Xj82fi066zDWSjerLCeOImzXERg/ciEy94wCYk0DGLQoxiK/f9bxuTDuIPrleM+A8IAtRLEYbDpL5MMrB2AN2ntuEhobiLTH4CUMTtSMRGWUpiLyvTXpvQ1Fmib9JJB9VVQRs7zg7OxErmwDbhEfv8gLEbTqREMkbDC9p+4jDGOkN2O5Lrm8vKCqaqqq5sGDBzx99ozlYom1kOcZe/u7/OIv/jE+/PABjx49Js9TvvLV97h2bY+qqnujPMYsX3eo3ksII0u/UY2X90as4VzPpBHjFvHk+nVUlvGL332fg8WCdZbyYGfHq3A6DzdIZyGUoqlrHjx4SDGdcf36dbq25vzkmKaVJgvr8pDo9ILpbMrWfIut7S1SnXo8NhbudIfX2LaYrmPZhqBUPHjrMeosTdFRLNRKBdpF/o6M7wWrevmGKBhpJDmv/Hjofi4lKD0kvp1fTM5Zz2aRXEVnDZ1y4AQ+aI1BuQijFEZFmMbQdi3OGZpOdIDQeKMgjSmy6VyUAq04EdZj24uLC5bLBVVZ0hlD4qmdWmkePHjA++9/j+2tLW7cuMGtW3fY290jjRMUUqMYnh0EOQHDxcWFaOmY0LRiBMO9BtqS1oQt67JksVhgbkgEk3ilUSEwifcd+USisfjKZ19DMTJqWiviWKOI6FpIEs3e/hbz7YLzszXHh2uUijxr5fXAyDA9hyRoH6m85j4Gj32Y+5urYfi+TzvP+N/BMAdZgnDeOE5I05wsz7lz5y44ODk9pe0MnxZ1jGGkQBVNY0WeJCismCwntsspiwnrVUukRprg8lTAwzTBtU66837GwH0+jLsCYpkowmeXcmXVMRQvRfJGqxVOS6cj5VRf2o4D7Zx0U1cK5yKUmdPZDtO1TLe25G3O9Qs5aEgETxYl7fCaRvpgvoLTAU5FzGdbmMby/YcfcblYEMdSHnzr9g2M6fjd3/t9Hjx8yNHRCefnF56dcJPppGA+O2BrtsPNr9+haRtW6xWnZydMpxMmk4IvfelH+NEffY+yLDk6POTxk4dcO7g5mqiDFy7HWCTJ4Zzuk6cgHkIoDxdvbSj5Ho5N9oExsok8m2/zG2+9xc9++CF/+re+zW/fuc1vvfsOXZEgCUVQwYtV4Jzm8vKS09NT7t+9w9vvvsfh4UsA5lu7TGdbnj1jWZcrqmpNtV6TxQlplhGlGVmRM5lNQDlsJ9cYGiFghB9ftwZtHKVtxYtX3gvtwBnhGmsdytldP8VA4JzQyFwr5Zs9aHEufAjTdS3WSms7pwTPHXrXisfVehnbKIp8EZ7n5scRRQLTqe41iIJ3aq0k2MqVKCeuvDFXSvqVbu9ukSQJjx49whmL0zCdTJlPZxwfHfP82XN+//d+n6//2Nd55+23pbJWK59cHRoxl2XZs2a2t7d7Kl7/tPVwbVpr6lqqbI1tWa2WrNdrjo9fsr29zf7+ATrya8TJQlQqQiGaMBblFUy7YYONYtI4IU002STh4CAnijsuzpd88sE5dS2MqCTJ+rnYbw5XYMSN9ddHxJv4/VWjvHEovD34wTjM2KC/LloIr8fxnL29A4wxnJ4OG2ivQTUy6FfHHaTaWMeOPI1QhEbeTuoElG9VqLTk0yKN85FplCXYyJHdv0730XPSmzfg+SGfdnw+jLuTAhCUFkzcOYFjcH7iijHvnPVUQAmDcSJPapUj8XxVq8WdK+ycxM1ouhpU6BgkDy/y3ohS41ZVDq1hXZbUdelD9ddjWm++cZcnz4/4/e8+oaor5vOc9z94wNe/9qNMphnf//73SbOcd955jyydoJTizp07fPe7v0/bGi4uSn7t1/4h6/Wa6WzCm2+9wY/+yHscHx1xcbHgk08e8P3vfcjh4RG/+It/hIP9G/01ulf8kE28ceMvSnnIyCejA6sjfMtovgt+O2CRSimMUnzv5i3qJOXHHz/kncNDTJryrffe813gPX3NG7mimJDmBVmWsbezTZLE3L37BsvlitV6yenZKVVV0bYdbdugtXjHQbceLUnHNIlFhTDJNlQ40zTpPT0/bUSywlk6a7CRNDmWxGVY+KbnqIfmJ7KBGZzWtC5QaZXXC7F0nRjuUKiitCIiQieBg209thz5wjSvSuoXdTCWZVmyXq/Z2tqSiDDLWK3WrMuKtqnJ85RiKrrkTVWJwFzTUFUVkdI8fvKALC34hV/4BVarFS9ePGexWHDz1g2WiwXL5ZLGdv1YhSKZ58+f8+1vf5v1es2NGzd47733+mcUGsg0TcNisehzRqGw7sGDB718RtNU3Lx5o+/5G5rAC9yi+ukmld4KawxRHDGf5dy8tUdRZLRNw/HRBSdnl3Sm836IArWJr4vTHZgrn26IQz5soEOGufDqZz7t71dJB+MjQHSvw/mVUr69XyGb82rVb9yD/Ld+5fv6Jh7+e9PYK3F2Xe/Fj3N61jkSpaQncxT1sGmbx9RpRFzEtLRsffk9eP77nzpWnwvj7qDvXuIcYDzHWWsCOdBJXD68B7+7GhE1JYmwCNgaKVDk2BaapqMoCr8Z+AIKBWmWjR7iMPjSp1SkWsc51QCKaKVIs5y8yDi7OOLFi+fs72+zs7tF2ZTcvH2N23fu8o9//Z/4jLnQzObzOe+++w55LoqGP/VTf4iDgwPm8zmRlxUo1yV/77/5+zx9+gKAg4N93nzjjVcw0VePzUa5VydtkgobwRhLFEOcxqRRTNfWvnmAT/T0SbNBmQ+leHCwz9P9bb705Am3lmv++O9/h9/98W+Q379PUQgjI0uFvbFaVyyWC168fMFquaRtBWfuPE/aObwH6Igih05Ck3EHRjzitnIsLi9BRT2uaq2VRiV50euQiAca+0bB4rHnRU5e5BtaOcZ0BKVRa6XSMvabu3DqpZLZGIMjJNOVb4w9GBHrHF3b0rRSrm9tw2q1omulwKcz1itANr0RUkpzeBhTFCK8dvfuHd568z4X52dUTcPh8QkvXx7Stk3vhRaTCacnx7x4+YzL8wVf+9qX+ZEfeZc8T3jy5AlluSLWEWkWk6gYp5SXtRAhr/fff588z5lMJhwdHfHOO+8wmYiTsV6v+4bvaZqys7PT6wShLH/gD/wB3n77bdq2ZX9/V/oDePjT+PsLBtAGL9sJ5TNLM+7ePaCYxqzXLasTA0bTNALPxJGTJDMJWjuiJPE4u/MRltBarxYUvWIvXuOtvw4vH0NV4d+h+5FMbbXxHa9bQ+FnGM+mabi4uOibZ1816GGujj/bw0jGkMSAsXQd9JfiHQzcSE7EF2M6JxCisoqqiGnpmM8mtEqh9rZfOz7h+FwYd8B3W7JDOCKbu9ycVX7H17hYCYQTdCyUL81G/FrdGXAZSuUYU+N88+TeOiNemlSlDiXSIC294jjqE5CvhniB2ezY25/yp/70L9C1LUpLJxdn4ezsjFs3b/ILv/BH+qggz3N2dnaYTmf9713X8a1v/Qvef/97VHXJj/7oe9y6dYuf//mf5+nT59y+fYt33nnbh7zWT5DPDi3HYev49zDZijzHmI62lZ6qsU8cDnj+AFs5F2hbOVmWiTb6/Xe59tvf5u7jR9x89IiP3niTTy4uWFxe0tR1j5eLAXU9W8M50XfJs4KgYd60NcY0dE0LSLGSQrw/4+sQomRghYDAM+v12idHh+riosiZz6eidzOdoVAsLhc0bcPJySlnZ2fyrEHaHFrRiL937y5b822c802oFwtWq6XAcrYbbUbWJwXD7zBMqACFgWyyjiGRLu8zpmOxuGS1uuTx4wdszbco8oLJbMadO3e5fv065+fnvsH5mrZp2N3b4yd/8qc4OxFt/eVSPPdvfvObbG1t89Uvf4mdnR26zjCbz0mSmPVa4JjT01PefudtETTzLe6Wy6Wf43EfRST9BheuVIzf/v6+l+ZwvWGPfDOKKIrpupSmqfoEsXOW2DdsfvbkFB1pJjMRxtI+jyY+le7Vo6SVXzyc3wVm0+ZcHq/Bscd+1bu++r7w2utgkaswy/hcVyGf4K1nWcZisaBpmj6vAZuRRCj4eh0sI46IaOE4i8gfqM37tU6QCmn6rXqqZJDN0D9yl/Z3vk/kFB2adV3zWcfnxriLddb9bq6UD32dpnUGF6vewCk3GFmQSaOsCE2pNmIS75OSUnaiDjhmEUSxSEbGcdRP3DGsETjwbpMIK3/12KCxlocfP+Q3//m3sVjvPcZsb8954437aB2zs7vF+fkl5bokL6T92uHhaR/KXVxc8N/8N3+fupYuQQ8+ecJP//RP8uUvf5G7d+/y7Nlz/uE//B8p1yV/4pd+CZ1EfVL3sya1aGdL31j5u0Jph7EtVV0RcHWQRKT21aCCDYsxn822vRxqQhKn0k+1qlisS/7+W29x23bcOTpl+z/5Tzn+8pcpJ0W/iLGWWIuGvHC2pfu7dYa2KVFW+lfmiVfCw9H6DccYh45jiiwj9l1mjOnousbrsKdMJlNmsxnT2QSNYjqdsLW1JU3W25YHHz9guViwWnranxKDZn1uoCyXmM7QRCWPbSfqnrt7xGnGjevXmEzf5OTkmCdPnrBcLvwCxY9pCOWuMkSCMTEMBh4P3YSko2wCTVNzfHJEKLLLiwl7e9fY37vOvbtvcHm5YLlccHF5znq1Is9noi/fdsRJxpe+8jWOj4548OgRP33nFovDQ7CGc3NOVTcsF5copcjSlChSzLdm5EUqm7Qv1gv3AP1O5TFvKxi4AhVyTtYNTpFSgBLFzUjTtLbfvDvr5d5cTeRiVstLvyGEdSb1G1qF/qIJkU76vrl+dQ7wDK/30K/i2J9Gk3zd0WvqsLl5vG4jUUr1bTKNMZydnfV5lvER8hfAqEG2jK3GSMMU5yS2Ngas6iXL+8JLfw2JjlBxBBpJlgLKKWwrInKT++9wMv8NusML0iiGg73X3mc4PhfGXaF8QwGFazpsJA16lRLaSdAasQ5JoBpL4sTY2gh0pqVFqnFoFWNtStOJQdra3kHrqB90pQd2QE9TRAY4tO6qqk+X0gwT7Nnz5/z6r/9/5Dv8A/+xr/8o7777NmdnC/7hr/0jHjx4TNt2HFzb587t26xWdU9LS9OUr33tx8SLKwqm05wsT3nx4iXf//73+Na3vk0cJ/zBn/gJgRdGk/DTvJbQCzZg7FcLqcKRpimTyYSt2ZzJZMJkNiOOM6pqiTEddd2yWFx63HhF07SjKkPFycE1VNPyVtvwh5485jtvvMlJnvpr854aeLrn2pfgC40x8Rhi29VeTkLUOKMkxaTCaGq7jqZtieOELEuZTAqm05lo/mhNkRc0bcPpyTGnp0eUpWDczjnhvzvZ6KM4Bq1GobLXDVeqjxJOT084OzslK3KuX7/BdDbhrbfeYnd3l+PjYw4PD7m4uPCeez/iV2bFphhWyIMoH12GGqerz8Raw2V7yWKx4Nmzx+zsbLO/t8/1G/vcuHmdrutYLRYcHx2zXC0pioK9/X3eefttynLFYrFkPt/i0YOHlHXL9vYOi8WCuq45PDwkzRLSNGFvb0/yiqO5LjCIGKHeuPaR7XCtYkztKDoJSUVJWDuf9O6bkSj6/sHhdWmZ6OtTep0ZjdbSbSxEEFfx6isrb2Ouu5Fh3GDq9BvF67F1Of9mMna8YSil+oYdSZJQVRVlWb4CtQA+D5RuQIfyfX4eOIiUA+Uwru21351znigyzIUoirw87dhpDc9DoOQuL3j2Y1+lenzC25OCbn/rM8brc2LcnXM4pYjs2N1hkPKNtU8LgrK2Z4woBREa2xi/22sSPSXRvocmitAA1zlRedO+scPrHnwIwV73+nBYjDXcunOLr3z1S5ydnaMjePON+/zMH/5DHB2d8N/9g1/j8nLBzs4OW1tb7O7uUhQTbt/eYjKZ9Jix8F5l8Ws9CCq9+eZb3Lx5m+3tXfb39rHOc6w9N/0q/DIeR9kQFY6ox6Wnk4ituWY2nVAUBZNJThxHtHXH4vKSwxdHVE1FWS6pvEa685Vz1o4nc0yW5Witebq9jX7+nK31ii8/fMjv3rnF+XzWT24/cv1iFilvwbiN31RlsxamhdYxUZaTZgnbWzvs7uySJuE5Gqqq4ujwBV0rG2Td1H1HHPw9WwVEMbFvaO56DMV67W6NMW1vtHxtIM45ytWah598wvNnL9nd2+fatWu88847vPfeFzg9OePx44ccHR9SluvR3AiJVf9snLwWLsk6BcGYjQxj/7x65pMkLw8PK46ODonjmGkxZW9vn0k+5Y033sAaw3otPOqz8zPyQrjWpjO8+4UvgFI8efqUjz75kCiKSdIIpSy3bt1CKSncw8NvwyWMWSRicKUgqNucW04RpAHCPWgdEUcRpH4krAgIODUUVoUipbCmBKeWOZqmGVpHvnvTejQ2jlhr2Tz8Rqx90lL5aw4MmCEKlTqQHmDt7fz43uS5SGPsgRs/9tyVz11sbW1RVRWXl5e9Nz7+vuCtDzmdgW6qdYQ1Dowh1sKCqmvRnNHRJjYfIKE+qcprNib/7JRz1DiOvnCfo+vXWZ/d4b3JUAz5uuNzYdwBdGdRxmEiYS0oJ/CHtqA6Kf9WWuEijUF5XFOCYKU1OoqxTpMyR5uYtq3IMvEexkkWnCNJkt54hUMpaXs2fpjh2DT0YJxlOpnwK3/hzxKSA845zk7OOTlZ8o1v/AEvFzxM8BB9wDDxpZLQh2h98YIizwuKYkYcJ8MDd2La5SI2rytMhDiOfRIwZjqd9m3KnJMuSxfnZ5yenlLXJU1do4n6LjdlU+Jch7V+n/TJxCxL+4kcWCZN01BZw/t7e9xMEm42LV99+JBPbt/i8c4OA3Sk0Np7az68D9himqbM53Nm8zlZlpNnBfP5NsYazs5PWVdrFotzzs/OqOqGqqrpmpI889BCv8k7sjQXGqAWTFc482N+t3jtsrAH8SlGRlfGU9hS66dPefnyJU+fPuFg/xpZXvClL32JunmHp/5vy+Wl3yhGDwT6Z7jxm9rclMfn2zRA8nvTNHRNx2KxJI0ztra22N/f5+DggDt37vhip5LD4yOOXr7smzXfvHmDr3zlKzx48JCqqrh2bZ/bt28P3z+kl0bnHDxhCZSHN4xhjPFtbdAE/YTUWkmDizjpMePwgeA0BWZO0FfpOe5+DKyV7lVd2/TzLChUBs8+ECKUx7i11kRq8Py1FnbTVSMped9xQd/ms8iyjO3t7Q0I5nVV6kFeOqzfwLjbfLaWKLI+Z6FIEln/4w0zbAihQjfcfxhXYXc5X4MhYztNYn7m9g0+ma04urHD2+n/fA2y/6c7FBCB0QCOyLghvPKTRnnjECO61w7Q2qFimUTWOBKTYW1KayRM39ndRb7R5+C1lHJLxnzYzQGUhwjaRhKj4v0O+uJDSK04P7vkH//6b+OceCPvvvceW/NtsIad+RzbJ97c6HMiZKRU0GeXxTSIB4VEXHjQzoe0LUkSgdLDdfpJHKKAceJHkmhSHHRxeU5T19RNy3q1pFwvxdB5FkekFV2nBecuCqzt6DrrGwQnGNvSmYq6MVjj+kpfMfSGKFIcbm/TAm8+b7lzeEypI0729vyGJBZBKZFFLYqCyXTKfD7nxo3rzOdTuk4KblbLJU8fnXN6dspivfBl/J6r7hxppIiztN+kx4upbRupS1AS2vbMH7yQp7MbhnQz4glVzt74WYezYmBfvlzx8vAZk2LK+flNrl+/zv7+HrPpnNVqxfnFKefn59R10BAR7z2w+YZ8jh0ndvprUEpqM8Lf5Kq9JjmyyTZty/HJMadnZzx69IjdXemctL27xbX9fbZmW0KJbBrOzy/42td+jC9+8UtYYzxkMLLoG/BEWHhh89O9qQ/9AJyPtKxTWGQdir3WRFFGFHUDxxtxvuI4Q2tpzi7nEYOuPc3V2hatk76z2fh5SM1ARJKmqN6VcX0XJOekxiBID1sDXdNiTL3hPYfvCnTWOI56oUBh3DqUdr3jlaYps+kUawwX5+d0bYcadVIaM2aCt37VIOMs1rRoK8lnnO17Rsj7TA8Pj5k7YzjqKkyktPJeu+ohtSJK+dHtCJQi1lfhwc3jc2HcFfiQJfJcYwmz0Q7nG6NYG8pvFEmSkkYZaZwyzQum2ZQsmvHy8JK6jLFtIw/BGA8B+CYGShFFiTfuIekY9N0jj7G1A2bGVbxOZnfXGX7v997HOcf29jbvvvsjKKVRoYrPDbARbGLk8hzHYmJBRnUTRxxCQKniy/Oc3d1dUaZzsF6vEVXLwjfjXlzB/YaNq23r3nvFRwkD/iphpfHJ2CiKqOqariuxtgHVEkcpiojXep4KTra2qLXi6598wt3DI6ooxu3tM/U0u6IQ+mJgIjVNw9OnTzk7O6H1FawhWrPWDh3lldf9cT40VZsCYf31eA1zZy2m8/fF4D9L6DuE1GNPa/geh/XOhRhlLybtFMvlgg8/XPDo0UP29g64fu0WBwcHHFzbp6pKzs5OOTw8ZL1eeSOjhvFxrm++MTzzYd4HtOQqxVd7yYQh6rTUdcXLl1IUljwX3v9svs329g537uyQJAkvXryQa1mtaJvWOxTyvXY0brJxRiPK6ODLysYy0I4lgna+elxGVgxxPFxvb4w3ocL+Xr3zMe4z+unH4HmD6ns4iJ2IepgHO8yBMO9DZOacOCPWGBrv/YfIAUBF2jsZN8A5HvpoR2yEQCjKb0h5nlMURS/UBpI8hcFAoxTaddKjoJPnLeMT7mRz3l312MOxkVcbVikiaigNTXCim/WD2lZ/Low7iKlV2kIUmt5CrBPyJCWLc+b5lGk2YVbMmGYzJvGEzJd2KyLOLkoOX1RoJX0IpUUefbwpvgmkaUZQlRwGXpGlGbu7+xwfH4+MxnB9Y2jn2rVr/PIv/zJA339yeB9AzNDkw1vAHg8nuEf+BOJNSFPsmKKYek7tVIx5nPQec9u1LJervkAm0LA+iz0gE96gVDDuwScaeZpWypoCR9taeQZSJ6Z64wdgOgOxx5S9PkiapsR37xLv7fH22Rlf2N0lNobyrTd5ruD582ecnLxkvS7pupa6biRqUUMBRwjxxwnqMKDOKzsOhikknmRReUd9dC+DcR9gEz0sIiXGK+R0vL3y7e16MKGfHuFymqbm5csXnJycMp1OuXHjOjdu3GRn+x3efPMdmqbmwYNPeHF46LnkciXGmr7xsvbFd2L4fdUrDpRIZqg+yRlCdNvfqyxxyV+0dUtTVywulxwfHTOfb7G9s83+/j47Ozu9WNhisZB6i6rE2uC4yPy3NsAkwbscGQsV7lsKDK0N81WuLzS3Cc/P+uc2lgcI8y/AdDI3pcI15CuG76T/ruFzn3L00Mow38cOVBRLF6Q0z/pn6XBYIz0EkiThxo0baK1ZLpecnJzQtE3vrXfW+Kbmltls1idNx85FgDO7rqXtKmxToa3BtB3a61h1XnI8tONzgHXWJ5Bl/Qz3sFkRu+l8+KDSb2ZRFG1AT592/FDGXSm1A/yfgK8gM/bfBL4H/GfAm8AD4C86586UXOnfQlrtrYG/6pz71mefQDPL50yyKZNsym62w7yYM0kL8jgnjVOZEG7AWYMxUBacUxy+PKSqappGDF6eiz4348oxn8i56l3I92nfE3P1Cg46fl/4rt3d3Q1PwL9BJt1IKW/jTGFCeq2KyWRKPhGYYmdnRyoVm6Yvt1+v11RVQ9u0feJGoKJXJ//rEsTDSYWZEfIMLliXUfFT8OzD5Ir08D47EnKKE+155TMmkylZVrC3tye9TYEHz56Sfuu3mJ+c0nz8MY/2dniapz0AJlFTYCyMvZSggTPeSIf7Gm9i/c+NAfA5ATdyQfvBD3IM/jt9Uq7fTNDgTL/5Dt2CNs8bIq2ua7m8POfy8pxnz55x8+Yt9vf22Nre5qtf/Rp3va7L8+dPOT8/AzsURg0euuuLgKwLWjcWY72/1utqyM8+vHcQM5QSOwdt03BycsLp2SnPnj1jb2+P69evM5vPuXnrFkopVqsVT5484eTkhM579OG+xKP0eSwftfqeOAxNrUOifKCBbkZRUsgUioTGEdH4SQn2HKAN+o1m47m+Ei2PHrN/Rr3R3EgK+xEbOSO9HwXEScLu7i7z+Zwsy3jx4gXL5dI3x442jGqo8Qjc9ZCLG29egoVbVNehreghKSU9WZUzUrEbRTS1sM1UFBPFMdbLV4TzqFGx3himGXoaQyi2E1hUbbzv044f1nP/W8CvOud+RSmVAhPgfw/89865v6mU+hvA3wD+feCXgff8fz8J/Af+56ce28U2v/SVX5bOI0oTWd+Uw/mScWP7UndrRQNEo6WhsoKyrji+EH5v17bg/IRFPLlQ/RpHEUkcSagfPCZ/GK+i13YtoVerG2FrfQJ0AxIIEx96D2QDo5fzZllGMZmwvbXFfC6ewNbWFnEcU1YlZ2dnvHjxjMvLS9brStq6abz+R04Sp/SJpB7HHY7grfYLb+T5hoVnRteubJjAw+IaIKKhFBoFWZaTZQU7O3vs7e1LcVEcoZQwWNbrko8++oB1ufYRRYVRcGtrzhdevODeaone2+HRwV4PUwzj5UvQnR3uqffcfWbXzwGcNzgMhiP0Q1U4gfO8Azxyuv0hdc5jqE26I1lfuSxUU4kAQpmNAzVQG8cl5IxyMYvFBYvFBQ+ShL29A27fvs3Ozh5vv/UWb731JufnZzx88JAj782HTS0YV+tEedL5PJLye55oyjtCV8kg/Omcwyg/GOB1yeVD1jrKsuTJkyc8ffoUrXXvOOzt7XH3zl0O9vfp2o6joyMWyxVdK2JnsgYCS2ao9xDueZjTg9MCwgwRqKIDBXESi4T2qHmG5Jrk31EUkWc2IP2eQeXhr37KDp58WHebc3l4r7/r/lkNbxzeH46iKLh//z7T6ZSXL1/w7NmTkSaMaFmFZxygxOCdy3t85OedIGutqDhaI4qOJL4NnyL1ieJejC+OfT4iQY82P9vnEuijgbHBVmGXdaqvYVH9GtUj6ZTXHz/QuCultoGfB/6qv6gGaJRSfw74Bf+2/wj4h4hx/3PAf+xkZP+pUmpHKXXLOff8084R6YgiztF2MCqy8BTKA7DOiE5a0G0PLdrQ8PL4lFbsNaYzFEXBBu4sWTXpNK5V30CgH0CGhI/AJ2PPI3zFJs9V/r7p7cpkFzng6XRKlmVkmbAdxlhdWdU8f/EBy+WCslz1bIBxBh7feE15nmwQrhqHbuDhhTCJlPINTjYjk2GhAv2WJjRHpWXAHc4XMU0piinz2ZYvfhFWi3OKpmk4OT7mcnHBei0CU84NYyMeuCNJYk6znO/EEV9+8oQ3Dw8xOJ7s7/fX1EdfSuH8/dvxolSy+AP+LBvb4Fn1/w6/+71Wq80CN+eCUJxfkHaAx5yzAsV4Ay/P3evxhS8cnWs8H4YwXf7etg0vXz7n6Ogl0+k2169f49r1G+RFwRfe+1Fu3bjD8+dPOT07pfbFZEpLlyYft8h5CHbb72TBaNngLGhvbMcNKXxx0Oi+A8Z8eipJ38ePHjObTdn2vX3v379P11mqumK5WLBYSN4maOnITFE4JEEtENzYy5Y5FOSxxdjHHnIZGEp+Bg6buodwAue7j6a0X91O+e94vWEfvzbQCcd5q/GGQk88uHbtGm3b8sEHH3B5eQl03lvX3p+QD0wmk54htNlBym+sxmJbaSikcdL31m9cYS50YS2icVi010a6arjjWDOI9g2vD165rImuEzlT66y0Du06VPTZTBn44Tz3t4Aj4P+slPox4LeA/y1wY2SwXwBB3eoO8Hj0+Sf+tU817uFxjRdRwPuUklJdpzUWK56Oove8Lxdrnr04kpZhqzU60uRFDhuGUhZ9lmUE+dselIU+MRmy2fBqaHj1deHvSug2n8/952NyL5yVJIkwKs7P+fjjj/sKymDkh81hCMUkySI8+tgrG4bJG+yYhIYj2tTomlyPqcsRjG7YdGQiW6z3YuMsYz4XUau9vV2SJCJJcoxxrFclVbXmxYsXPHz4kNWq9CXs1idG5bzRiFUgz1I8DWctiyzlO3fv8M7zZ7x1eMQyy7nwXHjZFByuZwqMJoSTDdxF4qWJ5rojjlPfKWto87b5jGQUZC5dnWVj3RzPQUdMJCEyUCJnseH2e09aa6/tzqah2cRHZfNYLM5Yri549vwpN27cYGd7Hxzcun2Lvf096rri9PSU07MzOlP33mAwqVLfIriqsXjvPeDwnnV19RKt6b1+5e2mQHEgybyWs9OKs9MT0iRlZ3ube2/c5/69O0RRxHK5YnG5pKpqTk6PWSwuaX03Mmsk2SxJaTcALQ6UEm9d5pnotzs7eNIDxCbj1HXGb9aKDZEwM/beNw3562AadWV9j+dQ+GyWZT0Ec3p6ynK59FCq3IHxhtk5yLKEyWRgwzjneoqprE/pFYASTSTTidqsJqzd6Mp1Sg5HKe37A2xGI8HhCjmQobo8bCLSLN2YwAwEjfIJ6WijCOrTjh/GuMfAjwP/nnPuN5RSfwuBYMYD7tQPSt1eOZRSfx346wD7u7vyoODK5BwSYD5Wlay8AiJN1TR8/PgJq7plXTWs1yV7nobnRmF00GNO01Q8fuc25pV4jZZyVfn+kEO4Mzbmkc/Ua625d++eT1DJNUZRxNGRNCaWqraKzjeCuIrThZ9BYTBgacKHlVBTEdgSo0SX35MGeGN4vc8Pj4xOuH5jxGDkeUGcJBSTiefSF+RZznQ6pa5KDwsdcXm55PTkjKpe+wWt+rA1SWKc036MrkxmO0AfyicrL7KU92/f5N2nz/mDH33Mw5s3+OjGDTqnvPHZzEsEwyFr33thQNO1tJ0jz4u+ofPrDPynHeE5bSQNAe316YOpF5TDB/xhR1XOd2DSm+M+uo7xmIfkdV2tePTwAS/Sl8xmc3Z3d0U6YTpjNptz4+Ytjk+OOTs5o6krPx6GUDBkjIAOsXIeQhuNj9s0bD1U4aNO5SGvUBncb17W0TY1J8dHnJ0eMZlO2Ts4YH//gJu3brA1n+OAk5MTPnnwkJOTUxz0eRflF6fzsgxRlPSbXqjVEMO/aXjGWHZ4zpu76PCZAOt81vN81QkbIorARZ/P5zRNw+Hh4WvqV0LuQwqXxDnbTASHzmEyzkZ0pPwm6jphxkil7uB9jxt4K68TIyUVr25YomCaeIft1XksG5FGRxFRLFX8Wiey1sLNfsbxwxj3J8AT59xv+N//74hxfxngFqXULSAICz8F7o0+f9e/tnE45/428LcB3rx/zzknLcsUfod0r+7YAYcHRWsdHz95xvm6pusc69W6N7xBA0ImoizMyaTwa9Zj7W6TbuWs6w147DHuLMu8yNeg3d00DXVdcXJyxGq1YLVa9WJCoduTMW6zwTaq37BUcK8IyRHxCmUDiAQmcSNVRjbHQfa5kShXeN9oowKBMpI07avisjRje2uOUtAZSbAuF5ccvzykqkqapvZwlcYYR9N2XhtkCBEFT3UId3lTfc+5zu8t4pFF2mugm45FEvPgYB/tYL5acef0lOc7ezQ+gRAiNceo2McijVdwBP1wa0MnIzdgzp4mGe69h4jYhGfCePawDF7V0Mlm6sLc6F1SvD+hGDoXhfXkgRQnWH+kh0hmGH96ayxtB0XmYDabsb+3z/7+HvPplOsH12nqhkePH7NaLTm/OBtplHgH+AqsZq31cFpYE8N5x/Mk0gywpodDFMGxkLFbrRYs15c8fvQJaTbh4OCA7e1dptMZt2/dZGtrSwTbyhVVVdK2Igcc2viN4YZNT3tz4x887s3frx7DhjV8x1jnaRwpbR4yT65dO+D27VvUdc3z5897ivDmesKv55jJZLrRi3aY07b/aYzBmca3fBQnM/F6RWMWjcyvwamUqNb6/gj0Rj/AO9IgpRklU/VobOT74mRoHC50cBlErf4nwNydcy+UUo+VUj/inPse8IvAd/x/fwX4m/7nf+U/8neBf1cp9Z8iidSLz8Lb+/P4iiztcciNXcmvKtFYUdSd4cNHj3lxek7ZdiyWC5RWzOfzDYMjynOa6bQgSWOGRI9AFUFIaXt7m62tLdq2pSik9VlZlpRlyWq5ojOtSLp6FTxrO6qqZL1ebngkUazQkVDfIt9cRB68I459iKaFax96Tw6Vqf798APCrWFsejjLJ7YE48+Jo6SXcZXNqMYaw8uXh6xWl5TlmrqqUOA1tYP3qgiMpDQdl2e/6kmNo5HQ6kwMh/YJ7BCmS7n36XTKRV7wzukZu0vB6p/v7A7ca8CpMdc7YKEed9fCGe69ICKMj3osjuiKgQ+Uwn7v6y/db5zOQzDIBmCtRUVB1S8Ms98s1DDawTA4AitDeZrg8DcZlmDFbF+7YR0sLs5ZXl7w8sUzDg4OuHHjJkU+5c37b5BmCWcXZ7x8+ZKXL196jSPnsdsAwY2eg/cOxaCofr69mhfCj51vTRkamKggxKexzlKVax4/fsSTJ09JkoTpdM7e3h6z+ZydbAeldnutlaquaeoaM2KMDZ5v2JSvzFs//uoz5vewUTk8QZpNVtfrDXuSRGxt7bG/v89iccnz589GDar1xrgoJay56XS6EYkFGEYMtnjT1lroKrQbGlpHyjfzHkGS4z4B8RWMPWD3Q/SIt0/B2w8Nvq1Awzg60/l8hkRyyopyqnHhuj7bsMMPz5b594D/q2fKfAz8NWSV/OdKqX8LeAj8Rf/ev4fQID9EqJB/7Yc8R3+ME2X978iuuaoqvvfwIYfnl6zKhlVZo51if2+vb8g7aFvAdDbtS/HTNO156WIAsx4HPzw8pGlqmrYF53pD7kaTdIythgRsSIZGUSQJ20j3kErY1YfqPOdx9HBnmxNXjqHYaOxtDId4HHmek/guP9OZSAlnWYbpDFXd0LQNF5cX1FUlXle5pqlLCf29vx9r4dsqHTxoPxHVlb31yoIKi0/GW4yEdYbQzT7YwuAlBijERJrHB/vcOz3n+sUl87Li5fY259MCtPaRG95THYXw/cIIHpLqn41/e//cHdL8fFyVuomP9ypFBP8+eOPWmFeGPHw+0trPBbk2GzRKHDg1eG/jnqLKjSOFUUiOo6xKHj95zJOnT5jPd7h18yb37t/n7t073Lp1i9OTUx4+esTR8ZFw5vuIUxb5MCZjeGowIMpvlIHiCGrkIdLbWvl72OwGFljTNKzXh5ydnbK9s0NRTDi4dq2vkA2RamjnF8T2ghFVfULabyBX5tQPOvoIiuHn8Ow2E5N5nrO1NQOnefToEVW1Hnm1mw9Ua+lHG4TNenwbRtr1Guc6urbFtqXn+ct3aSVVrxDE38bj7Xr0APAMLoN24rgoXz2tQ8Lc31uvMe8x+LZtZQ5b6x0QeX6dk7qSwHeXPgaffvxQxt05923gJ17zp198zXsd8O/8MN979ei9LheqPL0BAZyC1brk/Y8+4vDykuWqZrlcEacp27v7IuvaJxB1z0W/cVMm5GQyoa5rlFLUdU25rnj58lC8Wmu9ceqvhKthpb+3fvIHT3nMXtGR8p65fHzM+YVQsfbqA9kMZ+XDAxNnECpK05Qsy5lOpqRpRhxHpFlK2wrP+eREKj4DTDTggC1DEdNwj+KBjnjhOIQtojzssclp7rrAMFCgJFknHnWIACRxFiqJQ5Ww8xxy5xx1pHmwt8MX2oaDxYK0a3HscTmdCkbsi1uslXHsPWnGyoMK8B5xgCOUBHza85KdVV5/xm48v8EjU76rl2flODU49SMPL0Q30trXL3zriLQXrbNu5E0HiqZnQRCu2xsn5RPZPkIIIlbnF8cslmc8f/mUO3fucu3aTZIk4+6de1y/doO6qTk7PROmTVX74qNBQE+m/VhKY0xMCPTFzTqBYDvHsKELQn39hmdxrqOpS0zXUpZrsrxgZ3eXPBNRtzfffLOvywgFQRLRhshA5tqmsX69w7D5mvPf4YDOj3Ew7iJPMJ/PuX79OlW1ZrlaslwuvbM1RH7jI1AcBQ7pNhp3wGCsnTXgOpypMW3XRz9SPKSxo+g5HJ3vqtRz1ZVGWcPhs8dUVcOt+2+g4vAsTO/4yfMLhWoiraKUIvQncz6jHpAp5wQWU2i6H+C8fz4qVP3u2Ydr3nNXSkJfg+L07JyPHzzhYl2xWtYsFysiHbE92+rLchU+q60Vu7u7ngGSsFwuOT0VLfUgCGTN4FFdxWU3jeDm0RswRe+F96GcL6qI9BX8s981XvXEN8JFhAYWRzFZLlQn6Xof9Qa+qSVxfH7uu9pjRVvlClVz8xzDsMo/PB49WuxyHRpH7P8ePEG/WEZetCTm8Jh4MBYDNGF9sk/2p6EuIIxDF2m+e+smW7u7XF9ccv/klGqx5Ps3b8gYqfDsfUiqRJ+8CXjvBtwgT1AucvDgh7Fl+I+AN0v+IBgyWUxDZ6GNzTZENv1+L/caokvHEDn05/Feqjgris4YT9G06EiJdokevPkgjnV2JrTFNP2Q3d19bt26xdbWFnM15eaNm6zXa54/f87R0SGr5ZKxBxvud4z5CsaLZ4ENzon2Xc1Qo40g5FAIEIOfkb4fr3WAsdR1zYsXL4Qh4j13SRJP2dnZ6VliTd1Q1SK7bd0QYQxcrk0HajxXB8zeEeCmcSQbRxG7u3u88cYbOBxnnwiRYZj7r3rroelMOIIwWe+s4NefsxhbEyNIQWeF3RPkCPpq6bAhukGIblCKlHXTrktePH7C2Ylsyu9++Wt9USVsSiaA712sQhJ2BHmGjS0gfc4R6c/22uHzYtwZQm9rPX8UUNrRuYinL4958vyQddmwKtes1zVxkrCzs+MryLz0qhZ1yNl8SprFLFfS9GAwXpthq3gWg1ywaFYPC3vswY0NYQhxo2hghwAoIgYpUUZGJtwjjCd0oD+maSoqibMttBYNFqVgsVgIu6FraduOqqpo2np44PKtV7DN1x0hlA0hs584eNVNrXFK+04wGmsQ2VJZ6p7KFXmjpfp7lGy+LL7QS7XrLMbUpHEEOkQu4mJYy9DpCssiz1jn1/jCs+fcOTllnSQ83N3usXCCcbWOSCnyLPP3LB5c8Ij75T/aQAYGg+DJIZnoMwMe7xzYOkoJG6HPAXghsVCUE4w1jMQbtK8UDd6UkshMKSmUE2oksmn6YhSswjojaqb+6hWaQB201lDXa168KDk8fMre3h43b95ma75HkqTcf+MuN25e4/JiydHREZeX50huoBsZdHnGXef6+RFolMEj1v1c8PUVvlAwJJmVUsSxwJfWaWmQ48abu6W11neQOu81WLK08LmfgqKYinZQU9O2NVVVYbrNiFiGdJNqPDCxBthSIi7HdDpld/c6WZbz7NkTjk+O+7aBMIaF/EYQx8xms75JeDCoVxOhOFGlpamIEREwawVSSeMYHQkW7mJxAoR8MKALYa23rTS3jrQmK2Z87WtfQ5uKZ4eXGBsQiU2RM4FaLM5JU3Y1updeRweJDkzoETz6/KcdnxvjrjwoN2Y8rFY1j54fcnq+YF02LJYrjO3Ii5zZbHYFipHWebPZrO8nOfZix8Z6/FqAQAZvwZsKN3j0m7CJHGNK3eBNBqxxeD14jyF7HiZVaJhx7dq1HutzFk5Pz2hbKMsVy5X0ILW+2jZcixqsWW/kP+tBX00mBSM/4K7OJ/0GBkq/8K7cn3VDDYIYeF+ARCcFYp3nV0ebCnhhUwwNrfEepFGKD27eIDGGGxcX5FXFg/1dVolITgi/XJgZNhT6eA9ZcgXeCbVKwtfXRS6MCsQ8+6drwxia3uOXObj5vMdf18NrQSdEXhzNI3n+3rcHZF5aZz2kM7x2FYbYnFtBShYODw85OTklS6fs7e2xt7/rIbqEN998k6pcs1otOT094XJxifPc9jHcEr5zY/64V52WUEPoAK0ij+3T9622OOmnoF5VMgRYLpcs3RLtIcvpZEKaZWzN5+hoW6Siy5qyLHs49PVR8mgu+w03z1Nu377J3t4+F+crnj19xmq97CPn1z13aQ9ZjAqtxiJd/r49tOfaGtvWKN/LQEeKKE7BSuRjhbQulc0EqqlGx7ofNGlKIu0Dp5NtMp1RX1rKxZq7d+5RWucbt7g+PyjNyOWeA9subNDW2h7uuRqV/S/Gcx+8JlAWjFM8OT7i8dPnrMuG5bIUfBLZuWc+gQiBiqVI0pj5fL7RbOPqggmvjw/Xh4yWoUHvJlYecN/NJgYe0hl5MxtevPcK8jxnf3+f/f393ntYr9csl0vm8zlaa54/f856vaaua9q2IhQ3oRTOeo9aroTBAx+M8Cslyxv357wg2LjabgOnkHFXUV/0Eu6pz0NYMBissT27ZkgUBlhGuPSdaQkiSeF6xkNurZWKVK0waNHtjyK+f+sW184v2Vou2F2WNNuJeDrInBBjary+dRiDQVrCB7ZekW9IvCoV+cpX7TdsTRSlcp09ZqnxDE7/7A2B/oi1o0RjuKegBeDRoF4rxQofvXcUJDJ0dsBYtd6kLvpgCTcWNrsyT6211NWKF89LTo5fsrW9zf7eNZI4Ik4i3nrnba7duMHF+QXPnj5ltVrSdS0Bhw/OxaAAqQkyC2Mv1/n5kEQp2vOzZY57iQIXYUzUG6bxnBvmlkTfZdlS12vffzRna2uHPCso8gnz+Zy6rnuKZde1fSet8DyCxdQ65taNG+zv75FmMYeHR7x84ZPMQWuCzbUaZBfSNO0hLzG8Q2Qjom0tzkLXGpStUFipc8FK3sQ3HomcOGbWSJV471DGAm8lSQIKtDMekmlpViU6zZgWB0zSKcRTYtuwXJ9i3KBRL5u47efF+FoHz16gO6UVsXq9muTrjs+FcXfBTdSaxeUlHz15xuHFOauyZHm5xFrHZDJlZ3unN5Dj0CrNMra2Zhs80o3vvvKz9+KCC7OBuauN94V/jxfk8P7ABNBEkSZJcvK8YH9/XxoqVBVJkjCfSzu79XrN8fGxb9vW8ezZMy8gNC6rDiFpwNoCDgmEhKff6YfM/qvVfK+PWkabhAperxVIxgToJOCcbjN68f/bCGUZfg+JVK1jFEPxVZDOFVGpxFP3ov4ynG8AXkYRT3Z3yIuM+2dn3GhqLqYz6jShiWLKJGHtNwoJiZVo3Ojh2sOiHW/AfXGIsjjEQFkfHg+HL+V3DmtEVXBzvDbn6tVCKMVI5IkQ8cgYdt2m+uEAjQwsHe9kb+Csm3NcLsVaQ9NYjg4POTk+ZTabs7O7g3WOSEuXrHv377M1n3FxccGjRw9YLlcbToe1Dq1sP42ver1C6Y1RPgeB8pz+UCnrgiM0XOtAKrg6VpamqanrisXinCRJKYq5GHlfODSZ5GS5rOnz8wvOz89p2waFJklirl+/xfXr12nblu9+933W6xJnQ15ns0pYouOoV3IM9yXesYzlwKIR5XxMR6KD0XYCVXrp6zAGxnZ4+Zz+PGMnsg10UF/wl8YKW55RmYQozVFqRtsJ1TJSGiLZDKy1nn45bGZjWxPGNly/QGTDmn9FuPDK8bkw7gDrpuPpiyOevTjicrXkcrmkrNaAI/e7/Zh6GAZ4MpmQFzlBO+TqcdWow9UdLxQMDQvzdQZSFmG0ee5iynQ2ZXt7G2edtIjz3VyapuHi4sJ37VnywQcf0HWN56fKJBhXpQ2haDh3+H1c3j+GV8Tb7v/mnHiuzlcm+kRoSMaG5Jqs1wAbhHvWflxjgmKjJCmHBuLayWJQvbdkxeP3WKy8SY2kCcD5UFP7SKDrmv56Ay1U9H5iOZ+Gej6nKiuoa3bOLymMoYxjyiTmsshp0oQujlhkqXhZHhYKWNV4c5d7DmGvZ0/oYS7IxmOIVEwQsJIIZLzBj8ffcZUnOjYu/bPRnvEUtIAih4q81+w6v296SiVB4nroUhSM0OaGoTauw9qOxeKcxeKcly+esrt7wMHBNfIsY39/n3v37vPO2+/y4uVzHjz4iNPTUzFs/jlK5OV6yEpGSBFrjVYG63yOJIqxGKlB8JXTEHTgI8aSHTL+42R2mMuhnL+kaTouOPeN2EWKIi8yimJCnk/Y39vn7OycqqqZTCY4Bx99/KHIIXglxcHRGVaPVE8nvbrqGN4Nhr2vzXAK2xlcUwMt1rQEeYRe/rjr/KYtz9IqRWct1nTkSSrRWBT3UKASa43AKxqiiBZDZaSSdd3WrC6OKHKIpgXSjCc0MlH+mUr0FyLBsPGHyN21MifaptuYG592fC6Me9Mafuf9D1guS8qq4uzinKZtiSLNfGtOkU/6G5YmAZo8L5hOp36H3awMg1c91/HPV/HOwTMdvFZ6e6tQxEncextbW1vs7Owwncx7PG+9XtN1DY8ePXqFkjh4u7Iwx5vM2FvbfFgDfUz445sb1NUj4Nj45Fnv8SF63aHaVBwXf//9V8m1yRh42MV0CG4Rrs9grfFSBrGPVjZlUp210C92hbEhGhgVuqiRd+qL1SItDAgRSbJ8uLcLwHbVoKOYvctLFlHE7fNz7pyf82x3hyrSWKVZFQUXWc4yz3qIZmxw+ztUr2rD9HHMaF4oNXjMvcFWgRkBYWKE5zlQ2oYKUDuKHqIoEpplD2X5a/Fc5c6Jbk4SD5omV5+zs+5K4VGYF/Ls2tbw8uVLjo9PmM/nGGOYTmY+uad45513uHfvXt/wu63qjTXRBxZO5rrc7Kjyl5BUHrDgOA4J68HbfN36Gke7LswRFOv1mrJco5SiqkqKIiNNM65fu9nDlUpJdW9dVSNvdjjn+DxRFPVsnfEzDdIjY00nBRhTE/tnahHZ5IB3Wyvwo18Ocv1u2EDCJhGgEryjoH1kqXCkWYZt5D2dtXSmJZ+kJFR0pqNqO4m4PFe9/74+Evfxu3WvzOcA04z7SLzu+FwY97ppODw+Y7Ve0XUyGGmes7u9vZHVDuyS2WzKZFrIpMNudJgJx6vY+uZCv/qaeL9iAFGaOBn6kJrOsLO7w6SYYKx0/Hn+7CXGPkU65NSsVmu6brPv4utgHaXi0e9jnfHA2Bk8c+fGGHrgvV/l79reYKCiAXG5snkN5wgTUBFgJec6n/hrPaYumLlyQgETLrvoyojWhfYejuuLeYIBd2YwcmH3EKEjEwAvFBCHheAkUuiM6Z+n1hHGWC69mNt5GtPULbWCF9tb7NQ1adsyqUr21iV7eYqKY9ok5bQo2F6ueLC/R+QcVZL0C2b8LEK0EzbDoYecGPhx2zZjN0vTh11R2s8FT1wgD+UrGK0nwATvWFg7DDCxBDv+uRhje+MVNo5+LowSjOPoa3imcrRtx8lJzfn5OdPplFu3brGzs4Nzitlsi+l0i2vXbnJ5ccHx8THL1QVB38dZhYp87oFgir1XqiMIlEgr0JtzYR4P47SxIY2M71g9NcBmw3rVXpFSDNrx8QlFMWU2nffOw97eAeCoqpp1uaaq1q9AErPZTBra+MY2V5PFA4tI0XUNTbvCOOtp0UJNzTLpxUo0cN577rt/ppGWzUPmh8fhtRQ3dV1HZwxZlBLFCYnWWCukgSRKQBXkieayqWk7Q+R1aQL7JUBJsslbLxo26LiPWTJ9b9vPOD4Xxr3rOs4uzrHWkqYpB3vCIFHO9YsqSQRTFDwtIdCngrZGOK4adXnxyq9XDH0cxxT5hNlsjrXWd0KaEEURXddR1zXLhXS8aduWtm2l3RWbMNDrkpmwWWk5eH/ikdHznfWVCbnpUQbDM05kDufxUIq/rQGCCd9N/52hQjF4gEoFGt6oe6dyaBURxZLsy7LMV8N5qmPXYRppYeZ0oJj679AxGtWfQ4+48CANHZQalf77ZxiqLp212P6BOR+mCnvheFIQxxEvtUJ1LWlnmFcNTRpz//wc23VsXy6YtC1vv3hJ1nW82Jozq2sO969TxbHPIYdtxFMjXxsV+ejDJ/LH8Eg/f1x425CHsc7Rt7bssWDdNwgfzuEGL1Er32lqnDMaRXKjyxpYE4OuSYAqw/wKvQlWqxVZlnFwcMC1a9d6GHM2m3Ht+nWOjl5yfn7OcrmQKNNHKTLV9Cj0H+59/PvV8diMUocxDc7G0B94s3n5eD2K7EfF2dmpVGJnmUhQz2ckSUqeZxgrCdmyLHs2SVEU/XeMGSbhGobmGCKZGysvzGYDfCaYeHAgh3UkNqhuO6I4lupR7wAFaWR81NZ10oWpbVsuyo6HLw+5ef02kzQj0uCIUarGWkOW573+0tghDOcXpkxLyHOF8R1X4f+g43Nh3MPNzefzHmoB+h6GOlJsbYmsri8Y9+HdAMeMj1fDQ/FSexRba9I0YWtb5G6n0ylpKi37qqqSdnaLBWfnFxjT0dTSHcleOY+c49Xzvu7+XgunqOHeP43x4txQJNFrXYzeJwZhMC7hMwNGjEdWxjz3kH0PHaoYGSFp4h3H9K9X1dpfn/ObiEJhiZIEMYAGrX1SUY8MqBI4wplWDJ0CdGg3EPpueu8Z7RuyBO9ZC4vEjbo2OUMUGDZKUyaaKsvQCt6f5DgUurOkrSHrGm5cXjJtGmZVxf0Pv8/RfM7333yb/fWaay9f8PH+AU2ssQPpfETPC4VqIrsbxnSM3VorFMfOBva8RasYXOSTb4NmyObhKZO9REKgtsUY0/jQK+4dAe0UTl1xJNhMpG/OG9m2rLWU6zWPHn3C8+dP2d3d59q1a32V5tb2HtPpNnVdc3F5yfnFCU1TIVx9J/UPfh5Jsnyz1VyYa1c3vledLb/+VHBABpnnzSWzOY/btsGYjtV6xdm5tDaUpvCxX8Np74CN8fVxf9OxtysJ3oquWhP7CueuM0RaoaOotyVhcwjzwVpLEotq63gVDyJ1oCItWjMK1p2hWjc8ePKIf/LPf5e9nW12d3dIoow/+KMHEr1jwdNNx9c93rCts8Q6Io4C5VLgMgJE+Hpz0x+fC+OutObatWv9jjns+IrJZMJ8a7ahGx520/B7fwSo/MqEj+OYSCdS7edpWHEiDysUQJyfn/c4YAj7JAQdG93N694M0Yfzbf791X+PL/gqdPNp7x1vWK+792AIXsGae7aIeiU8lc9ZMUZq7DUGrvawkMddeiASvBCBluJ41GBZqcE770Ny/zfn6EJnm77xg8xUZ61UvKqBqhYqgAPPXY3GV/X/82Pm/21izTrSLFzEybRAO8e8qlgt1zgUnbOkbYO2lmlV8c7FGesi46Pr15it1yzjGBOFaxtW0NVxHTsVEQFSGqIC12/Cm3Ng0/v1NFwvYWBtx9DjdDxHQlnfiGHDQGW8alBlzlqfVJdztW3L8fExJycnTCYTbt26xe7eAS6S9nMHBwccHBxwcXHOar1iuVxs5ISuGvbxz/HxaYY/wIHh38P7N38fj9V4nK21nJ83XF5e9O3vQsVpgGwDfBHw68ATD/xxaw1dK2SCMd1QR3EfXQyR0SZBI4ljT1QYopNIDxuC7SM8X0g50/ziT7zDh99/wPPzBTuTOevykvNmho5j7GgTCtcf/h3OkaWpNJNRkqu1pkMh1EsFP9B7/1wY9/BAwuBGkTRdns/n5LkwYRzulQEfJrTqQ149wqeKYkJR5D0Gl2Yp69WKqq5pF81GA41hIkpIPCSLRAwrTMDPihLGr31a4vPqMV7wm7guryykq+d+NXHFK38f/3vo3j60knNOo3116vh8SnmZWxfonuH8ynt14JTzvHOF6r1Vv9F4bFlB32HJ2sAMAKfUYBKtYdCy2QzzgxSybB52gHPCeGmG5sxKKi2ts6Cl6MY4xVmeczGR2ohYWV7ubfOiyDFtw8FCU0cx8/WaN49OuMgLHh3s8u7hSxaTCc/nEyZNxzpP/Dxwch2v8ZwEXnI++glRjvd8le6rXcVpCDkP08NiUug0cJ7l+UUyNi6M4yatdXMOAL1HHxRHRzkZf93L5SUffHBJnj9he2ebawfXJOloHQcH19hqt6mrisvLC8qq7PHtMJ/GRuXTotKr0OdVR+cqdHP1/Ve/J/w0xvgOYFIINJ1O2dra2lgj4W99dOUGeFchzp7xa1w5enZZpDXGbW6aIYkakrLhO/v/jHTBQkOaJUKn9GUqtl5z7/o2b969yfZ8wkndUIUxG9m7wWFTPVQU8Pco0mgVY6yh6wxJGmGcFbkM89mu++fCuIcj6DPMZjMmk8ngKbD5gMeTTNQYpdfozs4OVVX1u3Wo/Ly4uMS6rsfPXwfljI/hbz2o+qnv/zSc/bO+/3Xne93nPm2BjCfy1ZB47NmPvyPs9P1E9/c3JOs28f2A/0qBBSPsXAy0U5velfELSiGYakgmBr5+8ITH0YHSHpLyz1jo50Nh1rAoQYW+oUoRWuEFzRdFECsbNiaLFWGwK89IGjVa2jjCOM13bt+S7+8syyzjZDYjtoaibWDt0G3D/rrk4c6cSd2gjOHRwb7MjNHiDIbCjvDvMY1SqLpiwkXu4mqFoaewMkRhzoXnOoYvAp/8CtzjNGgb4gecA9MhmigqwFyB5y3vqaqS+mXF+dkZs9mMGzdvM5vNMMaQZTk3bhZ0XctqtWK9Xr/SSezq2L5uzr5u/l593+vWyusig9cZ+nH16WvzIv798r5OeiSbDjdSjXTO9atAOVAjyrW1tqc2Bw9b7I6HToy0znTKYT2jKbTcOz27IEaTJxmr9ZLGKVzkFWLdEAGM6d3huruuw1nJYUWuo7NDAnZciPVZx+fCuCvopQNms9mVBOTgnQsEEBH/f9s711DJsuu+/9Y+59R9dU/3dE93ayQbaYSEg6yALQyRSAgmTmRJGImAMTKGSI6NQx6Qx4dEgyCQb3ISQhwIlkUe2EGx5Th2LEQSkSjOxyixHVuWLY3VE780I830THff7vusOuesfFhr7b2rbt1+iJ659za1hp5bderUqf1cez3/q+3Y3NhgbX2Nvp/RdR2zac/B4T7jODLrp+zuTelnswq6F2oGVmACgpnVoVzx++L/lksnyxbv8kUfomzNPJdL9vOqe6WwRkhUOrro43vAUsae1fiUSKpA404k4xqjJ0aVyk9jXjjGWFNxt6onJ2GMTEeHHUBJncVRDwdqtnEJNL9gTjVKoOuaMStSwg1jLMPPoENPEug6gzsVOlR7AtFRMd4GgqSOhNebTdhB4MzVWuA4KoPbu30Yh7bj+Te8wcdv5HevXqVvGramMzanM3Yna7zp9h0u7+5y7nDK165dZUjCVCvnlkvYZdIiuqllGMzsYiXptPocA5pTmyUh1qZvdB1AGkItCu0pOThddrCLZs0pwobVHS7BDKKdZpIISV+tBN+tm9zZucvW5haXLz/F5tYmIh1t0/HU5SvMnpgx63uvt+qF5Kv1ukjHMeVFJrbs+nEa6uL3gFwtKaTqGggMilknDiUrpjNjGEdDaR1c+8taowkLxJrV5MVYdO5gi2ujjgwok27iM6oM48jYz7hx+w6Jlsttx97BDnLhMskDE5okWXpvHcl0HF1bbSxarZ106KhMZ4c0k45u0jEO/X2F06BTwdxTk7I3H8piCFjdiKKpK6ZsbZ0DwasITQ1Uy+PKjyQzCWhlPzQKhltBOGVV0b+2EEK3aHOs6V7mETscSip4QBwsW6y19JG/oPX7o7959Pfq6yUmu7b3qptkQpBUtKoYE5jRxuiMnzSu6jv3iphnBqy4tNKstQzueG6yDTOkxUSJCBqJLFaDWShdPSqp4m0cIaRQdRNGHMyA0oDHGqemJTUm4VveTkl40aishCBioHGqiqWyh3SrHLQWFre93rK9sc6oI1+5epU/9dJLtDrynd/4JodNw/NXn2Lj4JDbmxsVYyhhf8GyNXwH0hJFQObWjGrWPMr8x2kXsdm9J9VESGucJAGE5mGsWjTbeY3PAgnCCVnG2kZwHGccTvd44cWvWxGbJy6yuWmF3q14PFy4cJH19Q0r2nGwz+Hh/n3X4ZE1zXLt87iD4jhtuL43tJKowhaO1HC2hgYIdiA0eCWkoc+hFmMfBdQVXEIWBE0F9yWbfjxPo2kaK4jtPsEU4506Lr7xGfpe6Ie79Ds7bJ6/hGo4esU5UITAlnKbqmpBdBFs0SS6JiHV+OSErHvQqWDubdtlD36oUOfPWxUYVXN+rK+vc/v2bW7cuIGqcufOnRxz7mLPPanWBozcnkmE7c0vvPp791pU95IqwqyzZL3mtiyzPc7bvtX3eHjmmyP3H9kUKnk8jK970J8m0CGbFIaskYSkDJHJWW8og94104gEBKuap1+CieOIgmLhjiklJEd8FKgHEUNaFLGY6TqUNduy85wUE05KgVcTzl4qKVkNAwax2nJh7CfRRMyyj59FJIYmIxDZqL5ZA92ydjBHPd7DpuN33vgmkva87ZWb7KfEW165xfpsxrTt2Os6njg4YG+to091FFNhcvPrz/ujYbICJExhFk/eRIbkWMYQikSa93c+vOKg8gQYTEQ3WIGJBSaIVTSzw8afZSvE7cdmn7+9fZudnR3WN9bZWN9gfWOdpkmsrU1YW5tw/olzoBaMsLO7M5cbsKhBHmcyWbx+9LMyfvMkeRxqqjN7ox3FoWomwiRx8CWGtiE1DeLC3+A4QH0OWhiZ9WZbD7OIYtE16uuqtu/XJqJZb5F261vr7DRrbDQdihpEt2e7p6bJ+7z3QvAZOliV1DSsuzNXtRwepZbB8XQqmPtkMuHNb36zlbXb3WVryxDwZrMZL774Yq7yUpDk6kmtxb7yzOXM9qh0voyO+659b3mEwLLvFcl/MXxx+W/WFBl62T4t0ecwFc0/ZF5KcjU/6+kAyaTv1JvULSAYIuKiMyoqvYTqb5Io1BpOBHTksMAKsbFtGsPBmJl9O0Ia/RvVOFLsIrkPNdOrcUvEiyTMm27C1h0gUsXgYZE8qmUPqNqxMKpn9GIwqyUTs8xFXl+RqSl2KPSqIImvXrsKCBcPDri4s8deN+Hc/h5vvXmTnbU1rl95Kv9uGkee3t7m1fUJhxsbhLRdxkEpYFl+PiEI5ki2oiVH7atSmbJUQ/ov4ZUR/mqQwmbSS01THNBuWmjc1NeIOaXjXjPvDOzt7Vqhjj0rTbe1teW5D2vs7x3y5JOX2NoyKIHtO7eszsAyoaNa28ftzeXMv+DB2EeFbc3BCkC2wYcZJQ7FjKw4JGbTGQwDqj0zj3JpBMPdT5HNbULU2Jtdf9CRWT+Qkj2361o02cqJineLQt+lpy4hKIf7BzTnrzKkhjZZ8SHUUDiHsa9s6OQ+GEyChz0K2W1ldngLuRzuU63jvsxdRL4D+Ex16a3APwR+zq+/BfhD4IdU9ZZYD38KK7W3B3xUVX/zXr8xjiOvvGK4zG3bsr29zauvvsp0Op1DMzxq09bsbLXxOqoGLkrV9T2LJpf6u0vG4ci1xUV4lOFCMONcfm7hmcfZGeswtJCsS13Ro4fL3DOkymn0F+PQAya1m42yp23IsfMhBRpjmA+1lCS5CLRJ3vN40uKLbk7KdkZjZpcBHevxtuSoWmvJ0yj1nHiscblMiZqyGDHbtGGqMPyaprFY+4DWHUfQMZWDTo1xBuZ6Gc+ScIOag9OwQ0zDGHJcupdKFOXmZMLNyxNQZX/ScXcy4YbX5sRt4hcOD3nniy/Szqb81z/9TsYMhwzQMPRW8DprkOK7WUZ30tZr3B2qc6qLR5PlQfJn6+hRSQNd081JtG3bZuEjbNbG1Jt84Md4xHwcHh4ynU65c+cO586dy+n+bdu6LXug7Z6i73v29/bZP9hnNit4QqUPR0MpFzXYeZt92NFD0Jk/HOuKZ4v5IsHszfnqNvmmo0lNLl+ISF5XOprmNKofQmJRV03b0vohURy5PbkmhC/gOj4+pZF+2pMk0dYm5+qQTZWGKIgnQw10XQQJYKZO5NhD8Th6kALZzwHf5YPVAC8AvwJ8DPiCqn5CRD7m7/8B8H7g7f7vzwA/7X+Ppb7vcyWV4xofak/Vrng1N9nHUSymeoCOY5KLi+t+DP/IQeGqcDZZiNVVjdjkOQvKMW2B+TCzMizlt2r8k/p1jZZnDMYgGgadminLTSvjMNCklqjSHolKAW5WNriVmQss9KNmqcD1cVMKViqxH4zh1qGKpd/RG38PiMcNmznGMgjjK+Pc2ggtwbUgLyGoLu33vflSNLl0PirqSJTS2uFliXAhciVXIEz6TY04Vo//TvgrMJyeYegZB2ckqpitP9GnxPNXr1RMy5KBdiZrrA0D3Tiy3vfsV6nj49jTD8paM8GA30YG7UnSIB7yRqXRqMI4JPDDQJEMQIXb3M2/4U7vsQcRmmY9S4QlwkQz7pBBS9hYhN03TByLe3IYBm7fvs329jZra2tcvHCRrlvLAsnW5jkm3Rpve9vbuXP3Ni+99BK7u7tzIcf3Ms2UNRJ7Kvp11MQ5V8HN35cQWuvLwcFBiYlPCZqWpCNtY7APAJOuyxagUUFl5GB6mH0Tk4onlJj0qJBWJbVpWStj36M6MOpAt9H4gWqOVCQx9LMFIQeSQ4j0fW8HZ+UgjmeP45hhFu5FD2uW+T7geVX9IxH5EPC9fv1ngf+JMfcPAT+nNjP/S0QuisjTqvqN4x9bqjDZoM2nMC9K7MsWxpFDQZmXYDl+EeWvLFlY9fcW711qew8n3ygZAjQz5MoEsvjMWn2s+1wDRS22Z9l4LXtmSDCqLuG46t6IVY6qTR+15B3fg+KcKws7lWd5+naeI0rkgcESuMlBBEljLgIRWCyRHMJYzFAl6kGIVGxLavIog8pBZpl8ySKKUoyNOVPtwAnHojl/Dd3SmYxNJrlQtEtiqcG0jTF0w8BijwO3xviZNy0VYcOZUdvw1Tdc48ndXXofzxokjDn9k9w/g2JwE4E6KEPWrGKMzQlYJNbIeG4IdM/Qtuo1UiI0yhoJKTjuqzFaFvdh/N3fM7iArpuwubnBpUtPMptZ/sjLL7/M5cuXeOd3XmNnZ4cXXniB7Tu3MzrlIqeunz0nZGlc8/HxOdVxZDbr6XsDtYv7a0ZbHKszUppgpiZzTkfG+dj34IzXQmcGEgXWNyLu4rmLTH7xesyhrWvFsJuOaiU1Pkwxw0pE/DKMAZdt2lSSEvl0P7hfeHjm/mHg5/31tYphfxO45q/fBPxJ9Z2v+7XjmbvOq2qLzHxeRSu4zLbRj4ufTZWhCuqojKAHYfLHMeO4b+5zLWaUOL1LNk+Rvhb7U5ivHlkky9qyqH7Wz6k3an0I1PDCEireaDU+w3sf7SiLNyBP59tsTqUS9idJGGczkkaWoCDa0rYTZrNAIHRgLYTU4BKIzzUROz96qCbEYaa+NkZXl9fWzARj8eJ+GEXb8gGj+ftRhCQLAdiBFAzdrrht02Pyx9Glq8bDREexqKAqwkXz9yM6wosiA+6VrTQa4fqVK3D5MoMo6mWgbK4SKYUfyc1V3qqmbdABS4xSZRhCgqUcSAQyZcqmqpr5pMaYxfy8lrUTTGJxz9VUC0Xz67NI1MMw4+7dKQcHu0wma0wm67Rtx+7uHtPpjLZtuXr1KufPn2d7e5udnR2LbEk2K8v2V9mftoezqKbx2w3TwxlbW5q1gq7r5sw0oVFOpwduS29JqaGfOvyxOy4PpzO6yYQkngDlGpvNSynNVx8Yi+NX2/4tUMCCRcZxoEuNo3RaqKRU+7prWmZjnz1zksxk6OcavQPXJTHz6HGWhEV6YOYuIhPgg8Czi5+pqkpdX+7BnvcTwE+AYcocxUy594SHlLlMkheRnMBSfbNszPze/uaf0SzwL/xmcXYdbVv5vriDxf43zrWztPGolG3qfWXSUeakZDiqKSzaK4+ak6JdRXJumtY/aUAHwytRW2xNXpiCgXVFf60wsPfCy+QBDnZlEThqRTPUkmjatkM0MZuFVKOu/moedxGXVny4jMkLEW5ZTEsJZKAZMVvoKKQmpFOvIpUjocgMPjSlUWflOaYsm1Q7G71kGr5hBojDRk3qsv9aM/tIOWgWNR0dJWsjbhxCqJOQjFGMAG5KKtoRuS81JLFFnggpQy6HeS+glM2RLHEYVAeJrR1PeGkC2TMdWS9Q4sSDidb3LJoD4nph8D6XKREhs5b13bO7u89s2nPlylP5u+vr66hqZvR3797lzt07HBzseRvKfpgz30TUlHo/kmlUgJsZoesmrsWMOeEomHDXdezv77oQY+PWtB3oCMMAw8BhP2P0wuGN29qjHRFps6jJhtmnHPhmtovwSyGwadRwnBorLtNIgUoIDBlcS89cIg5iETsMXMsc1SJ3zD7/6JKY3g/8pqq+5O9fCnOLiDwNvOzXXwC+vfret/m1OVLVTwGfArh27Zprx/eOcz0iOfjkJ8fesPuWRxVEGv0RaRsyMw2mPN+EiItWmDu/xCXHYvopYYvL7fbLtIQiXZuUWcw3JVW/phqiYFFSX3ymSJEoAJpmgqpFtjRt8rh2f0bTVKeakprkSRWJxkG9UkpoKiGa9tdC9WZDxAWrVZtRC3m0whdxaCSHCxgt0j8OFB0Y+jDtRPsbDGrYQvREO2Dqv9mSUsSnJ2bDyKRrkewvIEcUqDPwWotSVTMP9R5njDlYSSWUDg3EQJeGVapDJEwEnkwkKWOAaF4nNka27twnkJmXEBEgJQxy9LBGoVHDHmGEQa2IiqRIN/e94M9thGxeSCk0gUTXFROWpJaIUor1UuMTZSFCQxsTP7CPrt0QOuL96NAJJcKqFMq4u7PNzu4dUkpceOIiV69ey9Ag6+vrnD9/not7F7lx44bFze/vuwQe7az9ShW+DUqB3oSD/SmTSYckzfbo+jDrupadnRmzWUvXraFjYpAJTeptbY+KNC2KQ+k6H4lMd2tD7FE3mSzY9pMHHBQHP4w6kFzi7vspKomD6SFdN8kacWhUuVykFuCyLCY4XEEJVKDSUo+nh2HuP0wxyQB8FvgI8An/+6vV9b8lIr+AOVK39Z72dqPFqJdigihM6qiEjttYpVS9kcQiLO4yE4+EiB06cPXcpqkWlHilHLGNbEvLT2qPc1U3R1BpEyHZxKa2j5fZxn0jVUUi8oiM9lthdrB+mPSGOx3F+1BXts+qbEhiWmyRi5Ch8+Nkf8tn5EUlaV71FInXrdtQHQ4iWTx9wsq1mc19yG0jH6qSfzMyj0fi8LL+lHloXZPo81yP3s/UjDBXhauKHHLNZRyNhc87oHwd+DiN4+h26MFx7WNT16iU8+sEwqEXfguNqSuRK1lrizVdhJRoQ87E1WICqE0oIf378nJtaCCYal73+cBJeR1D8jkU5te//a1DBzXGoxZalijkZX/6c1Q987bea0WYGoaBmzdvcfv2Npubm1y4cIGLFy+yubnJ1tYW6+vr3Lx5M0vd29vbngFb5rRpTI/Jwo8WTWc6ndJ1Xfb9TCbdXN3gWKu5PGPTWGWpfiCJrdNmrMIKhWy6jLkKZmxO0cKPStZqRM6YpmBauC2ZtjUUyLZpskAF8zH6tcBW79M4MPGDLhy89VgfRw/E3EVkC/hLwF+rLn8C+EUR+THgj4Af8uv/GQuDvI6FQv7og/wGkVRC2BJLB2oGX0sNih3gdsIDuHRzJHZ6ri/2NxWuHjHC5sioMKyD2TW+mEevK5nbljwuOCT/EoceDHWMOOlsMhjn++DzG5svFqz1V9xcE30ht01CaoSsoka7aqYe5gQhWTzzaNmMEWERY5p/23SoijkYLcKn5izPVBy/YQqQsUGk8QgKUBHE8cxV1cxBIowqtI7Ihw4ujIVdVFxybEF7U6XH1hn/aLgpeRw1S1Fhew7gM7CklTrb2EeI0efU9mcUJw5GFUUTYqVZSOLoZoJ4Xu0oU/Vi2F5/s/iGYm5SnrOUWkQNO4TG5gbMhlvX/Jy3heM1Y3toHGCM4v8wH0nJAh5HpWltvkPTWtwH5XXZc1mw8sWX94w7kcXXDc7AyHvABB5F87qtZZlxHLl79y47OzvcuHEjM/nZzIrcnD9/Pv9+ZJzHZyHYJM+ZCOHOGGyfBb2UWgJ+If4NQ89ksmbPPDxgc/M8pMRsGJjNDvNchW/H5r84ZlNqcxtMCCiMvkQW2XhnkDU1rXAYehhG1whMixiGWkiaz1YOpMiIlrH168llo5vixAqDTP3e4+iBmLuq7gKXF669ikXPLN6rwN98kOfWNGcq0UgyuXeYY15khDQUYX7zz132W0X+Dqk6ZTU0DhSLQohFVL67CFRE3rzxbMkSdH1IxW/VNsu5Z9Qv/fNl5pb8O9WYLUY9xG9BRExEKFmJyinjLqCJtilag1SMIu4r78XyK0J7yszex0lBGovtVYCp4bngDGNUt89XtvLQTppGaNvOHpKw+PRwZA2tj5Eh+I2jOWGFfo55RzhlHPa26cdqAxeTRPDuMm6RIVo0nPkQN3GTVSRJJZKYz2I2C2dbMVPMr7uQkBuv6OM4/W2XnaYBdhdS53yUS2hBCQmsomT1X8OE0XVdZu5xMNRawuJ+mH/2fL5EbfbLax6Z+zwo2+xTYzVaxcsouvakKugQvpLEdDrlxo0b3Lp1iwsXLnDlyhXGceTWrVuoFsfo+vo6s9nMExiHIhTNabkmva9vrBF+jFpDFWnY2NgwzWA2o5sZHlK3tsZUHSXVndk6FK1k2TgZRHhXMl79s6hMlvFimhYGM6sMw0ivPd36JLepnt94HxJ7mHxCYAlGH33PuT/jvW3ucj/R/vUgEbkLPHfS7XjE9BTwykk34hHSqj+nmx63/sDj16fXoj9vVtUryz44FfADwHOq+j0n3YhHSSLy649Tn1b9Od30uPUHHr8+vd79Sfe/ZUUrWtGKVnTWaMXcV7SiFa3oMaTTwtw/ddINeA3ocevTqj+nmx63/sDj16fXtT+nwqG6ohWtaEUrerR0WiT3Fa1oRSta0SOkE2fuIvI+EXlORK6LQQefehKRbxeRXxOR3xOR3xWRv+3XL4nIfxORr/nfJ/26iMi/8D5+SUTedbI9WE4i0ojI/xWRz/n7Z0Tki97uz4jhCyEia/7+un/+lhNt+BISQyP9JRH5qoh8RUTe8xjMz9/19fZlEfl5EVk/S3MkIv9GRF4WkS9X1x56TkTkI37/10TkIyfRl6oty/r0T3zdfUlEfkVELlafPet9ek5Evr+6/uj5YCQtnMQ/rM7d81gBkAnw28A7TrJND9jup4F3+evzwO8D7wD+MfAxv/4x4Cf99QeA/4KldLwb+OJJ9+GYfv094N8Dn/P3vwh82F9/Evjr/vpvAJ/01x8GPnPSbV/Sl58FftxfT4CLZ3l+MGTVPwA2qrn56FmaI+DPA+8Cvlxde6g5AS4B/8//PumvnzxlfXov0Prrn6z69A7ncWvAM877mteKD570ZL8H+Hz1/lng2ZNehN9CP34Vg2d4Dnjarz2Nxe8D/Azww9X9+b7T8g8DePsC8BeAz/mmeqVapHmugM8D7/HXrd8nJ92Hqi8XnBHKwvWzPD8BpX3Jx/xzwPeftTnCKrfVjPCh5gTDuPqZ6vrcfaehTwuf/WXg0/56jr/FHL1WfPCkzTLHYb+fGXJ197uBL/LwGPenif458PcpaE2XgduqGlUB6jbn/vjn2yzAU5wwPQPcAP6tm5n+lRg+0pmdH1V9AfinwB9jtRG2gd/g7M5R0MPOyamfqwX6q5gGAq9zn06auZ9pEpFzwH8E/o6q3qk/UzuCz0Qokoj8APCyqv7GSbflEVGLqco/rarfDexiKn+mszQ/AG6L/hB2cL0R2ALed6KNesR01ubkfiQiH8egTD99Er9/0sz9gbDfTyOJSIcx9k+r6i/75ZfEsO2RbwHj/gTpzwIfFJE/BH4BM838FHBRRAKiom5z7o9/fgF49fVs8H3o68DXVfWL/v6XMGZ/VucH4C8Cf6CqN1R1BvwyNm9ndY6CHnZOzsJcISIfBX4A+BE/tOB17tNJM/f/A7zdPf4TzPHz2RNu031JRAT418BXVPWfVR8Fxj0cxbj/Kx4B8G4eEOP+9SJVfVZVv01V34LNwf9Q1R8Bfg34Qb9tsT/Rzx/0+0+NxKWq3wT+RES+wy99H/B7nNH5cfpj4N0isunrL/p0Jueoooedk88D7xWRJ12bea9fOzUkIu/DTJwfVNW96qPPAh/2SKZngLcD/5vXig+epCPC19oHsGiT54GPn3R7HrDNfw5TH78E/Jb/+wBm0/wC8DXgvwOX/H4B/qX38XeA7znpPtyjb99LiZZ5qy++68B/ANb8+rq/v+6fv/Wk272kH98F/LrP0X/CIivO9PwA/wj4KvBl4N9hURdnZo6wYj/fAGaYdvVj38qcYHbs6/7vR09hn65jNvTgDZ+s7v+49+k54P3V9UfOB1cZqita0YpW9BjSSZtlVrSiFa1oRa8BrZj7ila0ohU9hrRi7ita0YpW9BjSirmvaEUrWtFjSCvmvqIVrWhFjyGtmPuKVrSiFT2GtGLuK1rRilb0GNKKua9oRSta0WNI/x9R8aCypTnFSQAAAABJRU5ErkJggg==", "text/plain": [ @@ -189,10 +179,10 @@ }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" }, { - "output_type": "display_data", "data": { "image/png": "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", "text/plain": [ @@ -201,11 +191,12 @@ }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='object_id', ctx=Load()), ops=[In()], comparators=[Name(id='id_array', ctx=Load())]))])\n", "Worlds Table created successfully........\n", @@ -232,21 +223,30 @@ ] } ], - "metadata": {} + "source": [ + "### Example Test Query\n", + "filtered_world = scenic_world.predicate(lambda obj:obj.object_type == \"car\")\n", + "filtered_world.get_trajectory().execute()" + ] }, { "cell_type": "code", "execution_count": null, - "source": [], + "id": "7a6d62a3", + "metadata": {}, "outputs": [], - "metadata": {} + "source": [] } ], "metadata": { "celltoolbar": "Raw Cell Format", + "interpreter": { + "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" + }, "kernelspec": { - "name": "python3", - "display_name": "Python 3.6.9 64-bit" + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -258,12 +258,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.9" - }, - "interpreter": { - "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" + "version": "3.7.4" } }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} From b6a6d56aa80ddcd07579daa975323fa2517b77d2 Mon Sep 17 00:00:00 2001 From: eeeeenchanted <597380714@qq.com> Date: Fri, 4 Feb 2022 15:56:25 -0800 Subject: [PATCH 03/26] Add box class --- apperception/scenic_box.py | 104 ++++++++++++++++++++++++++++++++++++ apperception/scenic_util.py | 40 +++++--------- 2 files changed, 118 insertions(+), 26 deletions(-) create mode 100644 apperception/scenic_box.py diff --git a/apperception/scenic_box.py b/apperception/scenic_box.py new file mode 100644 index 00000000..48e14187 --- /dev/null +++ b/apperception/scenic_box.py @@ -0,0 +1,104 @@ +import numpy as np +from pyquaternion import Quaternion + +class Box: + """ Simple data class representing a 3d box including, label, score and velocity. """ + + def __init__(self, + center, + size, + orientation: Quaternion): + """ + :param center: Center of box given as x, y, z. + :param size: Size of box in width, length, height. + :param orientation: Box orientation. + """ + assert not np.any(np.isnan(center)) + assert not np.any(np.isnan(size)) + assert len(center) == 3 + assert len(size) == 3 + assert type(orientation) == Quaternion + + self.center = np.array(center) + self.wlh = np.array(size) + self.orientation = orientation + + @property + def rotation_matrix(self) -> np.ndarray: + """ + Return a rotation matrix. + :return: . The box's rotation matrix. + """ + return self.orientation.rotation_matrix + + def translate(self, x: np.ndarray) -> None: + """ + Applies a translation. + :param x: . Translation in x, y, z direction. + """ + self.center += x + + def rotate(self, quaternion: Quaternion) -> None: + """ + Rotates box. + :param quaternion: Rotation to apply. + """ + self.center = np.dot(quaternion.rotation_matrix, self.center) + self.orientation = quaternion * self.orientation + + def corners(self, wlh_factor: float = 1.0) -> np.ndarray: + """ + Returns the bounding box corners. + :param wlh_factor: Multiply w, l, h by a factor to scale the box. + :return: . First four corners are the ones facing forward. + The last four are the ones facing backwards. + """ + w, l, h = self.wlh * wlh_factor + + # 3D bounding box corners. (Convention: x points forward, y to the left, z up.) + x_corners = l / 2 * np.array([1, 1, 1, 1, -1, -1, -1, -1]) + y_corners = w / 2 * np.array([1, -1, -1, 1, 1, -1, -1, 1]) + z_corners = h / 2 * np.array([1, 1, -1, -1, 1, 1, -1, -1]) + corners = np.vstack((x_corners, y_corners, z_corners)) + + # Rotate + corners = np.dot(self.orientation.rotation_matrix, corners) + + # Translate + x, y, z = self.center + corners[0, :] = corners[0, :] + x + corners[1, :] = corners[1, :] + y + corners[2, :] = corners[2, :] + z + + return corners + + def bottom_corners(self) -> np.ndarray: + """ + Returns the four bottom corners. + :return: . Bottom corners. First two face forward, last two face backwards. + """ + return self.corners()[:, [2, 3, 7, 6]] + + def view_points(self, points: np.ndarray, view: np.ndarray, normalize = True) -> np.ndarray: + viewpad = np.eye(4) + viewpad[:view.shape[0], :view.shape[1]] = view + + nbr_points = points.shape[1] + + # Do operation in homogenous coordinates. + points = np.concatenate((points, np.ones((1, nbr_points)))) + points = np.dot(viewpad, points) + points = points[:3, :] + + if normalize: + points = points / points[2:3, :].repeat(3, 0).reshape(3, nbr_points) + + return points + + def map_2d(self, + view: np.ndarray = np.eye(3), + normalize: bool = True) -> np.ndarray: + + corners = self.view_points(self.corners(), view, normalize)[:2, :] + + return corners \ No newline at end of file diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py index 017f697c..e38a9337 100644 --- a/apperception/scenic_util.py +++ b/apperception/scenic_util.py @@ -9,6 +9,7 @@ from pyquaternion import Quaternion import json import os +from scenic_box import Box # Create a camera table def create_or_insert_scenic_camera_table(conn, world_name, camera): @@ -87,31 +88,12 @@ def insert_scenic_data(scenic_data_dir, db): db['sample_annotation'].insert_many(sample_annotation_json) db['sample_annotation'].create_index('token') -def get_box(translation, size, orientation): - """ - return: . First four corners are the ones facing forward. - The last four are the ones facing backwards. - """ - center = np.array(translation) - wlh = np.array(size) - w, l, h = wlh +def transform_box(box: Box, camera, ego_pose): + box.translate(-np.array(ego_pose['translation'])) + box.rotate(Quaternion(ego_pose['rotation']).inverse) - # 3D bounding box corners. (Convention: x points forward, y to the left, z up.) - x_corners = l / 2 * np.array([1, 1, 1, 1, -1, -1, -1, -1]) - y_corners = w / 2 * np.array([1, -1, -1, 1, 1, -1, -1, 1]) - z_corners = h / 2 * np.array([1, 1, -1, -1, 1, 1, -1, -1]) - corners = np.vstack((x_corners, y_corners, z_corners)) - - # Rotate - corners = np.dot(orientation.rotation_matrix, corners) - - # Translate - x, y, z = center - corners[0, :] = corners[0, :] + x - corners[1, :] = corners[1, :] + y - corners[2, :] = corners[2, :] + z - - return [corners[:, 1], corners[:, 7]] + box.translate(-np.array(camera['translation'])) + box.rotate(Quaternion(camera['rotation']).inverse) def scenic_recognize(video_file, scenic_data_dir): ### TODO: Read all attributes from the @@ -134,6 +116,8 @@ def scenic_recognize(video_file, scenic_data_dir): file_data = db['sample_data'].find_one({'filename': video_file}) sample_token = file_data['sample_token'] all_annotations = db['sample_annotation'].find({'sample_token': sample_token}) + camera_info = db['calibrated_sensor'].find_one({'token': file_data['calibrated_sensor_token']}) + ego_pose = db['ego_pose'].find_one({'token': file_data['ego_pose_token']}) for annotation in all_annotations: instance = db['instance'].find_one({'token': annotation['instance_token']}) if not instance: @@ -145,10 +129,14 @@ def scenic_recognize(video_file, scenic_data_dir): formatted_result[item_id]['attributes']['cat_name'] = category['name'] formatted_result[item_id]['attributes']['cat_desc'] = category['description'] - bbox = get_box(annotation['translation'], annotation['size'], Quaternion(annotation['rotation'])) + box = Box(annotation['translation'], annotation['size'], Quaternion(annotation['rotation'])) + # transform_box(box, camera_info, ego_pose) + # corners = box.map_2d(np.array(camera_info['camera_intrinsic'])) + corners = box.corners() + bbox = [corners[:, 1], corners[:, 7]] formatted_result[item_id]['bboxes'].append(bbox) - return {} + return {} def add_scenic_recognized_objs(conn, formatted_result, start_time, default_depth=True): clean_tables(conn) From af523f6e723dfe10e31149e9738e89667544810b Mon Sep 17 00:00:00 2001 From: eeeeenchanted <597380714@qq.com> Date: Mon, 7 Feb 2022 20:43:53 -0800 Subject: [PATCH 04/26] Update scenic_recognize to return two tables as discussed --- apperception/scenic_util.py | 56 +++++++++++++++++++++++++++++-------- 1 file changed, 44 insertions(+), 12 deletions(-) diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py index e38a9337..15a728cd 100644 --- a/apperception/scenic_util.py +++ b/apperception/scenic_util.py @@ -96,11 +96,36 @@ def transform_box(box: Box, camera, ego_pose): box.rotate(Quaternion(camera['rotation']).inverse) def scenic_recognize(video_file, scenic_data_dir): - ### TODO: Read all attributes from the - ### return formatted_result: {object: {bboxes: [[top_left:3d np.array, bottom_right:3d np.array]], - # attributes: {*attr_name: *attr_value}} - # } - + """ + return: + video_frames: { + frame_id: { + filename: image file name, + camera_config: { + token, + translation, + rotation, + camera_intrinsic, + ego_config: { + token, + translation, + rotation, + timestamp + } + } + } + ... + } + annotations: { + object_id: { + bboxes: [[[x1, y1, z1], [x2, y2, z2]], ...] + object_type, + frame_id + } + ... + } + """ + # connect mongoDB client = MongoClient("mongodb+srv://apperception:apperception@cluster0.gvxkh.mongodb.net/cluster0?retryWrites=true&w=majority") db = client['apperception'] @@ -110,7 +135,8 @@ def scenic_recognize(video_file, scenic_data_dir): else: print('already exists') - formatted_result = {} + video_frames = {} + annotations = {} # get bboxes and categories of all the objects appeared in the image file file_data = db['sample_data'].find_one({'filename': video_file}) @@ -118,25 +144,31 @@ def scenic_recognize(video_file, scenic_data_dir): all_annotations = db['sample_annotation'].find({'sample_token': sample_token}) camera_info = db['calibrated_sensor'].find_one({'token': file_data['calibrated_sensor_token']}) ego_pose = db['ego_pose'].find_one({'token': file_data['ego_pose_token']}) + del ego_pose['_id'] + camera_info['ego_config'] = ego_pose + del camera_info['sensor_token'] + del camera_info['_id'] + video_frames[sample_token] = {'filename': video_file, 'camera_config': camera_info} + for annotation in all_annotations: instance = db['instance'].find_one({'token': annotation['instance_token']}) if not instance: continue item_id = instance['token'] - if item_id not in formatted_result: - formatted_result[item_id] = {'bboxes': [], 'attributes': {}} + if item_id not in annotations: + annotations[item_id] = {'bboxes': []} category = db['category'].find_one({'token': instance['category_token']}) - formatted_result[item_id]['attributes']['cat_name'] = category['name'] - formatted_result[item_id]['attributes']['cat_desc'] = category['description'] + annotations[item_id]['object_type'] = category['name'] + annotations[item_id]['frame_id'] = sample_token box = Box(annotation['translation'], annotation['size'], Quaternion(annotation['rotation'])) # transform_box(box, camera_info, ego_pose) # corners = box.map_2d(np.array(camera_info['camera_intrinsic'])) corners = box.corners() bbox = [corners[:, 1], corners[:, 7]] - formatted_result[item_id]['bboxes'].append(bbox) + annotations[item_id]['bboxes'].append(bbox) - return {} + return video_frames, annotations def add_scenic_recognized_objs(conn, formatted_result, start_time, default_depth=True): clean_tables(conn) From f270783fc3d710b220710a40e823cd4d9227ec8c Mon Sep 17 00:00:00 2001 From: eeeeenchanted <597380714@qq.com> Date: Fri, 11 Feb 2022 17:13:42 -0800 Subject: [PATCH 05/26] scenic_recognize pass in a list of filenames & add frame num --- apperception/scenic_util.py | 69 +++++++++++++++++++++---------------- scenic_test.ipynb | 18 ++++++---- 2 files changed, 51 insertions(+), 36 deletions(-) diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py index 15a728cd..57c28cb6 100644 --- a/apperception/scenic_util.py +++ b/apperception/scenic_util.py @@ -88,6 +88,11 @@ def insert_scenic_data(scenic_data_dir, db): db['sample_annotation'].insert_many(sample_annotation_json) db['sample_annotation'].create_index('token') + with open(os.path.join(scenic_data_dir, 'v1.0-mini', 'frame_num.json')) as f: + frame_num_json = json.load(f) + db['frame_num'].insert_many(frame_num_json) + db['frame_num'].create_index('token') + def transform_box(box: Box, camera, ego_pose): box.translate(-np.array(ego_pose['translation'])) box.rotate(Quaternion(ego_pose['rotation']).inverse) @@ -95,11 +100,12 @@ def transform_box(box: Box, camera, ego_pose): box.translate(-np.array(camera['translation'])) box.rotate(Quaternion(camera['rotation']).inverse) -def scenic_recognize(video_file, scenic_data_dir): +def scenic_recognize(video_files, scenic_data_dir): """ return: video_frames: { frame_id: { + frame_num: the frame sequence number filename: image file name, camera_config: { token, @@ -138,37 +144,42 @@ def scenic_recognize(video_file, scenic_data_dir): video_frames = {} annotations = {} - # get bboxes and categories of all the objects appeared in the image file - file_data = db['sample_data'].find_one({'filename': video_file}) - sample_token = file_data['sample_token'] - all_annotations = db['sample_annotation'].find({'sample_token': sample_token}) - camera_info = db['calibrated_sensor'].find_one({'token': file_data['calibrated_sensor_token']}) - ego_pose = db['ego_pose'].find_one({'token': file_data['ego_pose_token']}) - del ego_pose['_id'] - camera_info['ego_config'] = ego_pose - del camera_info['sensor_token'] - del camera_info['_id'] - video_frames[sample_token] = {'filename': video_file, 'camera_config': camera_info} - - for annotation in all_annotations: - instance = db['instance'].find_one({'token': annotation['instance_token']}) - if not instance: + for img_name in video_files: + # get bboxes and categories of all the objects appeared in the image file + file_data = db['sample_data'].find_one({'filename': img_name}) + if not file_data: continue - item_id = instance['token'] - if item_id not in annotations: - annotations[item_id] = {'bboxes': []} - category = db['category'].find_one({'token': instance['category_token']}) - annotations[item_id]['object_type'] = category['name'] - annotations[item_id]['frame_id'] = sample_token + sample_token = file_data['sample_token'] + frame_num = db['frame_num'].find_one({'token': sample_token})['frame_num'] + all_annotations = db['sample_annotation'].find({'sample_token': sample_token}) + camera_info = db['calibrated_sensor'].find_one({'token': file_data['calibrated_sensor_token']}) + ego_pose = db['ego_pose'].find_one({'token': file_data['ego_pose_token']}) + del ego_pose['_id'] + camera_info['ego_config'] = ego_pose + del camera_info['sensor_token'] + del camera_info['_id'] + video_frames[sample_token] = {'filename': img_name, 'frame_num': frame_num, 'camera_config': camera_info} + + for annotation in all_annotations: + instance = db['instance'].find_one({'token': annotation['instance_token']}) + if not instance: + continue + item_id = instance['token'] + if item_id not in annotations: + annotations[item_id] = {'bboxes': []} + category = db['category'].find_one({'token': instance['category_token']}) + annotations[item_id]['object_type'] = category['name'] + annotations[item_id]['frame_id'] = sample_token - box = Box(annotation['translation'], annotation['size'], Quaternion(annotation['rotation'])) - # transform_box(box, camera_info, ego_pose) - # corners = box.map_2d(np.array(camera_info['camera_intrinsic'])) - corners = box.corners() - bbox = [corners[:, 1], corners[:, 7]] - annotations[item_id]['bboxes'].append(bbox) + box = Box(annotation['translation'], annotation['size'], Quaternion(annotation['rotation'])) + # transform_box(box, camera_info, ego_pose) + # corners = box.map_2d(np.array(camera_info['camera_intrinsic'])) + corners = box.corners() + bbox = [corners[:, 1], corners[:, 7]] + annotations[item_id]['bboxes'].append(bbox) - return video_frames, annotations + print(video_frames) + return {} def add_scenic_recognized_objs(conn, formatted_result, start_time, default_depth=True): clean_tables(conn) diff --git a/scenic_test.ipynb b/scenic_test.ipynb index 2942f947..52807ed3 100644 --- a/scenic_test.ipynb +++ b/scenic_test.ipynb @@ -25,7 +25,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "id": "c3bd0bc2", "metadata": {}, "outputs": [], @@ -34,7 +34,10 @@ "name = 'ScenicWorld' # world name\n", "units = 'metrics' # world units\n", "cam_id = 'CAM_FRONT'\n", - "video_file = os.path.join(\"samples\",cam_id,\"n008-2018-08-01-15-16-36-0400__CAM_FRONT__1533151603512404.jpg\") #example video file, using image file for now\n", + "video_files = [\n", + " \"samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg\", \n", + " \"samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg\"\n", + "]\n", "user_data_dir = os.path.join(\"v1.0-mini\")\n", "lens_attrs = {'fov': 120, \n", " 'cam_origin': (0, 0, 0), \n", @@ -52,7 +55,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 3, "id": "8721832d", "metadata": {}, "outputs": [], @@ -62,20 +65,20 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 4, "id": "b09a2632", "metadata": {}, "outputs": [], "source": [ "### Ingest the camera to the world\n", "scenic_world = scenic_world.scenic_camera(cam_id=cam_id, \n", - " video_file=video_file, \n", + " video_file=video_files, \n", " metadata_identifier=name+\"_\"+cam_id)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 5, "id": "38170a10", "metadata": {}, "outputs": [ @@ -86,7 +89,8 @@ "Worlds Table created successfully........\n", "New world inserted successfully........\n", "Camera Table created successfully........\n", - "already exists\n" + "already exists\n", + "{'ca9a282c9e77460f8360f564131a8af5': {'filename': 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg', 'frame_num': 1, 'camera_config': {'token': '1d31c729b073425e8e0202c5c6e66ee1', 'translation': [1.70079118954, 0.0159456324149, 1.51095763913], 'rotation': [0.4998015430569128, -0.5030316162024876, 0.4997798114386805, -0.49737083824542755], 'camera_intrinsic': [[1266.417203046554, 0.0, 816.2670197447984], [0.0, 1266.417203046554, 491.50706579294757], [0.0, 0.0, 1.0]], 'ego_config': {'token': 'e3d495d4ac534d54b321f50006683844', 'timestamp': 1532402927612460, 'rotation': [0.5720063498929273, -0.0021434844534272707, 0.011564094980151613, -0.8201648693182716], 'translation': [411.4199861830012, 1181.197175631848, 0.0]}}}, '356d81f38dd9473ba590f39e266f54e5': {'filename': 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg', 'frame_num': 11, 'camera_config': {'token': '1d31c729b073425e8e0202c5c6e66ee1', 'translation': [1.70079118954, 0.0159456324149, 1.51095763913], 'rotation': [0.4998015430569128, -0.5030316162024876, 0.4997798114386805, -0.49737083824542755], 'camera_intrinsic': [[1266.417203046554, 0.0, 816.2670197447984], [0.0, 1266.417203046554, 491.50706579294757], [0.0, 0.0, 1.0]], 'ego_config': {'token': 'd0d9ef23e3934ea09d55afdc24db9827', 'timestamp': 1532402928662460, 'rotation': [0.5771649372725738, -0.0026354805918850518, 0.01230141162033981, -0.8165306881540596], 'translation': [408.2105568055955, 1172.4467000474276, 0.0]}}}}\n" ] } ], From 61889c17684a8fdb49bb8948a5b746cc73cf2164 Mon Sep 17 00:00:00 2001 From: eeeeenchanted <597380714@qq.com> Date: Tue, 15 Feb 2022 21:05:26 -0800 Subject: [PATCH 06/26] Save object and camera to database --- apperception/scenic_context.py | 24 +- apperception/scenic_generate_df.py | 87 ++++++ apperception/scenic_util.py | 277 +++++++++++------- apperception/scenic_video_context_executor.py | 7 +- apperception/scenic_world.py | 8 +- scenic_test.ipynb | 182 ++---------- 6 files changed, 291 insertions(+), 294 deletions(-) create mode 100644 apperception/scenic_generate_df.py diff --git a/apperception/scenic_context.py b/apperception/scenic_context.py index 5d109ade..23873f3d 100644 --- a/apperception/scenic_context.py +++ b/apperception/scenic_context.py @@ -10,11 +10,8 @@ # Camera node class ScenicCamera: - def __init__(self, cam_id, video_file, metadata_id): - self.cam_id = cam_id - self.video_file = video_file - self.metadata_id = metadata_id - self.properties = {} + def __init__(self, scenic_scene_name): + self.scenic_scene_name = scenic_scene_name # Contain objects that still have yet to be added to the backend # If user calls recognize, those items will have already been @@ -33,16 +30,17 @@ def add_property(self, properties, property_type, new_prop): self.properties[property_type].append(new_prop) # Add a default add_recog_obj = True - def recognize(self, scenic_data_dir): + def recognize(self, sample_data, annotation): # Create object recognition node - object_rec_node = ScenicObjectRecognition(scenic_data_dir) + object_rec_node = ScenicObjectRecognition(sample_data, annotation) self.object_recognition = object_rec_node return object_rec_node # Object Recognition node class ScenicObjectRecognition: - def __init__(self, scenic_data_dir): - self.scenic_data_dir = scenic_data_dir + def __init__(self, sample_data, annotation): + self.sample_data = sample_data + self.annotation = annotation self.properties = {} def add_properties(self, properties): @@ -72,11 +70,11 @@ def get_units(self): return self.units # Establish camera - def scenic_camera(self, cam_id, video_file, metadata_id): - camera_node = self.__get_camera(cam_id) + def scenic_camera(self, scenic_scene_name): + camera_node = self.__get_camera(scenic_scene_name) if not camera_node: - camera_node = ScenicCamera(cam_id, video_file, metadata_id) - self.__add_camera(cam_id, camera_node) + camera_node = ScenicCamera(scenic_scene_name) + self.__add_camera(scenic_scene_name, camera_node) return camera_node def properties(self, cam_id, properties, property_type): diff --git a/apperception/scenic_generate_df.py b/apperception/scenic_generate_df.py new file mode 100644 index 00000000..98852fd3 --- /dev/null +++ b/apperception/scenic_generate_df.py @@ -0,0 +1,87 @@ +import json +import pandas as pd + +def scenic_generate_df(): + with open('v1.0-mini/v1.0-mini/attribute.json') as f: + attribute_json = json.load(f) + + with open('v1.0-mini/v1.0-mini/calibrated_sensor.json') as f: + calibrated_sensor_json = json.load(f) + + with open('v1.0-mini/v1.0-mini/category.json') as f: + category_json = json.load(f) + + with open('v1.0-mini/v1.0-mini/sample.json') as f: + sample_json = json.load(f) + + with open('v1.0-mini/v1.0-mini/sample_data.json') as f: + sample_data_json = json.load(f) + + with open('v1.0-mini/v1.0-mini/sample_annotation.json') as f: + sample_annotation_json = json.load(f) + + with open('v1.0-mini/v1.0-mini/instance.json') as f: + instance_json = json.load(f) + + with open('v1.0-mini/v1.0-mini/scene.json') as f: + scene_json = json.load(f) + + with open('v1.0-mini/v1.0-mini/ego_pose.json') as f: + ego_pose_json = json.load(f) + + df_sample_data = pd.DataFrame(sample_data_json) + df_sample_data = df_sample_data[['token','sample_token', 'calibrated_sensor_token', 'ego_pose_token', 'timestamp', 'fileformat', 'filename', 'prev', 'next']] + df_sample_data = df_sample_data[df_sample_data['fileformat'] == 'jpg'] + df_sample_data.index = range(len(df_sample_data)) + + df_sample = pd.DataFrame(sample_json) + df_sample.columns = ['sample_token', 'timestamp', 'prev_sample', 'next_sample', 'scene_token'] + df_sample = df_sample[['sample_token', 'prev_sample', 'next_sample', 'scene_token']] + df_sample_data = pd.merge(df_sample_data, df_sample, on="sample_token", how="left") + + df_calibrated_sensor = pd.DataFrame(calibrated_sensor_json) + df_calibrated_sensor.columns = ['calibrated_sensor_token', 'sensor_token', 'camera_translation', 'camera_rotation', 'camera_intrinsic'] + df_calibrated_sensor = df_calibrated_sensor[['calibrated_sensor_token', 'camera_translation', 'camera_rotation', 'camera_intrinsic']] + df_sample_data = pd.merge(df_sample_data, df_calibrated_sensor, on="calibrated_sensor_token", how="left") + df_sample_data = df_sample_data.drop(columns=['calibrated_sensor_token']) + + df_ego_pose = pd.DataFrame(ego_pose_json) + df_ego_pose.columns = ['ego_pose_token', 'timestamp', 'ego_rotation', 'ego_translation'] + df_ego_pose = df_ego_pose.drop(columns=['timestamp']) + df_sample_data = pd.merge(df_sample_data, df_ego_pose, on="ego_pose_token", how="left") + df_sample_data = df_sample_data.drop(columns=['ego_pose_token']) + + df_scene = pd.DataFrame(scene_json) + df_scene.columns = ['scene_token', 'log_token', 'nbr_samples', 'first_sample_token', 'last_sample_token', 'scene_name', 'description'] + df_scene = df_scene[['scene_token', 'first_sample_token', 'last_sample_token', 'scene_name']] + df_sample_data = pd.merge(df_sample_data, df_scene, on="scene_token", how="left") + df_sample_data = df_sample_data.drop(columns=['scene_token']) + + df_sample_data['frame_order'] = 0 + for index, row in df_sample_data.iterrows(): + if len(row['prev']) == 0: + df_sample_data.loc[index,'frame_order'] = 1 + i = 2 + next_frame_token = row['next'] + while len(next_frame_token) != 0: + #print(next_frame_token) + cur_index = df_sample_data[df_sample_data['token'] == next_frame_token].index.tolist()[0] + #print(cur_index) + df_sample_data.loc[cur_index,'frame_order'] = i + i += 1 + next_frame_token = list(df_sample_data[df_sample_data['token'] == next_frame_token]['next'])[0] + + df_sample_data = df_sample_data.drop(columns=['fileformat', 'prev', 'next', 'prev_sample', 'next_sample', 'first_sample_token', 'last_sample_token']) + + df_sample_annotation = pd.DataFrame(sample_annotation_json) + df_sample_annotation = df_sample_annotation[['token', 'sample_token', 'instance_token', 'translation', 'size', 'rotation']] + + df_instance = pd.DataFrame(instance_json) + df_category = pd.DataFrame(category_json) + df_category.rename(columns={'token': 'cat_token'}, inplace=True) + df_instance = pd.merge(df_instance, df_category, left_on="category_token", right_on="cat_token", how="left") + df_instance = df_instance.drop(columns=['category_token', 'cat_token', 'nbr_annotations', 'first_annotation_token', 'last_annotation_token', 'description']) + df_instance.columns = ['instance_token', 'category'] + df_sample_annotation = pd.merge(df_sample_annotation, df_instance, on="instance_token", how="left") + + return df_sample_data, df_sample_annotation diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py index 57c28cb6..f6a0b763 100644 --- a/apperception/scenic_util.py +++ b/apperception/scenic_util.py @@ -3,13 +3,55 @@ import numpy as np import datetime import cv2 -from object_tracker import yolov4_deepsort_video_track +# from object_tracker import yolov4_deepsort_video_track from video_util import * from pymongo import MongoClient from pyquaternion import Quaternion import json import os from scenic_box import Box +import time +import pandas as pd + +def fetch_camera_config(scene_name, sample_data): + ''' + return + [{ + camera_id: scene name, + frame_id, + frame_num: the frame sequence number + filename: image file name, + camera_translation, + camera_rotation, + camera_intrinsic(since it's a matrix, save as a nested array), + ego_translation, + ego_rotation, + timestamp + }, + ... + ] + ''' + camera_config = [] + + # TODO: different camera in one frame has same timestamp for same object + # how to store same scene in different cameras + all_frames = sample_data[(sample_data['scene_name'] == scene_name) & (sample_data['filename'].str.contains('/CAM_FRONT/', regex=False))] + + for idx, frame in all_frames.iterrows(): + config = {} + config['camera_id'] = scene_name + config['frame_id'] = frame['sample_token'] + config['frame_num'] = frame['frame_order'] + config['filename'] = frame['filename'] + config['camera_translation'] = frame['camera_translation'] + config['camera_rotation'] = frame['camera_rotation'] + config['camera_intrinsic'] = frame['camera_intrinsic'] + config['ego_translation'] = frame['ego_translation'] + config['ego_rotation'] = frame['ego_rotation'] + config['timestamp'] = frame['timestamp'] + camera_config.append(config) + + return camera_config # Create a camera table def create_or_insert_scenic_camera_table(conn, world_name, camera): @@ -18,35 +60,58 @@ def create_or_insert_scenic_camera_table(conn, world_name, camera): ''' Create and Populate A camera table with the given camera object. ''' - ### TODO: Modify the following codes to for scenic cameras #Doping Cameras table if already exists. - cursor.execute("DROP TABLE IF EXISTS Cameras") - #Creating table with the first camera - sql = '''CREATE TABLE IF NOT EXISTS Scenic_Cameras( + cursor.execute("DROP TABLE IF EXISTS Scenic_Cameras") + # Formal_Scenic_cameras table stands for the formal table which won't be erased + sql = '''CREATE TABLE IF NOT EXISTS Formal_Scenic_Cameras( cameraId TEXT, worldId TEXT, - ratio real, - origin geometry, - focalpoints geometry, - fov INTEGER, - skev_factor real + frameId TEXT, + frameNum Int, + fileName TEXT, + cameraTranslation geometry, + cameraRotation geometry, + cameraIntrinsic real[][], + egoTranslation geometry, + egoRotation geometry, + timestamp TEXT );''' cursor.execute(sql) print("Camera Table created successfully........") - # insert_scenic_camera(conn, world_name, camera) + insert_scenic_camera(conn, world_name, fetch_camera_config(camera.scenic_scene_name, camera.object_recognition.sample_data)) return sql # Helper function to insert the camera -def insert_scenic_camera(conn, world_name, camera_node): +def insert_scenic_camera(conn, world_name, camera_config): #Creating a cursor object using the cursor() method cursor = conn.cursor() - lens = camera_node.lens - focal_x = str(lens.focal_x) - focal_y = str(lens.focal_y) - cam_x, cam_y, cam_z = str(lens.cam_origin[0]), str(lens.cam_origin[1]), str(lens.cam_origin[2]) - cursor.execute('''INSERT INTO Scenic_Cameras (cameraId, worldId, ratio, origin, focalpoints, fov, skev_factor) '''+ \ - '''VALUES (\'%s\', \'%s\', %f, \'POINT Z (%s %s %s)\', \'POINT(%s %s)\', %s, %f);''' \ - %(camera_node.cam_id, world_name, camera_node.ratio, cam_x, cam_y, cam_z, focal_x, focal_y, lens.fov, lens.alpha)) + for config in camera_config: + cursor.execute('''INSERT INTO Formal_Scenic_Cameras ( + cameraId, + worldId, + frameId, + frameNum, + fileName, + cameraTranslation, + cameraRotation, + cameraIntrinsic, + egoTranslation, + egoRotation, + timestamp + ) '''+ \ + '''VALUES (\'%s\', \'%s\', \'%s\', %s, \'%s\', \'POINT Z (%s %s %s)\', \'POINT Z (%s %s %s)\', + \'{{%s, %s, %s}, {%s, %s, %s}, {%s, %s, %s}}\', + \'POINT Z (%s %s %s)\', \'POINT Z (%s %s %s)\', \'%s\');''' \ + %(config['camera_id'], world_name, config['frame_id'], config['frame_num'], config['filename'], + config['camera_translation'][0], config['camera_translation'][1], config['camera_translation'][2], + config['camera_rotation'][0], config['camera_rotation'][1], config['camera_rotation'][2], + config['camera_intrinsic'][0][0], config['camera_intrinsic'][0][1], config['camera_intrinsic'][0][2], + config['camera_intrinsic'][1][0], config['camera_intrinsic'][1][1], config['camera_intrinsic'][1][2], + config['camera_intrinsic'][2][0], config['camera_intrinsic'][2][1], config['camera_intrinsic'][2][2], + config['ego_translation'][0], config['ego_translation'][1], config['ego_translation'][2], + config['ego_rotation'][0], config['ego_rotation'][1], config['ego_rotation'][2], + config['timestamp'] + )) print("New camera inserted successfully.........") conn.commit() @@ -100,107 +165,89 @@ def transform_box(box: Box, camera, ego_pose): box.translate(-np.array(camera['translation'])) box.rotate(Quaternion(camera['rotation']).inverse) -def scenic_recognize(video_files, scenic_data_dir): +# import matplotlib.pyplot as plt +# def overlay_bbox(image, corners): +# frame = cv2.imread(image) +# frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) +# for i in range(len(corners)): +# current_coner = (corners[0][i], corners[1][i]) +# cv2.circle(frame,tuple([int(current_coner[0]), int(current_coner[1])]),4,(255,0,0),thickness=5) +# plt.rcParams["figure.figsize"] = (20,20) +# plt.figure() +# plt.imshow(frame) +# plt.show() + +def scenic_recognize(scene_name, sample_data, annotation): """ return: - video_frames: { - frame_id: { - frame_num: the frame sequence number - filename: image file name, - camera_config: { - token, - translation, - rotation, - camera_intrinsic, - ego_config: { - token, - translation, - rotation, - timestamp - } - } - } - ... - } annotations: { object_id: { bboxes: [[[x1, y1, z1], [x2, y2, z2]], ...] object_type, + frame_num, frame_id } ... } """ - - # connect mongoDB - client = MongoClient("mongodb+srv://apperception:apperception@cluster0.gvxkh.mongodb.net/cluster0?retryWrites=true&w=majority") - db = client['apperception'] - - if len(db.list_collection_names()) == 0: - insert_scenic_data(scenic_data_dir, db) - else: - print('already exists') - video_frames = {} annotations = {} - for img_name in video_files: - # get bboxes and categories of all the objects appeared in the image file - file_data = db['sample_data'].find_one({'filename': img_name}) - if not file_data: - continue - sample_token = file_data['sample_token'] - frame_num = db['frame_num'].find_one({'token': sample_token})['frame_num'] - all_annotations = db['sample_annotation'].find({'sample_token': sample_token}) - camera_info = db['calibrated_sensor'].find_one({'token': file_data['calibrated_sensor_token']}) - ego_pose = db['ego_pose'].find_one({'token': file_data['ego_pose_token']}) - del ego_pose['_id'] - camera_info['ego_config'] = ego_pose - del camera_info['sensor_token'] - del camera_info['_id'] - video_frames[sample_token] = {'filename': img_name, 'frame_num': frame_num, 'camera_config': camera_info} + # TODO: different camera in one frame has same timestamp for same object + # how to store same scene in different cameras + img_files = sample_data[(sample_data['scene_name'] == scene_name) & (sample_data['filename'].str.contains('/CAM_FRONT/', regex=False))].sort_values(by='frame_order') - for annotation in all_annotations: - instance = db['instance'].find_one({'token': annotation['instance_token']}) - if not instance: - continue - item_id = instance['token'] + for _, img_file in img_files.iterrows(): + # get bboxes and categories of all the objects appeared in the image file + sample_token = img_file['sample_token'] + frame_num = img_file['frame_order'] + all_annotations = annotation[annotation['sample_token'] == sample_token] + + for _, ann in all_annotations.iterrows(): + item_id = ann['instance_token'] if item_id not in annotations: - annotations[item_id] = {'bboxes': []} - category = db['category'].find_one({'token': instance['category_token']}) - annotations[item_id]['object_type'] = category['name'] + annotations[item_id] = {'bboxes': [], 'frame_num': []} + annotations[item_id]['object_type'] = ann['category'] annotations[item_id]['frame_id'] = sample_token - box = Box(annotation['translation'], annotation['size'], Quaternion(annotation['rotation'])) - # transform_box(box, camera_info, ego_pose) - # corners = box.map_2d(np.array(camera_info['camera_intrinsic'])) + box = Box(ann['translation'], ann['size'], Quaternion(ann['rotation'])) + corners = box.corners() + + # if item_id == '6dd2cbf4c24b4caeb625035869bca7b5': + # print("corners", corners) + # transform_box(box, camera_info, ego_pose) + # print("transformed box: ", box.corners()) + # corners_2d = box.map_2d(np.array(camera_info['camera_intrinsic'])) + # print("2d_corner: ", corners_2d) + # overlay_bbox("v1.0-mini/samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg", corners_2d) + bbox = [corners[:, 1], corners[:, 7]] annotations[item_id]['bboxes'].append(bbox) + annotations[item_id]['frame_num'].append(int(frame_num)) - print(video_frames) - return {} + print("Recognization done, saving to database......") + return annotations def add_scenic_recognized_objs(conn, formatted_result, start_time, default_depth=True): - clean_tables(conn) - ### TODO: Modify the following code to store the recognized formatted result into the database - ### TODO: Update the database schema to include all new fields + clean_scenic_tables(conn) for item_id in formatted_result: object_type = formatted_result[item_id]["object_type"] + frame_id = formatted_result[item_id]["frame_id"] recognized_bboxes = np.array(formatted_result[item_id]["bboxes"]) - tracked_cnt = formatted_result[item_id]["tracked_cnt"] - top_left = np.vstack((recognized_bboxes[:,0,0], recognized_bboxes[:,0,1])) - if default_depth: - top_left_depths = np.ones(len(recognized_bboxes)) - else: - top_left_depths = self.__get_depths_of_points(recognized_bboxes[:,0,0], recognized_bboxes[:,0,1]) + tracked_cnt = formatted_result[item_id]["frame_num"] + top_left = np.vstack((recognized_bboxes[:,0,0], recognized_bboxes[:,0,1], recognized_bboxes[:,0,2])) + # if default_depth: + # top_left_depths = np.ones(len(recognized_bboxes)) + # else: + # top_left_depths = self.__get_depths_of_points(recognized_bboxes[:,0,0], recognized_bboxes[:,0,1]) - # Convert bottom right coordinates to world coordinates - bottom_right = np.vstack((recognized_bboxes[:,1,0], recognized_bboxes[:,1,1])) - if default_depth: - bottom_right_depths = np.ones(len(tracked_cnt)) - else: - bottom_right_depths = self.__get_depths_of_points(recognized_bboxes[:,1,0], recognized_bboxes[:,1,1]) + # # Convert bottom right coordinates to world coordinates + bottom_right = np.vstack((recognized_bboxes[:,1,0], recognized_bboxes[:,1,1], recognized_bboxes[:,1,2])) + # if default_depth: + # bottom_right_depths = np.ones(len(tracked_cnt)) + # else: + # bottom_right_depths = self.__get_depths_of_points(recognized_bboxes[:,1,0], recognized_bboxes[:,1,1]) top_left = np.array(top_left.T) bottom_right = np.array(bottom_right.T) @@ -210,12 +257,11 @@ def add_scenic_recognized_objs(conn, formatted_result, start_time, default_depth current_br = bottom_right[i] obj_traj.append([current_tl.tolist(), current_br.tolist()]) - scenic_bboxes_to_postgres(conn, item_id, object_type, "default_color" if item_id not in properties['color'] else properties['color'][item_id], start_time, tracked_cnt, obj_traj, type="yolov4") + scenic_bboxes_to_postgres(conn, item_id, object_type, frame_id, "default_color", start_time, tracked_cnt, obj_traj, type="yolov4") # bbox_to_tasm() # Insert bboxes to postgres -def scenic_bboxes_to_postgres(conn, item_id, object_type, color, start_time, timestamps, bboxes, type='yolov3'): - ### TODO: Modify the following codes to add recognized scenic objects to the database +def scenic_bboxes_to_postgres(conn, item_id, object_type, frame_id, color, start_time, timestamps, bboxes, type='yolov3'): if type == 'yolov3': timestamps = range(timestamps) @@ -226,12 +272,12 @@ def scenic_bboxes_to_postgres(conn, item_id, object_type, color, start_time, tim pairs.append(meta_box[0]) deltas.append(meta_box[1:]) postgres_timestamps = convert_timestamps(start_time, timestamps) - create_or_insert_scenic_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs) - print(f"{item_id} saved successfully") + create_or_insert_scenic_general_trajectory(conn, item_id, object_type, frame_id, color, postgres_timestamps, bboxes, pairs) + # print(f"{item_id} saved successfully") # Create general trajectory table -def create_or_insert_scenic_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs): +def create_or_insert_scenic_general_trajectory(conn, item_id, object_type, frame_id, color, postgres_timestamps, bboxes, pairs): cursor = conn.cursor() ''' Create and Populate A Trajectory table using mobilityDB. @@ -239,45 +285,45 @@ def create_or_insert_scenic_general_trajectory(conn, item_id, object_type, color Then the timestamp should be the timestamp regarding the world starting time ''' - ### TODO: Modify the table fields to match scenic schema - create_itemtraj_sql ='''CREATE TABLE IF NOT EXISTS Scenic_Item_General_Trajectory( + # Formal_Scenic_Item_General_Trajectory table stands for the formal table which won't be erased + create_itemtraj_sql ='''CREATE TABLE IF NOT EXISTS Formal_Scenic_Item_General_Trajectory( itemId TEXT, objectType TEXT, + frameId TEXT, color TEXT, trajCentroids tgeompoint, largestBbox stbox, PRIMARY KEY (itemId) );''' cursor.execute(create_itemtraj_sql) - cursor.execute("CREATE INDEX IF NOT EXISTS traj_idx ON Scenic_Item_General_Trajectory USING GiST(trajCentroids);") + cursor.execute("CREATE INDEX IF NOT EXISTS traj_idx ON Formal_Scenic_Item_General_Trajectory USING GiST(trajCentroids);") conn.commit() - #Creating table with the first item - create_bboxes_sql ='''CREATE TABLE IF NOT EXISTS Scenic_General_Bbox( + # Formal_Scenic_General_Bbox table stands for the formal table which won't be erased + create_bboxes_sql ='''CREATE TABLE IF NOT EXISTS Formal_Scenic_General_Bbox( itemId TEXT, trajBbox stbox, FOREIGN KEY(itemId) - REFERENCES Scenic_Item_General_Trajectory(itemId) + REFERENCES Formal_Scenic_Item_General_Trajectory(itemId) );''' cursor.execute(create_bboxes_sql) - cursor.execute("CREATE INDEX IF NOT EXISTS item_idx ON Scenic_General_Bbox(itemId);") - cursor.execute("CREATE INDEX IF NOT EXISTS traj_bbox_idx ON Scenic_General_Bbox USING GiST(trajBbox);") + cursor.execute("CREATE INDEX IF NOT EXISTS item_idx ON Formal_Scenic_General_Bbox(itemId);") + cursor.execute("CREATE INDEX IF NOT EXISTS traj_bbox_idx ON Formal_Scenic_General_Bbox USING GiST(trajBbox);") conn.commit() #Insert the trajectory of the first item - insert_scenic_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs) + insert_scenic_general_trajectory(conn, item_id, object_type, frame_id, color, postgres_timestamps, bboxes, pairs) # Insert general trajectory -def insert_scenic_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs): - ### TODO: Modify the insert based on the new table schema +def insert_scenic_general_trajectory(conn, item_id, object_type, frame_id, color, postgres_timestamps, bboxes, pairs): #Creating a cursor object using the cursor() method cursor = conn.cursor() #Inserting bboxes into Bbox table insert_bbox_trajectory = "" - insert_format = "INSERT INTO Scenic_General_Bbox (itemId, trajBbox) "+ \ + insert_format = "INSERT INTO Formal_Scenic_General_Bbox (itemId, trajBbox) "+ \ "VALUES (\'%s\'," % (item_id) # Insert the item_trajectory separately - insert_trajectory = "INSERT INTO Scenic_Item_General_Trajectory (itemId, objectType, color, trajCentroids, largestBbox) "+ \ - "VALUES (\'%s\', \'%s\', \'%s\', " % (item_id, object_type, color) + insert_trajectory = "INSERT INTO Formal_Scenic_Item_General_Trajectory (itemId, objectType, frameId, color, trajCentroids, largestBbox) "+ \ + "VALUES (\'%s\', \'%s\', \'%s\', \'%s\', " % (item_id, object_type, frame_id, color) traj_centroids = "\'{" min_ltx, min_lty, min_ltz, max_brx, max_bry, max_brz = float('inf'), float('inf'), float('inf'), float('-inf'), float('-inf'), float('-inf') # max_ltx, max_lty, max_ltz, min_brx, min_bry, min_brz = float('-inf'), float('-inf'), float('-inf'), float('inf'), float('inf'), float('inf') @@ -307,4 +353,9 @@ def insert_scenic_general_trajectory(conn, item_id, object_type, color, postgres cursor.execute(insert_bbox_trajectory) # Commit your changes in the database conn.commit() - \ No newline at end of file + +def clean_scenic_tables(conn): + cursor = conn.cursor() + cursor.execute("DROP TABLE IF EXISTS scenic_General_Bbox;") + cursor.execute("DROP TABLE IF EXISTS scenic_Item_General_Trajectory;") + conn.commit() \ No newline at end of file diff --git a/apperception/scenic_video_context_executor.py b/apperception/scenic_video_context_executor.py index 1065146a..68cac8b1 100644 --- a/apperception/scenic_video_context_executor.py +++ b/apperception/scenic_video_context_executor.py @@ -37,16 +37,15 @@ def visit_camera(self, camera_node): if camera_node.object_recognition is not None: self.visit_obj_rec(camera_node, camera_node.object_recognition) if self.tasm: - video_data_to_tasm(camera_node.video_file, camera_node.metadata_id, self.tasm) + video_data_to_tasm(camera_node, camera_node.metadata_id, self.tasm) return camera_sql def visit_obj_rec(self, camera_node, object_rec_node): - cam_id = camera_node.cam_id - video_file = camera_node.video_file + cam_id = camera_node.scenic_scene_name start_time = self.current_context.start_time - tracking_results = scenic_recognize(video_file, object_rec_node.scenic_data_dir) + tracking_results = scenic_recognize(cam_id, object_rec_node.sample_data, object_rec_node.annotation) add_scenic_recognized_objs(self.conn, tracking_results, start_time) if self.tasm: metadata_to_tasm(tracking_results, camera_node.metadata_id, self.tasm) diff --git a/apperception/scenic_world.py b/apperception/scenic_world.py index 21ff4426..e56419c5 100644 --- a/apperception/scenic_world.py +++ b/apperception/scenic_world.py @@ -43,9 +43,9 @@ def item(self, item_id, cam_id, item_type, location): new_context.VideoContext.item(item_id, cam_id, item_type, location) return new_context - def scenic_camera(self, cam_id, video_file, metadata_identifier): + def scenic_camera(self, scenic_scene_name): new_context = copy.deepcopy(self) - new_context.ScenicVideoContext.scenic_camera(cam_id, video_file, metadata_identifier) + new_context.ScenicVideoContext.scenic_camera(scenic_scene_name) return new_context def add_properties(self, cam_id, properties, property_type): @@ -53,9 +53,9 @@ def add_properties(self, cam_id, properties, property_type): new_context.VideoContext.properties(cam_id, properties, property_type) return new_context - def recognize(self, cam_id, scenic_data_dir): + def recognize(self, cam_id, sample_data, annotation): new_context = copy.deepcopy(self) - new_context.ScenicVideoContext.camera_nodes[cam_id].recognize(scenic_data_dir) + new_context.ScenicVideoContext.camera_nodes[cam_id].recognize(sample_data, annotation) return new_context ######################### diff --git a/scenic_test.ipynb b/scenic_test.ipynb index 52807ed3..ae6a7eed 100644 --- a/scenic_test.ipynb +++ b/scenic_test.ipynb @@ -18,9 +18,10 @@ "from world_executor import *\n", "from video_util import *\n", "from metadata_util import *\n", - "import lens\n", - "import point\n", - "\n" + "import json\n", + "import pandas as pd\n", + "\n", + "from scenic_generate_df import *\n" ] }, { @@ -33,24 +34,19 @@ "### Let's define some attribute for constructing the world first\n", "name = 'ScenicWorld' # world name\n", "units = 'metrics' # world units\n", - "cam_id = 'CAM_FRONT'\n", - "video_files = [\n", - " \"samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg\", \n", - " \"samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg\"\n", - "]\n", - "user_data_dir = os.path.join(\"v1.0-mini\")\n", - "lens_attrs = {'fov': 120, \n", - " 'cam_origin': (0, 0, 0), \n", - " 'skew_factor': 0}\n", - "point_attrs = {'p_id': 'p1', \n", - " 'cam_id': 'cam1', \n", - " 'x': 0,\n", - " 'y': 0, \n", - " 'z': 0,\n", - " 'time': None, \n", - " 'type':'pos'}\n", - "camera_attrs = {'ratio': 0.5}\n", - "fps = 30\n" + "user_data_dir = os.path.join(\"v1.0-mini\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "01c91100", + "metadata": {}, + "outputs": [], + "source": [ + "# generate dataframes from scenic json files\n", + "# takes 1min to run\n", + "df_sample_data, df_annotation = scenic_generate_df()" ] }, { @@ -71,9 +67,8 @@ "outputs": [], "source": [ "### Ingest the camera to the world\n", - "scenic_world = scenic_world.scenic_camera(cam_id=cam_id, \n", - " video_file=video_files, \n", - " metadata_identifier=name+\"_\"+cam_id)" + "scene_name = \"scene-0061\"\n", + "scenic_world = scenic_world.scenic_camera(scene_name)" ] }, { @@ -89,150 +84,17 @@ "Worlds Table created successfully........\n", "New world inserted successfully........\n", "Camera Table created successfully........\n", - "already exists\n", - "{'ca9a282c9e77460f8360f564131a8af5': {'filename': 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg', 'frame_num': 1, 'camera_config': {'token': '1d31c729b073425e8e0202c5c6e66ee1', 'translation': [1.70079118954, 0.0159456324149, 1.51095763913], 'rotation': [0.4998015430569128, -0.5030316162024876, 0.4997798114386805, -0.49737083824542755], 'camera_intrinsic': [[1266.417203046554, 0.0, 816.2670197447984], [0.0, 1266.417203046554, 491.50706579294757], [0.0, 0.0, 1.0]], 'ego_config': {'token': 'e3d495d4ac534d54b321f50006683844', 'timestamp': 1532402927612460, 'rotation': [0.5720063498929273, -0.0021434844534272707, 0.011564094980151613, -0.8201648693182716], 'translation': [411.4199861830012, 1181.197175631848, 0.0]}}}, '356d81f38dd9473ba590f39e266f54e5': {'filename': 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg', 'frame_num': 11, 'camera_config': {'token': '1d31c729b073425e8e0202c5c6e66ee1', 'translation': [1.70079118954, 0.0159456324149, 1.51095763913], 'rotation': [0.4998015430569128, -0.5030316162024876, 0.4997798114386805, -0.49737083824542755], 'camera_intrinsic': [[1266.417203046554, 0.0, 816.2670197447984], [0.0, 1266.417203046554, 491.50706579294757], [0.0, 0.0, 1.0]], 'ego_config': {'token': 'd0d9ef23e3934ea09d55afdc24db9827', 'timestamp': 1532402928662460, 'rotation': [0.5771649372725738, -0.0026354805918850518, 0.01230141162033981, -0.8165306881540596], 'translation': [408.2105568055955, 1172.4467000474276, 0.0]}}}}\n" + "New camera inserted successfully.........\n", + "Recognization done, saving to database......\n" ] } ], "source": [ "### Call execute on the world to run the detection algorithm and save the real data to the database\n", - "recognized_scenic_world = scenic_world.recognize(cam_id, scenic_data_dir=user_data_dir)\n", + "recognized_scenic_world = scenic_world.recognize(scene_name, df_sample_data, df_annotation)\n", "recognized_scenic_world.execute()" ] }, - { - "cell_type": "code", - "execution_count": 7, - "id": "9fe17cfc", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'cam1': }\n", - "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='object_type', ctx=Load()), ops=[Eq()], comparators=[Str(s='car')]))])\n", - "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load()), ops=[In()], comparators=[Name(id='volume', ctx=Load())]))])\n", - "Module(body=[Return(value=Compare(left=Call(func=Name(id='Tmin', ctx=Load()), args=[Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load())], keywords=[]), ops=[GtE()], comparators=[Name(id='start', ctx=Load())]))])\n", - "Module(body=[Return(value=Compare(left=Call(func=Name(id='Tmax', ctx=Load()), args=[Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load())], keywords=[]), ops=[Lt()], comparators=[Name(id='end', ctx=Load())]))])\n", - "Worlds Table created successfully........\n", - "New world inserted successfully........\n", - "Camera Table created successfully........\n", - "New camera inserted successfully.........\n", - "SELECT distinct on(itemId) Item_General_Trajectory.itemId From Item_General_Trajectory INNER JOIN General_Bbox USING(itemId) Where Item_General_Trajectory.objectType='car' AND overlap(General_Bbox.trajBbox, stbox 'STBOX Z((0.01082532, 2.59647246, 0),(3.01034039, 3.35985782, 2))')=true AND Tmin(General_Bbox.trajBbox)>='2021-06-08 07:10:28' AND Tmax(General_Bbox.trajBbox)<'2021-06-08 07:12:28';\n", - "\n", - "filtered_ids are [['car-1']\n", - " ['car-12']\n", - " ['car-15']\n", - " ['car-17']\n", - " ['car-2']]\n", - "5\n", - "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='object_id', ctx=Load()), ops=[In()], comparators=[Name(id='id_array', ctx=Load())]))])\n", - "Worlds Table created successfully........\n", - "New world inserted successfully........\n", - "Camera Table created successfully........\n", - "New camera inserted successfully.........\n", - "atPeriodSet(Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}')\n", - "asMFJSON(atPeriodSet(Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}'))::json->'coordinates'\n", - "SELECT distinct on(itemId) asMFJSON(atPeriodSet(Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}'))::json->'coordinates' From Item_General_Trajectory Where Item_General_Trajectory.itemId IN ('car-1','car-12','car-15','car-17','car-2');\n", - "\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAADfCAYAAAAN+JPJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9WaxlS5rfh/1iWNMezpgnT453qLpVXVVd3dXVbJHNQTIt2YBI2Og3ajAEUSDQIEDCMNoPIvwiP9IvNgjIoNGGBZOAYUqQbUgwKNESwZnqptjV1dU13brzvTnnmfewphj8EGvts84+e++zT2be7mQjv4u8Z++114oVK1bEP77v/33xhfDe80beyBt5I2/kj5bIP+wKvJE38kbeyBt59fIG3N/IG3kjb+SPoLwB9zfyRt7IG/kjKG/A/Y28kTfyRv4IyhtwfyNv5I28kT+C8gbc38gbeSNv5I+gfCngLoT4t4UQ7wshPhRC/LUv4x5v5I28kTfyRpaLeNVx7kIIBfwM+J8DD4D/Efj3vPc/fqU3eiNv5I28kTeyVL4Mzf2PAx967z/23lfA3wF+7Uu4zxt5I2/kjbyRJaK/hDLvAl90vj8A/sSqC/r9vt/Z2Vn4mxDi1dVsRfmtBfNl3+9F5IXrtOZ1F8666hrvWWTriWvc76p6LC1/viovUPayMsSCYyvLa07yYnX5q2Sh1fyH1f/m6uKXHO/2xT+s1e3/Kq2qf9m6XnX9gwcPDrz3e4t++zLAfS0RQvw68OsA29vb/MZv/Eb3t4Wf565fes5VDSKEuPBvWbmr7n+d36W8bCA559Yq13s/K2Pduri575fOa9rHN7+3Za8z0XnvF9Z9nfotquuFMtry589du9SL13jOQUoteNcAtnlW1Xl2t2QC69ZlHtyXir943aKHudBfu/16rpjZRDT3nubLWfScQoil7buoDOcc3vsL9xCAnAP3tv3kgvu+KLB177vsWbvS9sfuOe24uVAuHjyItmXnmulF6tvep712voy2HZfdY9k958tdds1v/MZvfLasbl8GuD8E7ne+32uOXRDv/W8Cvwlw//59/yo15qvKWgS2i6572Tp1AXO+rLYOi4By/rr5DtItwwOuHQgr6t4dLK45V3gPQuCdgwVtMj9A5usgpbxyklomiwbfvKzS5NvfFwJgA87dNlz0zmd16A6+TtnrDvWrzruyLCEWPsf8NS/SHxf26StA7FVpxi+j5c8D27Jn997P+mH3mpVt5XklwH7lfbj8HKuuX/S8iya3dfvBlwHu/yPwNSHEuwRQ/3eBf/9LuM9Mrnqh8wN7mWaz6vdF8jLg3167CCCXTQTXEe/9QqpkpmHQ9G/v8Q3Az7fBoo7ZTjRtnaSUS7WWq9rnqg57FbgvLbctrwHNK0GmmfCW3X+hrPnqffNfuGR+Onq1cpVy0rXolmnGbZ9ZOKbmNPnZfZprXoW0726dyZ/OuYsAfu17fsk0z3x7L7vfKitlHQtmXl45uHvvjRDirwJ/D1DAf+a9/9G6179KDb4LilcB+pcl84C5CABbgFzVoZdRJNB4xee0v0vXd69b9lt3gDdafXv+/DVtXWdU0NwE1T7TrN7t+Rcf6kJ9XswGuCyr2mqde6xqx3mlbxFcL7DFaEiBK7n/ZaJmzyTwYrlVJbvvZE2NsVtLGs2+a1nO+mzTf9vnEBfqdT3p1rFbyxei4DoAP69oXJycwIsvF8gX1a39246RdbX5ZSC/LsB/KZy79/7vAn933fMXcd+rzl1HrssBX6f869Z1FT3THaTLzumWt6jTrjZBl2haK7536wbLwb3byeYtEO8coju5Lrnvpdp1aIPuxLBI5ieLV6GBzWuuC39fUI8LdZjjqcMktraqv/RmF552XuPu9jW4QEvNF9e9Rff6riUnWExbLZJ1tMrratSraJhV5V9N9Ykv03haqsB1rV246CdY1jbL2nXdtvxDc6heJS+jVXeBfR1O7MuQZZPLPBCs0ylfhDJaJS806S062NHGF2mllyBtrj/O6IolGn23nAuY9wdscbWySPtvAfECv3+dGy0Zo10934eCL9Ztzq9wqf6d31xD0V1Fcy2cbDu/0dZjCZ12HX55/tgyim6hQ5HLc2D3eVdeuybd8zKyDOC7degCfbdOiyjOVRPGKnltwf268mW+sLUdNUuuveq3l6n7iziqrivLrhAEDR0hgrbLHKB322xVO6yom587Z2U9X4BvXVDISkvhUrTDgrqt28be+6UPJujQK1wErxbsW+16/t4XrJn565qy1mmnqzTK61yzzr1WHZ+nhtYpq0uFrLrPqol8XVmktM2XtQ7l2rWI1wH4VfJagvuLgt0qeue6dMuqsKp1QHkRFbOu5rKuXJej70qrOXQ70svUpeV3W63qKiLikua1Atjlknp1r2i1WTlXzjzYXdULzmmUTj2uuO8LT82LBmzn/uu8hQv9svl7gXZZcd3M6b5CpBDYrnKzZp3W7UOzd9/l8pcAY1vf+XDMRXXqUiHrct3z18/XYV2Zv88lemxF/+qOwUXl/KE6VF9GXlb7XgXuL1uXFgyvokhetAMt6wDdl73SWbSkPotknrbqOkfnJ7V16t51irXH5RWgJ1Z5F9tzVtxzWZ2WDfRlZXblKj532T1eWFtldR+6ar3CpbK4OLmuVwkxW/ewqEzoOMdhacTM8uLXUBg6zuB1yppNYkuUm/kJYT5g4WWt3XWtnmVyFWUDy8OMr1P/1wbc1xq4zYMtms3mZ7x17rdqdp0/vgjcl9XhRUyoRee2z9yWZ629dllw2Wm7zKJY1LZX1bGrFcHFaI21tLyllZ79r73hGqVdrNurlOtqY+vIKspDCIFihfbuF0SZzNepPbX5O2N5m7adh45l9RGdv3i/dN3Foufofl/Ggc//Pq/0XDeyZFVZ8+GSL8LBv+hkPl/nVpb1q2XWw7r1fW3AfZVcNftfV2Nfh1ZpZR4Yl1133cG+zu/zoZxKqZXayjzQrrpnV5OZb991Ot+qSW+tN9GetKwdxNol/YHJlzFprHOv68DIMh9Fq9VfcIZyPcrBe49fA9ivI8v68lUW8qJzVlEYXQVs3UCGdet9HUt91YS+SiFcpNheJa8tuM9rmMsebBH4dstYdN6L1OU6x9v7LavnOvda9EyrJrmrnr37eVUHWQTW3YlgVZ1eVHtdpmktO/+q866rVX6Zsqq+y6yBZRPlBU19WZ/snCs6/7plXOWkFnDJKvDdv1coW4vkZR2Ui35fBobzbT7fxq32vqjfde+77urr61jqq7T+RRPPonHY/b5KXmtwX7SydNkqtHUohBetx3Utg+49l5mHq65ZJesA81V1aXnI+futuv5lLZEv65oXMZEXTUSvUhvtyqtqty4gi87nReUte5ZVTtELADh/jvfh35yV1wXIqzTL67R3d+yvWnV6lcY7T/m0f7sKzCpwn6/vuj6oq2SdyXHR5DY/Dq+afF47cL+uRrYMeNY9dlVdlFIrwe0qLmxd821+oHSvedWa5oukM3hV8irey8teNy9fNrC/isnnwu9t+YsvvlDOsvJXfV90/jyNN6+stH239QvNy1W0yXxZrXRXnS6r6zrgv0gbvgprli06WvZ8q+Q61M38NS/aj147cIfLL7jbubrndD9/GSD4qkF21fWrHLbLZu75369z/1cBqNfpbK8S1F/22pe5z7rOvVfeF0PBF2PV562Y5t7rRsu8CFWyiipYVd46VOKi39flmdfpl4s09UX1WKRgXZUkr7U2uvd+0aR6i+rbree6FOZrB+7LTOZlzsJFs/CXDWLLZtLrDup5Teiql/Yq6IRXqSWvW5dl7+xV1eNly3gRk/pFy38RK6HLo1/Q2hsg95znF6Jz7lJOfY6muPL+CwB9HrhelfWzaAJ5kTK6dVoX1K+6fpXFex2L4qr7r2PhrLq+ldcO3OGyk23emTevIX1ZwN524kWde9l1L6K1XafOyyaA6/ggrqrDfHnrlrWOJrbs+HW1s+vIl6nlr6tFdevyMkC4DF66YC7n7vEi77IryzT1PyhpteaXue+LPvc6Clf393ncehVylQa/TF5bcJ//vIgrW6UhvSptsQvW6wL3ugN+XktZNjlcpbGv4lBfNSCu27FWlbXKCniRSerLAO9FzrhXdf950FinLa8a3GLut+vUZb6s69TlVZQ3f938OH5RkLyu5nxdPn8eG14VJbNIkXyRCfa1BPeuLOOblwHEy/Kd89fOL9Nfdu/2nEUm73UmhPly2u9dWmpRp2zP7a7GW2RGLuusL9JuVz3fOlTOdX//g5K2nSaTCYeHh0RRxNbWFkmSXJlKet3yX0Zmbc9l+mUVGL0Kf8D8RjOLFC/n3AsB3KusZ7c+17n3y5SxDHjXoWBedZ1eW3Bf1jGuApJXQctcdc9VHW/eJLvOhNM+cwvQF1LoLjH15su9akBd1+k1f591+MDrgP38vV/mnV1f62/btHNNc7SuKo6OjxmdnVHkBUVZ8PjxY7IsY2dnh42NDZIkeSUW4nzbLvs+q/UVbb7MjH9ZSmj+PvOT3KLf5n1ly+reVUqWnfcHIS9iSXWv7Y6/RX1jWSKzq8beonF3VV97bcG9lfbFv6i5eZ1zF2nFV2np68oq8OqCevf7i3ay9j6vAjC797nOJDdfl/b8RccXnfOiVsT1xXX+eoyxnJ6ccXJyTG1MyIHjLMKBqWtGdc3obITWiuHGBltbWwyHQ+I4vmDlvQzIr5J1KbeX1UJfpG/Pf++Op4Wbf1xxn9cB7JfJMgtj1a5v89Z09/nWpZCuMz5ee3CXUq4dl/2iA2oRqK9T3rpc7KoX131ZLxs6tazsbl1eVNaZ9K7bhm37KaWAy5PaOh25+4zWWrz3s7UJ60tYVj8ajzg+PKIoiu5PeNfk9Onc09SG4+NjTk9OUVoxHA7Z3d1lOBzOnmfRwH0RpaNbxnWsn1Ua/zLtftn3Rfear9Mqrfwq8JqnM14lmF/HYnmVls06v72Ib2Lda64EdyHEfwb8L4Bn3vtvN8d2gP8ceAf4FPgL3vtjEWr/N4A/D0yBv+i9/951Kj0/Cy7rqNeVZbRC+/dVUTiLyl5HXqWWPa8tXFdbW+eadSaOdbX67r+WjrpOp7fWcnBwcAFwsiwjyzLiOF5eHx+eI59OOTw6YDqdgPWzreOMtYwnY4q8wHqBjiK01kgpEELiPThnsc5yeHjI8fExcRyzsbHB7u4uWZah9avTn9axgK5z/SKgWGVNzZ+3zjtqlbOrzl2k/b+MZbxq/F2laF1HXjXl9SontXV63v8d+E+Bv9059teAv++9/+tCiL/WfP+PgT8HfK359yeAv9n8XSldzm0eaNvfukC/zsuZN5teRDO/7nmvQq4L8ldphS9i9Sz7fF15UYdrl39dx+E0Ho8ZjUZsbm7OrsmnOaPRCK01vV6PjY2NS3WrqoqTowPOzs7w3kLTV5yz5HlBVVX0emGCKIqaytRhAgDiOCGO09D+nANRVVUcHBxwdHREEsdsbm2xtbVFr9e79C7WebZXcXzReevSAYvKXZcu7I679j6LwhpX+RbWsUKWXdMtd1U45VXHXqRdVx1bJq+aeroS3L33/1gI8c7c4V8D/mzz+W8B/5AA7r8G/G0favlbQogtIcRt7/3jq+6ziFefB5l1tOFuY85zWovKnZcX1YquuubLniBW3fOqe7+IdXRdgFhWz2XUw3W0+CiKiKIoeEK9oI0Gl1LNysALEBJwWGs5OTnh5PgYW5fgHUIA3jOdjinLiiztsbGxxeHRAT99/32Gm5vcun2bXr+Hd566NkwmE4QUJHECUgIeIQV4sM4yNTn5NOfZk6ekWcbm1iZ7e3skSXLtdlr33JfRPteR67znRYoacMl5Oj9m5+szv/H1upNL957dfrQuwHd/+7IUwatWvr6MvKjNuN8B7CfAfvP5LvBF57wHzbErwb0ry0ypVSC0jFK4SrOdP74OUC0r78ugdpbVZdHEd937v6iGvug9LKvrVfdYNpm273EdLd47j5ThXGv9efiLFyDafCcC7xzj0SlHx4dUZRUWqLngSM2LKUVRkCQJ21tbHB+f8Vu/9dv8+Kc/YTKdIKRkMNzg9u3bvH3/Lfb398myHiAwxmDKEu89cRyjtT63HAFjDNPJJEwGQnD37t2l7bGOzPfxF9EWX4QCuC49s24du5P5Kk19VX2XteUiQO/2sXUsiPa3q5iDVfdfdvw6wROtrPvuXpoQ9N57IcS11QUhxK8Dvw6ws7Nz1T3W6kDd7+uYWouAp8vbLrq22xGX1eFVyjplr8pL8zLlXuea63Kki65d9A7mB3sbP30BOPBoKSmnU4xxxHGMECJw51Ig8EwnpxwfH5FPp+fvEqjqknw6QUaaze0tRmdj/uU/++f86Ec/ZDKezDbxds5ydnbC2dkpH/zsZ/QHA27t3+Ltt9/m1q1bpGmKJ/D/06JEAFrHaHUO9AjArQfE8/34ukD8KgF+1dhbNl7Wsa7nQynngbYLgC9KWSwbx1ed9wchi4B93XG0zjkvCu5PW7pFCHEbeNYcfwjc75x3rzl2Sbz3vwn8JsDbb7/tm2MrtetFWvmSsi9ds2zmXgTyizSjZZPIlwHs69Ao81rGq+oQ696/+/dlzMqWNrnKKlsVP+ytIT87Znx2Sl6URFqTZhn9/hCdplTOcVKVF0DCWtvQKjDcGDLJp/zWb/82v/+DH3J2eoYU0MsSjHOUVXXef7zHec9odMpoNOKjjz+i1+tx8+ZN3nnnHW7dusVgMAAPprbkeY4QAq01cRwH0HINfdPIvD9pUVt0sy2ua1muI6sA/svQJrvnX3Vs/r2/jKwz0X0Z8iLt8jKKUldeFNz/a+A/BP568/e/6hz/q0KIv0NwpJ6uw7fDcrOnCyDrrgycB7/rNtYyYJ+v17rWxLr36t6z/W1Rh5+Z/Asmp+vWZ9mkddX5XcrkZcX7QJ1orRdqql0t7nLf8EzGJxTTE7yrwVbUtqIup0zOTtnc3UNpjZCBcnfWMZlM8N4zGPYpypLvff/3+P7vfZ/j4xMUgq3hgG984+f42ntfZTqZ8Oz5cx48eMjB4SGTPMc6CPaCw1nHeHzGaHw2A/pbN2/yztvvcOvOXfq9PgJJXddMJhM+/fRT8iLna1//+gU6bR7QRZMSzFqLMQbvgxNXCIFtQjNflba5ij5Z59pldMYyrf46dZpfIf6q+el16/eiz9FeC8upqfnf18GPV0LLCCH+nwTn6Q0hxAPgPyGA+n8hhPhLwGfAX2hO/7uEMMgPCaGQ/9GVNVhS4UUm+nUeflGnu8p07ALn/N9V2vurlIUDfYmW8yq19Vausp7mKaB167HOfVeBwaLj4Xzw3uKxCGERsuknHhB+FptunWU6nWKtJU0zvHP86Ec/4ne+97shjFLAcDjk53/uPb719fcYDAZ474mVYHMw4L133qEoCp4fHvLw8VOePn3G6fgM6xwOj0DgkEwnEz755GM+/fRT0jRj7+ZN3rr3Nnfv3mM4HAKgtJ7FwnefpSt1VVAUBXmeE0URpycjkjRld+8GURSt3MTiZeRFgH7Z+Jo/tq72vAgHulTOvGLzZTkku/Iymv86tFt77DpW1FV1Wida5t9b8tO/teBcD/yVq8pc457A5Qbrmu/L8qasknVNwXkzudUsv2x5FUD5slbDda9dVzu7amJeFbK5aCBcZY15wnszxjA5G2G8od/vobXmww8/5He/932ePXuOs4at4YD3vv4eP/+tb7AxzJDCIRBYK5BSgRRYZ8j6KW/17nL/7l2quubo+ITHT5/w6PEjTs5GVNaF9a4+xMDnec7nn3/B559/QZqk7O3d5N133uWtt9+ePcN8uznnOD09wVTlBcVCKU1dG8ajMXEck6TJ2mGuLyqrwLYrL0PfLKNGF92je163jPmV3cvuO3/dyzzL5Wvb7775F46F8lofj8D79r0317jzc/yFa9v6tGW2k1y336wev6/9CtV5aTnadhZf9MJXabzLZBGoz//+KrWkZVbDKq15GaBdx6JZdv9VssjXsYwbni9/fpJc517zltIqzaf5NvvbnquVZjSa8M9/63d48PAh2ze2+drXvsbu7g6PHj3EY9nY6PHeO2/x7Z//FoPhIAw+IRmNxxRFwe7ODgZ4+PgxWmtu7u0hASEtkYy4desmt27d5Bd//hucno148vyAR4+ecHA0YloUFwarkJBlKTdu3MATEpKlaXqp/xpjGhrmomZaVjnGGM7OTiiKkt6gz9bW1tIcN69S1lGa1pnkX2Rczt9jUZ0WafXr1KEb1QRQ1zWw2tpor+9OJC11hvcorUOUViOuAXIhmms9OG9DX2voPbwDAYJ2krLQAfEWl7o+I2PMv3rb7C0zP+bNxfkHf9mOsyx/zarOsghsrwaii0C+iDpapMWseq5V4HoVFdU9vuw5r9Kq5p8FuPBe2t+cc0stoO6Evch5GqgW33DRjRUnJWEUNPAuBAJFUZT89P0f8eMf/4xxnpOkKW/1e9zY2ebBgwd8+vFn3Ll9k+/863+aGze2w0BDc3o24vj0lPd/9jP2tne4sb2D956DoyOs8zx9dsLx0Qnf/MZ7JHHMxkYfKQQax872FjvbW3zza19lPC14+vw5jx4/ZTwtuP/WO7zzla+wMdxECsmjhw959vQpb7/zDvv7++eD3oVB38ae1VVFWYbFVNYG4HE+hF6OTs84Oz1Fac1wMGRrOwB9d0VuV7r9e93ok1WT61XXtHIdKmaZArMIbBf116WU0nwVBCilLu2lOk/xtGN/UXtZGxa9SalwzlLXNcbUgCCOI6y1WFsjpSTPC4wxaB0jhcJ6Q13V1HUVVj/bGiEEUZTgfZhkyrJs0mm4mS9qNBo15cccHR1dySa8duC+VFozRHQPBbqkC4DrgP38b8sArzuJLJpg1qV55q/p1u+qTa2vOnaVrALzFyl/XqO+alKYfzfXyVp5eSA7nLWMRiOePXuGkJrhxgZVXYIAieTjjz/jd773u5yejYjjmJ//9td5772vcvj8iM8/+4wnT59zY2ebn//G19ndDmA7ykuOjo/55ONPKYqcb33rG2z2NxAIpBBh8VKvx/Onpzir+fizz3j+/Dnf+Lmv8a2f+ybGVRfyqW8MemwM3ua9d97CCo1OBggZnb9rD6Y2OGsDyAgJ3mG8x9Q108mUqphgrem0gWsvBfzMvK/LiqPykOPjI6I4ZnNzk83NTYbDYVjY1Wn7VsJ6gKtpxnYstTl7VsmyfnDdPrWqP3UVrXXPmZXb+R1EA77njmlr7YXQROccVSdKyhhDVVUURcFoNMJZ21B3IepqOp3OzhdCUBQFZTkljmPG4zHOuVkqCmPM7N4t1axUu+CuxQiFlOcaf/tcWsckyUWLb5m8XuDevC8h5yo+o7Au8kzzL7irzS9LVtQ14RZpnIvK7H5epxO2v3f/zl97XU18layial6ltJ2+6wycB+Clk15zTqQ1xlqqskRpvdC/seze08mEw4MDiiJnOs0pq5rj42MiUaMJJvDe3g6/8svfYXQ24s69u4ymOf/kn/wWk8mUP/WnfpX/2f/0z5KkEiUkElBC8OjxE85GE+7du4t3gt3dbRSyrTSRToh0SpLU3LixRZTc4P69OzhvkUrM0gRfemYhSeIIISW1NTgLCImUQWs8OT4h6/UY9PtMx2OOj48aILDIhtIRIrSnsQGAauOoyhrTRBe1gOE9VGXJ8+fPOHj+nCRN2dzcnFE383maruq/LyIvoum3111lsS8bo4sUjC64ex+SwpnaNIBbXqBfqrpmPBpRliFUNs/zkDhOCE7PTvHeE0URdV1TVRUQVkRLIYmjiCRJiON4lhm0/R4mVNCN83zekm0n3IvH2zaUCCGb791AEglcTKT43/7//t7Sdn1twP1FGMNloDZv1i8C5PmFMIs62CqOb9n9l9VtGe1y1fN0QXPde8//Pv8c3oe8KsYYoiiaZVFcRBPNl7mq7vN1c85xfHyM955YR8RxjHOOp0+fcnB4iI40w+GQfr9Pv98njuOFGR3LsuTg4IDx2QnOmeaom/muhAh0jRAw3BgwHPax1nJ4dMTmxoBf/qWf5+beDe7evYsQCmOnyFkXEbx9/22sM5weF4zGBVVd0c+ygO0epNTNwDpPadDv9zHWIEWA4ctUAngEtjYoKiKpQSmcVzgbkpI9f3bA4eEhG8MBSnT4ee9Bhn5sTI1zHik1SmosBpwliTTWWYqimml+WmvwQd0r8hBt8/z5c9I05Stf+cqF/DrrWlwvIlddu0rDX9RX58/rWtNwrlW32vZkMqEoCp4+fTqjAqfjcEyI8zUH7eTYjgEpJVtbW6RpynAz+DJ0o4B0/ymlEICSau3nnZ98Fu9B6/DezUC8TUN9PllBd6PFf3U0d3FOuVyq9DX7Wdt4i3ZRasuf1zKXAfm8LEpBvOzaRZPFqnzPy55l/vu1Bp4HcZHLoq4qvnjwgMPDQ7TWZFlGv9en1++RZRlJnKD04rS5876JRbyklBLnPQ8fPGAymbC7u8u0rjk4eN7wxxZjasqqZDIJibiUUsRxTL/XZzAcMOj3SeKYs7MzTk5Og5PJOXCeuq6piwrvggP0/Bmb0EhAKsne3h4ewc7uNr0sw9NoU2iE1DhbI4QnTVIqU6G1J44k41FBP+3RKu+SlpPVKKExNgC+dI6lnbPpzi3wC+GoypKgecUoEWLvHQHAZaTAhwVSzjm8sXg8kY6oa8Ozp8/46OOP+ezTzymrkrt37nLv/j329veJ4xhrbZOqWKB1jNJq5mCcTqeUZRmq1VUWZl2r6VMdjbL7fl+ZtJb5nK3TflrU160NfHaY6Azj8ZijoyPyPMc5R13XjMfjmaLSgnGWZWxubtLv9+llGWkaEsBFUQD0duUw7fh3Ducbv44QRHEEQszue8mqbNpPdHCrfbrZU3VOF6IF5yBSCtxstXIb0rs4GqjTky61zyp5fcCdL59n7soqkFz227IUxOto4uuC8rqm7dogL6CbHKIsKx4/fkCRT7BNZEZZFJwcHQMBZKM4Is0yBoMBWZbR6/VIkoQoihZaJPPafgv2dcMpm6omzydUVQCYuq6w1oA4BxFnLWVeUExzjg4PwwCNdWPiMpuU8J5IayoZeGqcATxCKQQXNTrfDgghMV4iRYRG4b3FWI/ABo1fZgSOMyGKFJPJKXbb4qUC4ZBYhIckzrBWIawK95St1bDkHQkPQlHZGmF9mJysw1HihUQqhYwSvDdUJmiYUkq01lgDh4cHfPLJp3z88cccHR2GzUOaZzr92YiffPA+/cGA27du89Zbb3H71i2SJMVaR1UWSAlKaaSMwF2kBaWUeAfeOzyWsqpQOr7kkF1Fla0jF/pGg1HN67ygGFjnKMqCs7MzRqMReZ7PQLssy1n/ay2UjY0N+v0+aZrOtPB2w5RV9Z0pZ77tH00dfKNJi6AYIM6drKt8FN77cC4t9M5NADNxtFq395YWrH1jec5ujmx+s81n0fntevLagPu8KXhtDZXVgDsPyutqzO15y/K3vIz5ukpeVbndUsqy5OnTp+R5McuxIoS4AP4BZC1FUXJ6chKcikoSx3HghwcDelmPfr9H3OwnKoRACnk+QCBoQN7jrePs9BSPwzsXFuYUBcZaEMGsnZXRrXijtSHAmDqsYFWBKzcmx9RjrAWpNEIqlFLYeWftTFOU9PoD8qIiShTOGLxwswgbgLLIESJBiBitU8raEMcSIQVSK4TQaC2wzuG9wBrbVn+5eHj0+BFSx2xtbZJECqH0LL+MMwYnJdJo0iRFKMHh0RGffvopH3/4IScnJwwHA+7fv8c7d/d59Pgxh0fHVHWN9R6HYDRqVsd++GFYHXvrNm+99Q77+3tkWdxQFTkffPgBXsD+/v5MG3UmRGN4Z8mnU/LqlBs3boQ8OXMW2XX64zL+3DlHXVZUVcV0OuXk5ITj42PKMsT0IwNlsrm5yc2bN7l///4MvLvUYfcey+jUZVRmy4F3Lc3ufq/zlgssc0B3rI/ZRLGwMWgnECHas1ZNlnNWje/Wv73XVWUEeW3Avcu1zjtErpJux5unDV4WJNv7t1rVi0w68/VYRhO9aHmrxANSBO/9kydPmkEVeHBnL0+is0HUXOzxWGPJbU6RFxwfHs3Oi+KYLE3p9/tkDaXTalFlMcXWZaA+PNRVSVHkRHGMrUqKoibp9dGRbupisc5fmESV1uRlTiQVWiuECSGBztV4W+MNWGPwKsE5cam/CCFRUYKKYoRKSNII6Wqc9LMFJc4JnDBUZYXUfZJMoeIdDo+e0u/vUlvD0dERg0FElAxQSmIij2cEqAvWx6V35OHBoy94djAh6/Uoy5xf+eU/zu7WJrH2WFMhcdi65CcffchPf/JTDo8P6WUZb9+/w5/+1e+yu7NDHMVMp1O++fX3mEwnPD845ItHj3l+eMgkL7De4XzIa//hhx/x8cefkmUpe3s7TWKzuyQNSLZUR1WWKO/wBI5XosAF/r4FulWRTYustfZvO3mUZTmLJBmNRlRVRV3VRFrT7/cZDAZ89atfnVmGUsoLWvM6953/vPRdiHMH5rx231pLLZW7iDrVWs/omaYms7Hj8Y01sqDOArzz4EVIUgogg8WEV41u0QL6PPXiZ76e5uvFgq+Q1wbc50O14JxzuyoqpTvbruPkfFHa5jJ4XJ1OuFtHuOzI/dLFQ1lVPH36hOl0wvHxCXEc8fnnnyOkZtAfzAaWECIsumi3q5MS3wB9l1sUogkly3OKPOf45Biad5AkCWmaIkUAbG8d0+kUgUcqxfd/93f5vd/7AVVtGWxusrExYGdnl5t7+9y4sYtSetbOSirSSOOtwZYVwlVIARKP8Mxi3qXoOoNDPaMopjcY0h/sYr3HOAcWLApUgnAOTw0i8NxRlFFZR1EGHl2IBOc1xnqOT04ZDO9RljWmtggc1lUkabTcKUkzXL2nqmqQBU+fHjCa1PQSyLYinClxtcHUNf1ewntffYtf2fgF9m7skCYSIRSeYB4ooUBLNoYRG8NN3n33bfIi5/DojIePHvP02QGj8QRrHDjLdDLhs+kZDx8+Ym9vn3/j3/if0Ov1wnv0jcHfvFLRzORCXnZWtu+7/XuB9mqAvCxL8jwP2w6enoV4fRHisbMso9/vzyyCuIk06U4Kl/nl5QpPe3yZld/9vCoooPuv9YXNb1DfLb/FofP7hDbzHUDu3redJMNeAuflhD7h2t5xwR/W5eVDWYLLTXO+1uMqeW3AfZlGvI5X/yrQfhGue9E1XUftjNIQYmEdFzkd58taV152Mqhrw3h8NtsG7p/983/K+z97H0HQjvv9ARsbQ7a2ttnc2mFzOGCYZXgZI0QUNA/aTS9k2GZOdt5Xw6O6Bsjz6ZTNQR9rDGVdE8URXzz4gt/+7d/m6ZOnYTAhOD58yvHBIw4e94m//W32dxJsEXjHOElRosfhs6dsbWyF9pYiaOgNjySaUEFwIBxCClSckG1ss7G5SxwngCCf5kjpiWXQpp3v4ZzFVGOkzxlPKqo6AiERokJ6wd7OPlpYkijmK2+/R5r1GY9LrA/gX+SCo+Nn7O/tM29Kz4uxFcqC1gIlIpAxXjqE8IFKkorNzS1u3dpHN5OpcZaiqCmrMZtbmzhgUnviuI/AokRNvx/RS4fcu3Wb2tacnp3w9PFTHj95jhOaW3fucufuPW7c2OeP//F/jSRNg9MOCdZifE1Z5ownZ5yejEj722xtb1/yrXTB3BjDaDRiMplwdnY2i0AJzssBt2/dJUkSlL6sWXvf+ic68HQ+u1ySeeVp2dhcR4vvWuDted0yZ1q4P187053MhBCzdnHOYbEg5Gxi6G6n2J4zK7PRW6VvraG2FUTzuQX7wL+fQ0Pbvxc/y1Xy2oB7t0FbuUpjn5dlL38dKmXdBmsBHi5aGOvUfV365UWpn0UihKCuK05PT4gizT/6x/+IDz/6YDbQjDVUZcHJ8QGuLimnp3wynuIdqCghywbcuHGDjc0Ner0+aZIRgN4iBLNFF0o2WoYQSKWYTqZoJSmLnH/8T/4RH374EVVd02orUkCsFV997yv80i/+AlsbW9R1SVUWYbIwUFUJzjpqW3F2NuVHP/599vdv8bX37gdDeNZEAeDjJGNz7yZR2mt+E8EcblaxAo1prJCqMb9t6xRzaB3Ri1N6mUIrQ10VYC2bwxgd1WRRRG0j8rImirfgtAgO4ys0qaC9V2itkFIhZsvTPUWR44Via2uLYloSRwmPnz7l6PiUu/duoVXIU+MReCkxVpFPDM5NSFLJVr+PqQriSLG3u8Pezg7f+Oa38DImSjOUilFSMx6P0UmEVoqzo2ccP3vItMxx3qG0wjnBNA8blrScdMs1B438FGMMQgiSJKHX6/HWW2+RZdnFJGi+dQi2/5ipo7PXdaFrC+Z7ehdw2z68THmaV8raz6vG2vwq1GX3bJ237dqOrvXdHrftQrQO5dNatnCe0qBV8OctBFhEJ15spFWK4yp5bcAdVtMeXVk1Oy8y29b9/brSDoB167nuBPIqfQZFkfPBR+/jvOcf/Pd/n88++yxoA/7cBRRrxS9861v84i/8PFVV4rynNsGpOp5MGI2OefTgU6qqRihNkiRsbQ25des2g+GAJ48ek6Ux/X6fKElJkpQ0SfnJj3/Mv/zd73E2HgWAbbag00Lx1t3bfPeXvsXtWzdRMmi+IYlucIBWxrIRR0R7N/jg/Q94+MUTnj07YXNrJyB0A9htgjDvw8bWcdynjTjwLbAjQRh8CzwCvBNNG0iGaYSLIY1ACAN+inchSkZ6j6urZmISSCkYJIJhT7O7fR/hwy5PCzX3GYYHakbrONBOiACCXnJ2Oqa/sROWsdsphYe8KCirnCyNgwnfUF5agBIaJQwqkmGCjGNMnRO0P0BItFLoNMFKMK7COcvPPnif+LOwgrUeH2GKCf2tXYabt9BxTBRrkIKqqvjiiy/49NNPqeua27dvc+NGWCNwCciZH6MCmjUH0gdKwnfovCBXJztbNEa7YD6/SLGddOYpo0Wy7JyuQ3V+zLXPPF/m/CKk+dDrC+UEUj5QYSJEW53TM1dj2ovI6wPu3i80z7ovcRlPt4iWOTcBgSt4unCgc9NrtOW8Fn8dOac1fPfg5d+7co16ikaL9t7x3//9v8+TR49DR2xc7h5Pr5fxq3/sV/i5r70XjhlAQqQtWZKwvTkMmqMPS6PLqmYyHocc5kdPMfkZx8+f8tko7D2qtCZNM4aDIaaquHd7H2N2OR2PmBZT+mnGd3/hO7z79n2iOIQzSs/M2RSUltDxhRQgJONJgReCQX+DZl5qNCFxgX8Us78e58HWFfnkmPFk2kTUhFA/0fgSvDBY70gjiTUO58vA59P2nfNQtFl/c80UZINjdmomM7haNMnf2N1lPDU8e/480BVSz57TA3leIKMy2DNSEsUJoj1BCqRQSNU4bttoCyGJdYScrcTqaK0E015isSYsspJSgPOUueN5WZLKikGa0R/ucTaecnT0OU+fPeGLhw94+PAhT548oSgKvvnNb/KX//JfZnd3d9YGC5WYhZ0z+EKaZTiruuna0jo2u2B7pZZ/gcO+rOF3Py/Cl0VW+XyumdaP1o2o6aY36DxBU5f282X/2yItfb5ui85bJK8PuBP4XLFggVB3VoQ16Y2OMvGHJdeadVsLlldHyXjvQ/yvTnjr3lukOuL09JQyL6jKks3NHn/6T/0qd+/cw1qHdR6U5OhsjPCWSEcIKcLCj0QjPPSilF6WcnNvm7IsSLMQC++Moa5rrHOUZcV4NMaakv29Hd56K5RvasNwY0iaZSFEzziSqFmJ51t+MSCbIPDjkpCHZXR2xtnRlHfe2mtwT9D6qtrB4vHgplRFSVkW5PmE09Mjnj19Tm8wDAu0kgSlQkoBrQRSOJwrm0mveRECvFcBxKVCoEJ0TggMh8bfIDvvrW3vrgjg6195l6999WuMJxPyombQi4ikR7owiVjrOT454/6920gESii0UOACN962hsSjpMD5sHBLaI1UjWY8uxvnjmbn8bbCeYfzCiEkMuohvMQ7T1EW/Iv/7r/hX37v+xwdH2ONQShFkibcvnObr3zlK3z3l345RDqVVVhyLwVeLMifLgDfcskNdSGaFWCYtnHaVmKdQbloDMxrxlf6slZARJdLnz/WSgvOXcqldZJe2upxjgrqlhWc2L6xMttnax33XCpjnbZYBwNfG3BvNZll3PUyM+2lxF+cAZYY1xfruarx5y8W3XvM/bDkt7Wcv91bLatwU4wUgl/6zne5f+8uDz7/CGMqnHFMJ1NiLRgM+oEdlQItJXVdUhsDzlDVNbWpUVHEcGODPC/YGPSJlMBbQmRMlgYwtHVYXdloLLvb22RZxsbmgKKYAj7wv5GmMhZnPUkaI4SdmauXLTc/i8EXIiTxogGvVvlp31zg/w2nR08om7DPH//oZ3z86QOqqmT/zh7f+c53SHTMw4cPuXnzBvfv3aafJQHEvWzqEFEZi6kNUaRASmojSdMtnHUgLZ4cZ8x5qqMVnKh3DoRhkKUMsgQlKqRwGBOAQ+uI5wcns5fWNoMQssFMP7NqW6D3Hhxiphmfv+5zCqTIa1AKpZoFO94hmp2jUMFvdHNnyK9855uURYGOYrJen62dHfobG6AURZ7zwQcfEEURw+GQ7Z1thhsbs4Rk7bOGOrnzyJHZ83c495ccri0H3qVfWpBd6Ztra7HglGWWSPtbK10wn9f2l1kCCx6A7srctomu6wu84Jy+4trXBtyB2RMvi365XoRJexGNtnWxLNH+9go6nZi9uDlZWt3Ojdt6vaDTZHGlLn6VwHR8ynh0jLUBlCIlGfT7KEAlKdI5XB34Y2eZAYpzoBpAMbXB1C7ws41GNosqEIJebxPnbUio5RVZopudkcSMLiiqCiEjkiTGCxr36nmnv/hKxOz1OQcq0gwGvXBUuAtne+9xpubDjz/g937wEx48eYJWmrfv3+G9975KkkR4BJ989DHT6ZRb+zfQWuGFxxPjhKeuPWVR4YUlUhod7CgqU+HcgLL0CBmjIo8QBZHWxJHCFhOWv2wx45HCPGAwGHzjN/AIxpNpiKEmLCpSzaKxkMfGzawKIRVKaLR2zIc/n+vv4X2cjmsqV7Kzs02WJhT5GbbO0UqHHiEc+3tb7O9tA1AWJVXtOTwKfWSwsYmMAklVVRUHBwccHB4SJzFf/epX2d7ePr+/98hmRdfldZwhlvu8e6+ntbda+rJU3IuAfZHltPQeXHRuriOLKKAutXp+e98agJfvKmZqLPN9ZpXjuHvf+ePL5LUA96CFrTZHVs1g8+dekEZruKD1X/h94a0X17Mz6VyyIloNc72iLp130flyPWC/rO9263UeEy48CCfAO7ywDb8sZsqnaAaoazQ9KUTj4vSAw7t2+fu5SCFRUuGsQcqIw+MRsVbs7W4jXIn3FoFEqxjrLM6BMVVYUCMaDYSLg6bbBgKIIsm9e7d556132NvNwFfMHIgdsc7TH2zw7W9/k69//Stsb29TViU/e/9DJpOc7/7yL/Nn/vSfJIp04C8IvH5RGCpbo2VYDJX1QgglwjUWA8EpgKSqHMJZPCWCiv2be9hivJCbvfg2Zjpb542Flb3et/HMwUeSpilZFXKqeGdxaYbzHmsdiJCaVgqJ1sFBfN5STT1F2MpPe4MXAqmi5v074kg1FMrFWvnG1/DZp5/y0Wef0x9u8O5X3uPtr7zXWWCkKMsSY8yFdSXOudn7kgsUMN9aZp3vVylqXYBfRX/Mf+6eswxkQ1OLGcC313T/rqI9lmHNTJ9cqdQtli63vpJquoass4fqfeBvA/tN7X7Te/83hBA7wH8OvAN8CvwF7/2xCE/+Nwh7qU6Bv+i9/96qe3TZOOfDsvVlFMy16Rl5rlNfpE/OUX1dKuZcS4cLXeYabX+pvi9vsV7gnWf/P8eP4IsjtOssprbp/AIXtGM8WkWzcsJ7CBMBPjgoPR4vXBOwG7RE58Da8+NCOIyzOCFQBG1dCDfr8AJJXVXBhPeyoWU67dN6Vr1HeoEQhl/+ztebXCgeicE1UBS8q+2Voax+L6Pfy8BbxpMJG8M+v/zHfpHNrU0G/S28dThT0y4/kQh0EoOR4GOkrBGymexkU3gT5ukbcy/ko2n3Drj4+uejNgCU1DjXZjJp2r3JAikkM2bdI3CuZpJPyPNpAB8hkU0fUTIKWSVdSaCDPZnuvve2P4d84L55P/iwbWDW65NPJ2RpTLfjtS5kLxxf+/pXuX3vDr//wx/z4Isv6PWH3Lh5kzRLm67gefbsGVtbW/T7/UvP291fAc6BfF7DXkSnzMbXwknyYvteCb7eN20a2rn7llpl5rzlzsel860L+Lqj8rzfnk8ybk5Pu6jdd9vlOj7FdSZHWE9zN8D/1nv/PSHEEPgdIcR/B/xF4O977/+6EOKvAX8N+I+BPwd8rfn3J4C/2fxdKs5ZyqpEqjgkU6Jtp8uz9Cvh2i+g3xWnXgL2S9C+dhlXHbuOzEClM18t4/GccCGrYiBfO8/hOY/A8AgCWKVpj8pIhKvxyjRGZFdnP6dQvNAk2ZC6jvBCk+c1OlY4Qqie9A584HqFCLaCbWPLPXQT28gu1zBTgwyRtHhvzpdv0wJt65DqNka7JFwyGAwQIuSfUaqHpQFvZZFIXLPJhpAKKT3OyRChIh3ey/NuIoOPISgfDi0EKgrgiVxtYYIgilO8VFRFETj4dmoRnu2dIW9VtwLN4kJ+nuHGkCzN2BwOwkpfZ/HOEmuHFzVyCEJFOO9mb2VmPbaVlgpbN4ukmvTIUqmmrbqzaQMWQBRHDDcG7N+6jdYRn3z+BT/60feZfq9mZ3ePW7dusb+/P1uws0iznt/xqQXxeUBqKZGusjYfOLEoSmT++va6VUDv/UVwb1/r/Hvy/nw6WDTJrLOD1UXrYbkGPm8pLEpBfl7O9dOTwHobZD8GHjefR0KInwB3gV8D/mxz2t8C/iEB3H8N+Ns+1Oa3hBBbQojbTTkLZTqd8sknn7C9s0ea9YijmDiOiNudZGb/Y+nL/jKkqyVI2bmvP3djXcTRc5N7ZhZ2NQbRNclfpmIX63de9sUJUAiBtYbnz581W3RdLqcFTGc9Xnq881gjsDVo7dGRblKlhvehtJqBfW+wzWCzTRkQgO+r7w0oq4ooTpAOvI1xosJTzfTToLWI2V6SLShfrNplwJwd8S2Y++7RTp/ws998E8WhdI/Hjw+4e2sbJSXOizD4BIhZvpHGaSvEhYVGYU4MzmLnHCrSpBtDqqK6UM+2Dl0Lz3lNWXvABDBusFU0E9Jw2GdjuIk3BbGS9NKYXroTTvL1OSfsLbY8w4sxSghwCt1smn1xMg9tKaWgNpaqrhAibZ6jndI77TabFIO1JpUiShJu3t5n++YNJpMp//Af/zMmkwmj0WiW0KvV2i91qTlQ6o6hS+0jLkbeLJok58tpz1vbkclFqzacv/L00AdaTbzTL8NCvZCqt11/MC/t2eE9i+bvZZBf9qzt853X/XL/WnR8kVyLcxdCvAN8F/htYL8D2E8ItA0E4P+ic9mD5tgFcBdC/Drw6wD9fo/j4yOskwyHJmT4s5ZIa7Y2N+kPeih1/YRg6/BnK551rixotzrDu9nsfhGs550/vnm5y/PJdMtYq4atgtYB8Nnd5zQp7z2T8YR/8S/+BcLkbA17nZqd/wuaoUPqc6gytqaqxuBtWMAjNWVZYYwlUgohJcONHeI48MEOj/CStKdIsrCKFR/jrIfxGEzYxUaqwBPXlUHriAva96VnnXEhC+RiJ9daY+z5NmneB4BrHZdKSExVIoTH2rCwhxl1JMLuX1YQEjW5zgR6biXNpg4pqITDiYXju/OqJJNJTe00Fodjws7OFko4hLH4Zqs2fMhXI6TDu7LRHpu0wqIF5Za3buI/rcXZav6G0Gjhvb4i7m2Bl3jXRrKsakqHsSHj5aQoODk7xXvJzZu3+Ct/5X/Nrdt3GAyHs02ll3HdF4r1neRaC3wS4R0t3nNhFXh3Nf5FNJj37eS1akQtWpfim/e/Ytm/n7N8WunoArNDc31jNQasj1PrWv1rg7sQYgD8v4D/jff+bO4lebGoNVaI9/43gd8EuHlzz29vb+GFYTx5ThIPUSqmqioeP35Cr5eyubVBr9e7sC/ksllt0WfRUBKdJ+IioPiOqd+O6PlwI3l+aajEhb9LTb1LP7SD4uK5C05Z+PMqjWn+t8l0ysHBEXf2NjpH/fyURKQDTQGeGzs9nIuo64y6qrAu7KRUSjlL2hU0GzEHGh0IbM4RM148tLetDcV0ysagj5bdAXiuLYX2b4oRIFTcbNbR1t1fGLpCEKKAGnCbledliIYREqQkSUPYphQhugdv8MTnjTt7ve1S87CwSGuFQ6FUTV1bTkenFKMJ/SxjZzCY1bu9dws8zjvCgixBUZbUZsSgn+CtY6Pfo7at1i3Dtm1pghMOiWnqpAGPVDJQSUo1FpINeexnzd18ENDSXM5MEMIhiCmLGu+b5FeLAE9AG30kZIQQMVVtmUymvP3OBl/96nvEaXqpf833tTbn0rm1u3j/A+DCnqXzvy+iY9vj5xO3vATql55p1hXF5fG06JKZkjGvVfvZLN/6Tq4jbV/yl6zNi3jkG7Bo67tI678Oc7EWuAshIgKw/z+89//v5vDTlm4RQtwGnjXHHwL3O5ffa44tFeccT548IS9zdAyRTuj3h/SzbYSXnJwc8ejxQzY2NtjY2Jg5c1otYpG0DTlrBG+bGGxDVdUYY2cmbYgECC+v18uI4yRkyHMXO/Kssy3ZXsv7eYhuJ6Bm4DQDudGX26tm5y4S0f20pibQ1tMYw8HBAfv7+0hfMN/D2ylJSYe3DlPnWFcDFcJ7Ei1JozRcJT29m9sIIcOCFwHWFJTVhCLPcQh0FKFUhJIapaKwv6gITtv21mkac2t/l+EgCxqqczNQOvcFiE7391AHy2eSV8SJRorzIRiAgLCa1XTaRCqkiukN+gihQWmywRCPBiIkDidUA4uiiSqRKC3xPoCgRDRUjMALi05AekNVTVFaUlQFlbNh443mObqA5LzDNx4kpSIQMVJIjHNIoZESzkYjvFdsbm0yrQxZllJZz2RaBI3dOTY3N7FekhuJUr3gWPYTokghsZiqpINknHtUBFDPxkI3Q+GFfhBeMB7H1tYNonQDKwWjs7PgC1igSF0qY44WnOfSu31zEdVyVZldbtq30Tm+A75zFF1z4fnzzVnUARuYu6YF4Pbe7XlN2UJyKQT38l2XPU2nXdp2uHh/f6GdCAyBOw8uXZXqZJGsEy0jgP8b8BPv/f+x89N/DfyHwF9v/v5XneN/VQjxdwiO1NNVfDuE3WJ2dvapjW9ygkcYW1IVBXleYK0lTTPKsuTBgwc8ffqUwSBjONxgZ2ebfm+AUpr25XjvsVVNWZcUxZTT0xPK6YQ8zzGmJooiqrKiKMtmN6KwKURla5Ik4ebNm+zf3OfG7h5xkkADAuuaQ53Gaz8ALbUDs05zfuLiyy98CN1omYnbSlfrUUqR5zk/+fFP+MVvfaVT4sXrTJ3T+Pc69WrbEoSQaBHila0zCG+RCKajQw4PT/joo49BSPr9Ab1+jzTNSLKUJE1I4ghn6hmAp6kiEwowzWR4OSzv4l/JWVHx0QdfcHp6zK/+6i8i9fwq5uZcKVBRSpxm9AYbJGkflSTkeYG3gp2dBJzFKQ2uh6ynCMxsIFtrmrz9rvGxnA9u5y0ykUgcWI9SwTmcu4ok0fiivrCU4hxIQ7ipFBIv1GxACyEQXnJ0eIaIeuzcSKmLM6bOcVrmHB0e8Nad2zMaq9VEnYXp2KCjAuNgo9ej9uehhudg01ie3V62Ivd8ODekSs6yHmn/Pvs3gyP3Iv24WJOcT5M7v4n6VdEf89+7dEur4c8mBk+Lfs001jo6ZfvkF8tbfNfuU8yOXJiIaC140WzBd05vFVWOR5K2O1ddV51fIMFwaJ5bEFx7S6ived5+kayjuf9p4D8Afl8I8f3m2P+OAOr/hRDiLwGfAX+h+e3vEsIgPySEQv5HV93AuRprz/A+oq6hriYgIEt7DIebjEcTTk5OmUymTKcTlBIcHoaNaqMoYmOwyc3dm0gpOT49ZTwaMR6fhgEqRQB0JWcpO4siZzoZM82nTCYB9MOu5Qmml/GzowM++MlPuH3rFptbOww2N7l37z5x2pu9gEVc3/IpvDULL0eczJ+2+HP40l2hNy/LHKv/2q/8Cr/0C7/Iw8/e5+Hnn8zdr3X4CLxQOAxSa6xLsL5GEJa837v/Nts7e1hrKcuCIp8ymYx4+OghURpz/923qMuwu87h4XNqY6jrAAx3bu1x987tUO9GY5EX6KxzjdO3INY8j28ieIyDk9EZwsuQVXEhHwo6Tri5cwudxoSYfYnD43xDD4gwu0rC4iBsFSy6WURHA4giAKHwAZQjrXCAaTh84wy2tggJRZ0Ti2hW7/P3IxprpD0ucRascSFenUAPGeMp65DvHhE2qxjc2EImGqRuuHaPpAkN9QLhPVpplOhw1m0jNBNHrz8kn+aBl5fNxt5uMS3jOx9a3BSN/6gNOxVcpOC6TtEuwHf7IlyOMOlSK90dkLoafTcDY9uebYillHK2k1UA9cbSmylA5/2h/T7vGzvXzrss3uVUAOFDCCsV3s/CJJ2r+eFPfw8fJ/zCV79BGgVqT1zi8Tv9e77NF47hi88Qqn2xbbttdZWsEy3zT1kOW//WgvM98FeuvHNHjJ1ydPxDpMrIkh5x0gMko7FG6RglUrY2E7SOcVubTKchU+HZyQnG1Jz2jnn++AlFkWNNjY40VV1inaU/3AgO2trhvcU2OcedNSgpSaKILI45PTtjOp5ydnqCbwZPPp0i1af0+n2ePHrI2+9+lZ3dXbJeHyU1yNZZtUj7aD4IZoOOuQ54fsI55TLbNMOF+PJWE2vTisL1ZnEpJUmaNCsTF3QID8YqTs9GRFGMl5qnzwo++fx9pKy5eWOPw5Mph0f/A8bWaJ1wY3eXm7ducev+10kixWQ8pi4mGFNh6irQNni0EgwGKVVZ46xF+ACOVe04Ox1hnWN/f3sONuZFoFQT9nYhXOyyfialJI57C8mn9lkvXNHQQKIhT5RWRIkgTsLvdVXhrSFWILUgFx6EDdu+aY11lrPTEdnWFqnWgQcPCwJm2vMsVBGoqpqyCukfZhqZlFTTOmTKFVA5y3haoSNNmA2D9iiknMXbBzCTSNn2qxZEWg3Uk+dlsIlmDkKoy/LCrpzz7YyH6XiM84H/VyqCJm3BhTOX8O7d/jj/r3vOPLB3y+pmWu2WeWEi6dBfYSa63HvO+fPZnec+d4i/TlHtPUUH+Z2zFFVJmmbgPU8On/H87AAfKR4dbPLu7bfRMoSZipnC1FocnXwzTcew1jItpvTSXoeAbOrVTjztc3TG/HUiZeA1WaHqnSLPQ56RuipQoxDV4AWBn/QJziiq0uKsCDmShZtRD8V0zKg6pqoqNjYGSKlI05gkSRiNxnggjWNKZ5lOp2ETYA91USK8pzY1g16fM6aznNvT6ZTRwQEAN2/e5NmTx4xHZ2xsbjLc2GRra4ed3T36/UFYKHWpwbsafWcGn4H97EdmUNDpwG1ObdE53p4DF03XVS/eWsvR0XPGk8lc/c7Nv7w0FOWUOElxWJSKkRKKYspkMubx40eAYDQeo7Xm8NlDPv34p01+lvvkRYG1ns2tTZL+AK0jFI4kblKbnp1SFQU4T1UZTsYTRmenDAcDhFcg7Hx2iE67BO46z3NcXeEsKDlbCXF+atPmXtJkmQwap7VBU25zMQrELADHi7AwKlUuaKiuBG3BukYTtnhncMZhqxNcqnDSEEXnG0mbuqbGE0USWbYu0ADCUng2+imWhNIYnM+Ct8Xac8AUgrPRFIvHCng+OuWsnJIlKXd2bjQBQyKAf7OptZMCtMSrQEW1S24aHQ+E4HRkQVqGGxkKh61KJA4dKaQIKclmU2pjIeE9P/nhD6idZXfvBptbG2xsbALv4TsAPw/i88fnz+nmZmkBfJnmOe887cbKX/ZxiQv4vcx5e/Ea3/nbasMrLGEsh8fP+Oijj/jWt38BKQSfPvkUox1VVfLg8CG3926zmcRYbGethr9AVYXQyVDuk4NH/OTj9/mVb/9xhtl5SGl4IxeDHeYn0lVRRPPyWoA7SJyNUCpFipQyLymLEillWCouNbUpsI3DrNfPqKqwA8xoNCaJYzY3NhkOBwyHA2pjKG3NZDKhcpZYa4SAPM8pioKyLImUJstSyrLE44mTlMxBbSqSJMF7z+72Nnfu3KUsC05Pz3j+/BmTyRhT5hw8eURZG+699RZf+erX6PUGCNWE9uHPdwuao298o41ba1CqcQj7c6AKTsUgSsoZDzgP6u3nVpZpOsbUlEXJJX1NnC/IinREmma0UYBSSvqDIc5PiZOIwaBHFMUMN/rc2L3Brf2b4Erw0EsyJJLaTPHe8dMf/xjnHO997WucnlYzzTXtbxMnPXQksdEpSEXSLAQSM2eE53ygnde3rmtqU2HKiqoO4HouITa/5WKFd3hTU9uKssgx9ZTJNJ/BXxRHzc45MdIZhPOYKj9P29v8/zxySkKsIIo5m4w4Pj5impcIcW5lGbdJtnsDahMWazWLwQJeFkBFohW3bwwCqAqFMTasAhZQ12HFrheAEvT6vRlIhD1FQ12kFNgmdvp87mv7hr+AUc55HJaqqhj2e9iqQCmNkk2ul3ZynGMO0jTh4NEjDg6fc/v2HX7u5/pNPMBi62oV2MwidDr9f10nanv9pfL9+XlSSkK+zMsZbZb5oxbVs6UMF/HbZVXywQcfcHxyxGdffMb+/k2MMzjr2Rps00/75NMpfRnzk08+4L233yXLstnYuuA78J7xdMxP33+fvM45Oj5kkJ2/a++7vX79+i+T1wLcvQNbCCwlkZVkUjIc9hFCkRcFzhoGvcFMC0vThEpLjDH09m7QH/SxzmG9BRwjmzMqCorphCiKsM7z4OFDrDH0+316vR7GWkYuZOjb3dtFCEllKo6OTrG2ptfrMR6P+PTTj3nnnXe4desmR4eHlHnB+OyMW7dvY63j6cMHPHrwkHe/8h733/4KWa+PUCFP+SJNwjnH2WjED3/8+3zrm99ie3MbvGIWLRJGXhhMAooqTDah7zV89RUD5ZIW786h64IjtgF4KXXDcxLGuxD00gF1fYJSgjgJaQkUPkQVBT0TBDhR4XzY6BnnOTk6Js8nfOsb32CQDrFUjMYTyumIk+ODYBUoTb+/wXDQJ44iIukwtkBWYaLFd9YLeKgqQ7+f0d/ZaxznFy2f9lxnDaOjLzBVTV2WHB2f8ODxI54/P2Rra5s7d+7Q62VUdUWSxAwHGVkSg2s2CRGBNT0PrReAwjuPqW2Io/eCXtbHWINS4cS6KLG1CaGdTRbGYHWJhq/24MIK28DaSlyzdaGU0O+nSKk5MyWTMgcpGPSHKKWRNCt3vQ+pCKKIJBEoVaM0IT7f07FGHNIrpI6CdStabtkTpxmTyYg0S1CXCQEg5J+/99bb1KZA4pDedhZ0nfevRZZidzXq/HmL+ukyAG7/zedDr6qK8XjMzs5OQ1e0ocbrR5DM6tMOgXbLzLk6uWYl8ZMnTzg5OQmpmUen+Njz9NlTclNhrWXQ6+OF5dMnn/HJg4+x0vGt975JJMJaEDrKmKsdT549ZTQNlOSnX3zO1tYO24M2THl+Y+5zZWfdNu3KawHuUkKkHNZInBA4rakArSS9rQ1Us6FuXQdt1zmLkgorLNPphIODA6QOuagn5ZSJq0myHkmaYsuQvXBjcwOaLeGiKCLb22QsKjZViqw8Tgo2NodkccyTg+eMx2M2hxskScLnn3+Oc440Thj0+5RlxXQyJYoiyrLk+PSM05NTPvnkY9756ld5772vBe2yofbOHTiBYnj/g/d59PQxSku++53vksY9ZjN1y/tJwcHRIT/56U/49s9/m36/z9OnT7h35y6qCcVcpEoZY3h+8Ixb+7eB0EmPj59STk4vAjvMVAUpJWourDRJeyRVEvhur0JyMG8DuLZav29WtjY+BQ/ESdhsQrQcJKAEOFPSjwRpP+NsUnB2dsRkcoJWsvF99MiybXb3EowpKco8lOEcuzs7/Kk/+atkcYwUpgkPa1RXf96+1lqePPycDz74iC8+f0hR12zubHH/3j1u3bjBxrDPo4cP+fyzz/nKe++w0X8LcIHC8SKkJEBjXOvAAyE1tbM4oVBKk2YZx8en3Ll9C6lliJl3Booq7M8qaPy2nXDAGZnLzKkc+kNDiUeCwhtyUyKkQEdxs4WboXaeREd4PNYYnK+oSoOKXJizW6OnceC20vY129D7gapfHE0ye+dJTBTH9AcDzsYWTN0JB+5y1P4SXx6602Xg6TpKu8fbOi7Sos/PC3x4XkxxzvHw4UMePHjIL33nO+zt7TULxZvVoktkvj6u8ZEJ2S5Yu0h7dOtUVRVZlrG9vc3B8RG1rXl8+Ix4kEGtKauSzx9/TlHllNOc3Od88vhTeoM+7955m1ioWfnehy0tz85OGU/GKKWJ4ojJdEo/ScP6nTkrKlTjsjXUHr1qOnstwB0UQg+obIEzFTYWxF4gRUw+KRDCU9clpmoWbuCDtqkFcRwxnU4wDoZpConG5nWjZYFpTMpelkJVY61FDxJcX+OLiom2KO+oFdiqoJieYX14sc6eNjsLpeR5weHhMXfu3GY43ODg+BglJePJmGmeE2lNmU95/0c/5Pj5M7797W+zsbkd+FJEACohKOuCk/IUkcKz06c8fPaQd+++i5Ia33jVPFDVNR98+jOenz3l+fFNRtOE3//J76O15M7+bcLSIxngs1244j1fPPqCTx9+wubmBsPeBraq+OmPf0g/EmxsDC8AS/jgESpEmgg8qrYkWYKIJNbvoZUhaTq89R4dxyAUECG0Jk6HZP3tkANeCu699RbT6RQdhS3iJGrmUvRNAnQtI7LUkyUx/SxGeIMxjrPTAyaTAhUrknRAlikGwyFJklNXoW/4ZqsoT0gXEEqWSCeprSWONO++8xZv3b9Lrz9AKMHZ6RlFMWF7Z5Nv/NzP8fPf/HoIWRaB5bQ+obYhuVlVVnhfESlBmmqc8JQKiMEUhuOTo2AZFAW1DZt/60jjN3rYwqKcm4HNDKgW9PgA7IKbt3aIb2yRVyEdbzxIgrbjHLk39JMIL4JFmkQyZNWUFuHAG4+PHJ6OleA9TgYtv6yqoD2Khu8VsjnLddwUjQaCD+PPCczZmIPDI6QXvPvOTRCaeeRZpj1ehxO+KuqjXU38k09+xMlkjJmUVKXh4cMH3Lixg5hHwwX1WHgPL4O1jESIkATustPXkOdjPvzkQw5OniMiRTZI+eCzD5mWE/qDAYPGvzetctCgs4hxMebh8SNu7+0TRb2ZJey9Y5KPOJ2cYrzFeSjqgryeUtoBUgsU55PBrC6d8M5gpbTRUR5WTGrw2oC7R0jP9rCH70vGriKVCeUkZ5oXDcXhZ+t+qio48NIsJuv3uXPnLiqJEVpxODmlKiu00DPNOQxiiJMY7R1lXVBOKipnkFKQJDGjyYg4jdi6tcfJo2MA6qpmmueMx2Nu3bqFkoqTk1OU0mxvbQEhPKqsDVaCjyTeOp4dPeef/dY/5969t7lz5w46itBRgowUT06eMrU5uh/jasd4MqauK2SsLwQ9nJ6dcnh8hJBgfc2jJweMp2OePn3Krb39oEHPHErB+B/nY97/4iOQjnE1pd8bMhxu8uf//P+S5w8/4/MvPr3U7hAiMZSUYcGOdxRFiXMCJcN6g8FgEBI14UnS4I9QErZ3b5H0hjjniZux8d7Xt88dwY1DkmkO2JmGr7VG+bDUu6GNiSJFlsXBke4dphxzfATPnoLUks3NTQa9TZI0TKJ5brCubqbCcy2+zYMDgauXSrG3t0d/0A8OY+PwtjxvaBS1ERjvkM16hjiOUWJGqASr0RhG4xH4kGrh+cHz2W2Hm0M2hgPIIjAWURp8J7InS8Mq1qKYtGp9k2HRkSUJKlNMvWM6mVAaM6Pfhv0+w/2bYVclZ8FPkORsDiO8UAgVUi1flED2Z1lE4RRd1b2Fry4N0YU95yzOSYQMXPN0VPD1n0svnOj84g0y1uHRL2jqM4dlp/hZEX4WSHB4csTR9BTrLaqn2Uh7TIscYwyxjrhi/rhw3/be1lkOnx+wd7PdvzfUx7f18uF58mLK8ckRzjv6vQHj6ZjBxpDtdAtjLKenpxRFwWAwCPntG7OtNhWVKXEqbVI6B0uwqirefuctjsenSKUpbcWHn30E3nP/1l2UDmRZVztvJ9X2MWeho+3AWSGvBbgLAGepTI0xisLXVLZmGCcIp1BxzOj5MZOTMUVZEMcR+7dusbO9xWg85uzslP5wAxsrrLNoJZvl2bKJBPN4KciGPWocToGgJkYiI0UlPFEchXBDH7G9d4NyMqGc5mF3eh8mFOcMtTGcnB6jdcg6GMcxw+EQkcaU1nB0cEAWxQx6fX764x/yyUcfoLTAS0/Uz7CppLQlrjakKsYaQ1nXKGWRTVy0tY6j4+eNI9FweHTA0fExzhmKYkqZF/QHUQCJBqRqW/PwyReMpieoRDIpzzDuBs4Yfvbxh6RyeX4bRLNniAxAH2uJMWBlTFFZnPMYWzXWjEUohaf56wMYB9wOaCelbCaesHAH0VnQIs5ThUlCKmGJv6CRBOpMsbW9FSKo6pwyP+DBYYmxPiS2urXPEElRTBG25nyD6OY+gI6Dgxsh8TrBigipLMLXAT6anPZaa4R3AdiQCOVpvctSgFKSvK4RMmxvFzUTom6AwRiLy0uEjBpr5ZwWQQpKUyKQs1w00gdlxguBa2ips8MjrAs5cnSzAMhZi6sNXkUIH5LA4T2WKjxXff4KZ0vPZLuD05idftgvti6L8I7aKKBl49ArdJSg44Qsy5AiCnmDvKf1FszHpsM51z4fqruwv3U2he68rg691Hz1YL3n0fEznp8eoZVikPapy4qNzX1eRFolbzI54/0Pf0Rpcu7duY8QMJmOSNMM5UPbl0XF4eEBOEsURxgcUZxQjysODo6wxjAYbnBje4coijBVSNUspKQoS6ZlwXa8cf5ehCBJEg4eHjR7CBSIsiROYg6PDrixvUMcJRcovdAs7UQsmlQa4Xe1lFw7l9cC3BGgYo2TDovD2LAZQJV4auFRykMvITGOvf2b3LlzmzRNEEIwzXMqayg01HUJQpAmSYiCMAH4pJJ4PGVdYYXHShUATUm01kynU2ZLQQTNsnEYDMIWcdZaNjb2qJOK05MTnDEUZUFVVSG2Os1wUuA89Pp9qAxlWaK1pijC3qTGWQbCo+KIui6wlSXtxTx58ph8VBDrlCiKsSZEThyeHIP3aKU4PDpkMpmglebw+IDv/+h7xFFCEicM+kOyrE+Uxjw9eoaIBF44vnj0OTv9fZ4+fsTT4wM2Un15om8OSCmIogRT5xTWsNlv9oukR2VuNwtgYJD0yNKwa5NAoDyIkNCdkAFPNHw8DR0VOqdvCcKG04y0QinRgFg76TTkuXezDtzGn0daEvV7DPtpw8HWfPHhR5TGsLV7g73dXbIsRUwn5PYIZy3ehpuKBjWEzDg4PGZ/e4DQMcYLhJs2uWtEx8MmkLL1FgTt2tmwmClL05DfxUEUaSIVNiqpbQ1JhFMaVRm8DRudCAdHR2OMU6RZL4TnpjHYNjeMQ9SeWlT0N4Yk1pOXU2KlQ+bJKKL0jsE5tjKn686xEk1skmsucE265Zl662kjby70Ad9eLdjeuUGcBIuvqip0HM3OXhbCeHB4SBRFbG5uroScEO1ykS2eTfYXLhQgHHk+5fD4kDgKi5pMXWHKmoPD5xwdH3Fzd+/SRDIflXM5fNDx+OljDsfHxM8ec3Nvn6oq+J0f/g98/b1f4M72Leqy5uD5c54+fYIQAus8SoiAE0pwY3cX5xxxkhLHIQeW854kTamriul0wtl4zK3+jVmI73Q65aOPPuLBw4cYEUK441g31qHj8OgQ4QQb/Y1Lk2J47eeml/e+2afiXwHN3TlPSY0aJkhvSHUaAFYHdrAuS3rbPUajM5599CGfffZZszw8aEfbe7tEGpJ+D1eBMTVahhWGHo+zYISnNh6VRXgfsiAKqXDOksQRRVlS5TV6kNDf7hNJyenRKWl/QKQjxtOczeEGaa/H40ePGI3G3Ny9QZImiDhiggm76MiM6mxMpCRVWSCVoqhrdC/BR4rahF10vPLBaqgtR6NnSGvQMqYsS4RWWBTGO4RqdgISYbs37z1uAoWpqI7GmLwmSzNu3ttnZMuwSAaDGXo+f/IJn3/0cdC2kowLziPOnaKingYAsAZcjcM00RyghAMnkV6SRRLR1EFIqIoTXO45OT4BwkQZNhJWqCgKuVpUcIqGOGpH1ORoCWDf5BpvdRPRgmobARLAWYkU601Ta0caa3Y2h1S2pipGfPHpKc5LkrTP3q39ZgHaGcX4LGiKzWIg4QNXj5MIUeGaVZhCSJQFRKAkhHAgJE56TKoRQiJNTexjvJQU04I4imfRMgqN9R6nBQKFN6BMoKaOTyecnFpUNGa4qbh1ax+sZ2PQp7IjvFJ4oShHZ0zzHOssU2Mpy5Lbt28hBwMmSiCTBGkUUqZ4DM7mASidxXt7Dpodqg4Ie7A2FoP3tm34C+NP0IZXhp2ppI7oRTFZX2BNhRMh/rqFyFn8thA8evKI7/3g++zduMF3f/GXieY2uA8SJhshPJWxqEij2g20Z3OUvzBfVcbyyaPPODg5oDA5Uiq2+pskSUxRFTx+/jisq9DxjMoQol3Zeu73mD1jA/LOW04mJ3hgWk4ZTU45PH3O0eSU7//0d+l9908RuxA8YL3FS0h6CT4Sgeqt4Ww0BiHoSYltUv/qSKOFYNjvIaWmLKfk5ZRe1sM7x+HJIcdnx3gZ/ITeB+sgjmPKusTikTpqDN52wvXUdcHB8RH7ezfD2FB+hmvG1KyS1wPcvUPHisrVnI1HRHFMnCYgPEkaYRuNcLi9yZCE4WBAFMeUVUVdV6AlIk2YFjm2Mgx6fbAW6zzWO6RUIUbYOZQQqCRGu/BCnLdMphPihhO31oCOSbOEdP8WT54+xnjXZOwDJRV3bt/m9PhkFsMrmpWDtQ2TinOWvCzp9/qY2jDopaQ7G5DFjPMzkjShFBWWFrwlmoTjozO8cPSHfZBhz1I8CBU6kfceESksjiSN8IlGGsj6KVY4jK3p9/ugPGeTEaayFKYkixKUVguigQEE3lvkTCsMMdpuZha2cftNrpSZ9iA4PHhGXdc8efwkLK5xbRIvCRKiOGZjuMnGxmazMlKE5CjSQwP2gYaZAxwfOnjLgRa25ujkjPHZGXfv7hOroNlJAUkcsb3ZQyvNaJLz4c9+glKK7d0b7N26B7ZmPMmDhZWk7NzYR0URZ2dHFGcHtBkm6TwtoXYo60MMvgp9xTiNsiFxVdhqThNFEUmSEGkFxmGkJxLnVkxdG/KiJhYCFcV4EXLYeOFBK86mBUVliLMQqTIajxiNRighmZyNGegEFWcIbylMSERWVwrvqrDBeT+lzKezibHxoqB0jKlLQohtsMSsrWfW0wV873w+z1Wu8PZ8pb8nrJJuc8Y45zg+OeQHP/4+4+IE8yzn9vPb3Nu/c3HTlfYWImRU/PjzT9nd3+fm5vaFeweHoW/6I9TWMs7H9Ic9YheRJhnKSVxlEMCzo2fcHt3mxvYestlYZcYMrpDRZMzR8WHg7NMELz3j6QiLZ5SPefD8EV+79xXiNMZ6j9ASqRVWwjSfcnh4RJHnSC0xzoZ2NQaldbM+xpJlGV+9/Q5ZlgEwycc4b7ixf4PRwwmT6ZSiKJBIrLEhP40MazCeP3/OjRu7eB+sw5PTE3724QfEUUSaJERac3JyTGkDe7BKXgtwD47JYNonSUxdG6YTS9bLiLXCK4mxlqSXkBCD8YzHYyKtSZMUlcZUwtGLEkTWR3iojcXDLAGUtx4rBcZZyqoOg8ybxjmoscZijUU6KG2BmZRkMmNjY4PK1EEDAvKiQEhBvL3B0dEJN7MUIT0SSaSCCRsPe+ja0UvS4DRUEhcpcleHLeiaZGjWWHpZD6cUzks2t7coypJRUVI7y3A4wBFMOq11yGrpLN4pTO2J0gQlYmSWMqkKSlOhVaBynHDUvmJrZ4M722/hygkno/xS7/eAF5IKEZKC6ZiqjBnlR2gtSOIIJWUzabVRGQEApFBsDDOSKJ2FmIHH2SY3OLC5GWJ4nTHNr6LZKs5jnCfWfuGADIuSgvNyNJ7yu9/7AVJ47t27fYHHDB9AKuj1Ivb8AOcc09ERP3ryiDjtcff+Oww3N0EqdJoSJQliUoQ0vhhaxnrGWEiBFzL4A4zHV5aDo0OSNKYuK/r9PnEcM52OOTw8JEmCwjGI4xDlZR3SBn7UueB0D+2lZ20uBIjaIb0nG/YwzlAUBQ7Y2dlBN4640hp2CYoJQoN3WGPRWtCujehOjcIH7TtOQi5950K6X984+oRX3Tn6Ul84O3lOnk+IoxQlQyis8J3yZzSHZzQZM5qeYWxNXlrOJsfUZo9EJ3PGgUB6ycHRM37409/nfn7G7nd+GdmkOg7KV5PCt+0XccTt/X2enT7HVobj8SGJSsnSjEme4xI4GY/YHGwT65DEDR/ok6WRPNbx+NEj8iJHa8XB4fOwgEw44iSjNjWPnj3CloZMh3eal9MQwjiZcHx2gkCyublFkqYkaUQSx+CgqisQIVVGlCQ8OXxOTw3YG+6QpX12NgWPnj8jn+Z459jZ3kbrqMlzZDk+OqQuKp4+eczd0V0mozG/+Au/wMnpMUWV83s//X2ElKRZyngyDlFaKFbJawHuMtb4fkwxHaGUpNdLGU0m1HWJ1grrmq3e4pjxeML44JhEx/Rv3CDt96iEw7oKU1tcUQRL31ikl2FxkwOkR0cKU9c4D3EvRkeSySRnOpmGSIsoOCmdllQYYmNol0tbY3j44AF7N2/S2xjitCAa9hmVBYONpNFcg7+g18uQ04peLyWKE0rvKGNPkY/whCgOU9f0eyFtcV3VeOeIkKT9HmUBsQ5+gboKiyV0k1tmOp0QaYVOE0Ts8N7gpMMLR5alWB9y5yAEKg2UQxKllGV+TtnOjexp4Tk6PmRzGEIlT04LfvSz93GuZmdrg7qquLF7g7Is2L2xw96N3ZCQSklEFCGcQzqHjqJZUjDhBUkcIxVMJxOg0ToNHJ9NOD09IUk09+7cuFwhYBbeIQRKBnpAqBAz32WdZ/HQBB5SxhotNYPNlLtxhkVyeHTCFw8esb29w+bWgNT7sImIUAgMSgiclCAVUUNjeOGwAoRWaCRJHHN8fEqRh3bs9XpsbYWJqygKjLH4TOKlxgqPqw3SWFTjMJVK4VzTl7zDSY9LNFk/Ia8qhFUza6nX7880ZCEkORalLXgFLqQiECrklpmtaJ41YdCaR5MS7wVRlAbqxlUIAWmSgbAsanOP54P3f8rhyRmDwYDd7RvcvXMXOjbfLOLEOsbTCV5AkqR4PA8fP2J3uMfe9g20VueKhPeMphN+9P5PcMJyfHzA8fER21s7RFE80/SFaDz7DnIz4enBAdZ7sjSjl/bwFnQcI7XCCcE4n4SFi6JVBrgE7F2AbwMCojRhMpngq4IoibDOMZqOERJGYsze9j5379zh8PkTJsaiophelpH1M4q8pKpqYqmwecV4Ws4oK6UVutdDSkleFTw5fkoaxWihefD0CbU1YetHKTA25MtXQhEnEaejk7B3bl3wyWef4ErD9tYWBwfPMabGuKCIlnlObWtsHSHqFVk+eU3AHecpxznToqCocra2tknSdNbBkzQNaXm9QPRjZD8hjXoY7zDOcTI9IzcVCkGkwvJyj8S6kItbS4WQnto6VCVQFryvyKWjKisiFaG9IOuFLf78pGR8cIKRBWmvF5IZKcXO3g7TKieTAxAw3Npo8sLboL1LhSbQEpOywNV1yJ+SJdRApDTT6YR8MiVWEaqnsaXFVy5oWYmmNhV1XeK8JonjsFwcwXQclvcrrZEqOGIsFqEIDk6lqIxlNDrDSUcSx3gL0SDFW4s3NlAMvuW4W547REnHUeDLnQ2hgIPBkOn0hCSJMKYiLyfUJkTvNMYz4EN0hlSNDyPi0ZOnCCTvvvUWsfJ4XzdUR1hxY52nNBXIEKE0n+FRiPO6hbj/hrH1jrp2TWKp5uQZz+yQwhNHMf2teyGffLPQy0uI0wF7xjKZTDg9OWV4byPs1Stl4zwPXLW1lroyxELipUMhsJXhJJ8yno5BwObmJlVVU5Ulk3FYjKJ0FCwy58EYpHNIF4Z8XYVUGmk2oCprrLENzQUeST4pgyWpPCfHx3ggyzJ0FBFFwWpyUkAk0S7C+wglQpZHpJ05sJkRX8GBfXIyBeUZDPsMspRqWgenuTVEuqHfZrZW0/YI7t1/i7v3JVUdksC5YsSTx59TlRIvJXs3b7Kxucnx8RFHhwfYOmzlZ4zBVZ4nT58w7A8YxMNmy8Lg1/ri0QOePn2GcZYsC5NXJGUn6iPM2s45xpMJnz78lJPJCB1HVHnO0dExcZQwHG42zn/Lo0eP2d3c5e5eoIJCPzl/mnNcD3Hmpa2xAqbjKXGSoKKwcbk1lkFvwCSfMM1zTs6O+MlHFWf5FFNbpLQkw4TKhWCH09EZPs9D9JwUaCXZ2NwMi8bGY2JTE6mYjWTAwycPqGuL0pppPiWwFKGeOgoZj2pTY6wlI0Rmee+wwvHBZx9isSBDmGqImKpx1mCsx5aLidZWXg9wF4LcBs/8zrA/22bPmJDFUUcO60IO8ayfEu3uYMclpamYnpbU1pKlgbM0tWkyNQoQMugxPgQUSSFRMgJnKKYF0zqnKoI5tdnrU0cV5bRAlY5hf4gUEuvtLMRrsDFkM1YIQgSCkBIdhZSw1jpKY0KHQdDb2mRydIw9OaF4XhPvDNCRIiMmTRXSS+qTAksZAC3SgeCMFGkSFrJIpZicnHF2dkaso1mEkLOOOJUgNDrRCBcWPRljEUhiBKaoqX3FlCmfP/sZsa9pfVjnEnq/1oE79g1PjNT0en2cmxDFmtSFzUu0VrOFPy24tyVKH1aIfvHwIfl0yu1bd4h7CuEdCEeSRFR1HZyXShE3i38WOfjmOgemydli6pLa1Kg4On+CNtIjvG50FKiwCyv5fHACDodDbuxuB448ysmbZwgOdt/QGH5WqBcCqwUikvSHYc+AuqyQolkTYF3odzJMXFXD47rah3BHBxvDPrWNkUpQFlPyicJbg9gahA3IpyVFUeG0ZWtzEy9CYjzvPXmeA4GmSZAhXNO3oYgzL+lFsrlxxHkvQjRGw7dLFRGngXqIs4g4jlBSzfaM7Q8t1ofQ1V7S59GjB3z/n/wT/ld/7pu45z/g//v+iAeTmu9891f4pV/6JdI04e7tO6RpOsuxo5Tm9v4t4iSajTlrA92kpObt+1+hNDVSSkxlscYR8umH8RWmWQe+pphOGI9GFLYCY9je2CSKY5QQGAuJDhp/ZU0AStWUMVs525p4TYw7gtFkwsHxId57pkXBQA9oc+3neU4SJVhrOTk+4sQchrBfB8oa8lHJ6fiE09GYvCgZSEldVZRKEPV7F9KaVKYGPNPJhFM7wlSGSEWUVcFoPEZIQZQkJEmMqWuqssY76GcZNJOQl55plSN0oJZNWSKVRuskOPKdQ8l/FRYxCUh7KaPJmJOTE+I4pKiNk5goDs5A4STCBQeHl4HHvLG9i04TxlVY7NS+WOfPNzOWqIbXCyFHxlQorUiiLKQ1UBlKaCbjEdIJ+hubHEwPwDg2+8PZGJJCoIVBWIvwowbcZODYXD/sxOM89UgwLmqSNCPSmr3tXQ4Pj7HTChlH9IWkNgEYhNKEjevCC8zPRggBmzf38MZg8oKejkl2dpFNDLrDIaTEVgbjDUIovA1cZRLHQT+uKpASVzjGxZjxyYi7ezv05GKOTkqJbnPFE7TkXtanNnGTvC1YQ8acxzK3tIlzFt8sMpPek8Zx2Cmpu7TbByoqOE/Db1rrCxs6zKI7OitoW8UrLKqCujJUpSHtgLuYYVwAZdHZuLgD7w110ay0Ne2CKo9qVvoC6FiSaIFWDisEpTMgJWVRcXR8EpasEyinliMej0eNZibJtSS9cxulZRO6KHj7rfu8/W7YpMPYQCHUrsbpkEBMqwytBKdnR3jvMSaAYa93vt9tv9dD9VJ0JlAVqCrkpInjmMFwgyTJ0EqjdUQchTDKez4iysKm5okOConUEUKq80RVtpNtUUCNB6GRDrRO+NafPuRPvpUGymok+L9+pMiyjNPTExCWjcEGG4ON8wR3gELgqoq8MrM5RwrJvbv3uHv77iyXPUCeVwhRNw58FyZW4XHOcH//HoNkSH84bPIJ0ayn8DgcVVVR1jbw+52c7jOfgG/7gGcymeC84+DogMrUDDc2KeuK0dmIXq9HmqXBv1PVxEkSbCAFsY7RsaIwFeVZSSQi9vf2kbGkODrGW89JWYSd24RoqxEcz1pRVEXwMeHJqyllVWKMmWnsuJC0zxpPaUqm+TTsOxFLbF2HhXS2wltP5EEYD3WFdw7nbGcsLpbXAtyddQgf4so3NjYQQnF0eIT3IJCYqkbHGltbTLN45sbWDhu9AbWtib0kyfqBx5pOMfZ88AaM8SHRk5cIBdaEcCJsAJ2izIm15tFHX3Bjr8JUBVpHuAzG4zHeObI0wxQh6qauJWVZEvdisiwOA9UrpPBEGKw0xLGgyi3HJ0ds7+xgfdgZKo5iRtMQilnYglqEsqMsIyIlH48Z5xNSIXFlTewVXkryoiDqJSQ6whUVFR6pJUKDQ4ScPJXB1RZhfLBenMci6A8HJGmKXxI6JURYCyCFaNhVR5b1yMsYIcRsO0NrbbOKLsgsMkNqnAchFVnaC3t+SgBLmxrhfJGTb7L5aZRatLnBecmtJEnMN7/5c/TSmMGgxwz2mxngPIzbg7cztsaaGqzB5FNAATpkkKQFCodwIKXBiyY8VjiMs+DluaOrNiRJjHWONEmQzUTYRo/Y2gYHuTfYqka5xoyQEm8tmNCqzdYbgWopCqQCYRymnNLr90OSu7oOkRRSEseh/afjMdo5VLxJWVnywpCkiht7e9zcDStYi7KirmqMNdjaU5kJJ+MmD49zjM7OKKs6TE4yKD91GaxWrVRIq1zXWO+RPuTR+bfvZHhfIEoQZYEwih/84Af83g8s1lYoKYmkJIrjWeSYijS9fo9eb4D3DlPXKKXRKgqxSEIw6A9I07RpQ0kcJyRJ0JrrukLKkBF1mKQkUqPjNIRotpuBCNckUzvvI3VdnzvEvTifCJynqixCCu7fe5fNzW2qumI8nZAXxaw/bqUDjDPUzlKWYRMXKk9d1kjn6fkYVIxUEUoLrFTEWUq2s81odMrR4RGbdpN+r0caJ3jjMdMq9BUJ3toQracVaUM5O2MDVrmwA10Uh+0fqWsoS5z3pCoiUTEq0hRFwaSYYuowCZ1vWrJYXgtwV1IiZHAQlWVFVdZkWYapDOVoGnbCKQxaarT1aBHhrOXw8ABjw8bBkQqLSjKp0crjlaAyBmtCyJxUAqzHO4PQerayUoiQoc8Yy/7N2xjjyNJ+iF/3IsQzNxZeVVdYa9BaUVYV2XADa3WgejykWUIca5JqSmVL0kRTTKZM8rA588awj1aSyXSEx5EqjbM11bQgQbExGBAnCdOixqYaLSCTTTinckCJLexs+y2nJE5HnE2neA+DNMMag3YhpltgG3ZdolWMN2FRS7u7TxsEqKQiShK884gadKRR0YBdeRso0TqsvMzzaUg/AAihGGxskqYDQDZ7VEi+/o0+dV0SpwOcsOA1XtTQRKUIqYjiGLycrcQEOPcKNtFNs8Uunr3dDfZ2N5vj9SylRhjMTabL5knz8WnYLNsbvLUYUzEejQCJ0ilbWz3U5kbYXrGs0NpjXZMSWRAWZnmFabT/LOthZcloMkVHEVmvN9spSGkdopiaRGO1CZuJ10KgrUN2UjnDef50H0hzPGCEw3qPraoAAM2OQ/iQK957z3AwJEpTRAjloizGVKXi008+5/OPPsPWddB8bdjoAgGTaUleVcRas7uzhamDNWltSRI3dF4WNdFkYSOROJYYC0pnHJ0c8w8+rfC1whZTfuuJpxaKCM/e/g2KKmc0HjHxFleNcd4hESQqpi4sp+MTtAxZXctmS0sQVFWIPIt0iHXXKiKOE+I4xhhDXVcICVHjc4ijhMHGcBbOLEWIEx8MB/TTHrGOMK7xd8WBbpIiKCpKKZQQDHoZ7crnQXorkD++id33EPYqbVb/NrRX2H7ThOAHE95tVVXkRUllStQwrDwejXMSNM5XqEmBKTxGNk7n2pKlA5SOwAk2B0OEktS1wZia6aQgSRJ6vWy2GY1vdpeKewOUlAyyjHpaIhCUpiKKUgaDTZxznJ6ersTVdfZQTYF/DCTN+f+l9/4/EUK8C/wdYBf4HeA/8N5XQogE+NvAHwMOgX/He//pFTfBeIs3jrIIYJIkKYn2lEdn6NKEDHiZxuKQwnI6zZmMR/STjF6aYeqSKI7xZU1EGDyFMVjrkVqHDRycR8uwH2hpK3CgREhOJXxY0musDdRPCLlh0AsmW57nHBwdsLm5iQMGm5ukWcbz5wcoqcmyjGG/x+nJiKzXYyMbMs2npP2I2lWYYkxVj4i0RamcJPMIaYmLErxCyxHObVDUAxASC6SZR/knKFdjLCF0KjF4p7FW4H2EqwxppIl0jHclUjocunG+RmQ65e17X2EQaeqioCyLkErBW2Sz5ZDwCiEUtjLN4ooC42qq2lKbSZNwLGi0renphSTpbaF00mjOEuugv5GEiQeHxeN9ihV5EzvtGo22ccm25nOHcj/fuyjE1gcONkwMIQbfBSrqUjSExFnH6PQJz58fcHBw0ESxGLI05eb+TW7s3gRvcM5R1XmYAETriAxLQGskpfAUwmOdxUrBZDpF6UB3TKZTYq3DTkxFEcAdP9uHV2U9nFTUqQqO1doga4IzWxJmDxk21Chqw9OTo9mS85ZWlFKiGr+Bc47JZIKSkrQfIZVndysjjh1SxqRKUTWOOppFX97D1nCAaajJJEmopCfJNFVRkjYrhJuhB4TlB9570rSP0ANGkxH//Hu/z48+G3L71j5RlOCp0LGmv9lDlB4fhUzqeZ5T1yFNdhJrYq3RzSrMtOgFZ2vzBsejCaPRiEHWY5hkeAtbW9tMJ1OUCmGak+mYoiwZ5xPcZMyzg+cYY4NFBU2aDhHGstJY65tJQpNmKb00JU0SNjc3AsUbaWRDA0ZR1GjO4Xvwz4XtJIUM4cxtf2r7V/jXOvmZhbY6woRaFBVVOaUqC+oaTk6PMKaiqoLPpCjKQAtLQV3VlEWBdQ6tVQiwyKckSYyWkjhqFsQh6CnNZDxlOppQl8Giu337NnVd8+zZs1kOpWWyjuZeAv+m934shIiAfyqE+G+A3wD+T977vyOE+L8Afwn4m83fY+/9e0KIfxf4PwD/zqobOBfMLKFlMNdkANc4jZHDPtXzU2ItkdMKpT1Z1qc/2GAQZ0RxTBrHeGvo9wecnJwER5QP3JdrcryDCtSDjvBSkMYZWilipdBSobUmThKMM0zLnNFoDAQnoUQQRcFEHo1G7O/fIk0ztIrY3NhqVjmG1abDjQ0+//wBb7/9Fjdv7lPVFc+ePmU6yYkijZCSLNtAWomzOZGeImQdVkzKirIqUTLGWkFVWyKZIFFo5ZEiQqLxskTpKrB54iQk7fIRSEWtBF7GREkIpezFAx598SlJlDIcbOK8IunvkGYpaZyRxEnwxvsCUzvqoiIZhCXU01xRVCF6o6oqlKqRUuObyBeQeC8bn167q/t5tAu4NstsAzzhF+lFE61yUbNt5cLy69kpnu5q1va67rnBCR9CUd955+0ZrSGgceAmaB2cuJFW+CgipPxVYZGYEBRCUjXOe60Eo9qQpinDKEZFEc4E525ZFkyLgixN0UlCFGnqumYyneCUYpMeqln9KuKQwEvYQJlZEVY+CiHY2t7GNStStdZEWs+eK0mSkF+orMBZinxMJDRp0myd585XLYdwRQ+Nw9vbAkVIpWDrItBVzabd5zv5homgdUB7H/YtVsmQnZ2bxCqmnOQ8evCIja0ddJrhnWN0dExtKpCCvC5ndZ+MJ9goJtrYDAu0RmFBolQKYw1FUeKlYOvGDSIVdjwTxnJyekBdGQa9IcONDbZ3NjgbjZg0qX7zSYGOI6JeGiz1kDKfPJ+G1NoG6rLGexiNz3j65BHO2tlmOM4FP0yShjj5wWDA5uZmmPSqqsnvHxFpTW8wbCaBmF6/12xwIpGyXX0twxabNFq2FKRRD4ZbHUR7F2tdExASMtFWdcmkmGK9pSgKijLHmJrJZBzyzEhFXVYkKiMWjjKfcnZ2jCI42J8/fw7eM9wYcnZ6Rr/fZzIer4LVtfZQ9UBbStT888C/Cfz7zfG/BfzvCeD+a81ngP8S+E+FEMKvShvngzOwtgbnLXVZNmFRKdo7okhjq5qz41N6vT6j0xF5ntMfDPBAr5eFPOsnZZP/ITglUiuImsxxwguUbBJdGUsaa2IVeE2tFePJlLzIGWxssDHcIk1DugMBDPsDJtMp+43JVpYVvd4A5zxRFHJL9HohwsV4y81bt/n408+4c/sWWZKwtbGFrQ0HB4dIpXhSPCNJEu7dv4dMQi4JLTxGSNKsZDqZYKiQxETREOlKEAbrPaZWeBcjWnD0LjgRAYQn8h4hamSziMjLkuFmgjSOo8PPmExzrAlmaaTDjkYCgVQxvcGAOOnhlaK3mbG7/xaD3jeakMXz3CL5dEKRj4mTCO8IawWKaQBaF+KSpZINJe4a3l00GhL0kwihdNDCm+XzbdTGjMmfxctDC0eyjX6YReqE792JQang9Ot2NylD+l6lVchbj7sQW51XJvChpNS1QQgbNOxEEvdSoiyjqkNK4yzLODo8xjnL+OwMZwx9IfBKoWTIXuldjZGgaoeug5KikzTEVgMmFtgocMbm9Iw8z/Heh2gQpRqKMmj3cRpyfUcqRH45ESZTWRukaVYNnyeeufDc3TRhnsD7ziJN5+bPc64rbNqytbnJztZWSPWhoCgNd+6/Hbh1JVE65vnBc87G4xmA9tIM6UP6D2NDcrN8nGMFHJ2eUFUlURIzTDRCa4y3FNMRlBVKaKaTMcaU6Fg3jxUsDxREaRT4+TSmrArqqiTJEuIoRnjBcHNIEse4ouT06DREP7WWEILpZEJVVpwVJYfPn2NM4MPxHmMdzjX+ozisNE3TOEQpJUnjd4qb42mY7Ad9kigK+xfQOlPbdBZhbYaMFDR5cZzrsbmxjYfZXgGe4G9sNyEydUlVFUynI05OThiPRigheP7sWdhfIY4pSkOc9ZlWFVF/sBRSYU3OXYSt5H8HeA/4PwMfASc+JNcGeADcbT7fBb5oOpoRQpwSqJuDuTJ/Hfh1CJEyzrrmn20WMvWIlMb5AhKLczkbOwIpJiit2NpLAYPDIUWNUyF7YzwQKBURqSGRjZiMqyYELzj+bu7tUhUlxtQkiSaKw+pUpRWjk1MePX7Mjf199vZucGt/H2sMRV6ElLPDIaPRiEePnyAE6ChCSUeSpBwdHZElGRsbveC0c/CjH/6I6WTCoN9j/9Y+WZqidMTu7i6PHz/m0ZPHbO5tEycJiVY4B2VV0ev10IlGOo/UimrqKKY1SgeHoKkg0j2UipBCNeGeYXwKIYl0jNQh8VQiMvZ236aYHGPLgliEmAYpwuYkUgTnorVQVIbTs6cUtcFaF2LaXcgNLoQgzVL6/QFxmrK1uU0UaXpZn7yY8uFHP+Phw4doIfnX/8yfIYo81pQY53DOzCgDhEHpczBy0iEb7f98x5+GCyWkDtMywthz64ALID+7AjrfL2bWUzi5ibUh7jqwdudxoVLGCFmHXFtCIlKJlQ4tLLFUHJ2e8fTZ8xnFc3o6Io4jjDFMp1PGk0nYmrDXY3M4JI4irIJSe6zymKqGokYJASoAuxVQ5QXGhQ23ozhGNzRBlRdMphPyvGB3dydYG3FEgmqydzaRSJGE2oHruKB92x7NwzV/lJJ4ZxEEf8z5gv1mz9m2rZwFHxbvbW/v8Mknn+K8Z+/mHoKwGYwzlnE+QkrJ3o0bITIkL2YavJBhQxzbpABRQBLHJHGMkIJ8PKWUORvDIZt7O0xPzihOJ6SxojYV0zI4DXWzOUrpwspx6Tw2L9FKIHVIP+IxeAOj8ow8Unhj6WV9QFCVZbDWkSF/VJWDhHwyQYmwlsB5HxZknY2QSqOajVKOj484OTlGIDDWhEVqXszAvd/vcXN3l+EwLGSrjUE0ikUcJ2GxUgP0/f5gZkVIIQIH30QpeQnEBCrTJcAQzx5vvR3GgLUWU1XY2uCspSiDD6Nd3Pjf/r1/sAS11wR3HzIO/ZIQYgv4/wDfWOe6K8r8TeA3AYbbQz8dTSlNEUKzlGAyOiOSil6iyLZi5FAHbcsGOgBiqspSTHMQiihK0HGMSgKPvLuxS5kblAzJeaQMsbBSgBQxTx6fcHp2zJ07dxonYUjmNM2nPH74xf+fuj+LsTRN8/uw37t8+1kjMiL32quX6p7uWXo2DpchRXEZUaZNkRBtwxYgwbo1YBg2dOcL+cLwhW1AgAwBvCAFGITtGxICJBlch8NlTM4MZ3qml+rq2jIrK5dYz/Zt7+KL5z0nsmq6e4YQaTS/QmZlZkScOPEtz/u8/+e/sL6+ZLGYk2UZ1uZsLi6Zzeac3jpFG8vqekUI0nHNZjOsVkzqknazE6aNGyFG3v7Cm6zXaz786EO6rmW2mFM3DZN5Q1lV5FWONzCmMOm6Fj8K7wQm0KakqUtwKzbtjjzLyUwgNznWZrhxZLNZC3PBWIqyoMg0ZSldINGjgk/PcYIJiHIeEIonWqOsolTik9GU0tEf0BCAIMXe7S7ZXY08e/QBo/NkWYmxlmeffsqjjz7m1q0lVVMxXx5RlBVGa9zQ0223dLsNEq4kBmU6DonqotP7ujEYQ8nDHLVm9A4fBDoQVOVmGLw/1Gfe7OcPhY+Wy8tLTu7fFUzzQLWMoLQAPkbcSTFOqIYBtpsdq8sriGCNxTlPURTJN94miqiTrbyxhFG8ibQXJs4QIxdX1zz95Dl3ThbcuXsLohbujtEsZlMi0A0yPLVKc73d0rUt280GFSO3Tk7El0aLTYWKEJzYPJTapOnGzc+qtaGZNGy2W0J4Ca4RDCbh7GkxlO2ddJ/Rc3H+jIAmKs2Ls+e8/sabHN1aElWk7ToinqvNmk0ris5h6FPTETBa0fU71CZS143YWfc9zosDZl7khCDDW6UsQz9SmIxMachzylpYMeN2TQiRru+x2qJ9T+xzXDfStS1FKb7/xnt8NxLRKEZ8vyPPStrdGu8EOptMJhJSYjRmmuE1ZGMu91YAk+XYXCIayzKnqhqBGW8tGEcxq3POMbgRH+T8jX7kenvB2cVzdMzQMWXFGpOwfEtdV1SVaDmOj25RVTVlWUgCU5bJXNFmhzlAllmM+lxmrNIYm5HbDJVYXlNuPueHWnin41+JLRNjvFJK/X3gF4GFUsqm7v0B8En6tE+Ah8BjpZQF5shg9YcfKjEIgsKa7MBXLScNXT9gQo5qPTbKMNSNgXbXsd2tqcpKlF+65eTeHQbEIa8NDpNlZBiC9/R9l4q7cLGPbx0Rg2ccR4q8oqkaMpszmS949PgJjz95zKefPuXOnTuUZUmMkQ8++JC7d+9yeucOfT/w4rlIg/M859bxMZkV9kHXtUxnNcbC448/pplM+NKXvige2VoJc0ApMJpuHClsmYZfEhsYQqQoCowxbPuO/nJNu1pjmpIiszR1wbxpKIqc7XYDDGTWUhUV0+mUF8/PGIaB4+Nj8ryg79eMruWAU3/uxhi9ph3GZB1gePrsknbYyg6qrPDBU9cV3nuqomZRZ6jgBGYpS1brDYvFnNunp9RNze/93rfkZ8gteV7S1BNu377DYnkHmxmKIic6xzi0DP2WsduKJ7qKBGUEt48C6SgUq/WO3/nmNwku8Au/+LPkeZJQ7TnaUaG0BXfjNa7UDXVuD+vczAb2EFCaAWhFjBawaOfJrEIHsXpdtVuyqiSmTtQoTaWNxAOm8Oq971BEuvEKiW1WIfL4k0+5uOq4f/8+daWJ2oCLFEpjvGK12/H08kJgn2RsF7z8HHt9QV1VorgN8OzTM148O+PtNx5irdgtfNalPaac3o0wctKiKa29oqmblwbUv38x7LqWXT+w2ba8uHhBVlR0ruXo6IiIYvSO0hbMF6LI7HppyJokqzcJS8casiKjD14skRVsd4KR73cofd+TK9AEgnZs2ssUzl5hdMCN4ELLMLSoaKiqmaRe7ZluKHRUGKPoBxjHSIgafCC4kcJalvM5WW5Zh5bt2KEzKBaG8boVvF6DNpaiKvGxR2cKhWYcPCE6tLFEHXFhpCgtZZ2jbU1hc0pTcry8BTHwySdP2Ox6rlZr2rbj2bMrnJfdYFF+SFmWB9fULMtEo1A3Qp0sK6azKXVVUZRCSBBbX4NN9gyZsQIjsffL+tGFHf5wbJkTYEyFvQL+XWRI+veBv4wwZv4j4G+lL/nb6e//NH387/1IvB3ZImc2SzFsEiTrg2O7Wcv2rjKUKMJuwPmItrmEUGvNttuRFxn1tKbXAaLGu8CjZ894/L1HWGX42jtfpKpr2t2W6B0EmM/mUtiLXPjNGIrc0DvPbDrn9qlnvV4zDgFrZVtWVRWbzZbJumU5PaLKazbrNSqCUZpm0rDIl3Rdx9nZC1bX10TnmJYlk6rm9M5tur4nXFxyvVoxOVqQWeG+uhDZbLZpWyed8zDIgLVYNphFJR7pAdquZzmbkWU5k2bKbDKlbVusEpe5+Xwu2+dErXr29BHGilxHTKRubowQI7tdy+VqxWK+ZAwj52c7LlZP8b5nuViy3W5YLOf0vXjMPHhwLxVLhdUyTC7zgjKXAWCe57z64CGZ6nHjyNnliu98+yljEPtdozPquuHu/QcsFlOmx3fIs5xu17PZrvFeZifojKg0PiquVxsJFUy4vFIvGY6ppDJ9GabZF/7PHOnzEs0wfbEMN4M8UCm4kFEFgoJq0hD6gV27ou06Tk9OKIpCVINupChLUMKzJgjVU/BihQ7Qrba4NrK92oEz5MYy9iP1dCr47/U1uclESmUMKiafEm2EkRHFJO/EZAz9yPXZOU8fP+a1B3fIkxr3pakzCvAx8M1vvcsrr7/OtKkprGXsO/K8pG13lEX2Q0qDYjqZcnpnyna74+JqxYvzc9p+w2a34d69V8mLkmbW0PYdfgyHBXQYB2yWgVZ4HwkqUpqCshTHTJ+cNFUQXnlUJG98j/Mju35L1zryrMA50gwiw1qNaQIaj/Nroo2YLMcYK9BNJrRkVbUUjfDTIxllITGP1/GcjJJBG8Y4UqgMO6vQqifELVEPhGiR3HXNaHuUB5WJNcLoOpSNzI9qMmPYXLf0/Y7T4yNU6TmaH3Fx/gQDVKXF5HMiyxTUomF0BCeiq6vLq2RBIHCLSa6i2lqmsxlNU5OlxSukJK+6bsiznPl0Rt00UveA6XSayAE//PjDdO53gb+ecHcN/D9jjP+NUupbwN9USv3nwG8Bfy19/l8D/mul1HvABfBX/6BvsIdiVBRfhaIo0KrA5Eq8IgZHRGGakspWmJix2WyxWcZsfkRWZIRcs/UjKqn8ghcq1na9ZUw49iuvvIrRltXVNTEqFsu5WAxnJePo6fuR69U1fd+zWCyo6wmr1TUff/QEYwU2OTs749133+Xtt76A845J07Bar3nx4gVf+OIXMNZwdXXFar1hMpkyrSoWsxll4pGDoiormqahw+PVKHQ65wW/i6Ko895TlAUmMzgFLgSMsXRtS6NyhmFk0kzIcxkWudEzpET2qq4OmJ/RhrKshL7l3O877zp1uEVZSthzlO13WRQ4t4eJpHBYa1LKEuyVQ/uvf/H8jMePH1M1Be+++23unp5QNZbMRObTkvmsxnmhZ67WO9aba77//WtCDGKeZHPyrOT41jG3797m+OQOVktUYlE13Lp9l+1qJdgJMTF2XmbPyPGDApb3MMS+/ElXL3mVMUFAB4veDAYdcMon+mdMEJx00l3XieikruTBTMrEPM9xg2SqemOJpA5cGzKbYVRJ9CP4gHdB8gUULI+WYl0xDvI9clEF7ymM3ifB2zCwvlqxur5mu93+8L4t1fnNdpcStDxlJo+51kZcEOMBof/clwohdLvpuLi4pq4qaVAIHL91nF5bIvhiiImyLLGGLsXIdVvxMM+1TYwj6TbHXQtphqS1kSKWMGhdFLghEr1Ql/tWoa0hKyuCsnSdQpkRUyhiFgmFYhg7nPdkpcPlYo0dnCX6iM1hNOL5iTWoqsD1I+MwkucZo4dZc5cCzfZ6S/CRvC7ZeEnoyq2l23RcX25w48ByuWDceFabFefn5zSTCdmp5dbRMbmxvHj+nGdPn+OAZjEDvWfmgUETgmO1vuTWYkKYybNvjKUdHO0wir3xbsPFxRkhCOPLB9E7ZDY//H8ymVBWFdoYaTLK4kfW1T8MW+Z3gJ/6Af/+PvBzP+DfO+Cv/EGv+7mvEnc3KzxTk7jPHk+W5wQnZkLuugOnsEqED1kmRlvVtGanI8YUGKXxoxMjqTKj3xii93TbDfbOPXy0+Kh59vQJ6rkMII+Ob7FrO549f453nrbvmE6nzOdzyqZk027pu47ZpMYNAx9//Ihvf+t30VbzzjtfZjKp2e1ann36hBhH5ssl82lD17aUTcP1eoW2Gu89z84uyTLD7fu35UYbAkF5tFXsNh3b7RbnRvGLdgPToxnGajJrybKc7eUKX+Y8O3vOxx9+QF3XnN6+jc1znHJgDNpm6CynbXfYCG3n0Cpg9f5sp7KY+MKZachy2QaOPnBxdcl8KZ72WolCNKgoIjJjDqlVMUbwjuAds+WSV+YWNQwUUWAErQU3N0o8Q0wEYxR5kbE0E8oyZzltiNHR947zyw2PPv4e33/v24Bi0sy5ffcO0/mCP/PnfwUFGKsZuhancvrNCu/kgfQRSfXRN4yFfVcb04JgrEUjpmvWWAY0kTSPiFLYjBEbWkPGqt/SD6NoG3xg9J7oPe2uxY0OY0TZa1/C3t04clRUKCuL4Omdu2hmBK9o++eM0UGhcIWhyhs2mzW9G9hstzRNI1YQ1pJl5tCZ7Yvx/GTJAxROqQQB6t+3O9mDLUGTcgYCUemUV6KSYdlLA9jDIdTLfggMo2cYO1SMfPkLX8SrSFbl9L5logp0VFxcSQ6ozQyKyHa7I8aYvGsq6jxLQ21xwSyqEqO1QA4hstu2osAsJTUty0ryuUrhURGTG0xuUCajzErZGRkYQodzGqVLijwyrFvW1y1DP2JtwXJ+RBwCzWyCjZ48y9g5x/XVCu89XdszKWvyumBZNDx+/zGjG7n3+usMQ4vWGXjPOPRcnr9gUk9YXV4zdC1933P79ITvfe97vHL/LrPJjE+efMjHH33EerujaGaYwZEVsjjbKJYnJjMUVcFmfS2CJT/i/IiaNOQqo1SamZ+jo4eUydy7gd22xblAcJ6xD5xdXuCeCxnh0aOPaZqaH3X8WChUgw/4YURXOV3XkRthW9Z1hc2EPxtbT3CBdtOynB+za3fkec7oHNvtljEXVaH3njg66qoUC1qtefr0KbPZhNffEk+OECW9PnrP7PhYejolEIUymuVSKEvKCD52fHKLy4sLYgic3Drm/PyC1WrDZFpzdXXNO+98hY8//ojHnzymKjMWSzGnIor6FqXo+4GynnB0tOTF2XNUiuVTWnIu8eLw1zSNDF4y8afo4yBujOOI6TvqaYPBUmU506oiRhgGTww9ZVEwm80JIfLRRx+RZRnLpWClWZYT/XA456kJS/BFSkxKDJSuaylHsYPQxmBlHEJ0yc8iJntVxHlPacUrv/QKf+V/9Sbv/ea7/LP/8ncR7PeGU+2d5+VyorVKhTQZsNUlWmcHNWEIkagM5+fP+PZ3v0M3OE5PT7h9+w4nJ7e59/AtdHS4sWPsW/q2ZXCBrLHsfRJVYvl0XU9Uitl8llhFe2qmAhUFc08T1hADXkVGAljDfDYjxChCFOcYh4Gu2wCRqpqKHYNOVMC6xlpDiAoTA2b0DKsdXmVC25vW2FlFnuT+/a6VpiVBftZaYZh4T9fJud5bHMQkRT8+Psa7iKnyz+oEXq7USuGDF0qiTR+IewbSDx47K6XohwHvFdpYYQPFwKtvvk6+rAk2YkLEuMjFSpKIvHc4P6TFUih/RVkwJP8TFyPX19dcr64prChOvfPJZsDJM9KPqG4Qm2NrUwqZQuWaXbclKxS5KdhtZfhuCkNMxIDd1ZpPPn7MsBs4PlpycndBkRmBbaJnHHvGIbIZdonynBTFPjIQuNyuePzpJ0xnc7pxYLvZklUV2gWuzl5QFDm3Tm7hvefajRwfHQEi8huHkUePHvP8xXOcV0Qs51dXlMFz7/69pNWRc5llSiCVKDvk6+0GW5coN4A1jM4RRoffdEyrhnk9wWeB8aplXk+wmSQ0lWWFc4HRjQzDwGaz/ZF19ceiuBPB2pyhG+k2O15cr0V2PK1pigbvRqpFjcoMUSmqyZTjumY6W3J2/ZRt16GQQGEVIy4ExnFkOpvRb3p2XSfT/t2WerIUFWb0XF1fcHTvjpj5pAuvtWaxWOC8x1rLZDIRt7dxZHtxSVbkvPHqQ54+PePF5QVPnz7n/v17NE3N1eUlZdmw27b4sKUsUjCE1mzbHbYoGH3gervmxcUZqsrFD90L3lo3NX3b4Z2nmUwwuUY5RV2WrHcb3NBTlDWuG2kj+HbLG6+8weq6Z725ZBw6Fos5XSdFvG1b5vNweBB/oM1QoucZLCqqQ3c8jp4sL9GZwShLiBHHgLV2T6BDaYsxOUZ5Jq9MaU4GTl49ZXI0Q5uMSMAjDA8ZZPrEGdYQC7QyiOdLRIjCe08gWRSb6ZSj5ZLoM37v29/l8uyCse346P33xa8kzzg5PeHevXssbz/A2gzvxc9+6Aacd2KvqtIAMXXzMQrTJABE0SbEMOCiYSBiQyADeu94fnFOluUHi4GhF9GOYKLQNI3sGBRcXDylKApOT04hLyALLO+fEIJYLgSj8Qi91MVI50bqenLowF82guq6fcrOjZVvlmycq6a8GYrHlwbkL422xmFgvV2DmjJrAj4I7vtDH8FU/EPa/Whr6boeN3rKw1Yg0jNQTSuKiXTTm/WaYRhZLpeYtNPIioJ+HOg7McqaNhMx5vIhKX1zUWgrxbDZUYRAkwt916PZDcJM2XUdjVKMRtxgPY4xBrq2p64rHn/4IY8ef8JPvPNljpcLzs+fA5F79++yut6QTyvspMS0nrDbses68jyjyHJ2/Y4hKlpG7h4vGRFbb1GtRspJTaYM2hpMZrlz7x53bp/yyccfA7DetQzuGevNGhc8tsh5/dWH2CKXpic1PgGx87CZpZ5MuL66ZoieyWTCLjhCsjmosoJionH9QNeJ2drJ0ZLV9RXrywvG0XN6epflco6dVUIxPlnyj37th5fVH4virq0hGrn5sspyXCwOWG6wkbKuiFoxndSo+YJKNRg0RyenXHQX2BQVkyWsMmsaCB6VwabdMc2FnrTZbCjKGSFEjLEMo6yAeS4kPGPkIVwsFowJ98oTBnpyckJ/vSbGwGw+Y9Is2P3e73J1ec23vvUt3nnnHeq6YTaTwaNL6U2TyZSiLNjtnChUDdx7cB9Kgylsei9icbzZpA50GOj6jvnxXDh+xqC94WR+h7qseNo/JRIpJw0+4au/8Rv/gtPTW9y+fQeQh/3q6orT09sCvWS5KBXT8XL3JpiexSfhU1WWRDxZXojlb1kC0O1aMSxCgdLU0xk6z9BD5Hv/3Ud8+ugJ3Vnk7eOvYm2Biw4h/fXsLcm0EqaJ1hxgInkTAhYcZqSJpqeAV+4veXD35wVaykTtuLpesdkOPHv8ER+//z2MtRwdnfDK628ym805uiUhxru2xcfA2Pc3WHO8aXQ1ARUU0RmMMlg3oIpA7x0uBmbzOUYb4RaP46HztNaI22AIlHWNtZbFYilMkDFgYqAYArnWYCPK9ATAB7lHOz8KdxkZrgEvBXTITmA/VLPGYI1itVnTdwOPH33CT3/la3Id480Yeb8bUwreeO01qkoYGuznD8TPLAA3534/c4iUeYE2NdZmKJ3TTKf07Y5oLFkhjI2h71OX7xO1TxoJpcTKNgJFUTCbTomTJsEwIiISBojk6xZFjkoD6+vNmqEdcGNE1SVVPqVpaomqS1hSv5NoyhBEEzNEz9e++lXu3T5ls16jleLs7IJ2t6PtO+699RDrJvTjgM0sk+mELBNfqjA4+rbj6PYJZSPD0mYyQec55IEmLxiSn1BRFFS5zBb2O6kPP/yQ6WxKM2kwmRV/nLIUoaETa2ZxP9UMXq6j846r9TWbocNlhmo2YQwSs1fWFf31htVqxXQyJYbIbDpJ94KE9cznc2HYDQNEmM3mP7Ku/lgUd/EKzzhayITbWn1QEAYAJ6HWLl2UpplLwJSSEO3oIkM/oKyR5Bujsdri88Dp7SW6d9RljdV5CjnQlHVNXlZcXl5x78ED2t2OohI1oM0zmfwfhnOKup6QVxXtbktZaubHc+7eu8e3vvtdnj4/ZzJ7wnw6Z7PbcXp6AiBzgaJgtliijGW92ZEZS8w1Sis22x2ZzXEu4EZHZgzVckFQospzamC73TJZTLGNgjxS2AJbZNgQheYZIijDpK4py5Kr6yuOjk6pqhqN2NWe3nsIY8tmaG8w2sMePUL06Y/imbFarejHgemk4fhoSpGJenh0YlAVVbLW1YZIwWxmaZolYQ0U+zCdCBjxuTmoQZN0JjFbYlQoJYpRqbaeQ3iHUvLxGMisT7qlCDisjhSZwc4q5rOaosgIMXB5veV3v/kbbLcd0+mCV159ldPT29w5PUUpxXa7JS9KIjCOnhAQ/QOOsYgMoccZcRDUaLZXgrkbbbi4uJCGQ2maSlz9hmFgt93S9n1itoqCtTy9A9YwKIExjBeGTjAKr8EnT9lJXdOnhUKk7SnEOUTatjvAMkopok/MHK1RmabtW7QtKLL8kG97U+Qjbzx4wD4UJIxj0gEk8Zj6wQU+KtCZxZgCWxTcbSaMriO4gWgEXpTAlCj867zAajkPbRJeTY0lM5nAfWkOMY4DXoEuMjJtUEqCdNrtFms0WWYJpYiH1t2K3EUqJdTKtu/IjFg7+CDOimUtNuBf/6mvU3oJy7BW8fz5MzGJM4pmPuf49BS0YjJp2Gx34hyZdjtZLi6Vzjuwmp2XXYYfOuGdK03R1GgPVZYxmzSURUFTF1RlwWa9wWYaYy2TacN0uSAkR3qTCWVbpem21ppsUvHs4oLn1+cUVY3JRUw3aRq5N9ud2Ea7gTo63nzzC+A9RZ5CZQI8f/EpGMXJrTvUlYWX7JN/0PFjUdxBVv6h6w6ui3ue994utOt25DZjuZihjaXtOkKIaGPo+l6Csr2mKoST7nzEj57j5ZKzT59xeXUl7BBjKKuKcqhYLpdcX14xXy4E/1ZK3O20Th7S4usAkGc59+7fp9ttic5xvDzma1+bsjw5IQDL+ZIsk450Npvhg6T6ZEUlAhQMY9+J2kyBMooirzHRsF2vpTvLNKMfGPxA0UiVLJoS5x1D16GD4ag4pqpLfDdiSPahVqxLrbW0u5awCEwmUxbLJRcXl9x98Drh86HF6kbir3VIyn9DaTPe+fLbjN4zmRTMFrUwfXxkzHPy3BBxsrBCKioyANfcbO85oAQhOZPKIE0RyazGWCTvkhtKo1Ky0H/22AeDcJgCqgPAtBdzROoip65r7mDph5HLyys+eO9bfOt3f5vZbM7JyR1u3TqhqZrDAx68GIOhPEWMlES8sgyj59OrS2EtJXy+KEuRzuU50QvUlef5niifqG3ymhfn51RVxVFVg1E4Y9jLrrIQsT6SR82z7YaRvce9PAPCJMnouv5Gym4M07pit92hM8M7P/EORVAYL8k8L5f1w9pNsqWIENnbGZBMyn7AA7i/RkBQMTH1ObwHl/QDAk2J4MoUBT7KTqbvOjarNW70LBYLCbkxmn6UXajWyeclRlTyuQkJl9+f1+16QzNtOLp1i9043OQMILOoYRCmz+DE2nhW1iyyCkWg7YSaGmPkzu07LE6PmS+XXHXXrFZrnj9/QYyR6XRKZq2ks0VoZjNsnrHr2hQ8Is0fvSSIzRKkRLxx6dwLt7LMCN8/maRpq3Ex4p24SsYYyTKLI6KJXFxdUlQlr7z+Ks1sBkan+YMw5vLMUjcNnz57zptvfonN9vyQzHR9vaKqajrXc+f2Qy4vz5nPlj+ypv5YFPfgpVtUUfjGY+fZrVthPgDTiWK1OeeombPdBjbDGt864vErjCFSNhOK4BidkxXVWqq6wmpL3I0oFRn9QLtbMY538V7CnfO8YJcWCWMNk8mU0bm0sAhkEhJWKfiqeIlvVmuuVisG53jx7FOePH3OG69/gcvLc7JCcf/+HabTKYUt6JRGG01IN17VTGj7NfPpFO8jY9dRlgVay6WwmYJMUVQFOlP4UfJV8yynaWqJxOsc1kxx3Q6rDcv5lHv3H3B5dYEbA8Erbt+5Q900XK/Wh23/Z6CYz/xZOjsdwSrN22/cSWaNkb1bIhYoclJVlMUh9DK46np8cOlVbzBi6cL1QfAEYE2ktIlVq+LhXR2Ag736TqvUCSXKYzQ3HedLb/7G7ldEQ9H3mBhYTmumTcngRq6vNjz68F3ee/dbTGZLfuInvkJuC9kVoPEhpsD0SOsGzncbeh2p6pq+7xODRYb81hjqKiXujAPj6BhHx3a9JgbHndNT2TUGx6bvaLICG2UYuX/7TsHa9ThNik4T+huIQZX34u+999BXQJ+cBb1zdBFqUwIqaRleGqymbj3GPTMmBWib5MOvPnvlUTHZysj5U25AxR6lDYEgC19eCCsqirVHXgpU0I8jCnFMDTHQTBoRfq1W2NaQZzLHKvOSEJBCnZoo78X2Vit1M3i0OXmWScZxlqcAno6qKA9CwhhF4BdCQMVIl1gtq9U1WmsePnzI8dGC6dGMIYwJZ8958ODBYaEM3suOJ0SackIMYjG82+1o2w5jLbfmS3KlGfqOYddR5RnnZ1esNxt2ux1lNaEsaz7+6GPu3r9HbjO2Yy9aDhBvpXQ9gnNcrNdcXa8kv7XtcIDzgbqpqSqxX7leXcvOydpkOjaAErw+ywRaXjQNzbTmow+/Q7vtf2Rd/bEo7hBpmlo6m8yilJFV3SUFaVlRuwqnI2vfoqOm7wJdGry0bUe328g0PWVjjmEksxZd59TTCW1YE6IjBDAmZ7k8YTpdMJ/fOmDsIQZ2u44PPviAoihZLo+4vLzEe9kBRAXX11eMQ3uQCk+amtxaRjfSdh0vzi/pui3z2YJX7j/E9Y6TkxO2o1h7fvL8CVs3kM0KirzA6oyyrrA6E+9oPzItG3Qmw7fBQDtsWa/WVHnN1ASePjtjOvF89UtfxETDZvNcCtHQ07cDF2dnnJyccHR8jDaGvl+RvRRy/PlDOm4OhVxGGHv8+3MwDjIIC4AfOlAWP3RiKUDCytX+TyoN2dLH0kBzL0Q6XP3P8PLi4d/2cnkoEqM9BTJ8DlXYd5fejXS7Lu0UDHmRU9iM2d0G89Dgg6KeH3N6+zZXF9eQaTaMjCrQh5SSFB26zJmZOnHFw8GIbK8Y1ZmBIdJUU/quJx/lPl1dXbDdbrl3ekcsexXEwtIjOyPlpYAGpTBFSe0swQW6ZB2cZaLO9j5graWua4EjvMelhSLz0OrIYBW5MYxRoZ1CO4mEkx2ZwZoM76XTVfvzG1P2arw51+qwMMiC3LdblOpk8Kw0MdPYugDnGUZPO/T0o9gAxODFbdPagwOn1jYtVIF2J0GGAs9Ipx5DILP2cL9oZLbmjEMBm/WGeZHTDqMUtDKn77qDudowjoShJ7MZ27Gl7cTfp65rFm8uxTF2VjFmii6MeAKb9YY8L6Rrz+Q5G4ZBFlKtsJll2G4pioLJROwg8NKOrDcbCm05Pz/n7OwFm80Kayxd1wKKo+Mjbp2esgdIbDJ+i/Fmxxm8pxsGgWnzMqlwp6mIy/vP85xJVfPs4kmys7DJr0ZTVSVETV1P2LY7ssxydHSL3ab9oc80/JgU9xihLipMLluQoXfkyau4KismeUORS2yXKTOCU0S95cmLJ0QjDnR5kUkclc0pilK0LgS0ChijOLp1RFk1aKMZ+44BEWOcnZ3x6NFH3Do5Zr6Y8vTTT0ApHtx/QIye1fW1mP4slbAiQMRFWjIj5/Mpr7z2kA8/esxuu6PvO86CQwdF9cZbInjILc20wWvPsjriwVfusn3xjDEiC9XQsd22Yi8cYRJrsjFDa0Ndi+BhcjShriYQFHGSc7Y7593H7/OVN9+RIZXJqOoJda3o257zi3MevPIqWhs+/ugRD++e/PDzjwFliHEEZXBESGZfe5QkJpzFqKThjDF1teJrfcMn57D3r0tx3Nzudjgn6uEYDc4ruTaIJzfK/X56XiQN0rTwswmIxfC+Un2uA5WpYNohKCKeoe8ODJlC10QlSkClLVErgg646Gl9RAexf9Y6Q6ddyND2bNYb9rGAMYr6dne1ZrPdSsiy1rx4/gKrNXXVEFHsdi3HzUyi0QbPmBu8lsE4WuM6Gba3u5bNZkvXtVRlRVHk1HWVGhzBq2PyLTFZxhgixuQUAfKYoaISLDyLBC8YrA5iBZwVBbHd2/zKIFUrRZGJL0visia46KUCrxU2y2QImP7VRY/KLVYrquQn03cto3PM5ndlMKpSXKPNZS4TxO8mRumKJRBHzK/2C7Fk6eaJmhqhKJjfylBak1cSnOG8o55OMVr0K1liDZEGyUVdY6yiynKC81irGYNjcLDut5ydnzEOI8a0Yu5XVayuV0QfOD6+xWK+wBrNrdMTxl7okFppdJ5Ld01A+ZGx7Xn24jnddis5yaNju90wmYslgvNyz2gjWQoqcBDSeRR9L4tjNctYHi3Jipx210qhb4Ry7IeR+cktjL3CB7Epz8uGqp5R16NcnyZnGANFlaM+D7V+7vixKO5aKbTN8GE8QAh9GtJY7TB5ycX6BdPJhMJ7cl2wOJ5wPDviyfkn1JMGHQNucOzWrVjyNvKwqFxR1CWFySjqmm3X8vHHH/HKqw85Olqy2Vxzdb2jru/jRlElXl9ds5jP6YeB7W5Dnm7YdtcKJ7ksxf+5KGi7HdV0ytVqRZ4Zdjsjw99hZLNZMZnW9H2Lj47zqwuihuzTitzURDyeSD+OoBQmsxR1hp1lUuxUZD1scN5TFDLQarsWnWuOFse0buDp5XOUlWm9BIVXjOVAPwysrlcYY+mHnq7vMYcm/CbpKEbFar1luxsompy26/nnv/3b1HmBUjCdTmi7jrqZ4MaR5XTGvbt3UPQQFEEJC0OjCMpwverwPnJ8NMdmwmMHDtzzbduy2uwYhp6myLl/+/SzdfqlQ0KrA7vdwKMnj9HK88brr6Yw5KQuPXyySt4xHAq8rEGBgKLzsN1tOQky3FTJpCuPGW7ogYAfJKc1yxUX7Zpd16G0pm2FZbTf1u8phV3b4UaBFkLySi+rmrYf2GYd0yzn8vkVPjR4FVDGM1/OuN5c046d2DYbQ16UeO9l7jSkwPSEkyulDsZk1li+89H3efbpM/7oz/0sdVnQlBnBj0JfRHZhLmo++PBDZvM5RZaTaYF3UNC2HVV9Ywz38mxVKYEKhr5nvWvZ9T3zW0cSxBwDw+hY72QxEl+djO2upR8EMgopTEPSqcIB1hRI6+ZZ3zN4QpBdS1mUVHmO7zui0oRMLBRQQhEenSMaI8NhxOrBaJljOBMppzWNyfjW7/4ei9NbLJtbol41hjt3bqOVZNj2fU/fd5ycnBwcSIdBHBaNNkQXsVZ8b1xiMimFGKANHVVdYrXier1FWUNeFSxPjnF+ZPBe5gleLD8S74kY4cWLF7z77nsUdcGtk1vYPBMGjBXmVNt2QplWkDcVlXeM3pOXNdu2J8s0V1cvIMC27+F2Tte1bNf/NnTuIeLWrXRnIYgzXDtitYx13OgS7zcyxpqyjMzqCbPJhOe7jHHo6LY9V5dXEBVViq26iSxTWCN2o1ly89vttlR1RZkYMm3b0jQNTdPw+PFjzl+8IMtEVBWrhqHrGMeRvu/IM1FguhR0PQwtt46PWdmc5dERfduxurwUm1jvmE2mNMsZzXyGnUngcAguDWoUxmq0kZve5kbMkKyS7miEzWoL8ymTRrzSi1igrdA3vQ8ptEEecFFLKtqu59Gjjymrino+QedWshk/dygFMUhnrAIE57i8vMQeLYjeM5lUjGNP2ybPFdezN2067O9TnNw4DHz//Xdp25Zv/MwvMJ+W3ExBZdAaQ8AHmYPcROn9sCMQoqftB7773ffIM8Vrr74C5mXIBg4l/XNMP/mc9FEHV+dXOCeMoHEYSGloWJ2B8nSjo/UdYxQoJa9KYrKg3itHxZnSpMHaIIyOrmPoe6azGc47mrrGacWg4WK35fL8mhACJ7dnlLMKnVvRb4SA9p4suSrK99grbIUpM47ukGGrtebOwztgFaawaKslys/LYrWnzMQQ+P73P+BLX35HIhTzTNxUxd9Z9jmfh7bSf1LYAt1my9NnLyiKinm+wCWvnn3+p0+iO20k8MQmBbZznt2uZbfdMZ/PpStNrJn9zhQf9ub8B7aNVRpb5jgC7VZYXVVdi4BsK55Le1HibrulKMs00Jbnvbu8xkWPzjO8VmSI2IlCmDbd0OG8aB+mkxmZlkQmrWRIvNu2RBWFmTOMSd2taDdrGBzj0ENUXF+vuV6tuXf/HkdHR1SFvA/f9zjvRR1vhCq8Vwgvj4/4ylffIS8LTKYZhwGbqJVd34mhmnNURUGRWex0hi1yzp+vCc5TFKIBms/mgGG+mDF0Z0wm/xr83P9NHwoIbc/gHMMwkmV5itUacdFTHc8oygplkym+VYRM4bUi6EhQgTGOTKcTtEnWwMh2NssLfCZeHzphvT543n//fUIMOC+DzvV6TVmW4t9Qljz6+GPu371HkRdkxuCd8NS1UXRty7RpZDCrDbNaiv12IxhjXTecvzjj/Q8+5OLijNPjW9xRDzAT8YUYE/XQaIt3LuHICkKk3fWYXmYG282GoR1odxK1VeiS6XwpjJL9hJ5ElzOGTGs22y2ZtRSFwFPGWvJGwnfd+DL2fQNtaC2Tf6U1gUg/OIzOyGxOZnPqqiYEsR8wKilZ08B13yfLIC9iM8NE15Km9xKOntlMgjBQwifP9MEg7YcdkZBMzoT5oTAIsLzfDZAKfIJvPueZsmd7gKiPh6FFKVlItdF4JTuXXke8hrFSkGc4kAcx5sTgsYYEzRi8EwxecOX98FeTlyXDKErirm15+PAho1bcee0ByzsDl5eXHJ3MyCqDVZNkhzuglKb3PWVVYa05rFf7NKA9nLEvjvPFjKOjJUXKIO2DR2Mh+MNiBaR8UqEcRtJ5TrCirICazy6ssniNHrRxlHXN8vYRxTQnZEFcKb2mXfVJiCbJZSgj5l5GH7p1YyTMfhwceqqTG6o+YO4+xf/Z5CAZo4S56yxDA1mRJ7W4IY6jwDAvibz2oSYRgYJiVFxeXjOdzsi1oTEl2mjWuw1+HNFacb3aoQvJP3jx/AVucMxmM+q6RKPxQ6TI8sPw3OiRzFiYTrh+cc52u2Nzdc3583PxbU+7LR+FcOF9YG9Wp/cU6jR7Uloznc9kJ2YVysiOJMQgUYRlgbG5+FdpmVuYzNB1Pf1uhytL2m1L13aoFA707PkzlrMfDrXCj0lxjwpUkZMbA0rjO2ExlHmFKSx1VRGyKUWeoax4f+uoUSpiMITeC3sm+ZnkRY42e4Mohc0zvIcsK3A+cn52Rt/t2K7WaGsPA7OyEOXfndu3aSdTFguhSMaoGMaBvJC80KzM5SJEnXDDjBgFBlpvNozDQEQUdsYqTk9O2e12TKc1KMltJQSGfpDtX4Sh75kvZzTTUrDuIaJUTZw2HOtjCJG8yKUo7DoGoMgKqKEfeqFe+h5rTMJAhV9uMssYPuv4/flDG4OJ+WHQ6T24lMiujCXLS0YnEXvGCta37/xCCIfBkYpQFFmC1mJyZ0/b31GoZQmcRWsOD+gPO0LCVX2QpBzvgtgEQNpy3Hy10kHi19IDto/X239GCDKMkyCViNKKIXicgmjkJxhGx9gPLOdzrseNBLcbfehK+34gz0Qr4b3AhuM4UqfitXfzG8eRi8tLTm+dEGPAVBnHzSlFmQsk5kRcdXV5dRgcS0iNoapLYiSFQ8gAdF/Y27Y9/Pl0viTPctAGVSiiB+0jysuC60LAh4gO4iwZgiSQmcNi/JknkKhC2tWI7YMtCtrzF3TdiMlynPfsupZtKx4yWgvLSBtD20qy0DAMhCAYflXVYgncdodrUhQFfd8Dgv9vd93h588zSVoqy1LUwONIt90K26YsU4IWlEUpbBnvZTHVmjYEnNU8fXzGbLpEDxFrFItswouzM55fnXPZ7+gRcSFaQjXGcWQcLZNmQl1KaM/Yj4S9MZwx5GVG17VcX16y2mzonePk9m0J7JhOUUYcL1GkXNp9MxGIYX8/puds3+14gbi6XuIDq6qSppQbyFRrzWQ2ZbO6RnUiCuu6nhB7iJ4iLyXU+0ccPxbFXeb0EZfM8PNcVnClBBe1RpO3EasUaoi4cSAbcsxcsbtqUWNgUtX4IPS0nfcUuXgmB6PBqKQuyxgHqMsCP+5o6oqT07tcrM64vrzEjyNNVfHw/gPZKhU511fXKGVo+x6b5+RVBdphiwxcFMuAQXj2y+WMq+srmRXkGUUUu4GnL55jq5xFBOuEIeBcQEUlg2OtiZOCfF4QwohzIz460FHCOXJZrIoyw3qFcpEcTR5FCTmoABqqSUaRy2Jns4LRRaLVFGXOAXD/zJHY11rEK3IxpEBtdi3L44W4+KmIUUGuSeLdpuC7VL59uo6QFRnKJb50FG9sGYyGNPAUR0abSRcTVPxMKpDU65RSE+Xzh9HhvFDK3CjXVl5/z+hJDB21f42XmDjIMuODZ3DCCY+JllhEQxU8Nhi8Uqwur7m+uiRDs243+CBUta4PEAR2enL1aRK11QzJA79p6gMEGGMk1sL8ur6+5qMPP2J1vUYbzU/91NepJxXr7RaTZzSTBvyNvatSit1uJ1Cb0ux2bYJmxhTwYA8KSe8cISgypVJ8nmBSMcYDLr3rOkqV01QSqxhGh804QFX7a6bUDayllQgBCV5gH6uJGkJEZkJR1Mp7eCaEwHbTs1qvWa9WZDZnuVxS1uXB0mN/9H1PlgmbzXuPzaSgKnTKuDXiS4PoS4zSZAmaGp3HK5HyG3UzixC+fU5xtOB4cBQTof8uZjPatuX64opMG+4e3cLHARuhXiwYM9lJGC12A0EHcaa1GuWFTtoHGQDXixm3QmAMnsXxLY7nR9RNTZYWepeaGSEiiXo2ppN8oyVJO6VAUtg6cis7CRUCMfT0Y0iUUMvoehnYZ4btWu7FvcVDbsU2ujD/wy1//40fMUZi79Axii2oQFboKB4juTKMyqK6SPARHTRORcKgMIOm20goclPV2DzHGktlM87OLiTL0GhyYw+FQCtFU9fsNhs4CUybCZdnZ3g3ostCbs5KvDP0Yo7Wht1Wwi72EEqMMQXnGi4vrsgzy2I25f69uzx79pz1BrLCJh+Mmk+ffMp2u+PN197g9u1Teq+4Wl+Lm12W4SV5C2MVeV5hs0AfR8Y+cHlxAWokHAWMzhi6FqUNrnOMzTHBaca+R5eR1u9ATYhBONPWKopYkfnAy84ieyaD7Bylk45eskyrqmJ0I0UuSsCizA9+5fvE9YgFnadMT3FWDAaWx/cSnJKx3ibPn5RPKcwVMNYcIIjP95EvZyztt+vb7YAPGudGhn6gaW6sTg+iKWS2ghavGgnt2HdR4IPDuYEblaYS7/GgGJVY8GbTklJN6PwgEYJJpBSTLUPf95yfXSRhnU3Ck/xAkxQqozoUeaXg+OQYiNw+PcHmlsE7lJFdh03CF508jaT77SHCMNwwZaSwG6zNRBOhlIR6KE1wEZwsvDrEw7BYKy3WwApik+7Z/fwjHeqzvwEKZS3aWOo6543FRNDC4CiMOIJmuWQSbzcbYoyM/cDZ2ZnASKmQd11HnnYpWutDDqlcK59UqzL/ybIMo0WF60PAKoNVWiyxk8z+eDojL0rOLi5ZX66Y1jVHszlHmcCFfbdjt+24e3zKcjrjvXffZbfaSDCPzYjeMVxsyWpDM6/I+kATDLtdyg1Qimo+w9gM5aVpGN1A8AFtxChvOplQvf0W9AHlUqarNfhD0lW6BYO0PFEJzUA67u6wgOe5PEulLSmNZbNak+XCJrp4ccZksURngaHdyaA8ihlbWUpYTp2VKCzTyYzg/y3o3IV5FzBWBoLi+ibZi5XNqLSmKBv6bkBlCjdEtA+EsaeJsmVpty2VtVRWY7XGhIANlqNoCf2IcT1hbCFMmJQVuyGw3lzTtlvm8yWL2YLN+oLpdEogCGadW+qqwLvA0HfoJCp5cf4CqxXL5Qm7zZaphwu/4+jkmOPlEW4YIAoFM0xGTk9Pub6+Is8M1gSi75iUBTrWtKYFpdh2HfpFkDSWacnoAnHwPFufpw6yEBtdYyimNVoJy6Z3nu1mx/nFOaf1LWwFee0xo8XGDNd1+Kr5rI8LLz3iKuHJRh4ucSTcsd066Rytoa4FtnLOJ2FZ2vonhkxEJbpipCwnh2vaDYCKZEpjVEjfUyT8xhrSvvUz0z310u/7Ark4avja179I6Ic0zHzp59jPD6LkrUZVElJzsD/cOBJi5M6duwcGhwue9djjDewQgQ6lZpJNpcvSoqYcup6h63nx/AW77Q4iuNEx9AOlKmnmNVqrA7NlHEemTU1EuuV60vDKG69KEJxzaf3RZFbmJVFpXKINDsNAPZmk4rc9zCTEG8jQ9z3eG8qmwSnPoCIhE//x4CMMHu2FrvrzP/vTYginLIZkBxFvVMk/mKKkxBslUfmUTuBamq9IVsJI1wsbKwwjwXuOFoubgbMyjG6k68S+uigKyUNOC5/3440uwYtTqNA+Pb0fKbKSKrOgIOBp6pLr9TOKwXD29CljPzDRtxmyUfjfxrC9PqMpc6K75jvf/A4ffvCEr371y0QcWmtm8yUvzs6wWnP2/Bmz8ojghPY4ny8EGlp39H4DKKqyRvWOzWZD1/dstlesNzvm8yXz2Yy6qtEafN9zcuc2m27Hrh+ETaUUQUOMLtlItId7eRxFuLWPx9wmrcDV1Y6hHxhXa1qfUS2nuHbL5nJFu9kxm9Zk2rBbb7Dasl2vmE5mQvX9EcePRXFXAEPAuMB0OhGRgRsZ/EiuDN24RfVbqhCxQUnnp0C5kfHFUyazDK0jC3pUK/1psIoci95tKI0hDLC9OGfjBxhHXrk9JfgdZXgO3TW3pz2+zqnVEzK3DxMOIkjQJZPmGqOuOZo6Xq8i2u7I3EcUy47qVknrNIW9xtaRcRZR3BIqsR5Rugb2W+8L4ALlc46yHqaBwSmecoJzgWHVMlzvMJkGFTiuG6rZlCzX1EVDaEfiGAgmUk4n6MKi7UgxqXj66XOO9YQx88wrOD875+joGGsURkVG9uyUVELVobdNf0n0tFZ8OJ49e8ZkUgtsEiI6kobV0qbs485iFJVjDOLbLofAMVorMNKPy3dOfOqU5fr78F91gxnEKH4tt2+V3Dm+IyZkUYa+PxhkCgRl0xA2GWURcUFEtXU9Ze/d0g0DPaJ/NQgeuocwq7zAhcDV9RWffvopwzDSJ1pkMykPWGqWZWLlnDJn27ZNIQtiUOVjPPyE1kcKDM4ogQq9px96nJxaxnHk+uqapq4x2rBer6mq6mAFHKNg+Xthk7ai9tSA0zLEi37vTQ9lISwWiKjoBDIIe2naHgZ7mfGUqEYh4L1g6WQajAXtCCnBKgaxiM7zApXlybrZpPfn8Mk0yxqD0fshq9wTAislO4NRFgDve9GRxMD1xacczQtCqfBhJAQ4/2Rge/0p87mi1DCd57TbJ1xd9EymJdvNSFFlxCDfP9rIvVc1MfseXRcoCsvj598jL8ExoesNRXYJeoeqHCFrcF7Cr4kNblQMYUs/eEyhqXMY/Y6yUtSTFeO4xXNEpCHqnEePP0bbKHkCFFyt1lRFJQ2RFzvysqjIcot3AyFYjNWEGJH5aWBc74ghMJ+V9H4kRs/6+ordbksMgaIosUYMz/quwzlHlhX48d+Czl2FgOoDWo3UTYPTmixqUIZCK/ToUQmHNkHjfcChGbcbhrEVf2tl8UOLUvsJvKZUYlK06wb8Zicik2IO40CuIKqWuPO0W8/UXqLMhCLsiEES0Y32eG8xdkIerwBNHAK1VfRhpM5KKq2JDBjjMToQxxUxrgVr9BkRjTYDrpebOGKJ6ZmBHJvdwnpHHAVO0M7j3cgYIx4oB0vRKVTX4neW4BVLU9NuO5p6gh4CWkXunp4y+JFtv8ONgVW3whrxcFd0KCwHSOLwu5TIIg8yxNMwbRr+zC//MaLWFHnOdDoRx7y8QEHKcZRibUxAk+GCRyUhSlR7rEeKhUZsmEnCmbIwFIWIdCJ7vro/CDI+gxJEJRBD+oiKe2xZpjT6sDpFUCJHF661wbPH7xUhOTGqpN5UWgzLcjSWiFeJr++FIql0xtX1NZfrlQyRTWAynR3wbpDivtltKEPJthV3yKZpmM/ndEMPQ4/NrWy5gUHdFProA24cGLwDrRg6hx89mckYOnFbLIriMFzzXqyQi6JiGBzDsCPXgl1XVYkxGkdAVxkupoAUH9FRIAV8xASLDnq/tN7MKpCu3gvhCGsMlbay0EfZzXXjSDvI8HjXChc9zzOM1sJw226JQTpVpSQDQUGKkNPkuZVON3XtB2FWei/7nIDbt18jy0BpT54pQtRk9UhWN+Rqg/Yr2p3ALX03EkIHsWS3HdHWS0QfYOLIerclzzK6AXY7yBvFto30Y8PorgCBWSX2TvByHSxo6PtzBjdQp8FtXgaUBpsNiVyxxVLgiXS7gFZbrlYDjx6X7MZAmYsj5nazJsaRqoSHD06xeYYqKowqJTQeR54NKLWmmUGd92yee9ADamxQKWugLCthq+U5zgeBcjKEcvkjjj90cU8xe/8C+CTG+BeUUq8j+anHwG8A/4sY46CUKoC/AfwMEoz9H8YYP/xRrx20Jl+UKGU5Vz2FMVTKoqJmEg01GRExEIpKunICnJ2fUxYFFkWmZUjpveB0RmumzYTr7RbnIto5YghYo7hcrfn+7wSkDAzMm4o/8lNvY4uK44evY+2M50/eJbiWjByTNUAPGMwYhIYYYDYZKHJxShxHx0jOdngTkx4ioTBYvMnotyPD2FFOSpRSBJNRVxOiyqitIq6+ic0NzXFN17f0XYt3A7G2tOyI40BhDH6n8P2Ooe8Yq5aVuWLbDkQ6TGakk0dDCDSNJK6v1xumZfUZ+iOp61ZKY2WqhtJQZopX799mbwYW03Y82XAiC4QwU8o8Q5lI34+g/WHZiEpBlOtlrEosFyBCZtSNCAmdOv0fcpMe8Jf9yF3wZIXgmuFznX8kErxLzethW3L4atk23wxtBxUZ4ijj4Cg7wlFlPN+tcEiBzbIM78uDvD4vcogcPN0hDciCZxh6Ls7PD0PDbMzInQzFtNYH/FZbg7EVWeo2jcoY1ZBcIaFOEIbWWganzhGVOvjc1FUlmL/WZFpjBD9hb3xnosJEeV+J7sVeFpDleTof4TNnXZAxL7CREg/1Mdn5aKUxTqNsRjHLGZxnOplijGZ0A30y/BtGUVHKLEJmECYXTYA1FqMU3vk0w1rhhpHFbI7RiqKoefrsKXqakdeFFLYQOfv0U8L4lCp3ZBZGH8lMKUlGQVhGVXOLalKh4ojVBaP1oFusFt3MOF4S9s8koHVBli2ICMwXfMRmmm5n0DonqlKgYQNjN5DlVaLCFigcIeyArUAlgwcTUNHTTGtquyC3JYWZcPb8m0ymjjfeCmT2I3bXGdopRjL6LQxugGak2yq0LvH9jnZrCUvHxdkGHw1lOcUHydQ9Oj5is2l59uwFx8dzUp/xQ49/lc79fw18G5ilv/+fgP9LjPFvKqX+78B/AvyX6f+XMca3lFJ/NX3ef/ijXljFQKEDtckYdMRqsfwtUoc4IDgiyspEn4CuKvwWmqok+FYGZiiCdwxdL5xsY9JEXQQ/gUg79oTaUuqbbalt4NJOMEpTeFkozrBoNaE2c5nQG40KCq8lLDsQ+LQdMT2UhcVYxTgqxhTXRhTObwxQ2opoFR8++oRoA9XMovKAvoLZZMnF9ozWjPgQKMYNMQOVK3IlMvl+gDiIVL4fPJnRBA2X11fMZguOl0e8OHvC2cU5RhsWiwXz2QStFNeXK0Y3kmkjzAqlPiNgOYA0L3fL+8KYOt8bbnTq9xNuO3Qt8cAvD8QEmUi6EVR1jTWR3dYlKuZeQ7nvG6UzVfth6OeOiARqx2Ag+qR2TeCOUp8t7FEYCU0pJd/Hm4i6IUrB2uPGVlsyY8mVZlQaHQPeBzJriMoyvPTaQs0TSCQECTOPBJqpwFXDMIj/fjey3W6p6xpja4pcOuoiL2VXECMqahG6JMOsoR9EnBf5DL107AfaRDncOxE20yku0SW32y0uz5iXNWqQj8uZFb/MqMBWDf2ugz1sFsWrSSuNKew+IuUzs5eYvvduu+Fiu0FlmtPTE2xmKJIQKvhI225RZQ1e2FpsO5rZlOlkyq7rUVpRZzlFnlFWJR9+8BEnt+7QWMvzF095+OBVNmHFl778RVw70LYrtC149MEHfOVrb+OHLe04Mow7zi+uKJoaUzR4gzx/0XAxKI4WU/rdgDIzhiFSZRnO55IBXC+IxkJQjGqgD+BjQVSanauYlAtcvGIMGZNa+OK66olB4cYBF3bsujVdZ6kKQ1nNsNmx7Pa9w9iIVhN8eMYQhM2yOLrL8u6XqIuSq/Mrwgc3aV8BxTA4Spvh3UZyYXFYYxi9AuUZhsDQajargY+ebPnCl75MXlhWw44iy9i1O1bbDb/zu9/mi196i7e/eO9HldU/XHFXSj0A/j3g/wj8b5Q83X8K+J+lT/nrwP8BKe5/Mf0Z4P8N/BdKKRVf5qf9gMMT2IWADVK4cmPJD3CgAh/k+VeiohOrDlF7mSidTUyuec6NKKPouw4dpFv1GnbtDp/PWbyxRNm9Vaq47j3fPiKoyHn/jCo/Zb1+TK2PmGYli5mmySqGoacbAheXA7tdK6k1SnE0Vdw6LmXY1I4ED+JZDsFHNruRvK549c03efbsCRdPz1FNoF7kVDGy8wNUmtzkaMzBDZMoJlJxGPHDgKGksDkxDoSoKYoJbTswDhesVitiiBwdH3FyfAub5Wk4KlhxnufEUVzkPnMhYqQffOoOVOoQHaMPeC9maiHBAs455rOZ8OhFbZ/gDo1RitW247vf/4DRO954/S3enDRYrQ4DWAi0XU8/OKwR2Ecgmh98a4jjYaI8psXF7OcFqSN9efhqVKRM9pbKeIGQInQ6ivMjCpuQCqWgiIqpEqdLlwbKn2wlgDr6iNGGrpdA7M1mI1j3tUoe5BmTyTRBPMIwgqQZ0Bo/joQgQhSTCRS0a1u8c+RK8ga0zbBTCQHX6FSAJcpPK3GkzK108SaJhmwSrKEiLtP0RggESu2Hy+CJbN0ONzqiC9RZhvYR7/csos8xlD632AeEdmyVxXiI2V4sFFHOsVtvuLU8FrNO7wnjiG+32KyisGLK1Q8aXEGeBXQceHDnLouq4tH77/POO18Ga/nSl77M97/7LqrRGKc4PTnheHEXskjbixXDeZHOmZlhM483ntEFvLJkzZS+X+Pw5CanD4Ztv2PX7chmx6AUYxiJRQNljVGW9nJFNi3ZqQC6AQyj6wm+Y58vsPYZMSsxpSjBvTEM1tIOHUrLjl97A1GxiQpbzHBuR2bEk78oS4y58UPqugqjI9oG1huPVxkuWPp+i2k112vJjMUZnIPdLvD8xTn3Xtnwx3/xFxLRYcR7x9XVNcvTO8yXE+7cn/6okvqH7tz/r8D/Dti/2jFwFWPcI/qPgfvpz/eBR+mBc0qp6/T5Zy+/oFLqPwX+U4Ayt0x2nrIqZYDpYQwOR8Bo8MFjCaggdDwTIm7oGWJDraFAQwo23g1jGgAKrumshEHECYylYbteQR0wSjwg9P5JBzFi8gH8iI4WrWZEZegGT1HCEODyumOzG3AOdAoR+GS3YTv0nJ7OudqtCM7jBkcI0mmVRUVvFPm05vTV1ygmCy4+fcr68TWT1z2ZqQRKIk3bk9IvRkWInhCFn/yd77zL7nrgZ3/mHQyaXbumqSesr9c8f/acvLS8+fpr9F3L1cUlmRWO9Gq7Y1k3lJn5nOxcfu62dwQUVivGGPnu99/n/OJCutlCghdsltG3O776zle4VdlDpz3gsQq0inTjyPfee5/Rjdy5/SoHO8KDIhYJX/YRF8UGuChEdfqDynsEurHn6sU13kfKzDCZ1EybhoOWaf9LgfOR3TgcIAqldRquCo+/R9TMIWkI1sql3UOgH0ec83Tekdkck+uDxa73AnEFsZtM3u2aru1omgYfReCWFXOIUGjBnNtRgq9tZtNgNJOmxUpQg1XQbdb0fc/RfImOBm8gzwxDP6IVGDSZzSGTbNgYo7CBFBR5iQsebyxZBFSyYnaBT977mMuzFYvZglfv3Ukyh8QvTlEq6qZvZ5+la40mzyMTJfetRtGNLT0OYiREx86tGWMLSWzUt1uaumJo1/ShTYt+xthuWA2fsm13/N1//Lc5OZlhTM4/+c2/y7YbiN9uUd3A8SdrNg8WEB0GyOsJ2ilm9YT1ZM3FasMrt94gK/ShyC3yI8o6o30xkFNTZSUxeja+JTjZCQYPgYALihgKPOIZ4z2SqYBJO+xBzk1i6AxDJ7CYaVBWdphD1KlaZkS1pw0EvC0pm4Zdrwjray4v/yVX5Smj35DnDu8Nt4+/gTGa9z/6Ll0G5bQkUyNFfYqvPKa8JpoZzfQIW1p+4qs/y0/+nOXNN7/Aa6+9JaiBiiIk225xbq+urfgv/s9/4wc8OXL8gcVdKfUXgOcxxt9QSv3yH/T5f9gjxvhfAf8VwGxax1WmWPsBokbpSIaiCpDZnKqu8f0avHSR3nmGEOljTmMkIk4ZGbtJWo5hGDxlYcXju8kYlxmVzbhzdIcX2x0gnXtIlDkNJE09XkVMVmFNBQiO6YP8+t577/H99x9hTMad2/f48MMP6fuOn/35r1BVhsm0YX29JeLIqwZtDc1sSaznPBsc6/OWEKawsOyeRh69+zG2iBgbyGwmSs6kZBMerZipqRDIRk9oO549fi4rfboRtbG88drr5KVlu9nQt+J5EvOCzWZHUTTE/Q96c12l4CqJOWyaKWHs6bc9i6MjqqamKms2qzVRKWwp/HptLYJop/cozYnwem+ILoLpqpvisfcjiUAzqclzS3T74nqzwH7uHiESGd3I9773PifHR9w+vUXTNL/vc+R7pl0eJNMxl6YEil3bEyN0Rz15FSQK0XuxiU+7PpNZaiN0XD+GAwMjeGF/iJhG6HWZtejEW67KicA1An2j0VgP01ixWq0YesfgWrKmZBh62tFxtJijUbx4/wmfPH7CL/3CHyHPLavNGp1lYntRCLf/ZDJl6Ee+/+hjSMNIrS3m9JRqUqJtFF1ISJ4/zjGuOnabkeVU34xP441f/ufnHFppGUIH8czZbFuMthibMW8meC3P3tD3HM1nZLms3UGBzSLBeUyuMErjowxo92ibV5HRRdwY8WPP+cUZIYPvfbSi2g3c/60rvqlPObo/J8QdL15ckkUoTUNdTBmaQlKfjCEzOVopFtMjjNKsnvUs5kcc3zrGO8e9ecd6dcVme8XiaMHVesWLdk1uC6yKGG0PXHTSnbyHH/d3ruD5OYQMVEzJY2mSc2Bzyd93250o1qPi+fkz7JizXM4JsSNGz2JxJEHqxqCMJXhHRsnbb73JpCp4drXjiw8m3L5zn+OjI6aTOUUxQZtMPN6vLtlsNuy2bTIQLJjP57gxyiL2I44/TOf+S8D/SCn1K0CJYO7/N2ChlLKpe38AfJI+/xPgIfBYKWWBOTJY/aFHDAG9G6iUguBlAEUkA5pqyuL0VT49OyMMjhAE+/zu4zMer57w6rzkK6/eTiwOhc0rPBanPC0K0zTERY03gV3nCMM1VV5gcoVKhvoqKozWIjfXRkQ3scEqQ/A9NmuIBEIYqWvDT379bW6d3GKxmPP227e4ur6mqgr6TgQozjuUBpU3VIsTdF5zMYx86/tPCN2ArS1HdYM5fcD96iFWbendhiyX4N6oIsYoMmvou57MZBRlBvkRrwyBhw/u4gmgNf/tf/MP2G46/uSf/kXmx3OsNmKlazNZLAbHxdmWoqiJ8fO8WOnfghfhWEyePDbLiEQWyzm73RbnPVoZumFMIQk3r6AAnZiUhJsBZwhOhqhpodq7fe75l0pxIE3KP6uXXvEwmoW4V6tGTCYhynsO+b4rP9SreOOhrfbfC6H34YW4HfYDTaUo0WilWA0DQ9uJ0nMM2LIkLzJyWxLCyGoYiNFhshyr5TUyK0HLVVViMo2JERMRdaOTYaWOEdYt69WGbTtwebXi/sPb4ANLW0swxc7BIE23juC6Ed17hmFN1dRkmYiHvO9x2566KcEolDZo78mDwjr5uWMQSp+OjiIrmVQGjU1IvFAUbzJXbxZoOXUxWe/KzvHi4pzrqyvefustThb30Nby7OlT3KD54z/3p8nznIuzc1bXG3bZlvt3XmFxcsJqu6aoCoIK9H3H9eqcV45zfFAM3Zqz3VOWsxOCVYx+RLWXtEc1i7XnonRcr55z5Tq0g2W9ZDWsCFbz5MUHZHmG1paqqCnLijIv6fwI2hKizNcm9Zyhg1df+SLeDZj4nOfZmocn76AU3Dt6k4DHq4Fh7OhdyzB2hCB+NyF6qiKjUXMyNAPpflcRjRGh9Z51Fr1YjYwBkymm85LVVUs+GTm6VePsAmUDn55fU+QF9x88oGxK7p7cYVlo8sLx1pvfQOtMCn/U7DaesxfP6FoZ2OdFxnQy4/btu1RVRZ58dfYpdT/q+AOLe4zxPwP+s/QA/jLwv40x/s+VUv8v4C8jjJn/CPhb6Uv+dvr7P00f/3t/EN6uQyTfduhi3xVGXBQ73KA1qsiJ2qCKkuA0zsPk1j2+cG/OojJsSot4kitUIfF4moBXwsRhAL8b2LUDO3fOz379TZqqwblAl+xw3SjWsIJTIit9aYlKOMh7Qckbb7yWlJ/iYzOd1jRNRdd1kqm5a1GIOdlFHwgbjVYdUYHpAuuQ88r0lNGNfPuTK3a3Jvzs7RlN3ohgpzlGG43zQk9UlQIdKW3O8VsPmNtChF46stpcs7pYEYBv/sb7HB/N+eLbb/DKw1OaZkKWWYZhZHXx4UsX9DP/S9f4xsyJCNvNlrzI2O52kh6T50zmOUPKsdxP3w5JP4kj/dnXlI76YBCQmnNhlQwHa4kfcMfxciP/+a5+r+R8+XsppYlBE0O4GdCyZ8nIIjEOI9erNa88fFXCMLRhYUvGOHJ1tSO2HQHP9cU1s2bCdDpleTph1ff81j/7F9y6fSTD0jxjfnIsW+UoBl3F4IV6CLLgpHUs6sS0DwE/OtZXG7azCVVZoKJmzxpVSh+KbozQ9T02DVi1T3MGFdFGApq1UilblVTUI8SX2S8KYzSTZopRsti//Aiql37/7CE7kePjY46Ob0FSYccgSuGhH9isNwQXyKqM7XrL2bMziJHjo1vsWs93fu9D/tgf+6MoYDNu+Bf/8nf4c3/+zzNdzHjy8XtcP7ni3tEbLE9vM/qB6/lzvhe/z52H95g3GcTAIgw8eu99iknJq/dnbMYBk2m82hLCSDdesd69wMdAMXO0/ozx8hqNoXMFedlw+849Hj36EGJk7B2Zznny6ROKIuPk9IQQvSRBmX2/ITYCPgT8LQdesRnO6NxOqMmhw4cRF8fENXLy3Lge73uqJlKVGfUMDD11M+dLX3qHo1tH7DYli/mCB/caiizD6ozd5pq2a1G6p+s3DH0POsPmIvo6OZlRluVnLCf2ebp7wdwfUFb/B/Hc//fA31RK/efAbwF/Lf37XwP+a6XUe8AF8Ff/oBeq51O+8qd+CZRGKSPwlyJlpGaM7Ji+8ZC+H3jxyTM23YaYW7zvudhqhquO4BwhCj89AqPzEANu7GWYiOby6ppbiyWvv3qfNpQM3tN1wqZpmoY807hNh7YSiF1UOZvNGrHCFpe+cRzx40BwCm0gOM8wujSsSqwIpVAYjB8YN8948ewTFsenNKcLNIpVe027WlGOK7qLM9rbr1FqGajlEYgS0LxnZ1RFxrwsyZWiySzWygma54b/5V/+H/P+o6d89/sfcXV9za//xm/y27+b8fprr/OVL36B6aTm5HhJpjXrVc9m21E1lSx/USWfG8fZ2TlNXaBQrNfXtOc9IUZePH9BlmWcX56zXm+4e/sOXhlMhH70jMFQGIVFJO9a7Z1m4GYl0anbAT86zp5d0EwqppOafF4nIk7qJ9OWN+7Nu4MYtOkoOyuQDld8y28ghhD2xXG/pKiX6pei7zyr640IbUJEkRw1kVQl1weyzNI0E4pENdwHh6MyrCpQHuosR7Ud4yic52qqxKYXXoKl9rsN2TQQwGpFbnJcH9C5QoUorK8IJip0COgYILFp8qpJqs5k66ugKBtsLjMkyeyUYex++C5rQJTPjwEt/rqE4OXPMcUVIu2PsJEgktKxlE87JaFuGhREx+nRHJsXjJsVpYLjaU1Z5UzKgktridFgcstyMmc5W1BXDSio6oaf+4Wf5+T2KVVdcf5cLHyrquLk1i127Q4d4IOPHqGamYjBosbvOt773nOar93mldN7NEqug97b6O4l/wlmMkbjvMMNydI6Gt57/xnOj1TTire+8DohOG6fnhCiCNpQskhKJkBAK8gSXdPYGuUD07rGR087dPR9nxq4HqUhywzogH3jlKwwVI1mUk+Y1DPUULFczKnymtF73t08ocw0MSh2u5FhbBNZoMK1HWVRMZ9OybKSzGYHH6F9Eb9xcZVjr9n411rcY4z/APgH6c/vAz/3Az6nA/7Kv8rrOg+XO8tqdUlZFEznx9gsSa+DWOOWTUnVaH739x7x27/9e+S5oW4aqmrO9fUZ3/iZnxbaI9BMplxeXvPpJ4/ZrK75k3/yl3nwyhv83X/wD7k8e8H8+Ijl8habtqXs+5RTGZN3d3awhC2KIjndBfYb/hglNktrg0++4F0/kBdCmdNaH6TW508ek2Ulk37Fx7/5Lb74zlc5ycVZMtaR733yiHW7Jfvya5hMVug8E/nzMDiyLCPPCiodmFhNrvRByBOjoyktP/eT7zBtGr7//nucnV9QlBWRCe9+733e/fZ3+OKbr5JNak6WcmNfr9Ysbx2JD0i6YaZNlXw8PApJ6/HOY61l8foblOWe561ZzpcyeCbKcDRErDJgSfaycODV8fv7w8V8Ql0VidYnNhOCY94ERe+b9Ru4JVEFlToMUD9/WGtTes3+Sz6rYl2vt+KqF+JhARH7YbGMNUborpUpKQqxfk31A2vFIApgc72iLjP8OGCyAjW5wftVTBBjgoMO7zVx8yV9qWM2rW5+sMhLVNIg4iBjJIA5F+O6xd63O4qXkbVZUobadI7DgUm63z/dPlkSKLAWrE2LTFoB9u/sRj3AS+cknW+koFgrkAHa8urrb5JZOU95kfOVr36V41t3+Ke//v9hGHrefPtV7pzeJi8LMZgjcvvOiQjUVCTLM/KyYjZfsJjPmEwnHC+X3Lt3V4b21hKiIkTFG2+8SVUVPH78iMvVFUqrg49LTAqH/VA4ixGrc7ZdS1lW9D2sd2uMDdw6WnD/wZS+6xiT8VyWiWZBIjkj2sgORaHT8x0xJjKMvcxtYqBQhrJs8IU0I5nN0BruvH4PhdBjldFkpsBMLJmt6AOMY+BoOQci663HGEueV+S5xdhC9A9aH7pyuRZ7VtMNS2n/6+XC/m+yc//XdizmS/7Cn/2L/Po//1Wm84o33/ipm6c73XTjOOJc4Nf+4T9GIZmM7W5gs32GH3t+93e+RZHfFnxRd7Rtz8XVU167d8zpoqHQjo8+eJ/LiwtePH3EtC5Q44ByfRL4WMDiqkhW5IllJ9muzo2E4Ag+kmU5mS1QShPiyOgjhbbkRUlZysUoS8HFJKyg5snTp2Air7/6UHIhrSXEwN17x+zaVhgpOkoAR4y4xLLpug5jNL22jGOkzhS11ojj+D6jVPPOF9/g+PSv8s3vfpdv/s63ePpc+O6v3bvDg8WMZxeX/Pp7H3P34UP+/b/0P+XpJ5/QlHBx/pzgHUVuKIoK5z2bTcsX33rjQMmr6/ozXQMAMbFbAglnl8mZVjCZTPHOp6ScG754aizJjKKapAVO0IbEAuHw6+XyrY1hMp/y6huvkBcl2mafweoPb+ll2OGlh0T+kIKmlWYcHUSPT2In9nh+ksajNNbYw8BNKYl6lIxTRXQ3OgFzyCNVifp6832V0gcL170lbFXVlIUM3+Q03lg4kIrpOIpCta5rcmPZrtZweidFEgqbSgy69jubAIbPQC9KKSZN/bmZhqUoLFobcSJM5r/7EhkjqKiZTiaYrACtuX16h6PjY2xRgLayc0o/r1KaooRqs2EYBc7Q1lA1lXTRfsRHT3CS7ISSBei1199mvlgSYnJKtBmNzQ/FSilDiHKuYvQcLebURjrsjz78gPnxESarCDGCTqEmyuKHHqMM26tLzq5GpospH77/AXX1OkUmq1vba4wSh748l2d4T2XtxhHvPHtqNCiitSitqfISrWSITkCcO0NIpm95uhYBrTOiEpXwukvZBcYyWy7QKXA8Sx05CmL0hJieAWXSJZXZCJ6UYmUP11Qp0aTpqAjhB7U4nz1+LIp722343e/+Ex4/eZ9Tf4svvtWTZTk+BGJM8nQdUMozjjveeeeLfPLkCVlW0487gjNMJyfcXvxxQhR/j3P1nBfn3+anfvLrfOnN1/j07EqYJVrRXl0yyUYyM5Jbh2LNGBRDiGzWSvi6ZUkzqTFGJ9OmAbRKbIwgviKjBAzkJsMYKy6KWuTWMQZsJiHNd+7c4datU0mqGUWshBa1Y5ZL/qJ34t+hUXTDgDUZRVFwdXVNWZZMpzN2DvoIdWYodLjBnqNnWuX8wje+xh/52Z/hk0fP+I3f/A2sivyTv/9r3H7wCs2kZLaY0Y0dL14857c+fI9bJwuqIqeZ1LxcbcU3KxBj2s5z0xEeEFulxMTLR7JMzMVuZzV/5s/8O1hjKIucsswJSYQjX7lvL5MXikowymEN/2wnEqMk/DRNw3I2STf0DehzMzSV96Nf2r7eFAv5u01RhHnK32zbFusc2ipikK393qkyy7I0gJXv09Qyv7BWFtQs14ToJOE+qhusPS1mKuExSsnHjNbovODWrYaytDS1qJT3P+04DGmHIF2xcwNVnVFXBV/+0tuSZOQN9+4sQUWMTrlJClQyX/vsDCKdk8Ml02S55fbtuzQp0F0C6EeGocf7yNBIcEhVleRFSVYUnJzcpZ7OQGn8S98g7GcbMTKZTvj6T/4Mi+WS69UZzgkLCaUlOQmdHDMNb7z5Nlq4hcIKS1iWSgYTsmOLhP2YRdgOmEygqTuzhrrO0UVO3/eUec733n2X05NTHn/wiNW25ZX7d/iXH36Ln//FX+Dy+RnTn/4yk6pB1RmfPH3Mrtswmdyi67aMbiQgHXxQspMVyb8U8sxaVJqlDP3A5eWGrutEYEaUGtE0BztfqzW5lsS3vbp4v7tQIRx2pmafWRyCsItCQHmPtcLMCzEIBJVo0fv/RyJxdJCLl9bva7o+d/xYFHdUJGSO177wGiF4fv2b/4RnHz3BZqDnGXF0+AjDZceTJx+jC8PgBormhLo+JrOyjb0I3yIqGfx88uI9QhjSiRl4tn3M13/hDaJVrGcd//iT38SrfYAwKG2oaCiGO1gnmL02kaIo0FpYK5v1WnymDVgrA8d210p32UwYujYNPmQrpZOPfPDiJy5xaTphn3sqVjJ3QuNGiXQzRjO4jn5saaoJPnrOL18wm8ypipLr0WFQlJkCrbABjFJYDEWe89brr/Dw3gkvzs74vekdLi4vub0suLWYsW1HijLj6vKcvLR869uPuXv7Lse3TsXOVVsMhltNwzf/xe8wf6uiWixRWoQ4mc2SZa8Ed/S9eNnn1lIrQyCijU4dpnTBR8enN1+rFV23kzzLoTsoMEnqWdQNO0Yp2YabBDuYRHcNcb8tv4F/Qvqcm6/dd8ew2fZoa6mbGUZL5zT6yNj21E2eeOsqbY+lGHXjDbNIx0gYU/ixSngreSpAIQWDv1RQX8JDj4+WLBdLmSdpI4PkZEtMDCzmM4ahJ7MGhaQAhdT5G6NRJuWzqkh2eFplTLwv3jcJVPJLK83y6IgsK8hyaRLyvGAymdz4ikfE9THcdO43WJr8LMbKQhOix4fIMEah+HmFiwOZlXDqN978EmhHJNA0M7TOU1C0vL6OEgby+WIk2oR9p4zYTKeg69EPGKNYr9ZcXVwwa2r+xfPHNJuG+9WCf/xr/4xf+Qu/wje/8x5fVhO23nO+2rI8cvTDCIjJ1tFySZlZgg/cOVkSg+dkXlOXUfJigwRneJVjbU6Mmn4Y2PU7ycjtO2FIOc92s8F7sTSISHjMOIwSwhLA4Qh9e7Bwjn6UhULl6R5VqUuXa2DMntaqD3kAxhiCC8TsBnbZF3iTfLMEsQmHZKofdvxYFPf1bs2v/fY/OBQ8jca92KFnJWa0eB3QRObOonCMoSevSr769Z/FVguRhycrTW0MV+eXPPnkAxQwBs+7zz/mWf+C5cMpIE6Fo3eC3MnuDhsUVk3E+jXdbsPQM5lM8F7sOoXlIR3GOA6MgxghlcmDZBwHUc2mgmWCUCyLMqfvBdffUwS1tQma3isGBedH7b0MBcNebVZkNqOpGvq+xzkvO4SsYN2PjKNnahWFyTEaUW6GgFGSZH9lFa9/5Ssc5ZHvfPSC3/z2c77y5hFFaem6gcXRCU9fnDM/vsM/+8f/X3753/mjdLuePLN8/O77/OTXvsorb3/xQGnc+7nvfWpucMBUeNX+RhQTqsOW/yWq4zQuIEZhIYyjBHh3HevNijwfD51TjDrd+OKEpwgH7OZl7keEwzB7/972BS8Cm7bFxwja0LUt19dXMlRNnf5iPpEOLm2XtVJstjuW8waI+NHR+UhTFWgL3jsp8Eoen7Af4HKoi4edg7V7YwB1WMQOwRrAgwf3ePjwwaFr11qKvNEZeVGIZ7cPwJBeWyXdIyidKLzWkmU5eZZTliVFWXJy6+QzD//+3BwG/iLsSJoKnYaTHKLwUIph6Lk6f44PA3luGMYMbRxhjPRhS2amlJnHhRxMj1KVBMuQC3SXDPiefvqYTx8/4ms//Y1U9CM+egnnGOR6d13HRx9+yN07d7i+OOdX/9Gv8id++Y/x+PEjvvkvv8m/+6f/FN//9AXzSc/kVsnVdctu57i62gCWrh3AGAbvRZdhlCyGMRDwdG4khAGjHE3eUGqhEoPF1DUBjfeR7ehwUTx5FHIPB+fIswzViO34ZtiCUhgt2g2hmAJezNM0e7sLJ7OamCBArKRM+XggjCh1g63vcXZIM6RkN/Ey1i5zKg5f86OOH4vijlKoKPhl1NA93+IuHeq1L/EwbFmNzzmuzyj0iMl6lC1QKsNkQhW6OD/n+uo5R8e3aWZLUSYCUQUen31Cv5gzpiJqEeolQR59jWznrbLEUMoWOk2VxnFEKc0w7Gi7HRHZLjl34zVirTAsvA8HD5KyLNOPlVKNNht5TSPFw/sgmRIvJQfFIBJ5m+lD97qnyDk/stquOJ4LBe/s/IymrphNZ4whcjGMFMYwzTR5lO4/L3OmzYRFkVNmmrffesjO59yNmjL3BN/j/YTnz59jjIQU182Ei4s1H3zwfe7+qT/KL/7Kr6AnC7bbjkmKCLy5ZDehFDJsTIOfkGCCtKUmURdfPuSGj+jMkGWlWPESOQm3D8VHay2pNTESwsgwjvRtR9e19GOPC6RO16KUGHft2RMHWEJJAdwPRiFwcXlJ2dQM/UCRtsknJ/NkbKZwfiREz+nxAoXsFl59eBtjDZkVpeBme4XRhrKoKbL8UKj3cqF9diZ7uAkRGe1xU60l/tCanMViycnJKTbLMUbxq7/692n7jjv3X+GN19/Au4G+H1ivtyluMEoiUpYfLIH3iUhKKYy2jOPAMHTJnvemoO+1Bofz+xIqv1+M9jF+PgZU2mlanUvurQGlLVE5lA/E4HE6JB2Ex7uWIisQK6CA1rI4eT+SZ4pxbNlcd1xeXnHr5Jir60v+zt/5O/yJP/4nUCj+9t/6W/y5P/tnKQvLk08+YbOSdKeuk5+lON/grlp25YQQPUWZEfDk1ki6WgzcvX3CV4Y3uX96yn/wF/89pmWOUR5jI4tipO9bcr0gIq6iERijZ3SRcQyJWKBZzBcYY2i3ElKdZxnRhxSt6BJ0JNbFzmmsydKZlHtRGX049/vuPATHPsBEpbD1l8//gY6s+Eyh33/8ZdbMPnT8Rx0/HsU9rUwxKkqT8+DOQx43gd8LgdtRMSWgu2c4PNHK4A4VUUaKS5Zn1PWcLCuIQTzYldEYY9n2G45CKQ+X1sJ9P2xBFSp5XFe6gTGlz6NSMIUUosvLK6FAKek4uq4/XCSJG9OMY/KR32OtWra0cgNIuDYqMvQuDYKkaz9MwhObQRpTJelBXmhaRhuUQXixpaKuK4Zh4Pr6islkgs0zeufp24HaKiZ5RgaUeUlRZvixQ0VPZgyzwrLaDvziL3yD9dYRhpbzqxVuHLm8PGMcHjA/mvFi2/Kdsxf88++8y92jJX/8j/0c282W11579fCe951DTJaPEuacFj2t0fkNTPHyuRHWy42T4R4vx3z2hldK4CajCzJbiGVz+n4xYZMKePH8Gauri4PXz8sMhCBYDdFHopaQjs12w3q7Jm+E0UEUvrrSCmssEQ2FSoNhzXJZ77lSifFiUEhM4n4gDBwCn0mDOGuNKCttJpmbzUS6wbyiqJsUQ5cGnEoRg5OBcfTkVUMzW2ISinIHGaIKni3/Zl7q3MaUo6u1TfbLQ7LYJV2bcIOVH+h1MbExwqHw94k9FoiMKQC+qkrcGBIQplN4ekOeVdg8YlJ6kUpe7UPX8vz5GcvlCX275uzFc2KIvPu973J1veYf/aN/xH/8n/zHGKP45PEjVteXNFXDbr1i7HoMI+22k2sRxNfok6fP+N1vfYeyLHjjjdeYTRuMhp/7xk/z4M4xX337Dg5Nk1e8+dorqOhZTgpiGIlRGGCvP7wtts7eM4SMwTnavmP0ARd0YsqJTXEIMfmvxwODJs9ynJNkrKgEpjO2wOZSa7SSTOD9cFRzcy+qPYMqmd9551CfY8iIhkETVPhMbCPcFPM9q+jfNM/9X/thjWaRN/zaex/SBcMvH7/NdtgxUQtUvMcYPyGGyHR6ymbXCX5qNHVd05SVbLOMTdaqAe9uKBj7BxEl0IVKXZVSigyDDbXQkdhT4DwxCGeibVsRvhiVgovjZwrIPkarqqrDxRrHQb4vkJucPLNMJg1jObDd9RJskSAehXSEMYZUhNRnCmYIDuUVufL0w0DX75g1UyZ1w2azRSmxNzZZRucdQzvQ5DlW52gUk9LILiX2ZEYzKRWv3n8dozXvvPEGv/Evf4+inqDCiNWap4+fsDw+wY+eYRhppjN+67e/yXvvvc9f+Q/+Et/5znf4+te/Rl3XHLjgGJyT/NcYIzGZKGkjdLt9cTmoTY3FaIM1ibUROSgo94fwkG82DEony1wt9EUdNUpr5rMjjDJ0fU9VBbRWZLlN9MjIi7MrKd6ZIUZP3/fstltOZwtU1AfOSPouCWLaS6BucFKjJU9UG433DpNlnN55QJYLxlrkBVmW08xmgiUrJYuvERop+wEyGm0yQLo1lNwnIcosx2aVWF5ET/QRkBxbpbUosfc7k4TVWmNEh5rgMe8cXduhiPI+jXzevoOU+/dme78/w95LUXHey1AQoYrmWUkwkX4U7UOWZ4xOiAE5OYbAr/7DX+f41glffueLXJxd8Df++v+D/8lf+veZT2fstluiVuyuW/q2Zbtecf7iBTYzdLsdCihyYczMphNEKeFQOlKWBZO6oN9t+MmvfIXz8wt+8itf5Rtf/0nKPOeXvvENMTjTkj+qoxHxY/SEMDAMTuYrY6AfPbvB0Y0eh9hMaFVgrHTgo/MoH1IsozCqghvluvtwGPhrrQUHiIHgI0pZrM3S7m9vTQ1oySzYs3IyrRAX1Rv4y6RCvb8+ALkVM7t9dsC+zghEk2IuX2qufmg9/UPU3P+/HFFFMqPZXG754NE5KigWZoF9Y8p8coQPJ7z/8YS++5jm9oy27zEmYHJD8CMhSHDyMI4S6ab2drHSbZlE25PvlTpGIytqoaeoMcdY6a73+a1akSiYDoWW4NsgJ72ua3mtl7rYPM+x1qZU9RE/SsDunrssASAZxEFCIYwmpG16lgJ799QRrWUFB4lu08ZAIQtSiI7tdoMbHEfLJZvNjqfPnh3CIpTOuB5GFIH5fM5sIu3fG6+cyI3lSnSIWB3Jcssf+cZP0vaOaf3nudqsmRQ5NiiOpnPaqzUXF1cUVcbRrXs8fXHBP/xH/4RXXn2V3/yt36YuLT/xE18jBo8Pnr4f5Ka3QrszUTM6l0I0brrGrusoypwQs8Qi2DOR+EzXYoxJxVWCO14uTDEqggtUVU1V1YcFZByFBSJJP56HD5I1qtZ8/OSpuD6GwOuvvYmOIpPvXvJn34dggGIyOky6rnmWMfQ9ZxfPCN4zXx7x8PW3MHkmuxUj3XVRpIxXFRPEp29olyHKjkPJwzw6J66EYaBvOwYfuHPvVdp+y/e+/x2aScVscoTROWVRSXeu0s6UvV9PSItjRCcocOh6nB9lgdV7mqXg2zZRKb13aQ4Q0vAzOT8q5Jr5SFVWKBQffvQRRVnQTBtc8Py3//1/T1U2/Mqf/3OA4vGjJ2xWHV/6wtuMfU/XtlxdXFAVGUVRsnMDk9mUXMmAetrUeD9CkB2lIlLmOVbDdDLhl37+Z5hVObe+/EW+9tYbvP/hR3z5zTf50FqaIqcoNNF5DAZjFdaWYvTmhe7a9p71pmW7a+mdxyuZTRhbSfyld4n33pHnOUEp+lHU6jFGsr1ZevCHeM2Q4Mvdbie779TgueAZslF2TWkoKtCwqNhdiOTWkFlD8OBcojgmFsweW9/feyiBYn2KBnOjk/mKMRgttaQois+Ej/+g48eiuEcF0WoZXpjIH33rizB4wvMt3/gjP4NeHvHr31lzuSvo/Q7hhWh0dFw8+5R3v/sdbIic3r3De997D23ADS0h0eaUTui6gqD2LAOVOmuNiROCN6hsTzETybVstdKDHpMRlVKUVSWBBqN0qmr/wChZzfcXIvggCtZBzMC22wRPxDTgSjuJPda237oRI1oZ6Qh9QBuVeNgyKXc+EMOI6x1udBRFyXw+4+rqms1mzXJ5RDNpCCFwdHqK0rAKGVVWUBh5fedHGegQiUpTVzlfeOMhbb/jzVcf8tGnZ3TjAIy07ZrJ7IQPP3rE6689YDqbEZXi29/5DifHS+7ff4Vf+7V/yk/91NdZzGfEAEF/FsOVYBD5efuu51f/4d/j6z/9NR7cuU9Ush31aSi67zAVELzY4GotAyxj7YEzv98y7wuWSlyzwhiKsmI6SylDabFwIfz/qPvTYNuS7L4P+2Xmns505ze/mqsaQHej0QAhTARBkBABgRRJKQhSosI0SSnECIeksL+J4Y/+xK/8pDDDEZYUtqzBFk1KokDZEiiBoAkIaDbm6q6uqlev3njvu+MZ9piZ/rAy997nvlfV7QjJUdod1ffdc885e+/cmSvX+q//+i+OT89Zlw2z6YL7r70VktiIRn+AANq2C16/GF90KB4yhrauJMnrHNPpjN2dfUmoatHoQcnz8gq6thYlwi7SDjvatmZTrvFKmFib0MVJqHc5P/CDX+fWzTuU5SpsCA1d53HaonUbkvYGrwzeB/2hphXj4C2pEgpxWYvnrrSiyLNQqBfzDyE3gvzbWXEiXJi7py8u+IM//BY//ENfJ8sm1E3NL//Df8j91+7z03/sj9LZjrIqWa9qLi+WOOc4Pz8nTXPOzs9omjawSHLSTFN3luUqYW9nSqI3GO9xTY3WjnffuE9hYGea86//lb/Mwe4uaWL4uZ/5abpWeoyiNPdvHvC7px9SZCllWZEms/DsNKV1tFVFWZWslhVVK/xxkxmSfEKae1TXynWXG6x1AxtJKzblhq4LXP3AJooyF52TKMZ2lqZrJTFvBI5VSvT8xTiLdHVPX/Q+UBoDjOM8VVljLULzDonfbWzd472hbS3O2yBOF5qx9Myw4RzXcfnrxxfCuCsk0rRdw+OTCz75vROqqmFz/y4/dnCDxdFd3Pu/x5v393n/d4Kc6qrkg//xn9A9vaTwDpMXHJ8qTLnH7NYJ66TD5sJbFiMeOXPRNEiYm6oCZTO06vObtE1L3VSkWSo84ICnd11HXuQoraibmrLcAEhH804khGsnBl3gGy3Vego652g38n6TmMGr00M2XBathc4h7eAI708CDKTwTlTtbFAA9N6x2SwpS9jd3aeua85enLBZr9g7PCQrJnS15XzTsUk1i1SRaSlNjz2NvHc9/p+alN1pzt3DPaxtudqZcnh4g7JpcFYW7NnZGWVZobThxs3bXK3WvP/t7/Cl7/8Snev4xm/9Nn/sj/4E08DnhuCZI4JfSmvefO0NpsWctnMCHyjJfcRIyFqLtw5jnDCbQvI6cTZgsQOE0xd66HHFpRgqWUQhsRoCo+l0ivKSdE6yAus8mVI9ppn5OLY+MHEGrFqj0MYIh1tpuq6idjXWQ7kpabsNrd3gnKepLNooDvbucHH5FK0mpJkmLwqSNGNv75D1+lKiQZ1gTApKkaYZTk3Cc446ItBay6aqSFODtRLyTyYZVxeXpKm0e0zNRDpxaYPrGrQ2NF1HEu6nqirhnWcSMbVty3/1X/0yb775Nl/52pdxeDZVxW9983f40pe+zHzHc7lcstpsuLxacnl1hVKe5dWSSTGnqtYSlTpLkku9Q7kp+3Wdmoy2szg/I0k0u7tz/tTP/TSTDIp8wr/yF/68yDMY2L+xF5qGC8Ztw5c4NEmSkSc5+ztHOJ9wWTpq21K3lzSdxTnp65pmBTuLjDSVXrrrcs3l5SVaSy6uaRvKSlrszWYzUpOSpInMlRDpFUXBdDKhCTRfD9I0p5Wuazp42VmWgVK03VDLEQ8fmoybNDSf71rSNCdJFIvFDm3bUTVNP6+iaqq1DkULXqESw9X5KY8efMS9+68x3zvAmqi9pP4XAst4UK2jwXFxWXJydilMhb0dZvtHGDSurrh5eEQSVuim3PDo00+5mx2wWMyo1JzliwWbGuqLJzhvSVIdYLLBaCilQkMg6TyfqDm2RgqPEKy97SqMUezu7uKceFjOOabTqdC2QtIpzwtAEhxVVfWGzCQhXPZWBAmtxSSi1+ERTHi2mNHZjrq1aK0QRCYYFRTOSoFDqjPB3a2jUx2JCSXLod0dyqK0p2kbTs+es1jscOfObU7PTzk5eczOzh6L2T6JT+jahrOmo8gyCqOYGGlwIRWnkRfukaKognfv3OSd2zeZzHb44KNPyHRCrjzYjtQonLU8fvKIw4MDppM58/mcF2cnfPDhR/zEj/84y+WK3/iNb/CVH/wyh4f7hCwyqUnY/4Ev8U9Vyx/1noVQSeic7w2pPLWeed2Hr17wB/GOAhOmp3iHBiLxObvO9dioTjPW6zUgVMbNukKb8EwCa8YgwnVjsTIJ3z1NXdK2HZfnL8iKCflsynK95A8/+G1a03Dr1j02VUlnKybZDKNgb2+XJNUcHdwC1WHUhCQFlEHrlEQXFEUrxS6BCaOUUGa7ppHIz9doJb13UYaqKsHntC3gNUWeUjU11ipM4lC+ZZLnNE3NannFZDphsZhLE27r+C/+q3/AzZs3+RN/4k/gkabXFxcrXry4pOscXjkur64oy4arqyXz+ZTpbErbNuRZxiQv8EqeQ5oaslxTV6FwKSR8k8Tw7ntvUWQpGXBnf4/V1Yr9xR43Zyn37xyE6NVJMx3v8dajvEgMO0VQbnShaUyKSye89t57NC2cliW+rEiygiybszdLSJIs6O0Y0kApttbRdQkKT103WBxeQ5bnIvqmE/I0OGt13TPdpCG15C7iobS0ruw6WctKSxGfSRPcWhwPbXSoG5D5KE6rVKl6P+SclsuV4OzBYXHOUVeVwIt5xu/97m+gnOErX/kRzk+e8bvf/Mfkkz/O3o07veMTo4XPO74Yxh3Aw/7OHj/xw+/y6e//PRIP33fvLiYp6JynbTZkRrLNV1dXdNbSuI7yKGN+cx/ftuwUL1CrJcvlUvoaGhnhqLPtAvebwHVPXUri5zil8NpEOXeSTGRWsyyh3AgUk6aCq1ZVRdO1Pd8bxPsBMUDxfVpptEG8AjN4ST7wbru24/bdAx4/OsaqEbUpKgqmDq0MVvtQTdiRKYMyHVqFJgN4rPeIbFeLx3N5dcl6s2H/4ACtYL0uybMd4UIXhbA96oay9dSpYppBqsD46MeD9S7Qy6Q3i8Px/W/d4QfevMXlasVP/chX2J0mIj3gLZNJyuVSxt11lr39ffLJjNOLS379N36b+6+/zv7hPh9++DEGxf137nPVlfyTpubrkwU7Wkkpvttm1EgkOhj8PiHLACcorXFdizYiHqa1YZycivmQspXn5r2jqQVW6JzFuDbkE2V38HhsqPps2w6Ppes8VXNBmhaU7YovfeXrpKHYqJhkdK7i5sGbLNNLOrshMxOUtugkB8RA5HmO7RTOtVjr0dqRZ4X0yrUd3lsUEzwNk8LSlGvqpkXrljSZ0XaWRGc0dRPK4EX4Cuc4PXlOnibs7e/g1Zq2WlPWJf/Z3/27/MzP/DF+8KtfwTroPGyaltOLK8qmJVGe5XrN5eqCg+oO601FlgtFExTzxZz5PAiYOUdiIDFKYCAFGou3LYn2/OSP/jD7e3tkviOfpfyr/9I/T4pQZLNFyu+XS84vUm5MJ1Kkg6SstRZj7lG0VtEpqLqOsqpZrmqa1lK3LcpokjwnnSRkatj2BZLLQp5Dir9kvsicMaFLWNu20qLEiDHQXmOUYVJIHqMJVcJKGYpigsbT1LXIOqDwGpwOYr9KYb2jaiv29naZzSd0nWW9qbDeIqJ0KlSqGvKgO7XZbEIEGunDhHyeMK0UlrZc8ezjD1De8ANf+jJ37t7iT/7xn2Zx5w0wBhPmszEpsXnMZx1fCOOuULz35vfxYz/wk6wvPP/vv//f47qW2XxOQIXZX8xYTAuy1LCzs0N6Io1+1+tL1g8vKXY0ZgqHeym38wPy7Abf/tanqDzBJzrQ5tSwo6LI1AxbSVjf07wSYSZY60jTjLPyShgEXUcdki06euE+FnwIm0LHQh4rXmWe5b2BEpqasD2MlsTMk8dPpaQ+qh0qjQ9JVNFmiRrdkTkiOJ6P4lfeyEO2wKiEu2kcx8/PWOzM2N09xCTi8ZVlye7uLsUkp+s6ll3NuoRFZpgZTeKFfy9XoPvyenDoVJpT3Mwz/uzP/yy1U3z5nbeZzQoMKkQpwhg6PT3l6uqSui6Z7+wwnc1oreVXf+3XWBQTbr57l0VruVOWeAvdfBfpwK16Nsd14aSxjECP40GAszRt16KVoSzLfqOMBSAybkpqEazn4uKc1brianmFNqIGaa2oBVpvaduW2WxKkoomvjEemDOb7rJarkkzUe/zXpOmCZ2vUWSkSYbztVR0NjV0Hu9b5hMoyw2KHGJVNBKq13WN7VqiXrj1VR+eO+tCxbIUTD17+pRNeUWeSwl/VdVsKsOv/MqvUJcV/9q/9q/gtNBKq7qiqmouLq6wnfCzm7ZmvV4xnUoy03tHkRcopSmmOTs7c7yXXBNeDLm1LSbRFJOMNNEYLLnW/PzP/nEMMLXSD/anf/gHZOO1HU6Fph2t9M7VOmF3t6BtRDtm4NxLV6nGQt121KsV6xAFCE00I5mkJDNJ/jZNHSjHEi1Pp1Npwh0KgKSuRCIIpWJRm+oLgqq2QWkta2tUVYwXMcCYcxFvO64nyU/YkLCOc1L47I7NpsQ7L1EPkRYbwUFxCvM8o227fg7bkONAi4qqUfKME+WZbCp+4StfFx68XfL/+K1f5aJ2vHXZ8os/NEdPdrFhTmfZ4GC+6vhCGPfZZM4f/5E/jXGa0p9z48YR88WcdDoNkITnS6/f4eDwiKP9giTRTKY5b73xOuv2ktfePMQlVroB6cD/tYbvfOdxaLXG0EmFUEjiFRlzGufIYlGNdiIQpsJGgKFuSppmm8PuraOjFWMcNs9o9L0oDWNMIrLDCN4bm4koL/Q0UNg6hG0x2dtz5I1ge07jpNoK78FaH7S1XfAwChbzHZxTbDZXNE1N5yI10bNZl9RVzdtvv4NSGWdnJ2w2S3bmC2nTlU9p25Zl1bIxjlliyJUjM6rn6PrQd1P50BFSycaTesef/GM/isJwcnbKO6/dYW8+YVMJXS7PpbHGxfKKi8tLdKJpupb9G/eZOcV8VfMvPT0jWcxgdw9JeWtsp/C+6yv2lFKD4qGXwrIkS2icJdEmQFmIp20lsdi2bb+g0zTFe9FIn2QF3ofSb21Yr1Zo45hMJzK2aKxraOoWVEOSFqRJJlFYEEKbThc4b/F0tK2n7Woau2GS71O3JVW1IdEZna3EwND1WLf3HUYH0SdvmE6b0KdWDLtJFV3t+fjBxyxmE2azBcZIkZDRmv/6H/wDzs9P+V//tb/MJM+ZFQUXQV99s6pwjad1NW3XgoOuacmSgvWypChyjPYBFkvJs5Q8y1itVsJS8qG9pFKkRrO72AHvSI1ilqf8lX/1L2GwZL5DG8/e3Zso57BtJWvH2lBw1gUWSYpKw6bvLbluKdc1jd/DeU/dasqqobatQJIK0jxnspj3yfGu7Vitl6zLFUki2k3T2ZS2qbC2o64rIRkg66inIarIgA4CZ3nOYj6HzVpqYJTCtcIQ6rqOrmsCo0si5KZpUFnSJ0slspc8V9u1uE42phZF15USQSkhPehoZYLBLgqpXu86+1INBiEKFUdFU5Rr7C//KumHz0lmU+yf/jonpy94WHlOzi/44Xt3uXd3hklz8iwlSczn2tUvhHGfZFMyKwYtTRImk5y9vV1uHN0k8r1fu3cHpROy1JCnmr39Ka+9c4OVK/DGYYPHq5C+mdor0lSoSD0uGwgqWikSV+Ba01PuRPMFYpoxTTPyTDxc50RRUAyFHyABsy1UZUOyT/A0UUaMWJzzkvXXPsHa5qUEjHRYSaQCrqtBEyhVUZxfMMrI/JgUE27euCFaJA6KIuHi4pz1eo1z4tkURSHG+2pJkiTcvHGD5XLJxeUlm82G/f1DptMZPvRavahq8iRjkhomtEE0aZDO9V7YA521KI+UZBu4ub/HX/vLvwQavvPJp8xmE6Gi4rGuw6SGvf1d0iRhXW7QyxL3m9/h9j9+n/Rf+RkqL0xz0e0YxliHxTAtJrQhfI100VRLNJYkCa2zpCZBeVl80cCLJERL9KDW6w15nktvUOOZTAq878LYSoFa1zXCzukcSqUopGLROkuRL1it1phEYL2m6VBK03S1XH8n3qXX0HYNJjE43wWcVBLHKlyb0WA7S5EVPf6aZSmffnrKf/gf/F/4F37h5/kzf+bPkqZSWHR1tcJaqXNw1nN5eUmipfXfer1CK8Xl1RWLxZQsSBQrpcmzlBtH+2zKEmOCEqISqYu2qYOg2E1ms4kYJtfx9mu3+Df/6l9kd5JRGM/MGKb7+9i2pq1K6YIV6jiMBx8aMGilEGHFoCUfGD1NB7v7C6bW8ORsI9IDxpBmOVkeGFCjXggi75CCimQCRReinOVqRaJFBmMymQWWCnhnByOPwIUgdjPLMmEjmST0n1V4JUyuyHiLNFFZ21ZaAgaKosPjImSI2qItppGlFfM0PjppYEwW5IV1X8gmzK8kOAsRXLIo72jWV2xOXrC7XFOvN0xOr/jR+69TP3yKyib4yYS2WrKY7/Rkgc87vhDGvWmE952mBttuWEwm/PiPfJ3DgwM8HbEcHzyzacbduzd574fu8/DqU8Gm+zAIlBYP0xnFe19/nSSV0FyFsZemuAm536FtWopsEqJ8adqs8NLdPkuE+uQ66aGoRwUMIwpSrPQTKllH5wQLT9Oc6WRCmmZ4XKBgSYJ14BOLlz6dzpnNd6iqSlg2jRgaue4wYbyjcRblPVlqmE0mfeEHGvJ8QpqusW6F9dINviikLVxXdzRlzWp5ycHhAbPJjBenZ5ydvaAs1+zs7pHlBSYVw3NZdTRZxkRrJr5Fe8lX4AfJAaODpktIHOdJivWWd+7d4n/31/9V8umMh89O0KrF+RbvxTNaXV3hHx2z+fBTdLUiX1f0QFlImiotCyRLUllgQT6XPvchevo4T9ta8iKnqwXaMEbareV5Tl3XoZ5BUVc1eZ5ifYdXmqq85PTkmMViinOSj0h1QlNbusaC17QdWFejyXBeeu5WVQNGjFNZNSQ6oetacCIlrMJGlSQZeZYBhnKzFIgO0R36h7/8y5wcv+Av/oV/mXt377CzsyNc6CwDJ7S7sqxFXK1yLFcrus7S2RbvHOtVRarBZ4rdxQKDRyewWMxIjSJLE57VJc51tHVNXZZM0pzlesPh4RGLvR28sxSpxnYtf+WX/iwaRaoBhAass4LOtnStpQ3FSwEfFD1/7yQ3AeAVxitpRq0z2g7O146qa4Q95j06z5hkBVmWB4ZJQ1lVlMuKzlqyNGM+mweoQSLoptmwWS8pqw2JSeg6oTC6gK1H+WKIDdbHVZuD8ySOzpSyqmkCNJMk8txam/SNdoR66EkSRZGnTCcFpVLUXYcKNRdJoMSODbwKTKuoKRXSRRidkJpUojI1FD5a5/Hhd4k6Da2tqWxF8u4tOi+EihdVzVdfu8OcFGv2uLW4xerynGKnpPOOq6urz7WrXwjjbm3LannO3v4BBwf7/NW/8r9iOpugFTR1Lah7MIZ/8c/9af7w2bf56PRjOm1RQScaL/iVQ4pcvPdM59Owg4dkYagS1D5BuRQYcHCI+K34qVmeCZc0aG1HfC4m98bYsNbRW5BJlucF8/nOVqFBkhhWq5V4XiOvPU1TZrMpu3tz0o1itZIQVCOeaSyOiee11rJYzMnzYqDr+agimBBL4UUJMEOhaeoG5yTJePz8OVkxYX9vj7atqcsNz8uaxe4us5k05fAuoW5q6kZTpTmFakm8PAejQkRBrOIL2GYYxzQxZOkM6wxHe3N+6V/8U7x15whlu9gxgssPPpGmI3lCOzGhWg8p3w4eu0hAtOgk6fFzAlab5yl13UnVcCKtBLM0xXbSBjDPc8qyCtLL0NYtk6JgVa4oy41ISQB5nlFXFX5lMVlF2zkmk5RMG6b5BK0LLDVtJ1CczFWLwuGUSBUIP32Cdx1pkjCbijSx7TrqzZK2t7naPQAAhdhJREFUaWk2G+q6IUtz8ixhdXXBixcn1FWFbVvaqqFqWk43L+iaGtd21GXJwwcPKIoJOzsLUm2ke1OoRp7kCWW5wVkrxsTDfDahLjd42zGfTdjf32E2KwBL167Zn2f85X/5z5Akhlx7jG/BeFF/jEnoUDdgNLSNlYR1MNBEYx4KFqzX1B46r6hrz6bs6KwC5VDGk6Yp02xCksomXVUV1fKKpm3wKEyakhUFibPY1oYK52FdKiXrZjabSf7EBbqq7ciyLLDPhhSMD9BrXF5Ry0ehKfKcyWQilbUhlxHrS6TJi2cynTLJc4w2lGVFVbZBDdUGITHVM2CikxO95y7AOj5QfVWYH+IMyvui8J9HowP1GUI+zVqKyYK9t3eY3c9wCn7tO59gP6n5lV/7dSo35e47X+b+7Xtcrq6o64qRGXnl8T0Zd6XUA2CJcDk67/2PKqUOgP8EeBN4APwl7/25Ehf7bwN/GtgAf817/43P/35LXa5xuzsoJY0GCGG6wwd6njy4p8sTPj5/RKtFKtSrKNpECA198KBCVWDgbwtlRrq8TNQc1xpSk/aTWWAzWTy2bZlNZrStxXZWHjCKbiT8A8OuHXGfiLPN5wvm8zlFUZCm0jUHtctB2wbKmBxt23J5dUGWT/DOM59Pmc1yzs+bkGADUGQBy2tsQ5JkFNmExKR4P3DDZSEk4tm2TsLeNBXOve+CaJFM5mpT0tS1yNHevs3J6QUXFxesVkqw+OmMvJjRWcumbamUIkunZN4x9S3aAXqkLuiHhKoNHrdWmr3ZnJ/44R/Cdg2NhdeODsgmOWkF+d1buOcll13NVAv44y2kaUJdS9WgdR7XtmRphgsa4WmaUlc1WkuI3XUNeZ7TtY0wJ0goNyVZnmGtbABpJnTBNM0F5gvAbF3XpFr6htZNIxXKXkuVs27omhKdavLJlLyYob1ib2eH1jWh5kByIFlScHVxQZYHTLhuIIWVuwADs3xC13QhWR/qKbyjqko+efiQ+WyB0ilHR4cSjbmOPE043N8jSROKPBWGWGtRXlFXG6bZnDQxNHXLtJjSNjV1uWY2KSjXKw4WC/7Nv/JXyBJNnshcSmiYZCJ1EfsxCY+/E6pt0LDPQpJDYMEEpQ22bemconKapu1oO0dVt2wagSdNasinBXmAEZ3z1HXJ2cVZ0G5XTCYTilzEvlrnWFdrmrrGe0dmDHme9tRBiPRgMX5xnaZphk4lmRoT5vE+onEPNmug1HrRDsqMrI/NRgqZvI+FcEKYWC6XtHXNZCKdsjrXScTkB10enKeFLecuaq2rQK3VgZUTGXXyHhvyZh0e019vbNyR5hlUNebZ78FG2EFvdR3fOJ3jybjYlLw4O2UxL6RDVG8TP/v4/8Vz/xPe+xej3/8m8N967/+WUupvht//XeAXgffCfz8O/Hvh52ceznXMJvM+7I/ep3ilQGDMfPj0Q7758A9oVSuJRiTRpwLtKD5c4wQukCSp72/UW0/qNZkWalle5P01jBkpAMorlst13FMEZxwXs4QQSx6QeCZ7+wtu3Dxib3efopgOhh3B8sWmDPfmnOPTRw+JTq2yhoPDfcpy8LQHoSDd83Ank+lg3P2g7icNKTIcrhessqmlph7GM/CPnHVcXl7QdQ23b9/marXhxekxT58+RSnD3bv3mEwmJElK17WUdUOHweUFBZaJF5rY4MXY3pOxKqSjlSENtM0M+At/5ufRxnD5X/waRWp4WCi+rzJcdpY0ybHO07ZNCJkDBTURGCZNU1pnQ0I1pawayZ0kiTRuKAq896w2azH2oSApz3PqphnGsGn7Ap6u65gv5qFTkBj5TVmS56IRoxGDTNAQKTcbDFJBmBYZTsNidx8NtE3HZDbDWUfrG4xOcDYKwYXn7wKPIrQpnM3nLGZT5qGauG022LYFL/h91zZU5YauKKirDd46UpOQGMVqdcV8OsUbx5/7038Ko6BQHYmr2ZkmuNaGysYgd+A1dFLbETwZaSepfISKsSG54lSAXXRK02kuVi3rqqFqmlC1DEVekBVz9hcpPkgebMqSqlyH5LEjz6dMFwtMJxIeVdOyXq9l0w3X5ZwV+WKlhA4Y1ofWCc4pyqqk6ZqAdWdCYTYi9SF5FR3ycnIo1f9zWMvQz5UsTSlRNG0rz1jrsIZkPvg07Z02750011HD+o9SwCL/LePonUMb3dsEUecc7EMshhsInAyve9/n1XSa0NYbmtOGqvV441FaHKMsTcmyhLop8d6GAqn/+dgyfx742fDv/wDprfrvhtf/Qy8j+0+VUntKqTve+6ef+U0e5oudXktduM2yGJQXjO3B80d88+N/RkONjwU8PoZIstNrL93iQRz1gfQIyiqMVWRmgW8T8MI/dsHrdQQBJ+9xnSPLJ3Tna3zojhQ3HqFohY7kqQm64/Ds+Rlf/5GvcXCw3xvuslxTlhtW6zVVWVHVFWUlTQCqSv5784232N8/EBZF19JWMMmnWN9SlmVI5OYYY2nbjqKQMFcp3U8UuVkV+L4TPJYkyYCENJtg0kradxHHJIyR92w2G1afPGB3/4BbN25ycnLC6dk5H330Ebdv3+bgQPqtJommbTpWVU1loMkSMq/IXJAGUFJB6wLVTxuPVg7bWSnZVlIGr5VmiWLn9hF7hWJnbWm0eINeaTA6SB9ngJX8QZaHTliexCRUZSmFIVaak0+mE7qmpe06itD3ViGt2qpKPHaTZFxeXmKdxVnNcrkhTQuaztE6x2Q6Z1NW2K5FpQWr1Zr5bEqSpIMj4D1FkZGmC5qmQQOpMRLdhTC8tQ0eKWUXVpTDek/nIPVO1BW9FaqpVsGjC7IH1uEC775zjs42bDYr6npFkab8/J/4Cazz7EwSlHXkqmGaa8gnQQjP0jpP03najsAf1zgMsXu3CvQ7DUyd5E6MAas0rZeioabxNNZRNS2N7SQfkOdkecr+fCK4sXXUdcPVekVZVT3ePJnkTKYzQLotnZ2ehN6napvR4h3Ku5FhT0lMjkKa3QgbLCdZp5RBmE9rGedW6RClhoI+ZXqHUOZ1sA+jQ6HIspyi66jSiq5ryRJDniXYDsok1LbkOUlSYIwKMGcjObVYYBcFxMJ9xG53Qzep0MkpyzBpFphAPvQK8PiQw9Neks3B/KG0JpvPcbM95rstVVPjPfyP73/I2cby5ltvsZhMePrwQ7pyxZtvv8ud2/c/06TC927cPfDfKMkc/h+9938HuDUy2M+AW+Hf94BPR599FF7bMu5Kqb8B/A2Ag7254FTBWsXGCz54zI/PHvPbH/8mpd9IOBMSEtJBfmiaLJi7hGqJi7riYcMIHe8z5jSNDTxl3++++Ni70AfGjsjqJiHUIjwAaRmWSgY+F0/5937v9zk+OaazHe+//z7f+c6HXF1dsVyu2GzWbDYb6rrCWieFMX4oTDo8/EP+wl/4l7l95whrFU0jHF/T87jpPdGikKTbOPyM3knk9EoGPxWZ4BBhmERa+fVJ5/j+MHC2c5y+eEGWZdy8eZPJdMaTp894/vw5V1dX3LhxJMm6LMFoRdM2XFUdiTFMTUaGZ+KaLTwyMhbiM4yd5jtrWSYdd2/vcev+HtUfPGXiHWmSUobGB0obbNdhMoM2itV6LU0ptKaqSrIs6zHOPM9pavEmp5MJm3KDVoo8zyjLkiwrSNKUi8slH3zwgTSHMDmgePT4CTePDpjNJlR1TV03zGcTwcu7Vtg0bWjAoDWrUOGqlKIsS+lzmuaUXUWSSNLXdi3WSmJeFBlNr7bofVQWDAl464LAmSQHq1L49T/7x36KuzcOcdWaWSKGMHMt7947QusElEUHbXmC93fy4oLHz1/QZQUmnZBkE9IgR6394OYoHSp7lWLdxcpfSVR2TlE1Ld7KJlkUU6ZZgkkMbSe67JeXF30xjkkSsnzCfD6jaRpR29ys+6gperIxer0+X30gHySh6XfkrMf8VlxrJqzBvgI8JESlqXSYz64XnoC+Ac7LR57lFHlB3dQiyZymdEqFjmu6z1WB63XyhY4cKJReHJY4121k34zuLV67UJrDNanIshnyZOADXVIiEqXA7Nwgac8wjaagwOkNhpo7d+7i24aP/uB3SH3NwXzC66/9wCvvMR7fq3H/ae/9Y6XUTeD/pZR6f/xH770Phv97PsIG8XcA3nztto8DE5MPLrSiO1ud81sf/AbL7rLHvCTh5tFexR43wtoI362cyObiBxVCrRQqmYHP8a7BmAjJiFc+zrQrkwqu2NS9KFWe58ISCYpsxaRgb3+H9abiW9/6gLfffoOqLPnP//P/JycnL6TwqbVBDCtASEqhtXyXhK7w/NkJ/91/99/zS7/05ymKAq1rjJGu86lJadqG1AgrwDslpehe9cUaLz3QJMH7tGf1bDab0FgkBIZ+ELiNG6jQOIWL/fjxY6azOW+99RYvXrxgs9nw6aefsphPuXXrNpPpBJOK8mVT1yxtxyRNsDon0w5vFdpLda3kWEVjI57PefA/8Aabox1ONlcc3/R81YBGePaTxFC1DabIWDYW3wle2jYNVSXJZMEuHZNiQl1VKCVCTutyA9qQpgnrUjRUdGK4vLrkxYsz/qP/5D/DG0WeT2ibhn/667/G/+Zv/Ou89+7blKslxWQCSrMp16RBbKt1HdPQBWu5vGQ6mdK0DZv1ium0oKlL6qYmS1OqzYbl1RWeDuUdtmtDi7Yw/kqRJIpJVjDNcvI0QWmL6xqJDBLHIp/wi3/yj2I6UNgQzQKqk/yGEt0ii+in29ry8PEzNpuao4NDmrbj13/3d3j07ITpzg6HB/scHRxw6+YtZnNpKnN5dsmjx485OX0RNl6pyrx163bo97svVM+2YVOtmU5nAybdtRSTSRBWk0Y04rjYLQg4Yt4Ra9Y66T3VwVSoniwhTtQgQxwdrzRJ+5qF/ru13sLlYTi3QmFSaTUojtR2NyqlxOPP81xkBpIMQnvDxIypjXJubbSMNRK1432fawHRbI8XHQXvIOTjxgPihT2jlERRWifszHcpioKyFNluvCabTGG3hdZSWOnRbDDs7u4wWcz4qT/64yTLM9R8jud/Aiqk9/5x+HmslPq7wI8BzyPcopS6AxyHtz8GXht9/H547TMPrUXc3ruhMhEP56slv/EHv85VdSmFRaGFFS4mhIT87xAPxnkx6iZI9gZfRaaQg5w5zomx0GpQwZNCi673fieTCVmakeUZWS5ViFHHIfLHd3d32D/c5fT0Y/Jswmuv3+f3f/8Pefz42ZaovlQCDmyf+Vw8SumiorCd4/333+eb33yLn/qpn2Q6nZDnKUmasrwqBYtXiWi5JKCUDhVuMkhjDD9en2g+C493s17T1NWwaBi2BLkuKdt3QRHPOcfTp08pJpfcvn2b3d1djo+fc3lxyXq95vDoiIODg17euGtb1nVDqTVFNiFNDNa1FN6FphGxom/IiRzdv41ViqO9HQ4P9sLfXF+NmyuP71qmSmOSjPPVEte5QG/sAoNiTl1VOOcpipS6rsGLx7QpS9H9SBLWmw1JKlh607a0tWNTVpKgU3B+IZ4ohM+uN/2zW2/WuE6MX9PUQWvEh4bWDqM1TVPTNCIJUJUbNqsVWZHibSsS0db2TKKqbkhnU/6FX/iT4Cz7sxTllVAZ24qJkWxr4mOFpXiNCgJ+Ly64sx1OaS4ur/jwoyccHhzx1pt3sF3L6viUTx59yuWm5vTqigcPP8ED+/v7/ORP/iQff/QxDx58zGq1outa9vb2KQphST1+8og7d+7wwz/8wwC0bc3OzqLPV1g34/yi5uLysmeayByMM+uzc3yiChrZLOF5hxoWHZKPMbkotykzNcuzPnIFwcUTk5FlBYTeC1Jc50kzj0m8yOq2QdJi6yokoozYe5qKsdVahQhB9PIjdTpGDHg7aMaE1wnvQw1FdjBEruMK1/hnrVPhuCvDYrEgTTPOz87JsgQdIvKuazDFhNZ3TFLHnVu3WW6e8O7rr2H1Bj9L0JeW6d6cWlV83vFdjbtSagZo7/0y/Pvngf8D8PeBvwr8rfDz74WP/H3g31ZK/cdIIvXyc/F2hOwvAx+qDTGsqjW//nu/ytn6uSglhjJ/wk6pQ+GEQonSY3RwgoF20fAFXZnE5xg/ZVM1zHodCunqJNXEKoSHCfPZlK5rg16FlJ+naSaNoU3KpMjZ2ZmRpAaTpJgU3n77Hf79f///xqYs+/vy3qE1xAKo6XTGZDLBuQV7e/vs7e1xebVEa1hv1nS2oyhynj+/YLlcM5kspNJT5jxpMm6wIMcgFSyH1iZMfHlvmmXUVUlfyUnQuSd6V7EpiBtCX++pq5JPH37CzZs3effttzk+fs7Z2Rknx8dUZcnB4SHT6bTPQbSNpaxLaqWYZDloEcDStPKcfGwxBxMNidIkCjzSmsErBELzQKhc0B7wLQfTnLrp2DQds/kCtGO9XCLVh1mP9xZFQRXgmslkwWq5BA9JmvPs5EWgvMWJLad69vw5X/rSu0wmE+q6omkbZtOY4GzJs5zNRjo3TYqCum5YraXBxHq9Zr3eSJMN7SnXkkeRmgiHKJFYtId54sm0J7cVi8MZiQLbduCQ6E7H52lFTiLQanWg86HCaLaOZ2cbXlxccnV+yev3X8O5hl//5jf5+JNPeX7yglVrsaPw3wGHR0d869vf5tvf/rZEtCGRuF6XVGVIuANVWfPeu19isViwu7NHmia0TSNqiuVa6JtdF+i8Q7Qt1ygO17YHH0kEY+M/KBuCJzOSu1KBGeeV73NhwhVP+pZ4xhgm+Rxj0hAJQ5ZJFzdrHU3p8c6MPPaxeQ/RUyo9Z1OTCn9dIXNWKTQmfESidJMkqAilBsJARASko5oeDHk4l9EGoyKTZ6jBMUazv79P23Zs1isu21a49SYTiKdzNNkUD3SrEp8rjm5MWF6VHCY1/8NqRbo/5+tvvMYHTUV2/IDPO74Xz/0W8HeDAUmA/8h7/8tKqf8R+E+VUv8G8Anwl8L7/wFCg/wOQoX869/tBB7R2vaBZ1tuVvz67/4ax8tnWN+gcKHEd9BscNFjUIGJgBj4UKgaWCEBa1eKNFngXYKTOL/XbtZKMZkUtK00n02zlNm0wDkbDKsS456loepPkZjQDxGh0P30T/84jx894eHDT5hMC2azGbPZjKPDA27euMHdu3fZ2dmRKtRE8L35fC4qkyEMjBh511Yc3Tgkywqc04ANBt1iknFIK4e6Zu3FczC9J5/nOVchaRebXTgnozP2vLQeQmgQTRvnHcfPn7G8uuTu3btMp1NOT0+pq5pnz54xnU45OjoKcFKKaROapmRdV9RpQmUSUu9JnSVRjkQTNiovSXEv0sfW2QDHDRuVNCaQAhXlHcp0ZLkCt6FuLbO8oHWeqqr7aKpqpIx8MV/04mHTYoq1jmfHx0GGQuZPnHlPnj0nyXO0ETw/DVhu1KhJU8NqvaJtG+YzoRy2bcNsMkV5R1XVWOsoEhmzLDVMtAPbMcsNRnusrShShVIW7SzaCcUwbqyxOtcGJoby8ZnoAStXBuc8m7rm9z/4iCfPTsiKnN/61gecn5+L7AOQxMKYQCn0wP7uLovFgm984xv9uIhGj6aqG4osI01T9vb2uH//PmmasV5v+PTThxR5zptvvYEPa1CN5lkcRxE+cyiNQIfBSRhyL6OInMHoKiUGL0tTjFZ0tkNhtjxhHWA21YmdcDoUeyHnct5RljpmJcPcjbh7vFbAR+Mrzp/AQANUlESFRT8YamPE2VPt0PvWGyeNdrTu62bivTo82hjSRHrOxpmuiN68wJnn52fhdyPCgkqFBj81/+SjE95641329g110fBH7v8g771xlzxzPJ3MeUjGbxhHO895/WrzSnsaj+9q3L33HwE/9IrXT4Gfe8XrHvi3vtv3XvtUmJCasi35x3/wT3hy9gCLBeX6CR+bIsih4kaMV6L9QEjieHyoovPSbcmkpOzQ1ZbEaAht7WLCMcsylJJO9VmWMZstUGgm06kkg/pGEx485EUuXZqalvms4Pbbd/jmP/s9/tQ//zO8/vrrHB4dsrOzy2w2I8vSIEkQdBCU2/K+pWSaPjFkTMJstgAMFxeXKA+J8X0ji7hYvtcjMnykAcBAy+rHTwsdLlVGeOUuyAoEz186IXmePX3CYr7gtXv3WK5WXFxdsF6tqKuK3d09dnf3SLOUJJ2LyFpTUtYV07wg1ym5BpQjC6XCygu/wHmC8p7vI4momGed7RcHoatNkmiKRGMRQ2lS0cxu2wqjFDshudc0NZM8RwFVVfLixQkhqBsyFV5xdbUiyzKqssRZyIqEtpOmGIvFol94Wslm6DtHiidVDu1aMuVIU0XWNWTKMc+VxCLa45QJgnVaEmveY724Jjr1vXHwwcdX1hI9FqOCrrkHMDTeUFYdpyvLjbtvUSxu8OL8jB1rcOS487NAzwul9148QWU0b739Nh9++KGMYnBokiRhZzFjb2+fe3fvcuvmTWazWWDCyAaQpVnY6Da0QZYhGvIYRUcIwgfJ6ji5e7JChNz6RKrbMvqJSXpddO8cXsU2h/0MJk0LjJGcWixck+Sm752RYEb6fLXqE5n060bOD3hHkqThAxG6GWCUeJ1GG1HurBta35GEhG/XSuMPjeQKTEj8dk6oqlmQKXHe9jk670V2OLY/9E72kZi07TnzxU02asHixi26ScKt4pDXDuY4NEfnxzyol2xMhree3f3bn7v2vxAVqnJ4XGf5zfd/i0fnn0AqegthnoYQVfQyUKrXiHAMHFIV2plZAKMxYafXPofOUDcV08kkYHoyCfM8YzabYW0mMEaakaaS8IyhuyxOT9AO4Nvf/g5Gd9x7401ef/0eWWr4Y3/sJ0cex3BF0XDH12MCM2bYIWLfXbg38WaLScGkqajWLftHntZaLl4keNe7n595jL15pURbw3Yt1ofy6DBOveEMhkf6WfhQNu/6NaOQRPby6pK6Krl95w77B3s8e/aMqmo4PztjU27Y3z9gPl+gtCHLJ5hEuNrOQ5dltGlK6y2FV4DtG3dkqcjnWhdF1YKQGvRKmzDoyvhQ4DU1gY9NzSRNcN7T1EvSriM3GmMcVdthsDShV+eQdJC7X6/W1FdLvHMUaUqupQVbkWgy7VG2JsNisCRtRaI1i3lBmmigRadIC0crfOg4rtEjd06Es3oYwiOQAhEWk7mow7y11oFJsSqlcZ51I0noxjZsyprOayazOcVszuEtIah1nWW1XnJxfiZU1tNTLi8vaZuW119/gyoUhf0Lv/ALPHnyhLZtuX37Dnv7h4J1hznYdV1I9Pt+HkkOJ0Z1kYUyNqpiqEVyWQoF45yOFd9DI3Xfe8owdNAKf+wlt8fnV0oojH3if9QHNm4Q44Il+a4xNBQN+9B5avwZh92KQvpPhfMlRiQEYrcsjMFNJrRWBNISY5gWE9mculaKBwOLRxtFkkamke3zNKKZlIqTOOLCK53wR/65H0c5y6zISbVBO4/XhjSb8ZY658xuKF1FbT3vqIxf+xw78IUw7t57Nl3Nb7//z/jw0/dxuhWcHQLWKHNGpZEbI7PAKvBaDE+0d14RsDAFSkLUid0NFn9oUWW0JEsmkylpKslBhQuhGn3S0ns/GLkwab75zd/mT/zJn+T+/fugRLp1vKy3cb6YIRpC8P57r70zsmo8DpQXHHjd8uK5Z7bIMUlHWw8Vlip+/7XJPXhN4dSYANWESRtC4gjREBLTPsgJ94vBS75AvH35vqpu+OThQ3b39njttde5vLwKUE3D8fMXLJcbDvYPKCYFPrGQ5rR1Q1U3lHVLkWU0JqFQCmtrjLXQhWyLB+ctSvk+yd6H9VFJs2sHHFepoIKpUdqhFUxSDWkGXu4nyRTTrOBf+/N/ht/4zd/in73/Ha6WS6aTKXt7O7zzxmssjCKfSRGUUdKY2Sca5aSR+V5mcFkUx4JEA96GpJ+n9a4fS7ETgatNUCiN1N2gh6LQCF1aktmtg84ZGpXQakVdO6qulC5VPopZiWFUcdZoYYR458hSw9HhIXdu3+LLX/4KTVNzfn7B2bNnzPb2+Ojhx7z33pdQSvPOO+9SFGIs29ayXq1oQv/YvtrS+9ArdM39+/fYU3skSQ60JElHF5umIF626tecQ/sB6xcP2/fFePEzcY46p8jSDKUTwPSORozixmso/nq9b6h870Aw8MFYqDCf8cNcH3/f4Fg5tnCgrUMJ5p9K68I0zfDhXrquk9aXaRaavQvfPksyJpMpe7u7WOt6Ib9YnCnUx4I0LaTfxLX7MFpJtGsCyVsplErxFt776ClvX5yxzmVjnH98+RnXHcbqc//6/8fjd7/zO7z/+HfodCswiFeRoRiSSnGn9cHPia8p8aj1gK0pJx4heIwv0LYI7cWy3huQhZaQZYUUSwUDpwNVyXaWsQEWOyPX0HYdJjBoulBtx5axHtQiI9Z4HRv/LGglsgi8czjfobWnrjvaOmNvL+X8tKZt+iWO0tIQYeztjL9ffmoZs96jkTsa7k8LXukJHZ4gJjWjYZdhlpDaoLm8vKKuG27evMm9e/c5PhYDv1quKTcVe3t77O3toLUhyTKU0ZKw7FqaDsrEYFRKrgwTHUSrXEMgDuPRffWkGPvkleMWQ/Q4P6KRdUH62DmB8t57/TY/8Oaf5c9drTm/OGd3d5f5fCZhtQYvNZOh+5Fs6MpoYfw42Ti8D82pnTxjrYP8gwr6RErmnfMi66vDxt51wpMWfZyMloTSSt5n0zaUraVsbJA9iN6sJI+61o7YUYS9XJMlsem67TnnKniBJkn56mbNL/zmb/CHr7/Br/zYj0u0a6XCN7ZJ7NoRvXA0b+q65lvf+hbr9Zq8yLl1+zaKBKVc6CpUBwlbcE5yRcqF8Q8rQIqMkhCJDV748AzjxmAwSS7QlAtm12zP4Vcd440IusEWEJywkRMlX3Nt/W39+qrzhARukpKmOZ2zZEmG09KGr7Vd6D1LqBqWyuHdnV0ODw5YLpeUZTlaYwH80ZqimA7zNGhXKaUojCFToFyLtxp0gvCzFEnXMv3mB0w+fMRGOVJlyNxnbUpyfCGMe1mX/MHD36VWFkwMm3SEzHAKUXcMYa8LnhAekaWN8IyLSmtSuKE95OwChs5aJrnpe49qo0kSjTFKPGWIbu6I5jUc0YP3AdefTaVNXqRoXZ8eQ9g4/C49V1WvXRFfH7waiRiePH7K8+enrFcb3njtnvC21xXeZzirtyZ9bBayfd7t3/3o6gKzmOAibXnHcQo2TZC9DbrTSml8qEo0WjpM4Z00HHnyhMlkxv3799hsNjx7/py2bTg7O2G9umB3d5fFXHIPsUtV13W0TUPZtpQmpUzTYGQTTKJJvcUoRaIIWixdALliTgXR6AnSqk6Nb0cNG224d3lNPLSj/SlHBzN5VRmsjx6rPCvbuT4qkjZ9sgCT0IxFm2FeeqQTVhuaPGilcdb2iTqvBTfXMfnrPHVpqTpRD227LgjdGYzJmOcTijzHGMPDhx9RFBOZyybCBuEOt0TrdKAQCmYtNQ2OH/vGb/H2pw/Rbct/85WvclXXbNZrYRaFmgupkh0gkzjnnz0Tctvh0SHPnz/nq1/5wT7a06EZSJyzOjBGBmdiMOS99ouKzZzjOjN99BU3Zxu0UvRoE7j+86V53Z9zDMOMHZgh6h6w0eE6v9sRHYYkSTCtGHCvNYlJmBQTPJ5JXpCnGcVkSjGZijjfyYnInwyX1D+/qAnjAwwlVEtFnhnyROGquhfO6+9Ra9qyRp0vya2nxVIAGfrVFx6OL4RxX9drWlcDDqcEkkA5PJpEJyjncJ0TD8qGRFSaDDevwHhpuIED7UB7i1YpGtE0j5lvaXQhCdUsT4UGiZVd3wcaU0xyMGBzA2wuXpJwb9twymEjGE+6cTcYlDADvJcEnbWWtm2oqg3rzYam7rh9+y6rVckHH3zM2ekVFxeX3LxxRJIKPWu9sgGSGltzuabPPPrNY7i+EPj2hi+gPDgP1ktXHOfEoCkEikA5lJYIKZbLR6xytVrx4MFH3L9/j7ffeYuPP35A21S0dcfJ8YbL84T5Yo/ZfFcUL3VCMU1JnWyiTddQ1pXQWJUUaGVpRp4kaAOpEyqc8ZLzkHFVGJQ0cpPdBuXkWp0W5897RwLheQfdjwB5gWgaxSYN/XMOWGk0PjIvQlgdFqYN4mPeaToFnddicLWcp7aK1grA1jpP1dXUXYsL2Ks2KcV0yqyYSKVzJpteXddUTU252fDixYkIbRUzlNJ9srNnczhH51xfoe0ICejwoH/jy1+hXC75xuERj46PtzZ9FfjBkhNwbDsEnsurC+7evU/TVGFuKMGbEYeorGp0J4nVceERYazjIV6+5AQkxyLFbSrILihlgvMQvf6wOdjt+TxE29uGf5Df1v2zG+6ixyCvO+3XlsdoXK4lg+PftNaSXNaiHZ9nuSSWFcxnM24c3SDLRFJ5vV5fy3nF6w1jE9aidx7rnHSzygsSY3BdR2T8yIXI3LMKSDQNYNGiGIv8/nnHF8K4g+iXEzwD4gN2YBIx2HQOE8IrD+AsOnhuEhpbMDpg8BIGp2pOqnJKW2FCb016b0ORZWk/CWRfFVXEvJhwfn4qV7YFt4iPPykmImjViYZI3GB6Tz1EGNZKb8ZyU3J1dUlV1VRVzYMHD3j85Amr5QrnoChyDg73+bmf+5N85zsPePjwU4oi46s/+B43bhxQVXVvlMeY5asO1XsJcWTpN6rx8t6KNbzvmTSRIaNDTiJKQWileg5yHLOuk85CKEVT1zx48AmT2ZybN2/StTUXpy9oWmmysCmPMWeXzOYzdhY77OzukOks4LGJcKc7gsa2w3YdqzYGpeLBu4BR51mGNolQKxVob8Id2dALVvXyDSYaaSQ5r8J46H4upSg9JL59WEzeu8BmkVxF5yyd8uAFPmitRXmDVQqrDLaxtF2L95amEx0gNMEoSGOKfLYQpUAnToQL2Pby8pLVaklVlnTWkgZqp1aaBw8e8P7732J3Z4dbt25x5849DvYPyJIUhdQoxmcHUU7A8o3ZnH/0Iz9KN4IFt6G64ZANV9N1LZuyZLlcYm9JBJMGpVEhMIn3bUIi0TpCzibUUIyMmtaKJNEoDF0Laao5ONxhsTvh4nzDi+MNSpnAWnk1MDJMzyEJ2kcqr7iPwWMf5v72ahi+77POM/53NMxRliCeN0lSsqwgLwru3bsPHk7Pzmg7y2dFHWMYKVJFs0RRpCkKJybLi+3yymHjetUSqZGl+CIT8DBL8a2X7ryfM3BfDOOugEQmivDZpVxZdQzFS0be6LTCa+l0pLzqS9vxoL2XbupK4b1B2QWd67Bdy2xnR97mfb+Qo4ZE9GRR0g6vaaQP5ks4HeCVYTHfwTaOb3/yIVfLJUki5cF37t7C2o7f/b3f58Enn3BycsrFxWVgJ9xmNp2wmB+xM9/j9tfv0bQN682as/NTZrMp0+mEL3/5+/j+73+Psiw5OT7m00efcOPo9miiDl64HGORJI/3uk+egngIsTxcvLWh5Hs4ttkH1g6bSO+FhJJrr40oDPqgrxG9WAXea66urjg7O+P1+/d4+933OD5+DsBiZ5/ZfCewZxybck1Vbag2G/IkJctzTJaTTwqm8ykoj+vkGmMjBKzw4+vWoq2ndK148Sp4oR14K1xj2Zyk0hOGJ9kFyC1NU2EtKMlZWG+JIUzXtTgnre28Ejx36F0rHlcbZGyNMaEIL3DzE8MkhdlM9xpE0Tt1ThJs5VqUE9fBmCsl/Up393dI05SHDx/ircNrmE1nLGZzXpy84OmTp/z+7/0+X/+hr/PO229LZa1WIbk6NGIuy7Jnzezu7vZUvP5p6+HatNbUtVTZWteyXq/YbDa8ePGc3d1dDg+P0CasES8LUSmDQjRhHOKFi55O2GBNQpakZKkmn6YcHRWYpOPyYsXHH1xQ18KIStO8n4v95nANRtxaf31EvI3fXzfKW4ci2IPvjsOMDfqrooX4epIsODg4wlrL2dllL43Qa1CNDPr1cQepNtaJp8gMitjI20vaS4VWhUpLPs1ofIhMTZ7ijCd//Sbdh0/Jbt+Cp8d81vHFMO5eCkBQWjBx7wWOwYeJK8a88y5QASUMxos8qVOeNPBVnRZ3buIWpH5O09WgYscgeXgmeCNKjVtVebSGTVlS12UI1V+Nab35xn0ePT3h9//wEVVdsVgUvP/BA77+te9nOsv59re/TZYXvPPOe+TZFKUU9+7d4w//8PdpW8vlZcmv/Mo/YrPZMJtPefOtN/j+73uPFycnXF4u+fjjB3z7W9/h+PiEn/u5P87R4a3+Gv1Lfsg23rj1F6UCZBSS0ZHVEb9lNN8Fvx2wyJcTwK/wlIJhjUZuMpmSFRPyPOdgb5c0Tbh//w1WqzXrzYqz8zOqqqJtO9q2QWvxjqNuPQHjz9JEVAjTfEuFM8vS3tPrrykkpTpncUaaHEviMi5823PUY/MT2cAsXmtaH6m0KuiFOLpODHcsVFFaYTDoNHKwXcCWTShMC6qkYcyisSzLks1mw87OjkSEec56vWFTVrRNTVFkTGaiS95UlQjMNQ1VVWGU5tNHD8izCT/7sz/Ler3m2bOnLJdLbt+5xWq5ZLVa0biuH6tYJPP06VO++c1vstlsuHXrFu+9917/jGIDmaZpWC6Xfc4oFtY9ePCgl89omorbt2/1PX9jE3iBW1Q/3aTSWxK2JjEs5gW37xwwmeS0TcOLk0tOz6/obBf8EAVqG18XpzsyVz7bEMd82ECHjHPh5c981t+vkw7GR4ToXoXzK6VCe7+JbM7rdb9xD/Lf+qXv65t4hO/NkqDEGfJafVQV1pjznlQp6clsTA+btkVCnRmSSUJLy85X3oOnv/+ZY/WFMO4e+u4l3gM2cJy1JpIDvcTlw3sIu6sVUVNSg0PAVqNAUeBaaJqOyWQSNoNQQKEgy/PRQxwGX/qUilTrOKcaQRGtFFleUExyzi9PePbsKYeHu+zt71A2Jbfv3uDuvfv841/9JyFjLjSzxWLBu+++Q1GIouFP/MSPcXR0xGKxwARZgXJT8g/+y/+ax4+fAXB0dMibb7zxEib68rHdKPf6pE0zYSNY6zAJJFlCZhK6tg7NAyIlcqiM3Pbch9yBUVLoNZ3NODg4ZDKZijpjJuyN9aZiuVry7Pkz1qsVbSs4cxd40rJJyHca49FpbDLuwYpH3Fae5dUVKNPjqs45aVRSTHodEvFAk9AoWDz2YlJQTIotrRxrux5eck4qLZOwuQunXiAnay2emExXoTH2YESc93RtS9NKub5zDev1mq6VBHRnXVCAbHojpJTm+DhhMhHhtfv37/HWm69zeXFO1TQcvzjl+fNj2rbpvdDJdMrZ6QuePX/C1cWSr33tK3zf971LUaQ8evSIslyTaEOWJ6QqwSsVZC1EyOv999+nKAqm0yknJye88847TKfiZGw2m77he5Zl7O3t9TpBKMcf+SN/hLfffpu2bTk83Jf+AAH+tOH+ogF00cv2QvnMs5z794+YzBI2m5b1qQWraRqBZxLjJclMitYek6YBZ/chwhJa6/WCopfsxSu89Vfh5WOoKv47dj8a5var18x1CCuOZ9M0XF5e9s2zrxv0OFfHn+1hJGtJE8A6ug76SwkOBn4kJ6IjW00gROUU1SShpWMxn9IqhTrYfeX4xOMLYdyB0G3JDeGIbO5yc06FHV/jEyUQTtSxUKE0G/FrdWfB5yhVYG2ND82Te+uMeGlSlTqUSIO09EoSQ0xAvhziRWaz5+Bwxp/5F3+Wrm1RWjq5eAfn5+fcuX2bn/3ZP95HBUVRsLe3x2w273/vuo5vfOOf8f7736KqS77/+9/jzp07/MzP/AyPHz/l7t07vPPO2yHkdWGCfH5oOQ5bx7/HyTYpCqztaFvpqZqExOGA5w+wlfeRtlWQ5zmTyZTpdMpiviDNMtBCC3xxesby6oqmrnu8XAxoyGOEsUzS0Jg6JNOatsbahq5pASlWUoj3Z0MdgkkHVggIPLPZbEJydKgunkwKFouZ6N3M5igUy6slTdtwenrG+fm5PGuQNodONOJfe+0+O4tdvA9NqJdL1uuVwHKuG21GLiQF4+8wTKgIhYFssp4hkS7vs7Zjubxivb7i008fsLPYYVJMmM7n3Lt3n5s3b3JxcREanG9om4b9gwN+/Md/gvNT0dZfrcRz/7Vf+zV2dnb5wa98mb29PbrOMl8sSNOEzUbgmLOzM95+520RNAst7larVZjjSR9FpP0GF69UjN/h4WGQ5vC9YTehGYUxCV2X0TRVnyD23pGEhs1PHp2hjWY6F2EsHfJo4lPpXj1KWvklw/l9ZDZtz+XxGhx77Ne96+vvi6+9Cha5DrOMz3Ud8oneep7nLJdLmqbp8xqwHUnEgq9XwTLiiIgWjneI/IHavl/nBamQpt+qp0pG2Qz9ffdpf+fbGK/o0Gzqms87vjDGXayz7ndzpULo6zWtt/hE9QZO+cHIgkwa5URoSrWGaXJIRkbZiTrgmEVgEpGMTBLTT9wxrBE58H6bCCt/DdigdY5PPvqE3/jNb+JwwXtM2N1d8MYbr6N1wt7+DhcXV5SbkmIi7deOj8/6UO7y8pL/8r/8r6lr6RL04ONH/ORP/jhf+coPcP/+fZ48eco/+kf/A+Wm5Bd+/ufRqemTup83qUU7W/rGyt8VSnusa6nqisELl0SkDtWggg2LMZ/Pd4McakqaZNJPtarYbEouLi56JcQ+QWR0v4hxjkSLhrxwtqX7u/OWtilRTvpXFmlQwsPThg3HWo9OEiZ5ThK6zFjb0XVN0GHPmE5nzOdzZvMpGsVsNmVnZ0earLctDz56wGq5ZL0KtD8lBs2F3EBZrrCdpTEln7pO1D33D0iynFs3bzCdvcnp6QsePXrEarUM90gY0xjKXWeIRGNiGQw8AbqJSUfZBJqm5sXpCbHIrphMOTi4weHBTV67/wZXV0tWqyWXVxds1muKYi768m1HkuZ8+atf48XJCQ8ePuQn791heXwMznJhL6jqhtXyCqUUeZZhjGKxM6eYZLJJh2K9eA/Q71QB83aCgStQMefk/OAUKQUoUdw0mqZ1/ebduVAZ4WuMT1ivrsKGENeZ1G9oFfuLphid9n1zw+oc4Ble7aFfx7E/iyb5qqPX1GF783jVRqKU6ttkWms5Pz/v8yzjI+YvgFGDbBlbjZWGKd5LbG0tONVLlveFl+EaUm1QiQGNJEsB5RWuFRG56evvcLr4dbrjSzKTwNHBK+8zHl8I465QoaGAwjcdzkiDXqUU+Eh1C+KPwvki9WJsnQGda2mRaj1aJTiX0XRikHZ299Da9IOu9MAO6GmKyADH1l1V9dlSmnGCPXn6lF/91f+PfEd44D/09e/n3Xff5vx8yT/6lf+eBw8+pW07jm4ccu/uXdZr6Wgfz/W1r/2QeHGTCbNZQV5kPHv2nG9/+1t84xvfJElS/rkf/VGBF0aT8LO8ltgLNmLs1wup4pFlGdPplJ35gul0ynQ+J0lyqmqFtR113bJcXgXceE3TtKMqw+G7I4YLnq5rw7UFTw0C3XMTSvCFxpgGDLHt6iAnIWqcJs2wmTCa2q6jaVuSJCXPM6bTCbPZXDR/tGZSTGjahrPTF5ydnVCWstl474X/7mWjN0kCWo1C5aAbrlQfJZydnXJ+fkY+Kbh58xaz+ZS33nqL/f19Xrx4wfHxMZeXl8Fz70f82qzYFsOKeRAVostY43T9mThnuWqvWC6XPHnyKXt7uxweHHLz1iG3bt+k6zrWyyUvTl6wWq+YTCYcHB7yzttvU5ZrlssVi8UODx98Qlm37O7usVwuqeua4+Njsjwly1IODg4krzia6wKDDJCbH92WYrhWMaZuFJ3EpKIkrH1IevfNSBR9/+D4urRMDPUpvc6MRmvpNhYjiOt49bWVtzXX/cgw9snY8If4dF6Frcv5t5Ox4w1DKdU37EjTlKqqKMvyJagFCHmgbAs6lO8L88CDUR6Ux/q213733geiyDAXjDFBnnbstMbnIVByV0x48kM/SPXpKW9PJ3SHO58zXl8Q4+69xyuFcWN3h0HKN9EhLQjKuZ4xohQYNK6xYbfXpHpGqkMPTRSxAa73ovKmQ2OHVz34GIK96vXhcFhnuXPvDl/9wS9zfn6BNvDmG6/zU3/0xzg5OeW/+Ye/wtXVkr29PXZ2dtjf32cymXL37g7T6bTHjIX3Kotf60FQ6c033+L27bvs7u5zeHCI84FjHbjp1+GX8TjKhqjwmB6Xnk0NOwvNfDZlMpkwnRYkiaGtO5ZXVxw/O6FqKspyRRU00n2onHNuPJkT8rzoi5vi0bbt8By9H31mEI0SKW/BuG3YVGWzFqaF1gkmL8jylN2dPfb39snS+BwtVVVxcvyMrpUNsm7qviMO4Z6dAkxCEhqa+x5DcUG7W2Nt2xutUBuI955yveGTjz/m6ZPn7B8ccuPGDd555x3ee+9LnJ2e8+mnn3Dy4piy3IzmRkyshmfj5bV4Sc4riMZsZBj759UznyR5eXxccXJyTJIkzCaS05gWM9544w2ctWw2wqM+vzinmAjX2naWd7/0JVCKR48f8+HH38GYhDQzKOW4c+cOSknhHgF+Gy5hzCIRgyubd7c9t7yi1yAK96C1ITEGsjASTgQEvBoKq2KRUlxTglPLHM2yHK1N6N60GY2NJ9FaNo+wEeuQtAxZoJ4BM0ShUgfSA6y9nR/fmzwXaYw9cOPHnrsKuYudnR2qquLq6qr3xsffF731Iadjt8bFWQ/WkmhhQdW1aM5os43NR0ioT6ryio0pPDvlPTWeky+9zsnNm2zO7/HedCiGfNXxhTDuALpzKOuxRlgLygv8oR2oTsq/lVZ4o7GogGtKEKy0RpsE5zUZC7RNaNuKPBfvYZxkwXvSNO2NVzyUkrZn44cZj21DD9Y7ZtMpv/QX/xwxOeC95/z0gtPTFT/8w38kyAUPEzxGHzBMfOeE/aMIFbmBt1EUEyaTOUmSDg/ci2mXi9i+rjgRkiQJScCE2WzWtynzXrosXV6cc3Z2Rl2XNHWNxvRdbsqmxPsO58I+GZKJeZ71EzmyTJqAWxuTjApJ4j3AAB0ptA7eWgjvI7aYZRmLxYL5YkGeFxT5hMViF+ss5xdnbKoNy+UFF+fnVHVDVdV0TUmRB2ih3+Q9eVYIDVALpiuc+WHBRcErWdiD+BQjoyvjKWypzePHPH/+nMePH3F0eIO8mPDlL3+ZunmHx+Fvq9VV2ChGDyTc+/h3H68B/4p5dd0Aye9N09A1HcvliizJ2dnZ4fDwkKOjI+7duxeKnUqOX5xw8vx536z59u1bfPWrX+XBg0+oqoobNw65e/fu8P1Deml0zsETlkB5eMMYxhjf1hZNMExIrZU0uEjSHjMeJ+XTNO2ZOVFfpee4hzFwTrpXdW3Tz7OoUBk9+0iIUAHj1lpj1OD5ay3sputGUvK+44K+7WeR5zm7u7tbEMyrqtSjvHRcv5Fxt/1sHca4kLNQpKms//GGGTeEWKEb7z+Oq7C7fKjBkLGdpQk/dfcWH8/XnNza4+3sf74G2f/THQowYDWAx1g/hFdh0qhgHBJE99ojGuQqkUnkrCe1Oc5ltFbC9L39feQbQw5eSym3eJ3Dbg6gAkTQNpIYFe930BcfQmrFxfkV//hXfxvvxRt597332FnsgrPsLRa4PvHmR58TISOloj67LKZBPCgm4uKD9iGkbUlTA0oP1xkmcYwCxokfSaJJcdDl1QVNXVM3LZv1inKzEkMXWBxGK7pOC849meBcR9e50CA4xbqWzlbUjcVZ31f6iqG3GDMsYI/GevmJjtipWASlRBZ1Mpkwnc1YLBbcunWTxWJG11kuLy9Zr1Y8fnjB2fkZy80ylPEHrrr3ZEaR5Fm/SY8XU9s2UpegJLTtmT8EIU/vtgzpdsQTq5yD8XMe78TAPn++5vnxE6aTGRcXt7l58yaHhwfMZwvW6zUXl2dcXFxQ11FDRLz3yOYb8jluwBH6+Sa4ve6ji2hqgyY5ssk2bcuL0xecnZ/z8OFD9velc9Lu/g43Dg/Zme8IJbJpuLi45Gtf+yF+4Ae+jLM2QAYji74FT8SFFzc/3Zv62A/Ah0jLeYVD1qE8bo0xOcZ0A8cbcb6SJEdrac4u5xGDHqM951q0TvvOZuPnITUDhjTLUL0r4/suSN5LjUGUHnYWuqbF2nrLe47fFemsSWJ6oUBh3HqU9r3jlWUZ89kMZy2XFxd0bYcadVIaM2aiM3PdIOMdzrZoJ8lnvOt7Rsj7bA8Pj5k7YzjqOkyktApeu+ohtYnJ+P5dA0qR6Ovw4PbxhTDuCkLIYgLXWMJstMeHxijOxfIbRZpmZCYnSzJmxYRZPiM3c54fX1GXCa5t5CFYGyCA0MRAKYxJg3GPSceo724CxtYOmBnX8TqZ3V1n+b3fex/vPbu7u7z77vehlEbFKj4/wEawjZHLcxyLiUUZ1W0ccQgBpYqvKAr29/dFmc7DZrNBVC0noRn38hruN2xcbVv33mv0sAf8VcJKG5KxxhiquqbrSpxrQLUkJkNheLXnOXqISLTlO5hNC3YWi8BmEfpiZCI1TcPjx485Pz+lDRWsMVpzzg0d5VXQ/fEhNFXbAmH99QQNc+8ctoubzeA/S+g7hNRjT2v4Ho8LzoUY5SAm7RWr1ZLvfGfJw4efcHBwxM0bdzg6OuLoxiFVVXJ+fsbx8TGbzToYmTi2wSnwfmsujOd9REuuU3x1kEwYok5HXVc8fy5FYelT4f3PF7vs7u5x794eaZry7NkzuZb1mrZpg0Mh3+tG4yYbpxlRRgdfVjaWgXYsEbQP1eMysmKIk+F6e2O8DRX29xqcj3Gf0c8+Bs8bVN/DQeyE6WEe3DAH4ryPkZn34ow4a2mC9x8jBwBldHAyboH3fBKinZhL0kaHXq0SZUwmk16oDQYoMhpolEL7TnoUdLHSO2EY1e15d91jj8dWXm1YpYiooTQ0wYtu1ndrW/2FMO4gplZpByY2vYVEpxRpRp4ULIoZs3zKfDJnls+ZJlPyUNqtMJxflhw/q9BK+hBKoo8+3hTfBLIsJ6pKDgOvyLOc/f1DXrx4MTIaw/WNoZ0bN27wi7/4iwB9/8nhfQAJQ5OP4Mr1eDjRPQonEG9CmmInTCazwKmdiTFP0t5jbruW1WrdF8hEGtbnsQdkwluUisY9+kQjT9NJWVPkaDsnz0DqxFRv/ABsZyEJmHLQB8kyKcaRzScVuCW0FDw/P+Xp0yecnj5nsynpupa6biRqUUMBRwzxxwnqOKA+KDsOhikmnmRRRZXi4V4G4z7AJnpYREqMV8zpBHsV2tv1YEI/PeLlNE3N8+fPOD09YzabcevWTW7dus3e7ju8+eY7NE3Ngwcf8+z4OHDJ5Uqss33jZR2K78Twh6pXPCiRzFB9kjOG6K6/V1nikr9o65amrlherXhx8oLFYofdvV0ODw/Z29sTLHu9ZrlcSr1FVeJcdFxk/jsXYZLoXY6MhYr3LQWGzsX5KtcXm9vE5+fCcxvLA8T5B2OKoVS4xnzF8J303zV87jOOHloZ5vvYgTKJdEHKirx/lh6Ps9JDIE1Tbt26hdaa1WrF6ekpTdv03nrnbGhq7pjP533SdOxcRDiz61rarsI1FdpZbNuhg45VFyTHYzs+DzjvQgJZ1s9wD9sVsdvORwgqw2ZmjNmCnj7r+J6Mu1JqD/g/AV9FZuy/DnwL+E+AN4EHwF/y3p8rudK/jbTa2wB/zXv/jc8/gWZeLJjmM6b5jP18j8VkwTSbUCQFWZLJhPADzhqNgXLgveL4+TFVVdM0YvCKQvS5GVeOhUTOde9Cvk+Hnpjrl3DQ8fvid+3v7295AuENMulGSnlbZ4oTMmhVTKcziqnAFHt7e1KpGBQZ27Zls9lQVQ1t0/aJG4GKXp78r0oQDycVZkbMM/hoXUbFT9Gzj5PL6OF9biTklKQ68MrnTKcz8nzCwcGB9DZVitPTE05OTnhun3FxfkFZrkSAahSKysIeNtf4LF00zH7wGsfezfWFv3WnYbyjqJe8Fv8Y5RjCd4akXL+ZEOQUwuY7dAvaPm+MtLqu5erqgqurC548ecLt23c4PDhgZ3eXH/zBr3H/8pLLy0uePn3MxcU5uKEwavDQfV8E5HzUunFYF/y1XldDfvbhvYeEoZTYe2ibhtPTU87Oz3jy5AkHBwfcvHmT+WLB7Tt3UEqxXq959OgRp6endMGjj/clHmXIY4WoNfTEYWhqPWj/j6OQIYqSQqaYaB9HROMnJdhzhDboN5qt5/pStDx6zOEZ9UYT9dJ7xv1dez8KSNKU/f19FosFeZ7z7NkzVqtVaI5ttoxqrPGI3PWYixtvXoKFO1TXoZ3oISklPVmVt1KxawxNLWwzZRJMkuCCfEU8jxoV641hmqGnMcRiO4FF1db7Puv4Xj33vw38svf+l5RSGTAF/vfAf+u9/1tKqb8J/E3g3wV+EXgv/PfjwL8Xfn7msTvZ5ee/+ovSeURpjAtNOXwoGbeuL3V3TjRANFoaKiso64oXl8Lv7doWfJiwiCcXq18TY0gTI6F+9JjCYa1luVzSdi2xV6sfYWt9AnQLEogTH3oPZAujl/Pmec5kOmV3Z4fFQjyBnZ0dkiShrErOz8959uwJV1dXbDaVtHXTBP2PgjTJ6BNJPY47HNFb7RfeyPONC8+Orl25OIGHxTVAREMpNAryvCDPJ+ztHXBwcCjFRYlBKWGwbDYlH374AZtyEyKKCms7sqwIrOVIVRtgimG8Qgm6d8M99Z57yOyGOYAPBofBcMR+qAovcF5wgEdOdzikznkMtUl3JBcql4VqKhFALLPxoAZq47iEnFEuZrm8ZLm85EGacnBwxN27d9nbO+Dtt97irbfe5OLinE8efMJJ8ObjphaNq/OiPOlDHkmFPc8FzCt2lYzCn957rAqDAUGXXD7knKcsSx49esTjx4/RWveOw8HBAffv3efo8JCu7Tg5OWG5WtO1InYmayCyZIZ6D+Gexzk9OC0gzBCBKjpQkKSJSGiPmmdIrkn+bYyhyF1E+gODKsBf/ZQdPHnYjkT7daeGd/oIa44hCj+8Px6TyYTXX3+d2WzG8+fPePLk0UgTRrSs4jOOUGL0zuU9IfIbNZR3XQfOiqIjaWjDp8hCorgX40uSkI9I0aPNz/W5BPpoYGywVdxlveprWFS/RvVIOuXVx3c17kqpXeBngL8WLqoBGqXUnwd+NrztPwD+EWLc/zzwH3oZ2X+qlNpTSt3x3j/9rHMYbZgkBToWTATMU2mFCgCst6KTFnXbY4s2NDx/cUYr9hrbWSaTCVu4s2TVpNO4Vn0DgX4AGRI+Ap+MPY/4Fds8V/n7trcrk13kgGezGXmek+fCdhhjdWVV8/TZB6xWS8py3bMBxhl4QuM1FXiyUbhqHLpBgBfiJFIqNDjZjkyGhQr0W5rQHJWWAff4UMQ0YzKZsZjvhOIXYbV4r2iahtMXL7haXrLZiMCU98PYiAfuQyd7+rGMqpSo7XC9D0HD/bvxolSy+CP+LBvb4Fn1/46/h71Wq+0CN++jUFxYkG6Ax7x3AsUEAy/PPejxxS8cnWs8H4YwXf7etg3Pnz/l5OQ5s9kuN2/e4MbNWxSTCV967/u5c+seT58+5uz8jDoUkymtRVKDYcPwxGEKO1k0Wi46CzoYWzW6x1AcNLrviDGfnUnS99OHnzKfz9gNvX1ff/11us5R1RWr5ZLlUvI2UUtHZorCIwlqgeDGXrbMoSiPLcY+CZDLwFAKM3DY1AOEEznffTSlw+r2KnzHqw37+LWBTjjOW403FHriwY0bN2jblg8++ICrqyugG3oV+BihwHQ67RlC2x2kwsZqHa6VhkIaL31vw8YV50IX1yIaj0MHbaTrhjtJNINo3/D64JXLmug6kTN13knr0K5Dmc9nysD35rm/BZwA/2el1A8BvwX8b4FbI4P9DIjqVveAT0effxRe+0zjHh/XeBFFvE8pKdX1WuNw4ukoes/7arnhybMTaRm23qCNppgUsGUoZdHneT4YGj+cOCYmYzYbXg4Nr78u/F0J3RaLRfh8QhGEs9I0FUbFxQUfffRRX0EZjfywOQyhmCRZhEefBGXDOHmjHZPQcESbGl1T8P368YxGN246MpEdLnixSZ6zWIio1cHBPmlqSNMCaz2bdUlVbXj27BmffPIJ63UZSthdSIzKec2IVSDPUjwNiSZcnxSKofI4jHfO43umwGhCeNnAvREvTTTXPUmShU5ZQ5u37WckoyBz6fosG+vmBA46YiKJkYESOYsttz940loHbXe2Dc02Piqbx3J5zmp9yZOnj7l16xZ7u4fg4c7dOxwcHlDXFWdnZ5ydn9PZuvcGo0mV+hbBVa0jeO8Rhw+sq+uX6Gzv9atgNwWKA0nmtZyfVZyfnZKlGXu7u7z2xuu8/to9jDGsVmuWVyuqqub07AXL5RVt6EbmrCSbJSntB6DFg1JJYE2J9+t9cDjUeHMN0Yn3dJ0Nm7ViSyTMjr33bUP+KphGXVvf4zkUP5vneQ/BnJ2dsVqtApQqd2CDYfYe8jxlOh3YMN77nmIq6zP2NRBNJNuJ2qwmrl1z7Tolh6OUDv0BtqOR6HDFHMhQXR43EWmWbm1kBoJGhYS02SqC+qzjezHuCfAjwL/jvf91pdTfRiCY8YB79d1St9cOpdTfAP4GwOH+vjwouDY5hwRYiFUlK68Ao6maho8+fcS6btlUDZtNycHBQQ+pxIcc9ZizLBOP3/uteSVeo6NcV6E/5BDujI25CZl6rTWvvfZaSFDJNRpjODmRxsRS1VbRhUYQ13G6+DMqDEYsTfiwBKMY2RKjRFfYkwZ4Y3g9GiFGRidev7ViMIpiQpKmTKbTwKWfUOQFs9mMuioDLHTC1dWKs9NzqnoTFrTqw9Y0TfBehzG6NpndAH2omKzUWmCu0doVby8an+28RDQcsvaDFwY0XUvbeYpi0jd0fpWB/6wjPqetpCGggz59NPWCcoSAP+6oyocOTHp73EfXMR7zmLyuqzUPP3nAs+w58/mC/f19kU6YzZnPF9y6fYcXpy84Pz2nqaswHpZYMGStgA6J8gFCG42P3zZsPVQRok4VIK9YGdxvXs7TNjWnL044PzsRAbijIw4Pj7h95xY7iwUeOD095eMHn3B6eoaHPu+iwuL0QZbBmLTf9GKthhj+bcMzxrLjc97eRYfPRFjn857ny07YEFFELvpisaBpGo6Pj19RvxJzH1K4JM7ZdmQZO4fJOFvRkQqbqO+EGSOVuoP3PW7grYJOjJRUvLxhSa1IGhy2l+exbEQabQwmkSp+rVNZa/FmP+f4Xoz7I+CR9/7Xw+//d8S4P49wi1LqDhCFhR8Dr40+fz+8tnV47/8O8HcA3nz9Ne+9tCxThB3Sv7xjRxweFK3zfPToCRebmq7zbNab3vBGDQiZiLIwp9NJWLMBa/fbdCvvfG/Ak4Bx53keRL4G7e6maajritPTE9brJev1utdZid2erPXbDbZR/YalontFTI6IVygbgBGYxA/h7/Ad8UrlHqLH3pvG0UYFAmWkWdZXxeVZzu7OAqWgs5JgXS2vePH8mKoqaZo6wFUaaz1N2wVtkCFEFDzVI9zlbfU977uwt4hHZnTQQLddaC4zFPLIdwbPbRSpeUbFPg5pvIIn6oc7FzsZ+QFzDjTJeO89RMQ2PBPHs4dlCKqGXjZTH+dG75IS/AnF0LkorqchGvFB5CxuuMP401tjaTsoMgfz+ZzDg0MODw9YzGbcPLpJUzc8/PRT1usVF5fnI42S4ABfg9WccwFOi2tiOO94nhjNAGsGOEQRHQsZu/V6yWpzxacPPybLpxwdHbG7u89sNufundvs7OyIYFu5pqpK2lbkgH1wxsZww7anvb3xDx739u/Xj2HDGr5jrPM0jpS2D5knN24ccffuHeq65unTpz1FeHs9EdZzwnQ62+pFO8xp1/+01uJtE1o+ipOZBr2iMYtG5tfgVEpU60J/BHqjH+EdaZDSjJKpejQ28n1JOjQOFzq4DKJW/xNg7t77Z0qpT5VS3+e9/xbwc8AfhP/+KvC3ws+/Fz7y94F/Wyn1HyOJ1MvPw9v784SKLB1wyK1dKawq0VhR1J3lOw8/5dnZBWXbsVwtUVqxWCy2DI4oz2lmswlpljAkegSqiEJKu7u77Ozs0LYtk4m0PivLkrIsWa/WdLYVSdeggudcR1WVbDarLY/EJApthPpmQnMRefCeJAkhmhaufew9OVSmhvfDdwm3hrHp4ayQ2BKMvyAxaS/jKptRjbOW58+PWa+vKMsNdVWhIGhqR+9VERlJWTYuz37ZkxpHI7HVmRgOHRLYMUyXcm/xIGXSxgSi6duOhVBfjbneEQslRF/CGe69IAw2RD0Oj7lm4COlsN/7+ksPG6cPEAyyATjnUCaq+sVhDpuFGkY7GgZPhJpUoAkOf5NhiVbM9bUbzsPy8oLV1SXPnz3h6OiIW7duMylmvPn6G2R5yvnlOc+fP+f58+dB48gH7DZCcKPnELxDMSiqn28v54UIYxdaU8YGJioK8Wmcd1Tlhk8/fcijR49J05TZbMHBwQHzxYK9fA+l9nutlaquaeoaO2KMDZ5v3JSvzdsw/upz5vewUXkCQZptVterDXuaGnZ2Djg8PGS5vOLp0yejBtV6a1yUEtbcbDbbisQiDCMGW5wQ5xx0FdoPDa2NCs28R5DkuE9Acg1jj9j9ED0S7FP09mODbyfQMJ7OdiHClUhOOVFOtT5e1+cbdvje2TL/DvB/DUyZj4C/jqyS/1Qp9W8AnwB/Kbz3HyA0yO8gVMi//j2eoz+89+PVODwU71lXFd/65BOOL65Ylw3rskZ7xeHBQd+Qd9C2gNl81pfiZ1nW89LFAOY9Dn58fCxqh20L3veG3I8m6RhbjQnYmAw1xkjC1ugeUom7+lCd5wOOHu9se+LKMRQbjb2N4RCPoygK0tDlZzYXKeE8z7Gdpaobmrbh8upS1BzLNVW5oalLCf2Dv59o4dsqHT3oMBHVtb312oKKi0/GW4yE85bYzT7awuglXodCol/de6dKKgmtHzyTMT4+LIzoIan+2YS398/dI83Px1Wp2/h4r1I0ug65JmftS0MeP2+0DnNBrs1FjRIPXg3e27inqPLjSGEUkuMpq5JPH33Ko8ePWCz2uHP7Nq+9/jr379/jzp07nJ2e8cnDh5y8OBHOfB9xyiIfxmQMTw0GRIWNMlIcQY08RHpbK3+Pm93AAmuahs3mmPPzM3b39phMphzduNFXyMZI9TLQPqPYXjSiqk9Ihw3k2pz6bkcfQTH8HJ7ddmKyKAp2dubgNQ8fPqSqNiOvdvuBai39aKOwWY9vw0i7XuN9R9e2uLYMPH/5Lh3mKkTxt/F4+x49AAKDy6K9OC4qVE/rmDAP99brNAUMvm1bmcPOBQdEnl/npa4k8t2lj8FnH9+TcffefxP40Vf86ede8V4P/Fvfy/deP3qvy8cqz2BAkAh+vSl5/8MPOb66YrWuWa3WJFnG7v6hyLr2CUTdc9Fv3ZYJOZ1OqesapRR1XVNuKp4/Pxav1rlgnPor4XpYGe6tn/zRUx6zV7RRwTOXj485vxAr1l5+INvhrHx4YOIMQkVZlpHnBbPpjCzLSRJDlme0rfCcT0+l4nMsxwsEDZQxe0HuUTzQES8cj7BFVIA9tjnNXRcZBgqUJOvEo44RgHjlsZI4Vgn7wCEfwl0XlBmHccU5qe4LxS3OyTj2njRj5UEFBI84whFKAj4deMneqaA/47ae3+CRqdDVK7ByvBqc+pGHF6Mbae0bFr7zGB1E65wfedORohlYEMTrDsZJhUR2iBCiiNXF5QuWq3OePn/MvXv3uXHjNmmac//ea9y8cYu6qTk/OxemTVWH4qNBQE+m/VhKY0xMiPTF7TqBaDvHsKGPQn39hufwvqOpS2zXUpYb8mLC3v4+RS6ibm+++WZflxELgiSijZGBzLVtY/1qh2H7tZCnUR7owhhH4y7yBIvFgps3b1JVG1brFavVKjhbQ+Q3PiLFUeCQbkv8DgZj7Z0F3+FtjW27PvqR4iGNG0XP8ehCV6Weq640ylmOn3xKVTXcef0NVBKfhe0dP3l+sVBNpFWUUsT+ZD5k1CMy5b3AYgpN912c9y9GhWrYPftwLXjuSknoa1GcnV/w0YNHXG4q1qua1XKN0Ybd+U5flqtQPZ67v78fGCApq9WKszPRUo+CQM4OHtV1XHbbCG4fvQFT9F54H8qFogqjr+Gf/a7xsie+FS4iNLDEJOSFUJ2k673pDXxTN0FX/VLK9nGirXKNqrl9jmFY5R8Bjx4tdrkOjScJf4+eYFgsIy9aEnMETDwaiwGacCHZJ/vTwJAZh+PO+b6J9bWrJfLLXUguKiX65E3Ee7fgBnmCcpGDBz+MLcN/RLxZ8gfRkMliGjoLbW22MbLp93u51xhdeobIoT9P8FLFWVF01gaKpkMbJdolevDmozjW+bnQFrPsO+zvH3Lnzh12dnZYqBm3b91ms9nw9OlTTk6OWa9WjD3YeL9jzFcwXgILbHBOdOhqhhptBET6XoQYwowM/XidB6yjrmuePXsmDJHguUuSeMbe3l7PEmvqhqoW2W3nhwhj2NK3HajxXB0we0+Em8aRbGIM+/sHvPHGG3g85x8LkWGY+y9767HpTDyiMFnvrBDWn3dYV5MgSEHnhN0T5Qj6aum4IfpBiG5QipR1025Knn36iPNT2ZTf/crX+qJKWQND7QmE3sUqJmFHkGfc2CLS5z1Gf77XDl8U484QejsX+KOA0p7OGx4/f8Gjp8dsyoZ1uWGzqUnSlL29vVBBFqRXtahDzhczsjxhtZamB4Px2g5bxbMY5IJFs3pY2GMPbmwIY4hrzMAOAVAYBilRRkYm3iOMJ3SkP2ZZJiqJ8x20Fg0WpWC5XAq7oWtp246qqmjaenjg8q280kZuHTGUjSFzmDgE1U2t8UqHTjAaZxHZUlnqgcplgtFS/T1KNl8WX+yl2nUOa2uyxICOkYu4GM4xooxt95XcmvCDSy8GKGwERZ6HexYPLnrE/fIfbSADg0Hw5JhMDJmBgHcObB2lhI3Q668EIbFYlBONNYzEG3SoFI3elJLITCkplBNqJLJphmIUnMJ5K2qm4eoVwiiS+7fU9YZnz0qOjx9zcHDA7dt32VkckKYZr79xn1u3b3B1ueLk5ISrqwskN9CNDLo8467z/fyINMroEet+LoT6ilAoGJPMSimSROBL57U0yPHjzd3ROhc6SF30Gix5Ngm5nwmTyUy0g5qatq2pqgrbbUfEMqTbVOOBiTXAlhJxeWazGfv7N8nzgidPHvHi9EXfNhDGsFDYCJKE+XzeNwnvG8xcS4TiRZWWpiJBRMCcE0glSxK0ESzcJ+IECPlgQBfiWm9baW5ttCafzPna176GthVPjq+wLiIS2yJnArU4vJem7Gp0L72ODhId2NgjePT5zzq+MMZdBVBuzHhYr2sePj3m7GLJpmxYrtZY11FMCubz+TUoRlrnzefzvp/k2IsdG+vxaxECGbyFYCr84NFvwyZyjHHkwZuMWOPwevQeY/Y8TqrYMOPGjRs91ucdnJ2d07ZQlmtWa+lB6kK1bbwWNViz3sh/3oO+nkyKRn7AXX1I+g0MlH7hXbs/54caBDHwoQCJTgrEukBxNNsKeHFTjA2tCR5kP+JxUSIGVrDq0BAi8LpdLPQJHrLkCoIT6pSEr6+KXBgViAX2T9fGMbS9xy9zcPt5j7+uh9eiToi8OJpH8vyDbw/IvHQ+cP7V8Np1GGJ7bkUpWTg+Pub09Iw8m3FwcMDB4X6A6FLefPNNqnLDer3i7OyUq+UVPnDbx3BL/M6t+eNfdlpiDaEHtDIB26fvW+3w0k9BvaxkCLBarVj5FTpAlrPplCzP2Vks0GaXpmmoypqyLHs49NVR8mguhw23KDLu3r3NwcEhlxdrnjx+wnqz6iPnVz13aQ85GRVajUW6wn0HaM+3Na6tUaGXgTYKk2TgJPJxQlqXymYi1VSjE90PmjQlkfaBs+kuuc6prxzlcsP9e69ROh8at/g+PyjNyOWeI9subtDOuR7uuR6V/S/Gcx+8JlAOrFc8enHCp4+fsikbVqtS8Elk556HBCJEKpYizRIWi8VWs43rCya+Pj58HzI6hga921h5xH23mxgESGfkzWx58cErKIqCw8NDDg8Pe+9hs9mwWq1YLBZorXn69CmbzYa6rmnbiljchFJ4FzxquRIGD3wwwi+VLG/dnw+CYONquy2cQsZdmb7oJd5Tn4dwYLE463p2zZAojLCMcOk72xJFkuL1jIfcOScVqVph0aIBHqNup4jF6UqNDFJICzhs0LeOYzBIS4TANijyDYlXpUyofA3MHDTGZHKdPWapCQzO8Owtkf6Ic6NEY7ynqAUQ0KBeK8UJH713FCQy9G7AWLXepi6GYAk/Fja7Nk+dc9TVmmdPS05fPGdnd5fDgxukiSFJDW+98zY3bt3i8uKSJ48fs16vQmesOOcHyEZgA02UWRh7uT7Mh9Rk6MDPljkeJAq8wVrTG6bxnBvmlkTfZdlS15vQf7RgZ2ePIp8wKaYsFgvquu4pll3X9p204vOIFlPrhDu3bnF4eECWJxwfn/D8WUgyR60JttdqlF3IsqyHvMTwDpGNiLa1eAdda1GuQuGkzgUneZPQeMR4ccyclSrx3qFMBN5K0xQUaG8DJNPSrEt0ljObHDHNZpDMSFzDanOG9YNGvWzirp8X42sdPHuB7pRWJOrVapKvOr4Qxt1HN1FrlldXfPjoCceXF6zLktXVCuc80+mMvd293kCOQ6ssz9nZmW/xSLe++9rP3ouLLswW5q623hf/PV6Qw/sjE0BjjCZNC4piwuHhoTRUqKpeJXE6nbLZbHjx4kVo29bx5MmTICA0xqNjSBqxtohDAjHhGXb6IbP/cjXfq6OW0SahotfrBJKxETqJOKffjl7C/22Fsgy/x0Sq1gmKofgqSueKqFQaqHumvwwfGoD3ybfgkUdJVKVUUALwtLbFe0JIrETjRg/XHhfteAPui0OUwyMGyrlIy+zvQu7Te5wVVcHt8RoO78edpoZZ04s8ESMeGcOu21Y/HKCRgaUTnOwtnHV7jsulOGdpGsfJ8TGnL86Yzxfs7e/hvMdo6ZL12uuvs7OYc3l5ycOHD1it1ltOh3MerVw/ja97vULpTVAhB4EKnP5YKeujIzRc60AquD5WjqapqeuK5fKCNM2YTBZi5EPh0HRakBeypi8uLrm4uKBtGxSaNE24efMON2/epG1b/vAP32ezKfEu5nW2YT2Jjk2v5BjvS7xjGcuBRSPK+diOVEej7QWqDNLXcQys6wjyOf15xk5kG+mgoeAvSxSuPKeyKSYrUGpO2wnV0igNRjYD51ygXw6b2djWxLGN1y8Q2bDmXxIuvHZ8IYw7wKbpePzshCfPTrhar7harSirDeApwm4/ph7GAZ5OpxSTgqgdcv24btTh+o4XC4aGhfkqAymL0GyfezJjNp+xu7uLd15axIVuLk3TcHl5Gbr2rPjggw/ouibwU2USjKvShlA0njv+Pi7vH8Mr4m33f/NePFcfKhNDIjQmY2NyTdZrhA3iPeswrgkEfQ9JUg4NxLWXxaB6b8mJxx+wWHmTGkkTgA+hpg6RQNc1/fVGWqjo/SQMND/hrUsRmCSXYlk/oZl3mhr64pIAC0Wsary5yz3HsDewJ/QwF2TjsRiVEAWsJAIZb/Dj8fdc54mOjUv/bHRgPEUtIONRJnjNvgv7ZohOiBLXQ5eiaIS2Nwy1dR3OdSyXFyyXFzx/9pj9/SOOjm5Q5DmHh4e89trrvPP2uzx7/pQHDz7k7OxMDFt4jhJ5+R6ykhFSJFqjlcX5kCMxCQ4rNQihchqiDrxhLNkh4z9OZse5HMv5S5qm45KL0Ih9jveeYpIzmUwpiimHB4ecn19QVTXT6RTv4cOPviNyCH07R1kn1yPCNOThYpJ0HK3HNSCSywrXWXxTAy3OtkR5hF7+uOvCpi3P0ilF5xzOdhRpJtGYSXooUIm1DnNWgzG0WCorlaybtmZ9ecKkADObIM14YiMTFZ6pRH8xEowbf4zcfStzom26rbnxWccXwrg3reV33v+A1aqkrCrOLy9o2hZjNIudBZNi2t+wNAnQFMWE2WwWdtjtyjB42XMd/3wZ7xw808Frpbe3CkWSJr23sbOzw97eHrPposfzNpsNXdfw8OHDlyiJg7crC3O8yYy9te2HNdDHhD++vUFdP/oioZA86z0+RK87VpuK4xLuv/8quTYZgwC72A7BLeL1WZyzQcogCdHKtkyqdw76xa6wLkYDo0IXNfJOQ7Ga0cKAEOG3cbMO028EsvmEoqXARpANcsD2Bw/yZUw7RhdxHgiUtD0/VLj3aAx6g60iMwLixIjPc6C0DRWgbhQ9GGOEZtlDWeFaAle586KbkyaDpsn15+ydv1Z4FOeFPLu2tTx//pwXL05ZLBZYa5lN5yG5p3jnnXd47bXX+obfbVVvrYk+sPAy1+VmR5W/xKTygAUnSUxYD97mq9bXONr1cY6g2Gw2lOUGpRRVVTKZ5GRZzs0bt3u4Uimp7q2rauTNDuccn8cY07N1xs80So+MNZ0UYG1NEp6pQ2STI97tnMCPYTnI9fthA4mbRIRKCI6CDhCkwpPlOa6R93TO0dmWYpqRUtHZjqrtJOIKXPX++/pIPMTvzr80nyNMM+4j8arjC2Hc66bh+MU5682arpPByIqC/d3drax2ZJfM5zOms4lMOtxWh5l4vIytby/066+J9ysGEKVJ0qEPqe0se/t7TCdTrJOOP0+fPMe6x0iHnJr1ekPXbfddfBWso1Qy+n2sMx4ZO4Nn7v0YQ4+89+v8XdcbDJQZEJdrm9dwjjgBFRFW8r4Lib82YOqCmSsvFDDhsouujGhd6ODh+L6YJxpwbwcjF3cPETqyEfBCAUlcCF4ihc7a/nlqbQJUE8fO0rUd2vCSJEJcCKLxYfo+qeNS8kGmdmTY+zBGNsOhh5wY+HHbNuu2S9OHXTHkCIInLpCHChWMLhBgoncsrB0GmFiCnfBc5H4V46Knfi6MEozj6Gt4pnK0bcfpac3FxQWz2Yw7d+6wt7eH94r5fIfZbIcbN25zdXnJixcvWK0vifo+3imUCbkHoikO46cNREqkE+jN+6R/NnGctjakkfEdq6dG2GxYrzooUspzfPHilMlkxny26J2Hg4MjwFNVNZtyQ1VtXoIk5vO5NLQJjW2uJ4sHFpGi6xqado31LtCihZqa59KLFTNw3nvue3imRsvmIfMj4PBaipu6rqOzltxkmCQl1RrnFFYpUpOCmlCkmqumpu0sJujSRPZLhJJkk3dBNGzQcR+zZPretp9zfCGMe9d1nF9e4JwjyzKODoRBokaLNE0FUxQ8LSXSp6K2RjyuG3V58dqv1wx9kiRMiinz+QLnXOiENMUYQ9d11HXNaikdb9q2pW1baXfFNgz0qmQmbFdaDt6feGRRSGfclUjeu+1RRsMzTmQO5wlQSritAYKJ303/nbFCMXqASkUa3qh7p/JoZTCJJPvyPA/VcIHq2HXYRlqYeR0ppuE7dIIOCVGp0t2Omkz0dEcbn0L1VZfeOVz/wHzw1h3axEhnXPgxwGmSONtOsA0GxJEkg5fTb7oEauQro6IQfYRE/hge6eePj2+LUZmE0H1ry/HmEqgowzn84CVqFTpN6a1r7t87uqwINwzRmeqhyji/Ym+C9XpNnuccHR1x48aNHsacz+fcuHmTk5PnXFxcsFotJcoMUYoM68DsGuA7tfX79fHYjlKHMR026RixbjcvH69Hkf2oOD8/k0rsPBcJ6sWcNM0oihzrJCFblmXPJplMJv13jBkm8RqG5hgimZuoIMzmInwmmHh0IOW9Q6RStx0mSaR6NDhAURqZELV1nXRhatuWy7Ljk+fH3L55l2mWYzR4EpSqcc6SF0WvvzR2COP5hSnTEvNccXzHVfjf7fhCGPd4c4vFoodagL6HoTaKnR2R1Q0F4yG8G+CY8fFyeCheao9ia02WpezsitztbDYjy6RlX1VV0s5uueT84hJrO5pauiO5a+eRc7x83lfd3yvhFDXc+2cxXrwfiiR6rYvR+8QgDMYlfmbAiAnIytjTjdn32KGKkRGSJt5JQv96VW3C9fmwiSgUDpOmiAG0aB2SijoJ9i4scuXxthVDpwAd2w3EvpvBe0aHhizRe9bCIvGjrk3eYgLDxnvZiFSQYtURMXcBfumhHR+8ILkGoxLxULsO30cxAyVvoOfFQjWR3Y1jOsZunROKY+cie96hVQLehOTboBmyffj+uuImLNS2BGubEHolvSOgvcKra44E24n07XkjUaBzjnKz4eHDj3n69DH7+4fcuHGjr9Lc2T1gNtulrmsur664uDylaSqEq++l/iHMI0mWb7eai3Pt+sb3srMV1p+KDsgg87y9ZLbncds2WNux3qw5v5DWhtIUPglrOOsdsDG+Pu5vOvZ2JcFb0VUbklDh3HUWoxXamN6WxM0hzgfnHGkiqq3jVTyI1IEyWrRmFGw6S7VpePDoIf/kN3+Xg71d9vf3SE3OP/f9RxK94yDQTcfXPd6wnXck2pCYSLkUuIwIEb7a3PTHF8K4K625ceNGv2OO8dPpdMpiZ76lGx530/h7f3h6w9J/d/DMjU6l2i/QsJJUHlYsgLi4uOhxwBj2SQg6Nrrb170dog/n2/77y/8eX/B16Oaz3jvesF5179EQvIQ192wR9VJ4Kp9zYozU2GuMXO1hIY+79IARvBCBlpJk1GBZqcE770Py8Dfv6WJnm77xg8xU75xUvKqBqhYrgCPPXY3GV/X/N7rX0WvOu2u2wgcPy+K9ISLuA8Qx5oLHLxpW0PVxHTsVhggphU1t5Hxc33S3vd9Aww0SBs51DD1Oh+seGnSMGDYMVMbrBlXmrAtJdTlX27a8ePGC09NTptMpd+7cYf/gCG+k/dzR0RFHR0dcXl6w3qxZrZZbOaHrhn38c3x8luGPcODoSV0b6+1jHA3E9X5x0XB1ddm3v4sVpxGyjfBFxK8jTzzyx52zdK2QCcZ0Q22SProYIqNtgkaaJIGoMEQnRg8bgusjvFBIOdf83I++w3e+/YCnF0v2pgs25RUXzRydJLjRJhSvP/47niPPMkJqCecQ+AihXir4rt77F8K4xwcSB9cYabq8WCwoCmHCePxLAz5MaNWHvHqET00mUyaTosfgsjxjs15T1TXtstlqoDFMRAmJeyPnRQxrHO6Pj23oZHjtlZ76K47xgt/GdXlpIV0/98uJK176+/jfQ/f2oZWc9xodqlPH51MqyNz6SPeM51fBqwOvfOCdK1TvrYaNJiAkCvoOS85FZgB4pQaT6CyDls12mC9esgmbhxvgnDhemqE5s5JKS+ddz4rxbpump3BoLXx06XkZrllF2CDMASXdjaxTKC2Swz0WHvVqru3BAi/5EP3EKCd4vkr31a7iNIg3C7aHxaTQaeA8y/mMjI2P47hNa92eA0Dv0UfF0VFOJlz3anXFBx9cURSP2N3b5cbRDUk6Os/R0Q122l3qquLq6pKyKnt8O86nsVH5rKj0OvR53dG5Dt1cf//174k/rbWhA5gUAs1mM3Z2drbWSPxbH135Ad5ViLNnY4W0p2eXGa2xfnvTjEnUmJSN39n/Z2WeoCHL05Dsl/nv6g2v3dzlzfu32V1MOa0bqjhmI3s3OGyqh4oi/m6MRqsE6yxdZ0kzg/VO5DLs57vuXwjjHo+ozzCfz5lOp4OnwPYDHk8yUWOUXqN7e3tUVdXv1rHy8/LyCue7Hj9/FZQzPoa/9aDqZ77/s3D2z/v+V53vVZ/7rAUynsjXQ+KxZz/+jrjT9xM93N9Ivmt0PwP+KwUWjLBzMdBebXtXNiwohWCqMZkY+frRaI6jA6UDJBWesdDPh8KsYVEG7zp08Imt8KLmiwr/i9i4UtK1yzs1uqd4l66PJgTfiRvFiKcdNqWYCNTKBK96KF1nNP792HtwI/x7TKMUqq6YcJG7uF5hGCisDFGY9/G5juGLeJ3X4B6vQbsYP+A92A7RRFER5oo8b3lPVZXUzysuzs+Zz+fcun2X+XyOtZY8L7h1e0LXtazXazabzUudxK6P7fj16397lYF/1b+vv/+7Gfpx9ekr8yLh/fK+Tnok2w4/Uo303verQHlQI8q1c66nNkcPW+xOgE6stM70yuNCBBhb7p2dX5KgKdKc9WZF4xXeBIVYP0QAY3p3vO6u6/BOcljGd3RuSMCOC7E+7/hCGHcFvXTAfD6/loAcvHOBAAxJkjKdTMiLnK5rSdOUtumo6hLnHG3XsN40dG07ku6FsQEbZAKiMRtTueL5Vfjv1d7Jqybvqyd9dGXHxvPVnv126D4KWCMlSr886ePngFca9j6M1xrtPWBCEmkMVch9CzwwGEAxrHpIt/pQnIQYMu+C7AAenQqP2lZesHEV1fyicRqrBIZYMz4VNdAN41jGPIO3HVoJv10aFqR43xEVHT1i20ChdIom9JvVyEYQjKtcQdBRsQHvBpT3KAYIKBbJ9AMQ3QstnP0Idyi1TWeNHvbw0CJTJ8FagV1MX44b/44IzXl5Soo4N8NC9xaUibtNHz3pIE7XJ9iV7yOnSBv2IeESjUG8zi5ELCpAWNa2nJ+fcbVaMpvOODw8YjqbolRKYlKODm/Q7rS0XRf6rYZG8qP5ev34LKN83Yi96vXPilCvfw7ouyVFr3osBAYDrBM3JWmm02KdE5VWG6K/PmoUZ4E4Z70OzVj81sYWX3PeYfFkaRaeqMc6h+taTi6u0CQcJimbaoXaPUQHYoLRqvfek6Bk6lyYT0bYakmW4p2naWtMlpJmKc5239U5jccXwrhro/tsPgyTIcrqRhbNuGPKbDYHRegi1IioVuCVv1TMpMCPF6GcBTG4IwmnPlQMH7tGobuOOY6Pz4NHZHMYSsGjxMGrJuvY++g/4Me/v3zOl883fn3gZI/xXh8gmehIevyoY0zUjJb4UuyJCaF+sF6R84xFmkt7TJ5gQ+LZ9Bhm9BY1AyPIEatYRWZhuNWXPVXCNTqIXqgPEEbcmAGPgcA11iZBG/HwpW5nKHjxsbMSCqVENM57j5SyD97tcC0D1j1ALPQb0ZYCpYuGYaD9RZPtY+5AJcQmIFtzxvs+8hief9ztIje7C0U1kdIad5IohBZorH6IbLcjPiESxCTkMNZyX8611M2Gx08eSRObnT2mU2n0Ls3jYXd3j6KYSNOOqqSuS77bPHxpTsfxuhZ9ftZG8VnR8Pi98bnFLmwxkRqTrTECBNkQDKETku16qoXrYgN1D8FDVii8HnRfeugn1GkYY6QhdsgJ6jjeOmXv7lt0naKzS7rViuniAO9jolcFCxQpsEO7Te+9kOgi2cJoUqPFCRmhFv+LwNyTJO0z+DGEWiykC4z3kvwoioKLiwtOTk7w3nN1ddVzzoPb87nHOBqQI+CZRNre9sQbf+7zJtXneRUR1nnFfO2v5VXY4zb27cMaj5l589L7X1oUW2wRiKqXymvwEsV47wVf7COJoYnAsOAJ3okNyUwvBTko8JLpV9GIExQFldAdtdaonvExSD0oJUqL4vUGOCWeq9dej89kgHC0jno1MdnLyEv2ogGDkt5yEVdBYyJnOYyfMBJjJKOIFVNxsUZ1y3GCeejHG3VsbP9dMdrRSoUNIkIvMLCYBiO3Pf/Cu0cbCCpCYcInN7FC0g1jCINH2q/vfvPy/XVIlCM7kcgKZEJMUNLRTDab8F0yQwJ+rADHxeUFq9WKYlIwKSYUkwJjNHmekecZi505eCEjrNarrdqA6xHkZ0Em119/+W/D+G0fqh+H8TGu7I3XMSRUBSLUKm58GpsYtDGo4PzZoAPU9aQFR9sJth5hEY+wa3yYV2N8fwwRtZ0w7YpZwcrkTEyKx4tEd6h21yZWvfuwEQ0NP5z3aGMoQjI3zrM4Jz/TsITjC2HcsyzjjTfekLZ26zWzmSjgtW3LkydP+i4vg5Lc+KGO3b7hO19tbF/2zl91fNZn5XOvZgi86nOD53+dvvjqc46PWKE39haHkuSXr2/bSwphfh+nA2jxvnUnXrcChSgiXk9GxU4vMfQXT5T/b3vnGmtJVtXx39pV59w73dN2T88roxAZwoQE/QCERIjGEFFeIRATQoaQCIjB+Eh8fNCZkJj4DdQYMTE84iNgkIcISiYaoogfHQVUHIGWQZ4TmOmZ6b797nOqavlhrbX3rnPv7QfpmXPvTa3O7VOnqk7Vfq691n+vB7WGEwYd2SywitjYNo3FwViaqWCYNPovqnaEOpFykUTBmF0dt0Q8ScIYugmsO4JIFcDDLHlUyxxQtWVh0IBdLMxq8cQsfZHHV3hqii0Kw2CaRvKJ6bfYZqe6aWbguFLKUpctpO3SDkoJluXrE4JgG8mWtGQ7vhrQkMZComWzN0Iz23Nsr0LC5M8bJbx7G4f6GhFfpCQHaBuGngsXzluijguWmu7w4cPu+7DBxQuXueWW4xw+bKEEts6csjwDOwkdMQJ2EJhKfXZi/iUejF0qbGsUVgAyBh8wSiyKObJin1gultD3qHYs3cqlESzufgpvbuvboTNcv9eBZdeTkj13NmvRZCMnMt6tCn3HbzuOoFy+eInmyB30qaFNlnwItSic/dBVGDq5Drav42aPQt62MhzeTC77q2TruCpzF5HnAh+tTj0b+B3gg37+WcA3gDeo6imxGr4bS7V3AXiLqn7hSu8YhoHHH7e4zG3bsrW1xRNPPMFisRhFM9yOaWugoVh7bVcDV6Xq+p5VyKX+7Q7tsO3c6iDcznAhmHFOP7fyzN1wxhGWm5lF5BXdvriMniGVT6MfDH0HmNRuGGVH25Bt50MKNMYwNrWUJDkJtEne43jS4oNuJGU7ozHYpXf782hvc46qtZbcjVL3idsal9MUq6kIPxDWTKbBdd3C4tFQQusOA+iQykKnxjhjc7W0Z3G4QW2D02KHmIbRZ7v0SJU4lOxFsYb6pA21YhjCooiqXtFfAA19ZwmvswYpPptl8E3aeoz7s0aqi1uT5UbyZ+vgVkk9s2Y2kmgtMFvZtO773pl6kxf8aI8o9+XLl1ksFpw5c4abb745u/u3betYdk87u42u67h44SIXL11kuSzxhEodtptSrmqwY8w+cPQQdMaLY53xbNVfJJi9bb46Jt/MaFKT0xcikseVDqY5DeqLkGA5etuW1heJspHbkXNC+ACu7eNTGugWHUkSbQ05V4tsqjREQdwZqmc2CyMBs+oakF0Xxd3oWhJknwCe743VAI8AnwTuAz6jqu8Ukfv8+28DrwLu8b8fA97jn7tS13U5k8puhQ+1pypXHI06ezeKwVQ30G5McnVwXY3hb1soXBXOkIVYXtWwTR4hKLuUBcZmZqVZyrvq+Cf1cR0tD5c2B1V6XRiU5dDK0Pc0qSWytIejUgQ3KxPcHIUiFvp2WCpgC4dSsFSJXW8MtzZVLPWO2vh3QNxu2OAY8yCMnwyjsRFagmtBnkJQXdrvOttL0eTS+aCoR6KU1hYvRS2dGoAkVyBM+k2NeKwef0/sV2DhD/q+Y+iL1Yxh/ck1nHJ/OAMxgKEd2wWIYejoemWjmWOB3wZ67UjSIG7yRqXRqMLQJ/DFQJEcgArH3G1/wze9hw5EaJrNLBEWCxPNcYcstIS1ReC+AXGszsm+7zl9+jRbW1tsbGxw7OgxZrONLJAcPnQz89kGz3nOPZw5e5pHH32U8+fPj0yOrwTNlDEScyrqtR3iHGVw8+/FhNbqcunSpWITnxI0LUkH2mZwr2aYz2YZARoUVAYuLS7nvYl5xRPKPktkSKuc2rSMlaHrUO0ZtGd2U1MinSaDxvpuuSLkQPIQIl3X2cJZbRDHs4dhyGEWrkTXC8u8DPiaqn5TRF4HvNTPfwD4F4y5vw74oFrP/KuIHBORu1T1u7s/tmRhskYbuzCvSuw7DYxti4IylmDZfRDln+wwsOrfrd67ncmFaaGYGV6KSenvqyCQ1WfW6mNd5zpQ1Gp5dmqvnZ4ZEoyqSziuujdimaNq6KOWvON3UDbnysBO5Vnuvp37iGJ5ENEcAyeSNOQkEBGLJZxDGAoMVawehHDFNqcmtzKoNsjMky+ZRVGKtrHNVFtwYmPRNn8tumUwYlzSDY9ak8RSg2kbQ+iGEYs9Ftw6xs8YWirChi94KWCfYqUVjCDqW4/GqJ+FYnCIQD0oQ9asoo1tE7BIrOHx3BDRPUPbqsdIsdAoYySk4LivjtGyOg/j8+IFCxcwm805dOgmjh+/heXS/Ecee+wxbr31OD/6I3dy7tw5HnnkEbbOnM7RKVc5df3skZClcc7bx/tUh4HlsqPr+sqCSUaMtmysLklpjkFNtjkdHudD14EzXjOd6UmUsL5hcRfPXWXyq+ejD21cKxa7abtWUseHKTCshMUv/RDhsk2bSlIsn64W7heun7nfC3zYj++sGPb3gDv9+IeAb1e/+Y6f252566q6OmbmYxWtxGW2ib6b/WyqgCqorTKCroXJ78aM477RdS0wSqzexZunSF+r9SnMV7cNkp3Ksqp+1s+pJ2q9CNThhSVUvMHsu2P3PspRBm+EPB2X2TaVitmfJGFYLkkaXoKCaEvbzlkuIwKhB9ZCSA0ugXhfE7bzg5tqQixm6mNjcHV5Y8MgGNu09MUoypYXGM2/jyQkWQjAFqRg6HbGsU23yR8Gl64aNxMdxKyCKgsXzb8P6whPigz4rmyl0RRmb0ynL2NEEinFPpLDVV6qpm3QHnOMUqXvQ4KlLEhEZMqUoaqa+aTGmMW4X8vYCSaxOudqqoWi8fgsEnXfLzl7dsGlS+eZzzeYzzdp2xnnz19gsVjSti133HEHR44cYWtri3PnzpllS7Je2Wl+lfkpDnsFRhTvblhcXnL4sGatYDabjWCa0CgXi0uOpbek1NAtPPyxb1xeXiyZzeckcQco18CsX4p/Q71grLZfjf2boYAZiwxDzyw1HqXTTCWlmtezpmU5dHlnTpJBhr6u0XnguiQGj+6GJKzSNTN3EZkDrwXuX72mqip1frlre97bgbeDxZTZHjPlyh0eUuZOkryIZAeW6pdlYubv9plfo1ngX3ln2ezaXrbye/ENFvtvGJWzlHG7lG3qfQXpKCMpGbZrCqt45XY4KcpVJOemaf1KA9pbvBK1wdbkgSlYsK6oryUG9lp4mjzAg12ZBY5a0gw1J5q2nSGaWC5Dqon47JrbXcSlFW8uY/JCmFsWaCmB9DQDhoUOQmpCOvUsUtkSiszgQ1MadFmeY8qySbXLwVOm4ROmh1hs1KQu+9ca7CNloVnVdHSQrI04OIRQOyEFYy/1L9oRuS51SGKzPBFSDrkc8F6EUraNZInFoFpIbOy4w0sTkT3TtvECxU48mGh9zyocEOcLg/e+TIkwmTWv747z5y+yXHTcfvtt+bebm5uoamb0Z8+e5czZM1y6dMHLUObDCL4Jqyn1eiTTqACHGWE2m7sWM2SHo2DCs9mMixfPuxBj7da0M9AB+h76nsvdksEThzeOtUc5wtJmVZMN2Kcs+AbbhfmlELFp1OI4NZZcppESKiFiyOBaeuYSsRCL2GLgWuagZrlj+PyNc2J6FfAFVX3Uvz8acIuI3AU85ucfAZ5Z/e4Zfm5Eqvp+4P0Ad955p2vHV7Zz3SY5eOcnj71h9+1sVRBu9NukbcjMNJjyuAhhF60wWr/EJccC/RSzxZ1x+520hCJdm5RZ4Jviql9THaJgVVJffaZIkSgAmmaOqlm2NG1yu3Z/RtNUq5qSmuROFYnGg3qllNBUTDTt00z1ln3YBatlm1EzebTEF7FoJA8XMJilfywo2tN3Ae1E+Rss1LCZ6InOgIW/syWlsE9PLPuB+axF8n4B2aJAnYHXWpSqGjzUuZ0xtsFKKqZ0aEQMdGlYpVpEAiJwZyJJOQaI5nFibWTjzvcEMvMSwgKkmEEObtYoNGqxRxigV0uiIinczX0u+HMbIcMLKYUmkJjNCoQlqSWslGK81PGJshChoY2JL9jbx24IHfF98NAJxcKqJMo4e26Lc+fPkFLi6A8c44477syhQTY3Nzly5AjHLhzj5MmTZjd/8eLIx0AqBhsLomnESgm9CZcuLpjPZ0jSjEfXi9ls1nLu3JLlsmU220CHRC9zmtTZ2B4UaVoUD6XrfCQ83a0MMUcdMlnB9pMbHJQNfhi0J7nE3XULVBKXFpeZzeZZIw6NKqeL1BK4LIsJHq6gGCpQaam70/Uw9zdSIBmATwFvBt7pn39Xnf9VEfkItpG6pVfE241WrV4KBFGY1HYJHcczpWS9kcRqWNydIB4JETt04Oq5TVMNKPFMOWIT2YaWr9Ru56oOR1BpE7UqHnVYZfj+Rl+1V+EWkwi1gh2sHia94ZuO4nWoM9tnVTYkMS1Y5GrI0HE72We5Rh5Uksaqp0gct46hejiIZPb0CUvXZtJqn8vGCKYIZm6exwOxeFl9Sj+0rkl0ua8Hr2dqBhhl4aosh1xzGQZj4eMNKB8H3k7DMDgO3Xtc+5jUdVTK8TiB2NCLfQuNriuWK1lrizFdhJQoQ/bE1QIB1BBKSP8+vFwb6gmmmsd9XnBSHseQvA+F8fi3z9p0UKM9aqFlB4W8zE9/jqp73tZzrQhTfd/z5JOnOH16i0OHDnH06FGOHTvGoUOHOHz4MJubmzz55JNZ6t7a2nIP2NKnTWN6TBZ+tGg6i8WC2WyW937m89kob3CM1ZyesWkss1TXk8TGaTNUZoVChi6jr4IZ26Zo4UfFazUsZ0xTMC3chkzbWhTItmmyQAVjG/1aYKvnaSyY+EIXG7x1W+9G18TcReQw8DPAL1an3wl8TETeBnwTeIOf/3vMDPJhzBTyrdfyDsKphMASSwVqBl9LDYot4LbCA7h0s812elQX+0yFq4eNsG1kVDGsg9k1PpgHzyuZy5bcLjgk/2KHHgx1CDvpDBkM4zp4/8bkiwFr9RWHa6Iu5LJJSI2QVdQoV83UA04QktkzD+bNGBYW0ab53aZDVczBaDV8avbyTGXjN6AAGRpEGregABVBPJ65qhocJMKgQusR+dDehbHARcUlxxa0M1V6aJ3xDxY3JbejZikqsOcIfAbmtFJ7G3sLMXif2vyM5MTBqAIfj5FmJomDwwTxvHqjTNWTYXv+zbI3FH2Tcp+l1CJqsUNorG/AMNw65+cYC8dzxnbQeIAxyv6H7ZEUL+BhUJrW+js0rdV5UI7LnMuClQ++PGd8E1l83OAMjDwHTOBRNI/bWpYZhoGzZ89y7tw5Tp48mZn8cmlJbo4cOZLfHx7ncS0Em+Q+EyHcGYPtsqCXUkuEX4i/vu+YzzfsmZcvcejQEUiJZd+zXF7OfRV7O9b/ZWM2pTaXwYSAwuiLZZG1dw6ypqYV9n0H/eAagWkRfV8LSWNv5YgUGdYyNn7duWxwKE4sMcjC792Nrom5q+p54NaVc09g1jOr9yrwK9fy3JpGUImGk8mVzRzzICOkoTDzGz93p3cV+Tuk6pTV0FhQzAohBlH57WqgIvLkjWdLlqDrRSreVWOWo2fUh359J7glv6dqs1Wrh3gXhMVEmJIVq5zS7gKaaJuiNUjFKOK+8l3MvyK0p8zsvZ0UpDHbXgVYWDwXnGEM6vh8hZWHdtI0QtvO7CEJs0+Pjay+9TayCH7DYJuwQjdi3mFOGYu9TfqhmsAFkgjeXdotPESLhjM2cROHrBSD0RJJbM9iuYzNtgJTjMddSMiNZ/TxOP3tLG+aRrC7kDrHVi6hBSUkYhUly/8aEMZsNsvMPRaGWktYnQ/jZ4/9JWrYL495ZHQ9KGP2qbEcrVL5ALjApn3slSQWiwUnT57k1KlTHD16lNtvv51hGDh16hSqZWN0c3OT5XLpDox9EYpGWq5J75s3bRD7GLWGKtJw0003mWawXDJbWjyk2cYGC/Uoqb6ZrX3RSnZqJwsRPiser34tMpPleDFNC73BKn0/0GnHbHOey1T3b3wPiT0gnxBYgtFH3bPvz3BlzF2uJto/HSQiZ4ET6y7HDabbgMfXXYgbSFN99jYdtPrAwavTU1GfH1bV23e6sCfCDwAnVPVF6y7EjSQR+dxBqtNUn71NB60+cPDq9HTXJ139lokmmmiiifYbTcx9ookmmugA0l5h7u9fdwGeAjpodZrqs7fpoNUHDl6dntb67IkN1YkmmmiiiW4s7RXJfaKJJppoohtIa2fuIvJKETkhIg+LhQ7e8yQizxSRz4rIl0Tkf0Tk1/z8cRH5RxH5qn/e4udFRP7Y6/hFEXnhemuwM4lIIyL/ISIP+Pe7ReRBL/dHxeILISIb/v1hv/6stRZ8BxKLRvpxEfmKiHxZRF5yAPrnN3y8PSQiHxaRzf3URyLy5yLymIg8VJ277j4RkTf7/V8VkTevoy5VWXaq0+/7uPuiiHxSRI5V1+73Op0QkVdU5288HwynhXX8YXnuvoYlAJkD/wU8b51lusZy3wW80I+PAP8LPA/4PeA+P38f8C4/fjXwD5hLx4uBB9ddh13q9ZvAXwEP+PePAff68XuBX/LjXwbe68f3Ah9dd9l3qMsHgF/w4zlwbD/3DxZZ9evATVXfvGU/9RHwk8ALgYeqc9fVJ8Bx4P/88xY/vmWP1enlQOvH76rq9DzncRvA3c77mqeKD667s18CfLr6fj9w/7oH4fdRj7/DwjOcAO7yc3dh9vsA7wPeWN2f79srf1iAt88APwU84JPq8WqQ5r4CPg28xI9bv0/WXYeqLkedEcrK+f3cPxFK+7i3+QPAK/ZbH2GZ22pGeF19gsW4el91fnTfXqjTyrWfBT7kxyP+Fn30VPHBdcMyu8V+3zfk6u4LgAe5/hj3e4n+CPgtSrSmW4HTqhpZAeoy5/r49S1WwlOsme4GTgJ/4TDTn4rFR9q3/aOqjwB/AHwLy42wBXye/dtHQdfbJ3u+r1bo5zENBJ7mOq2bue9rEpGbgb8Bfl1Vz9TX1JbgfWGKJCKvAR5T1c+vuyw3iFpMVX6Pqr4AOI+p/Jn2U/8AOBb9Omzh+kHgMPDKtRbqBtN+65OrkYi8Awtl+qF1vH/dzP2aYr/vRRKRGcbYP6Sqn/DTj4rFtke+jxj3a6QfB14rIt8APoJBM+8GjolIhKioy5zr49ePAk88nQW+Cn0H+I6qPujfP44x+/3aPwA/DXxdVU+q6hL4BNZv+7WPgq63T/ZDXyEibwFeA7zJFy14muu0bub+78A9vuM/xzZ+PrXmMl2VRESAPwO+rKp/WF2KGPewPcb9z7kFwIu5xhj3Txep6v2q+gxVfRbWB/+sqm8CPgu83m9brU/U8/V+/56RuFT1e8C3ReS5fuplwJfYp/3j9C3gxSJyyMdf1Glf9lFF19snnwZeLiK3uDbzcj+3Z0hEXolBnK9V1QvVpU8B97ol093APcC/8VTxwXVuRPhYezVmbfI14B3rLs81lvknMPXxi8B/+t+rMUzzM8BXgX8Cjvv9AvyJ1/G/gRetuw5XqNtLKdYyz/bB9zDw18CGn9/07w/79Wevu9w71OP5wOe8j/4Ws6zY1/0D/C7wFeAh4C8xq4t900dYsp/vAktMu3rb99MnGI79sP+9dQ/W6WEMQw/e8N7q/nd4nU4Ar6rO33A+OHmoTjTRRBMdQFo3LDPRRBNNNNFTQBNzn2iiiSY6gDQx94kmmmiiA0gTc59oookmOoA0MfeJJppoogNIE3OfaKKJJjqANDH3iSaaaKIDSBNzn2iiiSY6gPT/mckgxVvYAQEAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='object_id', ctx=Load()), ops=[In()], comparators=[Name(id='id_array', ctx=Load())]))])\n", - "Worlds Table created successfully........\n", - "New world inserted successfully........\n", - "Camera Table created successfully........\n", - "New camera inserted successfully.........\n", - "Module(body=[Return(value=Compare(left=Call(func=Name(id='Tmin', ctx=Load()), args=[Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load())], keywords=[]), ops=[GtE()], comparators=[Name(id='start', ctx=Load())]))])\n", - "Module(body=[Return(value=Compare(left=Call(func=Name(id='Tmax', ctx=Load()), args=[Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load())], keywords=[]), ops=[Lt()], comparators=[Name(id='end', ctx=Load())]))])\n", - "Xmin(General_Bbox.trajBbox)\n", - "Ymin(General_Bbox.trajBbox)\n", - "Zmin(General_Bbox.trajBbox)\n", - "Xmax(General_Bbox.trajBbox)\n", - "Ymax(General_Bbox.trajBbox)\n", - "Zmax(General_Bbox.trajBbox)\n", - "Tmin(General_Bbox.trajBbox)\n", - "SELECT Item_General_Trajectory.itemId, Xmin(General_Bbox.trajBbox), Ymin(General_Bbox.trajBbox), Zmin(General_Bbox.trajBbox), Xmax(General_Bbox.trajBbox), Ymax(General_Bbox.trajBbox), Zmax(General_Bbox.trajBbox), Tmin(General_Bbox.trajBbox) From Item_General_Trajectory INNER JOIN General_Bbox USING(itemId) Where Item_General_Trajectory.itemId IN ('car-1','car-12','car-15','car-17','car-2') AND Tmin(General_Bbox.trajBbox)>='0001-01-01 00:00:00' AND Tmax(General_Bbox.trajBbox)<'9999-12-31 23:59:59.999999';\n", - "\n", - "(121, 4)\n", - "(121, 4)\n", - "(13, 4)\n", - "(100, 4)\n", - "(66, 4)\n", - "output video files ./output/traffic_scene_cam1car-1.mp4,./output/traffic_scene_cam1car-2.mp4,./output/traffic_scene_cam1car-12.mp4,./output/traffic_scene_cam1car-15.mp4,./output/traffic_scene_cam1car-17.mp4\n" - ] - } - ], - "source": [ - "### Example Test Query\n", - "filtered_world = scenic_world.predicate(lambda obj:obj.object_type == \"car\")\n", - "filtered_world.get_trajectory().execute()" - ] - }, { "cell_type": "code", "execution_count": null, From 8fe4383e3a67a322a978f30157714e899cfa0c1e Mon Sep 17 00:00:00 2001 From: YongmingFrankGe Date: Wed, 16 Feb 2022 13:21:49 -0800 Subject: [PATCH 07/26] fix front end metadata view for scenic tables, query for trajectories and geo info works fine as prototyppe --- apperception/scenic_util.py | 40 ++++-- apperception/scenic_world.py | 25 ++-- apperception/scenic_world_executer.py | 6 +- apperception_example.ipynb | 162 ++++++++++++------------ scenic_test.ipynb | 175 +++++++++++++++++++------- 5 files changed, 258 insertions(+), 150 deletions(-) diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py index f6a0b763..76f017a4 100644 --- a/apperception/scenic_util.py +++ b/apperception/scenic_util.py @@ -63,7 +63,8 @@ def create_or_insert_scenic_camera_table(conn, world_name, camera): #Doping Cameras table if already exists. cursor.execute("DROP TABLE IF EXISTS Scenic_Cameras") # Formal_Scenic_cameras table stands for the formal table which won't be erased - sql = '''CREATE TABLE IF NOT EXISTS Formal_Scenic_Cameras( + # Test for now + sql = '''CREATE TABLE IF NOT EXISTS Test_Scenic_Cameras( cameraId TEXT, worldId TEXT, frameId TEXT, @@ -86,7 +87,7 @@ def insert_scenic_camera(conn, world_name, camera_config): #Creating a cursor object using the cursor() method cursor = conn.cursor() for config in camera_config: - cursor.execute('''INSERT INTO Formal_Scenic_Cameras ( + cursor.execute('''INSERT INTO Test_Scenic_Cameras ( cameraId, worldId, frameId, @@ -286,7 +287,8 @@ def create_or_insert_scenic_general_trajectory(conn, item_id, object_type, frame ''' # Formal_Scenic_Item_General_Trajectory table stands for the formal table which won't be erased - create_itemtraj_sql ='''CREATE TABLE IF NOT EXISTS Formal_Scenic_Item_General_Trajectory( + # Test for now + create_itemtraj_sql ='''CREATE TABLE IF NOT EXISTS Test_Scenic_Item_General_Trajectory( itemId TEXT, objectType TEXT, frameId TEXT, @@ -296,18 +298,19 @@ def create_or_insert_scenic_general_trajectory(conn, item_id, object_type, frame PRIMARY KEY (itemId) );''' cursor.execute(create_itemtraj_sql) - cursor.execute("CREATE INDEX IF NOT EXISTS traj_idx ON Formal_Scenic_Item_General_Trajectory USING GiST(trajCentroids);") + cursor.execute("CREATE INDEX IF NOT EXISTS traj_idx ON Test_Scenic_Item_General_Trajectory USING GiST(trajCentroids);") conn.commit() # Formal_Scenic_General_Bbox table stands for the formal table which won't be erased - create_bboxes_sql ='''CREATE TABLE IF NOT EXISTS Formal_Scenic_General_Bbox( + # Test for now + create_bboxes_sql ='''CREATE TABLE IF NOT EXISTS Test_Scenic_General_Bbox( itemId TEXT, trajBbox stbox, FOREIGN KEY(itemId) - REFERENCES Formal_Scenic_Item_General_Trajectory(itemId) + REFERENCES Test_Scenic_Item_General_Trajectory(itemId) );''' cursor.execute(create_bboxes_sql) - cursor.execute("CREATE INDEX IF NOT EXISTS item_idx ON Formal_Scenic_General_Bbox(itemId);") - cursor.execute("CREATE INDEX IF NOT EXISTS traj_bbox_idx ON Formal_Scenic_General_Bbox USING GiST(trajBbox);") + cursor.execute("CREATE INDEX IF NOT EXISTS item_idx ON Test_Scenic_General_Bbox(itemId);") + cursor.execute("CREATE INDEX IF NOT EXISTS traj_bbox_idx ON Test_Scenic_General_Bbox USING GiST(trajBbox);") conn.commit() #Insert the trajectory of the first item insert_scenic_general_trajectory(conn, item_id, object_type, frame_id, color, postgres_timestamps, bboxes, pairs) @@ -319,10 +322,10 @@ def insert_scenic_general_trajectory(conn, item_id, object_type, frame_id, color cursor = conn.cursor() #Inserting bboxes into Bbox table insert_bbox_trajectory = "" - insert_format = "INSERT INTO Formal_Scenic_General_Bbox (itemId, trajBbox) "+ \ + insert_format = "INSERT INTO Test_Scenic_General_Bbox (itemId, trajBbox) "+ \ "VALUES (\'%s\'," % (item_id) # Insert the item_trajectory separately - insert_trajectory = "INSERT INTO Formal_Scenic_Item_General_Trajectory (itemId, objectType, frameId, color, trajCentroids, largestBbox) "+ \ + insert_trajectory = "INSERT INTO Test_Scenic_Item_General_Trajectory (itemId, objectType, frameId, color, trajCentroids, largestBbox) "+ \ "VALUES (\'%s\', \'%s\', \'%s\', \'%s\', " % (item_id, object_type, frame_id, color) traj_centroids = "\'{" min_ltx, min_lty, min_ltz, max_brx, max_bry, max_brz = float('inf'), float('inf'), float('inf'), float('-inf'), float('-inf'), float('-inf') @@ -353,9 +356,22 @@ def insert_scenic_general_trajectory(conn, item_id, object_type, frame_id, color cursor.execute(insert_bbox_trajectory) # Commit your changes in the database conn.commit() + +def fetch_camera(conn, scene_name, frame_num): + ### TODO: Fix fetch camera that given a scene_name and frame_num, return the corresponding camera metadata + cursor = conn.cursor() + + if cam_id == []: + query = '''SELECT cameraId, ratio, ST_X(origin), ST_Y(origin), ST_Z(origin), ST_X(focalpoints), ST_Y(focalpoints), fov, skev_factor ''' \ + + '''FROM Cameras WHERE worldId = \'%s\';''' %world_id + else: + query = '''SELECT cameraId, ratio, ST_X(origin), ST_Y(origin), ST_Z(origin), ST_X(focalpoints), ST_Y(focalpoints), fov, skev_factor ''' \ + + '''FROM Cameras WHERE cameraId IN (\'%s\') AND worldId = \'%s\';''' %(','.join(cam_id), world_id) + cursor.execute(query) + return cursor.fetchall() def clean_scenic_tables(conn): cursor = conn.cursor() - cursor.execute("DROP TABLE IF EXISTS scenic_General_Bbox;") - cursor.execute("DROP TABLE IF EXISTS scenic_Item_General_Trajectory;") + cursor.execute("DROP TABLE IF EXISTS test_scenic_General_Bbox;") + cursor.execute("DROP TABLE IF EXISTS test_scenic_Item_General_Trajectory;") conn.commit() \ No newline at end of file diff --git a/apperception/scenic_world.py b/apperception/scenic_world.py index e56419c5..b581d88f 100644 --- a/apperception/scenic_world.py +++ b/apperception/scenic_world.py @@ -7,7 +7,7 @@ import matplotlib.pyplot as plt BASE_VOLUME_QUERY_TEXT = "stbox \'STBOX Z(({x1}, {y1}, {z1}),({x2}, {y2}, {z2}))\'" -world_executor = ScenicWorldExecutor() +scenic_world_executor = ScenicWorldExecutor() class ScenicWorld: def __init__(self, name, units, enable_tasm=False): @@ -18,13 +18,13 @@ def __init__(self, name, units, enable_tasm=False): self.enable_tasm = enable_tasm # self.AccessedVideoContext = False - def get_camera(self, cam_id=[]): + def get_camera(self, scene_name, frame_num): # Change depending if you're on docker or not if self.enable_tasm: - world_executor.connect_db(port=5432, user="docker", password="docker", database_name="mobilitydb") + scenic_world_executor.connect_db(port=5432, user="docker", password="docker", database_name="mobilitydb") else: - world_executor.connect_db(user="docker", password="docker", database_name="mobilitydb") - return world_executor.get_camera(cam_id) + scenic_world_executor.connect_db(user="docker", password="docker", database_name="mobilitydb") + return scenic_world_executor.get_camera(scene_name, frame_num) ######################### ### Video Context #### @@ -116,15 +116,15 @@ def interval(self, time_interval): return new_context def execute(self): - world_executor.create_world(self) + scenic_world_executor.create_world(self) if self.enable_tasm: - world_executor.enable_tasm() + scenic_world_executor.enable_tasm() print("successfully enable tasm during execution time") # Change depending if you're on docker or not - world_executor.connect_db(port=5432, user="docker", password="docker", database_name="mobilitydb") + scenic_world_executor.connect_db(port=5432, user="docker", password="docker", database_name="mobilitydb") else: - world_executor.connect_db(user="docker", password="docker", database_name="mobilitydb") - return world_executor.execute() + scenic_world_executor.connect_db(user="docker", password="docker", database_name="mobilitydb") + return scenic_world_executor.execute() def select_intersection_of_interest_or_use_default(self, cam_id, default=True): print(self.VideoContext.camera_nodes) @@ -152,9 +152,8 @@ def select_intersection_of_interest_or_use_default(self, cam_id, default=True): x2, y2, z2 = br return BASE_VOLUME_QUERY_TEXT.format(x1=x1, y1=y1, z1=0, x2=x2, y2=y2, z2=2) - def overlay_trajectory(self, cam_id, trajectory): - camera = self.VideoContext.get_camera(cam_id) - video_file = camera.video_file + def scenic_overlay_trajectory(self, scene_name, trajectory): + camera = self.get_camera(scene_name, frame_num) for traj in trajectory: current_trajectory = np.asarray(traj[0]) frame_points = camera.lens.world_to_pixels(current_trajectory.T).T diff --git a/apperception/scenic_world_executer.py b/apperception/scenic_world_executer.py index b3596808..9c20a353 100644 --- a/apperception/scenic_world_executer.py +++ b/apperception/scenic_world_executer.py @@ -1,7 +1,7 @@ from metadata_context_executor import * from metadata_context import * from scenic_video_context_executor import * -from video_util import * +from scenic_util import * import numpy as np class ScenicWorldExecutor: @@ -28,9 +28,9 @@ def enable_tasm(self): if not self.tasm: self.tasm = tasm.TASM() - def get_camera(self, cam_id = []): + def get_camera(self, scene_name, frame_num): assert self.curr_world, self.conn - cameras = fetch_camera(self.conn, self.curr_world.get_name(), cam_id) + cameras = fetch_camera(self.conn, scene_name, frame_num) ### each camera appear like: ### (cameraId, ratio, origin3d, focalpoints2d, fov, skev_factor) diff --git a/apperception_example.ipynb b/apperception_example.ipynb index f13e538e..12dae4be 100644 --- a/apperception_example.ipynb +++ b/apperception_example.ipynb @@ -3,11 +3,26 @@ { "cell_type": "code", "execution_count": 1, - "metadata": {}, + "source": [ + "import os\n", + "import sys\n", + "sys.path.append(os.path.join(os.getcwd(),\"apperception\"))\n", + "\n", + "### IMPORTS\n", + "import cv2\n", + "\n", + "from world import *\n", + "from world_executor import *\n", + "from video_util import *\n", + "from metadata_util import *\n", + "import lens\n", + "import point\n", + "\n" + ], "outputs": [ { - "name": "stderr", "output_type": "stream", + "name": "stderr", "text": [ "In /home/yongming/.local/lib/python3.6/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n", "The text.latex.preview rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n", @@ -27,28 +42,11 @@ ] } ], - "source": [ - "import os\n", - "import sys\n", - "sys.path.append(os.path.join(os.getcwd(),\"apperception\"))\n", - "\n", - "### IMPORTS\n", - "import cv2\n", - "\n", - "from world import *\n", - "from world_executor import *\n", - "from video_util import *\n", - "from metadata_util import *\n", - "import lens\n", - "import point\n", - "\n" - ] + "metadata": {} }, { "cell_type": "code", "execution_count": 2, - "metadata": {}, - "outputs": [], "source": [ "### Let's define some attribute for constructing the world first\n", "name = 'traffic_scene' # world name\n", @@ -66,26 +64,26 @@ " 'type':'pos'}\n", "camera_attrs = {'ratio': 0.5}\n", "fps = 30\n" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "code", "execution_count": 3, - "metadata": {}, - "outputs": [], "source": [ "### First we define a world\n", "traffic_world = World(name=name, units=units)\n", "\n", "### Use TASM if it's available on the machine\n", "# traffic_world = World(name=name, units=units, enable_tasm=True)" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "code", "execution_count": 4, - "metadata": {}, - "outputs": [], "source": [ "### Secondly we construct the camera\n", "fov, res, cam_origin, skew_factor = lens_attrs['fov'], [1280, 720], lens_attrs['cam_origin'], lens_attrs['skew_factor']\n", @@ -95,13 +93,13 @@ "location = point.Point(pt_id, cam_id, x, y, z, time, pt_type)\n", "\n", "ratio = camera_attrs['ratio']" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "code", "execution_count": 5, - "metadata": {}, - "outputs": [], "source": [ "### Ingest the camera to the world\n", "traffic_world = traffic_world.camera(cam_id=cam_id, \n", @@ -110,16 +108,22 @@ " video_file=video_file, \n", " metadata_identifier=name+\"_\"+cam_id, \n", " lens=cam_lens)" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "code", "execution_count": 6, - "metadata": {}, + "source": [ + "### Call execute on the world to run the detection algorithm and save the real data to the database\n", + "recognized_world = traffic_world.recognize(cam_id)\n", + "recognized_world.execute()" + ], "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "Worlds Table created successfully........\n", "New world inserted successfully........\n", @@ -145,20 +149,33 @@ ] } ], - "source": [ - "### Call execute on the world to run the detection algorithm and save the real data to the database\n", - "recognized_world = traffic_world.recognize(cam_id)\n", - "recognized_world.execute()" - ] + "metadata": {} }, { "cell_type": "code", "execution_count": 7, - "metadata": {}, + "source": [ + "volume = traffic_world.select_intersection_of_interest_or_use_default(cam_id=cam_id)\n", + "filtered_world = traffic_world.predicate(lambda obj:obj.object_type == \"car\").predicate(lambda obj:obj.location in volume, {\"volume\":volume})\n", + "filtered_world = filtered_world.interval([0,fps*4])\n", + " \n", + "### to get the trajectory and the video over the entire trajectory(amber case)\n", + "filtered_ids = filtered_world.selectkey(distinct = True).execute()\n", + "print(\"filtered_ids are\", filtered_ids)\n", + "print(len(filtered_ids))\n", + "if len(filtered_ids)>0:\n", + " id_array = [e[0] for e in filtered_ids]\n", + " ### Fetch the trajectory of these items\n", + " trajectory = traffic_world.predicate(lambda obj: obj.object_id in id_array, {\"id_array\":id_array}).get_trajectory(distinct=True).execute()\n", + " traffic_world.overlay_trajectory(cam_id, trajectory)\n", + " ### Get the videos of these items\n", + " entire_video = traffic_world.predicate(lambda obj: obj.object_id in id_array, {\"id_array\":id_array}).get_video()\n", + " entire_video.execute()" + ], "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "{'cam1': }\n", "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='object_type', ctx=Load()), ops=[Eq()], comparators=[Str(s='car')]))])\n", @@ -189,68 +206,68 @@ ] }, { + "output_type": "display_data", "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAADfCAYAAAAN+JPJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9WaxlS5rfh/1iWNMezpgnT453qLpVXVVd3dXVbJHNQTIt2YBI2Og3ajAEUSDQIEDCMNoPIvwiP9IvNgjIoNGGBZOAYUqQbUgwKNESwZnqptjV1dU13brzvTnnmfewphj8EGvts84+e++zT2be7mQjv4u8Z++114oVK1bEP77v/33xhfDe80beyBt5I2/kj5bIP+wKvJE38kbeyBt59fIG3N/IG3kjb+SPoLwB9zfyRt7IG/kjKG/A/Y28kTfyRv4IyhtwfyNv5I28kT+C8gbc38gbeSNv5I+gfCngLoT4t4UQ7wshPhRC/LUv4x5v5I28kTfyRpaLeNVx7kIIBfwM+J8DD4D/Efj3vPc/fqU3eiNv5I28kTeyVL4Mzf2PAx967z/23lfA3wF+7Uu4zxt5I2/kjbyRJaK/hDLvAl90vj8A/sSqC/r9vt/Z2Vn4mxDi1dVsRfmtBfNl3+9F5IXrtOZ1F8666hrvWWTriWvc76p6LC1/viovUPayMsSCYyvLa07yYnX5q2Sh1fyH1f/m6uKXHO/2xT+s1e3/Kq2qf9m6XnX9gwcPDrz3e4t++zLAfS0RQvw68OsA29vb/MZv/Eb3t4Wf565fes5VDSKEuPBvWbmr7n+d36W8bCA559Yq13s/K2Pduri575fOa9rHN7+3Za8z0XnvF9Z9nfotquuFMtry589du9SL13jOQUoteNcAtnlW1Xl2t2QC69ZlHtyXir943aKHudBfu/16rpjZRDT3nubLWfScQoil7buoDOcc3vsL9xCAnAP3tv3kgvu+KLB177vsWbvS9sfuOe24uVAuHjyItmXnmulF6tvep712voy2HZfdY9k958tdds1v/MZvfLasbl8GuD8E7ne+32uOXRDv/W8Cvwlw//59/yo15qvKWgS2i6572Tp1AXO+rLYOi4By/rr5DtItwwOuHQgr6t4dLK45V3gPQuCdgwVtMj9A5usgpbxyklomiwbfvKzS5NvfFwJgA87dNlz0zmd16A6+TtnrDvWrzruyLCEWPsf8NS/SHxf26StA7FVpxi+j5c8D27Jn997P+mH3mpVt5XklwH7lfbj8HKuuX/S8iya3dfvBlwHu/yPwNSHEuwRQ/3eBf/9LuM9Mrnqh8wN7mWaz6vdF8jLg3167CCCXTQTXEe/9QqpkpmHQ9G/v8Q3Az7fBoo7ZTjRtnaSUS7WWq9rnqg57FbgvLbctrwHNK0GmmfCW3X+hrPnqffNfuGR+Onq1cpVy0rXolmnGbZ9ZOKbmNPnZfZprXoW0726dyZ/OuYsAfu17fsk0z3x7L7vfKitlHQtmXl45uHvvjRDirwJ/D1DAf+a9/9G6179KDb4LilcB+pcl84C5CABbgFzVoZdRJNB4xee0v0vXd69b9lt3gDdafXv+/DVtXWdU0NwE1T7TrN7t+Rcf6kJ9XswGuCyr2mqde6xqx3mlbxFcL7DFaEiBK7n/ZaJmzyTwYrlVJbvvZE2NsVtLGs2+a1nO+mzTf9vnEBfqdT3p1rFbyxei4DoAP69oXJycwIsvF8gX1a39246RdbX5ZSC/LsB/KZy79/7vAn933fMXcd+rzl1HrssBX6f869Z1FT3THaTLzumWt6jTrjZBl2haK7536wbLwb3byeYtEO8coju5Lrnvpdp1aIPuxLBI5ieLV6GBzWuuC39fUI8LdZjjqcMktraqv/RmF552XuPu9jW4QEvNF9e9Rff6riUnWExbLZJ1tMrratSraJhV5V9N9Ykv03haqsB1rV246CdY1jbL2nXdtvxDc6heJS+jVXeBfR1O7MuQZZPLPBCs0ylfhDJaJS806S062NHGF2mllyBtrj/O6IolGn23nAuY9wdscbWySPtvAfECv3+dGy0Zo10934eCL9Ztzq9wqf6d31xD0V1Fcy2cbDu/0dZjCZ12HX55/tgyim6hQ5HLc2D3eVdeuybd8zKyDOC7degCfbdOiyjOVRPGKnltwf268mW+sLUdNUuuveq3l6n7iziqrivLrhAEDR0hgrbLHKB322xVO6yom587Z2U9X4BvXVDISkvhUrTDgrqt28be+6UPJujQK1wErxbsW+16/t4XrJn565qy1mmnqzTK61yzzr1WHZ+nhtYpq0uFrLrPqol8XVmktM2XtQ7l2rWI1wH4VfJagvuLgt0qeue6dMuqsKp1QHkRFbOu5rKuXJej70qrOXQ70svUpeV3W63qKiLikua1Atjlknp1r2i1WTlXzjzYXdULzmmUTj2uuO8LT82LBmzn/uu8hQv9svl7gXZZcd3M6b5CpBDYrnKzZp3W7UOzd9/l8pcAY1vf+XDMRXXqUiHrct3z18/XYV2Zv88lemxF/+qOwUXl/KE6VF9GXlb7XgXuL1uXFgyvokhetAMt6wDdl73SWbSkPotknrbqOkfnJ7V16t51irXH5RWgJ1Z5F9tzVtxzWZ2WDfRlZXblKj532T1eWFtldR+6ar3CpbK4OLmuVwkxW/ewqEzoOMdhacTM8uLXUBg6zuB1yppNYkuUm/kJYT5g4WWt3XWtnmVyFWUDy8OMr1P/1wbc1xq4zYMtms3mZ7x17rdqdp0/vgjcl9XhRUyoRee2z9yWZ629dllw2Wm7zKJY1LZX1bGrFcHFaI21tLyllZ79r73hGqVdrNurlOtqY+vIKspDCIFihfbuF0SZzNepPbX5O2N5m7adh45l9RGdv3i/dN3Foufofl/Ggc//Pq/0XDeyZFVZ8+GSL8LBv+hkPl/nVpb1q2XWw7r1fW3AfZVcNftfV2Nfh1ZpZR4Yl1133cG+zu/zoZxKqZXayjzQrrpnV5OZb991Ot+qSW+tN9GetKwdxNol/YHJlzFprHOv68DIMh9Fq9VfcIZyPcrBe49fA9ivI8v68lUW8qJzVlEYXQVs3UCGdet9HUt91YS+SiFcpNheJa8tuM9rmMsebBH4dstYdN6L1OU6x9v7LavnOvda9EyrJrmrnr37eVUHWQTW3YlgVZ1eVHtdpmktO/+q866rVX6Zsqq+y6yBZRPlBU19WZ/snCs6/7plXOWkFnDJKvDdv1coW4vkZR2Ui35fBobzbT7fxq32vqjfde+77urr61jqq7T+RRPPonHY/b5KXmtwX7SydNkqtHUohBetx3Utg+49l5mHq65ZJesA81V1aXnI+futuv5lLZEv65oXMZEXTUSvUhvtyqtqty4gi87nReUte5ZVTtELADh/jvfh35yV1wXIqzTL67R3d+yvWnV6lcY7T/m0f7sKzCpwn6/vuj6oq2SdyXHR5DY/Dq+afF47cL+uRrYMeNY9dlVdlFIrwe0qLmxd821+oHSvedWa5oukM3hV8irey8teNy9fNrC/isnnwu9t+YsvvlDOsvJXfV90/jyNN6+stH239QvNy1W0yXxZrXRXnS6r6zrgv0gbvgprli06WvZ8q+Q61M38NS/aj147cIfLL7jbubrndD9/GSD4qkF21fWrHLbLZu75369z/1cBqNfpbK8S1F/22pe5z7rOvVfeF0PBF2PV562Y5t7rRsu8CFWyiipYVd46VOKi39flmdfpl4s09UX1WKRgXZUkr7U2uvd+0aR6i+rbree6FOZrB+7LTOZlzsJFs/CXDWLLZtLrDup5Teiql/Yq6IRXqSWvW5dl7+xV1eNly3gRk/pFy38RK6HLo1/Q2hsg95znF6Jz7lJOfY6muPL+CwB9HrhelfWzaAJ5kTK6dVoX1K+6fpXFex2L4qr7r2PhrLq+ldcO3OGyk23emTevIX1ZwN524kWde9l1L6K1XafOyyaA6/ggrqrDfHnrlrWOJrbs+HW1s+vIl6nlr6tFdevyMkC4DF66YC7n7vEi77IryzT1PyhpteaXue+LPvc6Clf393ncehVylQa/TF5bcJ//vIgrW6UhvSptsQvW6wL3ugN+XktZNjlcpbGv4lBfNSCu27FWlbXKCniRSerLAO9FzrhXdf950FinLa8a3GLut+vUZb6s69TlVZQ3f938OH5RkLyu5nxdPn8eG14VJbNIkXyRCfa1BPeuLOOblwHEy/Kd89fOL9Nfdu/2nEUm73UmhPly2u9dWmpRp2zP7a7GW2RGLuusL9JuVz3fOlTOdX//g5K2nSaTCYeHh0RRxNbWFkmSXJlKet3yX0Zmbc9l+mUVGL0Kf8D8RjOLFC/n3AsB3KusZ7c+17n3y5SxDHjXoWBedZ1eW3Bf1jGuApJXQctcdc9VHW/eJLvOhNM+cwvQF1LoLjH15su9akBd1+k1f591+MDrgP38vV/mnV1f62/btHNNc7SuKo6OjxmdnVHkBUVZ8PjxY7IsY2dnh42NDZIkeSUW4nzbLvs+q/UVbb7MjH9ZSmj+PvOT3KLf5n1ly+reVUqWnfcHIS9iSXWv7Y6/RX1jWSKzq8beonF3VV97bcG9lfbFv6i5eZ1zF2nFV2np68oq8OqCevf7i3ay9j6vAjC797nOJDdfl/b8RccXnfOiVsT1xXX+eoyxnJ6ccXJyTG1MyIHjLMKBqWtGdc3obITWiuHGBltbWwyHQ+I4vmDlvQzIr5J1KbeX1UJfpG/Pf++Op4Wbf1xxn9cB7JfJMgtj1a5v89Z09/nWpZCuMz5ee3CXUq4dl/2iA2oRqK9T3rpc7KoX131ZLxs6tazsbl1eVNaZ9K7bhm37KaWAy5PaOh25+4zWWrz3s7UJ60tYVj8ajzg+PKIoiu5PeNfk9Onc09SG4+NjTk9OUVoxHA7Z3d1lOBzOnmfRwH0RpaNbxnWsn1Ua/zLtftn3Rfear9Mqrfwq8JqnM14lmF/HYnmVls06v72Ib2Lda64EdyHEfwb8L4Bn3vtvN8d2gP8ceAf4FPgL3vtjEWr/N4A/D0yBv+i9/951Kj0/Cy7rqNeVZbRC+/dVUTiLyl5HXqWWPa8tXFdbW+eadSaOdbX67r+WjrpOp7fWcnBwcAFwsiwjyzLiOF5eHx+eI59OOTw6YDqdgPWzreOMtYwnY4q8wHqBjiK01kgpEELiPThnsc5yeHjI8fExcRyzsbHB7u4uWZah9avTn9axgK5z/SKgWGVNzZ+3zjtqlbOrzl2k/b+MZbxq/F2laF1HXjXl9SontXV63v8d+E+Bv9059teAv++9/+tCiL/WfP+PgT8HfK359yeAv9n8XSldzm0eaNvfukC/zsuZN5teRDO/7nmvQq4L8ldphS9i9Sz7fF15UYdrl39dx+E0Ho8ZjUZsbm7OrsmnOaPRCK01vV6PjY2NS3WrqoqTowPOzs7w3kLTV5yz5HlBVVX0emGCKIqaytRhAgDiOCGO09D+nANRVVUcHBxwdHREEsdsbm2xtbVFr9e79C7WebZXcXzReevSAYvKXZcu7I679j6LwhpX+RbWsUKWXdMtd1U45VXHXqRdVx1bJq+aeroS3L33/1gI8c7c4V8D/mzz+W8B/5AA7r8G/G0favlbQogtIcRt7/3jq+6ziFefB5l1tOFuY85zWovKnZcX1YquuubLniBW3fOqe7+IdXRdgFhWz2XUw3W0+CiKiKIoeEK9oI0Gl1LNysALEBJwWGs5OTnh5PgYW5fgHUIA3jOdjinLiiztsbGxxeHRAT99/32Gm5vcun2bXr+Hd566NkwmE4QUJHECUgIeIQV4sM4yNTn5NOfZk6ekWcbm1iZ7e3skSXLtdlr33JfRPteR67znRYoacMl5Oj9m5+szv/H1upNL957dfrQuwHd/+7IUwatWvr6MvKjNuN8B7CfAfvP5LvBF57wHzbErwb0ry0ypVSC0jFK4SrOdP74OUC0r78ugdpbVZdHEd937v6iGvug9LKvrVfdYNpm273EdLd47j5ThXGv9efiLFyDafCcC7xzj0SlHx4dUZRUWqLngSM2LKUVRkCQJ21tbHB+f8Vu/9dv8+Kc/YTKdIKRkMNzg9u3bvH3/Lfb398myHiAwxmDKEu89cRyjtT63HAFjDNPJJEwGQnD37t2l7bGOzPfxF9EWX4QCuC49s24du5P5Kk19VX2XteUiQO/2sXUsiPa3q5iDVfdfdvw6wROtrPvuXpoQ9N57IcS11QUhxK8Dvw6ws7Nz1T3W6kDd7+uYWouAp8vbLrq22xGX1eFVyjplr8pL8zLlXuea63Kki65d9A7mB3sbP30BOPBoKSmnU4xxxHGMECJw51Ig8EwnpxwfH5FPp+fvEqjqknw6QUaaze0tRmdj/uU/++f86Ec/ZDKezDbxds5ydnbC2dkpH/zsZ/QHA27t3+Ltt9/m1q1bpGmKJ/D/06JEAFrHaHUO9AjArQfE8/34ukD8KgF+1dhbNl7Wsa7nQynngbYLgC9KWSwbx1ed9wchi4B93XG0zjkvCu5PW7pFCHEbeNYcfwjc75x3rzl2Sbz3vwn8JsDbb7/tm2MrtetFWvmSsi9ds2zmXgTyizSjZZPIlwHs69Ao81rGq+oQ696/+/dlzMqWNrnKKlsVP+ytIT87Znx2Sl6URFqTZhn9/hCdplTOcVKVF0DCWtvQKjDcGDLJp/zWb/82v/+DH3J2eoYU0MsSjHOUVXXef7zHec9odMpoNOKjjz+i1+tx8+ZN3nnnHW7dusVgMAAPprbkeY4QAq01cRwH0HINfdPIvD9pUVt0sy2ua1muI6sA/svQJrvnX3Vs/r2/jKwz0X0Z8iLt8jKKUldeFNz/a+A/BP568/e/6hz/q0KIv0NwpJ6uw7fDcrOnCyDrrgycB7/rNtYyYJ+v17rWxLr36t6z/W1Rh5+Z/Asmp+vWZ9mkddX5XcrkZcX7QJ1orRdqql0t7nLf8EzGJxTTE7yrwVbUtqIup0zOTtnc3UNpjZCBcnfWMZlM8N4zGPYpypLvff/3+P7vfZ/j4xMUgq3hgG984+f42ntfZTqZ8Oz5cx48eMjB4SGTPMc6CPaCw1nHeHzGaHw2A/pbN2/yztvvcOvOXfq9PgJJXddMJhM+/fRT8iLna1//+gU6bR7QRZMSzFqLMQbvgxNXCIFtQjNflba5ij5Z59pldMYyrf46dZpfIf6q+el16/eiz9FeC8upqfnf18GPV0LLCCH+nwTn6Q0hxAPgPyGA+n8hhPhLwGfAX2hO/7uEMMgPCaGQ/9GVNVhS4UUm+nUeflGnu8p07ALn/N9V2vurlIUDfYmW8yq19Vausp7mKaB167HOfVeBwaLj4Xzw3uKxCGERsuknHhB+FptunWU6nWKtJU0zvHP86Ec/4ne+97shjFLAcDjk53/uPb719fcYDAZ474mVYHMw4L133qEoCp4fHvLw8VOePn3G6fgM6xwOj0DgkEwnEz755GM+/fRT0jRj7+ZN3rr3Nnfv3mM4HAKgtJ7FwnefpSt1VVAUBXmeE0URpycjkjRld+8GURSt3MTiZeRFgH7Z+Jo/tq72vAgHulTOvGLzZTkku/Iymv86tFt77DpW1FV1Wida5t9b8tO/teBcD/yVq8pc457A5Qbrmu/L8qasknVNwXkzudUsv2x5FUD5slbDda9dVzu7amJeFbK5aCBcZY15wnszxjA5G2G8od/vobXmww8/5He/932ePXuOs4at4YD3vv4eP/+tb7AxzJDCIRBYK5BSgRRYZ8j6KW/17nL/7l2quubo+ITHT5/w6PEjTs5GVNaF9a4+xMDnec7nn3/B559/QZqk7O3d5N133uWtt9+ePcN8uznnOD09wVTlBcVCKU1dG8ajMXEck6TJ2mGuLyqrwLYrL0PfLKNGF92je163jPmV3cvuO3/dyzzL5Wvb7775F46F8lofj8D79r0317jzc/yFa9v6tGW2k1y336wev6/9CtV5aTnadhZf9MJXabzLZBGoz//+KrWkZVbDKq15GaBdx6JZdv9VssjXsYwbni9/fpJc517zltIqzaf5NvvbnquVZjSa8M9/63d48PAh2ze2+drXvsbu7g6PHj3EY9nY6PHeO2/x7Z//FoPhIAw+IRmNxxRFwe7ODgZ4+PgxWmtu7u0hASEtkYy4desmt27d5Bd//hucno148vyAR4+ecHA0YloUFwarkJBlKTdu3MATEpKlaXqp/xpjGhrmomZaVjnGGM7OTiiKkt6gz9bW1tIcN69S1lGa1pnkX2Rczt9jUZ0WafXr1KEb1QRQ1zWw2tpor+9OJC11hvcorUOUViOuAXIhmms9OG9DX2voPbwDAYJ2krLQAfEWl7o+I2PMv3rb7C0zP+bNxfkHf9mOsyx/zarOsghsrwaii0C+iDpapMWseq5V4HoVFdU9vuw5r9Kq5p8FuPBe2t+cc0stoO6Evch5GqgW33DRjRUnJWEUNPAuBAJFUZT89P0f8eMf/4xxnpOkKW/1e9zY2ebBgwd8+vFn3Ll9k+/863+aGze2w0BDc3o24vj0lPd/9jP2tne4sb2D956DoyOs8zx9dsLx0Qnf/MZ7JHHMxkYfKQQax872FjvbW3zza19lPC14+vw5jx4/ZTwtuP/WO7zzla+wMdxECsmjhw959vQpb7/zDvv7++eD3oVB38ae1VVFWYbFVNYG4HE+hF6OTs84Oz1Fac1wMGRrOwB9d0VuV7r9e93ok1WT61XXtHIdKmaZArMIbBf116WU0nwVBCilLu2lOk/xtGN/UXtZGxa9SalwzlLXNcbUgCCOI6y1WFsjpSTPC4wxaB0jhcJ6Q13V1HUVVj/bGiEEUZTgfZhkyrJs0mm4mS9qNBo15cccHR1dySa8duC+VFozRHQPBbqkC4DrgP38b8sArzuJLJpg1qV55q/p1u+qTa2vOnaVrALzFyl/XqO+alKYfzfXyVp5eSA7nLWMRiOePXuGkJrhxgZVXYIAieTjjz/jd773u5yejYjjmJ//9td5772vcvj8iM8/+4wnT59zY2ebn//G19ndDmA7ykuOjo/55ONPKYqcb33rG2z2NxAIpBBh8VKvx/Onpzir+fizz3j+/Dnf+Lmv8a2f+ybGVRfyqW8MemwM3ua9d97CCo1OBggZnb9rD6Y2OGsDyAgJ3mG8x9Q108mUqphgrem0gWsvBfzMvK/LiqPykOPjI6I4ZnNzk83NTYbDYVjY1Wn7VsJ6gKtpxnYstTl7VsmyfnDdPrWqP3UVrXXPmZXb+R1EA77njmlr7YXQROccVSdKyhhDVVUURcFoNMJZ21B3IepqOp3OzhdCUBQFZTkljmPG4zHOuVkqCmPM7N4t1axUu+CuxQiFlOcaf/tcWsckyUWLb5m8XuDevC8h5yo+o7Au8kzzL7irzS9LVtQ14RZpnIvK7H5epxO2v3f/zl97XU18layial6ltJ2+6wycB+Clk15zTqQ1xlqqskRpvdC/seze08mEw4MDiiJnOs0pq5rj42MiUaMJJvDe3g6/8svfYXQ24s69u4ymOf/kn/wWk8mUP/WnfpX/2f/0z5KkEiUkElBC8OjxE85GE+7du4t3gt3dbRSyrTSRToh0SpLU3LixRZTc4P69OzhvkUrM0gRfemYhSeIIISW1NTgLCImUQWs8OT4h6/UY9PtMx2OOj48aILDIhtIRIrSnsQGAauOoyhrTRBe1gOE9VGXJ8+fPOHj+nCRN2dzcnFE383maruq/LyIvoum3111lsS8bo4sUjC64ex+SwpnaNIBbXqBfqrpmPBpRliFUNs/zkDhOCE7PTvHeE0URdV1TVRUQVkRLIYmjiCRJiON4lhm0/R4mVNCN83zekm0n3IvH2zaUCCGb791AEglcTKT43/7//t7Sdn1twP1FGMNloDZv1i8C5PmFMIs62CqOb9n9l9VtGe1y1fN0QXPde8//Pv8c3oe8KsYYoiiaZVFcRBPNl7mq7vN1c85xfHyM955YR8RxjHOOp0+fcnB4iI40w+GQfr9Pv98njuOFGR3LsuTg4IDx2QnOmeaom/muhAh0jRAw3BgwHPax1nJ4dMTmxoBf/qWf5+beDe7evYsQCmOnyFkXEbx9/22sM5weF4zGBVVd0c+ygO0epNTNwDpPadDv9zHWIEWA4ctUAngEtjYoKiKpQSmcVzgbkpI9f3bA4eEhG8MBSnT4ee9Bhn5sTI1zHik1SmosBpwliTTWWYqimml+WmvwQd0r8hBt8/z5c9I05Stf+cqF/DrrWlwvIlddu0rDX9RX58/rWtNwrlW32vZkMqEoCp4+fTqjAqfjcEyI8zUH7eTYjgEpJVtbW6RpynAz+DJ0o4B0/ymlEICSau3nnZ98Fu9B6/DezUC8TUN9PllBd6PFf3U0d3FOuVyq9DX7Wdt4i3ZRasuf1zKXAfm8LEpBvOzaRZPFqnzPy55l/vu1Bp4HcZHLoq4qvnjwgMPDQ7TWZFlGv9en1++RZRlJnKD04rS5876JRbyklBLnPQ8fPGAymbC7u8u0rjk4eN7wxxZjasqqZDIJibiUUsRxTL/XZzAcMOj3SeKYs7MzTk5Og5PJOXCeuq6piwrvggP0/Bmb0EhAKsne3h4ewc7uNr0sw9NoU2iE1DhbI4QnTVIqU6G1J44k41FBP+3RKu+SlpPVKKExNgC+dI6lnbPpzi3wC+GoypKgecUoEWLvHQHAZaTAhwVSzjm8sXg8kY6oa8Ozp8/46OOP+ezTzymrkrt37nLv/j329veJ4xhrbZOqWKB1jNJq5mCcTqeUZRmq1VUWZl2r6VMdjbL7fl+ZtJb5nK3TflrU160NfHaY6Azj8ZijoyPyPMc5R13XjMfjmaLSgnGWZWxubtLv9+llGWkaEsBFUQD0duUw7fh3Ducbv44QRHEEQszue8mqbNpPdHCrfbrZU3VOF6IF5yBSCtxstXIb0rs4GqjTky61zyp5fcCdL59n7soqkFz227IUxOto4uuC8rqm7dogL6CbHKIsKx4/fkCRT7BNZEZZFJwcHQMBZKM4Is0yBoMBWZbR6/VIkoQoihZaJPPafgv2dcMpm6omzydUVQCYuq6w1oA4BxFnLWVeUExzjg4PwwCNdWPiMpuU8J5IayoZeGqcATxCKQQXNTrfDgghMV4iRYRG4b3FWI/ABo1fZgSOMyGKFJPJKXbb4qUC4ZBYhIckzrBWIawK95St1bDkHQkPQlHZGmF9mJysw1HihUQqhYwSvDdUJmiYUkq01lgDh4cHfPLJp3z88cccHR2GzUOaZzr92YiffPA+/cGA27du89Zbb3H71i2SJMVaR1UWSAlKaaSMwF2kBaWUeAfeOzyWsqpQOr7kkF1Fla0jF/pGg1HN67ygGFjnKMqCs7MzRqMReZ7PQLssy1n/ay2UjY0N+v0+aZrOtPB2w5RV9Z0pZ77tH00dfKNJi6AYIM6drKt8FN77cC4t9M5NADNxtFq395YWrH1jec5ujmx+s81n0fntevLagPu8KXhtDZXVgDsPyutqzO15y/K3vIz5ukpeVbndUsqy5OnTp+R5McuxIoS4AP4BZC1FUXJ6chKcikoSx3HghwcDelmPfr9H3OwnKoRACnk+QCBoQN7jrePs9BSPwzsXFuYUBcZaEMGsnZXRrXijtSHAmDqsYFWBKzcmx9RjrAWpNEIqlFLYeWftTFOU9PoD8qIiShTOGLxwswgbgLLIESJBiBitU8raEMcSIQVSK4TQaC2wzuG9wBrbVn+5eHj0+BFSx2xtbZJECqH0LL+MMwYnJdJo0iRFKMHh0RGffvopH3/4IScnJwwHA+7fv8c7d/d59Pgxh0fHVHWN9R6HYDRqVsd++GFYHXvrNm+99Q77+3tkWdxQFTkffPgBXsD+/v5MG3UmRGN4Z8mnU/LqlBs3boQ8OXMW2XX64zL+3DlHXVZUVcV0OuXk5ITj42PKMsT0IwNlsrm5yc2bN7l///4MvLvUYfcey+jUZVRmy4F3Lc3ufq/zlgssc0B3rI/ZRLGwMWgnECHas1ZNlnNWje/Wv73XVWUEeW3Avcu1zjtErpJux5unDV4WJNv7t1rVi0w68/VYRhO9aHmrxANSBO/9kydPmkEVeHBnL0+is0HUXOzxWGPJbU6RFxwfHs3Oi+KYLE3p9/tkDaXTalFlMcXWZaA+PNRVSVHkRHGMrUqKoibp9dGRbupisc5fmESV1uRlTiQVWiuECSGBztV4W+MNWGPwKsE5cam/CCFRUYKKYoRKSNII6Wqc9LMFJc4JnDBUZYXUfZJMoeIdDo+e0u/vUlvD0dERg0FElAxQSmIij2cEqAvWx6V35OHBoy94djAh6/Uoy5xf+eU/zu7WJrH2WFMhcdi65CcffchPf/JTDo8P6WUZb9+/w5/+1e+yu7NDHMVMp1O++fX3mEwnPD845ItHj3l+eMgkL7De4XzIa//hhx/x8cefkmUpe3s7TWKzuyQNSLZUR1WWKO/wBI5XosAF/r4FulWRTYustfZvO3mUZTmLJBmNRlRVRV3VRFrT7/cZDAZ89atfnVmGUsoLWvM6953/vPRdiHMH5rx231pLLZW7iDrVWs/omaYms7Hj8Y01sqDOArzz4EVIUgogg8WEV41u0QL6PPXiZ76e5uvFgq+Q1wbc50O14JxzuyoqpTvbruPkfFHa5jJ4XJ1OuFtHuOzI/dLFQ1lVPH36hOl0wvHxCXEc8fnnnyOkZtAfzAaWECIsumi3q5MS3wB9l1sUogkly3OKPOf45Biad5AkCWmaIkUAbG8d0+kUgUcqxfd/93f5vd/7AVVtGWxusrExYGdnl5t7+9y4sYtSetbOSirSSOOtwZYVwlVIARKP8Mxi3qXoOoNDPaMopjcY0h/sYr3HOAcWLApUgnAOTw0i8NxRlFFZR1EGHl2IBOc1xnqOT04ZDO9RljWmtggc1lUkabTcKUkzXL2nqmqQBU+fHjCa1PQSyLYinClxtcHUNf1ewntffYtf2fgF9m7skCYSIRSeYB4ooUBLNoYRG8NN3n33bfIi5/DojIePHvP02QGj8QRrHDjLdDLhs+kZDx8+Ym9vn3/j3/if0Ov1wnv0jcHfvFLRzORCXnZWtu+7/XuB9mqAvCxL8jwP2w6enoV4fRHisbMso9/vzyyCuIk06U4Kl/nl5QpPe3yZld/9vCoooPuv9YXNb1DfLb/FofP7hDbzHUDu3redJMNeAuflhD7h2t5xwR/W5eVDWYLLTXO+1uMqeW3AfZlGvI5X/yrQfhGue9E1XUftjNIQYmEdFzkd58taV152Mqhrw3h8NtsG7p/983/K+z97H0HQjvv9ARsbQ7a2ttnc2mFzOGCYZXgZI0QUNA/aTS9k2GZOdt5Xw6O6Bsjz6ZTNQR9rDGVdE8URXzz4gt/+7d/m6ZOnYTAhOD58yvHBIw4e94m//W32dxJsEXjHOElRosfhs6dsbWyF9pYiaOgNjySaUEFwIBxCClSckG1ss7G5SxwngCCf5kjpiWXQpp3v4ZzFVGOkzxlPKqo6AiERokJ6wd7OPlpYkijmK2+/R5r1GY9LrA/gX+SCo+Nn7O/tM29Kz4uxFcqC1gIlIpAxXjqE8IFKkorNzS1u3dpHN5OpcZaiqCmrMZtbmzhgUnviuI/AokRNvx/RS4fcu3Wb2tacnp3w9PFTHj95jhOaW3fucufuPW7c2OeP//F/jSRNg9MOCdZifE1Z5ownZ5yejEj722xtb1/yrXTB3BjDaDRiMplwdnY2i0AJzssBt2/dJUkSlL6sWXvf+ic68HQ+u1ySeeVp2dhcR4vvWuDted0yZ1q4P187053MhBCzdnHOYbEg5Gxi6G6n2J4zK7PRW6VvraG2FUTzuQX7wL+fQ0Pbvxc/y1Xy2oB7t0FbuUpjn5dlL38dKmXdBmsBHi5aGOvUfV365UWpn0UihKCuK05PT4gizT/6x/+IDz/6YDbQjDVUZcHJ8QGuLimnp3wynuIdqCghywbcuHGDjc0Ner0+aZIRgN4iBLNFF0o2WoYQSKWYTqZoJSmLnH/8T/4RH374EVVd02orUkCsFV997yv80i/+AlsbW9R1SVUWYbIwUFUJzjpqW3F2NuVHP/599vdv8bX37gdDeNZEAeDjJGNz7yZR2mt+E8EcblaxAo1prJCqMb9t6xRzaB3Ri1N6mUIrQ10VYC2bwxgd1WRRRG0j8rImirfgtAgO4ys0qaC9V2itkFIhZsvTPUWR44Via2uLYloSRwmPnz7l6PiUu/duoVXIU+MReCkxVpFPDM5NSFLJVr+PqQriSLG3u8Pezg7f+Oa38DImSjOUilFSMx6P0UmEVoqzo2ccP3vItMxx3qG0wjnBNA8blrScdMs1B438FGMMQgiSJKHX6/HWW2+RZdnFJGi+dQi2/5ipo7PXdaFrC+Z7ehdw2z68THmaV8raz6vG2vwq1GX3bJ237dqOrvXdHrftQrQO5dNatnCe0qBV8OctBFhEJ15spFWK4yp5bcAdVtMeXVk1Oy8y29b9/brSDoB167nuBPIqfQZFkfPBR+/jvOcf/Pd/n88++yxoA/7cBRRrxS9861v84i/8PFVV4rynNsGpOp5MGI2OefTgU6qqRihNkiRsbQ25des2g+GAJ48ek6Ux/X6fKElJkpQ0SfnJj3/Mv/zd73E2HgWAbbag00Lx1t3bfPeXvsXtWzdRMmi+IYlucIBWxrIRR0R7N/jg/Q94+MUTnj07YXNrJyB0A9htgjDvw8bWcdynjTjwLbAjQRh8CzwCvBNNG0iGaYSLIY1ACAN+inchSkZ6j6urZmISSCkYJIJhT7O7fR/hwy5PCzX3GYYHakbrONBOiACCXnJ2Oqa/sROWsdsphYe8KCirnCyNgwnfUF5agBIaJQwqkmGCjGNMnRO0P0BItFLoNMFKMK7COcvPPnif+LOwgrUeH2GKCf2tXYabt9BxTBRrkIKqqvjiiy/49NNPqeua27dvc+NGWCNwCciZH6MCmjUH0gdKwnfovCBXJztbNEa7YD6/SLGddOYpo0Wy7JyuQ3V+zLXPPF/m/CKk+dDrC+UEUj5QYSJEW53TM1dj2ovI6wPu3i80z7ovcRlPt4iWOTcBgSt4unCgc9NrtOW8Fn8dOac1fPfg5d+7co16ikaL9t7x3//9v8+TR49DR2xc7h5Pr5fxq3/sV/i5r70XjhlAQqQtWZKwvTkMmqMPS6PLqmYyHocc5kdPMfkZx8+f8tko7D2qtCZNM4aDIaaquHd7H2N2OR2PmBZT+mnGd3/hO7z79n2iOIQzSs/M2RSUltDxhRQgJONJgReCQX+DZl5qNCFxgX8Us78e58HWFfnkmPFk2kTUhFA/0fgSvDBY70gjiTUO58vA59P2nfNQtFl/c80UZINjdmomM7haNMnf2N1lPDU8e/480BVSz57TA3leIKMy2DNSEsUJoj1BCqRQSNU4bttoCyGJdYScrcTqaK0E015isSYsspJSgPOUueN5WZLKikGa0R/ucTaecnT0OU+fPeGLhw94+PAhT548oSgKvvnNb/KX//JfZnd3d9YGC5WYhZ0z+EKaZTiruuna0jo2u2B7pZZ/gcO+rOF3Py/Cl0VW+XyumdaP1o2o6aY36DxBU5f282X/2yItfb5ui85bJK8PuBP4XLFggVB3VoQ16Y2OMvGHJdeadVsLlldHyXjvQ/yvTnjr3lukOuL09JQyL6jKks3NHn/6T/0qd+/cw1qHdR6U5OhsjPCWSEcIKcLCj0QjPPSilF6WcnNvm7IsSLMQC++Moa5rrHOUZcV4NMaakv29Hd56K5RvasNwY0iaZSFEzziSqFmJ51t+MSCbIPDjkpCHZXR2xtnRlHfe2mtwT9D6qtrB4vHgplRFSVkW5PmE09Mjnj19Tm8wDAu0kgSlQkoBrQRSOJwrm0mveRECvFcBxKVCoEJ0TggMh8bfIDvvrW3vrgjg6195l6999WuMJxPyombQi4ikR7owiVjrOT454/6920gESii0UOACN962hsSjpMD5sHBLaI1UjWY8uxvnjmbn8bbCeYfzCiEkMuohvMQ7T1EW/Iv/7r/hX37v+xwdH2ONQShFkibcvnObr3zlK3z3l345RDqVVVhyLwVeLMifLgDfcskNdSGaFWCYtnHaVmKdQbloDMxrxlf6slZARJdLnz/WSgvOXcqldZJe2upxjgrqlhWc2L6xMttnax33XCpjnbZYBwNfG3BvNZll3PUyM+2lxF+cAZYY1xfruarx5y8W3XvM/bDkt7Wcv91bLatwU4wUgl/6zne5f+8uDz7/CGMqnHFMJ1NiLRgM+oEdlQItJXVdUhsDzlDVNbWpUVHEcGODPC/YGPSJlMBbQmRMlgYwtHVYXdloLLvb22RZxsbmgKKYAj7wv5GmMhZnPUkaI4SdmauXLTc/i8EXIiTxogGvVvlp31zg/w2nR08om7DPH//oZ3z86QOqqmT/zh7f+c53SHTMw4cPuXnzBvfv3aafJQHEvWzqEFEZi6kNUaRASmojSdMtnHUgLZ4cZ8x5qqMVnKh3DoRhkKUMsgQlKqRwGBOAQ+uI5wcns5fWNoMQssFMP7NqW6D3Hhxiphmfv+5zCqTIa1AKpZoFO94hmp2jUMFvdHNnyK9855uURYGOYrJen62dHfobG6AURZ7zwQcfEEURw+GQ7Z1thhsbs4Rk7bOGOrnzyJHZ83c495ccri0H3qVfWpBd6Ztra7HglGWWSPtbK10wn9f2l1kCCx6A7srctomu6wu84Jy+4trXBtyB2RMvi365XoRJexGNtnWxLNH+9go6nZi9uDlZWt3Ojdt6vaDTZHGlLn6VwHR8ynh0jLUBlCIlGfT7KEAlKdI5XB34Y2eZAYpzoBpAMbXB1C7ws41GNosqEIJebxPnbUio5RVZopudkcSMLiiqCiEjkiTGCxr36nmnv/hKxOz1OQcq0gwGvXBUuAtne+9xpubDjz/g937wEx48eYJWmrfv3+G9975KkkR4BJ989DHT6ZRb+zfQWuGFxxPjhKeuPWVR4YUlUhod7CgqU+HcgLL0CBmjIo8QBZHWxJHCFhOWv2wx45HCPGAwGHzjN/AIxpNpiKEmLCpSzaKxkMfGzawKIRVKaLR2zIc/n+vv4X2cjmsqV7Kzs02WJhT5GbbO0UqHHiEc+3tb7O9tA1AWJVXtOTwKfWSwsYmMAklVVRUHBwccHB4SJzFf/epX2d7ePr+/98hmRdfldZwhlvu8e6+ntbda+rJU3IuAfZHltPQeXHRuriOLKKAutXp+e98agJfvKmZqLPN9ZpXjuHvf+ePL5LUA96CFrTZHVs1g8+dekEZruKD1X/h94a0X17Mz6VyyIloNc72iLp130flyPWC/rO9263UeEy48CCfAO7ywDb8sZsqnaAaoazQ9KUTj4vSAw7t2+fu5SCFRUuGsQcqIw+MRsVbs7W4jXIn3FoFEqxjrLM6BMVVYUCMaDYSLg6bbBgKIIsm9e7d556132NvNwFfMHIgdsc7TH2zw7W9/k69//Stsb29TViU/e/9DJpOc7/7yL/Nn/vSfJIp04C8IvH5RGCpbo2VYDJX1QgglwjUWA8EpgKSqHMJZPCWCiv2be9hivJCbvfg2Zjpb542Flb3et/HMwUeSpilZFXKqeGdxaYbzHmsdiJCaVgqJ1sFBfN5STT1F2MpPe4MXAqmi5v074kg1FMrFWvnG1/DZp5/y0Wef0x9u8O5X3uPtr7zXWWCkKMsSY8yFdSXOudn7kgsUMN9aZp3vVylqXYBfRX/Mf+6eswxkQ1OLGcC313T/rqI9lmHNTJ9cqdQtli63vpJquoass4fqfeBvA/tN7X7Te/83hBA7wH8OvAN8CvwF7/2xCE/+Nwh7qU6Bv+i9/96qe3TZOOfDsvVlFMy16Rl5rlNfpE/OUX1dKuZcS4cLXeYabX+pvi9vsV7gnWf/P8eP4IsjtOssprbp/AIXtGM8WkWzcsJ7CBMBPjgoPR4vXBOwG7RE58Da8+NCOIyzOCFQBG1dCDfr8AJJXVXBhPeyoWU67dN6Vr1HeoEQhl/+ztebXCgeicE1UBS8q+2Voax+L6Pfy8BbxpMJG8M+v/zHfpHNrU0G/S28dThT0y4/kQh0EoOR4GOkrBGymexkU3gT5ukbcy/ko2n3Drj4+uejNgCU1DjXZjJp2r3JAikkM2bdI3CuZpJPyPNpAB8hkU0fUTIKWSVdSaCDPZnuvve2P4d84L55P/iwbWDW65NPJ2RpTLfjtS5kLxxf+/pXuX3vDr//wx/z4Isv6PWH3Lh5kzRLm67gefbsGVtbW/T7/UvP291fAc6BfF7DXkSnzMbXwknyYvteCb7eN20a2rn7llpl5rzlzsel860L+Lqj8rzfnk8ybk5Pu6jdd9vlOj7FdSZHWE9zN8D/1nv/PSHEEPgdIcR/B/xF4O977/+6EOKvAX8N+I+BPwd8rfn3J4C/2fxdKs5ZyqpEqjgkU6Jtp8uz9Cvh2i+g3xWnXgL2S9C+dhlXHbuOzEClM18t4/GccCGrYiBfO8/hOY/A8AgCWKVpj8pIhKvxyjRGZFdnP6dQvNAk2ZC6jvBCk+c1OlY4Qqie9A584HqFCLaCbWPLPXQT28gu1zBTgwyRtHhvzpdv0wJt65DqNka7JFwyGAwQIuSfUaqHpQFvZZFIXLPJhpAKKT3OyRChIh3ey/NuIoOPISgfDi0EKgrgiVxtYYIgilO8VFRFETj4dmoRnu2dIW9VtwLN4kJ+nuHGkCzN2BwOwkpfZ/HOEmuHFzVyCEJFOO9mb2VmPbaVlgpbN4ukmvTIUqmmrbqzaQMWQBRHDDcG7N+6jdYRn3z+BT/60feZfq9mZ3ePW7dusb+/P1uws0iznt/xqQXxeUBqKZGusjYfOLEoSmT++va6VUDv/UVwb1/r/Hvy/nw6WDTJrLOD1UXrYbkGPm8pLEpBfl7O9dOTwHobZD8GHjefR0KInwB3gV8D/mxz2t8C/iEB3H8N+Ns+1Oa3hBBbQojbTTkLZTqd8sknn7C9s0ea9YijmDiOiNudZGb/Y+nL/jKkqyVI2bmvP3djXcTRc5N7ZhZ2NQbRNclfpmIX63de9sUJUAiBtYbnz581W3RdLqcFTGc9Xnq881gjsDVo7dGRblKlhvehtJqBfW+wzWCzTRkQgO+r7w0oq4ooTpAOvI1xosJTzfTToLWI2V6SLShfrNplwJwd8S2Y++7RTp/ws998E8WhdI/Hjw+4e2sbJSXOizD4BIhZvpHGaSvEhYVGYU4MzmLnHCrSpBtDqqK6UM+2Dl0Lz3lNWXvABDBusFU0E9Jw2GdjuIk3BbGS9NKYXroTTvL1OSfsLbY8w4sxSghwCt1smn1xMg9tKaWgNpaqrhAibZ6jndI77TabFIO1JpUiShJu3t5n++YNJpMp//Af/zMmkwmj0WiW0KvV2i91qTlQ6o6hS+0jLkbeLJok58tpz1vbkclFqzacv/L00AdaTbzTL8NCvZCqt11/MC/t2eE9i+bvZZBf9qzt853X/XL/WnR8kVyLcxdCvAN8F/htYL8D2E8ItA0E4P+ic9mD5tgFcBdC/Drw6wD9fo/j4yOskwyHJmT4s5ZIa7Y2N+kPeih1/YRg6/BnK551rixotzrDu9nsfhGs550/vnm5y/PJdMtYq4atgtYB8Nnd5zQp7z2T8YR/8S/+BcLkbA17nZqd/wuaoUPqc6gytqaqxuBtWMAjNWVZYYwlUgohJcONHeI48MEOj/CStKdIsrCKFR/jrIfxGEzYxUaqwBPXlUHriAva96VnnXEhC+RiJ9daY+z5NmneB4BrHZdKSExVIoTH2rCwhxl1JMLuX1YQEjW5zgR6biXNpg4pqITDiYXju/OqJJNJTe00Fodjws7OFko4hLH4Zqs2fMhXI6TDu7LRHpu0wqIF5Za3buI/rcXZav6G0Gjhvb4i7m2Bl3jXRrKsakqHsSHj5aQoODk7xXvJzZu3+Ct/5X/Nrdt3GAyHs02ll3HdF4r1neRaC3wS4R0t3nNhFXh3Nf5FNJj37eS1akQtWpfim/e/Ytm/n7N8WunoArNDc31jNQasj1PrWv1rg7sQYgD8v4D/jff+bO4lebGoNVaI9/43gd8EuHlzz29vb+GFYTx5ThIPUSqmqioeP35Cr5eyubVBr9e7sC/ksllt0WfRUBKdJ+IioPiOqd+O6PlwI3l+aajEhb9LTb1LP7SD4uK5C05Z+PMqjWn+t8l0ysHBEXf2NjpH/fyURKQDTQGeGzs9nIuo64y6qrAu7KRUSjlL2hU0GzEHGh0IbM4RM148tLetDcV0ysagj5bdAXiuLYX2b4oRIFTcbNbR1t1fGLpCEKKAGnCbledliIYREqQkSUPYphQhugdv8MTnjTt7ve1S87CwSGuFQ6FUTV1bTkenFKMJ/SxjZzCY1bu9dws8zjvCgixBUZbUZsSgn+CtY6Pfo7at1i3Dtm1pghMOiWnqpAGPVDJQSUo1FpINeexnzd18ENDSXM5MEMIhiCmLGu+b5FeLAE9AG30kZIQQMVVtmUymvP3OBl/96nvEaXqpf833tTbn0rm1u3j/A+DCnqXzvy+iY9vj5xO3vATql55p1hXF5fG06JKZkjGvVfvZLN/6Tq4jbV/yl6zNi3jkG7Bo67tI678Oc7EWuAshIgKw/z+89//v5vDTlm4RQtwGnjXHHwL3O5ffa44tFeccT548IS9zdAyRTuj3h/SzbYSXnJwc8ejxQzY2NtjY2Jg5c1otYpG0DTlrBG+bGGxDVdUYY2cmbYgECC+v18uI4yRkyHMXO/Kssy3ZXsv7eYhuJ6Bm4DQDudGX26tm5y4S0f20pibQ1tMYw8HBAfv7+0hfMN/D2ylJSYe3DlPnWFcDFcJ7Ei1JozRcJT29m9sIIcOCFwHWFJTVhCLPcQh0FKFUhJIapaKwv6gITtv21mkac2t/l+EgCxqqczNQOvcFiE7391AHy2eSV8SJRorzIRiAgLCa1XTaRCqkiukN+gihQWmywRCPBiIkDidUA4uiiSqRKC3xPoCgRDRUjMALi05AekNVTVFaUlQFlbNh443mObqA5LzDNx4kpSIQMVJIjHNIoZESzkYjvFdsbm0yrQxZllJZz2RaBI3dOTY3N7FekhuJUr3gWPYTokghsZiqpINknHtUBFDPxkI3Q+GFfhBeMB7H1tYNonQDKwWjs7PgC1igSF0qY44WnOfSu31zEdVyVZldbtq30Tm+A75zFF1z4fnzzVnUARuYu6YF4Pbe7XlN2UJyKQT38l2XPU2nXdp2uHh/f6GdCAyBOw8uXZXqZJGsEy0jgP8b8BPv/f+x89N/DfyHwF9v/v5XneN/VQjxdwiO1NNVfDuE3WJ2dvapjW9ygkcYW1IVBXleYK0lTTPKsuTBgwc8ffqUwSBjONxgZ2ebfm+AUpr25XjvsVVNWZcUxZTT0xPK6YQ8zzGmJooiqrKiKMtmN6KwKURla5Ik4ebNm+zf3OfG7h5xkkADAuuaQ53Gaz8ALbUDs05zfuLiyy98CN1omYnbSlfrUUqR5zk/+fFP+MVvfaVT4sXrTJ3T+Pc69WrbEoSQaBHila0zCG+RCKajQw4PT/joo49BSPr9Ab1+jzTNSLKUJE1I4ghn6hmAp6kiEwowzWR4OSzv4l/JWVHx0QdfcHp6zK/+6i8i9fwq5uZcKVBRSpxm9AYbJGkflSTkeYG3gp2dBJzFKQ2uh6ynCMxsIFtrmrz9rvGxnA9u5y0ykUgcWI9SwTmcu4ok0fiivrCU4hxIQ7ipFBIv1GxACyEQXnJ0eIaIeuzcSKmLM6bOcVrmHB0e8Nad2zMaq9VEnYXp2KCjAuNgo9ej9uehhudg01ie3V62Ivd8ODekSs6yHmn/Pvs3gyP3Iv24WJOcT5M7v4n6VdEf89+7dEur4c8mBk+Lfs001jo6ZfvkF8tbfNfuU8yOXJiIaC140WzBd05vFVWOR5K2O1ddV51fIMFwaJ5bEFx7S6ived5+kayjuf9p4D8Afl8I8f3m2P+OAOr/hRDiLwGfAX+h+e3vEsIgPySEQv5HV93AuRprz/A+oq6hriYgIEt7DIebjEcTTk5OmUymTKcTlBIcHoaNaqMoYmOwyc3dm0gpOT49ZTwaMR6fhgEqRQB0JWcpO4siZzoZM82nTCYB9MOu5Qmml/GzowM++MlPuH3rFptbOww2N7l37z5x2pu9gEVc3/IpvDULL0eczJ+2+HP40l2hNy/LHKv/2q/8Cr/0C7/Iw8/e5+Hnn8zdr3X4CLxQOAxSa6xLsL5GEJa837v/Nts7e1hrKcuCIp8ymYx4+OghURpz/923qMuwu87h4XNqY6jrAAx3bu1x987tUO9GY5EX6KxzjdO3INY8j28ieIyDk9EZwsuQVXEhHwo6Tri5cwudxoSYfYnD43xDD4gwu0rC4iBsFSy6WURHA4giAKHwAZQjrXCAaTh84wy2tggJRZ0Ti2hW7/P3IxprpD0ucRascSFenUAPGeMp65DvHhE2qxjc2EImGqRuuHaPpAkN9QLhPVpplOhw1m0jNBNHrz8kn+aBl5fNxt5uMS3jOx9a3BSN/6gNOxVcpOC6TtEuwHf7IlyOMOlSK90dkLoafTcDY9uebYillHK2k1UA9cbSmylA5/2h/T7vGzvXzrss3uVUAOFDCCsV3s/CJJ2r+eFPfw8fJ/zCV79BGgVqT1zi8Tv9e77NF47hi88Qqn2xbbttdZWsEy3zT1kOW//WgvM98FeuvHNHjJ1ydPxDpMrIkh5x0gMko7FG6RglUrY2E7SOcVubTKchU+HZyQnG1Jz2jnn++AlFkWNNjY40VV1inaU/3AgO2trhvcU2OcedNSgpSaKILI45PTtjOp5ydnqCbwZPPp0i1af0+n2ePHrI2+9+lZ3dXbJeHyU1yNZZtUj7aD4IZoOOuQ54fsI55TLbNMOF+PJWE2vTisL1ZnEpJUmaNCsTF3QID8YqTs9GRFGMl5qnzwo++fx9pKy5eWOPw5Mph0f/A8bWaJ1wY3eXm7ducev+10kixWQ8pi4mGFNh6irQNni0EgwGKVVZ46xF+ACOVe04Ox1hnWN/f3sONuZFoFQT9nYhXOyyfialJI57C8mn9lkvXNHQQKIhT5RWRIkgTsLvdVXhrSFWILUgFx6EDdu+aY11lrPTEdnWFqnWgQcPCwJm2vMsVBGoqpqyCukfZhqZlFTTOmTKFVA5y3haoSNNmA2D9iiknMXbBzCTSNn2qxZEWg3Uk+dlsIlmDkKoy/LCrpzz7YyH6XiM84H/VyqCJm3BhTOX8O7d/jj/r3vOPLB3y+pmWu2WeWEi6dBfYSa63HvO+fPZnec+d4i/TlHtPUUH+Z2zFFVJmmbgPU8On/H87AAfKR4dbPLu7bfRMoSZipnC1FocnXwzTcew1jItpvTSXoeAbOrVTjztc3TG/HUiZeA1WaHqnSLPQ56RuipQoxDV4AWBn/QJziiq0uKsCDmShZtRD8V0zKg6pqoqNjYGSKlI05gkSRiNxnggjWNKZ5lOp2ETYA91USK8pzY1g16fM6aznNvT6ZTRwQEAN2/e5NmTx4xHZ2xsbjLc2GRra4ed3T36/UFYKHWpwbsafWcGn4H97EdmUNDpwG1ObdE53p4DF03XVS/eWsvR0XPGk8lc/c7Nv7w0FOWUOElxWJSKkRKKYspkMubx40eAYDQeo7Xm8NlDPv34p01+lvvkRYG1ns2tTZL+AK0jFI4kblKbnp1SFQU4T1UZTsYTRmenDAcDhFcg7Hx2iE67BO46z3NcXeEsKDlbCXF+atPmXtJkmQwap7VBU25zMQrELADHi7AwKlUuaKiuBG3BukYTtnhncMZhqxNcqnDSEEXnG0mbuqbGE0USWbYu0ADCUng2+imWhNIYnM+Ct8Xac8AUgrPRFIvHCng+OuWsnJIlKXd2bjQBQyKAf7OptZMCtMSrQEW1S24aHQ+E4HRkQVqGGxkKh61KJA4dKaQIKclmU2pjIeE9P/nhD6idZXfvBptbG2xsbALv4TsAPw/i88fnz+nmZmkBfJnmOe887cbKX/ZxiQv4vcx5e/Ea3/nbasMrLGEsh8fP+Oijj/jWt38BKQSfPvkUox1VVfLg8CG3926zmcRYbGethr9AVYXQyVDuk4NH/OTj9/mVb/9xhtl5SGl4IxeDHeYn0lVRRPPyWoA7SJyNUCpFipQyLymLEillWCouNbUpsI3DrNfPqKqwA8xoNCaJYzY3NhkOBwyHA2pjKG3NZDKhcpZYa4SAPM8pioKyLImUJstSyrLE44mTlMxBbSqSJMF7z+72Nnfu3KUsC05Pz3j+/BmTyRhT5hw8eURZG+699RZf+erX6PUGCNWE9uHPdwuao298o41ba1CqcQj7c6AKTsUgSsoZDzgP6u3nVpZpOsbUlEXJJX1NnC/IinREmma0UYBSSvqDIc5PiZOIwaBHFMUMN/rc2L3Brf2b4Erw0EsyJJLaTPHe8dMf/xjnHO997WucnlYzzTXtbxMnPXQksdEpSEXSLAQSM2eE53ygnde3rmtqU2HKiqoO4HouITa/5WKFd3hTU9uKssgx9ZTJNJ/BXxRHzc45MdIZhPOYKj9P29v8/zxySkKsIIo5m4w4Pj5impcIcW5lGbdJtnsDahMWazWLwQJeFkBFohW3bwwCqAqFMTasAhZQ12HFrheAEvT6vRlIhD1FQ12kFNgmdvp87mv7hr+AUc55HJaqqhj2e9iqQCmNkk2ul3ZynGMO0jTh4NEjDg6fc/v2HX7u5/pNPMBi62oV2MwidDr9f10nanv9pfL9+XlSSkK+zMsZbZb5oxbVs6UMF/HbZVXywQcfcHxyxGdffMb+/k2MMzjr2Rps00/75NMpfRnzk08+4L233yXLstnYuuA78J7xdMxP33+fvM45Oj5kkJ2/a++7vX79+i+T1wLcvQNbCCwlkZVkUjIc9hFCkRcFzhoGvcFMC0vThEpLjDH09m7QH/SxzmG9BRwjmzMqCorphCiKsM7z4OFDrDH0+316vR7GWkYuZOjb3dtFCEllKo6OTrG2ptfrMR6P+PTTj3nnnXe4desmR4eHlHnB+OyMW7dvY63j6cMHPHrwkHe/8h733/4KWa+PUCFP+SJNwjnH2WjED3/8+3zrm99ie3MbvGIWLRJGXhhMAooqTDah7zV89RUD5ZIW786h64IjtgF4KXXDcxLGuxD00gF1fYJSgjgJaQkUPkQVBT0TBDhR4XzY6BnnOTk6Js8nfOsb32CQDrFUjMYTyumIk+ODYBUoTb+/wXDQJ44iIukwtkBWYaLFd9YLeKgqQ7+f0d/ZaxznFy2f9lxnDaOjLzBVTV2WHB2f8ODxI54/P2Rra5s7d+7Q62VUdUWSxAwHGVkSg2s2CRGBNT0PrReAwjuPqW2Io/eCXtbHWINS4cS6KLG1CaGdTRbGYHWJhq/24MIK28DaSlyzdaGU0O+nSKk5MyWTMgcpGPSHKKWRNCt3vQ+pCKKIJBEoVaM0IT7f07FGHNIrpI6CdStabtkTpxmTyYg0S1CXCQEg5J+/99bb1KZA4pDedhZ0nfevRZZidzXq/HmL+ukyAG7/zedDr6qK8XjMzs5OQ1e0ocbrR5DM6tMOgXbLzLk6uWYl8ZMnTzg5OQmpmUen+Njz9NlTclNhrWXQ6+OF5dMnn/HJg4+x0vGt975JJMJaEDrKmKsdT549ZTQNlOSnX3zO1tYO24M2THl+Y+5zZWfdNu3KawHuUkKkHNZInBA4rakArSS9rQ1Us6FuXQdt1zmLkgorLNPphIODA6QOuagn5ZSJq0myHkmaYsuQvXBjcwOaLeGiKCLb22QsKjZViqw8Tgo2NodkccyTg+eMx2M2hxskScLnn3+Oc440Thj0+5RlxXQyJYoiyrLk+PSM05NTPvnkY9756ld5772vBe2yofbOHTiBYnj/g/d59PQxSku++53vksY9ZjN1y/tJwcHRIT/56U/49s9/m36/z9OnT7h35y6qCcVcpEoZY3h+8Ixb+7eB0EmPj59STk4vAjvMVAUpJWourDRJeyRVEvhur0JyMG8DuLZav29WtjY+BQ/ESdhsQrQcJKAEOFPSjwRpP+NsUnB2dsRkcoJWsvF99MiybXb3EowpKco8lOEcuzs7/Kk/+atkcYwUpgkPa1RXf96+1lqePPycDz74iC8+f0hR12zubHH/3j1u3bjBxrDPo4cP+fyzz/nKe++w0X8LcIHC8SKkJEBjXOvAAyE1tbM4oVBKk2YZx8en3Ll9C6lliJl3Booq7M8qaPy2nXDAGZnLzKkc+kNDiUeCwhtyUyKkQEdxs4WboXaeREd4PNYYnK+oSoOKXJizW6OnceC20vY129D7gapfHE0ye+dJTBTH9AcDzsYWTN0JB+5y1P4SXx6602Xg6TpKu8fbOi7Sos/PC3x4XkxxzvHw4UMePHjIL33nO+zt7TULxZvVoktkvj6u8ZEJ2S5Yu0h7dOtUVRVZlrG9vc3B8RG1rXl8+Ix4kEGtKauSzx9/TlHllNOc3Od88vhTeoM+7955m1ioWfnehy0tz85OGU/GKKWJ4ojJdEo/ScP6nTkrKlTjsjXUHr1qOnstwB0UQg+obIEzFTYWxF4gRUw+KRDCU9clpmoWbuCDtqkFcRwxnU4wDoZpConG5nWjZYFpTMpelkJVY61FDxJcX+OLiom2KO+oFdiqoJieYX14sc6eNjsLpeR5weHhMXfu3GY43ODg+BglJePJmGmeE2lNmU95/0c/5Pj5M7797W+zsbkd+FJEACohKOuCk/IUkcKz06c8fPaQd+++i5Ia33jVPFDVNR98+jOenz3l+fFNRtOE3//J76O15M7+bcLSIxngs1244j1fPPqCTx9+wubmBsPeBraq+OmPf0g/EmxsDC8AS/jgESpEmgg8qrYkWYKIJNbvoZUhaTq89R4dxyAUECG0Jk6HZP3tkANeCu699RbT6RQdhS3iJGrmUvRNAnQtI7LUkyUx/SxGeIMxjrPTAyaTAhUrknRAlikGwyFJklNXoW/4ZqsoT0gXEEqWSCeprSWONO++8xZv3b9Lrz9AKMHZ6RlFMWF7Z5Nv/NzP8fPf/HoIWRaB5bQ+obYhuVlVVnhfESlBmmqc8JQKiMEUhuOTo2AZFAW1DZt/60jjN3rYwqKcm4HNDKgW9PgA7IKbt3aIb2yRVyEdbzxIgrbjHLk39JMIL4JFmkQyZNWUFuHAG4+PHJ6OleA9TgYtv6yqoD2Khu8VsjnLddwUjQaCD+PPCczZmIPDI6QXvPvOTRCaeeRZpj1ehxO+KuqjXU38k09+xMlkjJmUVKXh4cMH3Lixg5hHwwX1WHgPL4O1jESIkATustPXkOdjPvzkQw5OniMiRTZI+eCzD5mWE/qDAYPGvzetctCgs4hxMebh8SNu7+0TRb2ZJey9Y5KPOJ2cYrzFeSjqgryeUtoBUgsU55PBrC6d8M5gpbTRUR5WTGrw2oC7R0jP9rCH70vGriKVCeUkZ5oXDcXhZ+t+qio48NIsJuv3uXPnLiqJEVpxODmlKiu00DPNOQxiiJMY7R1lXVBOKipnkFKQJDGjyYg4jdi6tcfJo2MA6qpmmueMx2Nu3bqFkoqTk1OU0mxvbQEhPKqsDVaCjyTeOp4dPeef/dY/5969t7lz5w46itBRgowUT06eMrU5uh/jasd4MqauK2SsLwQ9nJ6dcnh8hJBgfc2jJweMp2OePn3Krb39oEHPHErB+B/nY97/4iOQjnE1pd8bMhxu8uf//P+S5w8/4/MvPr3U7hAiMZSUYcGOdxRFiXMCJcN6g8FgEBI14UnS4I9QErZ3b5H0hjjniZux8d7Xt88dwY1DkmkO2JmGr7VG+bDUu6GNiSJFlsXBke4dphxzfATPnoLUks3NTQa9TZI0TKJ5brCubqbCcy2+zYMDgauXSrG3t0d/0A8OY+PwtjxvaBS1ERjvkM16hjiOUWJGqASr0RhG4xH4kGrh+cHz2W2Hm0M2hgPIIjAWURp8J7InS8Mq1qKYtGp9k2HRkSUJKlNMvWM6mVAaM6Pfhv0+w/2bYVclZ8FPkORsDiO8UAgVUi1flED2Z1lE4RRd1b2Fry4N0YU95yzOSYQMXPN0VPD1n0svnOj84g0y1uHRL2jqM4dlp/hZEX4WSHB4csTR9BTrLaqn2Uh7TIscYwyxjrhi/rhw3/be1lkOnx+wd7PdvzfUx7f18uF58mLK8ckRzjv6vQHj6ZjBxpDtdAtjLKenpxRFwWAwCPntG7OtNhWVKXEqbVI6B0uwqirefuctjsenSKUpbcWHn30E3nP/1l2UDmRZVztvJ9X2MWeho+3AWSGvBbgLAGepTI0xisLXVLZmGCcIp1BxzOj5MZOTMUVZEMcR+7dusbO9xWg85uzslP5wAxsrrLNoJZvl2bKJBPN4KciGPWocToGgJkYiI0UlPFEchXBDH7G9d4NyMqGc5mF3eh8mFOcMtTGcnB6jdcg6GMcxw+EQkcaU1nB0cEAWxQx6fX764x/yyUcfoLTAS0/Uz7CppLQlrjakKsYaQ1nXKGWRTVy0tY6j4+eNI9FweHTA0fExzhmKYkqZF/QHUQCJBqRqW/PwyReMpieoRDIpzzDuBs4Yfvbxh6RyeX4bRLNniAxAH2uJMWBlTFFZnPMYWzXWjEUohaf56wMYB9wOaCelbCaesHAH0VnQIs5ThUlCKmGJv6CRBOpMsbW9FSKo6pwyP+DBYYmxPiS2urXPEElRTBG25nyD6OY+gI6Dgxsh8TrBigipLMLXAT6anPZaa4R3AdiQCOVpvctSgFKSvK4RMmxvFzUTom6AwRiLy0uEjBpr5ZwWQQpKUyKQs1w00gdlxguBa2ips8MjrAs5cnSzAMhZi6sNXkUIH5LA4T2WKjxXff4KZ0vPZLuD05idftgvti6L8I7aKKBl49ArdJSg44Qsy5AiCnmDvKf1FszHpsM51z4fqruwv3U2he68rg691Hz1YL3n0fEznp8eoZVikPapy4qNzX1eRFolbzI54/0Pf0Rpcu7duY8QMJmOSNMM5UPbl0XF4eEBOEsURxgcUZxQjysODo6wxjAYbnBje4coijBVSNUspKQoS6ZlwXa8cf5ehCBJEg4eHjR7CBSIsiROYg6PDrixvUMcJRcovdAs7UQsmlQa4Xe1lFw7l9cC3BGgYo2TDovD2LAZQJV4auFRykMvITGOvf2b3LlzmzRNEEIwzXMqayg01HUJQpAmSYiCMAH4pJJ4PGVdYYXHShUATUm01kynU2ZLQQTNsnEYDMIWcdZaNjb2qJOK05MTnDEUZUFVVSG2Os1wUuA89Pp9qAxlWaK1pijC3qTGWQbCo+KIui6wlSXtxTx58ph8VBDrlCiKsSZEThyeHIP3aKU4PDpkMpmglebw+IDv/+h7xFFCEicM+kOyrE+Uxjw9eoaIBF44vnj0OTv9fZ4+fsTT4wM2Un15om8OSCmIogRT5xTWsNlv9oukR2VuNwtgYJD0yNKwa5NAoDyIkNCdkAFPNHw8DR0VOqdvCcKG04y0QinRgFg76TTkuXezDtzGn0daEvV7DPtpw8HWfPHhR5TGsLV7g73dXbIsRUwn5PYIZy3ehpuKBjWEzDg4PGZ/e4DQMcYLhJs2uWtEx8MmkLL1FgTt2tmwmClL05DfxUEUaSIVNiqpbQ1JhFMaVRm8DRudCAdHR2OMU6RZL4TnpjHYNjeMQ9SeWlT0N4Yk1pOXU2KlQ+bJKKL0jsE5tjKn686xEk1skmsucE265Zl662kjby70Ad9eLdjeuUGcBIuvqip0HM3OXhbCeHB4SBRFbG5uroScEO1ykS2eTfYXLhQgHHk+5fD4kDgKi5pMXWHKmoPD5xwdH3Fzd+/SRDIflXM5fNDx+OljDsfHxM8ec3Nvn6oq+J0f/g98/b1f4M72Leqy5uD5c54+fYIQAus8SoiAE0pwY3cX5xxxkhLHIQeW854kTamriul0wtl4zK3+jVmI73Q65aOPPuLBw4cYEUK441g31qHj8OgQ4QQb/Y1Lk2J47eeml/e+2afiXwHN3TlPSY0aJkhvSHUaAFYHdrAuS3rbPUajM5599CGfffZZszw8aEfbe7tEGpJ+D1eBMTVahhWGHo+zYISnNh6VRXgfsiAKqXDOksQRRVlS5TV6kNDf7hNJyenRKWl/QKQjxtOczeEGaa/H40ePGI3G3Ny9QZImiDhiggm76MiM6mxMpCRVWSCVoqhrdC/BR4rahF10vPLBaqgtR6NnSGvQMqYsS4RWWBTGO4RqdgISYbs37z1uAoWpqI7GmLwmSzNu3ttnZMuwSAaDGXo+f/IJn3/0cdC2kowLziPOnaKingYAsAZcjcM00RyghAMnkV6SRRLR1EFIqIoTXO45OT4BwkQZNhJWqCgKuVpUcIqGOGpH1ORoCWDf5BpvdRPRgmobARLAWYkU601Ta0caa3Y2h1S2pipGfPHpKc5LkrTP3q39ZgHaGcX4LGiKzWIg4QNXj5MIUeGaVZhCSJQFRKAkhHAgJE56TKoRQiJNTexjvJQU04I4imfRMgqN9R6nBQKFN6BMoKaOTyecnFpUNGa4qbh1ax+sZ2PQp7IjvFJ4oShHZ0zzHOssU2Mpy5Lbt28hBwMmSiCTBGkUUqZ4DM7mASidxXt7Dpodqg4Ie7A2FoP3tm34C+NP0IZXhp2ppI7oRTFZX2BNhRMh/rqFyFn8thA8evKI7/3g++zduMF3f/GXieY2uA8SJhshPJWxqEij2g20Z3OUvzBfVcbyyaPPODg5oDA5Uiq2+pskSUxRFTx+/jisq9DxjMoQol3Zeu73mD1jA/LOW04mJ3hgWk4ZTU45PH3O0eSU7//0d+l9908RuxA8YL3FS0h6CT4Sgeqt4Ww0BiHoSYltUv/qSKOFYNjvIaWmLKfk5ZRe1sM7x+HJIcdnx3gZ/ITeB+sgjmPKusTikTpqDN52wvXUdcHB8RH7ezfD2FB+hmvG1KyS1wPcvUPHisrVnI1HRHFMnCYgPEkaYRuNcLi9yZCE4WBAFMeUVUVdV6AlIk2YFjm2Mgx6fbAW6zzWO6RUIUbYOZQQqCRGu/BCnLdMphPihhO31oCOSbOEdP8WT54+xnjXZOwDJRV3bt/m9PhkFsMrmpWDtQ2TinOWvCzp9/qY2jDopaQ7G5DFjPMzkjShFBWWFrwlmoTjozO8cPSHfZBhz1I8CBU6kfceESksjiSN8IlGGsj6KVY4jK3p9/ugPGeTEaayFKYkixKUVguigQEE3lvkTCsMMdpuZha2cftNrpSZ9iA4PHhGXdc8efwkLK5xbRIvCRKiOGZjuMnGxmazMlKE5CjSQwP2gYaZAxwfOnjLgRa25ujkjPHZGXfv7hOroNlJAUkcsb3ZQyvNaJLz4c9+glKK7d0b7N26B7ZmPMmDhZWk7NzYR0URZ2dHFGcHtBkm6TwtoXYo60MMvgp9xTiNsiFxVdhqThNFEUmSEGkFxmGkJxLnVkxdG/KiJhYCFcV4EXLYeOFBK86mBUVliLMQqTIajxiNRighmZyNGegEFWcIbylMSERWVwrvqrDBeT+lzKezibHxoqB0jKlLQohtsMSsrWfW0wV873w+z1Wu8PZ8pb8nrJJuc8Y45zg+OeQHP/4+4+IE8yzn9vPb3Nu/c3HTlfYWImRU/PjzT9nd3+fm5vaFeweHoW/6I9TWMs7H9Ic9YheRJhnKSVxlEMCzo2fcHt3mxvYestlYZcYMrpDRZMzR8WHg7NMELz3j6QiLZ5SPefD8EV+79xXiNMZ6j9ASqRVWwjSfcnh4RJHnSC0xzoZ2NQaldbM+xpJlGV+9/Q5ZlgEwycc4b7ixf4PRwwmT6ZSiKJBIrLEhP40MazCeP3/OjRu7eB+sw5PTE3724QfEUUSaJERac3JyTGkDe7BKXgtwD47JYNonSUxdG6YTS9bLiLXCK4mxlqSXkBCD8YzHYyKtSZMUlcZUwtGLEkTWR3iojcXDLAGUtx4rBcZZyqoOg8ybxjmoscZijUU6KG2BmZRkMmNjY4PK1EEDAvKiQEhBvL3B0dEJN7MUIT0SSaSCCRsPe+ja0UvS4DRUEhcpcleHLeiaZGjWWHpZD6cUzks2t7coypJRUVI7y3A4wBFMOq11yGrpLN4pTO2J0gQlYmSWMqkKSlOhVaBynHDUvmJrZ4M722/hygkno/xS7/eAF5IKEZKC6ZiqjBnlR2gtSOIIJWUzabVRGQEApFBsDDOSKJ2FmIHH2SY3OLC5GWJ4nTHNr6LZKs5jnCfWfuGADIuSgvNyNJ7yu9/7AVJ47t27fYHHDB9AKuj1Ivb8AOcc09ERP3ryiDjtcff+Oww3N0EqdJoSJQliUoQ0vhhaxnrGWEiBFzL4A4zHV5aDo0OSNKYuK/r9PnEcM52OOTw8JEmCwjGI4xDlZR3SBn7UueB0D+2lZ20uBIjaIb0nG/YwzlAUBQ7Y2dlBN4640hp2CYoJQoN3WGPRWtCujehOjcIH7TtOQi5950K6X984+oRX3Tn6Ul84O3lOnk+IoxQlQyis8J3yZzSHZzQZM5qeYWxNXlrOJsfUZo9EJ3PGgUB6ycHRM37409/nfn7G7nd+GdmkOg7KV5PCt+0XccTt/X2enT7HVobj8SGJSsnSjEme4xI4GY/YHGwT65DEDR/ok6WRPNbx+NEj8iJHa8XB4fOwgEw44iSjNjWPnj3CloZMh3eal9MQwjiZcHx2gkCyublFkqYkaUQSx+CgqisQIVVGlCQ8OXxOTw3YG+6QpX12NgWPnj8jn+Z459jZ3kbrqMlzZDk+OqQuKp4+eczd0V0mozG/+Au/wMnpMUWV83s//X2ElKRZyngyDlFaKFbJawHuMtb4fkwxHaGUpNdLGU0m1HWJ1grrmq3e4pjxeML44JhEx/Rv3CDt96iEw7oKU1tcUQRL31ikl2FxkwOkR0cKU9c4D3EvRkeSySRnOpmGSIsoOCmdllQYYmNol0tbY3j44AF7N2/S2xjitCAa9hmVBYONpNFcg7+g18uQ04peLyWKE0rvKGNPkY/whCgOU9f0eyFtcV3VeOeIkKT9HmUBsQ5+gboKiyV0k1tmOp0QaYVOE0Ts8N7gpMMLR5alWB9y5yAEKg2UQxKllGV+TtnOjexp4Tk6PmRzGEIlT04LfvSz93GuZmdrg7qquLF7g7Is2L2xw96N3ZCQSklEFCGcQzqHjqJZUjDhBUkcIxVMJxOg0ToNHJ9NOD09IUk09+7cuFwhYBbeIQRKBnpAqBAz32WdZ/HQBB5SxhotNYPNlLtxhkVyeHTCFw8esb29w+bWgNT7sImIUAgMSgiclCAVUUNjeOGwAoRWaCRJHHN8fEqRh3bs9XpsbYWJqygKjLH4TOKlxgqPqw3SWFTjMJVK4VzTl7zDSY9LNFk/Ia8qhFUza6nX7880ZCEkORalLXgFLqQiECrklpmtaJ41YdCaR5MS7wVRlAbqxlUIAWmSgbAsanOP54P3f8rhyRmDwYDd7RvcvXMXOjbfLOLEOsbTCV5AkqR4PA8fP2J3uMfe9g20VueKhPeMphN+9P5PcMJyfHzA8fER21s7RFE80/SFaDz7DnIz4enBAdZ7sjSjl/bwFnQcI7XCCcE4n4SFi6JVBrgE7F2AbwMCojRhMpngq4IoibDOMZqOERJGYsze9j5379zh8PkTJsaiophelpH1M4q8pKpqYqmwecV4Ws4oK6UVutdDSkleFTw5fkoaxWihefD0CbU1YetHKTA25MtXQhEnEaejk7B3bl3wyWef4ErD9tYWBwfPMabGuKCIlnlObWtsHSHqFVk+eU3AHecpxznToqCocra2tknSdNbBkzQNaXm9QPRjZD8hjXoY7zDOcTI9IzcVCkGkwvJyj8S6kItbS4WQnto6VCVQFryvyKWjKisiFaG9IOuFLf78pGR8cIKRBWmvF5IZKcXO3g7TKieTAxAw3Npo8sLboL1LhSbQEpOywNV1yJ+SJdRApDTT6YR8MiVWEaqnsaXFVy5oWYmmNhV1XeK8JonjsFwcwXQclvcrrZEqOGIsFqEIDk6lqIxlNDrDSUcSx3gL0SDFW4s3NlAMvuW4W547REnHUeDLnQ2hgIPBkOn0hCSJMKYiLyfUJkTvNMYz4EN0hlSNDyPi0ZOnCCTvvvUWsfJ4XzdUR1hxY52nNBXIEKE0n+FRiPO6hbj/hrH1jrp2TWKp5uQZz+yQwhNHMf2teyGffLPQy0uI0wF7xjKZTDg9OWV4byPs1Stl4zwPXLW1lroyxELipUMhsJXhJJ8yno5BwObmJlVVU5Ulk3FYjKJ0FCwy58EYpHNIF4Z8XYVUGmk2oCprrLENzQUeST4pgyWpPCfHx3ggyzJ0FBFFwWpyUkAk0S7C+wglQpZHpJ05sJkRX8GBfXIyBeUZDPsMspRqWgenuTVEuqHfZrZW0/YI7t1/i7v3JVUdksC5YsSTx59TlRIvJXs3b7Kxucnx8RFHhwfYOmzlZ4zBVZ4nT58w7A8YxMNmy8Lg1/ri0QOePn2GcZYsC5NXJGUn6iPM2s45xpMJnz78lJPJCB1HVHnO0dExcZQwHG42zn/Lo0eP2d3c5e5eoIJCPzl/mnNcD3Hmpa2xAqbjKXGSoKKwcbk1lkFvwCSfMM1zTs6O+MlHFWf5FFNbpLQkw4TKhWCH09EZPs9D9JwUaCXZ2NwMi8bGY2JTE6mYjWTAwycPqGuL0pppPiWwFKGeOgoZj2pTY6wlI0Rmee+wwvHBZx9isSBDmGqImKpx1mCsx5aLidZWXg9wF4LcBs/8zrA/22bPmJDFUUcO60IO8ayfEu3uYMclpamYnpbU1pKlgbM0tWkyNQoQMugxPgQUSSFRMgJnKKYF0zqnKoI5tdnrU0cV5bRAlY5hf4gUEuvtLMRrsDFkM1YIQgSCkBIdhZSw1jpKY0KHQdDb2mRydIw9OaF4XhPvDNCRIiMmTRXSS+qTAksZAC3SgeCMFGkSFrJIpZicnHF2dkaso1mEkLOOOJUgNDrRCBcWPRljEUhiBKaoqX3FlCmfP/sZsa9pfVjnEnq/1oE79g1PjNT0en2cmxDFmtSFzUu0VrOFPy24tyVKH1aIfvHwIfl0yu1bd4h7CuEdCEeSRFR1HZyXShE3i38WOfjmOgemydli6pLa1Kg4On+CNtIjvG50FKiwCyv5fHACDodDbuxuB448ysmbZwgOdt/QGH5WqBcCqwUikvSHYc+AuqyQolkTYF3odzJMXFXD47rah3BHBxvDPrWNkUpQFlPyicJbg9gahA3IpyVFUeG0ZWtzEy9CYjzvPXmeA4GmSZAhXNO3oYgzL+lFsrlxxHkvQjRGw7dLFRGngXqIs4g4jlBSzfaM7Q8t1ofQ1V7S59GjB3z/n/wT/ld/7pu45z/g//v+iAeTmu9891f4pV/6JdI04e7tO6RpOsuxo5Tm9v4t4iSajTlrA92kpObt+1+hNDVSSkxlscYR8umH8RWmWQe+pphOGI9GFLYCY9je2CSKY5QQGAuJDhp/ZU0AStWUMVs525p4TYw7gtFkwsHxId57pkXBQA9oc+3neU4SJVhrOTk+4sQchrBfB8oa8lHJ6fiE09GYvCgZSEldVZRKEPV7F9KaVKYGPNPJhFM7wlSGSEWUVcFoPEZIQZQkJEmMqWuqssY76GcZNJOQl55plSN0oJZNWSKVRuskOPKdQ8l/FRYxCUh7KaPJmJOTE+I4pKiNk5goDs5A4STCBQeHl4HHvLG9i04TxlVY7NS+WOfPNzOWqIbXCyFHxlQorUiiLKQ1UBlKaCbjEdIJ+hubHEwPwDg2+8PZGJJCoIVBWIvwowbcZODYXD/sxOM89UgwLmqSNCPSmr3tXQ4Pj7HTChlH9IWkNgEYhNKEjevCC8zPRggBmzf38MZg8oKejkl2dpFNDLrDIaTEVgbjDUIovA1cZRLHQT+uKpASVzjGxZjxyYi7ezv05GKOTkqJbnPFE7TkXtanNnGTvC1YQ8acxzK3tIlzFt8sMpPek8Zx2Cmpu7TbByoqOE/Db1rrCxs6zKI7OitoW8UrLKqCujJUpSHtgLuYYVwAZdHZuLgD7w110ay0Ne2CKo9qVvoC6FiSaIFWDisEpTMgJWVRcXR8EpasEyinliMej0eNZibJtSS9cxulZRO6KHj7rfu8/W7YpMPYQCHUrsbpkEBMqwytBKdnR3jvMSaAYa93vt9tv9dD9VJ0JlAVqCrkpInjmMFwgyTJ0EqjdUQchTDKez4iysKm5okOConUEUKq80RVtpNtUUCNB6GRDrRO+NafPuRPvpUGymok+L9+pMiyjNPTExCWjcEGG4ON8wR3gELgqoq8MrM5RwrJvbv3uHv77iyXPUCeVwhRNw58FyZW4XHOcH//HoNkSH84bPIJ0ayn8DgcVVVR1jbw+52c7jOfgG/7gGcymeC84+DogMrUDDc2KeuK0dmIXq9HmqXBv1PVxEkSbCAFsY7RsaIwFeVZSSQi9vf2kbGkODrGW89JWYSd24RoqxEcz1pRVEXwMeHJqyllVWKMmWnsuJC0zxpPaUqm+TTsOxFLbF2HhXS2wltP5EEYD3WFdw7nbGcsLpbXAtyddQgf4so3NjYQQnF0eIT3IJCYqkbHGltbTLN45sbWDhu9AbWtib0kyfqBx5pOMfZ88AaM8SHRk5cIBdaEcCJsAJ2izIm15tFHX3Bjr8JUBVpHuAzG4zHeObI0wxQh6qauJWVZEvdisiwOA9UrpPBEGKw0xLGgyi3HJ0ds7+xgfdgZKo5iRtMQilnYglqEsqMsIyIlH48Z5xNSIXFlTewVXkryoiDqJSQ6whUVFR6pJUKDQ4ScPJXB1RZhfLBenMci6A8HJGmKXxI6JURYCyCFaNhVR5b1yMsYIcRsO0NrbbOKLsgsMkNqnAchFVnaC3t+SgBLmxrhfJGTb7L5aZRatLnBecmtJEnMN7/5c/TSmMGgxwz2mxngPIzbg7cztsaaGqzB5FNAATpkkKQFCodwIKXBiyY8VjiMs+DluaOrNiRJjHWONEmQzUTYRo/Y2gYHuTfYqka5xoyQEm8tmNCqzdYbgWopCqQCYRymnNLr90OSu7oOkRRSEseh/afjMdo5VLxJWVnywpCkiht7e9zcDStYi7KirmqMNdjaU5kJJ+MmD49zjM7OKKs6TE4yKD91GaxWrVRIq1zXWO+RPuTR+bfvZHhfIEoQZYEwih/84Af83g8s1lYoKYmkJIrjWeSYijS9fo9eb4D3DlPXKKXRKgqxSEIw6A9I07RpQ0kcJyRJ0JrrukLKkBF1mKQkUqPjNIRotpuBCNckUzvvI3VdnzvEvTifCJynqixCCu7fe5fNzW2qumI8nZAXxaw/bqUDjDPUzlKWYRMXKk9d1kjn6fkYVIxUEUoLrFTEWUq2s81odMrR4RGbdpN+r0caJ3jjMdMq9BUJ3toQracVaUM5O2MDVrmwA10Uh+0fqWsoS5z3pCoiUTEq0hRFwaSYYuowCZ1vWrJYXgtwV1IiZHAQlWVFVdZkWYapDOVoGnbCKQxaarT1aBHhrOXw8ABjw8bBkQqLSjKp0crjlaAyBmtCyJxUAqzHO4PQerayUoiQoc8Yy/7N2xjjyNJ+iF/3IsQzNxZeVVdYa9BaUVYV2XADa3WgejykWUIca5JqSmVL0kRTTKZM8rA588awj1aSyXSEx5EqjbM11bQgQbExGBAnCdOixqYaLSCTTTinckCJLexs+y2nJE5HnE2neA+DNMMag3YhpltgG3ZdolWMN2FRS7u7TxsEqKQiShK884gadKRR0YBdeRso0TqsvMzzaUg/AAihGGxskqYDQDZ7VEi+/o0+dV0SpwOcsOA1XtTQRKUIqYjiGLycrcQEOPcKNtFNs8Uunr3dDfZ2N5vj9SylRhjMTabL5knz8WnYLNsbvLUYUzEejQCJ0ilbWz3U5kbYXrGs0NpjXZMSWRAWZnmFabT/LOthZcloMkVHEVmvN9spSGkdopiaRGO1CZuJ10KgrUN2UjnDef50H0hzPGCEw3qPraoAAM2OQ/iQK957z3AwJEpTRAjloizGVKXi008+5/OPPsPWddB8bdjoAgGTaUleVcRas7uzhamDNWltSRI3dF4WNdFkYSOROJYYC0pnHJ0c8w8+rfC1whZTfuuJpxaKCM/e/g2KKmc0HjHxFleNcd4hESQqpi4sp+MTtAxZXctmS0sQVFWIPIt0iHXXKiKOE+I4xhhDXVcICVHjc4ijhMHGcBbOLEWIEx8MB/TTHrGOMK7xd8WBbpIiKCpKKZQQDHoZ7crnQXorkD++id33EPYqbVb/NrRX2H7ThOAHE95tVVXkRUllStQwrDwejXMSNM5XqEmBKTxGNk7n2pKlA5SOwAk2B0OEktS1wZia6aQgSRJ6vWy2GY1vdpeKewOUlAyyjHpaIhCUpiKKUgaDTZxznJ6ersTVdfZQTYF/DCTN+f+l9/4/EUK8C/wdYBf4HeA/8N5XQogE+NvAHwMOgX/He//pFTfBeIs3jrIIYJIkKYn2lEdn6NKEDHiZxuKQwnI6zZmMR/STjF6aYeqSKI7xZU1EGDyFMVjrkVqHDRycR8uwH2hpK3CgREhOJXxY0musDdRPCLlh0AsmW57nHBwdsLm5iQMGm5ukWcbz5wcoqcmyjGG/x+nJiKzXYyMbMs2npP2I2lWYYkxVj4i0RamcJPMIaYmLErxCyxHObVDUAxASC6SZR/knKFdjLCF0KjF4p7FW4H2EqwxppIl0jHclUjocunG+RmQ65e17X2EQaeqioCyLkErBW2Sz5ZDwCiEUtjLN4ooC42qq2lKbSZNwLGi0renphSTpbaF00mjOEuugv5GEiQeHxeN9ihV5EzvtGo22ccm25nOHcj/fuyjE1gcONkwMIQbfBSrqUjSExFnH6PQJz58fcHBw0ESxGLI05eb+TW7s3gRvcM5R1XmYAETriAxLQGskpfAUwmOdxUrBZDpF6UB3TKZTYq3DTkxFEcAdP9uHV2U9nFTUqQqO1doga4IzWxJmDxk21Chqw9OTo9mS85ZWlFKiGr+Bc47JZIKSkrQfIZVndysjjh1SxqRKUTWOOppFX97D1nCAaajJJEmopCfJNFVRkjYrhJuhB4TlB9570rSP0ANGkxH//Hu/z48+G3L71j5RlOCp0LGmv9lDlB4fhUzqeZ5T1yFNdhJrYq3RzSrMtOgFZ2vzBsejCaPRiEHWY5hkeAtbW9tMJ1OUCmGak+mYoiwZ5xPcZMyzg+cYY4NFBU2aDhHGstJY65tJQpNmKb00JU0SNjc3AsUbaWRDA0ZR1GjO4Xvwz4XtJIUM4cxtf2r7V/jXOvmZhbY6woRaFBVVOaUqC+oaTk6PMKaiqoLPpCjKQAtLQV3VlEWBdQ6tVQiwyKckSYyWkjhqFsQh6CnNZDxlOppQl8Giu337NnVd8+zZs1kOpWWyjuZeAv+m934shIiAfyqE+G+A3wD+T977vyOE+L8Afwn4m83fY+/9e0KIfxf4PwD/zqobOBfMLKFlMNdkANc4jZHDPtXzU2ItkdMKpT1Z1qc/2GAQZ0RxTBrHeGvo9wecnJwER5QP3JdrcryDCtSDjvBSkMYZWilipdBSobUmThKMM0zLnNFoDAQnoUQQRcFEHo1G7O/fIk0ztIrY3NhqVjmG1abDjQ0+//wBb7/9Fjdv7lPVFc+ePmU6yYkijZCSLNtAWomzOZGeImQdVkzKirIqUTLGWkFVWyKZIFFo5ZEiQqLxskTpKrB54iQk7fIRSEWtBF7GREkIpezFAx598SlJlDIcbOK8IunvkGYpaZyRxEnwxvsCUzvqoiIZhCXU01xRVCF6o6oqlKqRUuObyBeQeC8bn167q/t5tAu4NstsAzzhF+lFE61yUbNt5cLy69kpnu5q1va67rnBCR9CUd955+0ZrSGgceAmaB2cuJFW+CgipPxVYZGYEBRCUjXOe60Eo9qQpinDKEZFEc4E525ZFkyLgixN0UlCFGnqumYyneCUYpMeqln9KuKQwEvYQJlZEVY+CiHY2t7GNStStdZEWs+eK0mSkF+orMBZinxMJDRp0myd585XLYdwRQ+Nw9vbAkVIpWDrItBVzabd5zv5homgdUB7H/YtVsmQnZ2bxCqmnOQ8evCIja0ddJrhnWN0dExtKpCCvC5ndZ+MJ9goJtrYDAu0RmFBolQKYw1FUeKlYOvGDSIVdjwTxnJyekBdGQa9IcONDbZ3NjgbjZg0qX7zSYGOI6JeGiz1kDKfPJ+G1NoG6rLGexiNz3j65BHO2tlmOM4FP0yShjj5wWDA5uZmmPSqqsnvHxFpTW8wbCaBmF6/12xwIpGyXX0twxabNFq2FKRRD4ZbHUR7F2tdExASMtFWdcmkmGK9pSgKijLHmJrJZBzyzEhFXVYkKiMWjjKfcnZ2jCI42J8/fw7eM9wYcnZ6Rr/fZzIer4LVtfZQ9UBbStT888C/Cfz7zfG/BfzvCeD+a81ngP8S+E+FEMKvShvngzOwtgbnLXVZNmFRKdo7okhjq5qz41N6vT6j0xF5ntMfDPBAr5eFPOsnZZP/ITglUiuImsxxwguUbBJdGUsaa2IVeE2tFePJlLzIGWxssDHcIk1DugMBDPsDJtMp+43JVpYVvd4A5zxRFHJL9HohwsV4y81bt/n408+4c/sWWZKwtbGFrQ0HB4dIpXhSPCNJEu7dv4dMQi4JLTxGSNKsZDqZYKiQxETREOlKEAbrPaZWeBcjWnD0LjgRAYQn8h4hamSziMjLkuFmgjSOo8PPmExzrAlmaaTDjkYCgVQxvcGAOOnhlaK3mbG7/xaD3jeakMXz3CL5dEKRj4mTCO8IawWKaQBaF+KSpZINJe4a3l00GhL0kwihdNDCm+XzbdTGjMmfxctDC0eyjX6YReqE792JQang9Ot2NylD+l6lVchbj7sQW51XJvChpNS1QQgbNOxEEvdSoiyjqkNK4yzLODo8xjnL+OwMZwx9IfBKoWTIXuldjZGgaoeug5KikzTEVgMmFtgocMbm9Iw8z/Heh2gQpRqKMmj3cRpyfUcqRH45ESZTWRukaVYNnyeeufDc3TRhnsD7ziJN5+bPc64rbNqytbnJztZWSPWhoCgNd+6/Hbh1JVE65vnBc87G4xmA9tIM6UP6D2NDcrN8nGMFHJ2eUFUlURIzTDRCa4y3FNMRlBVKaKaTMcaU6Fg3jxUsDxREaRT4+TSmrArqqiTJEuIoRnjBcHNIEse4ouT06DREP7WWEILpZEJVVpwVJYfPn2NM4MPxHmMdzjX+ozisNE3TOEQpJUnjd4qb42mY7Ad9kigK+xfQOlPbdBZhbYaMFDR5cZzrsbmxjYfZXgGe4G9sNyEydUlVFUynI05OThiPRigheP7sWdhfIY4pSkOc9ZlWFVF/sBRSYU3OXYSt5H8HeA/4PwMfASc+JNcGeADcbT7fBb5oOpoRQpwSqJuDuTJ/Hfh1CJEyzrrmn20WMvWIlMb5AhKLczkbOwIpJiit2NpLAYPDIUWNUyF7YzwQKBURqSGRjZiMqyYELzj+bu7tUhUlxtQkiSaKw+pUpRWjk1MePX7Mjf199vZucGt/H2sMRV6ElLPDIaPRiEePnyAE6ChCSUeSpBwdHZElGRsbveC0c/CjH/6I6WTCoN9j/9Y+WZqidMTu7i6PHz/m0ZPHbO5tEycJiVY4B2VV0ev10IlGOo/UimrqKKY1SgeHoKkg0j2UipBCNeGeYXwKIYl0jNQh8VQiMvZ236aYHGPLgliEmAYpwuYkUgTnorVQVIbTs6cUtcFaF2LaXcgNLoQgzVL6/QFxmrK1uU0UaXpZn7yY8uFHP+Phw4doIfnX/8yfIYo81pQY53DOzCgDhEHpczBy0iEb7f98x5+GCyWkDtMywthz64ALID+7AjrfL2bWUzi5ibUh7jqwdudxoVLGCFmHXFtCIlKJlQ4tLLFUHJ2e8fTZ8xnFc3o6Io4jjDFMp1PGk0nYmrDXY3M4JI4irIJSe6zymKqGokYJASoAuxVQ5QXGhQ23ozhGNzRBlRdMphPyvGB3dydYG3FEgmqydzaRSJGE2oHruKB92x7NwzV/lJJ4ZxEEf8z5gv1mz9m2rZwFHxbvbW/v8Mknn+K8Z+/mHoKwGYwzlnE+QkrJ3o0bITIkL2YavJBhQxzbpABRQBLHJHGMkIJ8PKWUORvDIZt7O0xPzihOJ6SxojYV0zI4DXWzOUrpwspx6Tw2L9FKIHVIP+IxeAOj8ow8Unhj6WV9QFCVZbDWkSF/VJWDhHwyQYmwlsB5HxZknY2QSqOajVKOj484OTlGIDDWhEVqXszAvd/vcXN3l+EwLGSrjUE0ikUcJ2GxUgP0/f5gZkVIIQIH30QpeQnEBCrTJcAQzx5vvR3GgLUWU1XY2uCspSiDD6Nd3Pjf/r1/sAS11wR3HzIO/ZIQYgv4/wDfWOe6K8r8TeA3AYbbQz8dTSlNEUKzlGAyOiOSil6iyLZi5FAHbcsGOgBiqspSTHMQiihK0HGMSgKPvLuxS5kblAzJeaQMsbBSgBQxTx6fcHp2zJ07dxonYUjmNM2nPH74xf+fuj+LsTRN8/uw37t8+1kjMiL32quX6p7uWXo2DpchRXEZUaZNkRBtwxYgwbo1YBg2dOcL+cLwhW1AgAwBvCAFGITtGxICJBlch8NlTM4MZ3qml+rq2jIrK5dYz/Zt7+KL5z0nsmq6e4YQaTS/QmZlZkScOPEtz/u8/+e/sL6+ZLGYk2UZ1uZsLi6Zzeac3jpFG8vqekUI0nHNZjOsVkzqknazE6aNGyFG3v7Cm6zXaz786EO6rmW2mFM3DZN5Q1lV5FWONzCmMOm6Fj8K7wQm0KakqUtwKzbtjjzLyUwgNznWZrhxZLNZC3PBWIqyoMg0ZSldINGjgk/PcYIJiHIeEIonWqOsolTik9GU0tEf0BCAIMXe7S7ZXY08e/QBo/NkWYmxlmeffsqjjz7m1q0lVVMxXx5RlBVGa9zQ0223dLsNEq4kBmU6DonqotP7ujEYQ8nDHLVm9A4fBDoQVOVmGLw/1Gfe7OcPhY+Wy8tLTu7fFUzzQLWMoLQAPkbcSTFOqIYBtpsdq8sriGCNxTlPURTJN94miqiTrbyxhFG8ibQXJs4QIxdX1zz95Dl3ThbcuXsLohbujtEsZlMi0A0yPLVKc73d0rUt280GFSO3Tk7El0aLTYWKEJzYPJTapOnGzc+qtaGZNGy2W0J4Ca4RDCbh7GkxlO2ddJ/Rc3H+jIAmKs2Ls+e8/sabHN1aElWk7ToinqvNmk0ris5h6FPTETBa0fU71CZS143YWfc9zosDZl7khCDDW6UsQz9SmIxMachzylpYMeN2TQiRru+x2qJ9T+xzXDfStS1FKb7/xnt8NxLRKEZ8vyPPStrdGu8EOptMJhJSYjRmmuE1ZGMu91YAk+XYXCIayzKnqhqBGW8tGEcxq3POMbgRH+T8jX7kenvB2cVzdMzQMWXFGpOwfEtdV1SVaDmOj25RVTVlWUgCU5bJXNFmhzlAllmM+lxmrNIYm5HbDJVYXlNuPueHWnin41+JLRNjvFJK/X3gF4GFUsqm7v0B8En6tE+Ah8BjpZQF5shg9YcfKjEIgsKa7MBXLScNXT9gQo5qPTbKMNSNgXbXsd2tqcpKlF+65eTeHQbEIa8NDpNlZBiC9/R9l4q7cLGPbx0Rg2ccR4q8oqkaMpszmS949PgJjz95zKefPuXOnTuUZUmMkQ8++JC7d+9yeucOfT/w4rlIg/M859bxMZkV9kHXtUxnNcbC448/pplM+NKXvige2VoJc0ApMJpuHClsmYZfEhsYQqQoCowxbPuO/nJNu1pjmpIiszR1wbxpKIqc7XYDDGTWUhUV0+mUF8/PGIaB4+Nj8ryg79eMruWAU3/uxhi9ph3GZB1gePrsknbYyg6qrPDBU9cV3nuqomZRZ6jgBGYpS1brDYvFnNunp9RNze/93rfkZ8gteV7S1BNu377DYnkHmxmKIic6xzi0DP2WsduKJ7qKBGUEt48C6SgUq/WO3/nmNwku8Au/+LPkeZJQ7TnaUaG0BXfjNa7UDXVuD+vczAb2EFCaAWhFjBawaOfJrEIHsXpdtVuyqiSmTtQoTaWNxAOm8Oq971BEuvEKiW1WIfL4k0+5uOq4f/8+daWJ2oCLFEpjvGK12/H08kJgn2RsF7z8HHt9QV1VorgN8OzTM148O+PtNx5irdgtfNalPaac3o0wctKiKa29oqmblwbUv38x7LqWXT+w2ba8uHhBVlR0ruXo6IiIYvSO0hbMF6LI7HppyJokqzcJS8casiKjD14skRVsd4KR73cofd+TK9AEgnZs2ssUzl5hdMCN4ELLMLSoaKiqmaRe7ZluKHRUGKPoBxjHSIgafCC4kcJalvM5WW5Zh5bt2KEzKBaG8boVvF6DNpaiKvGxR2cKhWYcPCE6tLFEHXFhpCgtZZ2jbU1hc0pTcry8BTHwySdP2Ox6rlZr2rbj2bMrnJfdYFF+SFmWB9fULMtEo1A3Qp0sK6azKXVVUZRCSBBbX4NN9gyZsQIjsffL+tGFHf5wbJkTYEyFvQL+XWRI+veBv4wwZv4j4G+lL/nb6e//NH387/1IvB3ZImc2SzFsEiTrg2O7Wcv2rjKUKMJuwPmItrmEUGvNttuRFxn1tKbXAaLGu8CjZ894/L1HWGX42jtfpKpr2t2W6B0EmM/mUtiLXPjNGIrc0DvPbDrn9qlnvV4zDgFrZVtWVRWbzZbJumU5PaLKazbrNSqCUZpm0rDIl3Rdx9nZC1bX10TnmJYlk6rm9M5tur4nXFxyvVoxOVqQWeG+uhDZbLZpWyed8zDIgLVYNphFJR7pAdquZzmbkWU5k2bKbDKlbVusEpe5+Xwu2+dErXr29BHGilxHTKRubowQI7tdy+VqxWK+ZAwj52c7LlZP8b5nuViy3W5YLOf0vXjMPHhwLxVLhdUyTC7zgjKXAWCe57z64CGZ6nHjyNnliu98+yljEPtdozPquuHu/QcsFlOmx3fIs5xu17PZrvFeZifojKg0PiquVxsJFUy4vFIvGY6ppDJ9GabZF/7PHOnzEs0wfbEMN4M8UCm4kFEFgoJq0hD6gV27ou06Tk9OKIpCVINupChLUMKzJgjVU/BihQ7Qrba4NrK92oEz5MYy9iP1dCr47/U1uclESmUMKiafEm2EkRHFJO/EZAz9yPXZOU8fP+a1B3fIkxr3pakzCvAx8M1vvcsrr7/OtKkprGXsO/K8pG13lEX2Q0qDYjqZcnpnyna74+JqxYvzc9p+w2a34d69V8mLkmbW0PYdfgyHBXQYB2yWgVZ4HwkqUpqCshTHTJ+cNFUQXnlUJG98j/Mju35L1zryrMA50gwiw1qNaQIaj/Nroo2YLMcYK9BNJrRkVbUUjfDTIxllITGP1/GcjJJBG8Y4UqgMO6vQqifELVEPhGiR3HXNaHuUB5WJNcLoOpSNzI9qMmPYXLf0/Y7T4yNU6TmaH3Fx/gQDVKXF5HMiyxTUomF0BCeiq6vLq2RBIHCLSa6i2lqmsxlNU5OlxSukJK+6bsiznPl0Rt00UveA6XSayAE//PjDdO53gb+ecHcN/D9jjP+NUupbwN9USv3nwG8Bfy19/l8D/mul1HvABfBX/6BvsIdiVBRfhaIo0KrA5Eq8IgZHRGGakspWmJix2WyxWcZsfkRWZIRcs/UjKqn8ghcq1na9ZUw49iuvvIrRltXVNTEqFsu5WAxnJePo6fuR69U1fd+zWCyo6wmr1TUff/QEYwU2OTs749133+Xtt76A845J07Bar3nx4gVf+OIXMNZwdXXFar1hMpkyrSoWsxll4pGDoiormqahw+PVKHQ65wW/i6Ko895TlAUmMzgFLgSMsXRtS6NyhmFk0kzIcxkWudEzpET2qq4OmJ/RhrKshL7l3O877zp1uEVZSthzlO13WRQ4t4eJpHBYa1LKEuyVQ/uvf/H8jMePH1M1Be+++23unp5QNZbMRObTkvmsxnmhZ67WO9aba77//WtCDGKeZHPyrOT41jG3797m+OQOVktUYlE13Lp9l+1qJdgJMTF2XmbPyPGDApb3MMS+/ElXL3mVMUFAB4veDAYdcMon+mdMEJx00l3XieikruTBTMrEPM9xg2SqemOJpA5cGzKbYVRJ9CP4gHdB8gUULI+WYl0xDvI9clEF7ymM3ifB2zCwvlqxur5mu93+8L4t1fnNdpcStDxlJo+51kZcEOMBof/clwohdLvpuLi4pq4qaVAIHL91nF5bIvhiiImyLLGGLsXIdVvxMM+1TYwj6TbHXQtphqS1kSKWMGhdFLghEr1Ql/tWoa0hKyuCsnSdQpkRUyhiFgmFYhg7nPdkpcPlYo0dnCX6iM1hNOL5iTWoqsD1I+MwkucZo4dZc5cCzfZ6S/CRvC7ZeEnoyq2l23RcX25w48ByuWDceFabFefn5zSTCdmp5dbRMbmxvHj+nGdPn+OAZjEDvWfmgUETgmO1vuTWYkKYybNvjKUdHO0wir3xbsPFxRkhCOPLB9E7ZDY//H8ymVBWFdoYaTLK4kfW1T8MW+Z3gJ/6Af/+PvBzP+DfO+Cv/EGv+7mvEnc3KzxTk7jPHk+W5wQnZkLuugOnsEqED1kmRlvVtGanI8YUGKXxoxMjqTKj3xii93TbDfbOPXy0+Kh59vQJ6rkMII+Ob7FrO549f453nrbvmE6nzOdzyqZk027pu47ZpMYNAx9//Ihvf+t30VbzzjtfZjKp2e1ann36hBhH5ssl82lD17aUTcP1eoW2Gu89z84uyTLD7fu35UYbAkF5tFXsNh3b7RbnRvGLdgPToxnGajJrybKc7eUKX+Y8O3vOxx9+QF3XnN6+jc1znHJgDNpm6CynbXfYCG3n0Cpg9f5sp7KY+MKZachy2QaOPnBxdcl8KZ72WolCNKgoIjJjDqlVMUbwjuAds+WSV+YWNQwUUWAErQU3N0o8Q0wEYxR5kbE0E8oyZzltiNHR947zyw2PPv4e33/v24Bi0sy5ffcO0/mCP/PnfwUFGKsZuhancvrNCu/kgfQRSfXRN4yFfVcb04JgrEUjpmvWWAY0kTSPiFLYjBEbWkPGqt/SD6NoG3xg9J7oPe2uxY0OY0TZa1/C3t04clRUKCuL4Omdu2hmBK9o++eM0UGhcIWhyhs2mzW9G9hstzRNI1YQ1pJl5tCZ7Yvx/GTJAxROqQQB6t+3O9mDLUGTcgYCUemUV6KSYdlLA9jDIdTLfggMo2cYO1SMfPkLX8SrSFbl9L5logp0VFxcSQ6ozQyKyHa7I8aYvGsq6jxLQ21xwSyqEqO1QA4hstu2osAsJTUty0ryuUrhURGTG0xuUCajzErZGRkYQodzGqVLijwyrFvW1y1DP2JtwXJ+RBwCzWyCjZ48y9g5x/XVCu89XdszKWvyumBZNDx+/zGjG7n3+usMQ4vWGXjPOPRcnr9gUk9YXV4zdC1933P79ITvfe97vHL/LrPJjE+efMjHH33EerujaGaYwZEVsjjbKJYnJjMUVcFmfS2CJT/i/IiaNOQqo1SamZ+jo4eUydy7gd22xblAcJ6xD5xdXuCeCxnh0aOPaZqaH3X8WChUgw/4YURXOV3XkRthW9Z1hc2EPxtbT3CBdtOynB+za3fkec7oHNvtljEXVaH3njg66qoUC1qtefr0KbPZhNffEk+OECW9PnrP7PhYejolEIUymuVSKEvKCD52fHKLy4sLYgic3Drm/PyC1WrDZFpzdXXNO+98hY8//ojHnzymKjMWSzGnIor6FqXo+4GynnB0tOTF2XNUiuVTWnIu8eLw1zSNDF4y8afo4yBujOOI6TvqaYPBUmU506oiRhgGTww9ZVEwm80JIfLRRx+RZRnLpWClWZYT/XA456kJS/BFSkxKDJSuaylHsYPQxmBlHEJ0yc8iJntVxHlPacUrv/QKf+V/9Sbv/ea7/LP/8ncR7PeGU+2d5+VyorVKhTQZsNUlWmcHNWEIkagM5+fP+PZ3v0M3OE5PT7h9+w4nJ7e59/AtdHS4sWPsW/q2ZXCBrLHsfRJVYvl0XU9Uitl8llhFe2qmAhUFc08T1hADXkVGAljDfDYjxChCFOcYh4Gu2wCRqpqKHYNOVMC6xlpDiAoTA2b0DKsdXmVC25vW2FlFnuT+/a6VpiVBftZaYZh4T9fJud5bHMQkRT8+Psa7iKnyz+oEXq7USuGDF0qiTR+IewbSDx47K6XohwHvFdpYYQPFwKtvvk6+rAk2YkLEuMjFSpKIvHc4P6TFUih/RVkwJP8TFyPX19dcr64prChOvfPJZsDJM9KPqG4Qm2NrUwqZQuWaXbclKxS5KdhtZfhuCkNMxIDd1ZpPPn7MsBs4PlpycndBkRmBbaJnHHvGIbIZdonynBTFPjIQuNyuePzpJ0xnc7pxYLvZklUV2gWuzl5QFDm3Tm7hvefajRwfHQEi8huHkUePHvP8xXOcV0Qs51dXlMFz7/69pNWRc5llSiCVKDvk6+0GW5coN4A1jM4RRoffdEyrhnk9wWeB8aplXk+wmSQ0lWWFc4HRjQzDwGaz/ZF19ceiuBPB2pyhG+k2O15cr0V2PK1pigbvRqpFjcoMUSmqyZTjumY6W3J2/ZRt16GQQGEVIy4ExnFkOpvRb3p2XSfT/t2WerIUFWb0XF1fcHTvjpj5pAuvtWaxWOC8x1rLZDIRt7dxZHtxSVbkvPHqQ54+PePF5QVPnz7n/v17NE3N1eUlZdmw27b4sKUsUjCE1mzbHbYoGH3gervmxcUZqsrFD90L3lo3NX3b4Z2nmUwwuUY5RV2WrHcb3NBTlDWuG2kj+HbLG6+8weq6Z725ZBw6Fos5XSdFvG1b5vNweBB/oM1QoucZLCqqQ3c8jp4sL9GZwShLiBHHgLV2T6BDaYsxOUZ5Jq9MaU4GTl49ZXI0Q5uMSMAjDA8ZZPrEGdYQC7QyiOdLRIjCe08gWRSb6ZSj5ZLoM37v29/l8uyCse346P33xa8kzzg5PeHevXssbz/A2gzvxc9+6Aacd2KvqtIAMXXzMQrTJABE0SbEMOCiYSBiQyADeu94fnFOluUHi4GhF9GOYKLQNI3sGBRcXDylKApOT04hLyALLO+fEIJYLgSj8Qi91MVI50bqenLowF82guq6fcrOjZVvlmycq6a8GYrHlwbkL422xmFgvV2DmjJrAj4I7vtDH8FU/EPa/Whr6boeN3rKw1Yg0jNQTSuKiXTTm/WaYRhZLpeYtNPIioJ+HOg7McqaNhMx5vIhKX1zUWgrxbDZUYRAkwt916PZDcJM2XUdjVKMRtxgPY4xBrq2p64rHn/4IY8ef8JPvPNljpcLzs+fA5F79++yut6QTyvspMS0nrDbses68jyjyHJ2/Y4hKlpG7h4vGRFbb1GtRspJTaYM2hpMZrlz7x53bp/yyccfA7DetQzuGevNGhc8tsh5/dWH2CKXpic1PgGx87CZpZ5MuL66ZoieyWTCLjhCsjmosoJionH9QNeJ2drJ0ZLV9RXrywvG0XN6epflco6dVUIxPlnyj37th5fVH4virq0hGrn5sspyXCwOWG6wkbKuiFoxndSo+YJKNRg0RyenXHQX2BQVkyWsMmsaCB6VwabdMc2FnrTZbCjKGSFEjLEMo6yAeS4kPGPkIVwsFowJ98oTBnpyckJ/vSbGwGw+Y9Is2P3e73J1ec23vvUt3nnnHeq6YTaTwaNL6U2TyZSiLNjtnChUDdx7cB9Kgylsei9icbzZpA50GOj6jvnxXDh+xqC94WR+h7qseNo/JRIpJw0+4au/8Rv/gtPTW9y+fQeQh/3q6orT09sCvWS5KBXT8XL3JpiexSfhU1WWRDxZXojlb1kC0O1aMSxCgdLU0xk6z9BD5Hv/3Ud8+ugJ3Vnk7eOvYm2Biw4h/fXsLcm0EqaJ1hxgInkTAhYcZqSJpqeAV+4veXD35wVaykTtuLpesdkOPHv8ER+//z2MtRwdnfDK628ym805uiUhxru2xcfA2Pc3WHO8aXQ1ARUU0RmMMlg3oIpA7x0uBmbzOUYb4RaP46HztNaI22AIlHWNtZbFYilMkDFgYqAYArnWYCPK9ATAB7lHOz8KdxkZrgEvBXTITmA/VLPGYI1itVnTdwOPH33CT3/la3Id480Yeb8bUwreeO01qkoYGuznD8TPLAA3534/c4iUeYE2NdZmKJ3TTKf07Y5oLFkhjI2h71OX7xO1TxoJpcTKNgJFUTCbTomTJsEwIiISBojk6xZFjkoD6+vNmqEdcGNE1SVVPqVpaomqS1hSv5NoyhBEEzNEz9e++lXu3T5ls16jleLs7IJ2t6PtO+699RDrJvTjgM0sk+mELBNfqjA4+rbj6PYJZSPD0mYyQec55IEmLxiSn1BRFFS5zBb2O6kPP/yQ6WxKM2kwmRV/nLIUoaETa2ZxP9UMXq6j846r9TWbocNlhmo2YQwSs1fWFf31htVqxXQyJYbIbDpJ94KE9cznc2HYDQNEmM3mP7Ku/lgUd/EKzzhayITbWn1QEAYAJ6HWLl2UpplLwJSSEO3oIkM/oKyR5Bujsdri88Dp7SW6d9RljdV5CjnQlHVNXlZcXl5x78ED2t2OohI1oM0zmfwfhnOKup6QVxXtbktZaubHc+7eu8e3vvtdnj4/ZzJ7wnw6Z7PbcXp6AiBzgaJgtliijGW92ZEZS8w1Sis22x2ZzXEu4EZHZgzVckFQospzamC73TJZTLGNgjxS2AJbZNgQheYZIijDpK4py5Kr6yuOjk6pqhqN2NWe3nsIY8tmaG8w2sMePUL06Y/imbFarejHgemk4fhoSpGJenh0YlAVVbLW1YZIwWxmaZolYQ0U+zCdCBjxuTmoQZN0JjFbYlQoJYpRqbaeQ3iHUvLxGMisT7qlCDisjhSZwc4q5rOaosgIMXB5veV3v/kbbLcd0+mCV159ldPT29w5PUUpxXa7JS9KIjCOnhAQ/QOOsYgMoccZcRDUaLZXgrkbbbi4uJCGQ2maSlz9hmFgt93S9n1itoqCtTy9A9YwKIExjBeGTjAKr8EnT9lJXdOnhUKk7SnEOUTatjvAMkopok/MHK1RmabtW7QtKLL8kG97U+Qjbzx4wD4UJIxj0gEk8Zj6wQU+KtCZxZgCWxTcbSaMriO4gWgEXpTAlCj867zAajkPbRJeTY0lM5nAfWkOMY4DXoEuMjJtUEqCdNrtFms0WWYJpYiH1t2K3EUqJdTKtu/IjFg7+CDOimUtNuBf/6mvU3oJy7BW8fz5MzGJM4pmPuf49BS0YjJp2Gx34hyZdjtZLi6Vzjuwmp2XXYYfOuGdK03R1GgPVZYxmzSURUFTF1RlwWa9wWYaYy2TacN0uSAkR3qTCWVbpem21ppsUvHs4oLn1+cUVY3JRUw3aRq5N9ud2Ea7gTo63nzzC+A9RZ5CZQI8f/EpGMXJrTvUlYWX7JN/0PFjUdxBVv6h6w6ui3ue994utOt25DZjuZihjaXtOkKIaGPo+l6Csr2mKoST7nzEj57j5ZKzT59xeXUl7BBjKKuKcqhYLpdcX14xXy4E/1ZK3O20Th7S4usAkGc59+7fp9ttic5xvDzma1+bsjw5IQDL+ZIsk450Npvhg6T6ZEUlAhQMY9+J2kyBMooirzHRsF2vpTvLNKMfGPxA0UiVLJoS5x1D16GD4ag4pqpLfDdiSPahVqxLrbW0u5awCEwmUxbLJRcXl9x98Drh86HF6kbir3VIyn9DaTPe+fLbjN4zmRTMFrUwfXxkzHPy3BBxsrBCKioyANfcbO85oAQhOZPKIE0RyazGWCTvkhtKo1Ky0H/22AeDcJgCqgPAtBdzROoip65r7mDph5HLyys+eO9bfOt3f5vZbM7JyR1u3TqhqZrDAx68GIOhPEWMlES8sgyj59OrS2EtJXy+KEuRzuU50QvUlef5niifqG3ymhfn51RVxVFVg1E4Y9jLrrIQsT6SR82z7YaRvce9PAPCJMnouv5Gym4M07pit92hM8M7P/EORVAYL8k8L5f1w9pNsqWIENnbGZBMyn7AA7i/RkBQMTH1ObwHl/QDAk2J4MoUBT7KTqbvOjarNW70LBYLCbkxmn6UXajWyeclRlTyuQkJl9+f1+16QzNtOLp1i9043OQMILOoYRCmz+DE2nhW1iyyCkWg7YSaGmPkzu07LE6PmS+XXHXXrFZrnj9/QYyR6XRKZq2ks0VoZjNsnrHr2hQ8Is0fvSSIzRKkRLxx6dwLt7LMCN8/maRpq3Ex4p24SsYYyTKLI6KJXFxdUlQlr7z+Ks1sBkan+YMw5vLMUjcNnz57zptvfonN9vyQzHR9vaKqajrXc+f2Qy4vz5nPlj+ypv5YFPfgpVtUUfjGY+fZrVthPgDTiWK1OeeombPdBjbDGt864vErjCFSNhOK4BidkxXVWqq6wmpL3I0oFRn9QLtbMY538V7CnfO8YJcWCWMNk8mU0bm0sAhkEhJWKfiqeIlvVmuuVisG53jx7FOePH3OG69/gcvLc7JCcf/+HabTKYUt6JRGG01IN17VTGj7NfPpFO8jY9dRlgVay6WwmYJMUVQFOlP4UfJV8yynaWqJxOsc1kxx3Q6rDcv5lHv3H3B5dYEbA8Erbt+5Q900XK/Wh23/Z6CYz/xZOjsdwSrN22/cSWaNkb1bIhYoclJVlMUh9DK46np8cOlVbzBi6cL1QfAEYE2ktIlVq+LhXR2Ag736TqvUCSXKYzQ3HedLb/7G7ldEQ9H3mBhYTmumTcngRq6vNjz68F3ee/dbTGZLfuInvkJuC9kVoPEhpsD0SOsGzncbeh2p6pq+7xODRYb81hjqKiXujAPj6BhHx3a9JgbHndNT2TUGx6bvaLICG2UYuX/7TsHa9ThNik4T+huIQZX34u+999BXQJ+cBb1zdBFqUwIqaRleGqymbj3GPTMmBWib5MOvPnvlUTHZysj5U25AxR6lDYEgC19eCCsqirVHXgpU0I8jCnFMDTHQTBoRfq1W2NaQZzLHKvOSEJBCnZoo78X2Vit1M3i0OXmWScZxlqcAno6qKA9CwhhF4BdCQMVIl1gtq9U1WmsePnzI8dGC6dGMIYwJZ8958ODBYaEM3suOJ0SackIMYjG82+1o2w5jLbfmS3KlGfqOYddR5RnnZ1esNxt2ux1lNaEsaz7+6GPu3r9HbjO2Yy9aDhBvpXQ9gnNcrNdcXa8kv7XtcIDzgbqpqSqxX7leXcvOydpkOjaAErw+ywRaXjQNzbTmow+/Q7vtf2Rd/bEo7hBpmlo6m8yilJFV3SUFaVlRuwqnI2vfoqOm7wJdGry0bUe328g0PWVjjmEksxZd59TTCW1YE6IjBDAmZ7k8YTpdMJ/fOmDsIQZ2u44PPviAoihZLo+4vLzEe9kBRAXX11eMQ3uQCk+amtxaRjfSdh0vzi/pui3z2YJX7j/E9Y6TkxO2o1h7fvL8CVs3kM0KirzA6oyyrrA6E+9oPzItG3Qmw7fBQDtsWa/WVHnN1ASePjtjOvF89UtfxETDZvNcCtHQ07cDF2dnnJyccHR8jDaGvl+RvRRy/PlDOm4OhVxGGHv8+3MwDjIIC4AfOlAWP3RiKUDCytX+TyoN2dLH0kBzL0Q6XP3P8PLi4d/2cnkoEqM9BTJ8DlXYd5fejXS7Lu0UDHmRU9iM2d0G89Dgg6KeH3N6+zZXF9eQaTaMjCrQh5SSFB26zJmZOnHFw8GIbK8Y1ZmBIdJUU/quJx/lPl1dXbDdbrl3ekcsexXEwtIjOyPlpYAGpTBFSe0swQW6ZB2cZaLO9j5graWua4EjvMelhSLz0OrIYBW5MYxRoZ1CO4mEkx2ZwZoM76XTVfvzG1P2arw51+qwMMiC3LdblOpk8Kw0MdPYugDnGUZPO/T0o9gAxODFbdPagwOn1jYtVIF2J0GGAs9Ipx5DILP2cL9oZLbmjEMBm/WGeZHTDqMUtDKn77qDudowjoShJ7MZ27Gl7cTfp65rFm8uxTF2VjFmii6MeAKb9YY8L6Rrz+Q5G4ZBFlKtsJll2G4pioLJROwg8NKOrDcbCm05Pz/n7OwFm80Kayxd1wKKo+Mjbp2esgdIbDJ+i/Fmxxm8pxsGgWnzMqlwp6mIy/vP85xJVfPs4kmys7DJr0ZTVSVETV1P2LY7ssxydHSL3ab9oc80/JgU9xihLipMLluQoXfkyau4KismeUORS2yXKTOCU0S95cmLJ0QjDnR5kUkclc0pilK0LgS0ChijOLp1RFk1aKMZ+44BEWOcnZ3x6NFH3Do5Zr6Y8vTTT0ApHtx/QIye1fW1mP4slbAiQMRFWjIj5/Mpr7z2kA8/esxuu6PvO86CQwdF9cZbInjILc20wWvPsjriwVfusn3xjDEiC9XQsd22Yi8cYRJrsjFDa0Ndi+BhcjShriYQFHGSc7Y7593H7/OVN9+RIZXJqOoJda3o257zi3MevPIqWhs+/ugRD++e/PDzjwFliHEEZXBESGZfe5QkJpzFqKThjDF1teJrfcMn57D3r0tx3Nzudjgn6uEYDc4ruTaIJzfK/X56XiQN0rTwswmIxfC+Un2uA5WpYNohKCKeoe8ODJlC10QlSkClLVErgg646Gl9RAexf9Y6Q6ddyND2bNYb9rGAMYr6dne1ZrPdSsiy1rx4/gKrNXXVEFHsdi3HzUyi0QbPmBu8lsE4WuM6Gba3u5bNZkvXtVRlRVHk1HWVGhzBq2PyLTFZxhgixuQUAfKYoaISLDyLBC8YrA5iBZwVBbHd2/zKIFUrRZGJL0visia46KUCrxU2y2QImP7VRY/KLVYrquQn03cto3PM5ndlMKpSXKPNZS4TxO8mRumKJRBHzK/2C7Fk6eaJmhqhKJjfylBak1cSnOG8o55OMVr0K1liDZEGyUVdY6yiynKC81irGYNjcLDut5ydnzEOI8a0Yu5XVayuV0QfOD6+xWK+wBrNrdMTxl7okFppdJ5Ld01A+ZGx7Xn24jnddis5yaNju90wmYslgvNyz2gjWQoqcBDSeRR9L4tjNctYHi3Jipx210qhb4Ry7IeR+cktjL3CB7Epz8uGqp5R16NcnyZnGANFlaM+D7V+7vixKO5aKbTN8GE8QAh9GtJY7TB5ycX6BdPJhMJ7cl2wOJ5wPDviyfkn1JMGHQNucOzWrVjyNvKwqFxR1CWFySjqmm3X8vHHH/HKqw85Olqy2Vxzdb2jru/jRlElXl9ds5jP6YeB7W5Dnm7YdtcKJ7ksxf+5KGi7HdV0ytVqRZ4Zdjsjw99hZLNZMZnW9H2Lj47zqwuihuzTitzURDyeSD+OoBQmsxR1hp1lUuxUZD1scN5TFDLQarsWnWuOFse0buDp5XOUlWm9BIVXjOVAPwysrlcYY+mHnq7vMYcm/CbpKEbFar1luxsompy26/nnv/3b1HmBUjCdTmi7jrqZ4MaR5XTGvbt3UPQQFEEJC0OjCMpwverwPnJ8NMdmwmMHDtzzbduy2uwYhp6myLl/+/SzdfqlQ0KrA7vdwKMnj9HK88brr6Yw5KQuPXyySt4xHAq8rEGBgKLzsN1tOQky3FTJpCuPGW7ogYAfJKc1yxUX7Zpd16G0pm2FZbTf1u8phV3b4UaBFkLySi+rmrYf2GYd0yzn8vkVPjR4FVDGM1/OuN5c046d2DYbQ16UeO9l7jSkwPSEkyulDsZk1li+89H3efbpM/7oz/0sdVnQlBnBj0JfRHZhLmo++PBDZvM5RZaTaYF3UNC2HVV9Ywz38mxVKYEKhr5nvWvZ9T3zW0cSxBwDw+hY72QxEl+djO2upR8EMgopTEPSqcIB1hRI6+ZZ3zN4QpBdS1mUVHmO7zui0oRMLBRQQhEenSMaI8NhxOrBaJljOBMppzWNyfjW7/4ei9NbLJtbol41hjt3bqOVZNj2fU/fd5ycnBwcSIdBHBaNNkQXsVZ8b1xiMimFGKANHVVdYrXier1FWUNeFSxPjnF+ZPBe5gleLD8S74kY4cWLF7z77nsUdcGtk1vYPBMGjBXmVNt2QplWkDcVlXeM3pOXNdu2J8s0V1cvIMC27+F2Tte1bNf/NnTuIeLWrXRnIYgzXDtitYx13OgS7zcyxpqyjMzqCbPJhOe7jHHo6LY9V5dXEBVViq26iSxTWCN2o1ly89vttlR1RZkYMm3b0jQNTdPw+PFjzl+8IMtEVBWrhqHrGMeRvu/IM1FguhR0PQwtt46PWdmc5dERfduxurwUm1jvmE2mNMsZzXyGnUngcAguDWoUxmq0kZve5kbMkKyS7miEzWoL8ymTRrzSi1igrdA3vQ8ptEEecFFLKtqu59Gjjymrino+QedWshk/dygFMUhnrAIE57i8vMQeLYjeM5lUjGNP2ybPFdezN2067O9TnNw4DHz//Xdp25Zv/MwvMJ+W3ExBZdAaQ8AHmYPcROn9sCMQoqftB7773ffIM8Vrr74C5mXIBg4l/XNMP/mc9FEHV+dXOCeMoHEYSGloWJ2B8nSjo/UdYxQoJa9KYrKg3itHxZnSpMHaIIyOrmPoe6azGc47mrrGacWg4WK35fL8mhACJ7dnlLMKnVvRb4SA9p4suSrK99grbIUpM47ukGGrtebOwztgFaawaKslys/LYrWnzMQQ+P73P+BLX35HIhTzTNxUxd9Z9jmfh7bSf1LYAt1my9NnLyiKinm+wCWvnn3+p0+iO20k8MQmBbZznt2uZbfdMZ/PpStNrJn9zhQf9ub8B7aNVRpb5jgC7VZYXVVdi4BsK55Le1HibrulKMs00Jbnvbu8xkWPzjO8VmSI2IlCmDbd0OG8aB+mkxmZlkQmrWRIvNu2RBWFmTOMSd2taDdrGBzj0ENUXF+vuV6tuXf/HkdHR1SFvA/f9zjvRR1vhCq8Vwgvj4/4ylffIS8LTKYZhwGbqJVd34mhmnNURUGRWex0hi1yzp+vCc5TFKIBms/mgGG+mDF0Z0wm/xr83P9NHwoIbc/gHMMwkmV5itUacdFTHc8oygplkym+VYRM4bUi6EhQgTGOTKcTtEnWwMh2NssLfCZeHzphvT543n//fUIMOC+DzvV6TVmW4t9Qljz6+GPu371HkRdkxuCd8NS1UXRty7RpZDCrDbNaiv12IxhjXTecvzjj/Q8+5OLijNPjW9xRDzAT8YUYE/XQaIt3LuHICkKk3fWYXmYG282GoR1odxK1VeiS6XwpjJL9hJ5ElzOGTGs22y2ZtRSFwFPGWvJGwnfd+DL2fQNtaC2Tf6U1gUg/OIzOyGxOZnPqqiYEsR8wKilZ08B13yfLIC9iM8NE15Km9xKOntlMgjBQwifP9MEg7YcdkZBMzoT5oTAIsLzfDZAKfIJvPueZsmd7gKiPh6FFKVlItdF4JTuXXke8hrFSkGc4kAcx5sTgsYYEzRi8EwxecOX98FeTlyXDKErirm15+PAho1bcee0ByzsDl5eXHJ3MyCqDVZNkhzuglKb3PWVVYa05rFf7NKA9nLEvjvPFjKOjJUXKIO2DR2Mh+MNiBaR8UqEcRtJ5TrCirICazy6ssniNHrRxlHXN8vYRxTQnZEFcKb2mXfVJiCbJZSgj5l5GH7p1YyTMfhwceqqTG6o+YO4+xf/Z5CAZo4S56yxDA1mRJ7W4IY6jwDAvibz2oSYRgYJiVFxeXjOdzsi1oTEl2mjWuw1+HNFacb3aoQvJP3jx/AVucMxmM+q6RKPxQ6TI8sPw3OiRzFiYTrh+cc52u2Nzdc3583PxbU+7LR+FcOF9YG9Wp/cU6jR7Uloznc9kJ2YVysiOJMQgUYRlgbG5+FdpmVuYzNB1Pf1uhytL2m1L13aoFA707PkzlrMfDrXCj0lxjwpUkZMbA0rjO2ExlHmFKSx1VRGyKUWeoax4f+uoUSpiMITeC3sm+ZnkRY42e4Mohc0zvIcsK3A+cn52Rt/t2K7WaGsPA7OyEOXfndu3aSdTFguhSMaoGMaBvJC80KzM5SJEnXDDjBgFBlpvNozDQEQUdsYqTk9O2e12TKc1KMltJQSGfpDtX4Sh75kvZzTTUrDuIaJUTZw2HOtjCJG8yKUo7DoGoMgKqKEfeqFe+h5rTMJAhV9uMssYPuv4/flDG4OJ+WHQ6T24lMiujCXLS0YnEXvGCta37/xCCIfBkYpQFFmC1mJyZ0/b31GoZQmcRWsOD+gPO0LCVX2QpBzvgtgEQNpy3Hy10kHi19IDto/X239GCDKMkyCViNKKIXicgmjkJxhGx9gPLOdzrseNBLcbfehK+34gz0Qr4b3AhuM4UqfitXfzG8eRi8tLTm+dEGPAVBnHzSlFmQsk5kRcdXV5dRgcS0iNoapLYiSFQ8gAdF/Y27Y9/Pl0viTPctAGVSiiB+0jysuC60LAh4gO4iwZgiSQmcNi/JknkKhC2tWI7YMtCtrzF3TdiMlynPfsupZtKx4yWgvLSBtD20qy0DAMhCAYflXVYgncdodrUhQFfd8Dgv9vd93h588zSVoqy1LUwONIt90K26YsU4IWlEUpbBnvZTHVmjYEnNU8fXzGbLpEDxFrFItswouzM55fnXPZ7+gRcSFaQjXGcWQcLZNmQl1KaM/Yj4S9MZwx5GVG17VcX16y2mzonePk9m0J7JhOUUYcL1GkXNp9MxGIYX8/puds3+14gbi6XuIDq6qSppQbyFRrzWQ2ZbO6RnUiCuu6nhB7iJ4iLyXU+0ccPxbFXeb0EZfM8PNcVnClBBe1RpO3EasUaoi4cSAbcsxcsbtqUWNgUtX4IPS0nfcUuXgmB6PBqKQuyxgHqMsCP+5o6oqT07tcrM64vrzEjyNNVfHw/gPZKhU511fXKGVo+x6b5+RVBdphiwxcFMuAQXj2y+WMq+srmRXkGUUUu4GnL55jq5xFBOuEIeBcQEUlg2OtiZOCfF4QwohzIz460FHCOXJZrIoyw3qFcpEcTR5FCTmoABqqSUaRy2Jns4LRRaLVFGXOAXD/zJHY11rEK3IxpEBtdi3L44W4+KmIUUGuSeLdpuC7VL59uo6QFRnKJb50FG9sGYyGNPAUR0abSRcTVPxMKpDU65RSE+Xzh9HhvFDK3CjXVl5/z+hJDB21f42XmDjIMuODZ3DCCY+JllhEQxU8Nhi8Uqwur7m+uiRDs243+CBUta4PEAR2enL1aRK11QzJA79p6gMEGGMk1sL8ur6+5qMPP2J1vUYbzU/91NepJxXr7RaTZzSTBvyNvatSit1uJ1Cb0ux2bYJmxhTwYA8KSe8cISgypVJ8nmBSMcYDLr3rOkqV01QSqxhGh804QFX7a6bUDayllQgBCV5gH6uJGkJEZkJR1Mp7eCaEwHbTs1qvWa9WZDZnuVxS1uXB0mN/9H1PlgmbzXuPzaSgKnTKuDXiS4PoS4zSZAmaGp3HK5HyG3UzixC+fU5xtOB4cBQTof8uZjPatuX64opMG+4e3cLHARuhXiwYM9lJGC12A0EHcaa1GuWFTtoHGQDXixm3QmAMnsXxLY7nR9RNTZYWepeaGSEiiXo2ppN8oyVJO6VAUtg6cis7CRUCMfT0Y0iUUMvoehnYZ4btWu7FvcVDbsU2ujD/wy1//40fMUZi79Axii2oQFboKB4juTKMyqK6SPARHTRORcKgMIOm20goclPV2DzHGktlM87OLiTL0GhyYw+FQCtFU9fsNhs4CUybCZdnZ3g3ostCbs5KvDP0Yo7Wht1Wwi72EEqMMQXnGi4vrsgzy2I25f69uzx79pz1BrLCJh+Mmk+ffMp2u+PN197g9u1Teq+4Wl+Lm12W4SV5C2MVeV5hs0AfR8Y+cHlxAWokHAWMzhi6FqUNrnOMzTHBaca+R5eR1u9ATYhBONPWKopYkfnAy84ieyaD7Bylk45eskyrqmJ0I0UuSsCizA9+5fvE9YgFnadMT3FWDAaWx/cSnJKx3ibPn5RPKcwVMNYcIIjP95EvZyztt+vb7YAPGudGhn6gaW6sTg+iKWS2ghavGgnt2HdR4IPDuYEblaYS7/GgGJVY8GbTklJN6PwgEYJJpBSTLUPf95yfXSRhnU3Ck/xAkxQqozoUeaXg+OQYiNw+PcHmlsE7lJFdh03CF508jaT77SHCMNwwZaSwG6zNRBOhlIR6KE1wEZwsvDrEw7BYKy3WwApik+7Z/fwjHeqzvwEKZS3aWOo6543FRNDC4CiMOIJmuWQSbzcbYoyM/cDZ2ZnASKmQd11HnnYpWutDDqlcK59UqzL/ybIMo0WF60PAKoNVWiyxk8z+eDojL0rOLi5ZX66Y1jVHszlHmcCFfbdjt+24e3zKcjrjvXffZbfaSDCPzYjeMVxsyWpDM6/I+kATDLtdyg1Qimo+w9gM5aVpGN1A8AFtxChvOplQvf0W9AHlUqarNfhD0lW6BYO0PFEJzUA67u6wgOe5PEulLSmNZbNak+XCJrp4ccZksURngaHdyaA8ihlbWUpYTp2VKCzTyYzg/y3o3IV5FzBWBoLi+ibZi5XNqLSmKBv6bkBlCjdEtA+EsaeJsmVpty2VtVRWY7XGhIANlqNoCf2IcT1hbCFMmJQVuyGw3lzTtlvm8yWL2YLN+oLpdEogCGadW+qqwLvA0HfoJCp5cf4CqxXL5Qm7zZaphwu/4+jkmOPlEW4YIAoFM0xGTk9Pub6+Is8M1gSi75iUBTrWtKYFpdh2HfpFkDSWacnoAnHwPFufpw6yEBtdYyimNVoJy6Z3nu1mx/nFOaf1LWwFee0xo8XGDNd1+Kr5rI8LLz3iKuHJRh4ucSTcsd066Rytoa4FtnLOJ2FZ2vonhkxEJbpipCwnh2vaDYCKZEpjVEjfUyT8xhrSvvUz0z310u/7Ark4avja179I6Ic0zHzp59jPD6LkrUZVElJzsD/cOBJi5M6duwcGhwue9djjDewQgQ6lZpJNpcvSoqYcup6h63nx/AW77Q4iuNEx9AOlKmnmNVqrA7NlHEemTU1EuuV60vDKG69KEJxzaf3RZFbmJVFpXKINDsNAPZmk4rc9zCTEG8jQ9z3eG8qmwSnPoCIhE//x4CMMHu2FrvrzP/vTYginLIZkBxFvVMk/mKKkxBslUfmUTuBamq9IVsJI1wsbKwwjwXuOFoubgbMyjG6k68S+uigKyUNOC5/3440uwYtTqNA+Pb0fKbKSKrOgIOBp6pLr9TOKwXD29CljPzDRtxmyUfjfxrC9PqMpc6K75jvf/A4ffvCEr371y0QcWmtm8yUvzs6wWnP2/Bmz8ojghPY4ny8EGlp39H4DKKqyRvWOzWZD1/dstlesNzvm8yXz2Yy6qtEafN9zcuc2m27Hrh+ETaUUQUOMLtlItId7eRxFuLWPx9wmrcDV1Y6hHxhXa1qfUS2nuHbL5nJFu9kxm9Zk2rBbb7Dasl2vmE5mQvX9EcePRXFXAEPAuMB0OhGRgRsZ/EiuDN24RfVbqhCxQUnnp0C5kfHFUyazDK0jC3pUK/1psIoci95tKI0hDLC9OGfjBxhHXrk9JfgdZXgO3TW3pz2+zqnVEzK3DxMOIkjQJZPmGqOuOZo6Xq8i2u7I3EcUy47qVknrNIW9xtaRcRZR3BIqsR5Rugb2W+8L4ALlc46yHqaBwSmecoJzgWHVMlzvMJkGFTiuG6rZlCzX1EVDaEfiGAgmUk4n6MKi7UgxqXj66XOO9YQx88wrOD875+joGGsURkVG9uyUVELVobdNf0n0tFZ8OJ49e8ZkUgtsEiI6kobV0qbs485iFJVjDOLbLofAMVorMNKPy3dOfOqU5fr78F91gxnEKH4tt2+V3Dm+IyZkUYa+PxhkCgRl0xA2GWURcUFEtXU9Ze/d0g0DPaJ/NQgeuocwq7zAhcDV9RWffvopwzDSJ1pkMykPWGqWZWLlnDJn27ZNIQtiUOVjPPyE1kcKDM4ogQq9px96nJxaxnHk+uqapq4x2rBer6mq6mAFHKNg+Xthk7ai9tSA0zLEi37vTQ9lISwWiKjoBDIIe2naHgZ7mfGUqEYh4L1g6WQajAXtCCnBKgaxiM7zApXlybrZpPfn8Mk0yxqD0fshq9wTAislO4NRFgDve9GRxMD1xacczQtCqfBhJAQ4/2Rge/0p87mi1DCd57TbJ1xd9EymJdvNSFFlxCDfP9rIvVc1MfseXRcoCsvj598jL8ExoesNRXYJeoeqHCFrcF7Cr4kNblQMYUs/eEyhqXMY/Y6yUtSTFeO4xXNEpCHqnEePP0bbKHkCFFyt1lRFJQ2RFzvysqjIcot3AyFYjNWEGJH5aWBc74ghMJ+V9H4kRs/6+ordbksMgaIosUYMz/quwzlHlhX48d+Czl2FgOoDWo3UTYPTmixqUIZCK/ToUQmHNkHjfcChGbcbhrEVf2tl8UOLUvsJvKZUYlK06wb8Zicik2IO40CuIKqWuPO0W8/UXqLMhCLsiEES0Y32eG8xdkIerwBNHAK1VfRhpM5KKq2JDBjjMToQxxUxrgVr9BkRjTYDrpebOGKJ6ZmBHJvdwnpHHAVO0M7j3cgYIx4oB0vRKVTX4neW4BVLU9NuO5p6gh4CWkXunp4y+JFtv8ONgVW3whrxcFd0KCwHSOLwu5TIIg8yxNMwbRr+zC//MaLWFHnOdDoRx7y8QEHKcZRibUxAk+GCRyUhSlR7rEeKhUZsmEnCmbIwFIWIdCJ7vro/CDI+gxJEJRBD+oiKe2xZpjT6sDpFUCJHF661wbPH7xUhOTGqpN5UWgzLcjSWiFeJr++FIql0xtX1NZfrlQyRTWAynR3wbpDivtltKEPJthV3yKZpmM/ndEMPQ4/NrWy5gUHdFProA24cGLwDrRg6hx89mckYOnFbLIriMFzzXqyQi6JiGBzDsCPXgl1XVYkxGkdAVxkupoAUH9FRIAV8xASLDnq/tN7MKpCu3gvhCGsMlbay0EfZzXXjSDvI8HjXChc9zzOM1sJw226JQTpVpSQDQUGKkNPkuZVON3XtB2FWei/7nIDbt18jy0BpT54pQtRk9UhWN+Rqg/Yr2p3ALX03EkIHsWS3HdHWS0QfYOLIerclzzK6AXY7yBvFto30Y8PorgCBWSX2TvByHSxo6PtzBjdQp8FtXgaUBpsNiVyxxVLgiXS7gFZbrlYDjx6X7MZAmYsj5nazJsaRqoSHD06xeYYqKowqJTQeR54NKLWmmUGd92yee9ADamxQKWugLCthq+U5zgeBcjKEcvkjjj90cU8xe/8C+CTG+BeUUq8j+anHwG8A/4sY46CUKoC/AfwMEoz9H8YYP/xRrx20Jl+UKGU5Vz2FMVTKoqJmEg01GRExEIpKunICnJ2fUxYFFkWmZUjpveB0RmumzYTr7RbnIto5YghYo7hcrfn+7wSkDAzMm4o/8lNvY4uK44evY+2M50/eJbiWjByTNUAPGMwYhIYYYDYZKHJxShxHx0jOdngTkx4ioTBYvMnotyPD2FFOSpRSBJNRVxOiyqitIq6+ic0NzXFN17f0XYt3A7G2tOyI40BhDH6n8P2Ooe8Yq5aVuWLbDkQ6TGakk0dDCDSNJK6v1xumZfUZ+iOp61ZKY2WqhtJQZopX799mbwYW03Y82XAiC4QwU8o8Q5lI34+g/WHZiEpBlOtlrEosFyBCZtSNCAmdOv0fcpMe8Jf9yF3wZIXgmuFznX8kErxLzethW3L4atk23wxtBxUZ4ijj4Cg7wlFlPN+tcEiBzbIM78uDvD4vcogcPN0hDciCZxh6Ls7PD0PDbMzInQzFtNYH/FZbg7EVWeo2jcoY1ZBcIaFOEIbWWganzhGVOvjc1FUlmL/WZFpjBD9hb3xnosJEeV+J7sVeFpDleTof4TNnXZAxL7CREg/1Mdn5aKUxTqNsRjHLGZxnOplijGZ0A30y/BtGUVHKLEJmECYXTYA1FqMU3vk0w1rhhpHFbI7RiqKoefrsKXqakdeFFLYQOfv0U8L4lCp3ZBZGH8lMKUlGQVhGVXOLalKh4ojVBaP1oFusFt3MOF4S9s8koHVBli2ICMwXfMRmmm5n0DonqlKgYQNjN5DlVaLCFigcIeyArUAlgwcTUNHTTGtquyC3JYWZcPb8m0ymjjfeCmT2I3bXGdopRjL6LQxugGak2yq0LvH9jnZrCUvHxdkGHw1lOcUHydQ9Oj5is2l59uwFx8dzUp/xQ49/lc79fw18G5ilv/+fgP9LjPFvKqX+78B/AvyX6f+XMca3lFJ/NX3ef/ijXljFQKEDtckYdMRqsfwtUoc4IDgiyspEn4CuKvwWmqok+FYGZiiCdwxdL5xsY9JEXQQ/gUg79oTaUuqbbalt4NJOMEpTeFkozrBoNaE2c5nQG40KCq8lLDsQ+LQdMT2UhcVYxTgqxhTXRhTObwxQ2opoFR8++oRoA9XMovKAvoLZZMnF9ozWjPgQKMYNMQOVK3IlMvl+gDiIVL4fPJnRBA2X11fMZguOl0e8OHvC2cU5RhsWiwXz2QStFNeXK0Y3kmkjzAqlPiNgOYA0L3fL+8KYOt8bbnTq9xNuO3Qt8cAvD8QEmUi6EVR1jTWR3dYlKuZeQ7nvG6UzVfth6OeOiARqx2Ag+qR2TeCOUp8t7FEYCU0pJd/Hm4i6IUrB2uPGVlsyY8mVZlQaHQPeBzJriMoyvPTaQs0TSCQECTOPBJqpwFXDMIj/fjey3W6p6xpja4pcOuoiL2VXECMqahG6JMOsoR9EnBf5DL107AfaRDncOxE20yku0SW32y0uz5iXNWqQj8uZFb/MqMBWDf2ugz1sFsWrSSuNKew+IuUzs5eYvvduu+Fiu0FlmtPTE2xmKJIQKvhI225RZQ1e2FpsO5rZlOlkyq7rUVpRZzlFnlFWJR9+8BEnt+7QWMvzF095+OBVNmHFl778RVw70LYrtC149MEHfOVrb+OHLe04Mow7zi+uKJoaUzR4gzx/0XAxKI4WU/rdgDIzhiFSZRnO55IBXC+IxkJQjGqgD+BjQVSanauYlAtcvGIMGZNa+OK66olB4cYBF3bsujVdZ6kKQ1nNsNmx7Pa9w9iIVhN8eMYQhM2yOLrL8u6XqIuSq/Mrwgc3aV8BxTA4Spvh3UZyYXFYYxi9AuUZhsDQajargY+ebPnCl75MXlhWw44iy9i1O1bbDb/zu9/mi196i7e/eO9HldU/XHFXSj0A/j3g/wj8b5Q83X8K+J+lT/nrwP8BKe5/Mf0Z4P8N/BdKKRVf5qf9gMMT2IWADVK4cmPJD3CgAh/k+VeiohOrDlF7mSidTUyuec6NKKPouw4dpFv1GnbtDp/PWbyxRNm9Vaq47j3fPiKoyHn/jCo/Zb1+TK2PmGYli5mmySqGoacbAheXA7tdK6k1SnE0Vdw6LmXY1I4ED+JZDsFHNruRvK549c03efbsCRdPz1FNoF7kVDGy8wNUmtzkaMzBDZMoJlJxGPHDgKGksDkxDoSoKYoJbTswDhesVitiiBwdH3FyfAub5Wk4KlhxnufEUVzkPnMhYqQffOoOVOoQHaMPeC9maiHBAs455rOZ8OhFbZ/gDo1RitW247vf/4DRO954/S3enDRYrQ4DWAi0XU8/OKwR2Ecgmh98a4jjYaI8psXF7OcFqSN9efhqVKRM9pbKeIGQInQ6ivMjCpuQCqWgiIqpEqdLlwbKn2wlgDr6iNGGrpdA7M1mI1j3tUoe5BmTyTRBPMIwgqQZ0Bo/joQgQhSTCRS0a1u8c+RK8ga0zbBTCQHX6FSAJcpPK3GkzK108SaJhmwSrKEiLtP0RggESu2Hy+CJbN0ONzqiC9RZhvYR7/csos8xlD632AeEdmyVxXiI2V4sFFHOsVtvuLU8FrNO7wnjiG+32KyisGLK1Q8aXEGeBXQceHDnLouq4tH77/POO18Ga/nSl77M97/7LqrRGKc4PTnheHEXskjbixXDeZHOmZlhM483ntEFvLJkzZS+X+Pw5CanD4Ztv2PX7chmx6AUYxiJRQNljVGW9nJFNi3ZqQC6AQyj6wm+Y58vsPYZMSsxpSjBvTEM1tIOHUrLjl97A1GxiQpbzHBuR2bEk78oS4y58UPqugqjI9oG1huPVxkuWPp+i2k112vJjMUZnIPdLvD8xTn3Xtnwx3/xFxLRYcR7x9XVNcvTO8yXE+7cn/6okvqH7tz/r8D/Dti/2jFwFWPcI/qPgfvpz/eBR+mBc0qp6/T5Zy+/oFLqPwX+U4Ayt0x2nrIqZYDpYQwOR8Bo8MFjCaggdDwTIm7oGWJDraFAQwo23g1jGgAKrumshEHECYylYbteQR0wSjwg9P5JBzFi8gH8iI4WrWZEZegGT1HCEODyumOzG3AOdAoR+GS3YTv0nJ7OudqtCM7jBkcI0mmVRUVvFPm05vTV1ygmCy4+fcr68TWT1z2ZqQRKIk3bk9IvRkWInhCFn/yd77zL7nrgZ3/mHQyaXbumqSesr9c8f/acvLS8+fpr9F3L1cUlmRWO9Gq7Y1k3lJn5nOxcfu62dwQUVivGGPnu99/n/OJCutlCghdsltG3O776zle4VdlDpz3gsQq0inTjyPfee5/Rjdy5/SoHO8KDIhYJX/YRF8UGuChEdfqDynsEurHn6sU13kfKzDCZ1EybhoOWaf9LgfOR3TgcIAqldRquCo+/R9TMIWkI1sql3UOgH0ec83Tekdkck+uDxa73AnEFsZtM3u2aru1omgYfReCWFXOIUGjBnNtRgq9tZtNgNJOmxUpQg1XQbdb0fc/RfImOBm8gzwxDP6IVGDSZzSGTbNgYo7CBFBR5iQsebyxZBFSyYnaBT977mMuzFYvZglfv3Ukyh8QvTlEq6qZvZ5+la40mzyMTJfetRtGNLT0OYiREx86tGWMLSWzUt1uaumJo1/ShTYt+xthuWA2fsm13/N1//Lc5OZlhTM4/+c2/y7YbiN9uUd3A8SdrNg8WEB0GyOsJ2ilm9YT1ZM3FasMrt94gK/ShyC3yI8o6o30xkFNTZSUxeja+JTjZCQYPgYALihgKPOIZ4z2SqYBJO+xBzk1i6AxDJ7CYaVBWdphD1KlaZkS1pw0EvC0pm4Zdrwjray4v/yVX5Smj35DnDu8Nt4+/gTGa9z/6Ll0G5bQkUyNFfYqvPKa8JpoZzfQIW1p+4qs/y0/+nOXNN7/Aa6+9JaiBiiIk225xbq+urfgv/s9/4wc8OXL8gcVdKfUXgOcxxt9QSv3yH/T5f9gjxvhfAf8VwGxax1WmWPsBokbpSIaiCpDZnKqu8f0avHSR3nmGEOljTmMkIk4ZGbtJWo5hGDxlYcXju8kYlxmVzbhzdIcX2x0gnXtIlDkNJE09XkVMVmFNBQiO6YP8+t577/H99x9hTMad2/f48MMP6fuOn/35r1BVhsm0YX29JeLIqwZtDc1sSaznPBsc6/OWEKawsOyeRh69+zG2iBgbyGwmSs6kZBMerZipqRDIRk9oO549fi4rfboRtbG88drr5KVlu9nQt+J5EvOCzWZHUTTE/Q96c12l4CqJOWyaKWHs6bc9i6MjqqamKms2qzVRKWwp/HptLYJop/cozYnwem+ILoLpqpvisfcjiUAzqclzS3T74nqzwH7uHiESGd3I9773PifHR9w+vUXTNL/vc+R7pl0eJNMxl6YEil3bEyN0Rz15FSQK0XuxiU+7PpNZaiN0XD+GAwMjeGF/iJhG6HWZtejEW67KicA1An2j0VgP01ixWq0YesfgWrKmZBh62tFxtJijUbx4/wmfPH7CL/3CHyHPLavNGp1lYntRCLf/ZDJl6Ee+/+hjSMNIrS3m9JRqUqJtFF1ISJ4/zjGuOnabkeVU34xP441f/ufnHFppGUIH8czZbFuMthibMW8meC3P3tD3HM1nZLms3UGBzSLBeUyuMErjowxo92ibV5HRRdwY8WPP+cUZIYPvfbSi2g3c/60rvqlPObo/J8QdL15ckkUoTUNdTBmaQlKfjCEzOVopFtMjjNKsnvUs5kcc3zrGO8e9ecd6dcVme8XiaMHVesWLdk1uC6yKGG0PXHTSnbyHH/d3ruD5OYQMVEzJY2mSc2Bzyd93250o1qPi+fkz7JizXM4JsSNGz2JxJEHqxqCMJXhHRsnbb73JpCp4drXjiw8m3L5zn+OjI6aTOUUxQZtMPN6vLtlsNuy2bTIQLJjP57gxyiL2I44/TOf+S8D/SCn1K0CJYO7/N2ChlLKpe38AfJI+/xPgIfBYKWWBOTJY/aFHDAG9G6iUguBlAEUkA5pqyuL0VT49OyMMjhAE+/zu4zMer57w6rzkK6/eTiwOhc0rPBanPC0K0zTERY03gV3nCMM1VV5gcoVKhvoqKozWIjfXRkQ3scEqQ/A9NmuIBEIYqWvDT379bW6d3GKxmPP227e4ur6mqgr6TgQozjuUBpU3VIsTdF5zMYx86/tPCN2ArS1HdYM5fcD96iFWbendhiyX4N6oIsYoMmvou57MZBRlBvkRrwyBhw/u4gmgNf/tf/MP2G46/uSf/kXmx3OsNmKlazNZLAbHxdmWoqiJ8fO8WOnfghfhWEyePDbLiEQWyzm73RbnPVoZumFMIQk3r6AAnZiUhJsBZwhOhqhpodq7fe75l0pxIE3KP6uXXvEwmoW4V6tGTCYhynsO+b4rP9SreOOhrfbfC6H34YW4HfYDTaUo0WilWA0DQ9uJ0nMM2LIkLzJyWxLCyGoYiNFhshyr5TUyK0HLVVViMo2JERMRdaOTYaWOEdYt69WGbTtwebXi/sPb4ANLW0swxc7BIE23juC6Ed17hmFN1dRkmYiHvO9x2566KcEolDZo78mDwjr5uWMQSp+OjiIrmVQGjU1IvFAUbzJXbxZoOXUxWe/KzvHi4pzrqyvefustThb30Nby7OlT3KD54z/3p8nznIuzc1bXG3bZlvt3XmFxcsJqu6aoCoIK9H3H9eqcV45zfFAM3Zqz3VOWsxOCVYx+RLWXtEc1i7XnonRcr55z5Tq0g2W9ZDWsCFbz5MUHZHmG1paqqCnLijIv6fwI2hKizNcm9Zyhg1df+SLeDZj4nOfZmocn76AU3Dt6k4DHq4Fh7OhdyzB2hCB+NyF6qiKjUXMyNAPpflcRjRGh9Z51Fr1YjYwBkymm85LVVUs+GTm6VePsAmUDn55fU+QF9x88oGxK7p7cYVlo8sLx1pvfQOtMCn/U7DaesxfP6FoZ2OdFxnQy4/btu1RVRZ58dfYpdT/q+AOLe4zxPwP+s/QA/jLwv40x/s+VUv8v4C8jjJn/CPhb6Uv+dvr7P00f/3t/EN6uQyTfduhi3xVGXBQ73KA1qsiJ2qCKkuA0zsPk1j2+cG/OojJsSot4kitUIfF4moBXwsRhAL8b2LUDO3fOz379TZqqwblAl+xw3SjWsIJTIit9aYlKOMh7Qckbb7yWlJ/iYzOd1jRNRdd1kqm5a1GIOdlFHwgbjVYdUYHpAuuQ88r0lNGNfPuTK3a3Jvzs7RlN3ohgpzlGG43zQk9UlQIdKW3O8VsPmNtChF46stpcs7pYEYBv/sb7HB/N+eLbb/DKw1OaZkKWWYZhZHXx4UsX9DP/S9f4xsyJCNvNlrzI2O52kh6T50zmOUPKsdxP3w5JP4kj/dnXlI76YBCQmnNhlQwHa4kfcMfxciP/+a5+r+R8+XsppYlBE0O4GdCyZ8nIIjEOI9erNa88fFXCMLRhYUvGOHJ1tSO2HQHP9cU1s2bCdDpleTph1ff81j/7F9y6fSTD0jxjfnIsW+UoBl3F4IV6CLLgpHUs6sS0DwE/OtZXG7azCVVZoKJmzxpVSh+KbozQ9T02DVi1T3MGFdFGApq1UilblVTUI8SX2S8KYzSTZopRsti//Aiql37/7CE7kePjY46Ob0FSYccgSuGhH9isNwQXyKqM7XrL2bMziJHjo1vsWs93fu9D/tgf+6MoYDNu+Bf/8nf4c3/+zzNdzHjy8XtcP7ni3tEbLE9vM/qB6/lzvhe/z52H95g3GcTAIgw8eu99iknJq/dnbMYBk2m82hLCSDdesd69wMdAMXO0/ozx8hqNoXMFedlw+849Hj36EGJk7B2Zznny6ROKIuPk9IQQvSRBmX2/ITYCPgT8LQdesRnO6NxOqMmhw4cRF8fENXLy3Lge73uqJlKVGfUMDD11M+dLX3qHo1tH7DYli/mCB/caiizD6ozd5pq2a1G6p+s3DH0POsPmIvo6OZlRluVnLCf2ebp7wdwfUFb/B/Hc//fA31RK/efAbwF/Lf37XwP+a6XUe8AF8Ff/oBeq51O+8qd+CZRGKSPwlyJlpGaM7Ji+8ZC+H3jxyTM23YaYW7zvudhqhquO4BwhCj89AqPzEANu7GWYiOby6ppbiyWvv3qfNpQM3tN1wqZpmoY807hNh7YSiF1UOZvNGrHCFpe+cRzx40BwCm0gOM8wujSsSqwIpVAYjB8YN8948ewTFsenNKcLNIpVe027WlGOK7qLM9rbr1FqGajlEYgS0LxnZ1RFxrwsyZWiySzWygma54b/5V/+H/P+o6d89/sfcXV9za//xm/y27+b8fprr/OVL36B6aTm5HhJpjXrVc9m21E1lSx/USWfG8fZ2TlNXaBQrNfXtOc9IUZePH9BlmWcX56zXm+4e/sOXhlMhH70jMFQGIVFJO9a7Z1m4GYl0anbAT86zp5d0EwqppOafF4nIk7qJ9OWN+7Nu4MYtOkoOyuQDld8y28ghhD2xXG/pKiX6pei7zyr640IbUJEkRw1kVQl1weyzNI0E4pENdwHh6MyrCpQHuosR7Ud4yic52qqxKYXXoKl9rsN2TQQwGpFbnJcH9C5QoUorK8IJip0COgYILFp8qpJqs5k66ugKBtsLjMkyeyUYex++C5rQJTPjwEt/rqE4OXPMcUVIu2PsJEgktKxlE87JaFuGhREx+nRHJsXjJsVpYLjaU1Z5UzKgktridFgcstyMmc5W1BXDSio6oaf+4Wf5+T2KVVdcf5cLHyrquLk1i127Q4d4IOPHqGamYjBosbvOt773nOar93mldN7NEqug97b6O4l/wlmMkbjvMMNydI6Gt57/xnOj1TTire+8DohOG6fnhCiCNpQskhKJkBAK8gSXdPYGuUD07rGR087dPR9nxq4HqUhywzogH3jlKwwVI1mUk+Y1DPUULFczKnymtF73t08ocw0MSh2u5FhbBNZoMK1HWVRMZ9OybKSzGYHH6F9Eb9xcZVjr9n411rcY4z/APgH6c/vAz/3Az6nA/7Kv8rrOg+XO8tqdUlZFEznx9gsSa+DWOOWTUnVaH739x7x27/9e+S5oW4aqmrO9fUZ3/iZnxbaI9BMplxeXvPpJ4/ZrK75k3/yl3nwyhv83X/wD7k8e8H8+Ijl8habtqXs+5RTGZN3d3awhC2KIjndBfYb/hglNktrg0++4F0/kBdCmdNaH6TW508ek2Ulk37Fx7/5Lb74zlc5ycVZMtaR733yiHW7Jfvya5hMVug8E/nzMDiyLCPPCiodmFhNrvRByBOjoyktP/eT7zBtGr7//nucnV9QlBWRCe9+733e/fZ3+OKbr5JNak6WcmNfr9Ysbx2JD0i6YaZNlXw8PApJ6/HOY61l8foblOWe561ZzpcyeCbKcDRErDJgSfaycODV8fv7w8V8Ql0VidYnNhOCY94ERe+b9Ru4JVEFlToMUD9/WGtTes3+Sz6rYl2vt+KqF+JhARH7YbGMNUborpUpKQqxfk31A2vFIApgc72iLjP8OGCyAjW5wftVTBBjgoMO7zVx8yV9qWM2rW5+sMhLVNIg4iBjJIA5F+O6xd63O4qXkbVZUobadI7DgUm63z/dPlkSKLAWrE2LTFoB9u/sRj3AS+cknW+koFgrkAHa8urrb5JZOU95kfOVr36V41t3+Ke//v9hGHrefPtV7pzeJi8LMZgjcvvOiQjUVCTLM/KyYjZfsJjPmEwnHC+X3Lt3V4b21hKiIkTFG2+8SVUVPH78iMvVFUqrg49LTAqH/VA4ixGrc7ZdS1lW9D2sd2uMDdw6WnD/wZS+6xiT8VyWiWZBIjkj2sgORaHT8x0xJjKMvcxtYqBQhrJs8IU0I5nN0BruvH4PhdBjldFkpsBMLJmt6AOMY+BoOQci663HGEueV+S5xdhC9A9aH7pyuRZ7VtMNS2n/6+XC/m+yc//XdizmS/7Cn/2L/Po//1Wm84o33/ipm6c73XTjOOJc4Nf+4T9GIZmM7W5gs32GH3t+93e+RZHfFnxRd7Rtz8XVU167d8zpoqHQjo8+eJ/LiwtePH3EtC5Q44ByfRL4WMDiqkhW5IllJ9muzo2E4Ag+kmU5mS1QShPiyOgjhbbkRUlZysUoS8HFJKyg5snTp2Air7/6UHIhrSXEwN17x+zaVhgpOkoAR4y4xLLpug5jNL22jGOkzhS11ojj+D6jVPPOF9/g+PSv8s3vfpdv/s63ePpc+O6v3bvDg8WMZxeX/Pp7H3P34UP+/b/0P+XpJ5/QlHBx/pzgHUVuKIoK5z2bTcsX33rjQMmr6/ozXQMAMbFbAglnl8mZVjCZTPHOp6ScG754aizJjKKapAVO0IbEAuHw6+XyrY1hMp/y6huvkBcl2mafweoPb+ll2OGlh0T+kIKmlWYcHUSPT2In9nh+ksajNNbYw8BNKYl6lIxTRXQ3OgFzyCNVifp6832V0gcL170lbFXVlIUM3+Q03lg4kIrpOIpCta5rcmPZrtZweidFEgqbSgy69jubAIbPQC9KKSZN/bmZhqUoLFobcSJM5r/7EhkjqKiZTiaYrACtuX16h6PjY2xRgLayc0o/r1KaooRqs2EYBc7Q1lA1lXTRfsRHT3CS7ISSBei1199mvlgSYnJKtBmNzQ/FSilDiHKuYvQcLebURjrsjz78gPnxESarCDGCTqEmyuKHHqMM26tLzq5GpospH77/AXX1OkUmq1vba4wSh748l2d4T2XtxhHvPHtqNCiitSitqfISrWSITkCcO0NIpm95uhYBrTOiEpXwukvZBcYyWy7QKXA8Sx05CmL0hJieAWXSJZXZCJ6UYmUP11Qp0aTpqAjhB7U4nz1+LIp722343e/+Ex4/eZ9Tf4svvtWTZTk+BGJM8nQdUMozjjveeeeLfPLkCVlW0487gjNMJyfcXvxxQhR/j3P1nBfn3+anfvLrfOnN1/j07EqYJVrRXl0yyUYyM5Jbh2LNGBRDiGzWSvi6ZUkzqTFGJ9OmAbRKbIwgviKjBAzkJsMYKy6KWuTWMQZsJiHNd+7c4datU0mqGUWshBa1Y5ZL/qJ34t+hUXTDgDUZRVFwdXVNWZZMpzN2DvoIdWYodLjBnqNnWuX8wje+xh/52Z/hk0fP+I3f/A2sivyTv/9r3H7wCs2kZLaY0Y0dL14857c+fI9bJwuqIqeZ1LxcbcU3KxBj2s5z0xEeEFulxMTLR7JMzMVuZzV/5s/8O1hjKIucsswJSYQjX7lvL5MXikowymEN/2wnEqMk/DRNw3I2STf0DehzMzSV96Nf2r7eFAv5u01RhHnK32zbFusc2ipikK393qkyy7I0gJXv09Qyv7BWFtQs14ToJOE+qhusPS1mKuExSsnHjNbovODWrYaytDS1qJT3P+04DGmHIF2xcwNVnVFXBV/+0tuSZOQN9+4sQUWMTrlJClQyX/vsDCKdk8Ml02S55fbtuzQp0F0C6EeGocf7yNBIcEhVleRFSVYUnJzcpZ7OQGn8S98g7GcbMTKZTvj6T/4Mi+WS69UZzgkLCaUlOQmdHDMNb7z5Nlq4hcIKS1iWSgYTsmOLhP2YRdgOmEygqTuzhrrO0UVO3/eUec733n2X05NTHn/wiNW25ZX7d/iXH36Ln//FX+Dy+RnTn/4yk6pB1RmfPH3Mrtswmdyi67aMbiQgHXxQspMVyb8U8sxaVJqlDP3A5eWGrutEYEaUGtE0BztfqzW5lsS3vbp4v7tQIRx2pmafWRyCsItCQHmPtcLMCzEIBJVo0fv/RyJxdJCLl9bva7o+d/xYFHdUJGSO177wGiF4fv2b/4RnHz3BZqDnGXF0+AjDZceTJx+jC8PgBormhLo+JrOyjb0I3yIqGfx88uI9QhjSiRl4tn3M13/hDaJVrGcd//iT38SrfYAwKG2oaCiGO1gnmL02kaIo0FpYK5v1WnymDVgrA8d210p32UwYujYNPmQrpZOPfPDiJy5xaTphn3sqVjJ3QuNGiXQzRjO4jn5saaoJPnrOL18wm8ypipLr0WFQlJkCrbABjFJYDEWe89brr/Dw3gkvzs74vekdLi4vub0suLWYsW1HijLj6vKcvLR869uPuXv7Lse3TsXOVVsMhltNwzf/xe8wf6uiWixRWoQ4mc2SZa8Ed/S9eNnn1lIrQyCijU4dpnTBR8enN1+rFV23kzzLoTsoMEnqWdQNO0Yp2YabBDuYRHcNcb8tv4F/Qvqcm6/dd8ew2fZoa6mbGUZL5zT6yNj21E2eeOsqbY+lGHXjDbNIx0gYU/ixSngreSpAIQWDv1RQX8JDj4+WLBdLmSdpI4PkZEtMDCzmM4ahJ7MGhaQAhdT5G6NRJuWzqkh2eFplTLwv3jcJVPJLK83y6IgsK8hyaRLyvGAymdz4ikfE9THcdO43WJr8LMbKQhOix4fIMEah+HmFiwOZlXDqN978EmhHJNA0M7TOU1C0vL6OEgby+WIk2oR9p4zYTKeg69EPGKNYr9ZcXVwwa2r+xfPHNJuG+9WCf/xr/4xf+Qu/wje/8x5fVhO23nO+2rI8cvTDCIjJ1tFySZlZgg/cOVkSg+dkXlOXUfJigwRneJVjbU6Mmn4Y2PU7ycjtO2FIOc92s8F7sTSISHjMOIwSwhLA4Qh9e7Bwjn6UhULl6R5VqUuXa2DMntaqD3kAxhiCC8TsBnbZF3iTfLMEsQmHZKofdvxYFPf1bs2v/fY/OBQ8jca92KFnJWa0eB3QRObOonCMoSevSr769Z/FVguRhycrTW0MV+eXPPnkAxQwBs+7zz/mWf+C5cMpIE6Fo3eC3MnuDhsUVk3E+jXdbsPQM5lM8F7sOoXlIR3GOA6MgxghlcmDZBwHUc2mgmWCUCyLMqfvBdffUwS1tQma3isGBedH7b0MBcNebVZkNqOpGvq+xzkvO4SsYN2PjKNnahWFyTEaUW6GgFGSZH9lFa9/5Ssc5ZHvfPSC3/z2c77y5hFFaem6gcXRCU9fnDM/vsM/+8f/X3753/mjdLuePLN8/O77/OTXvsorb3/xQGnc+7nvfWpucMBUeNX+RhQTqsOW/yWq4zQuIEZhIYyjBHh3HevNijwfD51TjDrd+OKEpwgH7OZl7keEwzB7/972BS8Cm7bFxwja0LUt19dXMlRNnf5iPpEOLm2XtVJstjuW8waI+NHR+UhTFWgL3jsp8Eoen7Af4HKoi4edg7V7YwB1WMQOwRrAgwf3ePjwwaFr11qKvNEZeVGIZ7cPwJBeWyXdIyidKLzWkmU5eZZTliVFWXJy6+QzD//+3BwG/iLsSJoKnYaTHKLwUIph6Lk6f44PA3luGMYMbRxhjPRhS2amlJnHhRxMj1KVBMuQC3SXDPiefvqYTx8/4ms//Y1U9CM+egnnGOR6d13HRx9+yN07d7i+OOdX/9Gv8id++Y/x+PEjvvkvv8m/+6f/FN//9AXzSc/kVsnVdctu57i62gCWrh3AGAbvRZdhlCyGMRDwdG4khAGjHE3eUGqhEoPF1DUBjfeR7ehwUTx5FHIPB+fIswzViO34ZtiCUhgt2g2hmAJezNM0e7sLJ7OamCBArKRM+XggjCh1g63vcXZIM6RkN/Ey1i5zKg5f86OOH4vijlKoKPhl1NA93+IuHeq1L/EwbFmNzzmuzyj0iMl6lC1QKsNkQhW6OD/n+uo5R8e3aWZLUSYCUQUen31Cv5gzpiJqEeolQR59jWznrbLEUMoWOk2VxnFEKc0w7Gi7HRHZLjl34zVirTAsvA8HD5KyLNOPlVKNNht5TSPFw/sgmRIvJQfFIBJ5m+lD97qnyDk/stquOJ4LBe/s/IymrphNZ4whcjGMFMYwzTR5lO4/L3OmzYRFkVNmmrffesjO59yNmjL3BN/j/YTnz59jjIQU182Ei4s1H3zwfe7+qT/KL/7Kr6AnC7bbjkmKCLy5ZDehFDJsTIOfkGCCtKUmURdfPuSGj+jMkGWlWPESOQm3D8VHay2pNTESwsgwjvRtR9e19GOPC6RO16KUGHft2RMHWEJJAdwPRiFwcXlJ2dQM/UCRtsknJ/NkbKZwfiREz+nxAoXsFl59eBtjDZkVpeBme4XRhrKoKbL8UKj3cqF9diZ7uAkRGe1xU60l/tCanMViycnJKTbLMUbxq7/692n7jjv3X+GN19/Au4G+H1ivtyluMEoiUpYfLIH3iUhKKYy2jOPAMHTJnvemoO+1Bofz+xIqv1+M9jF+PgZU2mlanUvurQGlLVE5lA/E4HE6JB2Ex7uWIisQK6CA1rI4eT+SZ4pxbNlcd1xeXnHr5Jir60v+zt/5O/yJP/4nUCj+9t/6W/y5P/tnKQvLk08+YbOSdKeuk5+lON/grlp25YQQPUWZEfDk1ki6WgzcvX3CV4Y3uX96yn/wF/89pmWOUR5jI4tipO9bcr0gIq6iERijZ3SRcQyJWKBZzBcYY2i3ElKdZxnRhxSt6BJ0JNbFzmmsydKZlHtRGX049/vuPATHPsBEpbD1l8//gY6s+Eyh33/8ZdbMPnT8Rx0/HsU9rUwxKkqT8+DOQx43gd8LgdtRMSWgu2c4PNHK4A4VUUaKS5Zn1PWcLCuIQTzYldEYY9n2G45CKQ+X1sJ9P2xBFSp5XFe6gTGlz6NSMIUUosvLK6FAKek4uq4/XCSJG9OMY/KR32OtWra0cgNIuDYqMvQuDYKkaz9MwhObQRpTJelBXmhaRhuUQXixpaKuK4Zh4Pr6islkgs0zeufp24HaKiZ5RgaUeUlRZvixQ0VPZgyzwrLaDvziL3yD9dYRhpbzqxVuHLm8PGMcHjA/mvFi2/Kdsxf88++8y92jJX/8j/0c282W11579fCe951DTJaPEuacFj2t0fkNTPHyuRHWy42T4R4vx3z2hldK4CajCzJbiGVz+n4xYZMKePH8Gauri4PXz8sMhCBYDdFHopaQjs12w3q7Jm+E0UEUvrrSCmssEQ2FSoNhzXJZ77lSifFiUEhM4n4gDBwCn0mDOGuNKCttJpmbzUS6wbyiqJsUQ5cGnEoRg5OBcfTkVUMzW2ISinIHGaIKni3/Zl7q3MaUo6u1TfbLQ7LYJV2bcIOVH+h1MbExwqHw94k9FoiMKQC+qkrcGBIQplN4ekOeVdg8YlJ6kUpe7UPX8vz5GcvlCX275uzFc2KIvPu973J1veYf/aN/xH/8n/zHGKP45PEjVteXNFXDbr1i7HoMI+22k2sRxNfok6fP+N1vfYeyLHjjjdeYTRuMhp/7xk/z4M4xX337Dg5Nk1e8+dorqOhZTgpiGIlRGGCvP7wtts7eM4SMwTnavmP0ARd0YsqJTXEIMfmvxwODJs9ynJNkrKgEpjO2wOZSa7SSTOD9cFRzcy+qPYMqmd9551CfY8iIhkETVPhMbCPcFPM9q+jfNM/9X/thjWaRN/zaex/SBcMvH7/NdtgxUQtUvMcYPyGGyHR6ymbXCX5qNHVd05SVbLOMTdaqAe9uKBj7BxEl0IVKXZVSigyDDbXQkdhT4DwxCGeibVsRvhiVgovjZwrIPkarqqrDxRrHQb4vkJucPLNMJg1jObDd9RJskSAehXSEMYZUhNRnCmYIDuUVufL0w0DX75g1UyZ1w2azRSmxNzZZRucdQzvQ5DlW52gUk9LILiX2ZEYzKRWv3n8dozXvvPEGv/Evf4+inqDCiNWap4+fsDw+wY+eYRhppjN+67e/yXvvvc9f+Q/+Et/5znf4+te/Rl3XHLjgGJyT/NcYIzGZKGkjdLt9cTmoTY3FaIM1ibUROSgo94fwkG82DEony1wt9EUdNUpr5rMjjDJ0fU9VBbRWZLlN9MjIi7MrKd6ZIUZP3/fstltOZwtU1AfOSPouCWLaS6BucFKjJU9UG433DpNlnN55QJYLxlrkBVmW08xmgiUrJYuvERop+wEyGm0yQLo1lNwnIcosx2aVWF5ET/QRkBxbpbUosfc7k4TVWmNEh5rgMe8cXduhiPI+jXzevoOU+/dme78/w95LUXHey1AQoYrmWUkwkX4U7UOWZ4xOiAE5OYbAr/7DX+f41glffueLXJxd8Df++v+D/8lf+veZT2fstluiVuyuW/q2Zbtecf7iBTYzdLsdCihyYczMphNEKeFQOlKWBZO6oN9t+MmvfIXz8wt+8itf5Rtf/0nKPOeXvvENMTjTkj+qoxHxY/SEMDAMTuYrY6AfPbvB0Y0eh9hMaFVgrHTgo/MoH1IsozCqghvluvtwGPhrrQUHiIHgI0pZrM3S7m9vTQ1oySzYs3IyrRAX1Rv4y6RCvb8+ALkVM7t9dsC+zghEk2IuX2qufmg9/UPU3P+/HFFFMqPZXG754NE5KigWZoF9Y8p8coQPJ7z/8YS++5jm9oy27zEmYHJD8CMhSHDyMI4S6ab2drHSbZlE25PvlTpGIytqoaeoMcdY6a73+a1akSiYDoWW4NsgJ72ua3mtl7rYPM+x1qZU9RE/SsDunrssASAZxEFCIYwmpG16lgJ799QRrWUFB4lu08ZAIQtSiI7tdoMbHEfLJZvNjqfPnh3CIpTOuB5GFIH5fM5sIu3fG6+cyI3lSnSIWB3Jcssf+cZP0vaOaf3nudqsmRQ5NiiOpnPaqzUXF1cUVcbRrXs8fXHBP/xH/4RXXn2V3/yt36YuLT/xE18jBo8Pnr4f5Ka3QrszUTM6l0I0brrGrusoypwQs8Qi2DOR+EzXYoxJxVWCO14uTDEqggtUVU1V1YcFZByFBSJJP56HD5I1qtZ8/OSpuD6GwOuvvYmOIpPvXvJn34dggGIyOky6rnmWMfQ9ZxfPCN4zXx7x8PW3MHkmuxUj3XVRpIxXFRPEp29olyHKjkPJwzw6J66EYaBvOwYfuHPvVdp+y/e+/x2aScVscoTROWVRSXeu0s6UvV9PSItjRCcocOh6nB9lgdV7mqXg2zZRKb13aQ4Q0vAzOT8q5Jr5SFVWKBQffvQRRVnQTBtc8Py3//1/T1U2/Mqf/3OA4vGjJ2xWHV/6wtuMfU/XtlxdXFAVGUVRsnMDk9mUXMmAetrUeD9CkB2lIlLmOVbDdDLhl37+Z5hVObe+/EW+9tYbvP/hR3z5zTf50FqaIqcoNNF5DAZjFdaWYvTmhe7a9p71pmW7a+mdxyuZTRhbSfyld4n33pHnOUEp+lHU6jFGsr1ZevCHeM2Q4Mvdbie779TgueAZslF2TWkoKtCwqNhdiOTWkFlD8OBcojgmFsweW9/feyiBYn2KBnOjk/mKMRgttaQois+Ej/+g48eiuEcF0WoZXpjIH33rizB4wvMt3/gjP4NeHvHr31lzuSvo/Q7hhWh0dFw8+5R3v/sdbIic3r3De997D23ADS0h0eaUTui6gqD2LAOVOmuNiROCN6hsTzETybVstdKDHpMRlVKUVSWBBqN0qmr/wChZzfcXIvggCtZBzMC22wRPxDTgSjuJPda237oRI1oZ6Qh9QBuVeNgyKXc+EMOI6x1udBRFyXw+4+rqms1mzXJ5RDNpCCFwdHqK0rAKGVVWUBh5fedHGegQiUpTVzlfeOMhbb/jzVcf8tGnZ3TjAIy07ZrJ7IQPP3rE6689YDqbEZXi29/5DifHS+7ff4Vf+7V/yk/91NdZzGfEAEF/FsOVYBD5efuu51f/4d/j6z/9NR7cuU9Ush31aSi67zAVELzY4GotAyxj7YEzv98y7wuWSlyzwhiKsmI6SylDabFwIfz/qPvTYNuS7L4P+2Xmns505ze/mqsaQHej0QAhTARBkBABgRRJKQhSosI0SSnECIeksL+J4Y/+xK/8pDDDEZYUtqzBFk1KokDZEiiBoAkIaDbm6q6uqlev3njvu+MZ9piZ/rAy997nvlfV7QjJUdod1ffdc885e+/cmSvX+q//+i+OT89Zlw2z6YL7r70VktiIRn+AANq2C16/GF90KB4yhrauJMnrHNPpjN2dfUmoatHoQcnz8gq6thYlwi7SDjvatmZTrvFKmFib0MVJqHc5P/CDX+fWzTuU5SpsCA1d53HaonUbkvYGrwzeB/2hphXj4C2pEgpxWYvnrrSiyLNQqBfzDyE3gvzbWXEiXJi7py8u+IM//BY//ENfJ8sm1E3NL//Df8j91+7z03/sj9LZjrIqWa9qLi+WOOc4Pz8nTXPOzs9omjawSHLSTFN3luUqYW9nSqI3GO9xTY3WjnffuE9hYGea86//lb/Mwe4uaWL4uZ/5abpWeoyiNPdvHvC7px9SZCllWZEms/DsNKV1tFVFWZWslhVVK/xxkxmSfEKae1TXynWXG6x1AxtJKzblhq4LXP3AJooyF52TKMZ2lqZrJTFvBI5VSvT8xTiLdHVPX/Q+UBoDjOM8VVljLULzDonfbWzd472hbS3O2yBOF5qx9Myw4RzXcfnrxxfCuCsk0rRdw+OTCz75vROqqmFz/y4/dnCDxdFd3Pu/x5v393n/d4Kc6qrkg//xn9A9vaTwDpMXHJ8qTLnH7NYJ66TD5sJbFiMeOXPRNEiYm6oCZTO06vObtE1L3VSkWSo84ICnd11HXuQoraibmrLcAEhH804khGsnBl3gGy3Vego652g38n6TmMGr00M2XBathc4h7eAI708CDKTwTlTtbFAA9N6x2SwpS9jd3aeua85enLBZr9g7PCQrJnS15XzTsUk1i1SRaSlNjz2NvHc9/p+alN1pzt3DPaxtudqZcnh4g7JpcFYW7NnZGWVZobThxs3bXK3WvP/t7/Cl7/8Snev4xm/9Nn/sj/4E08DnhuCZI4JfSmvefO0NpsWctnMCHyjJfcRIyFqLtw5jnDCbQvI6cTZgsQOE0xd66HHFpRgqWUQhsRoCo+l0ivKSdE6yAus8mVI9ppn5OLY+MHEGrFqj0MYIh1tpuq6idjXWQ7kpabsNrd3gnKepLNooDvbucHH5FK0mpJkmLwqSNGNv75D1+lKiQZ1gTApKkaYZTk3Cc446ItBay6aqSFODtRLyTyYZVxeXpKm0e0zNRDpxaYPrGrQ2NF1HEu6nqirhnWcSMbVty3/1X/0yb775Nl/52pdxeDZVxW9983f40pe+zHzHc7lcstpsuLxacnl1hVKe5dWSSTGnqtYSlTpLkku9Q7kp+3Wdmoy2szg/I0k0u7tz/tTP/TSTDIp8wr/yF/68yDMY2L+xF5qGC8Ztw5c4NEmSkSc5+ztHOJ9wWTpq21K3lzSdxTnp65pmBTuLjDSVXrrrcs3l5SVaSy6uaRvKSlrszWYzUpOSpInMlRDpFUXBdDKhCTRfD9I0p5Wuazp42VmWgVK03VDLEQ8fmoybNDSf71rSNCdJFIvFDm3bUTVNP6+iaqq1DkULXqESw9X5KY8efMS9+68x3zvAmqi9pP4XAst4UK2jwXFxWXJydilMhb0dZvtHGDSurrh5eEQSVuim3PDo00+5mx2wWMyo1JzliwWbGuqLJzhvSVIdYLLBaCilQkMg6TyfqDm2RgqPEKy97SqMUezu7uKceFjOOabTqdC2QtIpzwtAEhxVVfWGzCQhXPZWBAmtxSSi1+ERTHi2mNHZjrq1aK0QRCYYFRTOSoFDqjPB3a2jUx2JCSXLod0dyqK0p2kbTs+es1jscOfObU7PTzk5eczOzh6L2T6JT+jahrOmo8gyCqOYGGlwIRWnkRfukaKognfv3OSd2zeZzHb44KNPyHRCrjzYjtQonLU8fvKIw4MDppM58/mcF2cnfPDhR/zEj/84y+WK3/iNb/CVH/wyh4f7hCwyqUnY/4Ev8U9Vyx/1noVQSeic7w2pPLWeed2Hr17wB/GOAhOmp3iHBiLxObvO9dioTjPW6zUgVMbNukKb8EwCa8YgwnVjsTIJ3z1NXdK2HZfnL8iKCflsynK95A8/+G1a03Dr1j02VUlnKybZDKNgb2+XJNUcHdwC1WHUhCQFlEHrlEQXFEUrxS6BCaOUUGa7ppHIz9doJb13UYaqKsHntC3gNUWeUjU11ipM4lC+ZZLnNE3NannFZDphsZhLE27r+C/+q3/AzZs3+RN/4k/gkabXFxcrXry4pOscXjkur64oy4arqyXz+ZTpbErbNuRZxiQv8EqeQ5oaslxTV6FwKSR8k8Tw7ntvUWQpGXBnf4/V1Yr9xR43Zyn37xyE6NVJMx3v8dajvEgMO0VQbnShaUyKSye89t57NC2cliW+rEiygiybszdLSJIs6O0Y0kApttbRdQkKT103WBxeQ5bnIvqmE/I0OGt13TPdpCG15C7iobS0ruw6WctKSxGfSRPcWhwPbXSoG5D5KE6rVKl6P+SclsuV4OzBYXHOUVeVwIt5xu/97m+gnOErX/kRzk+e8bvf/Mfkkz/O3o07veMTo4XPO74Yxh3Aw/7OHj/xw+/y6e//PRIP33fvLiYp6JynbTZkRrLNV1dXdNbSuI7yKGN+cx/ftuwUL1CrJcvlUvoaGhnhqLPtAvebwHVPXUri5zil8NpEOXeSTGRWsyyh3AgUk6aCq1ZVRdO1Pd8bxPsBMUDxfVpptEG8AjN4ST7wbru24/bdAx4/OsaqEbUpKgqmDq0MVvtQTdiRKYMyHVqFJgN4rPeIbFeLx3N5dcl6s2H/4ACtYL0uybMd4UIXhbA96oay9dSpYppBqsD46MeD9S7Qy6Q3i8Px/W/d4QfevMXlasVP/chX2J0mIj3gLZNJyuVSxt11lr39ffLJjNOLS379N36b+6+/zv7hPh9++DEGxf137nPVlfyTpubrkwU7Wkkpvttm1EgkOhj8PiHLACcorXFdizYiHqa1YZycivmQspXn5r2jqQVW6JzFuDbkE2V38HhsqPps2w6Ppes8VXNBmhaU7YovfeXrpKHYqJhkdK7i5sGbLNNLOrshMxOUtugkB8RA5HmO7RTOtVjr0dqRZ4X0yrUd3lsUEzwNk8LSlGvqpkXrljSZ0XaWRGc0dRPK4EX4Cuc4PXlOnibs7e/g1Zq2WlPWJf/Z3/27/MzP/DF+8KtfwTroPGyaltOLK8qmJVGe5XrN5eqCg+oO601FlgtFExTzxZz5PAiYOUdiIDFKYCAFGou3LYn2/OSP/jD7e3tkviOfpfyr/9I/T4pQZLNFyu+XS84vUm5MJ1Kkg6SstRZj7lG0VtEpqLqOsqpZrmqa1lK3LcpokjwnnSRkatj2BZLLQp5Dir9kvsicMaFLWNu20qLEiDHQXmOUYVJIHqMJVcJKGYpigsbT1LXIOqDwGpwOYr9KYb2jaiv29naZzSd0nWW9qbDeIqJ0KlSqGvKgO7XZbEIEGunDhHyeMK0UlrZc8ezjD1De8ANf+jJ37t7iT/7xn2Zx5w0wBhPmszEpsXnMZx1fCOOuULz35vfxYz/wk6wvPP/vv//f47qW2XxOQIXZX8xYTAuy1LCzs0N6Io1+1+tL1g8vKXY0ZgqHeym38wPy7Abf/tanqDzBJzrQ5tSwo6LI1AxbSVjf07wSYSZY60jTjLPyShgEXUcdki06euE+FnwIm0LHQh4rXmWe5b2BEpqasD2MlsTMk8dPpaQ+qh0qjQ9JVNFmiRrdkTkiOJ6P4lfeyEO2wKiEu2kcx8/PWOzM2N09xCTi8ZVlye7uLsUkp+s6ll3NuoRFZpgZTeKFfy9XoPvyenDoVJpT3Mwz/uzP/yy1U3z5nbeZzQoMKkQpwhg6PT3l6uqSui6Z7+wwnc1oreVXf+3XWBQTbr57l0VruVOWeAvdfBfpwK16Nsd14aSxjECP40GAszRt16KVoSzLfqOMBSAybkpqEazn4uKc1brianmFNqIGaa2oBVpvaduW2WxKkoomvjEemDOb7rJarkkzUe/zXpOmCZ2vUWSkSYbztVR0NjV0Hu9b5hMoyw2KHGJVNBKq13WN7VqiXrj1VR+eO+tCxbIUTD17+pRNeUWeSwl/VdVsKsOv/MqvUJcV/9q/9q/gtNBKq7qiqmouLq6wnfCzm7ZmvV4xnUoy03tHkRcopSmmOTs7c7yXXBNeDLm1LSbRFJOMNNEYLLnW/PzP/nEMMLXSD/anf/gHZOO1HU6Fph2t9M7VOmF3t6BtRDtm4NxLV6nGQt121KsV6xAFCE00I5mkJDNJ/jZNHSjHEi1Pp1Npwh0KgKSuRCIIpWJRm+oLgqq2QWkta2tUVYwXMcCYcxFvO64nyU/YkLCOc1L47I7NpsQ7L1EPkRYbwUFxCvM8o227fg7bkONAi4qqUfKME+WZbCp+4StfFx68XfL/+K1f5aJ2vHXZ8os/NEdPdrFhTmfZ4GC+6vhCGPfZZM4f/5E/jXGa0p9z48YR88WcdDoNkITnS6/f4eDwiKP9giTRTKY5b73xOuv2ktfePMQlVroB6cD/tYbvfOdxaLXG0EmFUEjiFRlzGufIYlGNdiIQpsJGgKFuSppmm8PuraOjFWMcNs9o9L0oDWNMIrLDCN4bm4koL/Q0UNg6hG0x2dtz5I1ge07jpNoK78FaH7S1XfAwChbzHZxTbDZXNE1N5yI10bNZl9RVzdtvv4NSGWdnJ2w2S3bmC2nTlU9p25Zl1bIxjlliyJUjM6rn6PrQd1P50BFSycaTesef/GM/isJwcnbKO6/dYW8+YVMJXS7PpbHGxfKKi8tLdKJpupb9G/eZOcV8VfMvPT0jWcxgdw9JeWtsp/C+6yv2lFKD4qGXwrIkS2icJdEmQFmIp20lsdi2bb+g0zTFe9FIn2QF3ofSb21Yr1Zo45hMJzK2aKxraOoWVEOSFqRJJlFYEEKbThc4b/F0tK2n7Woau2GS71O3JVW1IdEZna3EwND1WLf3HUYH0SdvmE6b0KdWDLtJFV3t+fjBxyxmE2azBcZIkZDRmv/6H/wDzs9P+V//tb/MJM+ZFQUXQV99s6pwjad1NW3XgoOuacmSgvWypChyjPYBFkvJs5Q8y1itVsJS8qG9pFKkRrO72AHvSI1ilqf8lX/1L2GwZL5DG8/e3Zso57BtJWvH2lBw1gUWSYpKw6bvLbluKdc1jd/DeU/dasqqobatQJIK0jxnspj3yfGu7Vitl6zLFUki2k3T2ZS2qbC2o64rIRkg66inIarIgA4CZ3nOYj6HzVpqYJTCtcIQ6rqOrmsCo0si5KZpUFnSJ0slspc8V9u1uE42phZF15USQSkhPehoZYLBLgqpXu86+1INBiEKFUdFU5Rr7C//KumHz0lmU+yf/jonpy94WHlOzi/44Xt3uXd3hklz8iwlSczn2tUvhHGfZFMyKwYtTRImk5y9vV1uHN0k8r1fu3cHpROy1JCnmr39Ka+9c4OVK/DGYYPHq5C+mdor0lSoSD0uGwgqWikSV+Ba01PuRPMFYpoxTTPyTDxc50RRUAyFHyABsy1UZUOyT/A0UUaMWJzzkvXXPsHa5qUEjHRYSaQCrqtBEyhVUZxfMMrI/JgUE27euCFaJA6KIuHi4pz1eo1z4tkURSHG+2pJkiTcvHGD5XLJxeUlm82G/f1DptMZPvRavahq8iRjkhomtEE0aZDO9V7YA521KI+UZBu4ub/HX/vLvwQavvPJp8xmE6Gi4rGuw6SGvf1d0iRhXW7QyxL3m9/h9j9+n/Rf+RkqL0xz0e0YxliHxTAtJrQhfI100VRLNJYkCa2zpCZBeVl80cCLJERL9KDW6w15nktvUOOZTAq878LYSoFa1zXCzukcSqUopGLROkuRL1it1phEYL2m6VBK03S1XH8n3qXX0HYNJjE43wWcVBLHKlyb0WA7S5EVPf6aZSmffnrKf/gf/F/4F37h5/kzf+bPkqZSWHR1tcJaqXNw1nN5eUmipfXfer1CK8Xl1RWLxZQsSBQrpcmzlBtH+2zKEmOCEqISqYu2qYOg2E1ms4kYJtfx9mu3+Df/6l9kd5JRGM/MGKb7+9i2pq1K6YIV6jiMBx8aMGilEGHFoCUfGD1NB7v7C6bW8ORsI9IDxpBmOVkeGFCjXggi75CCimQCRReinOVqRaJFBmMymQWWCnhnByOPwIUgdjPLMmEjmST0n1V4JUyuyHiLNFFZ21ZaAgaKosPjImSI2qItppGlFfM0PjppYEwW5IV1X8gmzK8kOAsRXLIo72jWV2xOXrC7XFOvN0xOr/jR+69TP3yKyib4yYS2WrKY7/Rkgc87vhDGvWmE952mBttuWEwm/PiPfJ3DgwM8HbEcHzyzacbduzd574fu8/DqU8Gm+zAIlBYP0xnFe19/nSSV0FyFsZemuAm536FtWopsEqJ8adqs8NLdPkuE+uQ66aGoRwUMIwpSrPQTKllH5wQLT9Oc6WRCmmZ4XKBgSYJ14BOLlz6dzpnNd6iqSlg2jRgaue4wYbyjcRblPVlqmE0mfeEHGvJ8QpqusW6F9dINviikLVxXdzRlzWp5ycHhAbPJjBenZ5ydvaAs1+zs7pHlBSYVw3NZdTRZxkRrJr5Fe8lX4AfJAaODpktIHOdJivWWd+7d4n/31/9V8umMh89O0KrF+RbvxTNaXV3hHx2z+fBTdLUiX1f0QFlImiotCyRLUllgQT6XPvchevo4T9ta8iKnqwXaMEbareV5Tl3XoZ5BUVc1eZ5ifYdXmqq85PTkmMViinOSj0h1QlNbusaC17QdWFejyXBeeu5WVQNGjFNZNSQ6oetacCIlrMJGlSQZeZYBhnKzFIgO0R36h7/8y5wcv+Av/oV/mXt377CzsyNc6CwDJ7S7sqxFXK1yLFcrus7S2RbvHOtVRarBZ4rdxQKDRyewWMxIjSJLE57VJc51tHVNXZZM0pzlesPh4RGLvR28sxSpxnYtf+WX/iwaRaoBhAass4LOtnStpQ3FSwEfFD1/7yQ3AeAVxitpRq0z2g7O146qa4Q95j06z5hkBVmWB4ZJQ1lVlMuKzlqyNGM+mweoQSLoptmwWS8pqw2JSeg6oTC6gK1H+WKIDdbHVZuD8ySOzpSyqmkCNJMk8txam/SNdoR66EkSRZGnTCcFpVLUXYcKNRdJoMSODbwKTKuoKRXSRRidkJpUojI1FD5a5/Hhd4k6Da2tqWxF8u4tOi+EihdVzVdfu8OcFGv2uLW4xerynGKnpPOOq6urz7WrXwjjbm3LannO3v4BBwf7/NW/8r9iOpugFTR1Lah7MIZ/8c/9af7w2bf56PRjOm1RQScaL/iVQ4pcvPdM59Owg4dkYagS1D5BuRQYcHCI+K34qVmeCZc0aG1HfC4m98bYsNbRW5BJlucF8/nOVqFBkhhWq5V4XiOvPU1TZrMpu3tz0o1itZIQVCOeaSyOiee11rJYzMnzYqDr+agimBBL4UUJMEOhaeoG5yTJePz8OVkxYX9vj7atqcsNz8uaxe4us5k05fAuoW5q6kZTpTmFakm8PAejQkRBrOIL2GYYxzQxZOkM6wxHe3N+6V/8U7x15whlu9gxgssPPpGmI3lCOzGhWg8p3w4eu0hAtOgk6fFzAlab5yl13UnVcCKtBLM0xXbSBjDPc8qyCtLL0NYtk6JgVa4oy41ISQB5nlFXFX5lMVlF2zkmk5RMG6b5BK0LLDVtJ1CczFWLwuGUSBUIP32Cdx1pkjCbijSx7TrqzZK2t7naPQAAhdhJREFUaWk2G+q6IUtz8ixhdXXBixcn1FWFbVvaqqFqWk43L+iaGtd21GXJwwcPKIoJOzsLUm2ke1OoRp7kCWW5wVkrxsTDfDahLjd42zGfTdjf32E2KwBL167Zn2f85X/5z5Akhlx7jG/BeFF/jEnoUDdgNLSNlYR1MNBEYx4KFqzX1B46r6hrz6bs6KwC5VDGk6Yp02xCksomXVUV1fKKpm3wKEyakhUFibPY1oYK52FdKiXrZjabSf7EBbqq7ciyLLDPhhSMD9BrXF5Ry0ehKfKcyWQilbUhlxHrS6TJi2cynTLJc4w2lGVFVbZBDdUGITHVM2CikxO95y7AOj5QfVWYH+IMyvui8J9HowP1GUI+zVqKyYK9t3eY3c9wCn7tO59gP6n5lV/7dSo35e47X+b+7Xtcrq6o64qRGXnl8T0Zd6XUA2CJcDk67/2PKqUOgP8EeBN4APwl7/25Ehf7bwN/GtgAf817/43P/35LXa5xuzsoJY0GCGG6wwd6njy4p8sTPj5/RKtFKtSrKNpECA198KBCVWDgbwtlRrq8TNQc1xpSk/aTWWAzWTy2bZlNZrStxXZWHjCKbiT8A8OuHXGfiLPN5wvm8zlFUZCm0jUHtctB2wbKmBxt23J5dUGWT/DOM59Pmc1yzs+bkGADUGQBy2tsQ5JkFNmExKR4P3DDZSEk4tm2TsLeNBXOve+CaJFM5mpT0tS1yNHevs3J6QUXFxesVkqw+OmMvJjRWcumbamUIkunZN4x9S3aAXqkLuiHhKoNHrdWmr3ZnJ/44R/Cdg2NhdeODsgmOWkF+d1buOcll13NVAv44y2kaUJdS9WgdR7XtmRphgsa4WmaUlc1WkuI3XUNeZ7TtY0wJ0goNyVZnmGtbABpJnTBNM0F5gvAbF3XpFr6htZNIxXKXkuVs27omhKdavLJlLyYob1ib2eH1jWh5kByIFlScHVxQZYHTLhuIIWVuwADs3xC13QhWR/qKbyjqko+efiQ+WyB0ilHR4cSjbmOPE043N8jSROKPBWGWGtRXlFXG6bZnDQxNHXLtJjSNjV1uWY2KSjXKw4WC/7Nv/JXyBJNnshcSmiYZCJ1EfsxCY+/E6pt0LDPQpJDYMEEpQ22bemconKapu1oO0dVt2wagSdNasinBXmAEZ3z1HXJ2cVZ0G5XTCYTilzEvlrnWFdrmrrGe0dmDHme9tRBiPRgMX5xnaZphk4lmRoT5vE+onEPNmug1HrRDsqMrI/NRgqZvI+FcEKYWC6XtHXNZCKdsjrXScTkB10enKeFLecuaq2rQK3VgZUTGXXyHhvyZh0e019vbNyR5hlUNebZ78FG2EFvdR3fOJ3jybjYlLw4O2UxL6RDVG8TP/v4/8Vz/xPe+xej3/8m8N967/+WUupvht//XeAXgffCfz8O/Hvh52ceznXMJvM+7I/ep3ilQGDMfPj0Q7758A9oVSuJRiTRpwLtKD5c4wQukCSp72/UW0/qNZkWalle5P01jBkpAMorlst13FMEZxwXs4QQSx6QeCZ7+wtu3Dxib3efopgOhh3B8sWmDPfmnOPTRw+JTq2yhoPDfcpy8LQHoSDd83Ank+lg3P2g7icNKTIcrhessqmlph7GM/CPnHVcXl7QdQ23b9/marXhxekxT58+RSnD3bv3mEwmJElK17WUdUOHweUFBZaJF5rY4MXY3pOxKqSjlSENtM0M+At/5ufRxnD5X/waRWp4WCi+rzJcdpY0ybHO07ZNCJkDBTURGCZNU1pnQ0I1pawayZ0kiTRuKAq896w2azH2oSApz3PqphnGsGn7Ap6u65gv5qFTkBj5TVmS56IRoxGDTNAQKTcbDFJBmBYZTsNidx8NtE3HZDbDWUfrG4xOcDYKwYXn7wKPIrQpnM3nLGZT5qGauG022LYFL/h91zZU5YauKKirDd46UpOQGMVqdcV8OsUbx5/7038Ko6BQHYmr2ZkmuNaGysYgd+A1dFLbETwZaSepfISKsSG54lSAXXRK02kuVi3rqqFqmlC1DEVekBVz9hcpPkgebMqSqlyH5LEjz6dMFwtMJxIeVdOyXq9l0w3X5ZwV+WKlhA4Y1ofWCc4pyqqk6ZqAdWdCYTYi9SF5FR3ycnIo1f9zWMvQz5UsTSlRNG0rz1jrsIZkPvg07Z02750011HD+o9SwCL/LePonUMb3dsEUecc7EMshhsInAyve9/n1XSa0NYbmtOGqvV441FaHKMsTcmyhLop8d6GAqn/+dgyfx742fDv/wDprfrvhtf/Qy8j+0+VUntKqTve+6ef+U0e5oudXktduM2yGJQXjO3B80d88+N/RkONjwU8PoZIstNrL93iQRz1gfQIyiqMVWRmgW8T8MI/dsHrdQQBJ+9xnSPLJ3Tna3zojhQ3HqFohY7kqQm64/Ds+Rlf/5GvcXCw3xvuslxTlhtW6zVVWVHVFWUlTQCqSv5784232N8/EBZF19JWMMmnWN9SlmVI5OYYY2nbjqKQMFcp3U8UuVkV+L4TPJYkyYCENJtg0kradxHHJIyR92w2G1afPGB3/4BbN25ycnLC6dk5H330Ebdv3+bgQPqtJommbTpWVU1loMkSMq/IXJAGUFJB6wLVTxuPVg7bWSnZVlIGr5VmiWLn9hF7hWJnbWm0eINeaTA6SB9ngJX8QZaHTliexCRUZSmFIVaak0+mE7qmpe06itD3ViGt2qpKPHaTZFxeXmKdxVnNcrkhTQuaztE6x2Q6Z1NW2K5FpQWr1Zr5bEqSpIMj4D1FkZGmC5qmQQOpMRLdhTC8tQ0eKWUXVpTDek/nIPVO1BW9FaqpVsGjC7IH1uEC775zjs42bDYr6npFkab8/J/4Cazz7EwSlHXkqmGaa8gnQQjP0jpP03najsAf1zgMsXu3CvQ7DUyd5E6MAas0rZeioabxNNZRNS2N7SQfkOdkecr+fCK4sXXUdcPVekVZVT3ePJnkTKYzQLotnZ2ehN6napvR4h3Ku5FhT0lMjkKa3QgbLCdZp5RBmE9rGedW6RClhoI+ZXqHUOZ1sA+jQ6HIspyi66jSiq5ryRJDniXYDsok1LbkOUlSYIwKMGcjObVYYBcFxMJ9xG53Qzep0MkpyzBpFphAPvQK8PiQw9Neks3B/KG0JpvPcbM95rstVVPjPfyP73/I2cby5ltvsZhMePrwQ7pyxZtvv8ud2/c/06TC927cPfDfKMkc/h+9938HuDUy2M+AW+Hf94BPR599FF7bMu5Kqb8B/A2Ag7254FTBWsXGCz54zI/PHvPbH/8mpd9IOBMSEtJBfmiaLJi7hGqJi7riYcMIHe8z5jSNDTxl3++++Ni70AfGjsjqJiHUIjwAaRmWSgY+F0/5937v9zk+OaazHe+//z7f+c6HXF1dsVyu2GzWbDYb6rrCWieFMX4oTDo8/EP+wl/4l7l95whrFU0jHF/T87jpPdGikKTbOPyM3knk9EoGPxWZ4BBhmERa+fVJ5/j+MHC2c5y+eEGWZdy8eZPJdMaTp894/vw5V1dX3LhxJMm6LMFoRdM2XFUdiTFMTUaGZ+KaLTwyMhbiM4yd5jtrWSYdd2/vcev+HtUfPGXiHWmSUobGB0obbNdhMoM2itV6LU0ptKaqSrIs6zHOPM9pavEmp5MJm3KDVoo8zyjLkiwrSNKUi8slH3zwgTSHMDmgePT4CTePDpjNJlR1TV03zGcTwcu7Vtg0bWjAoDWrUOGqlKIsS+lzmuaUXUWSSNLXdi3WSmJeFBlNr7bofVQWDAl464LAmSQHq1L49T/7x36KuzcOcdWaWSKGMHMt7947QusElEUHbXmC93fy4oLHz1/QZQUmnZBkE9IgR6394OYoHSp7lWLdxcpfSVR2TlE1Ld7KJlkUU6ZZgkkMbSe67JeXF30xjkkSsnzCfD6jaRpR29ys+6gperIxer0+X30gHySh6XfkrMf8VlxrJqzBvgI8JESlqXSYz64XnoC+Ac7LR57lFHlB3dQiyZymdEqFjmu6z1WB63XyhY4cKJReHJY4121k34zuLV67UJrDNanIshnyZOADXVIiEqXA7Nwgac8wjaagwOkNhpo7d+7i24aP/uB3SH3NwXzC66/9wCvvMR7fq3H/ae/9Y6XUTeD/pZR6f/xH770Phv97PsIG8XcA3nztto8DE5MPLrSiO1ud81sf/AbL7rLHvCTh5tFexR43wtoI362cyObiBxVCrRQqmYHP8a7BmAjJiFc+zrQrkwqu2NS9KFWe58ISCYpsxaRgb3+H9abiW9/6gLfffoOqLPnP//P/JycnL6TwqbVBDCtASEqhtXyXhK7w/NkJ/91/99/zS7/05ymKAq1rjJGu86lJadqG1AgrwDslpehe9cUaLz3QJMH7tGf1bDab0FgkBIZ+ELiNG6jQOIWL/fjxY6azOW+99RYvXrxgs9nw6aefsphPuXXrNpPpBJOK8mVT1yxtxyRNsDon0w5vFdpLda3kWEVjI57PefA/8Aabox1ONlcc3/R81YBGePaTxFC1DabIWDYW3wle2jYNVSXJZMEuHZNiQl1VKCVCTutyA9qQpgnrUjRUdGK4vLrkxYsz/qP/5D/DG0WeT2ibhn/667/G/+Zv/Ou89+7blKslxWQCSrMp16RBbKt1HdPQBWu5vGQ6mdK0DZv1ium0oKlL6qYmS1OqzYbl1RWeDuUdtmtDi7Yw/kqRJIpJVjDNcvI0QWmL6xqJDBLHIp/wi3/yj2I6UNgQzQKqk/yGEt0ii+in29ry8PEzNpuao4NDmrbj13/3d3j07ITpzg6HB/scHRxw6+YtZnNpKnN5dsmjx485OX0RNl6pyrx163bo97svVM+2YVOtmU5nAybdtRSTSRBWk0Y04rjYLQg4Yt4Ra9Y66T3VwVSoniwhTtQgQxwdrzRJ+5qF/ru13sLlYTi3QmFSaTUojtR2NyqlxOPP81xkBpIMQnvDxIypjXJubbSMNRK1432fawHRbI8XHQXvIOTjxgPihT2jlERRWifszHcpioKyFNluvCabTGG3hdZSWOnRbDDs7u4wWcz4qT/64yTLM9R8jud/Aiqk9/5x+HmslPq7wI8BzyPcopS6AxyHtz8GXht9/H547TMPrUXc3ruhMhEP56slv/EHv85VdSmFRaGFFS4mhIT87xAPxnkx6iZI9gZfRaaQg5w5zomx0GpQwZNCi673fieTCVmakeUZWS5ViFHHIfLHd3d32D/c5fT0Y/Jswmuv3+f3f/8Pefz42ZaovlQCDmyf+Vw8SumiorCd4/333+eb33yLn/qpn2Q6nZDnKUmasrwqBYtXiWi5JKCUDhVuMkhjDD9en2g+C493s17T1NWwaBi2BLkuKdt3QRHPOcfTp08pJpfcvn2b3d1djo+fc3lxyXq95vDoiIODg17euGtb1nVDqTVFNiFNDNa1FN6FphGxom/IiRzdv41ViqO9HQ4P9sLfXF+NmyuP71qmSmOSjPPVEte5QG/sAoNiTl1VOOcpipS6rsGLx7QpS9H9SBLWmw1JKlh607a0tWNTVpKgU3B+IZ4ohM+uN/2zW2/WuE6MX9PUQWvEh4bWDqM1TVPTNCIJUJUbNqsVWZHibSsS0db2TKKqbkhnU/6FX/iT4Cz7sxTllVAZ24qJkWxr4mOFpXiNCgJ+Ly64sx1OaS4ur/jwoyccHhzx1pt3sF3L6viUTx59yuWm5vTqigcPP8ED+/v7/ORP/iQff/QxDx58zGq1outa9vb2KQphST1+8og7d+7wwz/8wwC0bc3OzqLPV1g34/yi5uLysmeayByMM+uzc3yiChrZLOF5hxoWHZKPMbkotykzNcuzPnIFwcUTk5FlBYTeC1Jc50kzj0m8yOq2QdJi6yokoozYe5qKsdVahQhB9PIjdTpGDHg7aMaE1wnvQw1FdjBEruMK1/hnrVPhuCvDYrEgTTPOz87JsgQdIvKuazDFhNZ3TFLHnVu3WW6e8O7rr2H1Bj9L0JeW6d6cWlV83vFdjbtSagZo7/0y/Pvngf8D8PeBvwr8rfDz74WP/H3g31ZK/cdIIvXyc/F2hOwvAx+qDTGsqjW//nu/ytn6uSglhjJ/wk6pQ+GEQonSY3RwgoF20fAFXZnE5xg/ZVM1zHodCunqJNXEKoSHCfPZlK5rg16FlJ+naSaNoU3KpMjZ2ZmRpAaTpJgU3n77Hf79f///xqYs+/vy3qE1xAKo6XTGZDLBuQV7e/vs7e1xebVEa1hv1nS2oyhynj+/YLlcM5kspNJT5jxpMm6wIMcgFSyH1iZMfHlvmmXUVUlfyUnQuSd6V7EpiBtCX++pq5JPH37CzZs3effttzk+fs7Z2Rknx8dUZcnB4SHT6bTPQbSNpaxLaqWYZDloEcDStPKcfGwxBxMNidIkCjzSmsErBELzQKhc0B7wLQfTnLrp2DQds/kCtGO9XCLVh1mP9xZFQRXgmslkwWq5BA9JmvPs5EWgvMWJLad69vw5X/rSu0wmE+q6omkbZtOY4GzJs5zNRjo3TYqCum5YraXBxHq9Zr3eSJMN7SnXkkeRmgiHKJFYtId54sm0J7cVi8MZiQLbduCQ6E7H52lFTiLQanWg86HCaLaOZ2cbXlxccnV+yev3X8O5hl//5jf5+JNPeX7yglVrsaPw3wGHR0d869vf5tvf/rZEtCGRuF6XVGVIuANVWfPeu19isViwu7NHmia0TSNqiuVa6JtdF+i8Q7Qt1ygO17YHH0kEY+M/KBuCJzOSu1KBGeeV73NhwhVP+pZ4xhgm+Rxj0hAJQ5ZJFzdrHU3p8c6MPPaxeQ/RUyo9Z1OTCn9dIXNWKTQmfESidJMkqAilBsJARASko5oeDHk4l9EGoyKTZ6jBMUazv79P23Zs1isu21a49SYTiKdzNNkUD3SrEp8rjm5MWF6VHCY1/8NqRbo/5+tvvMYHTUV2/IDPO74Xz/0W8HeDAUmA/8h7/8tKqf8R+E+VUv8G8Anwl8L7/wFCg/wOQoX869/tBB7R2vaBZ1tuVvz67/4ax8tnWN+gcKHEd9BscNFjUIGJgBj4UKgaWCEBa1eKNFngXYKTOL/XbtZKMZkUtK00n02zlNm0wDkbDKsS456loepPkZjQDxGh0P30T/84jx894eHDT5hMC2azGbPZjKPDA27euMHdu3fZ2dmRKtRE8L35fC4qkyEMjBh511Yc3Tgkywqc04ANBt1iknFIK4e6Zu3FczC9J5/nOVchaRebXTgnozP2vLQeQmgQTRvnHcfPn7G8uuTu3btMp1NOT0+pq5pnz54xnU45OjoKcFKKaROapmRdV9RpQmUSUu9JnSVRjkQTNiovSXEv0sfW2QDHDRuVNCaQAhXlHcp0ZLkCt6FuLbO8oHWeqqr7aKpqpIx8MV/04mHTYoq1jmfHx0GGQuZPnHlPnj0nyXO0ETw/DVhu1KhJU8NqvaJtG+YzoRy2bcNsMkV5R1XVWOsoEhmzLDVMtAPbMcsNRnusrShShVIW7SzaCcUwbqyxOtcGJoby8ZnoAStXBuc8m7rm9z/4iCfPTsiKnN/61gecn5+L7AOQxMKYQCn0wP7uLovFgm984xv9uIhGj6aqG4osI01T9vb2uH//PmmasV5v+PTThxR5zptvvYEPa1CN5lkcRxE+cyiNQIfBSRhyL6OInMHoKiUGL0tTjFZ0tkNhtjxhHWA21YmdcDoUeyHnct5RljpmJcPcjbh7vFbAR+Mrzp/AQANUlESFRT8YamPE2VPt0PvWGyeNdrTu62bivTo82hjSRHrOxpmuiN68wJnn52fhdyPCgkqFBj81/+SjE95641329g110fBH7v8g771xlzxzPJ3MeUjGbxhHO895/WrzSnsaj+9q3L33HwE/9IrXT4Gfe8XrHvi3vtv3XvtUmJCasi35x3/wT3hy9gCLBeX6CR+bIsih4kaMV6L9QEjieHyoovPSbcmkpOzQ1ZbEaAht7WLCMcsylJJO9VmWMZstUGgm06kkg/pGEx485EUuXZqalvms4Pbbd/jmP/s9/tQ//zO8/vrrHB4dsrOzy2w2I8vSIEkQdBCU2/K+pWSaPjFkTMJstgAMFxeXKA+J8X0ji7hYvtcjMnykAcBAy+rHTwsdLlVGeOUuyAoEz186IXmePX3CYr7gtXv3WK5WXFxdsF6tqKuK3d09dnf3SLOUJJ2LyFpTUtYV07wg1ym5BpQjC6XCygu/wHmC8p7vI4momGed7RcHoatNkmiKRGMRQ2lS0cxu2wqjFDshudc0NZM8RwFVVfLixQkhqBsyFV5xdbUiyzKqssRZyIqEtpOmGIvFol94Wslm6DtHiidVDu1aMuVIU0XWNWTKMc+VxCLa45QJgnVaEmveY724Jjr1vXHwwcdX1hI9FqOCrrkHMDTeUFYdpyvLjbtvUSxu8OL8jB1rcOS487NAzwul9148QWU0b739Nh9++KGMYnBokiRhZzFjb2+fe3fvcuvmTWazWWDCyAaQpVnY6Da0QZYhGvIYRUcIwgfJ6ji5e7JChNz6RKrbMvqJSXpddO8cXsU2h/0MJk0LjJGcWixck+Sm752RYEb6fLXqE5n060bOD3hHkqThAxG6GWCUeJ1GG1HurBta35GEhG/XSuMPjeQKTEj8dk6oqlmQKXHe9jk670V2OLY/9E72kZi07TnzxU02asHixi26ScKt4pDXDuY4NEfnxzyol2xMhree3f3bn7v2vxAVqnJ4XGf5zfd/i0fnn0AqegthnoYQVfQyUKrXiHAMHFIV2plZAKMxYafXPofOUDcV08kkYHoyCfM8YzabYW0mMEaakaaS8IyhuyxOT9AO4Nvf/g5Gd9x7401ef/0eWWr4Y3/sJ0cex3BF0XDH12MCM2bYIWLfXbg38WaLScGkqajWLftHntZaLl4keNe7n595jL15pURbw3Yt1ofy6DBOveEMhkf6WfhQNu/6NaOQRPby6pK6Krl95w77B3s8e/aMqmo4PztjU27Y3z9gPl+gtCHLJ5hEuNrOQ5dltGlK6y2FV4DtG3dkqcjnWhdF1YKQGvRKmzDoyvhQ4DU1gY9NzSRNcN7T1EvSriM3GmMcVdthsDShV+eQdJC7X6/W1FdLvHMUaUqupQVbkWgy7VG2JsNisCRtRaI1i3lBmmigRadIC0crfOg4rtEjd06Es3oYwiOQAhEWk7mow7y11oFJsSqlcZ51I0noxjZsyprOayazOcVszuEtIah1nWW1XnJxfiZU1tNTLi8vaZuW119/gyoUhf0Lv/ALPHnyhLZtuX37Dnv7h4J1hznYdV1I9Pt+HkkOJ0Z1kYUyNqpiqEVyWQoF45yOFd9DI3Xfe8owdNAKf+wlt8fnV0oojH3if9QHNm4Q44Il+a4xNBQN+9B5avwZh92KQvpPhfMlRiQEYrcsjMFNJrRWBNISY5gWE9mculaKBwOLRxtFkkamke3zNKKZlIqTOOLCK53wR/65H0c5y6zISbVBO4/XhjSb8ZY658xuKF1FbT3vqIxf+xw78IUw7t57Nl3Nb7//z/jw0/dxuhWcHQLWKHNGpZEbI7PAKvBaDE+0d14RsDAFSkLUid0NFn9oUWW0JEsmkylpKslBhQuhGn3S0ns/GLkwab75zd/mT/zJn+T+/fugRLp1vKy3cb6YIRpC8P57r70zsmo8DpQXHHjd8uK5Z7bIMUlHWw8Vlip+/7XJPXhN4dSYANWESRtC4gjREBLTPsgJ94vBS75AvH35vqpu+OThQ3b39njttde5vLwKUE3D8fMXLJcbDvYPKCYFPrGQ5rR1Q1U3lHVLkWU0JqFQCmtrjLXQhWyLB+ctSvk+yd6H9VFJs2sHHFepoIKpUdqhFUxSDWkGXu4nyRTTrOBf+/N/ht/4zd/in73/Ha6WS6aTKXt7O7zzxmssjCKfSRGUUdKY2Sca5aSR+V5mcFkUx4JEA96GpJ+n9a4fS7ETgatNUCiN1N2gh6LQCF1aktmtg84ZGpXQakVdO6qulC5VPopZiWFUcdZoYYR458hSw9HhIXdu3+LLX/4KTVNzfn7B2bNnzPb2+Ojhx7z33pdQSvPOO+9SFGIs29ayXq1oQv/YvtrS+9ArdM39+/fYU3skSQ60JElHF5umIF626tecQ/sB6xcP2/fFePEzcY46p8jSDKUTwPSORozixmso/nq9b6h870Aw8MFYqDCf8cNcH3/f4Fg5tnCgrUMJ5p9K68I0zfDhXrquk9aXaRaavQvfPksyJpMpe7u7WOt6Ib9YnCnUx4I0LaTfxLX7MFpJtGsCyVsplErxFt776ClvX5yxzmVjnH98+RnXHcbqc//6/8fjd7/zO7z/+HfodCswiFeRoRiSSnGn9cHPia8p8aj1gK0pJx4heIwv0LYI7cWy3huQhZaQZYUUSwUDpwNVyXaWsQEWOyPX0HYdJjBoulBtx5axHtQiI9Z4HRv/LGglsgi8czjfobWnrjvaOmNvL+X8tKZt+iWO0tIQYeztjL9ffmoZs96jkTsa7k8LXukJHZ4gJjWjYZdhlpDaoLm8vKKuG27evMm9e/c5PhYDv1quKTcVe3t77O3toLUhyTKU0ZKw7FqaDsrEYFRKrgwTHUSrXEMgDuPRffWkGPvkleMWQ/Q4P6KRdUH62DmB8t57/TY/8Oaf5c9drTm/OGd3d5f5fCZhtQYvNZOh+5Fs6MpoYfw42Ti8D82pnTxjrYP8gwr6RErmnfMi66vDxt51wpMWfZyMloTSSt5n0zaUraVsbJA9iN6sJI+61o7YUYS9XJMlsem67TnnKniBJkn56mbNL/zmb/CHr7/Br/zYj0u0a6XCN7ZJ7NoRvXA0b+q65lvf+hbr9Zq8yLl1+zaKBKVc6CpUBwlbcE5yRcqF8Q8rQIqMkhCJDV748AzjxmAwSS7QlAtm12zP4Vcd440IusEWEJywkRMlX3Nt/W39+qrzhARukpKmOZ2zZEmG09KGr7Vd6D1LqBqWyuHdnV0ODw5YLpeUZTlaYwH80ZqimA7zNGhXKaUojCFToFyLtxp0gvCzFEnXMv3mB0w+fMRGOVJlyNxnbUpyfCGMe1mX/MHD36VWFkwMm3SEzHAKUXcMYa8LnhAekaWN8IyLSmtSuKE95OwChs5aJrnpe49qo0kSjTFKPGWIbu6I5jUc0YP3AdefTaVNXqRoXZ8eQ9g4/C49V1WvXRFfH7waiRiePH7K8+enrFcb3njtnvC21xXeZzirtyZ9bBayfd7t3/3o6gKzmOAibXnHcQo2TZC9DbrTSml8qEo0WjpM4Z00HHnyhMlkxv3799hsNjx7/py2bTg7O2G9umB3d5fFXHIPsUtV13W0TUPZtpQmpUzTYGQTTKJJvcUoRaIIWixdALliTgXR6AnSqk6Nb0cNG224d3lNPLSj/SlHBzN5VRmsjx6rPCvbuT4qkjZ9sgCT0IxFm2FeeqQTVhuaPGilcdb2iTqvBTfXMfnrPHVpqTpRD227LgjdGYzJmOcTijzHGMPDhx9RFBOZyybCBuEOt0TrdKAQCmYtNQ2OH/vGb/H2pw/Rbct/85WvclXXbNZrYRaFmgupkh0gkzjnnz0Tctvh0SHPnz/nq1/5wT7a06EZSJyzOjBGBmdiMOS99ouKzZzjOjN99BU3Zxu0UvRoE7j+86V53Z9zDMOMHZgh6h6w0eE6v9sRHYYkSTCtGHCvNYlJmBQTPJ5JXpCnGcVkSjGZijjfyYnInwyX1D+/qAnjAwwlVEtFnhnyROGquhfO6+9Ra9qyRp0vya2nxVIAGfrVFx6OL4RxX9drWlcDDqcEkkA5PJpEJyjncJ0TD8qGRFSaDDevwHhpuIED7UB7i1YpGtE0j5lvaXQhCdUsT4UGiZVd3wcaU0xyMGBzA2wuXpJwb9twymEjGE+6cTcYlDADvJcEnbWWtm2oqg3rzYam7rh9+y6rVckHH3zM2ekVFxeX3LxxRJIKPWu9sgGSGltzuabPPPrNY7i+EPj2hi+gPDgP1ktXHOfEoCkEikA5lJYIKZbLR6xytVrx4MFH3L9/j7ffeYuPP35A21S0dcfJ8YbL84T5Yo/ZfFcUL3VCMU1JnWyiTddQ1pXQWJUUaGVpRp4kaAOpEyqc8ZLzkHFVGJQ0cpPdBuXkWp0W5897RwLheQfdjwB5gWgaxSYN/XMOWGk0PjIvQlgdFqYN4mPeaToFnddicLWcp7aK1grA1jpP1dXUXYsL2Ks2KcV0yqyYSKVzJpteXddUTU252fDixYkIbRUzlNJ9srNnczhH51xfoe0ICejwoH/jy1+hXC75xuERj46PtzZ9FfjBkhNwbDsEnsurC+7evU/TVGFuKMGbEYeorGp0J4nVceERYazjIV6+5AQkxyLFbSrILihlgvMQvf6wOdjt+TxE29uGf5Df1v2zG+6ixyCvO+3XlsdoXK4lg+PftNaSXNaiHZ9nuSSWFcxnM24c3SDLRFJ5vV5fy3nF6w1jE9aidx7rnHSzygsSY3BdR2T8yIXI3LMKSDQNYNGiGIv8/nnHF8K4g+iXEzwD4gN2YBIx2HQOE8IrD+AsOnhuEhpbMDpg8BIGp2pOqnJKW2FCb016b0ORZWk/CWRfFVXEvJhwfn4qV7YFt4iPPykmImjViYZI3GB6Tz1EGNZKb8ZyU3J1dUlV1VRVzYMHD3j85Amr5QrnoChyDg73+bmf+5N85zsPePjwU4oi46s/+B43bhxQVXVvlMeY5asO1XsJcWTpN6rx8t6KNbzvmTSRIaNDTiJKQWileg5yHLOuk85CKEVT1zx48AmT2ZybN2/StTUXpy9oWmmysCmPMWeXzOYzdhY77OzukOks4LGJcKc7gsa2w3YdqzYGpeLBu4BR51mGNolQKxVob8Id2dALVvXyDSYaaSQ5r8J46H4upSg9JL59WEzeu8BmkVxF5yyd8uAFPmitRXmDVQqrDLaxtF2L95amEx0gNMEoSGOKfLYQpUAnToQL2Pby8pLVaklVlnTWkgZqp1aaBw8e8P7732J3Z4dbt25x5849DvYPyJIUhdQoxmcHUU7A8o3ZnH/0Iz9KN4IFt6G64ZANV9N1LZuyZLlcYm9JBJMGpVEhMIn3bUIi0TpCzibUUIyMmtaKJNEoDF0Laao5ONxhsTvh4nzDi+MNSpnAWnk1MDJMzyEJ2kcqr7iPwWMf5v72ahi+77POM/53NMxRliCeN0lSsqwgLwru3bsPHk7Pzmg7y2dFHWMYKVJFs0RRpCkKJybLi+3yymHjetUSqZGl+CIT8DBL8a2X7ryfM3BfDOOugEQmivDZpVxZdQzFS0be6LTCa+l0pLzqS9vxoL2XbupK4b1B2QWd67Bdy2xnR97mfb+Qo4ZE9GRR0g6vaaQP5ks4HeCVYTHfwTaOb3/yIVfLJUki5cF37t7C2o7f/b3f58Enn3BycsrFxWVgJ9xmNp2wmB+xM9/j9tfv0bQN682as/NTZrMp0+mEL3/5+/j+73+Psiw5OT7m00efcOPo9miiDl64HGORJI/3uk+egngIsTxcvLWh5Hs4ttkH1g6bSO+FhJJrr40oDPqgrxG9WAXea66urjg7O+P1+/d4+933OD5+DsBiZ5/ZfCewZxybck1Vbag2G/IkJctzTJaTTwqm8ykoj+vkGmMjBKzw4+vWoq2ndK148Sp4oR14K1xj2Zyk0hOGJ9kFyC1NU2EtKMlZWG+JIUzXtTgnre28Ejx36F0rHlcbZGyNMaEIL3DzE8MkhdlM9xpE0Tt1ThJs5VqUE9fBmCsl/Up393dI05SHDx/ircNrmE1nLGZzXpy84OmTp/z+7/0+X/+hr/PO229LZa1WIbk6NGIuy7Jnzezu7vZUvP5p6+HatNbUtVTZWteyXq/YbDa8ePGc3d1dDg+P0CasES8LUSmDQjRhHOKFi55O2GBNQpakZKkmn6YcHRWYpOPyYsXHH1xQ18KIStO8n4v95nANRtxaf31EvI3fXzfKW4ci2IPvjsOMDfqrooX4epIsODg4wlrL2dllL43Qa1CNDPr1cQepNtaJp8gMitjI20vaS4VWhUpLPs1ofIhMTZ7ijCd//Sbdh0/Jbt+Cp8d81vHFMO5eCkBQWjBx7wWOwYeJK8a88y5QASUMxos8qVOeNPBVnRZ3buIWpH5O09WgYscgeXgmeCNKjVtVebSGTVlS12UI1V+Nab35xn0ePT3h9//wEVVdsVgUvP/BA77+te9nOsv59re/TZYXvPPOe+TZFKUU9+7d4w//8PdpW8vlZcmv/Mo/YrPZMJtPefOtN/j+73uPFycnXF4u+fjjB3z7W9/h+PiEn/u5P87R4a3+Gv1Lfsg23rj1F6UCZBSS0ZHVEb9lNN8Fvx2wyJcTwK/wlIJhjUZuMpmSFRPyPOdgb5c0Tbh//w1WqzXrzYqz8zOqqqJtO9q2QWvxjqNuPQHjz9JEVAjTfEuFM8vS3tPrrykkpTpncUaaHEviMi5823PUY/MT2cAsXmtaH6m0KuiFOLpODHcsVFFaYTDoNHKwXcCWTShMC6qkYcyisSzLks1mw87OjkSEec56vWFTVrRNTVFkTGaiS95UlQjMNQ1VVWGU5tNHD8izCT/7sz/Ler3m2bOnLJdLbt+5xWq5ZLVa0biuH6tYJPP06VO++c1vstlsuHXrFu+9917/jGIDmaZpWC6Xfc4oFtY9ePCgl89omorbt2/1PX9jE3iBW1Q/3aTSWxK2JjEs5gW37xwwmeS0TcOLk0tOz6/obBf8EAVqG18XpzsyVz7bEMd82ECHjHPh5c981t+vkw7GR4ToXoXzK6VCe7+JbM7rdb9xD/Lf+qXv65t4hO/NkqDEGfJafVQV1pjznlQp6clsTA+btkVCnRmSSUJLy85X3oOnv/+ZY/WFMO4e+u4l3gM2cJy1JpIDvcTlw3sIu6sVUVNSg0PAVqNAUeBaaJqOyWQSNoNQQKEgy/PRQxwGX/qUilTrOKcaQRGtFFleUExyzi9PePbsKYeHu+zt71A2Jbfv3uDuvfv841/9JyFjLjSzxWLBu+++Q1GIouFP/MSPcXR0xGKxwARZgXJT8g/+y/+ax4+fAXB0dMibb7zxEib68rHdKPf6pE0zYSNY6zAJJFlCZhK6tg7NAyIlcqiM3Pbch9yBUVLoNZ3NODg4ZDKZijpjJuyN9aZiuVry7Pkz1qsVbSs4cxd40rJJyHca49FpbDLuwYpH3Fae5dUVKNPjqs45aVRSTHodEvFAk9AoWDz2YlJQTIotrRxrux5eck4qLZOwuQunXiAnay2emExXoTH2YESc93RtS9NKub5zDev1mq6VBHRnXVCAbHojpJTm+DhhMhHhtfv37/HWm69zeXFO1TQcvzjl+fNj2rbpvdDJdMrZ6QuePX/C1cWSr33tK3zf971LUaQ8evSIslyTaEOWJ6QqwSsVZC1EyOv999+nKAqm0yknJye88847TKfiZGw2m77he5Zl7O3t9TpBKMcf+SN/hLfffpu2bTk83Jf+AAH+tOH+ogF00cv2QvnMs5z794+YzBI2m5b1qQWraRqBZxLjJclMitYek6YBZ/chwhJa6/WCopfsxSu89Vfh5WOoKv47dj8a5var18x1CCuOZ9M0XF5e9s2zrxv0OFfHn+1hJGtJE8A6ug76SwkOBn4kJ6IjW00gROUU1SShpWMxn9IqhTrYfeX4xOMLYdyB0G3JDeGIbO5yc06FHV/jEyUQTtSxUKE0G/FrdWfB5yhVYG2ND82Te+uMeGlSlTqUSIO09EoSQ0xAvhziRWaz5+Bwxp/5F3+Wrm1RWjq5eAfn5+fcuX2bn/3ZP95HBUVRsLe3x2w273/vuo5vfOOf8f7736KqS77/+9/jzp07/MzP/AyPHz/l7t07vPPO2yHkdWGCfH5oOQ5bx7/HyTYpCqztaFvpqZqExOGA5w+wlfeRtlWQ5zmTyZTpdMpiviDNMtBCC3xxesby6oqmrnu8XAxoyGOEsUzS0Jg6JNOatsbahq5pASlWUoj3Z0MdgkkHVggIPLPZbEJydKgunkwKFouZ6N3M5igUy6slTdtwenrG+fm5PGuQNodONOJfe+0+O4tdvA9NqJdL1uuVwHKuG21GLiQF4+8wTKgIhYFssp4hkS7vs7Zjubxivb7i008fsLPYYVJMmM7n3Lt3n5s3b3JxcREanG9om4b9gwN+/Md/gvNT0dZfrcRz/7Vf+zV2dnb5wa98mb29PbrOMl8sSNOEzUbgmLOzM95+520RNAst7larVZjjSR9FpP0GF69UjN/h4WGQ5vC9YTehGYUxCV2X0TRVnyD23pGEhs1PHp2hjWY6F2EsHfJo4lPpXj1KWvklw/l9ZDZtz+XxGhx77Ne96+vvi6+9Cha5DrOMz3Ud8oneep7nLJdLmqbp8xqwHUnEgq9XwTLiiIgWjneI/IHavl/nBamQpt+qp0pG2Qz9ffdpf+fbGK/o0Gzqms87vjDGXayz7ndzpULo6zWtt/hE9QZO+cHIgkwa5URoSrWGaXJIRkbZiTrgmEVgEpGMTBLTT9wxrBE58H6bCCt/DdigdY5PPvqE3/jNb+JwwXtM2N1d8MYbr6N1wt7+DhcXV5SbkmIi7deOj8/6UO7y8pL/8r/8r6lr6RL04ONH/ORP/jhf+coPcP/+fZ48eco/+kf/A+Wm5Bd+/ufRqemTup83qUU7W/rGyt8VSnusa6nqisELl0SkDtWggg2LMZ/Pd4McakqaZNJPtarYbEouLi56JcQ+QWR0v4hxjkSLhrxwtqX7u/OWtilRTvpXFmlQwsPThg3HWo9OEiZ5ThK6zFjb0XVN0GHPmE5nzOdzZvMpGsVsNmVnZ0earLctDz56wGq5ZL0KtD8lBs2F3EBZrrCdpTEln7pO1D33D0iynFs3bzCdvcnp6QsePXrEarUM90gY0xjKXWeIRGNiGQw8AbqJSUfZBJqm5sXpCbHIrphMOTi4weHBTV67/wZXV0tWqyWXVxds1muKYi768m1HkuZ8+atf48XJCQ8ePuQn791heXwMznJhL6jqhtXyCqUUeZZhjGKxM6eYZLJJh2K9eA/Q71QB83aCgStQMefk/OAUKQUoUdw0mqZ1/ebduVAZ4WuMT1ivrsKGENeZ1G9oFfuLphid9n1zw+oc4Ble7aFfx7E/iyb5qqPX1GF783jVRqKU6ttkWms5Pz/v8yzjI+YvgFGDbBlbjZWGKd5LbG0tONVLlveFl+EaUm1QiQGNJEsB5RWuFRG56evvcLr4dbrjSzKTwNHBK+8zHl8I465QoaGAwjcdzkiDXqUU+Eh1C+KPwvki9WJsnQGda2mRaj1aJTiX0XRikHZ299Da9IOu9MAO6GmKyADH1l1V9dlSmnGCPXn6lF/91f+PfEd44D/09e/n3Xff5vx8yT/6lf+eBw8+pW07jm4ccu/uXdZr6Wgfz/W1r/2QeHGTCbNZQV5kPHv2nG9/+1t84xvfJElS/rkf/VGBF0aT8LO8ltgLNmLs1wup4pFlGdPplJ35gul0ynQ+J0lyqmqFtR113bJcXgXceE3TtKMqw+G7I4YLnq5rw7UFTw0C3XMTSvCFxpgGDLHt6iAnIWqcJs2wmTCa2q6jaVuSJCXPM6bTCbPZXDR/tGZSTGjahrPTF5ydnVCWstl474X/7mWjN0kCWo1C5aAbrlQfJZydnXJ+fkY+Kbh58xaz+ZS33nqL/f19Xrx4wfHxMZeXl8Fz70f82qzYFsOKeRAVostY43T9mThnuWqvWC6XPHnyKXt7uxweHHLz1iG3bt+k6zrWyyUvTl6wWq+YTCYcHB7yzttvU5ZrlssVi8UODx98Qlm37O7usVwuqeua4+Njsjwly1IODg4krzia6wKDDJCbH92WYrhWMaZuFJ3EpKIkrH1IevfNSBR9/+D4urRMDPUpvc6MRmvpNhYjiOt49bWVtzXX/cgw9snY8If4dF6Frcv5t5Ox4w1DKdU37EjTlKqqKMvyJagFCHmgbAs6lO8L88CDUR6Ux/q213733geiyDAXjDFBnnbstMbnIVByV0x48kM/SPXpKW9PJ3SHO58zXl8Q4+69xyuFcWN3h0HKN9EhLQjKuZ4xohQYNK6xYbfXpHpGqkMPTRSxAa73ovKmQ2OHVz34GIK96vXhcFhnuXPvDl/9wS9zfn6BNvDmG6/zU3/0xzg5OeW/+Ye/wtXVkr29PXZ2dtjf32cymXL37g7T6bTHjIX3Kotf60FQ6c033+L27bvs7u5zeHCI84FjHbjp1+GX8TjKhqjwmB6Xnk0NOwvNfDZlMpkwnRYkiaGtO5ZXVxw/O6FqKspyRRU00n2onHNuPJkT8rzoi5vi0bbt8By9H31mEI0SKW/BuG3YVGWzFqaF1gkmL8jylN2dPfb39snS+BwtVVVxcvyMrpUNsm7qviMO4Z6dAkxCEhqa+x5DcUG7W2Nt2xutUBuI955yveGTjz/m6ZPn7B8ccuPGDd555x3ee+9LnJ2e8+mnn3Dy4piy3IzmRkyshmfj5bV4Sc4riMZsZBj759UznyR5eXxccXJyTJIkzCaS05gWM9544w2ctWw2wqM+vzinmAjX2naWd7/0JVCKR48f8+HH38GYhDQzKOW4c+cOSknhHgF+Gy5hzCIRgyubd7c9t7yi1yAK96C1ITEGsjASTgQEvBoKq2KRUlxTglPLHM2yHK1N6N60GY2NJ9FaNo+wEeuQtAxZoJ4BM0ShUgfSA6y9nR/fmzwXaYw9cOPHnrsKuYudnR2qquLq6qr3xsffF731Iadjt8bFWQ/WkmhhQdW1aM5os43NR0ioT6ryio0pPDvlPTWeky+9zsnNm2zO7/HedCiGfNXxhTDuALpzKOuxRlgLygv8oR2oTsq/lVZ4o7GogGtKEKy0RpsE5zUZC7RNaNuKPBfvYZxkwXvSNO2NVzyUkrZn44cZj21DD9Y7ZtMpv/QX/xwxOeC95/z0gtPTFT/8w38kyAUPEzxGHzBMfOeE/aMIFbmBt1EUEyaTOUmSDg/ci2mXi9i+rjgRkiQJScCE2WzWtynzXrosXV6cc3Z2Rl2XNHWNxvRdbsqmxPsO58I+GZKJeZ71EzmyTJqAWxuTjApJ4j3AAB0ptA7eWgjvI7aYZRmLxYL5YkGeFxT5hMViF+ss5xdnbKoNy+UFF+fnVHVDVdV0TUmRB2ih3+Q9eVYIDVALpiuc+WHBRcErWdiD+BQjoyvjKWypzePHPH/+nMePH3F0eIO8mPDlL3+ZunmHx+Fvq9VV2ChGDyTc+/h3H68B/4p5dd0Aye9N09A1HcvliizJ2dnZ4fDwkKOjI+7duxeKnUqOX5xw8vx536z59u1bfPWrX+XBg0+oqoobNw65e/fu8P1Deml0zsETlkB5eMMYxhjf1hZNMExIrZU0uEjSHjMeJ+XTNO2ZOVFfpee4hzFwTrpXdW3Tz7OoUBk9+0iIUAHj1lpj1OD5ay3sputGUvK+44K+7WeR5zm7u7tbEMyrqtSjvHRcv5Fxt/1sHca4kLNQpKms//GGGTeEWKEb7z+Oq7C7fKjBkLGdpQk/dfcWH8/XnNza4+3sf74G2f/THQowYDWAx1g/hFdh0qhgHBJE99ojGuQqkUnkrCe1Oc5ltFbC9L39feQbQw5eSym3eJ3Dbg6gAkTQNpIYFe930BcfQmrFxfkV//hXfxvvxRt597332FnsgrPsLRa4PvHmR58TISOloj67LKZBPCgm4uKD9iGkbUlTA0oP1xkmcYwCxokfSaJJcdDl1QVNXVM3LZv1inKzEkMXWBxGK7pOC849meBcR9e50CA4xbqWzlbUjcVZ31f6iqG3GDMsYI/GevmJjtipWASlRBZ1Mpkwnc1YLBbcunWTxWJG11kuLy9Zr1Y8fnjB2fkZy80ylPEHrrr3ZEaR5Fm/SY8XU9s2UpegJLTtmT8EIU/vtgzpdsQTq5yD8XMe78TAPn++5vnxE6aTGRcXt7l58yaHhwfMZwvW6zUXl2dcXFxQ11FDRLz3yOYb8jluwBH6+Sa4ve6ji2hqgyY5ssk2bcuL0xecnZ/z8OFD9velc9Lu/g43Dg/Zme8IJbJpuLi45Gtf+yF+4Ae+jLM2QAYji74FT8SFFzc/3Zv62A/Ah0jLeYVD1qE8bo0xOcZ0A8cbcb6SJEdrac4u5xGDHqM951q0TvvOZuPnITUDhjTLUL0r4/suSN5LjUGUHnYWuqbF2nrLe47fFemsSWJ6oUBh3HqU9r3jlWUZ89kMZy2XFxd0bYcadVIaM2aiM3PdIOMdzrZoJ8lnvOt7Rsj7bA8Pj5k7YzjqOkyktApeu+ohtYnJ+P5dA0qR6Ovw4PbxhTDuCkLIYgLXWMJstMeHxijOxfIbRZpmZCYnSzJmxYRZPiM3c54fX1GXCa5t5CFYGyCA0MRAKYxJg3GPSceo724CxtYOmBnX8TqZ3V1n+b3fex/vPbu7u7z77vehlEbFKj4/wEawjZHLcxyLiUUZ1W0ccQgBpYqvKAr29/dFmc7DZrNBVC0noRn38hruN2xcbVv33mv0sAf8VcJKG5KxxhiquqbrSpxrQLUkJkNheLXnOXqISLTlO5hNC3YWi8BmEfpiZCI1TcPjx485Pz+lDRWsMVpzzg0d5VXQ/fEhNFXbAmH99QQNc+8ctoubzeA/S+g7hNRjT2v4Ho8LzoUY5SAm7RWr1ZLvfGfJw4efcHBwxM0bdzg6OuLoxiFVVXJ+fsbx8TGbzToYmTi2wSnwfmsujOd9REuuU3x1kEwYok5HXVc8fy5FYelT4f3PF7vs7u5x794eaZry7NkzuZb1mrZpg0Mh3+tG4yYbpxlRRgdfVjaWgXYsEbQP1eMysmKIk+F6e2O8DRX29xqcj3Gf0c8+Bs8bVN/DQeyE6WEe3DAH4ryPkZn34ow4a2mC9x8jBwBldHAyboH3fBKinZhL0kaHXq0SZUwmk16oDQYoMhpolEL7TnoUdLHSO2EY1e15d91jj8dWXm1YpYiooTQ0wYtu1ndrW/2FMO4gplZpByY2vYVEpxRpRp4ULIoZs3zKfDJnls+ZJlPyUNqtMJxflhw/q9BK+hBKoo8+3hTfBLIsJ6pKDgOvyLOc/f1DXrx4MTIaw/WNoZ0bN27wi7/4iwB9/8nhfQAJQ5OP4Mr1eDjRPQonEG9CmmInTCazwKmdiTFP0t5jbruW1WrdF8hEGtbnsQdkwluUisY9+kQjT9NJWVPkaDsnz0DqxFRv/ABsZyEJmHLQB8kyKcaRzScVuCW0FDw/P+Xp0yecnj5nsynpupa6biRqUUMBRwzxxwnqOKA+KDsOhikmnmRRRZXi4V4G4z7AJnpYREqMV8zpBHsV2tv1YEI/PeLlNE3N8+fPOD09YzabcevWTW7dus3e7ju8+eY7NE3Ngwcf8+z4OHDJ5Uqss33jZR2K78Twh6pXPCiRzFB9kjOG6K6/V1nikr9o65amrlherXhx8oLFYofdvV0ODw/Z29sTLHu9ZrlcSr1FVeJcdFxk/jsXYZLoXY6MhYr3LQWGzsX5KtcXm9vE5+fCcxvLA8T5B2OKoVS4xnzF8J303zV87jOOHloZ5vvYgTKJdEHKirx/lh6Ps9JDIE1Tbt26hdaa1WrF6ekpTdv03nrnbGhq7pjP533SdOxcRDiz61rarsI1FdpZbNuhg45VFyTHYzs+DzjvQgJZ1s9wD9sVsdvORwgqw2ZmjNmCnj7r+J6Mu1JqD/g/AV9FZuy/DnwL+E+AN4EHwF/y3p8rudK/jbTa2wB/zXv/jc8/gWZeLJjmM6b5jP18j8VkwTSbUCQFWZLJhPADzhqNgXLgveL4+TFVVdM0YvCKQvS5GVeOhUTOde9Cvk+Hnpjrl3DQ8fvid+3v7295AuENMulGSnlbZ4oTMmhVTKcziqnAFHt7e1KpGBQZ27Zls9lQVQ1t0/aJG4GKXp78r0oQDycVZkbMM/hoXUbFT9Gzj5PL6OF9biTklKQ68MrnTKcz8nzCwcGB9DZVitPTE05OTnhun3FxfkFZrkSAahSKysIeNtf4LF00zH7wGsfezfWFv3WnYbyjqJe8Fv8Y5RjCd4akXL+ZEOQUwuY7dAvaPm+MtLqu5erqgqurC548ecLt23c4PDhgZ3eXH/zBr3H/8pLLy0uePn3MxcU5uKEwavDQfV8E5HzUunFYF/y1XldDfvbhvYeEoZTYe2ibhtPTU87Oz3jy5AkHBwfcvHmT+WLB7Tt3UEqxXq959OgRp6endMGjj/clHmXIY4WoNfTEYWhqPWj/j6OQIYqSQqaYaB9HROMnJdhzhDboN5qt5/pStDx6zOEZ9UYT9dJ7xv1dez8KSNKU/f19FosFeZ7z7NkzVqtVaI5ttoxqrPGI3PWYixtvXoKFO1TXoZ3oISklPVmVt1KxawxNLWwzZRJMkuCCfEU8jxoV641hmqGnMcRiO4FF1db7Puv4Xj33vw38svf+l5RSGTAF/vfAf+u9/1tKqb8J/E3g3wV+EXgv/PfjwL8Xfn7msTvZ5ee/+ovSeURpjAtNOXwoGbeuL3V3TjRANFoaKiso64oXl8Lv7doWfJiwiCcXq18TY0gTI6F+9JjCYa1luVzSdi2xV6sfYWt9AnQLEogTH3oPZAujl/Pmec5kOmV3Z4fFQjyBnZ0dkiShrErOz8959uwJV1dXbDaVtHXTBP2PgjTJ6BNJPY47HNFb7RfeyPONC8+Orl25OIGHxTVAREMpNAryvCDPJ+ztHXBwcCjFRYlBKWGwbDYlH374AZtyEyKKCms7sqwIrOVIVRtgimG8Qgm6d8M99Z57yOyGOYAPBofBcMR+qAovcF5wgEdOdzikznkMtUl3JBcql4VqKhFALLPxoAZq47iEnFEuZrm8ZLm85EGacnBwxN27d9nbO+Dtt97irbfe5OLinE8efMJJ8ObjphaNq/OiPOlDHkmFPc8FzCt2lYzCn957rAqDAUGXXD7knKcsSx49esTjx4/RWveOw8HBAffv3efo8JCu7Tg5OWG5WtO1InYmayCyZIZ6D+Gexzk9OC0gzBCBKjpQkKSJSGiPmmdIrkn+bYyhyF1E+gODKsBf/ZQdPHnYjkT7daeGd/oIa44hCj+8Px6TyYTXX3+d2WzG8+fPePLk0UgTRrSs4jOOUGL0zuU9IfIbNZR3XQfOiqIjaWjDp8hCorgX40uSkI9I0aPNz/W5BPpoYGywVdxlveprWFS/RvVIOuXVx3c17kqpXeBngL8WLqoBGqXUnwd+NrztPwD+EWLc/zzwH3oZ2X+qlNpTSt3x3j/9rHMYbZgkBToWTATMU2mFCgCst6KTFnXbY4s2NDx/cUYr9hrbWSaTCVu4s2TVpNO4Vn0DgX4AGRI+Ap+MPY/4Fds8V/n7trcrk13kgGezGXmek+fCdhhjdWVV8/TZB6xWS8py3bMBxhl4QuM1FXiyUbhqHLpBgBfiJFIqNDjZjkyGhQr0W5rQHJWWAff4UMQ0YzKZsZjvhOIXYbV4r2iahtMXL7haXrLZiMCU98PYiAfuQyd7+rGMqpSo7XC9D0HD/bvxolSy+CP+LBvb4Fn1/46/h71Wq+0CN++jUFxYkG6Ax7x3AsUEAy/PPejxxS8cnWs8H4YwXf7etg3Pnz/l5OQ5s9kuN2/e4MbNWxSTCV967/u5c+seT58+5uz8jDoUkymtRVKDYcPwxGEKO1k0Wi46CzoYWzW6x1AcNLrviDGfnUnS99OHnzKfz9gNvX1ff/11us5R1RWr5ZLlUvI2UUtHZorCIwlqgeDGXrbMoSiPLcY+CZDLwFAKM3DY1AOEEznffTSlw+r2KnzHqw37+LWBTjjOW403FHriwY0bN2jblg8++ICrqyugG3oV+BihwHQ67RlC2x2kwsZqHa6VhkIaL31vw8YV50IX1yIaj0MHbaTrhjtJNINo3/D64JXLmug6kTN13knr0K5Dmc9nysD35rm/BZwA/2el1A8BvwX8b4FbI4P9DIjqVveAT0effxRe+0zjHh/XeBFFvE8pKdX1WuNw4ukoes/7arnhybMTaRm23qCNppgUsGUoZdHneT4YGj+cOCYmYzYbXg4Nr78u/F0J3RaLRfh8QhGEs9I0FUbFxQUfffRRX0EZjfywOQyhmCRZhEefBGXDOHmjHZPQcESbGl1T8P368YxGN246MpEdLnixSZ6zWIio1cHBPmlqSNMCaz2bdUlVbXj27BmffPIJ63UZSthdSIzKec2IVSDPUjwNiSZcnxSKofI4jHfO43umwGhCeNnAvREvTTTXPUmShU5ZQ5u37WckoyBz6fosG+vmBA46YiKJkYESOYsttz940loHbXe2Dc02Piqbx3J5zmp9yZOnj7l16xZ7u4fg4c7dOxwcHlDXFWdnZ5ydn9PZuvcGo0mV+hbBVa0jeO8Rhw+sq+uX6Gzv9atgNwWKA0nmtZyfVZyfnZKlGXu7u7z2xuu8/to9jDGsVmuWVyuqqub07AXL5RVt6EbmrCSbJSntB6DFg1JJYE2J9+t9cDjUeHMN0Yn3dJ0Nm7ViSyTMjr33bUP+KphGXVvf4zkUP5vneQ/BnJ2dsVqtApQqd2CDYfYe8jxlOh3YMN77nmIq6zP2NRBNJNuJ2qwmrl1z7Tolh6OUDv0BtqOR6HDFHMhQXR43EWmWbm1kBoJGhYS02SqC+qzjezHuCfAjwL/jvf91pdTfRiCY8YB79d1St9cOpdTfAP4GwOH+vjwouDY5hwRYiFUlK68Ao6maho8+fcS6btlUDZtNycHBQQ+pxIcc9ZizLBOP3/uteSVeo6NcV6E/5BDujI25CZl6rTWvvfZaSFDJNRpjODmRxsRS1VbRhUYQ13G6+DMqDEYsTfiwBKMY2RKjRFfYkwZ4Y3g9GiFGRidev7ViMIpiQpKmTKbTwKWfUOQFs9mMuioDLHTC1dWKs9NzqnoTFrTqw9Y0TfBehzG6NpndAH2omKzUWmCu0doVby8an+28RDQcsvaDFwY0XUvbeYpi0jd0fpWB/6wjPqetpCGggz59NPWCcoSAP+6oyocOTHp73EfXMR7zmLyuqzUPP3nAs+w58/mC/f19kU6YzZnPF9y6fYcXpy84Pz2nqaswHpZYMGStgA6J8gFCG42P3zZsPVQRok4VIK9YGdxvXs7TNjWnL044PzsRAbijIw4Pj7h95xY7iwUeOD095eMHn3B6eoaHPu+iwuL0QZbBmLTf9GKthhj+bcMzxrLjc97eRYfPRFjn857ny07YEFFELvpisaBpGo6Pj19RvxJzH1K4JM7ZdmQZO4fJOFvRkQqbqO+EGSOVuoP3PW7grYJOjJRUvLxhSa1IGhy2l+exbEQabQwmkSp+rVNZa/FmP+f4Xoz7I+CR9/7Xw+//d8S4P49wi1LqDhCFhR8Dr40+fz+8tnV47/8O8HcA3nz9Ne+9tCxThB3Sv7xjRxweFK3zfPToCRebmq7zbNab3vBGDQiZiLIwp9NJWLMBa/fbdCvvfG/Ak4Bx53keRL4G7e6maajritPTE9brJev1utdZid2erPXbDbZR/YalontFTI6IVygbgBGYxA/h7/Ad8UrlHqLH3pvG0UYFAmWkWdZXxeVZzu7OAqWgs5JgXS2vePH8mKoqaZo6wFUaaz1N2wVtkCFEFDzVI9zlbfU977uwt4hHZnTQQLddaC4zFPLIdwbPbRSpeUbFPg5pvIIn6oc7FzsZ+QFzDjTJeO89RMQ2PBPHs4dlCKqGXjZTH+dG75IS/AnF0LkorqchGvFB5CxuuMP401tjaTsoMgfz+ZzDg0MODw9YzGbcPLpJUzc8/PRT1usVF5fnI42S4ABfg9WccwFOi2tiOO94nhjNAGsGOEQRHQsZu/V6yWpzxacPPybLpxwdHbG7u89sNufundvs7OyIYFu5pqpK2lbkgH1wxsZww7anvb3xDx739u/Xj2HDGr5jrPM0jpS2D5knN24ccffuHeq65unTpz1FeHs9EdZzwnQ62+pFO8xp1/+01uJtE1o+ipOZBr2iMYtG5tfgVEpU60J/BHqjH+EdaZDSjJKpejQ28n1JOjQOFzq4DKJW/xNg7t77Z0qpT5VS3+e9/xbwc8AfhP/+KvC3ws+/Fz7y94F/Wyn1HyOJ1MvPw9v784SKLB1wyK1dKawq0VhR1J3lOw8/5dnZBWXbsVwtUVqxWCy2DI4oz2lmswlpljAkegSqiEJKu7u77Ozs0LYtk4m0PivLkrIsWa/WdLYVSdeggudcR1WVbDarLY/EJApthPpmQnMRefCeJAkhmhaufew9OVSmhvfDdwm3hrHp4ayQ2BKMvyAxaS/jKptRjbOW58+PWa+vKMsNdVWhIGhqR+9VERlJWTYuz37ZkxpHI7HVmRgOHRLYMUyXcm/xIGXSxgSi6duOhVBfjbneEQslRF/CGe69IAw2RD0Oj7lm4COlsN/7+ksPG6cPEAyyATjnUCaq+sVhDpuFGkY7GgZPhJpUoAkOf5NhiVbM9bUbzsPy8oLV1SXPnz3h6OiIW7duMylmvPn6G2R5yvnlOc+fP+f58+dB48gH7DZCcKPnELxDMSiqn28v54UIYxdaU8YGJioK8Wmcd1Tlhk8/fcijR49J05TZbMHBwQHzxYK9fA+l9nutlaquaeoaO2KMDZ5v3JSvzdsw/upz5vewUXkCQZptVterDXuaGnZ2Djg8PGS5vOLp0yejBtV6a1yUEtbcbDbbisQiDCMGW5wQ5xx0FdoPDa2NCs28R5DkuE9Acg1jj9j9ED0S7FP09mODbyfQMJ7OdiHClUhOOVFOtT5e1+cbdvje2TL/DvB/DUyZj4C/jqyS/1Qp9W8AnwB/Kbz3HyA0yO8gVMi//j2eoz+89+PVODwU71lXFd/65BOOL65Ylw3rskZ7xeHBQd+Qd9C2gNl81pfiZ1nW89LFAOY9Dn58fCxqh20L3veG3I8m6RhbjQnYmAw1xkjC1ugeUom7+lCd5wOOHu9se+LKMRQbjb2N4RCPoygK0tDlZzYXKeE8z7Gdpaobmrbh8upS1BzLNVW5oalLCf2Dv59o4dsqHT3oMBHVtb312oKKi0/GW4yE85bYzT7awuglXodCol/de6dKKgmtHzyTMT4+LIzoIan+2YS398/dI83Px1Wp2/h4r1I0ug65JmftS0MeP2+0DnNBrs1FjRIPXg3e27inqPLjSGEUkuMpq5JPH33Ko8ePWCz2uHP7Nq+9/jr379/jzp07nJ2e8cnDh5y8OBHOfB9xyiIfxmQMTw0GRIWNMlIcQY08RHpbK3+Pm93AAmuahs3mmPPzM3b39phMphzduNFXyMZI9TLQPqPYXjSiqk9Ihw3k2pz6bkcfQTH8HJ7ddmKyKAp2dubgNQ8fPqSqNiOvdvuBai39aKOwWY9vw0i7XuN9R9e2uLYMPH/5Lh3mKkTxt/F4+x49AAKDy6K9OC4qVE/rmDAP99brNAUMvm1bmcPOBQdEnl/npa4k8t2lj8FnH9+TcffefxP40Vf86ede8V4P/Fvfy/deP3qvy8cqz2BAkAh+vSl5/8MPOb66YrWuWa3WJFnG7v6hyLr2CUTdc9Fv3ZYJOZ1OqesapRR1XVNuKp4/Pxav1rlgnPor4XpYGe6tn/zRUx6zV7RRwTOXj485vxAr1l5+INvhrHx4YOIMQkVZlpHnBbPpjCzLSRJDlme0rfCcT0+l4nMsxwsEDZQxe0HuUTzQES8cj7BFVIA9tjnNXRcZBgqUJOvEo44RgHjlsZI4Vgn7wCEfwl0XlBmHccU5qe4LxS3OyTj2njRj5UEFBI84whFKAj4deMneqaA/47ae3+CRqdDVK7ByvBqc+pGHF6Mbae0bFr7zGB1E65wfedORohlYEMTrDsZJhUR2iBCiiNXF5QuWq3OePn/MvXv3uXHjNmmac//ea9y8cYu6qTk/OxemTVWH4qNBQE+m/VhKY0xMiPTF7TqBaDvHsKGPQn39hufwvqOpS2zXUpYb8mLC3v4+RS6ibm+++WZflxELgiSijZGBzLVtY/1qh2H7tZCnUR7owhhH4y7yBIvFgps3b1JVG1brFavVKjhbQ+Q3PiLFUeCQbkv8DgZj7Z0F3+FtjW27PvqR4iGNG0XP8ehCV6Weq640ylmOn3xKVTXcef0NVBKfhe0dP3l+sVBNpFWUUsT+ZD5k1CMy5b3AYgpN912c9y9GhWrYPftwLXjuSknoa1GcnV/w0YNHXG4q1qua1XKN0Ybd+U5flqtQPZ67v78fGCApq9WKszPRUo+CQM4OHtV1XHbbCG4fvQFT9F54H8qFogqjr+Gf/a7xsie+FS4iNLDEJOSFUJ2k673pDXxTN0FX/VLK9nGirXKNqrl9jmFY5R8Bjx4tdrkOjScJf4+eYFgsIy9aEnMETDwaiwGacCHZJ/vTwJAZh+PO+b6J9bWrJfLLXUguKiX65E3Ee7fgBnmCcpGDBz+MLcN/RLxZ8gfRkMliGjoLbW22MbLp93u51xhdeobIoT9P8FLFWVF01gaKpkMbJdolevDmozjW+bnQFrPsO+zvH3Lnzh12dnZYqBm3b91ms9nw9OlTTk6OWa9WjD3YeL9jzFcwXgILbHBOdOhqhhptBET6XoQYwowM/XidB6yjrmuePXsmDJHguUuSeMbe3l7PEmvqhqoW2W3nhwhj2NK3HajxXB0we0+Em8aRbGIM+/sHvPHGG3g85x8LkWGY+y9767HpTDyiMFnvrBDWn3dYV5MgSEHnhN0T5Qj6aum4IfpBiG5QipR1025Knn36iPNT2ZTf/crX+qJKWQND7QmE3sUqJmFHkGfc2CLS5z1Gf77XDl8U484QejsX+KOA0p7OGx4/f8Gjp8dsyoZ1uWGzqUnSlL29vVBBFqRXtahDzhczsjxhtZamB4Px2g5bxbMY5IJFs3pY2GMPbmwIY4hrzMAOAVAYBilRRkYm3iOMJ3SkP2ZZJiqJ8x20Fg0WpWC5XAq7oWtp246qqmjaenjg8q280kZuHTGUjSFzmDgE1U2t8UqHTjAaZxHZUlnqgcplgtFS/T1KNl8WX+yl2nUOa2uyxICOkYu4GM4xooxt95XcmvCDSy8GKGwERZ6HexYPLnrE/fIfbSADg0Hw5JhMDJmBgHcObB2lhI3Q668EIbFYlBONNYzEG3SoFI3elJLITCkplBNqJLJphmIUnMJ5K2qm4eoVwiiS+7fU9YZnz0qOjx9zcHDA7dt32VkckKYZr79xn1u3b3B1ueLk5ISrqwskN9CNDLo8467z/fyINMroEet+LoT6ilAoGJPMSimSROBL57U0yPHjzd3ROhc6SF30Gix5Ngm5nwmTyUy0g5qatq2pqgrbbUfEMqTbVOOBiTXAlhJxeWazGfv7N8nzgidPHvHi9EXfNhDGsFDYCJKE+XzeNwnvG8xcS4TiRZWWpiJBRMCcE0glSxK0ESzcJ+IECPlgQBfiWm9baW5ttCafzPna176GthVPjq+wLiIS2yJnArU4vJem7Gp0L72ODhId2NgjePT5zzq+MMZdBVBuzHhYr2sePj3m7GLJpmxYrtZY11FMCubz+TUoRlrnzefzvp/k2IsdG+vxaxECGbyFYCr84NFvwyZyjHHkwZuMWOPwevQeY/Y8TqrYMOPGjRs91ucdnJ2d07ZQlmtWa+lB6kK1bbwWNViz3sh/3oO+nkyKRn7AXX1I+g0MlH7hXbs/54caBDHwoQCJTgrEukBxNNsKeHFTjA2tCR5kP+JxUSIGVrDq0BAi8LpdLPQJHrLkCoIT6pSEr6+KXBgViAX2T9fGMbS9xy9zcPt5j7+uh9eiToi8OJpH8vyDbw/IvHQ+cP7V8Np1GGJ7bkUpWTg+Pub09Iw8m3FwcMDB4X6A6FLefPNNqnLDer3i7OyUq+UVPnDbx3BL/M6t+eNfdlpiDaEHtDIB26fvW+3w0k9BvaxkCLBarVj5FTpAlrPplCzP2Vks0GaXpmmoypqyLHs49NVR8mguhw23KDLu3r3NwcEhlxdrnjx+wnqz6iPnVz13aQ85GRVajUW6wn0HaM+3Na6tUaGXgTYKk2TgJPJxQlqXymYi1VSjE90PmjQlkfaBs+kuuc6prxzlcsP9e69ROh8at/g+PyjNyOWeI9subtDOuR7uuR6V/S/Gcx+8JlAOrFc8enHCp4+fsikbVqtS8Elk556HBCJEKpYizRIWi8VWs43rCya+Pj58HzI6hga921h5xH23mxgESGfkzWx58cErKIqCw8NDDg8Pe+9hs9mwWq1YLBZorXn69CmbzYa6rmnbiljchFJ4FzxquRIGD3wwwi+VLG/dnw+CYONquy2cQsZdmb7oJd5Tn4dwYLE463p2zZAojLCMcOk72xJFkuL1jIfcOScVqVph0aIBHqNup4jF6UqNDFJICzhs0LeOYzBIS4TANijyDYlXpUyofA3MHDTGZHKdPWapCQzO8Owtkf6Ic6NEY7ynqAUQ0KBeK8UJH713FCQy9G7AWLXepi6GYAk/Fja7Nk+dc9TVmmdPS05fPGdnd5fDgxukiSFJDW+98zY3bt3i8uKSJ48fs16vQmesOOcHyEZgA02UWRh7uT7Mh9Rk6MDPljkeJAq8wVrTG6bxnBvmlkTfZdlS15vQf7RgZ2ePIp8wKaYsFgvquu4pll3X9p204vOIFlPrhDu3bnF4eECWJxwfn/D8WUgyR60JttdqlF3IsqyHvMTwDpGNiLa1eAdda1GuQuGkzgUneZPQeMR4ccyclSrx3qFMBN5K0xQUaG8DJNPSrEt0ljObHDHNZpDMSFzDanOG9YNGvWzirp8X42sdPHuB7pRWJOrVapKvOr4Qxt1HN1FrlldXfPjoCceXF6zLktXVCuc80+mMvd293kCOQ6ssz9nZmW/xSLe++9rP3ouLLswW5q623hf/PV6Qw/sjE0BjjCZNC4piwuHhoTRUqKpeJXE6nbLZbHjx4kVo29bx5MmTICA0xqNjSBqxtohDAjHhGXb6IbP/cjXfq6OW0SahotfrBJKxETqJOKffjl7C/22Fsgy/x0Sq1gmKofgqSueKqFQaqHumvwwfGoD3ybfgkUdJVKVUUALwtLbFe0JIrETjRg/XHhfteAPui0OUwyMGyrlIy+zvQu7Te5wVVcHt8RoO78edpoZZ04s8ESMeGcOu21Y/HKCRgaUTnOwtnHV7jsulOGdpGsfJ8TGnL86Yzxfs7e/hvMdo6ZL12uuvs7OYc3l5ycOHD1it1ltOh3MerVw/ja97vULpTVAhB4EKnP5YKeujIzRc60AquD5WjqapqeuK5fKCNM2YTBZi5EPh0HRakBeypi8uLrm4uKBtGxSaNE24efMON2/epG1b/vAP32ezKfEu5nW2YT2Jjk2v5BjvS7xjGcuBRSPK+diOVEej7QWqDNLXcQys6wjyOf15xk5kG+mgoeAvSxSuPKeyKSYrUGpO2wnV0igNRjYD51ygXw6b2djWxLGN1y8Q2bDmXxIuvHZ8IYw7wKbpePzshCfPTrhar7harSirDeApwm4/ph7GAZ5OpxSTgqgdcv24btTh+o4XC4aGhfkqAymL0GyfezJjNp+xu7uLd15axIVuLk3TcHl5Gbr2rPjggw/ouibwU2USjKvShlA0njv+Pi7vH8Mr4m33f/NePFcfKhNDIjQmY2NyTdZrhA3iPeswrgkEfQ9JUg4NxLWXxaB6b8mJxx+wWHmTGkkTgA+hpg6RQNc1/fVGWqjo/SQMND/hrUsRmCSXYlk/oZl3mhr64pIAC0Wsary5yz3HsDewJ/QwF2TjsRiVEAWsJAIZb/Dj8fdc54mOjUv/bHRgPEUtIONRJnjNvgv7ZohOiBLXQ5eiaIS2Nwy1dR3OdSyXFyyXFzx/9pj9/SOOjm5Q5DmHh4e89trrvPP2uzx7/pQHDz7k7OxMDFt4jhJ5+R6ykhFSJFqjlcX5kCMxCQ4rNQihchqiDrxhLNkh4z9OZse5HMv5S5qm45KL0Ih9jveeYpIzmUwpiimHB4ecn19QVTXT6RTv4cOPviNyCH07R1kn1yPCNOThYpJ0HK3HNSCSywrXWXxTAy3OtkR5hF7+uOvCpi3P0ilF5xzOdhRpJtGYSXooUIm1DnNWgzG0WCorlaybtmZ9ecKkADObIM14YiMTFZ6pRH8xEowbf4zcfStzom26rbnxWccXwrg3reV33v+A1aqkrCrOLy9o2hZjNIudBZNi2t+wNAnQFMWE2WwWdtjtyjB42XMd/3wZ7xw808Frpbe3CkWSJr23sbOzw97eHrPposfzNpsNXdfw8OHDlyiJg7crC3O8yYy9te2HNdDHhD++vUFdP/oioZA86z0+RK87VpuK4xLuv/8quTYZgwC72A7BLeL1WZyzQcogCdHKtkyqdw76xa6wLkYDo0IXNfJOQ7Ga0cKAEOG3cbMO028EsvmEoqXARpANcsD2Bw/yZUw7RhdxHgiUtD0/VLj3aAx6g60iMwLixIjPc6C0DRWgbhQ9GGOEZtlDWeFaAle586KbkyaDpsn15+ydv1Z4FOeFPLu2tTx//pwXL05ZLBZYa5lN5yG5p3jnnXd47bXX+obfbVVvrYk+sPAy1+VmR5W/xKTygAUnSUxYD97mq9bXONr1cY6g2Gw2lOUGpRRVVTKZ5GRZzs0bt3u4Uimp7q2rauTNDuccn8cY07N1xs80So+MNZ0UYG1NEp6pQ2STI97tnMCPYTnI9fthA4mbRIRKCI6CDhCkwpPlOa6R93TO0dmWYpqRUtHZjqrtJOIKXPX++/pIPMTvzr80nyNMM+4j8arjC2Hc66bh+MU5682arpPByIqC/d3drax2ZJfM5zOms4lMOtxWh5l4vIytby/066+J9ysGEKVJ0qEPqe0se/t7TCdTrJOOP0+fPMe6x0iHnJr1ekPXbfddfBWso1Qy+n2sMx4ZO4Nn7v0YQ4+89+v8XdcbDJQZEJdrm9dwjjgBFRFW8r4Lib82YOqCmSsvFDDhsouujGhd6ODh+L6YJxpwbwcjF3cPETqyEfBCAUlcCF4ihc7a/nlqbQJUE8fO0rUd2vCSJEJcCKLxYfo+qeNS8kGmdmTY+zBGNsOhh5wY+HHbNuu2S9OHXTHkCIInLpCHChWMLhBgoncsrB0GmFiCnfBc5H4V46Knfi6MEozj6Gt4pnK0bcfpac3FxQWz2Yw7d+6wt7eH94r5fIfZbIcbN25zdXnJixcvWK0vifo+3imUCbkHoikO46cNREqkE+jN+6R/NnGctjakkfEdq6dG2GxYrzooUspzfPHilMlkxny26J2Hg4MjwFNVNZtyQ1VtXoIk5vO5NLQJjW2uJ4sHFpGi6xqado31LtCihZqa59KLFTNw3nvue3imRsvmIfMj4PBaipu6rqOzltxkmCQl1RrnFFYpUpOCmlCkmqumpu0sJujSRPZLhJJkk3dBNGzQcR+zZPretp9zfCGMe9d1nF9e4JwjyzKODoRBokaLNE0FUxQ8LSXSp6K2RjyuG3V58dqv1wx9kiRMiinz+QLnXOiENMUYQ9d11HXNaikdb9q2pW1baXfFNgz0qmQmbFdaDt6feGRRSGfclUjeu+1RRsMzTmQO5wlQSritAYKJ303/nbFCMXqASkUa3qh7p/JoZTCJJPvyPA/VcIHq2HXYRlqYeR0ppuE7dIIOCVGp0t2Omkz0dEcbn0L1VZfeOVz/wHzw1h3axEhnXPgxwGmSONtOsA0GxJEkg5fTb7oEauQro6IQfYRE/hge6eePj2+LUZmE0H1ry/HmEqgowzn84CVqFTpN6a1r7t87uqwINwzRmeqhyji/Ym+C9XpNnuccHR1x48aNHsacz+fcuHmTk5PnXFxcsFotJcoMUYoM68DsGuA7tfX79fHYjlKHMR026RixbjcvH69Hkf2oOD8/k0rsPBcJ6sWcNM0oihzrJCFblmXPJplMJv13jBkm8RqG5hgimZuoIMzmInwmmHh0IOW9Q6RStx0mSaR6NDhAURqZELV1nXRhatuWy7Ljk+fH3L55l2mWYzR4EpSqcc6SF0WvvzR2COP5hSnTEvNccXzHVfjf7fhCGPd4c4vFoodagL6HoTaKnR2R1Q0F4yG8G+CY8fFyeCheao9ia02WpezsitztbDYjy6RlX1VV0s5uueT84hJrO5pauiO5a+eRc7x83lfd3yvhFDXc+2cxXrwfiiR6rYvR+8QgDMYlfmbAiAnIytjTjdn32KGKkRGSJt5JQv96VW3C9fmwiSgUDpOmiAG0aB2SijoJ9i4scuXxthVDpwAd2w3EvpvBe0aHhizRe9bCIvGjrk3eYgLDxnvZiFSQYtURMXcBfumhHR+8ILkGoxLxULsO30cxAyVvoOfFQjWR3Y1jOsZunROKY+cie96hVQLehOTboBmyffj+uuImLNS2BGubEHolvSOgvcKra44E24n07XkjUaBzjnKz4eHDj3n69DH7+4fcuHGjr9Lc2T1gNtulrmsur664uDylaSqEq++l/iHMI0mWb7eai3Pt+sb3srMV1p+KDsgg87y9ZLbncds2WNux3qw5v5DWhtIUPglrOOsdsDG+Pu5vOvZ2JcFb0VUbklDh3HUWoxXamN6WxM0hzgfnHGkiqq3jVTyI1IEyWrRmFGw6S7VpePDoIf/kN3+Xg71d9vf3SE3OP/f9RxK94yDQTcfXPd6wnXck2pCYSLkUuIwIEb7a3PTHF8K4K625ceNGv2OO8dPpdMpiZ76lGx530/h7f3h6w9J/d/DMjU6l2i/QsJJUHlYsgLi4uOhxwBj2SQg6Nrrb170dog/n2/77y/8eX/B16Oaz3jvesF5179EQvIQ192wR9VJ4Kp9zYozU2GuMXO1hIY+79IARvBCBlpJk1GBZqcE770Py8Dfv6WJnm77xg8xU75xUvKqBqhYrgCPPXY3GV/X/N7rX0WvOu2u2wgcPy+K9ISLuA8Qx5oLHLxpW0PVxHTsVhggphU1t5Hxc33S3vd9Aww0SBs51DD1Oh+seGnSMGDYMVMbrBlXmrAtJdTlX27a8ePGC09NTptMpd+7cYf/gCG+k/dzR0RFHR0dcXl6w3qxZrZZbOaHrhn38c3x8luGPcODoSV0b6+1jHA3E9X5x0XB1ddm3v4sVpxGyjfBFxK8jTzzyx52zdK2QCcZ0Q22SProYIqNtgkaaJIGoMEQnRg8bgusjvFBIOdf83I++w3e+/YCnF0v2pgs25RUXzRydJLjRJhSvP/47niPPMkJqCecQ+AihXir4rt77F8K4xwcSB9cYabq8WCwoCmHCePxLAz5MaNWHvHqET00mUyaTosfgsjxjs15T1TXtstlqoDFMRAmJeyPnRQxrHO6Pj23oZHjtlZ76K47xgt/GdXlpIV0/98uJK176+/jfQ/f2oZWc9xodqlPH51MqyNz6SPeM51fBqwOvfOCdK1TvrYaNJiAkCvoOS85FZgB4pQaT6CyDls12mC9esgmbhxvgnDhemqE5s5JKS+ddz4rxbpump3BoLXx06XkZrllF2CDMASXdjaxTKC2Swz0WHvVqru3BAi/5EP3EKCd4vkr31a7iNIg3C7aHxaTQaeA8y/mMjI2P47hNa92eA0Dv0UfF0VFOJlz3anXFBx9cURSP2N3b5cbRDUk6Os/R0Q122l3qquLq6pKyKnt8O86nsVH5rKj0OvR53dG5Dt1cf//174k/rbWhA5gUAs1mM3Z2drbWSPxbH135Ad5ViLNnY4W0p2eXGa2xfnvTjEnUmJSN39n/Z2WeoCHL05Dsl/nv6g2v3dzlzfu32V1MOa0bqjhmI3s3OGyqh4oi/m6MRqsE6yxdZ0kzg/VO5DLs57vuXwjjHo+ozzCfz5lOp4OnwPYDHk8yUWOUXqN7e3tUVdXv1rHy8/LyCue7Hj9/FZQzPoa/9aDqZ77/s3D2z/v+V53vVZ/7rAUynsjXQ+KxZz/+jrjT9xM93N9Ivmt0PwP+KwUWjLBzMdBebXtXNiwohWCqMZkY+frRaI6jA6UDJBWesdDPh8KsYVEG7zp08Imt8KLmiwr/i9i4UtK1yzs1uqd4l66PJgTfiRvFiKcdNqWYCNTKBK96KF1nNP792HtwI/x7TKMUqq6YcJG7uF5hGCisDFGY9/G5juGLeJ3X4B6vQbsYP+A92A7RRFER5oo8b3lPVZXUzysuzs+Zz+fcun2X+XyOtZY8L7h1e0LXtazXazabzUudxK6P7fj16397lYF/1b+vv/+7Gfpx9ekr8yLh/fK+Tnok2w4/Uo303verQHlQI8q1c66nNkcPW+xOgE6stM70yuNCBBhb7p2dX5KgKdKc9WZF4xXeBIVYP0QAY3p3vO6u6/BOcljGd3RuSMCOC7E+7/hCGHcFvXTAfD6/loAcvHOBAAxJkjKdTMiLnK5rSdOUtumo6hLnHG3XsN40dG07ku6FsQEbZAKiMRtTueL5Vfjv1d7Jqybvqyd9dGXHxvPVnv126D4KWCMlSr886ePngFca9j6M1xrtPWBCEmkMVch9CzwwGEAxrHpIt/pQnIQYMu+C7AAenQqP2lZesHEV1fyicRqrBIZYMz4VNdAN41jGPIO3HVoJv10aFqR43xEVHT1i20ChdIom9JvVyEYQjKtcQdBRsQHvBpT3KAYIKBbJ9AMQ3QstnP0Idyi1TWeNHvbw0CJTJ8FagV1MX44b/44IzXl5Soo4N8NC9xaUibtNHz3pIE7XJ9iV7yOnSBv2IeESjUG8zi5ELCpAWNa2nJ+fcbVaMpvOODw8YjqbolRKYlKODm/Q7rS0XRf6rYZG8qP5ev34LKN83Yi96vXPilCvfw7ouyVFr3osBAYDrBM3JWmm02KdE5VWG6K/PmoUZ4E4Z70OzVj81sYWX3PeYfFkaRaeqMc6h+taTi6u0CQcJimbaoXaPUQHYoLRqvfek6Bk6lyYT0bYakmW4p2naWtMlpJmKc5239U5jccXwrhro/tsPgyTIcrqRhbNuGPKbDYHRegi1IioVuCVv1TMpMCPF6GcBTG4IwmnPlQMH7tGobuOOY6Pz4NHZHMYSsGjxMGrJuvY++g/4Me/v3zOl883fn3gZI/xXh8gmehIevyoY0zUjJb4UuyJCaF+sF6R84xFmkt7TJ5gQ+LZ9Bhm9BY1AyPIEatYRWZhuNWXPVXCNTqIXqgPEEbcmAGPgcA11iZBG/HwpW5nKHjxsbMSCqVENM57j5SyD97tcC0D1j1ALPQb0ZYCpYuGYaD9RZPtY+5AJcQmIFtzxvs+8hief9ztIje7C0U1kdIad5IohBZorH6IbLcjPiESxCTkMNZyX8611M2Gx08eSRObnT2mU2n0Ls3jYXd3j6KYSNOOqqSuS77bPHxpTsfxuhZ9ftZG8VnR8Pi98bnFLmwxkRqTrTECBNkQDKETku16qoXrYgN1D8FDVii8HnRfeugn1GkYY6QhdsgJ6jjeOmXv7lt0naKzS7rViuniAO9jolcFCxQpsEO7Te+9kOgi2cJoUqPFCRmhFv+LwNyTJO0z+DGEWiykC4z3kvwoioKLiwtOTk7w3nN1ddVzzoPb87nHOBqQI+CZRNre9sQbf+7zJtXneRUR1nnFfO2v5VXY4zb27cMaj5l589L7X1oUW2wRiKqXymvwEsV47wVf7COJoYnAsOAJ3okNyUwvBTko8JLpV9GIExQFldAdtdaonvExSD0oJUqL4vUGOCWeq9dej89kgHC0jno1MdnLyEv2ogGDkt5yEVdBYyJnOYyfMBJjJKOIFVNxsUZ1y3GCeejHG3VsbP9dMdrRSoUNIkIvMLCYBiO3Pf/Cu0cbCCpCYcInN7FC0g1jCINH2q/vfvPy/XVIlCM7kcgKZEJMUNLRTDab8F0yQwJ+rADHxeUFq9WKYlIwKSYUkwJjNHmekecZi505eCEjrNarrdqA6xHkZ0Em119/+W/D+G0fqh+H8TGu7I3XMSRUBSLUKm58GpsYtDGo4PzZoAPU9aQFR9sJth5hEY+wa3yYV2N8fwwRtZ0w7YpZwcrkTEyKx4tEd6h21yZWvfuwEQ0NP5z3aGMoQjI3zrM4Jz/TsITjC2HcsyzjjTfekLZ26zWzmSjgtW3LkydP+i4vg5Lc+KGO3b7hO19tbF/2zl91fNZn5XOvZgi86nOD53+dvvjqc46PWKE39haHkuSXr2/bSwphfh+nA2jxvnUnXrcChSgiXk9GxU4vMfQXT5T/b3vnGmtJVtXx39pV59w73dN2T88roxAZwoQE/QCERIjGEFFeIRATQoaQCIjB+Eh8fNCZkJj4DdQYMTE84iNgkIcISiYaoogfHQVUHIGWQZ4TmOmZ6b797nOqavlhrbX3rnPv7QfpmXPvTa3O7VOnqk7Vfq691n+vB7WGEwYd2SywitjYNo3FwViaqWCYNPovqnaEOpFykUTBmF0dt0Q8ScIYugmsO4JIFcDDLHlUyxxQtWVh0IBdLMxq8cQsfZHHV3hqii0Kw2CaRvKJ6bfYZqe6aWbguFLKUpctpO3SDkoJluXrE4JgG8mWtGQ7vhrQkMZComWzN0Iz23Nsr0LC5M8bJbx7G4f6GhFfpCQHaBuGngsXzluijguWmu7w4cPu+7DBxQuXueWW4xw+bKEEts6csjwDOwkdMQJ2EJhKfXZi/iUejF0qbGsUVgAyBh8wSiyKObJin1gultD3qHYs3cqlESzufgpvbuvboTNcv9eBZdeTkj13NmvRZCMnMt6tCn3HbzuOoFy+eInmyB30qaFNlnwItSic/dBVGDq5Drav42aPQt62MhzeTC77q2TruCpzF5HnAh+tTj0b+B3gg37+WcA3gDeo6imxGr4bS7V3AXiLqn7hSu8YhoHHH7e4zG3bsrW1xRNPPMFisRhFM9yOaWugoVh7bVcDV6Xq+p5VyKX+7Q7tsO3c6iDcznAhmHFOP7fyzN1wxhGWm5lF5BXdvriMniGVT6MfDH0HmNRuGGVH25Bt50MKNMYwNrWUJDkJtEne43jS4oNuJGU7ozHYpXf782hvc46qtZbcjVL3idsal9MUq6kIPxDWTKbBdd3C4tFQQusOA+iQykKnxjhjc7W0Z3G4QW2D02KHmIbRZ7v0SJU4lOxFsYb6pA21YhjCooiqXtFfAA19ZwmvswYpPptl8E3aeoz7s0aqi1uT5UbyZ+vgVkk9s2Y2kmgtMFvZtO773pl6kxf8aI8o9+XLl1ksFpw5c4abb745u/u3betYdk87u42u67h44SIXL11kuSzxhEodtptSrmqwY8w+cPQQdMaLY53xbNVfJJi9bb46Jt/MaFKT0xcikseVDqY5DeqLkGA5etuW1heJspHbkXNC+ACu7eNTGugWHUkSbQ05V4tsqjREQdwZqmc2CyMBs+oakF0Xxd3oWhJknwCe743VAI8AnwTuAz6jqu8Ukfv8+28DrwLu8b8fA97jn7tS13U5k8puhQ+1pypXHI06ezeKwVQ30G5McnVwXY3hb1soXBXOkIVYXtWwTR4hKLuUBcZmZqVZyrvq+Cf1cR0tD5c2B1V6XRiU5dDK0Pc0qSWytIejUgQ3KxPcHIUiFvp2WCpgC4dSsFSJXW8MtzZVLPWO2vh3QNxu2OAY8yCMnwyjsRFagmtBnkJQXdrvOttL0eTS+aCoR6KU1hYvRS2dGoAkVyBM+k2NeKwef0/sV2DhD/q+Y+iL1Yxh/ck1nHJ/OAMxgKEd2wWIYejoemWjmWOB3wZ67UjSIG7yRqXRqMLQJ/DFQJEcgArH3G1/wze9hw5EaJrNLBEWCxPNcYcstIS1ReC+AXGszsm+7zl9+jRbW1tsbGxw7OgxZrONLJAcPnQz89kGz3nOPZw5e5pHH32U8+fPj0yOrwTNlDEScyrqtR3iHGVw8+/FhNbqcunSpWITnxI0LUkH2mZwr2aYz2YZARoUVAYuLS7nvYl5xRPKPktkSKuc2rSMlaHrUO0ZtGd2U1MinSaDxvpuuSLkQPIQIl3X2cJZbRDHs4dhyGEWrkTXC8u8DPiaqn5TRF4HvNTPfwD4F4y5vw74oFrP/KuIHBORu1T1u7s/tmRhskYbuzCvSuw7DYxti4IylmDZfRDln+wwsOrfrd67ncmFaaGYGV6KSenvqyCQ1WfW6mNd5zpQ1Gp5dmqvnZ4ZEoyqSziuujdimaNq6KOWvON3UDbnysBO5Vnuvp37iGJ5ENEcAyeSNOQkEBGLJZxDGAoMVawehHDFNqcmtzKoNsjMky+ZRVGKtrHNVFtwYmPRNn8tumUwYlzSDY9ak8RSg2kbQ+iGEYs9Ftw6xs8YWirChi94KWCfYqUVjCDqW4/GqJ+FYnCIQD0oQ9asoo1tE7BIrOHx3BDRPUPbqsdIsdAoYySk4LivjtGyOg/j8+IFCxcwm805dOgmjh+/heXS/Ecee+wxbr31OD/6I3dy7tw5HnnkEbbOnM7RKVc5df3skZClcc7bx/tUh4HlsqPr+sqCSUaMtmysLklpjkFNtjkdHudD14EzXjOd6UmUsL5hcRfPXWXyq+ejD21cKxa7abtWUseHKTCshMUv/RDhsk2bSlIsn64W7heun7nfC3zYj++sGPb3gDv9+IeAb1e/+Y6f252566q6OmbmYxWtxGW2ib6b/WyqgCqorTKCroXJ78aM477RdS0wSqzexZunSF+r9SnMV7cNkp3Ksqp+1s+pJ2q9CNThhSVUvMHsu2P3PspRBm+EPB2X2TaVitmfJGFYLkkaXoKCaEvbzlkuIwKhB9ZCSA0ugXhfE7bzg5tqQixm6mNjcHV5Y8MgGNu09MUoypYXGM2/jyQkWQjAFqRg6HbGsU23yR8Gl64aNxMdxKyCKgsXzb8P6whPigz4rmyl0RRmb0ynL2NEEinFPpLDVV6qpm3QHnOMUqXvQ4KlLEhEZMqUoaqa+aTGmMW4X8vYCSaxOudqqoWi8fgsEnXfLzl7dsGlS+eZzzeYzzdp2xnnz19gsVjSti133HEHR44cYWtri3PnzpllS7Je2Wl+lfkpDnsFRhTvblhcXnL4sGatYDabjWCa0CgXi0uOpbek1NAtPPyxb1xeXiyZzeckcQco18CsX4p/Q71grLZfjf2boYAZiwxDzyw1HqXTTCWlmtezpmU5dHlnTpJBhr6u0XnguiQGj+6GJKzSNTN3EZkDrwXuX72mqip1frlre97bgbeDxZTZHjPlyh0eUuZOkryIZAeW6pdlYubv9plfo1ngX3ln2ezaXrbye/ENFvtvGJWzlHG7lG3qfQXpKCMpGbZrCqt45XY4KcpVJOemaf1KA9pbvBK1wdbkgSlYsK6oryUG9lp4mjzAg12ZBY5a0gw1J5q2nSGaWC5Dqon47JrbXcSlFW8uY/JCmFsWaCmB9DQDhoUOQmpCOvUsUtkSiszgQ1MadFmeY8qySbXLwVOm4ROmh1hs1KQu+9ca7CNloVnVdHSQrI04OIRQOyEFYy/1L9oRuS51SGKzPBFSDrkc8F6EUraNZInFoFpIbOy4w0sTkT3TtvECxU48mGh9zyocEOcLg/e+TIkwmTWv747z5y+yXHTcfvtt+bebm5uoamb0Z8+e5czZM1y6dMHLUObDCL4Jqyn1eiTTqACHGWE2m7sWM2SHo2DCs9mMixfPuxBj7da0M9AB+h76nsvdksEThzeOtUc5wtJmVZMN2Kcs+AbbhfmlELFp1OI4NZZcppESKiFiyOBaeuYSsRCL2GLgWuagZrlj+PyNc2J6FfAFVX3Uvz8acIuI3AU85ucfAZ5Z/e4Zfm5Eqvp+4P0Ad955p2vHV7Zz3SY5eOcnj71h9+1sVRBu9NukbcjMNJjyuAhhF60wWr/EJccC/RSzxZ1x+520hCJdm5RZ4Jviql9THaJgVVJffaZIkSgAmmaOqlm2NG1yu3Z/RtNUq5qSmuROFYnGg3qllNBUTDTt00z1ln3YBatlm1EzebTEF7FoJA8XMJilfywo2tN3Ae1E+Rss1LCZ6InOgIW/syWlsE9PLPuB+axF8n4B2aJAnYHXWpSqGjzUuZ0xtsFKKqZ0aEQMdGlYpVpEAiJwZyJJOQaI5nFibWTjzvcEMvMSwgKkmEEObtYoNGqxRxigV0uiIinczX0u+HMbIcMLKYUmkJjNCoQlqSWslGK81PGJshChoY2JL9jbx24IHfF98NAJxcKqJMo4e26Lc+fPkFLi6A8c44477syhQTY3Nzly5AjHLhzj5MmTZjd/8eLIx0AqBhsLomnESgm9CZcuLpjPZ0jSjEfXi9ls1nLu3JLlsmU220CHRC9zmtTZ2B4UaVoUD6XrfCQ83a0MMUcdMlnB9pMbHJQNfhi0J7nE3XULVBKXFpeZzeZZIw6NKqeL1BK4LIsJHq6gGCpQaam70/Uw9zdSIBmATwFvBt7pn39Xnf9VEfkItpG6pVfE241WrV4KBFGY1HYJHcczpWS9kcRqWNydIB4JETt04Oq5TVMNKPFMOWIT2YaWr9Ru56oOR1BpE7UqHnVYZfj+Rl+1V+EWkwi1gh2sHia94ZuO4nWoM9tnVTYkMS1Y5GrI0HE72We5Rh5Uksaqp0gct46hejiIZPb0CUvXZtJqn8vGCKYIZm6exwOxeFl9Sj+0rkl0ua8Hr2dqBhhl4aosh1xzGQZj4eMNKB8H3k7DMDgO3Xtc+5jUdVTK8TiB2NCLfQuNriuWK1lrizFdhJQoQ/bE1QIB1BBKSP8+vFwb6gmmmsd9XnBSHseQvA+F8fi3z9p0UKM9aqFlB4W8zE9/jqp73tZzrQhTfd/z5JOnOH16i0OHDnH06FGOHTvGoUOHOHz4MJubmzz55JNZ6t7a2nIP2NKnTWN6TBZ+tGg6i8WC2WyW937m89kob3CM1ZyesWkss1TXk8TGaTNUZoVChi6jr4IZ26Zo4UfFazUsZ0xTMC3chkzbWhTItmmyQAVjG/1aYKvnaSyY+EIXG7x1W+9G18TcReQw8DPAL1an3wl8TETeBnwTeIOf/3vMDPJhzBTyrdfyDsKphMASSwVqBl9LDYot4LbCA7h0s812elQX+0yFq4eNsG1kVDGsg9k1PpgHzyuZy5bcLjgk/2KHHgx1CDvpDBkM4zp4/8bkiwFr9RWHa6Iu5LJJSI2QVdQoV83UA04QktkzD+bNGBYW0ab53aZDVczBaDV8avbyTGXjN6AAGRpEGregABVBPJ65qhocJMKgQusR+dDehbHARcUlxxa0M1V6aJ3xDxY3JbejZikqsOcIfAbmtFJ7G3sLMXif2vyM5MTBqAIfj5FmJomDwwTxvHqjTNWTYXv+zbI3FH2Tcp+l1CJqsUNorG/AMNw65+cYC8dzxnbQeIAxyv6H7ZEUL+BhUJrW+js0rdV5UI7LnMuClQ++PGd8E1l83OAMjDwHTOBRNI/bWpYZhoGzZ89y7tw5Tp48mZn8cmlJbo4cOZLfHx7ncS0Em+Q+EyHcGYPtsqCXUkuEX4i/vu+YzzfsmZcvcejQEUiJZd+zXF7OfRV7O9b/ZWM2pTaXwYSAwuiLZZG1dw6ypqYV9n0H/eAagWkRfV8LSWNv5YgUGdYyNn7duWxwKE4sMcjC792Nrom5q+p54NaVc09g1jOr9yrwK9fy3JpGUImGk8mVzRzzICOkoTDzGz93p3cV+Tuk6pTV0FhQzAohBlH57WqgIvLkjWdLlqDrRSreVWOWo2fUh359J7glv6dqs1Wrh3gXhMVEmJIVq5zS7gKaaJuiNUjFKOK+8l3MvyK0p8zsvZ0UpDHbXgVYWDwXnGEM6vh8hZWHdtI0QtvO7CEJs0+Pjay+9TayCH7DYJuwQjdi3mFOGYu9TfqhmsAFkgjeXdotPESLhjM2cROHrBSD0RJJbM9iuYzNtgJTjMddSMiNZ/TxOP3tLG+aRrC7kDrHVi6hBSUkYhUly/8aEMZsNsvMPRaGWktYnQ/jZ4/9JWrYL495ZHQ9KGP2qbEcrVL5ALjApn3slSQWiwUnT57k1KlTHD16lNtvv51hGDh16hSqZWN0c3OT5XLpDox9EYpGWq5J75s3bRD7GLWGKtJw0003mWawXDJbWjyk2cYGC/Uoqb6ZrX3RSnZqJwsRPiser34tMpPleDFNC73BKn0/0GnHbHOey1T3b3wPiT0gnxBYgtFH3bPvz3BlzF2uJto/HSQiZ4ET6y7HDabbgMfXXYgbSFN99jYdtPrAwavTU1GfH1bV23e6sCfCDwAnVPVF6y7EjSQR+dxBqtNUn71NB60+cPDq9HTXJ139lokmmmiiifYbTcx9ookmmugA0l5h7u9fdwGeAjpodZrqs7fpoNUHDl6dntb67IkN1YkmmmiiiW4s7RXJfaKJJppoohtIa2fuIvJKETkhIg+LhQ7e8yQizxSRz4rIl0Tkf0Tk1/z8cRH5RxH5qn/e4udFRP7Y6/hFEXnhemuwM4lIIyL/ISIP+Pe7ReRBL/dHxeILISIb/v1hv/6stRZ8BxKLRvpxEfmKiHxZRF5yAPrnN3y8PSQiHxaRzf3URyLy5yLymIg8VJ277j4RkTf7/V8VkTevoy5VWXaq0+/7uPuiiHxSRI5V1+73Op0QkVdU5288HwynhXX8YXnuvoYlAJkD/wU8b51lusZy3wW80I+PAP8LPA/4PeA+P38f8C4/fjXwD5hLx4uBB9ddh13q9ZvAXwEP+PePAff68XuBX/LjXwbe68f3Ah9dd9l3qMsHgF/w4zlwbD/3DxZZ9evATVXfvGU/9RHwk8ALgYeqc9fVJ8Bx4P/88xY/vmWP1enlQOvH76rq9DzncRvA3c77mqeKD667s18CfLr6fj9w/7oH4fdRj7/DwjOcAO7yc3dh9vsA7wPeWN2f79srf1iAt88APwU84JPq8WqQ5r4CPg28xI9bv0/WXYeqLkedEcrK+f3cPxFK+7i3+QPAK/ZbH2GZ22pGeF19gsW4el91fnTfXqjTyrWfBT7kxyP+Fn30VPHBdcMyu8V+3zfk6u4LgAe5/hj3e4n+CPgtSrSmW4HTqhpZAeoy5/r49S1WwlOsme4GTgJ/4TDTn4rFR9q3/aOqjwB/AHwLy42wBXye/dtHQdfbJ3u+r1bo5zENBJ7mOq2bue9rEpGbgb8Bfl1Vz9TX1JbgfWGKJCKvAR5T1c+vuyw3iFpMVX6Pqr4AOI+p/Jn2U/8AOBb9Omzh+kHgMPDKtRbqBtN+65OrkYi8Awtl+qF1vH/dzP2aYr/vRRKRGcbYP6Sqn/DTj4rFtke+jxj3a6QfB14rIt8APoJBM+8GjolIhKioy5zr49ePAk88nQW+Cn0H+I6qPujfP44x+/3aPwA/DXxdVU+q6hL4BNZv+7WPgq63T/ZDXyEibwFeA7zJFy14muu0bub+78A9vuM/xzZ+PrXmMl2VRESAPwO+rKp/WF2KGPewPcb9z7kFwIu5xhj3Txep6v2q+gxVfRbWB/+sqm8CPgu83m9brU/U8/V+/56RuFT1e8C3ReS5fuplwJfYp/3j9C3gxSJyyMdf1Glf9lFF19snnwZeLiK3uDbzcj+3Z0hEXolBnK9V1QvVpU8B97ol093APcC/8VTxwXVuRPhYezVmbfI14B3rLs81lvknMPXxi8B/+t+rMUzzM8BXgX8Cjvv9AvyJ1/G/gRetuw5XqNtLKdYyz/bB9zDw18CGn9/07w/79Wevu9w71OP5wOe8j/4Ws6zY1/0D/C7wFeAh4C8xq4t900dYsp/vAktMu3rb99MnGI79sP+9dQ/W6WEMQw/e8N7q/nd4nU4Ar6rO33A+OHmoTjTRRBMdQFo3LDPRRBNNNNFTQBNzn2iiiSY6gDQx94kmmmiiA0gTc59oookmOoA0MfeJJppoogNIE3OfaKKJJjqANDH3iSaaaKIDSBNzn2iiiSY6gPT/mckgxVvYAQEAAAAASUVORK5CYII=\n", + "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" - }, - "output_type": "display_data" + } }, { + "output_type": "display_data", "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" - }, - "output_type": "display_data" + } }, { + "output_type": "display_data", "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" - }, - "output_type": "display_data" + } }, { + "output_type": "display_data", "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" - }, - "output_type": "display_data" + } }, { + "output_type": "display_data", "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" - }, - "output_type": "display_data" + } }, { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='object_id', ctx=Load()), ops=[In()], comparators=[Name(id='id_array', ctx=Load())]))])\n", "Worlds Table created successfully........\n", @@ -277,39 +294,21 @@ ] } ], - "source": [ - "volume = traffic_world.select_intersection_of_interest_or_use_default(cam_id=cam_id)\n", - "filtered_world = traffic_world.predicate(lambda obj:obj.object_type == \"car\").predicate(lambda obj:obj.location in volume, {\"volume\":volume})\n", - "filtered_world = filtered_world.interval([0,fps*4])\n", - " \n", - "### to get the trajectory and the video over the entire trajectory(amber case)\n", - "filtered_ids = filtered_world.selectkey(distinct = True).execute()\n", - "print(\"filtered_ids are\", filtered_ids)\n", - "print(len(filtered_ids))\n", - "if len(filtered_ids)>0:\n", - " id_array = [e[0] for e in filtered_ids]\n", - " ### Fetch the trajectory of these items\n", - " trajectory = traffic_world.predicate(lambda obj: obj.object_id in id_array, {\"id_array\":id_array}).get_trajectory(distinct=True).execute()\n", - " traffic_world.overlay_trajectory(cam_id, trajectory)\n", - " ### Get the videos of these items\n", - " entire_video = traffic_world.predicate(lambda obj: obj.object_id in id_array, {\"id_array\":id_array}).get_video()\n", - " entire_video.execute()" - ] + "metadata": {} }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "source": [], "outputs": [], - "source": [] + "metadata": {} } ], "metadata": { "celltoolbar": "Raw Cell Format", "kernelspec": { - "display_name": "Python 3.6.9 64-bit", - "language": "python", - "name": "python36964bite8cb19f72df446e68174e40cae298cfa" + "name": "python3", + "display_name": "Python 3.7.11 64-bit" }, "language_info": { "codemirror_mode": { @@ -321,9 +320,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.9" + "version": "3.7.11" + }, + "interpreter": { + "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" } }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/scenic_test.ipynb b/scenic_test.ipynb index ae6a7eed..74f98796 100644 --- a/scenic_test.ipynb +++ b/scenic_test.ipynb @@ -2,10 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, - "id": "ac69e379", - "metadata": {}, - "outputs": [], + "execution_count": 2, "source": [ "import os\n", "import sys\n", @@ -22,64 +19,65 @@ "import pandas as pd\n", "\n", "from scenic_generate_df import *\n" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "code", - "execution_count": 2, - "id": "c3bd0bc2", - "metadata": {}, - "outputs": [], + "execution_count": 3, "source": [ "### Let's define some attribute for constructing the world first\n", "name = 'ScenicWorld' # world name\n", "units = 'metrics' # world units\n", - "user_data_dir = os.path.join(\"v1.0-mini\")\n" - ] + "user_data_dir = os.path.join(\"v1.0-mini\")" + ], + "outputs": [], + "metadata": {} }, { "cell_type": "code", - "execution_count": null, - "id": "01c91100", - "metadata": {}, - "outputs": [], + "execution_count": 3, "source": [ "# generate dataframes from scenic json files\n", "# takes 1min to run\n", "df_sample_data, df_annotation = scenic_generate_df()" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "code", - "execution_count": 3, - "id": "8721832d", - "metadata": {}, - "outputs": [], + "execution_count": 4, "source": [ "scenic_world = ScenicWorld(name=name, units=units)" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "code", - "execution_count": 4, - "id": "b09a2632", - "metadata": {}, - "outputs": [], + "execution_count": 5, "source": [ "### Ingest the camera to the world\n", "scene_name = \"scene-0061\"\n", "scenic_world = scenic_world.scenic_camera(scene_name)" - ] + ], + "outputs": [], + "metadata": {} }, { "cell_type": "code", - "execution_count": 5, - "id": "38170a10", - "metadata": {}, + "execution_count": 6, + "source": [ + "### Call execute on the world to run the detection algorithm and save the real data to the database\n", + "recognized_scenic_world = scenic_world.recognize(scene_name, df_sample_data, df_annotation)\n", + "recognized_scenic_world.execute()" + ], "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "Worlds Table created successfully........\n", "New world inserted successfully........\n", @@ -89,19 +87,113 @@ ] } ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 5, "source": [ - "### Call execute on the world to run the detection algorithm and save the real data to the database\n", - "recognized_scenic_world = scenic_world.recognize(scene_name, df_sample_data, df_annotation)\n", - "recognized_scenic_world.execute()" - ] + "car_trajectories = scenic_world.predicate(lambda obj:obj.object_type == \"vehicle.car\").get_trajectory().execute()" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='object_type', ctx=Load()), ops=[Eq()], comparators=[Str(s='vehicle.car')]))])\n", + "Worlds Table created successfully........\n", + "New world inserted successfully........\n", + "atPeriodSet(Test_Scenic_Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}')\n", + "asMFJSON(atPeriodSet(Test_Scenic_Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}'))::json->'coordinates'\n", + "SELECT asMFJSON(atPeriodSet(Test_Scenic_Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}'))::json->'coordinates' From Test_Scenic_Item_General_Trajectory Where Test_Scenic_Item_General_Trajectory.objectType='vehicle.car';\n", + "\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/home/yongming/workspace/research/apperception/apperception/metadata_context_executor.py:107: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", + " return np.asarray(self.cursor.fetchall())\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 11, + "source": [ + "print(len(car_trajectories))\n", + "print(len(car_trajectories[0][0]))" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "14\n", + "212\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 8, + "source": [ + "bboxes = scenic_world.predicate(lambda obj:obj.object_type == \"vehicle.car\").get_geo().execute()" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='object_type', ctx=Load()), ops=[Eq()], comparators=[Str(s='vehicle.car')]))])\n", + "Module(body=[Return(value=Compare(left=Call(func=Name(id='Tmin', ctx=Load()), args=[Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load())], keywords=[]), ops=[GtE()], comparators=[Name(id='start', ctx=Load())]))])\n", + "Module(body=[Return(value=Compare(left=Call(func=Name(id='Tmax', ctx=Load()), args=[Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load())], keywords=[]), ops=[Lt()], comparators=[Name(id='end', ctx=Load())]))])\n", + "Worlds Table created successfully........\n", + "New world inserted successfully........\n", + "Xmin(Test_Scenic_General_Bbox.trajBbox)\n", + "Ymin(Test_Scenic_General_Bbox.trajBbox)\n", + "Zmin(Test_Scenic_General_Bbox.trajBbox)\n", + "Xmax(Test_Scenic_General_Bbox.trajBbox)\n", + "Ymax(Test_Scenic_General_Bbox.trajBbox)\n", + "Zmax(Test_Scenic_General_Bbox.trajBbox)\n", + "SELECT Xmin(Test_Scenic_General_Bbox.trajBbox), Ymin(Test_Scenic_General_Bbox.trajBbox), Zmin(Test_Scenic_General_Bbox.trajBbox), Xmax(Test_Scenic_General_Bbox.trajBbox), Ymax(Test_Scenic_General_Bbox.trajBbox), Zmax(Test_Scenic_General_Bbox.trajBbox) From Test_Scenic_Item_General_Trajectory INNER JOIN Test_Scenic_General_Bbox USING(itemId) Where Test_Scenic_Item_General_Trajectory.objectType='vehicle.car' AND Tmin(Test_Scenic_General_Bbox.trajBbox)>='0001-01-01 00:00:00' AND Tmax(Test_Scenic_General_Bbox.trajBbox)<'9999-12-31 23:59:59.999999';\n", + "\n" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 9, + "source": [ + "bboxes.shape" + ], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(2004, 6)" + ] + }, + "metadata": {}, + "execution_count": 9 + } + ], + "metadata": {} }, { "cell_type": "code", "execution_count": null, - "id": "7a6d62a3", - "metadata": {}, + "source": [], "outputs": [], - "source": [] + "metadata": {} } ], "metadata": { @@ -110,9 +202,8 @@ "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" }, "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" + "name": "python3", + "display_name": "Python 3.7.11 64-bit" }, "language_info": { "codemirror_mode": { @@ -124,9 +215,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" + "version": "3.7.11" } }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file From 328c3e51c3ffe81aa6b9ded3f99d0b49498add3c Mon Sep 17 00:00:00 2001 From: YongmingFrankGe Date: Wed, 16 Feb 2022 13:51:09 -0800 Subject: [PATCH 08/26] write skeleton for the logic of overlay, most importantly the helper functions needed; return the trajectory now in spatial temporal form --- apperception/metadata_context.py | 3 ++- apperception/metadata_context_executor.py | 5 ++-- apperception/scenic_util.py | 16 +++++++++++-- apperception/scenic_world.py | 27 ++++++++++++++++++++- scenic_test.ipynb | 29 ++++++++--------------- 5 files changed, 55 insertions(+), 25 deletions(-) diff --git a/apperception/metadata_context.py b/apperception/metadata_context.py index 87ae24f9..d7cab6a7 100644 --- a/apperception/metadata_context.py +++ b/apperception/metadata_context.py @@ -55,7 +55,8 @@ def aggregate(self, func_name: str, parameters: List[str] = [], special_args: Li return self def get_coordinates(self): - self.aggregate("asMFJSON", special_args=["coordinates"]) + # self.aggregate("asMFJSON", special_args=["coordinates"]) + self.aggregate("asMFJSON") def interval(self, starttime, endtime): self.aggregate("atPeriodSet", parameters=["'{[%s, %s)}'" % (starttime, endtime)]) diff --git a/apperception/metadata_context_executor.py b/apperception/metadata_context_executor.py index e38988b6..003bbe75 100644 --- a/apperception/metadata_context_executor.py +++ b/apperception/metadata_context_executor.py @@ -125,6 +125,7 @@ def translate_aggregation(aggr_node: Aggregate, aggregated: str): if isinstance(aggr_node, asMFJSON): if len(aggr_node.interesting_fields) > 0: interesting_field = aggr_node.interesting_fields[0] - aggregated = aggregated + "::json->" + "'" + interesting_field + "'" - + aggregated = aggregated + "::json->" + "\'"+interesting_field+"\'" + else: + aggregated = aggregated + "::json" return aggregated diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py index 76f017a4..664b8e90 100644 --- a/apperception/scenic_util.py +++ b/apperception/scenic_util.py @@ -287,7 +287,7 @@ def create_or_insert_scenic_general_trajectory(conn, item_id, object_type, frame ''' # Formal_Scenic_Item_General_Trajectory table stands for the formal table which won't be erased - # Test for now + # Test for now create_itemtraj_sql ='''CREATE TABLE IF NOT EXISTS Test_Scenic_Item_General_Trajectory( itemId TEXT, objectType TEXT, @@ -357,8 +357,20 @@ def insert_scenic_general_trajectory(conn, item_id, object_type, frame_id, color # Commit your changes in the database conn.commit() +def transformation(centroid_3d, camera_config): + ''' + TODO: transformation from 3d world coordinate to 2d frame coordinate given the camera config + ''' + pass + def fetch_camera(conn, scene_name, frame_num): - ### TODO: Fix fetch camera that given a scene_name and frame_num, return the corresponding camera metadata + ''' + TODO: Fix fetch camera that given a scene_name and frame_num, return the corresponding camera metadata + scene_name: str + frame_num: int[] + return a list of metadata info for each frame_num + ''' + cursor = conn.cursor() if cam_id == []: diff --git a/apperception/scenic_world.py b/apperception/scenic_world.py index b581d88f..80da1005 100644 --- a/apperception/scenic_world.py +++ b/apperception/scenic_world.py @@ -152,8 +152,33 @@ def select_intersection_of_interest_or_use_default(self, cam_id, default=True): x2, y2, z2 = br return BASE_VOLUME_QUERY_TEXT.format(x1=x1, y1=y1, z1=0, x2=x2, y2=y2, z2=2) + def scenic_trajectory_to_frame_num(self, trajectory): + ''' + TODO: fetch the frame number from the trajectory + 1. get the time stamp field from the trajectory + 2. convert the time stamp to frame number + Refer to 'convert_datetime_to_frame_num' in 'video_util.py' + 3. return the frame number + ''' + + def get_overlay_info(self, trajectory, camera_info): + ''' + TODO: overlay each trajectory 3d coordinate on to the frame specified by the camera_info + 1. for each trajectory, get the 3d coordinate + 2. get the camera_info associated to it + 3. implement the transformation function from 3d to 2d + given the single centroid point and camera configuration + refer to TODO in "senic_utils.py" + 4. return a list of (2d coordinate, frame name/filename) + ''' + pass + def scenic_overlay_trajectory(self, scene_name, trajectory): - camera = self.get_camera(scene_name, frame_num) + frame_num = self.scenic_trajectory_to_frame_num(trajectory) + camera_info = self.get_camera(scene_name, frame_num) + assert len(camera_info) == len(frame_num) + overlay_info = self.get_overlay_info(trajectory, camera_info) + ### TODO: fix the following to overlay the 2d point onto the frame for traj in trajectory: current_trajectory = np.asarray(traj[0]) frame_points = camera.lens.world_to_pixels(current_trajectory.T).T diff --git a/scenic_test.ipynb b/scenic_test.ipynb index 74f98796..0aaf973a 100644 --- a/scenic_test.ipynb +++ b/scenic_test.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "source": [ "import os\n", "import sys\n", @@ -25,7 +25,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "source": [ "### Let's define some attribute for constructing the world first\n", "name = 'ScenicWorld' # world name\n", @@ -48,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "source": [ "scenic_world = ScenicWorld(name=name, units=units)" ], @@ -91,8 +91,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "source": [ + "# the trajectory returned now includes the temporal info instead of just the spatio info\n", "car_trajectories = scenic_world.predicate(lambda obj:obj.object_type == \"vehicle.car\").get_trajectory().execute()" ], "outputs": [ @@ -104,36 +105,26 @@ "Worlds Table created successfully........\n", "New world inserted successfully........\n", "atPeriodSet(Test_Scenic_Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}')\n", - "asMFJSON(atPeriodSet(Test_Scenic_Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}'))::json->'coordinates'\n", - "SELECT asMFJSON(atPeriodSet(Test_Scenic_Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}'))::json->'coordinates' From Test_Scenic_Item_General_Trajectory Where Test_Scenic_Item_General_Trajectory.objectType='vehicle.car';\n", + "asMFJSON(atPeriodSet(Test_Scenic_Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}'))::json\n", + "SELECT asMFJSON(atPeriodSet(Test_Scenic_Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}'))::json From Test_Scenic_Item_General_Trajectory Where Test_Scenic_Item_General_Trajectory.objectType='vehicle.car';\n", "\n" ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/home/yongming/workspace/research/apperception/apperception/metadata_context_executor.py:107: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", - " return np.asarray(self.cursor.fetchall())\n" - ] } ], "metadata": {} }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 8, "source": [ - "print(len(car_trajectories))\n", - "print(len(car_trajectories[0][0]))" + "print(car_trajectories[0][0])" ], "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "14\n", - "212\n" + "{'type': 'MovingPoint', 'coordinates': [[353.794, 1132.355, 0.602], [353.776, 1132.363, 0.622], [353.776, 1132.363, 0.622], [353.776, 1132.363, 0.622], [353.776, 1132.363, 0.622], [353.776, 1132.363, 0.622], [353.776, 1132.363, 0.622], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.741, 1132.378, 0.662], [353.741, 1132.378, 0.662], [353.741, 1132.378, 0.662], [353.741, 1132.378, 0.662], [353.741, 1132.378, 0.662], [353.741, 1132.378, 0.662], [353.724, 1132.385, 0.682], [353.724, 1132.385, 0.682], [353.724, 1132.385, 0.682], [353.724, 1132.385, 0.682], [353.724, 1132.385, 0.682], [353.724, 1132.385, 0.682], [353.755, 1132.372, 0.677], [353.755, 1132.372, 0.677], [353.755, 1132.372, 0.677], [353.755, 1132.372, 0.677], [353.755, 1132.372, 0.677], [353.786, 1132.358, 0.672], [353.786, 1132.358, 0.672], [353.786, 1132.358, 0.672], [353.786, 1132.358, 0.672], [353.786, 1132.358, 0.672], [353.786, 1132.358, 0.672], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.83, 1132.369, 0.737], [353.83, 1132.369, 0.737], [353.83, 1132.369, 0.737], [353.83, 1132.369, 0.737], [353.83, 1132.369, 0.737], [353.83, 1132.369, 0.737], [353.905, 1132.296, 0.77], [353.905, 1132.296, 0.77], [353.905, 1132.296, 0.77], [353.905, 1132.296, 0.77], [353.905, 1132.296, 0.77], [353.905, 1132.296, 0.77], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.906, 1132.322, 0.859], [353.906, 1132.322, 0.859], [353.906, 1132.322, 0.859], [353.906, 1132.322, 0.859], [353.906, 1132.322, 0.859], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.924, 1132.329, 1.151], [353.924, 1132.329, 1.151], [353.924, 1132.329, 1.151], [353.924, 1132.329, 1.151], [353.924, 1132.329, 1.151], [353.924, 1132.329, 1.151], [354.008, 1132.468, 1.186], [354.008, 1132.468, 1.186], [354.008, 1132.468, 1.186], [354.008, 1132.468, 1.186], [354.008, 1132.468, 1.186], [354.008, 1132.468, 1.186], [354.035, 1132.468, 1.196], [354.035, 1132.468, 1.196], [354.035, 1132.468, 1.196], [354.035, 1132.468, 1.196], [354.035, 1132.468, 1.196], [354.063, 1132.468, 1.206], [354.063, 1132.468, 1.206], [354.063, 1132.468, 1.206], [354.063, 1132.468, 1.206], [354.063, 1132.468, 1.206], [354.091, 1132.468, 1.216], [354.091, 1132.468, 1.216], [354.091, 1132.468, 1.216], [354.091, 1132.468, 1.216], [354.091, 1132.468, 1.216], [354.091, 1132.468, 1.216], [354.038, 1132.593, 1.366], [354.038, 1132.593, 1.366], [354.038, 1132.593, 1.366], [354.038, 1132.593, 1.366], [354.038, 1132.593, 1.366], [354.038, 1132.593, 1.366], [354.104, 1132.795, 1.367], [354.104, 1132.795, 1.367], [354.104, 1132.795, 1.367], [354.104, 1132.795, 1.367], [354.104, 1132.795, 1.367], [354.104, 1132.795, 1.367], [354.026, 1132.642, 1.267], [354.026, 1132.642, 1.267], [354.026, 1132.642, 1.267], [354.026, 1132.642, 1.267], [354.026, 1132.642, 1.267], [354.02, 1132.667, 1.28], [354.02, 1132.667, 1.28], [354.02, 1132.667, 1.28], [354.02, 1132.667, 1.28], [354.02, 1132.667, 1.28], [354.02, 1132.667, 1.28], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.009, 1132.716, 1.307], [354.009, 1132.716, 1.307], [354.009, 1132.716, 1.307], [354.009, 1132.716, 1.307], [354.009, 1132.716, 1.307], [354.009, 1132.716, 1.307], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [353.997, 1132.765, 1.333], [353.997, 1132.765, 1.333], [353.997, 1132.765, 1.333], [353.997, 1132.765, 1.333], [353.997, 1132.765, 1.333], [353.997, 1132.765, 1.333], [353.991, 1132.79, 1.346], [353.991, 1132.79, 1.346], [353.991, 1132.79, 1.346], [353.991, 1132.79, 1.346], [353.991, 1132.79, 1.346], [353.991, 1132.79, 1.346], [353.985, 1132.815, 1.359], [353.985, 1132.815, 1.359], [353.985, 1132.815, 1.359], [353.985, 1132.815, 1.359], [353.985, 1132.815, 1.359], [353.979, 1132.839, 1.372], [353.979, 1132.839, 1.372], [353.979, 1132.839, 1.372], [353.979, 1132.839, 1.372], [353.979, 1132.839, 1.372], [353.973, 1132.864, 1.346], [353.973, 1132.864, 1.346], [353.973, 1132.864, 1.346], [353.973, 1132.864, 1.346], [353.973, 1132.864, 1.346], [353.973, 1132.864, 1.346], [353.967, 1132.889, 1.32], [353.967, 1132.889, 1.32], [353.967, 1132.889, 1.32], [353.967, 1132.889, 1.32], [353.967, 1132.889, 1.32], [353.967, 1132.889, 1.32], [353.961, 1132.913, 1.294], [353.961, 1132.913, 1.294], [353.961, 1132.913, 1.294], [353.961, 1132.913, 1.294], [353.961, 1132.913, 1.294], [353.961, 1132.913, 1.294], [353.956, 1132.938, 1.268], [353.956, 1132.938, 1.268], [353.956, 1132.938, 1.268], [353.956, 1132.938, 1.268], [353.956, 1132.938, 1.268], [353.956, 1132.938, 1.268], [353.95, 1132.963, 1.242], [353.95, 1132.963, 1.242], [353.95, 1132.963, 1.242], [353.95, 1132.963, 1.242], [353.95, 1132.963, 1.242], [353.944, 1132.987, 1.216], [353.944, 1132.987, 1.216], [353.944, 1132.987, 1.216], [353.944, 1132.987, 1.216], [353.944, 1132.987, 1.216], [353.944, 1132.987, 1.216]], 'datetimes': ['2021-06-08T07:10:29+00', '2021-06-08T07:10:30+00', '2021-06-08T07:10:31+00', '2021-06-08T07:10:32+00', '2021-06-08T07:10:33+00', '2021-06-08T07:10:34+00', '2021-06-08T07:10:35+00', '2021-06-08T07:10:36+00', '2021-06-08T07:10:37+00', '2021-06-08T07:10:38+00', '2021-06-08T07:10:39+00', '2021-06-08T07:10:40+00', '2021-06-08T07:10:41+00', '2021-06-08T07:10:42+00', '2021-06-08T07:10:43+00', '2021-06-08T07:10:44+00', '2021-06-08T07:10:45+00', '2021-06-08T07:10:46+00', '2021-06-08T07:10:47+00', '2021-06-08T07:10:48+00', '2021-06-08T07:10:49+00', '2021-06-08T07:10:50+00', '2021-06-08T07:10:51+00', '2021-06-08T07:10:52+00', '2021-06-08T07:10:53+00', '2021-06-08T07:10:54+00', '2021-06-08T07:10:55+00', '2021-06-08T07:10:56+00', '2021-06-08T07:10:57+00', '2021-06-08T07:10:58+00', '2021-06-08T07:10:59+00', '2021-06-08T07:11:00+00', '2021-06-08T07:11:01+00', '2021-06-08T07:11:02+00', '2021-06-08T07:11:03+00', '2021-06-08T07:11:04+00', '2021-06-08T07:11:05+00', '2021-06-08T07:11:06+00', '2021-06-08T07:11:07+00', '2021-06-08T07:11:08+00', '2021-06-08T07:11:09+00', '2021-06-08T07:11:10+00', '2021-06-08T07:11:11+00', '2021-06-08T07:11:12+00', '2021-06-08T07:11:13+00', '2021-06-08T07:11:14+00', '2021-06-08T07:11:15+00', '2021-06-08T07:11:16+00', '2021-06-08T07:11:17+00', '2021-06-08T07:11:18+00', '2021-06-08T07:11:19+00', '2021-06-08T07:11:20+00', '2021-06-08T07:11:21+00', '2021-06-08T07:11:22+00', '2021-06-08T07:11:23+00', '2021-06-08T07:11:24+00', '2021-06-08T07:11:25+00', '2021-06-08T07:11:26+00', '2021-06-08T07:11:27+00', '2021-06-08T07:11:28+00', '2021-06-08T07:11:29+00', '2021-06-08T07:11:30+00', '2021-06-08T07:11:31+00', '2021-06-08T07:11:32+00', '2021-06-08T07:11:33+00', '2021-06-08T07:11:34+00', '2021-06-08T07:11:35+00', '2021-06-08T07:11:36+00', '2021-06-08T07:11:37+00', '2021-06-08T07:11:38+00', '2021-06-08T07:11:39+00', '2021-06-08T07:11:40+00', '2021-06-08T07:11:41+00', '2021-06-08T07:11:42+00', '2021-06-08T07:11:43+00', '2021-06-08T07:11:44+00', '2021-06-08T07:11:45+00', '2021-06-08T07:11:46+00', '2021-06-08T07:11:47+00', '2021-06-08T07:11:48+00', '2021-06-08T07:11:49+00', '2021-06-08T07:11:50+00', '2021-06-08T07:11:51+00', '2021-06-08T07:11:52+00', '2021-06-08T07:11:53+00', '2021-06-08T07:11:54+00', '2021-06-08T07:11:55+00', '2021-06-08T07:11:56+00', '2021-06-08T07:11:57+00', '2021-06-08T07:11:58+00', '2021-06-08T07:11:59+00', '2021-06-08T07:12:00+00', '2021-06-08T07:12:01+00', '2021-06-08T07:12:02+00', '2021-06-08T07:12:03+00', '2021-06-08T07:12:04+00', '2021-06-08T07:12:05+00', '2021-06-08T07:12:06+00', '2021-06-08T07:12:07+00', '2021-06-08T07:12:08+00', '2021-06-08T07:12:09+00', '2021-06-08T07:12:10+00', '2021-06-08T07:12:11+00', '2021-06-08T07:12:12+00', '2021-06-08T07:12:13+00', '2021-06-08T07:12:14+00', '2021-06-08T07:12:15+00', '2021-06-08T07:12:16+00', '2021-06-08T07:12:17+00', '2021-06-08T07:12:18+00', '2021-06-08T07:12:19+00', '2021-06-08T07:12:20+00', '2021-06-08T07:12:21+00', '2021-06-08T07:12:22+00', '2021-06-08T07:12:23+00', '2021-06-08T07:12:24+00', '2021-06-08T07:12:25+00', '2021-06-08T07:12:26+00', '2021-06-08T07:12:27+00', '2021-06-08T07:12:28+00', '2021-06-08T07:12:29+00', '2021-06-08T07:12:30+00', '2021-06-08T07:12:31+00', '2021-06-08T07:12:32+00', '2021-06-08T07:12:33+00', '2021-06-08T07:12:34+00', '2021-06-08T07:12:35+00', '2021-06-08T07:12:36+00', '2021-06-08T07:12:37+00', '2021-06-08T07:12:38+00', '2021-06-08T07:12:39+00', '2021-06-08T07:12:40+00', '2021-06-08T07:12:41+00', '2021-06-08T07:12:42+00', '2021-06-08T07:12:43+00', '2021-06-08T07:12:44+00', '2021-06-08T07:12:45+00', '2021-06-08T07:12:46+00', '2021-06-08T07:12:47+00', '2021-06-08T07:12:48+00', '2021-06-08T07:12:49+00', '2021-06-08T07:12:50+00', '2021-06-08T07:12:51+00', '2021-06-08T07:12:52+00', '2021-06-08T07:12:53+00', '2021-06-08T07:12:54+00', '2021-06-08T07:12:55+00', '2021-06-08T07:12:56+00', '2021-06-08T07:12:57+00', '2021-06-08T07:12:58+00', '2021-06-08T07:12:59+00', '2021-06-08T07:13:00+00', '2021-06-08T07:13:01+00', '2021-06-08T07:13:02+00', '2021-06-08T07:13:03+00', '2021-06-08T07:13:04+00', '2021-06-08T07:13:05+00', '2021-06-08T07:13:06+00', '2021-06-08T07:13:07+00', '2021-06-08T07:13:08+00', '2021-06-08T07:13:09+00', '2021-06-08T07:13:10+00', '2021-06-08T07:13:11+00', '2021-06-08T07:13:12+00', '2021-06-08T07:13:13+00', '2021-06-08T07:13:14+00', '2021-06-08T07:13:15+00', '2021-06-08T07:13:16+00', '2021-06-08T07:13:17+00', '2021-06-08T07:13:18+00', '2021-06-08T07:13:19+00', '2021-06-08T07:13:20+00', '2021-06-08T07:13:21+00', '2021-06-08T07:13:22+00', '2021-06-08T07:13:23+00', '2021-06-08T07:13:24+00', '2021-06-08T07:13:25+00', '2021-06-08T07:13:26+00', '2021-06-08T07:13:27+00', '2021-06-08T07:13:28+00', '2021-06-08T07:13:29+00', '2021-06-08T07:13:30+00', '2021-06-08T07:13:31+00', '2021-06-08T07:13:32+00', '2021-06-08T07:13:33+00', '2021-06-08T07:13:34+00', '2021-06-08T07:13:35+00', '2021-06-08T07:13:36+00', '2021-06-08T07:13:37+00', '2021-06-08T07:13:38+00', '2021-06-08T07:13:39+00', '2021-06-08T07:13:40+00', '2021-06-08T07:13:41+00', '2021-06-08T07:13:42+00', '2021-06-08T07:13:43+00', '2021-06-08T07:13:44+00', '2021-06-08T07:13:45+00', '2021-06-08T07:13:46+00', '2021-06-08T07:13:47+00', '2021-06-08T07:13:48+00', '2021-06-08T07:13:49+00', '2021-06-08T07:13:50+00', '2021-06-08T07:13:51+00', '2021-06-08T07:13:52+00', '2021-06-08T07:13:53+00', '2021-06-08T07:13:54+00', '2021-06-08T07:13:55+00', '2021-06-08T07:13:56+00', '2021-06-08T07:13:57+00', '2021-06-08T07:13:58+00', '2021-06-08T07:13:59+00', '2021-06-08T07:14:00+00'], 'interpolations': ['Discrete']}\n" ] } ], From 438c6c9b6c0cca0cd6845827010f349d94914a3d Mon Sep 17 00:00:00 2001 From: YongmingFrankGe Date: Tue, 22 Feb 2022 21:54:16 -0800 Subject: [PATCH 09/26] export direct export and import tables from postgres --- apperception/scenic_box.py | 2 +- apperception/scenic_util.py | 118 +++++++++++++++++++++++++---------- apperception/scenic_world.py | 3 +- scenic_test.ipynb | 78 ++++++++++++++++++----- 4 files changed, 149 insertions(+), 52 deletions(-) diff --git a/apperception/scenic_box.py b/apperception/scenic_box.py index 48e14187..1512cf73 100644 --- a/apperception/scenic_box.py +++ b/apperception/scenic_box.py @@ -54,7 +54,7 @@ def corners(self, wlh_factor: float = 1.0) -> np.ndarray: The last four are the ones facing backwards. """ w, l, h = self.wlh * wlh_factor - + # 3D bounding box corners. (Convention: x points forward, y to the left, z up.) x_corners = l / 2 * np.array([1, 1, 1, 1, -1, -1, -1, -1]) y_corners = w / 2 * np.array([1, -1, -1, 1, 1, -1, -1, 1]) diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py index 664b8e90..dd078b5b 100644 --- a/apperception/scenic_util.py +++ b/apperception/scenic_util.py @@ -13,6 +13,37 @@ import time import pandas as pd +CREATE_ITEMTRAJ_SQL ='''CREATE TABLE IF NOT EXISTS Test_Scenic_Item_General_Trajectory( + itemId TEXT, + objectType TEXT, + frameId TEXT, + color TEXT, + trajCentroids tgeompoint, + largestBbox stbox, + PRIMARY KEY (itemId) + );''' + +CREATE_BBOXES_SQL ='''CREATE TABLE IF NOT EXISTS Test_Scenic_General_Bbox( + itemId TEXT, + trajBbox stbox, + FOREIGN KEY(itemId) + REFERENCES Test_Scenic_Item_General_Trajectory(itemId) + );''' + +CREATE_CAMERA_SQL = '''CREATE TABLE IF NOT EXISTS Test_Scenic_Cameras( + cameraId TEXT, + worldId TEXT, + frameId TEXT, + frameNum Int, + fileName TEXT, + cameraTranslation geometry, + cameraRotation geometry, + cameraIntrinsic real[][], + egoTranslation geometry, + egoRotation geometry, + timestamp TEXT + );''' + def fetch_camera_config(scene_name, sample_data): ''' return @@ -64,23 +95,11 @@ def create_or_insert_scenic_camera_table(conn, world_name, camera): cursor.execute("DROP TABLE IF EXISTS Scenic_Cameras") # Formal_Scenic_cameras table stands for the formal table which won't be erased # Test for now - sql = '''CREATE TABLE IF NOT EXISTS Test_Scenic_Cameras( - cameraId TEXT, - worldId TEXT, - frameId TEXT, - frameNum Int, - fileName TEXT, - cameraTranslation geometry, - cameraRotation geometry, - cameraIntrinsic real[][], - egoTranslation geometry, - egoRotation geometry, - timestamp TEXT - );''' - cursor.execute(sql) + + cursor.execute(CREATE_CAMERA_SQL) print("Camera Table created successfully........") insert_scenic_camera(conn, world_name, fetch_camera_config(camera.scenic_scene_name, camera.object_recognition.sample_data)) - return sql + return CREATE_CAMERA_SQL # Helper function to insert the camera def insert_scenic_camera(conn, world_name, camera_config): @@ -186,7 +205,7 @@ def scenic_recognize(scene_name, sample_data, annotation): bboxes: [[[x1, y1, z1], [x2, y2, z2]], ...] object_type, frame_num, - frame_id + frame_id, } ... } @@ -288,27 +307,14 @@ def create_or_insert_scenic_general_trajectory(conn, item_id, object_type, frame # Formal_Scenic_Item_General_Trajectory table stands for the formal table which won't be erased # Test for now - create_itemtraj_sql ='''CREATE TABLE IF NOT EXISTS Test_Scenic_Item_General_Trajectory( - itemId TEXT, - objectType TEXT, - frameId TEXT, - color TEXT, - trajCentroids tgeompoint, - largestBbox stbox, - PRIMARY KEY (itemId) - );''' - cursor.execute(create_itemtraj_sql) + + cursor.execute(CREATE_ITEMTRAJ_SQL) cursor.execute("CREATE INDEX IF NOT EXISTS traj_idx ON Test_Scenic_Item_General_Trajectory USING GiST(trajCentroids);") conn.commit() # Formal_Scenic_General_Bbox table stands for the formal table which won't be erased # Test for now - create_bboxes_sql ='''CREATE TABLE IF NOT EXISTS Test_Scenic_General_Bbox( - itemId TEXT, - trajBbox stbox, - FOREIGN KEY(itemId) - REFERENCES Test_Scenic_Item_General_Trajectory(itemId) - );''' - cursor.execute(create_bboxes_sql) + + cursor.execute(CREATE_BBOXES_SQL) cursor.execute("CREATE INDEX IF NOT EXISTS item_idx ON Test_Scenic_General_Bbox(itemId);") cursor.execute("CREATE INDEX IF NOT EXISTS traj_bbox_idx ON Test_Scenic_General_Bbox USING GiST(trajBbox);") conn.commit() @@ -372,7 +378,7 @@ def fetch_camera(conn, scene_name, frame_num): ''' cursor = conn.cursor() - + if cam_id == []: query = '''SELECT cameraId, ratio, ST_X(origin), ST_Y(origin), ST_Z(origin), ST_X(focalpoints), ST_Y(focalpoints), fov, skev_factor ''' \ + '''FROM Cameras WHERE worldId = \'%s\';''' %world_id @@ -386,4 +392,48 @@ def clean_scenic_tables(conn): cursor = conn.cursor() cursor.execute("DROP TABLE IF EXISTS test_scenic_General_Bbox;") cursor.execute("DROP TABLE IF EXISTS test_scenic_Item_General_Trajectory;") + conn.commit() + +def export_tables(conn): + # create a query to specify which values we want from the database. + s = "SELECT *" + s += " FROM " + s_trajectory = s + "Test_Scenic_Item_General_Trajectory" + s_bbox = s + "Test_Scenic_General_Bbox" + s_camera = s + "Test_Scenic_Cameras" + + # set up our database connection. + db_cursor = conn.cursor() + + # Use the COPY function on the SQL we created above. + SQL_trajectory_output = "COPY ({0}) TO STDOUT WITH CSV HEADER".format(s_trajectory) + SQL_bbox_output = "COPY ({0}) TO STDOUT WITH CSV HEADER".format(s_bbox) + SQL_camera_output = "COPY ({0}) TO STDOUT WITH CSV HEADER".format(s_camera) + + # Set up a variable to store our file path and name. + trajectory_file = "test_trajectory.csv" + with open(trajectory_file, 'w') as trajectory_output: + db_cursor.copy_expert(SQL_trajectory_output, trajectory_output) + + bbox_file = "test_bbox.csv" + with open(bbox_file, 'w') as bbox_output: + db_cursor.copy_expert(SQL_bbox_output, bbox_output) + + camera_file = "test_camera.csv" + with open(camera_file, 'w') as camera_output: + db_cursor.copy_expert(SQL_camera_output, camera_output) + +def import_tables(conn): + cur = conn.cursor() + cur.execute(CREATE_CAMERA_SQL) + cur.execute(CREATE_ITEMTRAJ_SQL) + cur.execute(CREATE_BBOXES_SQL) + conn.commit() + with open('test_camera.csv', 'r') as camera_f: + cur.copy_expert(file=camera_f, sql="COPY test_scenic_cameras FROM STDIN CSV HEADER DELIMITER as ','") + with open('test_trajectory.csv', 'r') as trajectory_f: + cur.copy_expert(file=trajectory_f, sql="COPY test_scenic_item_general_trajectory FROM STDIN CSV HEADER DELIMITER as ','") + with open('test_bbox.csv', 'r') as bbox_f: + cur.copy_expert(file=bbox_f, sql="COPY test_scenic_general_bbox FROM STDIN CSV HEADER DELIMITER as ','") + conn.commit() \ No newline at end of file diff --git a/apperception/scenic_world.py b/apperception/scenic_world.py index 80da1005..9e7412ee 100644 --- a/apperception/scenic_world.py +++ b/apperception/scenic_world.py @@ -20,6 +20,7 @@ def __init__(self, name, units, enable_tasm=False): def get_camera(self, scene_name, frame_num): # Change depending if you're on docker or not + # TODO: fix get_camera in scenic_world_executor.py if self.enable_tasm: scenic_world_executor.connect_db(port=5432, user="docker", password="docker", database_name="mobilitydb") else: @@ -175,7 +176,7 @@ def get_overlay_info(self, trajectory, camera_info): def scenic_overlay_trajectory(self, scene_name, trajectory): frame_num = self.scenic_trajectory_to_frame_num(trajectory) - camera_info = self.get_camera(scene_name, frame_num) + camera_info = self.get_camera(scene_name, frame_num) ### TODO: fetch_camera_info in scenic_utils.py assert len(camera_info) == len(frame_num) overlay_info = self.get_overlay_info(trajectory, camera_info) ### TODO: fix the following to overlay the 2d point onto the frame diff --git a/scenic_test.ipynb b/scenic_test.ipynb index 0aaf973a..16ad5143 100644 --- a/scenic_test.ipynb +++ b/scenic_test.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "source": [ "import os\n", "import sys\n", @@ -25,7 +25,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "source": [ "### Let's define some attribute for constructing the world first\n", "name = 'ScenicWorld' # world name\n", @@ -37,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "source": [ "# generate dataframes from scenic json files\n", "# takes 1min to run\n", @@ -48,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 6, "source": [ "scenic_world = ScenicWorld(name=name, units=units)" ], @@ -57,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "source": [ "### Ingest the camera to the world\n", "scene_name = \"scene-0061\"\n", @@ -68,7 +68,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "source": [ "### Call execute on the world to run the detection algorithm and save the real data to the database\n", "recognized_scenic_world = scenic_world.recognize(scene_name, df_sample_data, df_annotation)\n", @@ -115,19 +115,11 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "source": [ "print(car_trajectories[0][0])" ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "{'type': 'MovingPoint', 'coordinates': [[353.794, 1132.355, 0.602], [353.776, 1132.363, 0.622], [353.776, 1132.363, 0.622], [353.776, 1132.363, 0.622], [353.776, 1132.363, 0.622], [353.776, 1132.363, 0.622], [353.776, 1132.363, 0.622], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.741, 1132.378, 0.662], [353.741, 1132.378, 0.662], [353.741, 1132.378, 0.662], [353.741, 1132.378, 0.662], [353.741, 1132.378, 0.662], [353.741, 1132.378, 0.662], [353.724, 1132.385, 0.682], [353.724, 1132.385, 0.682], [353.724, 1132.385, 0.682], [353.724, 1132.385, 0.682], [353.724, 1132.385, 0.682], [353.724, 1132.385, 0.682], [353.755, 1132.372, 0.677], [353.755, 1132.372, 0.677], [353.755, 1132.372, 0.677], [353.755, 1132.372, 0.677], [353.755, 1132.372, 0.677], [353.786, 1132.358, 0.672], [353.786, 1132.358, 0.672], [353.786, 1132.358, 0.672], [353.786, 1132.358, 0.672], [353.786, 1132.358, 0.672], [353.786, 1132.358, 0.672], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.83, 1132.369, 0.737], [353.83, 1132.369, 0.737], [353.83, 1132.369, 0.737], [353.83, 1132.369, 0.737], [353.83, 1132.369, 0.737], [353.83, 1132.369, 0.737], [353.905, 1132.296, 0.77], [353.905, 1132.296, 0.77], [353.905, 1132.296, 0.77], [353.905, 1132.296, 0.77], [353.905, 1132.296, 0.77], [353.905, 1132.296, 0.77], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.906, 1132.322, 0.859], [353.906, 1132.322, 0.859], [353.906, 1132.322, 0.859], [353.906, 1132.322, 0.859], [353.906, 1132.322, 0.859], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.924, 1132.329, 1.151], [353.924, 1132.329, 1.151], [353.924, 1132.329, 1.151], [353.924, 1132.329, 1.151], [353.924, 1132.329, 1.151], [353.924, 1132.329, 1.151], [354.008, 1132.468, 1.186], [354.008, 1132.468, 1.186], [354.008, 1132.468, 1.186], [354.008, 1132.468, 1.186], [354.008, 1132.468, 1.186], [354.008, 1132.468, 1.186], [354.035, 1132.468, 1.196], [354.035, 1132.468, 1.196], [354.035, 1132.468, 1.196], [354.035, 1132.468, 1.196], [354.035, 1132.468, 1.196], [354.063, 1132.468, 1.206], [354.063, 1132.468, 1.206], [354.063, 1132.468, 1.206], [354.063, 1132.468, 1.206], [354.063, 1132.468, 1.206], [354.091, 1132.468, 1.216], [354.091, 1132.468, 1.216], [354.091, 1132.468, 1.216], [354.091, 1132.468, 1.216], [354.091, 1132.468, 1.216], [354.091, 1132.468, 1.216], [354.038, 1132.593, 1.366], [354.038, 1132.593, 1.366], [354.038, 1132.593, 1.366], [354.038, 1132.593, 1.366], [354.038, 1132.593, 1.366], [354.038, 1132.593, 1.366], [354.104, 1132.795, 1.367], [354.104, 1132.795, 1.367], [354.104, 1132.795, 1.367], [354.104, 1132.795, 1.367], [354.104, 1132.795, 1.367], [354.104, 1132.795, 1.367], [354.026, 1132.642, 1.267], [354.026, 1132.642, 1.267], [354.026, 1132.642, 1.267], [354.026, 1132.642, 1.267], [354.026, 1132.642, 1.267], [354.02, 1132.667, 1.28], [354.02, 1132.667, 1.28], [354.02, 1132.667, 1.28], [354.02, 1132.667, 1.28], [354.02, 1132.667, 1.28], [354.02, 1132.667, 1.28], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.009, 1132.716, 1.307], [354.009, 1132.716, 1.307], [354.009, 1132.716, 1.307], [354.009, 1132.716, 1.307], [354.009, 1132.716, 1.307], [354.009, 1132.716, 1.307], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [353.997, 1132.765, 1.333], [353.997, 1132.765, 1.333], [353.997, 1132.765, 1.333], [353.997, 1132.765, 1.333], [353.997, 1132.765, 1.333], [353.997, 1132.765, 1.333], [353.991, 1132.79, 1.346], [353.991, 1132.79, 1.346], [353.991, 1132.79, 1.346], [353.991, 1132.79, 1.346], [353.991, 1132.79, 1.346], [353.991, 1132.79, 1.346], [353.985, 1132.815, 1.359], [353.985, 1132.815, 1.359], [353.985, 1132.815, 1.359], [353.985, 1132.815, 1.359], [353.985, 1132.815, 1.359], [353.979, 1132.839, 1.372], [353.979, 1132.839, 1.372], [353.979, 1132.839, 1.372], [353.979, 1132.839, 1.372], [353.979, 1132.839, 1.372], [353.973, 1132.864, 1.346], [353.973, 1132.864, 1.346], [353.973, 1132.864, 1.346], [353.973, 1132.864, 1.346], [353.973, 1132.864, 1.346], [353.973, 1132.864, 1.346], [353.967, 1132.889, 1.32], [353.967, 1132.889, 1.32], [353.967, 1132.889, 1.32], [353.967, 1132.889, 1.32], [353.967, 1132.889, 1.32], [353.967, 1132.889, 1.32], [353.961, 1132.913, 1.294], [353.961, 1132.913, 1.294], [353.961, 1132.913, 1.294], [353.961, 1132.913, 1.294], [353.961, 1132.913, 1.294], [353.961, 1132.913, 1.294], [353.956, 1132.938, 1.268], [353.956, 1132.938, 1.268], [353.956, 1132.938, 1.268], [353.956, 1132.938, 1.268], [353.956, 1132.938, 1.268], [353.956, 1132.938, 1.268], [353.95, 1132.963, 1.242], [353.95, 1132.963, 1.242], [353.95, 1132.963, 1.242], [353.95, 1132.963, 1.242], [353.95, 1132.963, 1.242], [353.944, 1132.987, 1.216], [353.944, 1132.987, 1.216], [353.944, 1132.987, 1.216], [353.944, 1132.987, 1.216], [353.944, 1132.987, 1.216], [353.944, 1132.987, 1.216]], 'datetimes': ['2021-06-08T07:10:29+00', '2021-06-08T07:10:30+00', '2021-06-08T07:10:31+00', '2021-06-08T07:10:32+00', '2021-06-08T07:10:33+00', '2021-06-08T07:10:34+00', '2021-06-08T07:10:35+00', '2021-06-08T07:10:36+00', '2021-06-08T07:10:37+00', '2021-06-08T07:10:38+00', '2021-06-08T07:10:39+00', '2021-06-08T07:10:40+00', '2021-06-08T07:10:41+00', '2021-06-08T07:10:42+00', '2021-06-08T07:10:43+00', '2021-06-08T07:10:44+00', '2021-06-08T07:10:45+00', '2021-06-08T07:10:46+00', '2021-06-08T07:10:47+00', '2021-06-08T07:10:48+00', '2021-06-08T07:10:49+00', '2021-06-08T07:10:50+00', '2021-06-08T07:10:51+00', '2021-06-08T07:10:52+00', '2021-06-08T07:10:53+00', '2021-06-08T07:10:54+00', '2021-06-08T07:10:55+00', '2021-06-08T07:10:56+00', '2021-06-08T07:10:57+00', '2021-06-08T07:10:58+00', '2021-06-08T07:10:59+00', '2021-06-08T07:11:00+00', '2021-06-08T07:11:01+00', '2021-06-08T07:11:02+00', '2021-06-08T07:11:03+00', '2021-06-08T07:11:04+00', '2021-06-08T07:11:05+00', '2021-06-08T07:11:06+00', '2021-06-08T07:11:07+00', '2021-06-08T07:11:08+00', '2021-06-08T07:11:09+00', '2021-06-08T07:11:10+00', '2021-06-08T07:11:11+00', '2021-06-08T07:11:12+00', '2021-06-08T07:11:13+00', '2021-06-08T07:11:14+00', '2021-06-08T07:11:15+00', '2021-06-08T07:11:16+00', '2021-06-08T07:11:17+00', '2021-06-08T07:11:18+00', '2021-06-08T07:11:19+00', '2021-06-08T07:11:20+00', '2021-06-08T07:11:21+00', '2021-06-08T07:11:22+00', '2021-06-08T07:11:23+00', '2021-06-08T07:11:24+00', '2021-06-08T07:11:25+00', '2021-06-08T07:11:26+00', '2021-06-08T07:11:27+00', '2021-06-08T07:11:28+00', '2021-06-08T07:11:29+00', '2021-06-08T07:11:30+00', '2021-06-08T07:11:31+00', '2021-06-08T07:11:32+00', '2021-06-08T07:11:33+00', '2021-06-08T07:11:34+00', '2021-06-08T07:11:35+00', '2021-06-08T07:11:36+00', '2021-06-08T07:11:37+00', '2021-06-08T07:11:38+00', '2021-06-08T07:11:39+00', '2021-06-08T07:11:40+00', '2021-06-08T07:11:41+00', '2021-06-08T07:11:42+00', '2021-06-08T07:11:43+00', '2021-06-08T07:11:44+00', '2021-06-08T07:11:45+00', '2021-06-08T07:11:46+00', '2021-06-08T07:11:47+00', '2021-06-08T07:11:48+00', '2021-06-08T07:11:49+00', '2021-06-08T07:11:50+00', '2021-06-08T07:11:51+00', '2021-06-08T07:11:52+00', '2021-06-08T07:11:53+00', '2021-06-08T07:11:54+00', '2021-06-08T07:11:55+00', '2021-06-08T07:11:56+00', '2021-06-08T07:11:57+00', '2021-06-08T07:11:58+00', '2021-06-08T07:11:59+00', '2021-06-08T07:12:00+00', '2021-06-08T07:12:01+00', '2021-06-08T07:12:02+00', '2021-06-08T07:12:03+00', '2021-06-08T07:12:04+00', '2021-06-08T07:12:05+00', '2021-06-08T07:12:06+00', '2021-06-08T07:12:07+00', '2021-06-08T07:12:08+00', '2021-06-08T07:12:09+00', '2021-06-08T07:12:10+00', '2021-06-08T07:12:11+00', '2021-06-08T07:12:12+00', '2021-06-08T07:12:13+00', '2021-06-08T07:12:14+00', '2021-06-08T07:12:15+00', '2021-06-08T07:12:16+00', '2021-06-08T07:12:17+00', '2021-06-08T07:12:18+00', '2021-06-08T07:12:19+00', '2021-06-08T07:12:20+00', '2021-06-08T07:12:21+00', '2021-06-08T07:12:22+00', '2021-06-08T07:12:23+00', '2021-06-08T07:12:24+00', '2021-06-08T07:12:25+00', '2021-06-08T07:12:26+00', '2021-06-08T07:12:27+00', '2021-06-08T07:12:28+00', '2021-06-08T07:12:29+00', '2021-06-08T07:12:30+00', '2021-06-08T07:12:31+00', '2021-06-08T07:12:32+00', '2021-06-08T07:12:33+00', '2021-06-08T07:12:34+00', '2021-06-08T07:12:35+00', '2021-06-08T07:12:36+00', '2021-06-08T07:12:37+00', '2021-06-08T07:12:38+00', '2021-06-08T07:12:39+00', '2021-06-08T07:12:40+00', '2021-06-08T07:12:41+00', '2021-06-08T07:12:42+00', '2021-06-08T07:12:43+00', '2021-06-08T07:12:44+00', '2021-06-08T07:12:45+00', '2021-06-08T07:12:46+00', '2021-06-08T07:12:47+00', '2021-06-08T07:12:48+00', '2021-06-08T07:12:49+00', '2021-06-08T07:12:50+00', '2021-06-08T07:12:51+00', '2021-06-08T07:12:52+00', '2021-06-08T07:12:53+00', '2021-06-08T07:12:54+00', '2021-06-08T07:12:55+00', '2021-06-08T07:12:56+00', '2021-06-08T07:12:57+00', '2021-06-08T07:12:58+00', '2021-06-08T07:12:59+00', '2021-06-08T07:13:00+00', '2021-06-08T07:13:01+00', '2021-06-08T07:13:02+00', '2021-06-08T07:13:03+00', '2021-06-08T07:13:04+00', '2021-06-08T07:13:05+00', '2021-06-08T07:13:06+00', '2021-06-08T07:13:07+00', '2021-06-08T07:13:08+00', '2021-06-08T07:13:09+00', '2021-06-08T07:13:10+00', '2021-06-08T07:13:11+00', '2021-06-08T07:13:12+00', '2021-06-08T07:13:13+00', '2021-06-08T07:13:14+00', '2021-06-08T07:13:15+00', '2021-06-08T07:13:16+00', '2021-06-08T07:13:17+00', '2021-06-08T07:13:18+00', '2021-06-08T07:13:19+00', '2021-06-08T07:13:20+00', '2021-06-08T07:13:21+00', '2021-06-08T07:13:22+00', '2021-06-08T07:13:23+00', '2021-06-08T07:13:24+00', '2021-06-08T07:13:25+00', '2021-06-08T07:13:26+00', '2021-06-08T07:13:27+00', '2021-06-08T07:13:28+00', '2021-06-08T07:13:29+00', '2021-06-08T07:13:30+00', '2021-06-08T07:13:31+00', '2021-06-08T07:13:32+00', '2021-06-08T07:13:33+00', '2021-06-08T07:13:34+00', '2021-06-08T07:13:35+00', '2021-06-08T07:13:36+00', '2021-06-08T07:13:37+00', '2021-06-08T07:13:38+00', '2021-06-08T07:13:39+00', '2021-06-08T07:13:40+00', '2021-06-08T07:13:41+00', '2021-06-08T07:13:42+00', '2021-06-08T07:13:43+00', '2021-06-08T07:13:44+00', '2021-06-08T07:13:45+00', '2021-06-08T07:13:46+00', '2021-06-08T07:13:47+00', '2021-06-08T07:13:48+00', '2021-06-08T07:13:49+00', '2021-06-08T07:13:50+00', '2021-06-08T07:13:51+00', '2021-06-08T07:13:52+00', '2021-06-08T07:13:53+00', '2021-06-08T07:13:54+00', '2021-06-08T07:13:55+00', '2021-06-08T07:13:56+00', '2021-06-08T07:13:57+00', '2021-06-08T07:13:58+00', '2021-06-08T07:13:59+00', '2021-06-08T07:14:00+00'], 'interpolations': ['Discrete']}\n" - ] - } - ], + "outputs": [], "metadata": {} }, { @@ -179,6 +171,60 @@ ], "metadata": {} }, + { + "cell_type": "code", + "execution_count": 13, + "source": [ + "import psycopg2\n", + "conn = psycopg2.connect(\n", + " database=\"mobilitydb\", user=\"docker\", password=\"docker\", host=\"localhost\", port=25432)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 14, + "source": [ + "from scenic_util import *\n", + "export_tables(conn)" + ], + "outputs": [ + { + "output_type": "error", + "ename": "NameError", + "evalue": "name 'con' is not defined", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_31415/795569161.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mscenic_util\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mexport_tables\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcon\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'con' is not defined" + ] + } + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 15, + "source": [ + "cur = conn.cursor()\n", + "cur.execute(CREATE_CAMERA_SQL)\n", + "cur.execute(CREATE_BBOXES_SQL)\n", + "cur.execute(CREATE_ITEMTRAJ_SQL)\n", + "conn.commit()\n", + "with open('test_camera.csv', 'r') as camera_f:\n", + " cur.copy_expert(file=camera_f, sql=\"COPY test_scenic_cameras FROM STDIN CSV HEADER DELIMITER as ','\")\n", + "with open('test_trajectory.csv', 'r') as trajectory_f:\n", + " cur.copy_expert(file=trajectory_f, sql=\"COPY test_scenic_item_general_trajectory FROM STDIN CSV HEADER DELIMITER as ','\")\n", + "with open('test_bbox.csv', 'r') as bbox_f:\n", + " cur.copy_expert(file=bbox_f, sql=\"COPY test_scenic_general_bbox FROM STDIN CSV HEADER DELIMITER as ','\")\n", + "\n", + "conn.commit()" + ], + "outputs": [], + "metadata": {} + }, { "cell_type": "code", "execution_count": null, From b780f8c97621cf981f2ee8c41c7dc98e73e85b7b Mon Sep 17 00:00:00 2001 From: YongmingFrankGe Date: Tue, 22 Feb 2022 21:57:52 -0800 Subject: [PATCH 10/26] delete contaminated file --- scenic_test.ipynb | 260 ---------------------------------------------- 1 file changed, 260 deletions(-) delete mode 100644 scenic_test.ipynb diff --git a/scenic_test.ipynb b/scenic_test.ipynb deleted file mode 100644 index 16ad5143..00000000 --- a/scenic_test.ipynb +++ /dev/null @@ -1,260 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "source": [ - "import os\n", - "import sys\n", - "sys.path.append(os.path.join(os.getcwd(),\"apperception\"))\n", - "\n", - "### IMPORTS\n", - "import cv2\n", - "\n", - "from scenic_world import *\n", - "from world_executor import *\n", - "from video_util import *\n", - "from metadata_util import *\n", - "import json\n", - "import pandas as pd\n", - "\n", - "from scenic_generate_df import *\n" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 3, - "source": [ - "### Let's define some attribute for constructing the world first\n", - "name = 'ScenicWorld' # world name\n", - "units = 'metrics' # world units\n", - "user_data_dir = os.path.join(\"v1.0-mini\")" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 5, - "source": [ - "# generate dataframes from scenic json files\n", - "# takes 1min to run\n", - "df_sample_data, df_annotation = scenic_generate_df()" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 6, - "source": [ - "scenic_world = ScenicWorld(name=name, units=units)" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 7, - "source": [ - "### Ingest the camera to the world\n", - "scene_name = \"scene-0061\"\n", - "scenic_world = scenic_world.scenic_camera(scene_name)" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 8, - "source": [ - "### Call execute on the world to run the detection algorithm and save the real data to the database\n", - "recognized_scenic_world = scenic_world.recognize(scene_name, df_sample_data, df_annotation)\n", - "recognized_scenic_world.execute()" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Worlds Table created successfully........\n", - "New world inserted successfully........\n", - "Camera Table created successfully........\n", - "New camera inserted successfully.........\n", - "Recognization done, saving to database......\n" - ] - } - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 4, - "source": [ - "# the trajectory returned now includes the temporal info instead of just the spatio info\n", - "car_trajectories = scenic_world.predicate(lambda obj:obj.object_type == \"vehicle.car\").get_trajectory().execute()" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='object_type', ctx=Load()), ops=[Eq()], comparators=[Str(s='vehicle.car')]))])\n", - "Worlds Table created successfully........\n", - "New world inserted successfully........\n", - "atPeriodSet(Test_Scenic_Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}')\n", - "asMFJSON(atPeriodSet(Test_Scenic_Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}'))::json\n", - "SELECT asMFJSON(atPeriodSet(Test_Scenic_Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}'))::json From Test_Scenic_Item_General_Trajectory Where Test_Scenic_Item_General_Trajectory.objectType='vehicle.car';\n", - "\n" - ] - } - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": null, - "source": [ - "print(car_trajectories[0][0])" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 8, - "source": [ - "bboxes = scenic_world.predicate(lambda obj:obj.object_type == \"vehicle.car\").get_geo().execute()" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='object_type', ctx=Load()), ops=[Eq()], comparators=[Str(s='vehicle.car')]))])\n", - "Module(body=[Return(value=Compare(left=Call(func=Name(id='Tmin', ctx=Load()), args=[Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load())], keywords=[]), ops=[GtE()], comparators=[Name(id='start', ctx=Load())]))])\n", - "Module(body=[Return(value=Compare(left=Call(func=Name(id='Tmax', ctx=Load()), args=[Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load())], keywords=[]), ops=[Lt()], comparators=[Name(id='end', ctx=Load())]))])\n", - "Worlds Table created successfully........\n", - "New world inserted successfully........\n", - "Xmin(Test_Scenic_General_Bbox.trajBbox)\n", - "Ymin(Test_Scenic_General_Bbox.trajBbox)\n", - "Zmin(Test_Scenic_General_Bbox.trajBbox)\n", - "Xmax(Test_Scenic_General_Bbox.trajBbox)\n", - "Ymax(Test_Scenic_General_Bbox.trajBbox)\n", - "Zmax(Test_Scenic_General_Bbox.trajBbox)\n", - "SELECT Xmin(Test_Scenic_General_Bbox.trajBbox), Ymin(Test_Scenic_General_Bbox.trajBbox), Zmin(Test_Scenic_General_Bbox.trajBbox), Xmax(Test_Scenic_General_Bbox.trajBbox), Ymax(Test_Scenic_General_Bbox.trajBbox), Zmax(Test_Scenic_General_Bbox.trajBbox) From Test_Scenic_Item_General_Trajectory INNER JOIN Test_Scenic_General_Bbox USING(itemId) Where Test_Scenic_Item_General_Trajectory.objectType='vehicle.car' AND Tmin(Test_Scenic_General_Bbox.trajBbox)>='0001-01-01 00:00:00' AND Tmax(Test_Scenic_General_Bbox.trajBbox)<'9999-12-31 23:59:59.999999';\n", - "\n" - ] - } - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 9, - "source": [ - "bboxes.shape" - ], - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "(2004, 6)" - ] - }, - "metadata": {}, - "execution_count": 9 - } - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 13, - "source": [ - "import psycopg2\n", - "conn = psycopg2.connect(\n", - " database=\"mobilitydb\", user=\"docker\", password=\"docker\", host=\"localhost\", port=25432)" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 14, - "source": [ - "from scenic_util import *\n", - "export_tables(conn)" - ], - "outputs": [ - { - "output_type": "error", - "ename": "NameError", - "evalue": "name 'con' is not defined", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_31415/795569161.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mscenic_util\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mexport_tables\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcon\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mNameError\u001b[0m: name 'con' is not defined" - ] - } - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 15, - "source": [ - "cur = conn.cursor()\n", - "cur.execute(CREATE_CAMERA_SQL)\n", - "cur.execute(CREATE_BBOXES_SQL)\n", - "cur.execute(CREATE_ITEMTRAJ_SQL)\n", - "conn.commit()\n", - "with open('test_camera.csv', 'r') as camera_f:\n", - " cur.copy_expert(file=camera_f, sql=\"COPY test_scenic_cameras FROM STDIN CSV HEADER DELIMITER as ','\")\n", - "with open('test_trajectory.csv', 'r') as trajectory_f:\n", - " cur.copy_expert(file=trajectory_f, sql=\"COPY test_scenic_item_general_trajectory FROM STDIN CSV HEADER DELIMITER as ','\")\n", - "with open('test_bbox.csv', 'r') as bbox_f:\n", - " cur.copy_expert(file=bbox_f, sql=\"COPY test_scenic_general_bbox FROM STDIN CSV HEADER DELIMITER as ','\")\n", - "\n", - "conn.commit()" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": null, - "source": [], - "outputs": [], - "metadata": {} - } - ], - "metadata": { - "celltoolbar": "Raw Cell Format", - "interpreter": { - "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3.7.11 64-bit" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} \ No newline at end of file From 377ab124a8bcc60690416a1f8575abbfc9d287fb Mon Sep 17 00:00:00 2001 From: eeeeenchanted <597380714@qq.com> Date: Wed, 16 Feb 2022 16:40:39 -0800 Subject: [PATCH 11/26] Remove frameId from trajectory table --- apperception/scenic_util.py | 20 ++-- scenic_test.ipynb | 225 ++++++++++++++++++++++++++++++++++++ 2 files changed, 234 insertions(+), 11 deletions(-) create mode 100644 scenic_test.ipynb diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py index dd078b5b..3525cb6b 100644 --- a/apperception/scenic_util.py +++ b/apperception/scenic_util.py @@ -92,7 +92,7 @@ def create_or_insert_scenic_camera_table(conn, world_name, camera): Create and Populate A camera table with the given camera object. ''' #Doping Cameras table if already exists. - cursor.execute("DROP TABLE IF EXISTS Scenic_Cameras") + cursor.execute("DROP TABLE IF EXISTS Test_Scenic_Cameras") # Formal_Scenic_cameras table stands for the formal table which won't be erased # Test for now @@ -228,7 +228,6 @@ def scenic_recognize(scene_name, sample_data, annotation): if item_id not in annotations: annotations[item_id] = {'bboxes': [], 'frame_num': []} annotations[item_id]['object_type'] = ann['category'] - annotations[item_id]['frame_id'] = sample_token box = Box(ann['translation'], ann['size'], Quaternion(ann['rotation'])) @@ -253,7 +252,6 @@ def add_scenic_recognized_objs(conn, formatted_result, start_time, default_depth clean_scenic_tables(conn) for item_id in formatted_result: object_type = formatted_result[item_id]["object_type"] - frame_id = formatted_result[item_id]["frame_id"] recognized_bboxes = np.array(formatted_result[item_id]["bboxes"]) tracked_cnt = formatted_result[item_id]["frame_num"] top_left = np.vstack((recognized_bboxes[:,0,0], recognized_bboxes[:,0,1], recognized_bboxes[:,0,2])) @@ -277,11 +275,11 @@ def add_scenic_recognized_objs(conn, formatted_result, start_time, default_depth current_br = bottom_right[i] obj_traj.append([current_tl.tolist(), current_br.tolist()]) - scenic_bboxes_to_postgres(conn, item_id, object_type, frame_id, "default_color", start_time, tracked_cnt, obj_traj, type="yolov4") + scenic_bboxes_to_postgres(conn, item_id, object_type, "default_color", start_time, tracked_cnt, obj_traj, type="yolov4") # bbox_to_tasm() # Insert bboxes to postgres -def scenic_bboxes_to_postgres(conn, item_id, object_type, frame_id, color, start_time, timestamps, bboxes, type='yolov3'): +def scenic_bboxes_to_postgres(conn, item_id, object_type, color, start_time, timestamps, bboxes, type='yolov3'): if type == 'yolov3': timestamps = range(timestamps) @@ -292,12 +290,12 @@ def scenic_bboxes_to_postgres(conn, item_id, object_type, frame_id, color, start pairs.append(meta_box[0]) deltas.append(meta_box[1:]) postgres_timestamps = convert_timestamps(start_time, timestamps) - create_or_insert_scenic_general_trajectory(conn, item_id, object_type, frame_id, color, postgres_timestamps, bboxes, pairs) + create_or_insert_scenic_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs) # print(f"{item_id} saved successfully") # Create general trajectory table -def create_or_insert_scenic_general_trajectory(conn, item_id, object_type, frame_id, color, postgres_timestamps, bboxes, pairs): +def create_or_insert_scenic_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs): cursor = conn.cursor() ''' Create and Populate A Trajectory table using mobilityDB. @@ -319,11 +317,11 @@ def create_or_insert_scenic_general_trajectory(conn, item_id, object_type, frame cursor.execute("CREATE INDEX IF NOT EXISTS traj_bbox_idx ON Test_Scenic_General_Bbox USING GiST(trajBbox);") conn.commit() #Insert the trajectory of the first item - insert_scenic_general_trajectory(conn, item_id, object_type, frame_id, color, postgres_timestamps, bboxes, pairs) + insert_scenic_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs) # Insert general trajectory -def insert_scenic_general_trajectory(conn, item_id, object_type, frame_id, color, postgres_timestamps, bboxes, pairs): +def insert_scenic_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs): #Creating a cursor object using the cursor() method cursor = conn.cursor() #Inserting bboxes into Bbox table @@ -331,8 +329,8 @@ def insert_scenic_general_trajectory(conn, item_id, object_type, frame_id, color insert_format = "INSERT INTO Test_Scenic_General_Bbox (itemId, trajBbox) "+ \ "VALUES (\'%s\'," % (item_id) # Insert the item_trajectory separately - insert_trajectory = "INSERT INTO Test_Scenic_Item_General_Trajectory (itemId, objectType, frameId, color, trajCentroids, largestBbox) "+ \ - "VALUES (\'%s\', \'%s\', \'%s\', \'%s\', " % (item_id, object_type, frame_id, color) + insert_trajectory = "INSERT INTO Test_Scenic_Item_General_Trajectory (itemId, objectType, color, trajCentroids, largestBbox) "+ \ + "VALUES (\'%s\', \'%s\', \'%s\', " % (item_id, object_type, color) traj_centroids = "\'{" min_ltx, min_lty, min_ltz, max_brx, max_bry, max_brz = float('inf'), float('inf'), float('inf'), float('-inf'), float('-inf'), float('-inf') # max_ltx, max_lty, max_ltz, min_brx, min_bry, min_brz = float('-inf'), float('-inf'), float('-inf'), float('inf'), float('inf'), float('inf') diff --git a/scenic_test.ipynb b/scenic_test.ipynb new file mode 100644 index 00000000..05a8bb0f --- /dev/null +++ b/scenic_test.ipynb @@ -0,0 +1,225 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "7eb80154", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "sys.path.append(os.path.join(os.getcwd(),\"apperception\"))\n", + "\n", + "### IMPORTS\n", + "import cv2\n", + "\n", + "from scenic_world import *\n", + "from world_executor import *\n", + "from video_util import *\n", + "from metadata_util import *\n", + "import json\n", + "import pandas as pd\n", + "\n", + "from scenic_generate_df import *\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "adf1fe39", + "metadata": {}, + "outputs": [], + "source": [ + "### Let's define some attribute for constructing the world first\n", + "name = 'ScenicWorld' # world name\n", + "units = 'metrics' # world units\n", + "user_data_dir = os.path.join(\"v1.0-mini\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "95c03aab", + "metadata": {}, + "outputs": [], + "source": [ + "# generate dataframes from scenic json files\n", + "# takes 1min to run\n", + "df_sample_data, df_annotation = scenic_generate_df()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "42b23e21", + "metadata": {}, + "outputs": [], + "source": [ + "scenic_world = ScenicWorld(name=name, units=units)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d15ddef2", + "metadata": {}, + "outputs": [], + "source": [ + "### Ingest the camera to the world\n", + "scene_name = \"scene-0061\"\n", + "scenic_world = scenic_world.scenic_camera(scene_name)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "309003c4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Worlds Table created successfully........\n", + "New world inserted successfully........\n", + "Camera Table created successfully........\n", + "New camera inserted successfully.........\n", + "Recognization done, saving to database......\n" + ] + } + ], + "source": [ + "### Call execute on the world to run the detection algorithm and save the real data to the database\n", + "recognized_scenic_world = scenic_world.recognize(scene_name, df_sample_data, df_annotation)\n", + "recognized_scenic_world.execute()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "215c26b2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='object_type', ctx=Load()), ops=[Eq()], comparators=[Str(s='vehicle.car')]))])\n", + "Worlds Table created successfully........\n", + "New world inserted successfully........\n", + "atPeriodSet(Test_Scenic_Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}')\n", + "asMFJSON(atPeriodSet(Test_Scenic_Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}'))::json\n", + "SELECT asMFJSON(atPeriodSet(Test_Scenic_Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}'))::json From Test_Scenic_Item_General_Trajectory Where Test_Scenic_Item_General_Trajectory.objectType='vehicle.car';\n", + "\n" + ] + } + ], + "source": [ + "# the trajectory returned now includes the temporal info instead of just the spatio info\n", + "car_trajectories = scenic_world.predicate(lambda obj:obj.object_type == \"vehicle.car\").get_trajectory().execute()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "32275228", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'type': 'MovingPoint', 'coordinates': [[353.794, 1132.355, 0.602], [353.776, 1132.363, 0.622], [353.776, 1132.363, 0.622], [353.776, 1132.363, 0.622], [353.776, 1132.363, 0.622], [353.776, 1132.363, 0.622], [353.776, 1132.363, 0.622], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.741, 1132.378, 0.662], [353.741, 1132.378, 0.662], [353.741, 1132.378, 0.662], [353.741, 1132.378, 0.662], [353.741, 1132.378, 0.662], [353.741, 1132.378, 0.662], [353.724, 1132.385, 0.682], [353.724, 1132.385, 0.682], [353.724, 1132.385, 0.682], [353.724, 1132.385, 0.682], [353.724, 1132.385, 0.682], [353.724, 1132.385, 0.682], [353.755, 1132.372, 0.677], [353.755, 1132.372, 0.677], [353.755, 1132.372, 0.677], [353.755, 1132.372, 0.677], [353.755, 1132.372, 0.677], [353.786, 1132.358, 0.672], [353.786, 1132.358, 0.672], [353.786, 1132.358, 0.672], [353.786, 1132.358, 0.672], [353.786, 1132.358, 0.672], [353.786, 1132.358, 0.672], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.83, 1132.369, 0.737], [353.83, 1132.369, 0.737], [353.83, 1132.369, 0.737], [353.83, 1132.369, 0.737], [353.83, 1132.369, 0.737], [353.83, 1132.369, 0.737], [353.905, 1132.296, 0.77], [353.905, 1132.296, 0.77], [353.905, 1132.296, 0.77], [353.905, 1132.296, 0.77], [353.905, 1132.296, 0.77], [353.905, 1132.296, 0.77], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.906, 1132.322, 0.859], [353.906, 1132.322, 0.859], [353.906, 1132.322, 0.859], [353.906, 1132.322, 0.859], [353.906, 1132.322, 0.859], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.924, 1132.329, 1.151], [353.924, 1132.329, 1.151], [353.924, 1132.329, 1.151], [353.924, 1132.329, 1.151], [353.924, 1132.329, 1.151], [353.924, 1132.329, 1.151], [354.008, 1132.468, 1.186], [354.008, 1132.468, 1.186], [354.008, 1132.468, 1.186], [354.008, 1132.468, 1.186], [354.008, 1132.468, 1.186], [354.008, 1132.468, 1.186], [354.035, 1132.468, 1.196], [354.035, 1132.468, 1.196], [354.035, 1132.468, 1.196], [354.035, 1132.468, 1.196], [354.035, 1132.468, 1.196], [354.063, 1132.468, 1.206], [354.063, 1132.468, 1.206], [354.063, 1132.468, 1.206], [354.063, 1132.468, 1.206], [354.063, 1132.468, 1.206], [354.091, 1132.468, 1.216], [354.091, 1132.468, 1.216], [354.091, 1132.468, 1.216], [354.091, 1132.468, 1.216], [354.091, 1132.468, 1.216], [354.091, 1132.468, 1.216], [354.038, 1132.593, 1.366], [354.038, 1132.593, 1.366], [354.038, 1132.593, 1.366], [354.038, 1132.593, 1.366], [354.038, 1132.593, 1.366], [354.038, 1132.593, 1.366], [354.104, 1132.795, 1.367], [354.104, 1132.795, 1.367], [354.104, 1132.795, 1.367], [354.104, 1132.795, 1.367], [354.104, 1132.795, 1.367], [354.104, 1132.795, 1.367], [354.026, 1132.642, 1.267], [354.026, 1132.642, 1.267], [354.026, 1132.642, 1.267], [354.026, 1132.642, 1.267], [354.026, 1132.642, 1.267], [354.02, 1132.667, 1.28], [354.02, 1132.667, 1.28], [354.02, 1132.667, 1.28], [354.02, 1132.667, 1.28], [354.02, 1132.667, 1.28], [354.02, 1132.667, 1.28], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.009, 1132.716, 1.307], [354.009, 1132.716, 1.307], [354.009, 1132.716, 1.307], [354.009, 1132.716, 1.307], [354.009, 1132.716, 1.307], [354.009, 1132.716, 1.307], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [353.997, 1132.765, 1.333], [353.997, 1132.765, 1.333], [353.997, 1132.765, 1.333], [353.997, 1132.765, 1.333], [353.997, 1132.765, 1.333], [353.997, 1132.765, 1.333], [353.991, 1132.79, 1.346], [353.991, 1132.79, 1.346], [353.991, 1132.79, 1.346], [353.991, 1132.79, 1.346], [353.991, 1132.79, 1.346], [353.991, 1132.79, 1.346], [353.985, 1132.815, 1.359], [353.985, 1132.815, 1.359], [353.985, 1132.815, 1.359], [353.985, 1132.815, 1.359], [353.985, 1132.815, 1.359], [353.979, 1132.839, 1.372], [353.979, 1132.839, 1.372], [353.979, 1132.839, 1.372], [353.979, 1132.839, 1.372], [353.979, 1132.839, 1.372], [353.973, 1132.864, 1.346], [353.973, 1132.864, 1.346], [353.973, 1132.864, 1.346], [353.973, 1132.864, 1.346], [353.973, 1132.864, 1.346], [353.973, 1132.864, 1.346], [353.967, 1132.889, 1.32], [353.967, 1132.889, 1.32], [353.967, 1132.889, 1.32], [353.967, 1132.889, 1.32], [353.967, 1132.889, 1.32], [353.967, 1132.889, 1.32], [353.961, 1132.913, 1.294], [353.961, 1132.913, 1.294], [353.961, 1132.913, 1.294], [353.961, 1132.913, 1.294], [353.961, 1132.913, 1.294], [353.961, 1132.913, 1.294], [353.956, 1132.938, 1.268], [353.956, 1132.938, 1.268], [353.956, 1132.938, 1.268], [353.956, 1132.938, 1.268], [353.956, 1132.938, 1.268], [353.956, 1132.938, 1.268], [353.95, 1132.963, 1.242], [353.95, 1132.963, 1.242], [353.95, 1132.963, 1.242], [353.95, 1132.963, 1.242], [353.95, 1132.963, 1.242], [353.944, 1132.987, 1.216], [353.944, 1132.987, 1.216], [353.944, 1132.987, 1.216], [353.944, 1132.987, 1.216], [353.944, 1132.987, 1.216], [353.944, 1132.987, 1.216]], 'datetimes': ['2021-06-08T07:10:29+00', '2021-06-08T07:10:30+00', '2021-06-08T07:10:31+00', '2021-06-08T07:10:32+00', '2021-06-08T07:10:33+00', '2021-06-08T07:10:34+00', '2021-06-08T07:10:35+00', '2021-06-08T07:10:36+00', '2021-06-08T07:10:37+00', '2021-06-08T07:10:38+00', '2021-06-08T07:10:39+00', '2021-06-08T07:10:40+00', '2021-06-08T07:10:41+00', '2021-06-08T07:10:42+00', '2021-06-08T07:10:43+00', '2021-06-08T07:10:44+00', '2021-06-08T07:10:45+00', '2021-06-08T07:10:46+00', '2021-06-08T07:10:47+00', '2021-06-08T07:10:48+00', '2021-06-08T07:10:49+00', '2021-06-08T07:10:50+00', '2021-06-08T07:10:51+00', '2021-06-08T07:10:52+00', '2021-06-08T07:10:53+00', '2021-06-08T07:10:54+00', '2021-06-08T07:10:55+00', '2021-06-08T07:10:56+00', '2021-06-08T07:10:57+00', '2021-06-08T07:10:58+00', '2021-06-08T07:10:59+00', '2021-06-08T07:11:00+00', '2021-06-08T07:11:01+00', '2021-06-08T07:11:02+00', '2021-06-08T07:11:03+00', '2021-06-08T07:11:04+00', '2021-06-08T07:11:05+00', '2021-06-08T07:11:06+00', '2021-06-08T07:11:07+00', '2021-06-08T07:11:08+00', '2021-06-08T07:11:09+00', '2021-06-08T07:11:10+00', '2021-06-08T07:11:11+00', '2021-06-08T07:11:12+00', '2021-06-08T07:11:13+00', '2021-06-08T07:11:14+00', '2021-06-08T07:11:15+00', '2021-06-08T07:11:16+00', '2021-06-08T07:11:17+00', '2021-06-08T07:11:18+00', '2021-06-08T07:11:19+00', '2021-06-08T07:11:20+00', '2021-06-08T07:11:21+00', '2021-06-08T07:11:22+00', '2021-06-08T07:11:23+00', '2021-06-08T07:11:24+00', '2021-06-08T07:11:25+00', '2021-06-08T07:11:26+00', '2021-06-08T07:11:27+00', '2021-06-08T07:11:28+00', '2021-06-08T07:11:29+00', '2021-06-08T07:11:30+00', '2021-06-08T07:11:31+00', '2021-06-08T07:11:32+00', '2021-06-08T07:11:33+00', '2021-06-08T07:11:34+00', '2021-06-08T07:11:35+00', '2021-06-08T07:11:36+00', '2021-06-08T07:11:37+00', '2021-06-08T07:11:38+00', '2021-06-08T07:11:39+00', '2021-06-08T07:11:40+00', '2021-06-08T07:11:41+00', '2021-06-08T07:11:42+00', '2021-06-08T07:11:43+00', '2021-06-08T07:11:44+00', '2021-06-08T07:11:45+00', '2021-06-08T07:11:46+00', '2021-06-08T07:11:47+00', '2021-06-08T07:11:48+00', '2021-06-08T07:11:49+00', '2021-06-08T07:11:50+00', '2021-06-08T07:11:51+00', '2021-06-08T07:11:52+00', '2021-06-08T07:11:53+00', '2021-06-08T07:11:54+00', '2021-06-08T07:11:55+00', '2021-06-08T07:11:56+00', '2021-06-08T07:11:57+00', '2021-06-08T07:11:58+00', '2021-06-08T07:11:59+00', '2021-06-08T07:12:00+00', '2021-06-08T07:12:01+00', '2021-06-08T07:12:02+00', '2021-06-08T07:12:03+00', '2021-06-08T07:12:04+00', '2021-06-08T07:12:05+00', '2021-06-08T07:12:06+00', '2021-06-08T07:12:07+00', '2021-06-08T07:12:08+00', '2021-06-08T07:12:09+00', '2021-06-08T07:12:10+00', '2021-06-08T07:12:11+00', '2021-06-08T07:12:12+00', '2021-06-08T07:12:13+00', '2021-06-08T07:12:14+00', '2021-06-08T07:12:15+00', '2021-06-08T07:12:16+00', '2021-06-08T07:12:17+00', '2021-06-08T07:12:18+00', '2021-06-08T07:12:19+00', '2021-06-08T07:12:20+00', '2021-06-08T07:12:21+00', '2021-06-08T07:12:22+00', '2021-06-08T07:12:23+00', '2021-06-08T07:12:24+00', '2021-06-08T07:12:25+00', '2021-06-08T07:12:26+00', '2021-06-08T07:12:27+00', '2021-06-08T07:12:28+00', '2021-06-08T07:12:29+00', '2021-06-08T07:12:30+00', '2021-06-08T07:12:31+00', '2021-06-08T07:12:32+00', '2021-06-08T07:12:33+00', '2021-06-08T07:12:34+00', '2021-06-08T07:12:35+00', '2021-06-08T07:12:36+00', '2021-06-08T07:12:37+00', '2021-06-08T07:12:38+00', '2021-06-08T07:12:39+00', '2021-06-08T07:12:40+00', '2021-06-08T07:12:41+00', '2021-06-08T07:12:42+00', '2021-06-08T07:12:43+00', '2021-06-08T07:12:44+00', '2021-06-08T07:12:45+00', '2021-06-08T07:12:46+00', '2021-06-08T07:12:47+00', '2021-06-08T07:12:48+00', '2021-06-08T07:12:49+00', '2021-06-08T07:12:50+00', '2021-06-08T07:12:51+00', '2021-06-08T07:12:52+00', '2021-06-08T07:12:53+00', '2021-06-08T07:12:54+00', '2021-06-08T07:12:55+00', '2021-06-08T07:12:56+00', '2021-06-08T07:12:57+00', '2021-06-08T07:12:58+00', '2021-06-08T07:12:59+00', '2021-06-08T07:13:00+00', '2021-06-08T07:13:01+00', '2021-06-08T07:13:02+00', '2021-06-08T07:13:03+00', '2021-06-08T07:13:04+00', '2021-06-08T07:13:05+00', '2021-06-08T07:13:06+00', '2021-06-08T07:13:07+00', '2021-06-08T07:13:08+00', '2021-06-08T07:13:09+00', '2021-06-08T07:13:10+00', '2021-06-08T07:13:11+00', '2021-06-08T07:13:12+00', '2021-06-08T07:13:13+00', '2021-06-08T07:13:14+00', '2021-06-08T07:13:15+00', '2021-06-08T07:13:16+00', '2021-06-08T07:13:17+00', '2021-06-08T07:13:18+00', '2021-06-08T07:13:19+00', '2021-06-08T07:13:20+00', '2021-06-08T07:13:21+00', '2021-06-08T07:13:22+00', '2021-06-08T07:13:23+00', '2021-06-08T07:13:24+00', '2021-06-08T07:13:25+00', '2021-06-08T07:13:26+00', '2021-06-08T07:13:27+00', '2021-06-08T07:13:28+00', '2021-06-08T07:13:29+00', '2021-06-08T07:13:30+00', '2021-06-08T07:13:31+00', '2021-06-08T07:13:32+00', '2021-06-08T07:13:33+00', '2021-06-08T07:13:34+00', '2021-06-08T07:13:35+00', '2021-06-08T07:13:36+00', '2021-06-08T07:13:37+00', '2021-06-08T07:13:38+00', '2021-06-08T07:13:39+00', '2021-06-08T07:13:40+00', '2021-06-08T07:13:41+00', '2021-06-08T07:13:42+00', '2021-06-08T07:13:43+00', '2021-06-08T07:13:44+00', '2021-06-08T07:13:45+00', '2021-06-08T07:13:46+00', '2021-06-08T07:13:47+00', '2021-06-08T07:13:48+00', '2021-06-08T07:13:49+00', '2021-06-08T07:13:50+00', '2021-06-08T07:13:51+00', '2021-06-08T07:13:52+00', '2021-06-08T07:13:53+00', '2021-06-08T07:13:54+00', '2021-06-08T07:13:55+00', '2021-06-08T07:13:56+00', '2021-06-08T07:13:57+00', '2021-06-08T07:13:58+00', '2021-06-08T07:13:59+00', '2021-06-08T07:14:00+00'], 'interpolations': ['Discrete']}\n" + ] + } + ], + "source": [ + "print(car_trajectories[0][0])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f9a8f36b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='object_type', ctx=Load()), ops=[Eq()], comparators=[Str(s='vehicle.car')]))])\n", + "Module(body=[Return(value=Compare(left=Call(func=Name(id='Tmin', ctx=Load()), args=[Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load())], keywords=[]), ops=[GtE()], comparators=[Name(id='start', ctx=Load())]))])\n", + "Module(body=[Return(value=Compare(left=Call(func=Name(id='Tmax', ctx=Load()), args=[Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load())], keywords=[]), ops=[Lt()], comparators=[Name(id='end', ctx=Load())]))])\n", + "Worlds Table created successfully........\n", + "New world inserted successfully........\n", + "Xmin(Test_Scenic_General_Bbox.trajBbox)\n", + "Ymin(Test_Scenic_General_Bbox.trajBbox)\n", + "Zmin(Test_Scenic_General_Bbox.trajBbox)\n", + "Xmax(Test_Scenic_General_Bbox.trajBbox)\n", + "Ymax(Test_Scenic_General_Bbox.trajBbox)\n", + "Zmax(Test_Scenic_General_Bbox.trajBbox)\n", + "SELECT Xmin(Test_Scenic_General_Bbox.trajBbox), Ymin(Test_Scenic_General_Bbox.trajBbox), Zmin(Test_Scenic_General_Bbox.trajBbox), Xmax(Test_Scenic_General_Bbox.trajBbox), Ymax(Test_Scenic_General_Bbox.trajBbox), Zmax(Test_Scenic_General_Bbox.trajBbox) From Test_Scenic_Item_General_Trajectory INNER JOIN Test_Scenic_General_Bbox USING(itemId) Where Test_Scenic_Item_General_Trajectory.objectType='vehicle.car' AND Tmin(Test_Scenic_General_Bbox.trajBbox)>='0001-01-01 00:00:00' AND Tmax(Test_Scenic_General_Bbox.trajBbox)<'9999-12-31 23:59:59.999999';\n", + "\n" + ] + } + ], + "source": [ + "bboxes = scenic_world.predicate(lambda obj:obj.object_type == \"vehicle.car\").get_geo().execute()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "53bed3ac", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(2004, 6)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bboxes.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6bee4c8f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "celltoolbar": "Raw Cell Format", + "interpreter": { + "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" + }, + "kernelspec": { + "display_name": "Python 3.7.11 64-bit", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From edd43a4b081f7bf20f65bc9de58553ce9724927f Mon Sep 17 00:00:00 2001 From: eeeeenchanted <597380714@qq.com> Date: Tue, 22 Feb 2022 20:29:24 -0800 Subject: [PATCH 12/26] transform 3d to 2d --- apperception/scenic_util.py | 46 ++++++++++++++++++++++++++++--------- 1 file changed, 35 insertions(+), 11 deletions(-) diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py index 3525cb6b..0033d13e 100644 --- a/apperception/scenic_util.py +++ b/apperception/scenic_util.py @@ -178,12 +178,12 @@ def insert_scenic_data(scenic_data_dir, db): db['frame_num'].insert_many(frame_num_json) db['frame_num'].create_index('token') -def transform_box(box: Box, camera, ego_pose): - box.translate(-np.array(ego_pose['translation'])) - box.rotate(Quaternion(ego_pose['rotation']).inverse) +def transform_box(box: Box, camera): + box.translate(-np.array(camera['egoTranslation'])) + box.rotate(Quaternion(camera['egoRotation']).inverse) - box.translate(-np.array(camera['translation'])) - box.rotate(Quaternion(camera['rotation']).inverse) + box.translate(-np.array(camera['cameraTranslation'])) + box.rotate(Quaternion(camera['cameraRotation']).inverse) # import matplotlib.pyplot as plt # def overlay_bbox(image, corners): @@ -222,7 +222,13 @@ def scenic_recognize(scene_name, sample_data, annotation): sample_token = img_file['sample_token'] frame_num = img_file['frame_order'] all_annotations = annotation[annotation['sample_token'] == sample_token] - + # camera_info = {} + # camera_info['cameraTranslation'] = img_file['camera_translation'] + # camera_info['cameraRotation'] = img_file['camera_rotation'] + # camera_info['cameraIntrinsic'] = np.array(img_file['camera_intrinsic']) + # camera_info['egoRotation'] = img_file['ego_rotation'] + # camera_info['egoTranslation'] = img_file['ego_translation'] + for _, ann in all_annotations.iterrows(): item_id = ann['instance_token'] if item_id not in annotations: @@ -234,10 +240,11 @@ def scenic_recognize(scene_name, sample_data, annotation): corners = box.corners() # if item_id == '6dd2cbf4c24b4caeb625035869bca7b5': - # print("corners", corners) - # transform_box(box, camera_info, ego_pose) - # print("transformed box: ", box.corners()) - # corners_2d = box.map_2d(np.array(camera_info['camera_intrinsic'])) + # # print("corners", corners) + # # transform_box(box, camera_info) + # # print("transformed box: ", box.corners()) + # # corners_2d = box.map_2d(np.array(camera_info['cameraIntrinsic'])) + # corners_2d = transformation(box.center, camera_info) # print("2d_corner: ", corners_2d) # overlay_bbox("v1.0-mini/samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg", corners_2d) @@ -365,7 +372,24 @@ def transformation(centroid_3d, camera_config): ''' TODO: transformation from 3d world coordinate to 2d frame coordinate given the camera config ''' - pass + centroid_3d -= camera_config['egoTranslation'] + centroid_3d = np.dot(Quaternion(camera_config['egoRotation']).inverse.rotation_matrix, centroid_3d) + + centroid_3d -= camera_config['cameraTranslation'] + centroid_3d = np.dot(Quaternion(camera_config['cameraRotation']).inverse.rotation_matrix, centroid_3d) + + view = camera_config['cameraIntrinsic'] + viewpad = np.eye(4) + viewpad[:view.shape[0], :view.shape[1]] = view + + # Do operation in homogenous coordinates. + centroid_3d = centroid_3d.reshape((3, 1)) + centroid_3d = np.concatenate((centroid_3d, np.ones((1, 1)))) + centroid_3d = np.dot(viewpad, centroid_3d) + centroid_3d = centroid_3d[:3, :] + + centroid_3d = centroid_3d / centroid_3d[2:3, :].repeat(3, 0).reshape(3, 1) + return centroid_3d[:2, :] def fetch_camera(conn, scene_name, frame_num): ''' From a02bde133367abbf05206c5a914db2e57a24e7d9 Mon Sep 17 00:00:00 2001 From: Jim Lin Date: Sat, 26 Feb 2022 01:56:59 +0800 Subject: [PATCH 13/26] fix a wrong tag and delete mongoclient --- apperception/scenic_util.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py index 0033d13e..07a33cc8 100644 --- a/apperception/scenic_util.py +++ b/apperception/scenic_util.py @@ -5,7 +5,6 @@ import cv2 # from object_tracker import yolov4_deepsort_video_track from video_util import * -from pymongo import MongoClient from pyquaternion import Quaternion import json import os @@ -446,7 +445,7 @@ def export_tables(conn): db_cursor.copy_expert(SQL_camera_output, camera_output) def import_tables(conn): - cur = conn.cursor() + cur = conn.cursor() cur.execute(CREATE_CAMERA_SQL) cur.execute(CREATE_ITEMTRAJ_SQL) cur.execute(CREATE_BBOXES_SQL) From 6c4c7b4a6cdf351e0f8826ed33554a3d1676df1b Mon Sep 17 00:00:00 2001 From: "Chanwut (Mick) Kittivorawong" Date: Sat, 26 Feb 2022 16:07:27 -0800 Subject: [PATCH 14/26] XinyiJi1: Doverlay, with bug of sql --- apperception/scenic_util.py | 17 +- apperception/scenic_world.py | 42 +- scenic_test.ipynb | 4334 +++++++++++++++++++++++++++++++++- 3 files changed, 4340 insertions(+), 53 deletions(-) diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py index 07a33cc8..39d67939 100644 --- a/apperception/scenic_util.py +++ b/apperception/scenic_util.py @@ -5,6 +5,7 @@ import cv2 # from object_tracker import yolov4_deepsort_video_track from video_util import * +from pymongo import MongoClient from pyquaternion import Quaternion import json import os @@ -399,13 +400,15 @@ def fetch_camera(conn, scene_name, frame_num): ''' cursor = conn.cursor() - - if cam_id == []: - query = '''SELECT cameraId, ratio, ST_X(origin), ST_Y(origin), ST_Z(origin), ST_X(focalpoints), ST_Y(focalpoints), fov, skev_factor ''' \ - + '''FROM Cameras WHERE worldId = \'%s\';''' %world_id - else: - query = '''SELECT cameraId, ratio, ST_X(origin), ST_Y(origin), ST_Z(origin), ST_X(focalpoints), ST_Y(focalpoints), fov, skev_factor ''' \ - + '''FROM Cameras WHERE cameraId IN (\'%s\') AND worldId = \'%s\';''' %(','.join(cam_id), world_id) + # query = '''SELECT camera_info from camera_table where camera_table.camera_id == scene_name and camera_table.frame_num in frame_num''' + # if cam_id == []: + # query = '''SELECT cameraId, ratio, ST_X(origin), ST_Y(origin), ST_Z(origin), ST_X(focalpoints), ST_Y(focalpoints), fov, skev_factor ''' \ + # + '''FROM Cameras WHERE worldId = \'%s\';''' %world_id + # else: + # query = '''SELECT cameraId, ratio, ST_X(origin), ST_Y(origin), ST_Z(origin), ST_X(focalpoints), ST_Y(focalpoints), fov, skev_factor ''' \ + # + '''FROM Cameras WHERE cameraId IN (\'%s\') AND worldId = \'%s\';''' %(','.join(cam_id), world_id) + query = '''SELECT cameraId, egoTranslation, egoRotation, cameraTranslation, cameraRotation, cameraIntrinsic, frameNum, fileName ''' \ + + '''FROM Test_Scenic_Cameras WHERE cameraId = '{}' AND frameNum IN {};'''.format(scene_name, tuple(frame_num) ) cursor.execute(query) return cursor.fetchall() diff --git a/apperception/scenic_world.py b/apperception/scenic_world.py index 9e7412ee..9735b1cc 100644 --- a/apperception/scenic_world.py +++ b/apperception/scenic_world.py @@ -5,6 +5,7 @@ import copy from scenic_world_executer import ScenicWorldExecutor import matplotlib.pyplot as plt +from scenic_util import * BASE_VOLUME_QUERY_TEXT = "stbox \'STBOX Z(({x1}, {y1}, {z1}),({x2}, {y2}, {z2}))\'" scenic_world_executor = ScenicWorldExecutor() @@ -161,7 +162,14 @@ def scenic_trajectory_to_frame_num(self, trajectory): Refer to 'convert_datetime_to_frame_num' in 'video_util.py' 3. return the frame number ''' - + frame_num = [] + start_time = self.MetadataContext.start_time + for traj in trajectory: + current_trajectory = traj[0] + date_times =current_trajectory['datetimes'] + frame_num.append([(datetime.datetime.strptime(t, "%Y-%m-%dT%H:%M:%S+00").replace(tzinfo = None) - start_time).total_seconds() for t in date_times]) + return frame_num + def get_overlay_info(self, trajectory, camera_info): ''' TODO: overlay each trajectory 3d coordinate on to the frame specified by the camera_info @@ -172,12 +180,40 @@ def get_overlay_info(self, trajectory, camera_info): refer to TODO in "senic_utils.py" 4. return a list of (2d coordinate, frame name/filename) ''' - pass + result = [] + for traj_num in range(len(trajectory)): + traj_obj = trajectory[traj_num][0] # traj_obj means the trajectory of current object + traj_obj_3d = traj_obj['coordinates'] # 3d coordinate list of the object's trajectory + camera_info_obj = camera_info[traj_num] # camera info list corresponding the 3d coordinate + traj_obj_2d = [] # 2d coordinate list + for index in range(len(camera_info_obj)): + cur_camera_info = camera_info_obj[index] # camera info of the obejct in one point of the trajectory + centroid_3d = traj_obj_3d[index] # one point of the trajectory in 3d + # in order to fit into the function transformation, we develop a dictionary called camera_config + camera_config = {} + camera_config['egoTranslation'] = cur_camera_info[1] + print(type(camera_config["egoTranslation"])) + camera_config['egoRotation'] = cur_camera_info[2] + camera_config['cameraTranslation'] = cur_camera_info[3] + camera_config['cameraRotation'] = cur_camera_info[4] + camera_config['cameraIntrinsic'] =cur_camera_info[5] + traj_2d = transformation(centroid_3d, camera_config) # one point of the trajectory in 2d + + framenum = cur_camera_info[6] + filename = cur_camera_info[7] + traj_obj_2d.append((traj_2d, framenum, filename)) + result.append(traj_obj_2d) + return result + def scenic_overlay_trajectory(self, scene_name, trajectory): frame_num = self.scenic_trajectory_to_frame_num(trajectory) - camera_info = self.get_camera(scene_name, frame_num) ### TODO: fetch_camera_info in scenic_utils.py + # frame_num is int[[]], hence camera_info should also be [[]] + camera_info = [] + for cur_frame_num in frame_num: + camera_info.append(self.get_camera(scene_name, cur_frame_num)) ### TODO: fetch_camera_info in scenic_utils.py assert len(camera_info) == len(frame_num) + assert len(camera_info[0]) == len(frame_num[0]) overlay_info = self.get_overlay_info(trajectory, camera_info) ### TODO: fix the following to overlay the 2d point onto the frame for traj in trajectory: diff --git a/scenic_test.ipynb b/scenic_test.ipynb index 05a8bb0f..38c8011b 100644 --- a/scenic_test.ipynb +++ b/scenic_test.ipynb @@ -3,7 +3,6 @@ { "cell_type": "code", "execution_count": 1, - "id": "7eb80154", "metadata": {}, "outputs": [], "source": [ @@ -27,7 +26,6 @@ { "cell_type": "code", "execution_count": 2, - "id": "adf1fe39", "metadata": {}, "outputs": [], "source": [ @@ -40,7 +38,6 @@ { "cell_type": "code", "execution_count": 3, - "id": "95c03aab", "metadata": {}, "outputs": [], "source": [ @@ -52,7 +49,538 @@ { "cell_type": "code", "execution_count": 4, - "id": "42b23e21", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tokensample_tokentimestampfilenamecamera_translationcamera_rotationcamera_intrinsicego_rotationego_translationscene_nameframe_order
0512015c209c1490f906982c3b182c2a839586f9d59004284a7114a68825e8eec1532402927762460sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800...[1.70079118954, 0.0159456324149, 1.51095763913][0.4998015430569128, -0.5030316162024876, 0.49...[[1266.417203046554, 0.0, 816.2670197447984], ...[0.5731318069963492, -0.001008743951274553, 0....[410.9433704785875, 1179.9098624203461, 0.0]scene-00613
14c48e46e76b74a4c895b906418f79e4b356d81f38dd9473ba590f39e266f54e51532402928412460sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800...[1.70079118954, 0.0159456324149, 1.51095763913][0.4998015430569128, -0.5030316162024876, 0.49...[[1266.417203046554, 0.0, 816.2670197447984], ...[0.5756004222270319, 0.002468184877516363, 0.0...[408.9502699908764, 1174.4933020919336, 0.0]scene-006111
231280aeef5f04d3cb00724081dcca0e4e0845f5322254dafadbbed75aaa079691532402929112460sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800...[1.70079118954, 0.0159456324149, 1.51095763913][0.4998015430569128, -0.5030316162024876, 0.49...[[1266.417203046554, 0.0, 816.2670197447984], ...[0.5812651129089583, 0.0004956185578443312, 0....[406.9547611089034, 1168.8764471325978, 0.0]scene-006119
331b823dfb6bc489e8c85272ef027dedaf1e3d9d08f044c439ce86a2d6fcca57b1532402929762460sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800...[1.70079118954, 0.0159456324149, 1.51095763913][0.4998015430569128, -0.5030316162024876, 0.49...[[1266.417203046554, 0.0, 816.2670197447984], ...[0.5839935942635103, 0.0001221605241272317, 0....[405.242155872287, 1163.862806857947, 0.0]scene-006127
41464f2f69fc54d469a9810ef776550984f545737bf3347fbbc9af60b0be9a9631532402930412460sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800...[1.70079118954, 0.0159456324149, 1.51095763913][0.4998015430569128, -0.5030316162024876, 0.49...[[1266.417203046554, 0.0, 816.2670197447984], ...[0.5881335809828381, -0.0009546940046563173, 0...[403.6676139166417, 1159.200310831268, 0.0]scene-006135
....................................
140032f0c41630ed049c79d2c9713b62293ac8336b62c3f6f4bb988c3865cc5df44461542801004604844sweeps/CAM_FRONT_LEFT/n015-2018-11-21-19-38-26...[1.52387798135, 0.494631336551, 1.50932822144][0.6757265034669446, -0.6736266522251881, 0.21...[[1272.5979470598488, 0.0, 826.6154927353808],...[0.21734463639137175, 0.021947100873110408, 0....[1320.4899619460525, 903.2850514824449, 0.0]scene-1100199
140040d0438d077e3481db68b8c04de06cf838cc06390249d4895b5b9b860f0952f241542801005254844sweeps/CAM_FRONT_LEFT/n015-2018-11-21-19-38-26...[1.52387798135, 0.494631336551, 1.50932822144][0.6757265034669446, -0.6736266522251881, 0.21...[[1272.5979470598488, 0.0, 826.6154927353808],...[0.21734590189901404, 0.02201001850017383, 0.0...[1320.4899769167264, 903.2850689140539, 0.0]scene-1100207
140050247ec5fa603476a9c9f5b8da9a422add7cb9aa06de1442d8e2a22d562045cb41542801005904844samples/CAM_FRONT_LEFT/n015-2018-11-21-19-38-2...[1.52387798135, 0.494631336551, 1.50932822144][0.6757265034669446, -0.6736266522251881, 0.21...[[1272.5979470598488, 0.0, 826.6154927353808],...[0.21736779146486868, 0.02205034298791243, 0.0...[1320.4899595637255, 903.2850693428472, 0.0]scene-1100215
14006276a3634d746414a8e06cb7ca9e727a20d6668bcb0644bbaaee81c17cc3088451542801006604844sweeps/CAM_FRONT_LEFT/n015-2018-11-21-19-38-26...[1.52387798135, 0.494631336551, 1.50932822144][0.6757265034669446, -0.6736266522251881, 0.21...[[1272.5979470598488, 0.0, 826.6154927353808],...[0.21735700739688674, 0.022021890759692117, 0....[1320.4898559087292, 903.2850283180987, 0.0]scene-1100223
14007708c25a86d314da5b62197d7064bd339abf3d91d3c28407e80e3334fe89c03cb1542801007254844sweeps/CAM_FRONT_LEFT/n015-2018-11-21-19-38-26...[1.52387798135, 0.494631336551, 1.50932822144][0.6757265034669446, -0.6736266522251881, 0.21...[[1272.5979470598488, 0.0, 826.6154927353808],...[0.21733320983121257, 0.022053796274396114, 0....[1320.4899565014946, 903.2850811527192, 0.0]scene-1100231
\n", + "

14008 rows × 11 columns

\n", + "
" + ], + "text/plain": [ + " token sample_token \\\n", + "0 512015c209c1490f906982c3b182c2a8 39586f9d59004284a7114a68825e8eec \n", + "1 4c48e46e76b74a4c895b906418f79e4b 356d81f38dd9473ba590f39e266f54e5 \n", + "2 31280aeef5f04d3cb00724081dcca0e4 e0845f5322254dafadbbed75aaa07969 \n", + "3 31b823dfb6bc489e8c85272ef027deda f1e3d9d08f044c439ce86a2d6fcca57b \n", + "4 1464f2f69fc54d469a9810ef77655098 4f545737bf3347fbbc9af60b0be9a963 \n", + "... ... ... \n", + "14003 2f0c41630ed049c79d2c9713b62293ac 8336b62c3f6f4bb988c3865cc5df4446 \n", + "14004 0d0438d077e3481db68b8c04de06cf83 8cc06390249d4895b5b9b860f0952f24 \n", + "14005 0247ec5fa603476a9c9f5b8da9a422ad d7cb9aa06de1442d8e2a22d562045cb4 \n", + "14006 276a3634d746414a8e06cb7ca9e727a2 0d6668bcb0644bbaaee81c17cc308845 \n", + "14007 708c25a86d314da5b62197d7064bd339 abf3d91d3c28407e80e3334fe89c03cb \n", + "\n", + " timestamp filename \\\n", + "0 1532402927762460 sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800... \n", + "1 1532402928412460 sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800... \n", + "2 1532402929112460 sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800... \n", + "3 1532402929762460 sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800... \n", + "4 1532402930412460 sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800... \n", + "... ... ... \n", + "14003 1542801004604844 sweeps/CAM_FRONT_LEFT/n015-2018-11-21-19-38-26... \n", + "14004 1542801005254844 sweeps/CAM_FRONT_LEFT/n015-2018-11-21-19-38-26... \n", + "14005 1542801005904844 samples/CAM_FRONT_LEFT/n015-2018-11-21-19-38-2... \n", + "14006 1542801006604844 sweeps/CAM_FRONT_LEFT/n015-2018-11-21-19-38-26... \n", + "14007 1542801007254844 sweeps/CAM_FRONT_LEFT/n015-2018-11-21-19-38-26... \n", + "\n", + " camera_translation \\\n", + "0 [1.70079118954, 0.0159456324149, 1.51095763913] \n", + "1 [1.70079118954, 0.0159456324149, 1.51095763913] \n", + "2 [1.70079118954, 0.0159456324149, 1.51095763913] \n", + "3 [1.70079118954, 0.0159456324149, 1.51095763913] \n", + "4 [1.70079118954, 0.0159456324149, 1.51095763913] \n", + "... ... \n", + "14003 [1.52387798135, 0.494631336551, 1.50932822144] \n", + "14004 [1.52387798135, 0.494631336551, 1.50932822144] \n", + "14005 [1.52387798135, 0.494631336551, 1.50932822144] \n", + "14006 [1.52387798135, 0.494631336551, 1.50932822144] \n", + "14007 [1.52387798135, 0.494631336551, 1.50932822144] \n", + "\n", + " camera_rotation \\\n", + "0 [0.4998015430569128, -0.5030316162024876, 0.49... \n", + "1 [0.4998015430569128, -0.5030316162024876, 0.49... \n", + "2 [0.4998015430569128, -0.5030316162024876, 0.49... \n", + "3 [0.4998015430569128, -0.5030316162024876, 0.49... \n", + "4 [0.4998015430569128, -0.5030316162024876, 0.49... \n", + "... ... \n", + "14003 [0.6757265034669446, -0.6736266522251881, 0.21... \n", + "14004 [0.6757265034669446, -0.6736266522251881, 0.21... \n", + "14005 [0.6757265034669446, -0.6736266522251881, 0.21... \n", + "14006 [0.6757265034669446, -0.6736266522251881, 0.21... \n", + "14007 [0.6757265034669446, -0.6736266522251881, 0.21... \n", + "\n", + " camera_intrinsic \\\n", + "0 [[1266.417203046554, 0.0, 816.2670197447984], ... \n", + "1 [[1266.417203046554, 0.0, 816.2670197447984], ... \n", + "2 [[1266.417203046554, 0.0, 816.2670197447984], ... \n", + "3 [[1266.417203046554, 0.0, 816.2670197447984], ... \n", + "4 [[1266.417203046554, 0.0, 816.2670197447984], ... \n", + "... ... \n", + "14003 [[1272.5979470598488, 0.0, 826.6154927353808],... \n", + "14004 [[1272.5979470598488, 0.0, 826.6154927353808],... \n", + "14005 [[1272.5979470598488, 0.0, 826.6154927353808],... \n", + "14006 [[1272.5979470598488, 0.0, 826.6154927353808],... \n", + "14007 [[1272.5979470598488, 0.0, 826.6154927353808],... \n", + "\n", + " ego_rotation \\\n", + "0 [0.5731318069963492, -0.001008743951274553, 0.... \n", + "1 [0.5756004222270319, 0.002468184877516363, 0.0... \n", + "2 [0.5812651129089583, 0.0004956185578443312, 0.... \n", + "3 [0.5839935942635103, 0.0001221605241272317, 0.... \n", + "4 [0.5881335809828381, -0.0009546940046563173, 0... \n", + "... ... \n", + "14003 [0.21734463639137175, 0.021947100873110408, 0.... \n", + "14004 [0.21734590189901404, 0.02201001850017383, 0.0... \n", + "14005 [0.21736779146486868, 0.02205034298791243, 0.0... \n", + "14006 [0.21735700739688674, 0.022021890759692117, 0.... \n", + "14007 [0.21733320983121257, 0.022053796274396114, 0.... \n", + "\n", + " ego_translation scene_name frame_order \n", + "0 [410.9433704785875, 1179.9098624203461, 0.0] scene-0061 3 \n", + "1 [408.9502699908764, 1174.4933020919336, 0.0] scene-0061 11 \n", + "2 [406.9547611089034, 1168.8764471325978, 0.0] scene-0061 19 \n", + "3 [405.242155872287, 1163.862806857947, 0.0] scene-0061 27 \n", + "4 [403.6676139166417, 1159.200310831268, 0.0] scene-0061 35 \n", + "... ... ... ... \n", + "14003 [1320.4899619460525, 903.2850514824449, 0.0] scene-1100 199 \n", + "14004 [1320.4899769167264, 903.2850689140539, 0.0] scene-1100 207 \n", + "14005 [1320.4899595637255, 903.2850693428472, 0.0] scene-1100 215 \n", + "14006 [1320.4898559087292, 903.2850283180987, 0.0] scene-1100 223 \n", + "14007 [1320.4899565014946, 903.2850811527192, 0.0] scene-1100 231 \n", + "\n", + "[14008 rows x 11 columns]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_sample_data" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tokensample_tokeninstance_tokentranslationsizerotationcategory
070aecbe9b64f4722ab3c230391a3beb8cd21dbfc3bd749c7b10a5c42562e0c426dd2cbf4c24b4caeb625035869bca7b5[373.214, 1130.48, 1.25][0.621, 0.669, 1.642][0.9831098797903927, 0.0, 0.0, -0.183016295062...human.pedestrian.adult
17fa3a688931b4500b7ce29d187d3b9752ff86dc19c4644a1a88ce5ba848f56e56dd2cbf4c24b4caeb625035869bca7b5[373.152, 1130.357, 1.25][0.621, 0.669, 1.642][0.9831098797903927, 0.0, 0.0, -0.183016295062...human.pedestrian.adult
293d5b79041c64693a5b32f1103a39a0629e056fc277543c9bc42310b122c640e6dd2cbf4c24b4caeb625035869bca7b5[373.35, 1130.67, 1.123][0.621, 0.669, 1.642][0.9831098797903927, 0.0, 0.0, -0.183016295062...human.pedestrian.adult
3ef63a697930c4b20a6b9791f423351daca9a282c9e77460f8360f564131a8af56dd2cbf4c24b4caeb625035869bca7b5[373.256, 1130.419, 0.8][0.621, 0.669, 1.642][0.9831098797903927, 0.0, 0.0, -0.183016295062...human.pedestrian.adult
47987617983634b119e383d8a29607fd739586f9d59004284a7114a68825e8eec6dd2cbf4c24b4caeb625035869bca7b5[373.256, 1130.419, 0.81][0.621, 0.669, 1.642][0.9831098797903927, 0.0, 0.0, -0.183016295062...human.pedestrian.adult
........................
1853347327ad48c754ae182837e12a9dacac3c36e8482feb041de9f081e76396cf4fe88b7a3d6e9394198a1511642a5aa5499[1327.591, 918.656, 1.306][1.836, 4.416, 1.43][0.9048506452970881, 0.0, 0.0, 0.4257291506409...vehicle.car
185347261b1ae5c5c4253941f1b3298f108dbb902d29df24c4efda414a9a88ed5703188b7a3d6e9394198a1511642a5aa5499[1347.981, 943.716, 2.682][1.836, 4.416, 1.43][0.9048506452970881, 0.0, 0.0, 0.4257291506409...vehicle.car
185358fbe30c0e281488f9a2e4a061fc92c530a3abc33048d46f9bd78151d1df4b00488b7a3d6e9394198a1511642a5aa5499[1337.789, 931.193, 2.006][1.836, 4.416, 1.43][0.9048506452970881, 0.0, 0.0, 0.4257291506409...vehicle.car
18536fb2873a3231945249b1fe1acf0cedf1da480496a5988410fbe3d8ed6c84da99688b7a3d6e9394198a1511642a5aa5499[1315.676, 902.276, 0.406][1.836, 4.416, 1.43][0.8854193832467303, 0.0, 0.0, 0.4647929816283...vehicle.car
18537b8dd2792bd4a4b1eb4deba5083bf74f4dc4c80e8a1534ff8a3eb80307341161c88b7a3d6e9394198a1511642a5aa5499[1324.369, 914.564, 1.106][1.836, 4.416, 1.43][0.8972826104991134, 0.0, 0.0, 0.4414565855165...vehicle.car
\n", + "

18538 rows × 7 columns

\n", + "
" + ], + "text/plain": [ + " token sample_token \\\n", + "0 70aecbe9b64f4722ab3c230391a3beb8 cd21dbfc3bd749c7b10a5c42562e0c42 \n", + "1 7fa3a688931b4500b7ce29d187d3b975 2ff86dc19c4644a1a88ce5ba848f56e5 \n", + "2 93d5b79041c64693a5b32f1103a39a06 29e056fc277543c9bc42310b122c640e \n", + "3 ef63a697930c4b20a6b9791f423351da ca9a282c9e77460f8360f564131a8af5 \n", + "4 7987617983634b119e383d8a29607fd7 39586f9d59004284a7114a68825e8eec \n", + "... ... ... \n", + "18533 47327ad48c754ae182837e12a9dacac3 c36e8482feb041de9f081e76396cf4fe \n", + "18534 7261b1ae5c5c4253941f1b3298f108db b902d29df24c4efda414a9a88ed57031 \n", + "18535 8fbe30c0e281488f9a2e4a061fc92c53 0a3abc33048d46f9bd78151d1df4b004 \n", + "18536 fb2873a3231945249b1fe1acf0cedf1d a480496a5988410fbe3d8ed6c84da996 \n", + "18537 b8dd2792bd4a4b1eb4deba5083bf74f4 dc4c80e8a1534ff8a3eb80307341161c \n", + "\n", + " instance_token translation \\\n", + "0 6dd2cbf4c24b4caeb625035869bca7b5 [373.214, 1130.48, 1.25] \n", + "1 6dd2cbf4c24b4caeb625035869bca7b5 [373.152, 1130.357, 1.25] \n", + "2 6dd2cbf4c24b4caeb625035869bca7b5 [373.35, 1130.67, 1.123] \n", + "3 6dd2cbf4c24b4caeb625035869bca7b5 [373.256, 1130.419, 0.8] \n", + "4 6dd2cbf4c24b4caeb625035869bca7b5 [373.256, 1130.419, 0.81] \n", + "... ... ... \n", + "18533 88b7a3d6e9394198a1511642a5aa5499 [1327.591, 918.656, 1.306] \n", + "18534 88b7a3d6e9394198a1511642a5aa5499 [1347.981, 943.716, 2.682] \n", + "18535 88b7a3d6e9394198a1511642a5aa5499 [1337.789, 931.193, 2.006] \n", + "18536 88b7a3d6e9394198a1511642a5aa5499 [1315.676, 902.276, 0.406] \n", + "18537 88b7a3d6e9394198a1511642a5aa5499 [1324.369, 914.564, 1.106] \n", + "\n", + " size \\\n", + "0 [0.621, 0.669, 1.642] \n", + "1 [0.621, 0.669, 1.642] \n", + "2 [0.621, 0.669, 1.642] \n", + "3 [0.621, 0.669, 1.642] \n", + "4 [0.621, 0.669, 1.642] \n", + "... ... \n", + "18533 [1.836, 4.416, 1.43] \n", + "18534 [1.836, 4.416, 1.43] \n", + "18535 [1.836, 4.416, 1.43] \n", + "18536 [1.836, 4.416, 1.43] \n", + "18537 [1.836, 4.416, 1.43] \n", + "\n", + " rotation \\\n", + "0 [0.9831098797903927, 0.0, 0.0, -0.183016295062... \n", + "1 [0.9831098797903927, 0.0, 0.0, -0.183016295062... \n", + "2 [0.9831098797903927, 0.0, 0.0, -0.183016295062... \n", + "3 [0.9831098797903927, 0.0, 0.0, -0.183016295062... \n", + "4 [0.9831098797903927, 0.0, 0.0, -0.183016295062... \n", + "... ... \n", + "18533 [0.9048506452970881, 0.0, 0.0, 0.4257291506409... \n", + "18534 [0.9048506452970881, 0.0, 0.0, 0.4257291506409... \n", + "18535 [0.9048506452970881, 0.0, 0.0, 0.4257291506409... \n", + "18536 [0.8854193832467303, 0.0, 0.0, 0.4647929816283... \n", + "18537 [0.8972826104991134, 0.0, 0.0, 0.4414565855165... \n", + "\n", + " category \n", + "0 human.pedestrian.adult \n", + "1 human.pedestrian.adult \n", + "2 human.pedestrian.adult \n", + "3 human.pedestrian.adult \n", + "4 human.pedestrian.adult \n", + "... ... \n", + "18533 vehicle.car \n", + "18534 vehicle.car \n", + "18535 vehicle.car \n", + "18536 vehicle.car \n", + "18537 vehicle.car \n", + "\n", + "[18538 rows x 7 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_annotation" + ] + }, + { + "cell_type": "code", + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -61,20 +589,18 @@ }, { "cell_type": "code", - "execution_count": 5, - "id": "d15ddef2", + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "### Ingest the camera to the world\n", "scene_name = \"scene-0061\"\n", - "scenic_world = scenic_world.scenic_camera(scene_name)" + "scenic_world_61 = scenic_world.scenic_camera(scene_name)" ] }, { "cell_type": "code", - "execution_count": 6, - "id": "309003c4", + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -91,14 +617,13 @@ ], "source": [ "### Call execute on the world to run the detection algorithm and save the real data to the database\n", - "recognized_scenic_world = scenic_world.recognize(scene_name, df_sample_data, df_annotation)\n", + "recognized_scenic_world = scenic_world_61.recognize(scene_name, df_sample_data, df_annotation)\n", "recognized_scenic_world.execute()" ] }, { "cell_type": "code", - "execution_count": 4, - "id": "215c26b2", + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -122,9 +647,10 @@ }, { "cell_type": "code", - "execution_count": 8, - "id": "32275228", - "metadata": {}, + "execution_count": 10, + "metadata": { + "scrolled": true + }, "outputs": [ { "name": "stdout", @@ -140,51 +666,3773 @@ }, { "cell_type": "code", - "execution_count": 8, - "id": "f9a8f36b", + "execution_count": 11, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='object_type', ctx=Load()), ops=[Eq()], comparators=[Str(s='vehicle.car')]))])\n", - "Module(body=[Return(value=Compare(left=Call(func=Name(id='Tmin', ctx=Load()), args=[Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load())], keywords=[]), ops=[GtE()], comparators=[Name(id='start', ctx=Load())]))])\n", - "Module(body=[Return(value=Compare(left=Call(func=Name(id='Tmax', ctx=Load()), args=[Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load())], keywords=[]), ops=[Lt()], comparators=[Name(id='end', ctx=Load())]))])\n", - "Worlds Table created successfully........\n", - "New world inserted successfully........\n", - "Xmin(Test_Scenic_General_Bbox.trajBbox)\n", - "Ymin(Test_Scenic_General_Bbox.trajBbox)\n", - "Zmin(Test_Scenic_General_Bbox.trajBbox)\n", - "Xmax(Test_Scenic_General_Bbox.trajBbox)\n", - "Ymax(Test_Scenic_General_Bbox.trajBbox)\n", - "Zmax(Test_Scenic_General_Bbox.trajBbox)\n", - "SELECT Xmin(Test_Scenic_General_Bbox.trajBbox), Ymin(Test_Scenic_General_Bbox.trajBbox), Zmin(Test_Scenic_General_Bbox.trajBbox), Xmax(Test_Scenic_General_Bbox.trajBbox), Ymax(Test_Scenic_General_Bbox.trajBbox), Zmax(Test_Scenic_General_Bbox.trajBbox) From Test_Scenic_Item_General_Trajectory INNER JOIN Test_Scenic_General_Bbox USING(itemId) Where Test_Scenic_Item_General_Trajectory.objectType='vehicle.car' AND Tmin(Test_Scenic_General_Bbox.trajBbox)>='0001-01-01 00:00:00' AND Tmax(Test_Scenic_General_Bbox.trajBbox)<'9999-12-31 23:59:59.999999';\n", - "\n" - ] + "data": { + "text/plain": [ + "[[1.0,\n", + " 2.0,\n", + " 3.0,\n", + " 4.0,\n", + " 5.0,\n", + " 6.0,\n", + " 7.0,\n", + " 8.0,\n", + " 9.0,\n", + " 10.0,\n", + " 11.0,\n", + " 12.0,\n", + " 13.0,\n", + " 14.0,\n", + " 15.0,\n", + " 16.0,\n", + " 17.0,\n", + " 18.0,\n", + " 19.0,\n", + " 20.0,\n", + " 21.0,\n", + " 22.0,\n", + " 23.0,\n", + " 24.0,\n", + " 25.0,\n", + " 26.0,\n", + " 27.0,\n", + " 28.0,\n", + " 29.0,\n", + " 30.0,\n", + " 31.0,\n", + " 32.0,\n", + " 33.0,\n", + " 34.0,\n", + " 35.0,\n", + " 36.0,\n", + " 37.0,\n", + " 38.0,\n", + " 39.0,\n", + " 40.0,\n", + " 41.0,\n", + " 42.0,\n", + " 43.0,\n", + " 44.0,\n", + " 45.0,\n", + " 46.0,\n", + " 47.0,\n", + " 48.0,\n", + " 49.0,\n", + " 50.0,\n", + " 51.0,\n", + " 52.0,\n", + " 53.0,\n", + " 54.0,\n", + " 55.0,\n", + " 56.0,\n", + " 57.0,\n", + " 58.0,\n", + " 59.0,\n", + " 60.0,\n", + " 61.0,\n", + " 62.0,\n", + " 63.0,\n", + " 64.0,\n", + " 65.0,\n", + " 66.0,\n", + " 67.0,\n", + " 68.0,\n", + " 69.0,\n", + " 70.0,\n", + " 71.0,\n", + " 72.0,\n", + " 73.0,\n", + " 74.0,\n", + " 75.0,\n", + " 76.0,\n", + " 77.0,\n", + " 78.0,\n", + " 79.0,\n", + " 80.0,\n", + " 81.0,\n", + " 82.0,\n", + " 83.0,\n", + " 84.0,\n", + " 85.0,\n", + " 86.0,\n", + " 87.0,\n", + " 88.0,\n", + " 89.0,\n", + " 90.0,\n", + " 91.0,\n", + " 92.0,\n", + " 93.0,\n", + " 94.0,\n", + " 95.0,\n", + " 96.0,\n", + " 97.0,\n", + " 98.0,\n", + " 99.0,\n", + " 100.0,\n", + " 101.0,\n", + " 102.0,\n", + " 103.0,\n", + " 104.0,\n", + " 105.0,\n", + " 106.0,\n", + " 107.0,\n", + " 108.0,\n", + " 109.0,\n", + " 110.0,\n", + " 111.0,\n", + " 112.0,\n", + " 113.0,\n", + " 114.0,\n", + " 115.0,\n", + " 116.0,\n", + " 117.0,\n", + " 118.0,\n", + " 119.0,\n", + " 120.0,\n", + " 121.0,\n", + " 122.0,\n", + " 123.0,\n", + " 124.0,\n", + " 125.0,\n", + " 126.0,\n", + " 127.0,\n", + " 128.0,\n", + " 129.0,\n", + " 130.0,\n", + " 131.0,\n", + " 132.0,\n", + " 133.0,\n", + " 134.0,\n", + " 135.0,\n", + " 136.0,\n", + " 137.0,\n", + " 138.0,\n", + " 139.0,\n", + " 140.0,\n", + " 141.0,\n", + " 142.0,\n", + " 143.0,\n", + " 144.0,\n", + " 145.0,\n", + " 146.0,\n", + " 147.0,\n", + " 148.0,\n", + " 149.0,\n", + " 150.0,\n", + " 151.0,\n", + " 152.0,\n", + " 153.0,\n", + " 154.0,\n", + " 155.0,\n", + " 156.0,\n", + " 157.0,\n", + " 158.0,\n", + " 159.0,\n", + " 160.0,\n", + " 161.0,\n", + " 162.0,\n", + " 163.0,\n", + " 164.0,\n", + " 165.0,\n", + " 166.0,\n", + " 167.0,\n", + " 168.0,\n", + " 169.0,\n", + " 170.0,\n", + " 171.0,\n", + " 172.0,\n", + " 173.0,\n", + " 174.0,\n", + " 175.0,\n", + " 176.0,\n", + " 177.0,\n", + " 178.0,\n", + " 179.0,\n", + " 180.0,\n", + " 181.0,\n", + " 182.0,\n", + " 183.0,\n", + " 184.0,\n", + " 185.0,\n", + " 186.0,\n", + " 187.0,\n", + " 188.0,\n", + " 189.0,\n", + " 190.0,\n", + " 191.0,\n", + " 192.0,\n", + " 193.0,\n", + " 194.0,\n", + " 195.0,\n", + " 196.0,\n", + " 197.0,\n", + " 198.0,\n", + " 199.0,\n", + " 200.0,\n", + " 201.0,\n", + " 202.0,\n", + " 203.0,\n", + " 204.0,\n", + " 205.0,\n", + " 206.0,\n", + " 207.0,\n", + " 208.0,\n", + " 209.0,\n", + " 210.0,\n", + " 211.0,\n", + " 212.0],\n", + " [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0],\n", + " [1.0,\n", + " 2.0,\n", + " 3.0,\n", + " 4.0,\n", + " 5.0,\n", + " 6.0,\n", + " 7.0,\n", + " 8.0,\n", + " 9.0,\n", + " 10.0,\n", + " 11.0,\n", + " 12.0,\n", + " 13.0,\n", + " 14.0,\n", + " 15.0,\n", + " 16.0,\n", + " 17.0,\n", + " 18.0,\n", + " 19.0,\n", + " 20.0,\n", + " 21.0,\n", + " 22.0,\n", + " 23.0,\n", + " 24.0,\n", + " 25.0,\n", + " 26.0,\n", + " 27.0,\n", + " 28.0,\n", + " 29.0,\n", + " 30.0,\n", + " 31.0,\n", + " 32.0,\n", + " 33.0,\n", + " 34.0,\n", + " 35.0,\n", + " 36.0,\n", + " 37.0,\n", + " 38.0,\n", + " 39.0,\n", + " 40.0,\n", + " 41.0,\n", + " 42.0,\n", + " 43.0,\n", + " 44.0,\n", + " 45.0,\n", + " 46.0,\n", + " 47.0,\n", + " 48.0,\n", + " 49.0,\n", + " 50.0,\n", + " 51.0,\n", + " 52.0,\n", + " 53.0,\n", + " 54.0,\n", + " 55.0,\n", + " 56.0,\n", + " 57.0,\n", + " 58.0,\n", + " 59.0,\n", + " 60.0,\n", + " 61.0,\n", + " 62.0,\n", + " 63.0,\n", + " 64.0,\n", + " 65.0,\n", + " 66.0,\n", + " 67.0,\n", + " 68.0,\n", + " 69.0,\n", + " 70.0,\n", + " 71.0,\n", + " 72.0,\n", + " 73.0,\n", + " 74.0,\n", + " 75.0,\n", + " 76.0,\n", + " 77.0,\n", + " 78.0,\n", + " 79.0,\n", + " 80.0,\n", + " 81.0,\n", + " 82.0,\n", + " 83.0,\n", + " 84.0,\n", + " 85.0,\n", + " 86.0,\n", + " 87.0,\n", + " 88.0,\n", + " 89.0,\n", + " 90.0,\n", + " 91.0,\n", + " 92.0,\n", + " 93.0,\n", + " 94.0,\n", + " 95.0,\n", + " 96.0,\n", + " 97.0,\n", + " 98.0,\n", + " 99.0,\n", + " 100.0,\n", + " 101.0,\n", + " 102.0,\n", + " 103.0,\n", + " 104.0,\n", + " 105.0,\n", + " 106.0,\n", + " 107.0,\n", + " 108.0,\n", + " 109.0,\n", + " 110.0,\n", + " 111.0,\n", + " 112.0,\n", + " 113.0,\n", + " 114.0,\n", + " 115.0,\n", + " 116.0,\n", + " 117.0,\n", + " 118.0,\n", + " 119.0,\n", + " 120.0,\n", + " 121.0,\n", + " 122.0,\n", + " 123.0,\n", + " 124.0,\n", + " 125.0,\n", + " 126.0,\n", + " 127.0,\n", + " 128.0,\n", + " 129.0,\n", + " 130.0,\n", + " 131.0,\n", + " 132.0,\n", + " 133.0,\n", + " 134.0,\n", + " 135.0],\n", + " [1.0,\n", + " 2.0,\n", + " 3.0,\n", + " 4.0,\n", + " 5.0,\n", + " 6.0,\n", + " 7.0,\n", + " 8.0,\n", + " 9.0,\n", + " 10.0,\n", + " 11.0,\n", + " 12.0,\n", + " 13.0,\n", + " 14.0,\n", + " 15.0,\n", + " 16.0,\n", + " 17.0,\n", + " 18.0,\n", + " 19.0,\n", + " 20.0,\n", + " 21.0,\n", + " 22.0,\n", + " 23.0,\n", + " 24.0,\n", + " 25.0,\n", + " 26.0,\n", + " 27.0,\n", + " 28.0,\n", + " 29.0,\n", + " 30.0,\n", + " 31.0,\n", + " 32.0,\n", + " 33.0,\n", + " 34.0,\n", + " 35.0,\n", + " 36.0,\n", + " 37.0,\n", + " 38.0,\n", + " 39.0,\n", + " 40.0,\n", + " 41.0,\n", + " 42.0,\n", + " 43.0,\n", + " 44.0,\n", + " 45.0,\n", + " 46.0,\n", + " 47.0,\n", + " 48.0,\n", + " 49.0,\n", + " 50.0,\n", + " 51.0,\n", + " 52.0,\n", + " 53.0,\n", + " 54.0,\n", + " 55.0,\n", + " 56.0,\n", + " 57.0,\n", + " 58.0,\n", + " 59.0,\n", + " 60.0,\n", + " 61.0,\n", + " 62.0,\n", + " 63.0,\n", + " 64.0,\n", + " 65.0,\n", + " 66.0,\n", + " 67.0,\n", + " 68.0,\n", + " 69.0,\n", + " 70.0,\n", + " 71.0,\n", + " 72.0,\n", + " 73.0,\n", + " 74.0,\n", + " 75.0,\n", + " 76.0,\n", + " 77.0,\n", + " 78.0,\n", + " 79.0,\n", + " 80.0,\n", + " 81.0,\n", + " 82.0,\n", + " 83.0,\n", + " 84.0,\n", + " 85.0,\n", + " 86.0,\n", + " 87.0,\n", + " 88.0,\n", + " 89.0,\n", + " 90.0,\n", + " 91.0,\n", + " 92.0,\n", + " 93.0,\n", + " 94.0,\n", + " 95.0,\n", + " 96.0,\n", + " 97.0,\n", + " 98.0,\n", + " 99.0,\n", + " 100.0,\n", + " 101.0,\n", + " 102.0,\n", + " 103.0,\n", + " 104.0,\n", + " 105.0,\n", + " 106.0,\n", + " 107.0,\n", + " 108.0,\n", + " 109.0,\n", + " 110.0,\n", + " 111.0,\n", + " 112.0,\n", + " 113.0,\n", + " 114.0,\n", + " 115.0,\n", + " 116.0,\n", + " 117.0,\n", + " 118.0,\n", + " 119.0,\n", + " 120.0,\n", + " 121.0,\n", + " 122.0,\n", + " 123.0,\n", + " 124.0,\n", + " 125.0,\n", + " 126.0,\n", + " 127.0,\n", + " 128.0,\n", + " 129.0,\n", + " 130.0,\n", + " 131.0,\n", + " 132.0,\n", + " 133.0,\n", + " 134.0,\n", + " 135.0,\n", + " 136.0,\n", + " 137.0,\n", + " 138.0,\n", + " 139.0,\n", + " 140.0,\n", + " 141.0,\n", + " 142.0,\n", + " 143.0,\n", + " 144.0,\n", + " 145.0,\n", + " 146.0,\n", + " 147.0,\n", + " 148.0,\n", + " 149.0,\n", + " 150.0,\n", + " 151.0,\n", + " 152.0,\n", + " 153.0,\n", + " 154.0,\n", + " 155.0,\n", + " 156.0,\n", + " 157.0,\n", + " 158.0,\n", + " 159.0,\n", + " 160.0,\n", + " 161.0,\n", + " 162.0,\n", + " 163.0,\n", + " 164.0,\n", + " 165.0,\n", + " 166.0,\n", + " 167.0,\n", + " 168.0,\n", + " 169.0,\n", + " 170.0,\n", + " 171.0,\n", + " 172.0,\n", + " 173.0,\n", + " 174.0,\n", + " 175.0,\n", + " 176.0,\n", + " 177.0,\n", + " 178.0,\n", + " 179.0,\n", + " 180.0,\n", + " 181.0,\n", + " 182.0,\n", + " 183.0,\n", + " 184.0,\n", + " 185.0,\n", + " 186.0,\n", + " 187.0,\n", + " 188.0,\n", + " 189.0,\n", + " 190.0,\n", + " 191.0,\n", + " 192.0,\n", + " 193.0,\n", + " 194.0,\n", + " 195.0,\n", + " 196.0,\n", + " 197.0,\n", + " 198.0,\n", + " 199.0,\n", + " 200.0,\n", + " 201.0,\n", + " 202.0,\n", + " 203.0,\n", + " 204.0,\n", + " 205.0,\n", + " 206.0,\n", + " 207.0,\n", + " 208.0,\n", + " 209.0,\n", + " 210.0,\n", + " 211.0,\n", + " 212.0,\n", + " 213.0,\n", + " 214.0,\n", + " 215.0,\n", + " 216.0,\n", + " 217.0,\n", + " 218.0,\n", + " 219.0,\n", + " 220.0,\n", + " 221.0,\n", + " 222.0,\n", + " 223.0,\n", + " 224.0],\n", + " [2.0,\n", + " 3.0,\n", + " 4.0,\n", + " 5.0,\n", + " 6.0,\n", + " 7.0,\n", + " 8.0,\n", + " 9.0,\n", + " 10.0,\n", + " 11.0,\n", + " 12.0,\n", + " 13.0,\n", + " 14.0,\n", + " 15.0,\n", + " 16.0,\n", + " 17.0,\n", + " 18.0,\n", + " 19.0,\n", + " 20.0,\n", + " 21.0,\n", + " 22.0,\n", + " 23.0,\n", + " 24.0,\n", + " 25.0,\n", + " 26.0,\n", + " 27.0,\n", + " 28.0,\n", + " 29.0,\n", + " 30.0,\n", + " 31.0,\n", + " 32.0,\n", + " 33.0,\n", + " 34.0,\n", + " 35.0,\n", + " 36.0,\n", + " 37.0,\n", + " 38.0,\n", + " 39.0,\n", + " 40.0,\n", + " 41.0,\n", + " 42.0,\n", + " 43.0,\n", + " 44.0,\n", + " 45.0,\n", + " 46.0,\n", + " 47.0,\n", + " 48.0,\n", + " 49.0,\n", + " 50.0,\n", + " 51.0,\n", + " 52.0,\n", + " 53.0,\n", + " 54.0,\n", + " 55.0,\n", + " 56.0,\n", + " 57.0,\n", + " 58.0,\n", + " 59.0,\n", + " 60.0,\n", + " 61.0,\n", + " 62.0,\n", + " 63.0,\n", + " 64.0,\n", + " 65.0,\n", + " 66.0,\n", + " 67.0,\n", + " 68.0,\n", + " 69.0,\n", + " 70.0,\n", + " 71.0,\n", + " 72.0,\n", + " 73.0,\n", + " 74.0,\n", + " 75.0,\n", + " 76.0,\n", + " 77.0],\n", + " [1.0,\n", + " 2.0,\n", + " 3.0,\n", + " 4.0,\n", + " 5.0,\n", + " 6.0,\n", + " 7.0,\n", + " 8.0,\n", + " 9.0,\n", + " 10.0,\n", + " 11.0,\n", + " 12.0,\n", + " 13.0,\n", + " 14.0,\n", + " 15.0,\n", + " 16.0,\n", + " 17.0,\n", + " 18.0,\n", + " 19.0,\n", + " 20.0,\n", + " 21.0,\n", + " 22.0,\n", + " 23.0,\n", + " 24.0,\n", + " 25.0,\n", + " 26.0],\n", + " [1.0,\n", + " 2.0,\n", + " 3.0,\n", + " 4.0,\n", + " 5.0,\n", + " 6.0,\n", + " 7.0,\n", + " 8.0,\n", + " 9.0,\n", + " 10.0,\n", + " 11.0,\n", + " 12.0,\n", + " 13.0,\n", + " 14.0,\n", + " 15.0,\n", + " 16.0,\n", + " 17.0,\n", + " 18.0,\n", + " 19.0,\n", + " 20.0,\n", + " 21.0,\n", + " 22.0,\n", + " 23.0,\n", + " 24.0,\n", + " 25.0,\n", + " 26.0,\n", + " 27.0,\n", + " 28.0,\n", + " 29.0,\n", + " 30.0,\n", + " 31.0,\n", + " 32.0,\n", + " 33.0,\n", + " 34.0,\n", + " 35.0,\n", + " 36.0,\n", + " 37.0,\n", + " 38.0,\n", + " 39.0,\n", + " 40.0,\n", + " 41.0,\n", + " 42.0,\n", + " 43.0,\n", + " 44.0,\n", + " 45.0,\n", + " 46.0,\n", + " 47.0,\n", + " 48.0,\n", + " 49.0,\n", + " 50.0,\n", + " 51.0,\n", + " 52.0,\n", + " 53.0,\n", + " 54.0,\n", + " 55.0,\n", + " 56.0,\n", + " 57.0,\n", + " 58.0,\n", + " 59.0,\n", + " 60.0,\n", + " 61.0,\n", + " 62.0,\n", + " 63.0,\n", + " 64.0,\n", + " 65.0,\n", + " 66.0,\n", + " 67.0,\n", + " 68.0,\n", + " 69.0,\n", + " 70.0,\n", + " 71.0,\n", + " 72.0,\n", + " 73.0,\n", + " 74.0,\n", + " 75.0,\n", + " 76.0,\n", + " 77.0,\n", + " 78.0,\n", + " 79.0,\n", + " 80.0,\n", + " 81.0,\n", + " 82.0,\n", + " 83.0,\n", + " 84.0,\n", + " 85.0,\n", + " 86.0,\n", + " 87.0,\n", + " 88.0,\n", + " 89.0,\n", + " 90.0,\n", + " 91.0,\n", + " 92.0,\n", + " 93.0,\n", + " 94.0,\n", + " 95.0,\n", + " 96.0,\n", + " 97.0,\n", + " 98.0,\n", + " 99.0,\n", + " 100.0,\n", + " 101.0,\n", + " 102.0,\n", + " 103.0,\n", + " 104.0,\n", + " 105.0,\n", + " 106.0,\n", + " 107.0,\n", + " 108.0,\n", + " 109.0,\n", + " 110.0,\n", + " 111.0,\n", + " 112.0,\n", + " 113.0,\n", + " 114.0,\n", + " 115.0,\n", + " 116.0,\n", + " 117.0,\n", + " 118.0,\n", + " 119.0,\n", + " 120.0,\n", + " 121.0,\n", + " 122.0,\n", + " 123.0,\n", + " 124.0,\n", + " 125.0,\n", + " 126.0,\n", + " 127.0,\n", + " 128.0,\n", + " 129.0,\n", + " 130.0,\n", + " 131.0,\n", + " 132.0,\n", + " 133.0,\n", + " 134.0,\n", + " 135.0,\n", + " 136.0,\n", + " 137.0,\n", + " 138.0,\n", + " 139.0,\n", + " 140.0,\n", + " 141.0,\n", + " 142.0,\n", + " 143.0,\n", + " 144.0,\n", + " 145.0,\n", + " 146.0,\n", + " 147.0,\n", + " 148.0,\n", + " 149.0,\n", + " 150.0,\n", + " 151.0,\n", + " 152.0,\n", + " 153.0,\n", + " 154.0,\n", + " 155.0,\n", + " 156.0,\n", + " 157.0,\n", + " 158.0,\n", + " 159.0,\n", + " 160.0,\n", + " 161.0,\n", + " 162.0,\n", + " 163.0,\n", + " 164.0,\n", + " 165.0,\n", + " 166.0,\n", + " 167.0,\n", + " 168.0,\n", + " 169.0,\n", + " 170.0,\n", + " 171.0,\n", + " 172.0,\n", + " 173.0,\n", + " 174.0,\n", + " 175.0,\n", + " 176.0,\n", + " 177.0,\n", + " 178.0,\n", + " 179.0,\n", + " 180.0,\n", + " 181.0,\n", + " 182.0,\n", + " 183.0,\n", + " 184.0,\n", + " 185.0,\n", + " 186.0,\n", + " 187.0,\n", + " 188.0,\n", + " 189.0,\n", + " 190.0,\n", + " 191.0,\n", + " 192.0,\n", + " 193.0,\n", + " 194.0,\n", + " 195.0,\n", + " 196.0,\n", + " 197.0,\n", + " 198.0,\n", + " 199.0,\n", + " 200.0,\n", + " 201.0,\n", + " 202.0,\n", + " 203.0,\n", + " 204.0,\n", + " 205.0,\n", + " 206.0,\n", + " 207.0,\n", + " 208.0,\n", + " 209.0,\n", + " 210.0,\n", + " 211.0,\n", + " 212.0,\n", + " 213.0,\n", + " 214.0,\n", + " 215.0,\n", + " 216.0,\n", + " 217.0,\n", + " 218.0,\n", + " 219.0,\n", + " 220.0,\n", + " 221.0,\n", + " 222.0,\n", + " 223.0,\n", + " 224.0],\n", + " [1.0,\n", + " 2.0,\n", + " 3.0,\n", + " 4.0,\n", + " 5.0,\n", + " 6.0,\n", + " 7.0,\n", + " 8.0,\n", + " 9.0,\n", + " 10.0,\n", + " 11.0,\n", + " 12.0,\n", + " 13.0,\n", + " 14.0,\n", + " 15.0,\n", + " 16.0,\n", + " 17.0,\n", + " 18.0,\n", + " 19.0,\n", + " 20.0,\n", + " 21.0,\n", + " 22.0,\n", + " 23.0,\n", + " 24.0,\n", + " 25.0,\n", + " 26.0,\n", + " 27.0,\n", + " 28.0,\n", + " 29.0,\n", + " 30.0,\n", + " 31.0,\n", + " 32.0,\n", + " 33.0,\n", + " 34.0,\n", + " 35.0,\n", + " 36.0,\n", + " 37.0,\n", + " 38.0,\n", + " 39.0,\n", + " 40.0,\n", + " 41.0,\n", + " 42.0,\n", + " 43.0,\n", + " 44.0,\n", + " 45.0,\n", + " 46.0,\n", + " 47.0,\n", + " 48.0,\n", + " 49.0,\n", + " 50.0,\n", + " 51.0,\n", + " 52.0,\n", + " 53.0,\n", + " 54.0,\n", + " 55.0,\n", + " 56.0,\n", + " 57.0,\n", + " 58.0,\n", + " 59.0,\n", + " 60.0,\n", + " 61.0,\n", + " 62.0,\n", + " 63.0,\n", + " 64.0,\n", + " 65.0,\n", + " 66.0,\n", + " 67.0,\n", + " 68.0,\n", + " 69.0,\n", + " 70.0,\n", + " 71.0,\n", + " 72.0,\n", + " 73.0,\n", + " 74.0,\n", + " 75.0,\n", + " 76.0,\n", + " 77.0,\n", + " 78.0,\n", + " 79.0,\n", + " 80.0,\n", + " 81.0,\n", + " 82.0,\n", + " 83.0,\n", + " 84.0,\n", + " 85.0,\n", + " 86.0,\n", + " 87.0,\n", + " 88.0,\n", + " 89.0,\n", + " 90.0,\n", + " 91.0,\n", + " 92.0,\n", + " 93.0,\n", + " 94.0,\n", + " 95.0,\n", + " 96.0,\n", + " 97.0,\n", + " 98.0,\n", + " 99.0,\n", + " 100.0,\n", + " 101.0,\n", + " 102.0,\n", + " 103.0,\n", + " 104.0,\n", + " 105.0,\n", + " 106.0,\n", + " 107.0,\n", + " 108.0,\n", + " 109.0,\n", + " 110.0,\n", + " 111.0,\n", + " 112.0,\n", + " 113.0,\n", + " 114.0,\n", + " 115.0,\n", + " 116.0,\n", + " 117.0,\n", + " 118.0,\n", + " 119.0,\n", + " 120.0,\n", + " 121.0,\n", + " 122.0,\n", + " 123.0,\n", + " 124.0,\n", + " 125.0,\n", + " 126.0,\n", + " 127.0,\n", + " 128.0,\n", + " 129.0,\n", + " 130.0,\n", + " 131.0,\n", + " 132.0,\n", + " 133.0,\n", + " 134.0,\n", + " 135.0,\n", + " 136.0,\n", + " 137.0,\n", + " 138.0,\n", + " 139.0,\n", + " 140.0,\n", + " 141.0,\n", + " 142.0,\n", + " 143.0,\n", + " 144.0,\n", + " 145.0,\n", + " 146.0,\n", + " 147.0,\n", + " 148.0,\n", + " 149.0,\n", + " 150.0,\n", + " 151.0,\n", + " 152.0,\n", + " 153.0,\n", + " 154.0,\n", + " 155.0,\n", + " 156.0,\n", + " 157.0,\n", + " 158.0,\n", + " 159.0,\n", + " 160.0,\n", + " 161.0,\n", + " 162.0,\n", + " 163.0,\n", + " 164.0,\n", + " 165.0,\n", + " 166.0,\n", + " 167.0,\n", + " 168.0,\n", + " 169.0,\n", + " 170.0,\n", + " 171.0,\n", + " 172.0,\n", + " 173.0,\n", + " 174.0,\n", + " 175.0,\n", + " 176.0,\n", + " 177.0,\n", + " 178.0,\n", + " 179.0,\n", + " 180.0,\n", + " 181.0,\n", + " 182.0,\n", + " 183.0],\n", + " [1.0,\n", + " 2.0,\n", + " 3.0,\n", + " 4.0,\n", + " 5.0,\n", + " 6.0,\n", + " 7.0,\n", + " 8.0,\n", + " 9.0,\n", + " 10.0,\n", + " 11.0,\n", + " 12.0,\n", + " 13.0,\n", + " 14.0,\n", + " 15.0,\n", + " 16.0,\n", + " 17.0,\n", + " 18.0,\n", + " 19.0,\n", + " 20.0,\n", + " 21.0,\n", + " 22.0,\n", + " 23.0,\n", + " 24.0,\n", + " 25.0,\n", + " 26.0,\n", + " 27.0,\n", + " 28.0,\n", + " 29.0,\n", + " 30.0,\n", + " 31.0,\n", + " 32.0,\n", + " 33.0,\n", + " 34.0,\n", + " 35.0,\n", + " 36.0,\n", + " 37.0,\n", + " 38.0,\n", + " 39.0,\n", + " 40.0,\n", + " 41.0,\n", + " 42.0,\n", + " 43.0,\n", + " 44.0,\n", + " 45.0,\n", + " 46.0,\n", + " 47.0,\n", + " 48.0,\n", + " 49.0,\n", + " 50.0,\n", + " 51.0,\n", + " 52.0,\n", + " 53.0,\n", + " 54.0,\n", + " 55.0,\n", + " 56.0,\n", + " 57.0,\n", + " 58.0,\n", + " 59.0,\n", + " 60.0,\n", + " 61.0,\n", + " 62.0,\n", + " 63.0,\n", + " 64.0,\n", + " 65.0,\n", + " 66.0,\n", + " 67.0,\n", + " 68.0,\n", + " 69.0,\n", + " 70.0,\n", + " 71.0,\n", + " 72.0,\n", + " 73.0,\n", + " 74.0,\n", + " 75.0,\n", + " 76.0,\n", + " 77.0,\n", + " 78.0,\n", + " 79.0,\n", + " 80.0,\n", + " 81.0,\n", + " 82.0,\n", + " 83.0,\n", + " 84.0,\n", + " 85.0,\n", + " 86.0,\n", + " 87.0,\n", + " 88.0,\n", + " 89.0,\n", + " 90.0,\n", + " 91.0,\n", + " 92.0,\n", + " 93.0,\n", + " 94.0,\n", + " 95.0,\n", + " 96.0,\n", + " 97.0,\n", + " 98.0,\n", + " 99.0,\n", + " 100.0,\n", + " 101.0,\n", + " 102.0,\n", + " 103.0,\n", + " 104.0,\n", + " 105.0,\n", + " 106.0,\n", + " 107.0,\n", + " 108.0,\n", + " 109.0,\n", + " 110.0,\n", + " 111.0,\n", + " 112.0,\n", + " 113.0,\n", + " 114.0,\n", + " 115.0,\n", + " 116.0,\n", + " 117.0,\n", + " 118.0,\n", + " 119.0,\n", + " 120.0,\n", + " 121.0,\n", + " 122.0,\n", + " 123.0,\n", + " 124.0,\n", + " 125.0,\n", + " 126.0,\n", + " 127.0,\n", + " 128.0,\n", + " 129.0,\n", + " 130.0,\n", + " 131.0,\n", + " 132.0,\n", + " 133.0,\n", + " 134.0,\n", + " 135.0,\n", + " 136.0,\n", + " 137.0,\n", + " 138.0,\n", + " 139.0,\n", + " 140.0,\n", + " 141.0,\n", + " 142.0,\n", + " 143.0,\n", + " 144.0,\n", + " 145.0,\n", + " 146.0,\n", + " 147.0,\n", + " 148.0,\n", + " 149.0,\n", + " 150.0,\n", + " 151.0,\n", + " 152.0,\n", + " 153.0,\n", + " 154.0,\n", + " 155.0,\n", + " 156.0,\n", + " 157.0,\n", + " 158.0,\n", + " 159.0,\n", + " 160.0,\n", + " 161.0,\n", + " 162.0,\n", + " 163.0,\n", + " 164.0,\n", + " 165.0,\n", + " 166.0,\n", + " 167.0,\n", + " 168.0,\n", + " 169.0,\n", + " 170.0,\n", + " 171.0,\n", + " 172.0,\n", + " 173.0,\n", + " 174.0,\n", + " 175.0,\n", + " 176.0,\n", + " 177.0,\n", + " 178.0,\n", + " 179.0,\n", + " 180.0,\n", + " 181.0,\n", + " 182.0,\n", + " 183.0,\n", + " 184.0,\n", + " 185.0,\n", + " 186.0,\n", + " 187.0,\n", + " 188.0,\n", + " 189.0,\n", + " 190.0,\n", + " 191.0,\n", + " 192.0,\n", + " 193.0,\n", + " 194.0,\n", + " 195.0,\n", + " 196.0,\n", + " 197.0,\n", + " 198.0,\n", + " 199.0,\n", + " 200.0,\n", + " 201.0,\n", + " 202.0,\n", + " 203.0,\n", + " 204.0,\n", + " 205.0,\n", + " 206.0,\n", + " 207.0,\n", + " 208.0,\n", + " 209.0,\n", + " 210.0,\n", + " 211.0,\n", + " 212.0,\n", + " 213.0,\n", + " 214.0,\n", + " 215.0,\n", + " 216.0,\n", + " 217.0,\n", + " 218.0,\n", + " 219.0,\n", + " 220.0,\n", + " 221.0,\n", + " 222.0,\n", + " 223.0,\n", + " 224.0],\n", + " [2.0,\n", + " 3.0,\n", + " 4.0,\n", + " 5.0,\n", + " 6.0,\n", + " 7.0,\n", + " 8.0,\n", + " 9.0,\n", + " 10.0,\n", + " 11.0,\n", + " 12.0,\n", + " 13.0,\n", + " 14.0,\n", + " 15.0,\n", + " 16.0,\n", + " 17.0,\n", + " 18.0,\n", + " 19.0,\n", + " 20.0,\n", + " 21.0,\n", + " 22.0,\n", + " 23.0,\n", + " 24.0,\n", + " 25.0,\n", + " 26.0,\n", + " 27.0,\n", + " 28.0,\n", + " 29.0,\n", + " 30.0,\n", + " 31.0,\n", + " 32.0,\n", + " 33.0,\n", + " 34.0,\n", + " 35.0,\n", + " 36.0,\n", + " 37.0,\n", + " 38.0,\n", + " 39.0,\n", + " 40.0,\n", + " 41.0,\n", + " 42.0,\n", + " 43.0,\n", + " 44.0,\n", + " 45.0,\n", + " 46.0,\n", + " 47.0,\n", + " 48.0,\n", + " 49.0,\n", + " 50.0,\n", + " 51.0,\n", + " 52.0,\n", + " 53.0,\n", + " 54.0,\n", + " 55.0,\n", + " 56.0,\n", + " 57.0,\n", + " 58.0,\n", + " 59.0,\n", + " 60.0,\n", + " 61.0,\n", + " 62.0,\n", + " 63.0,\n", + " 64.0,\n", + " 65.0,\n", + " 66.0,\n", + " 67.0,\n", + " 68.0,\n", + " 69.0,\n", + " 70.0,\n", + " 71.0,\n", + " 72.0,\n", + " 73.0,\n", + " 74.0,\n", + " 75.0,\n", + " 76.0,\n", + " 77.0,\n", + " 78.0,\n", + " 79.0,\n", + " 80.0,\n", + " 81.0,\n", + " 82.0,\n", + " 83.0,\n", + " 84.0,\n", + " 85.0,\n", + " 86.0,\n", + " 87.0,\n", + " 88.0,\n", + " 89.0,\n", + " 90.0,\n", + " 91.0,\n", + " 92.0,\n", + " 93.0,\n", + " 94.0,\n", + " 95.0,\n", + " 96.0,\n", + " 97.0,\n", + " 98.0,\n", + " 99.0,\n", + " 100.0,\n", + " 101.0,\n", + " 102.0,\n", + " 103.0,\n", + " 104.0,\n", + " 105.0,\n", + " 106.0,\n", + " 107.0,\n", + " 108.0,\n", + " 109.0,\n", + " 110.0,\n", + " 111.0,\n", + " 112.0,\n", + " 113.0,\n", + " 114.0,\n", + " 115.0,\n", + " 116.0,\n", + " 117.0,\n", + " 118.0,\n", + " 119.0,\n", + " 120.0,\n", + " 121.0,\n", + " 122.0,\n", + " 123.0,\n", + " 124.0,\n", + " 125.0,\n", + " 126.0,\n", + " 127.0,\n", + " 128.0,\n", + " 129.0,\n", + " 130.0,\n", + " 131.0,\n", + " 132.0,\n", + " 133.0,\n", + " 134.0,\n", + " 135.0,\n", + " 136.0,\n", + " 137.0,\n", + " 138.0,\n", + " 139.0,\n", + " 140.0,\n", + " 141.0,\n", + " 142.0,\n", + " 143.0,\n", + " 144.0,\n", + " 145.0,\n", + " 146.0,\n", + " 147.0,\n", + " 148.0,\n", + " 149.0,\n", + " 150.0,\n", + " 151.0,\n", + " 152.0,\n", + " 153.0,\n", + " 154.0,\n", + " 155.0],\n", + " [8.0,\n", + " 9.0,\n", + " 10.0,\n", + " 11.0,\n", + " 12.0,\n", + " 13.0,\n", + " 14.0,\n", + " 15.0,\n", + " 16.0,\n", + " 17.0,\n", + " 18.0,\n", + " 19.0,\n", + " 20.0,\n", + " 21.0,\n", + " 22.0,\n", + " 23.0,\n", + " 24.0,\n", + " 25.0,\n", + " 26.0,\n", + " 27.0,\n", + " 28.0,\n", + " 29.0,\n", + " 30.0,\n", + " 31.0,\n", + " 32.0,\n", + " 33.0,\n", + " 34.0,\n", + " 35.0,\n", + " 36.0,\n", + " 37.0,\n", + " 38.0,\n", + " 39.0,\n", + " 40.0,\n", + " 41.0,\n", + " 42.0,\n", + " 43.0,\n", + " 44.0,\n", + " 45.0,\n", + " 46.0,\n", + " 47.0,\n", + " 48.0,\n", + " 49.0,\n", + " 50.0,\n", + " 51.0,\n", + " 52.0,\n", + " 53.0,\n", + " 54.0,\n", + " 55.0,\n", + " 56.0,\n", + " 57.0,\n", + " 58.0,\n", + " 59.0,\n", + " 60.0,\n", + " 61.0,\n", + " 62.0,\n", + " 63.0,\n", + " 64.0,\n", + " 65.0,\n", + " 66.0,\n", + " 67.0,\n", + " 68.0,\n", + " 69.0,\n", + " 70.0,\n", + " 71.0,\n", + " 72.0,\n", + " 73.0,\n", + " 74.0,\n", + " 75.0,\n", + " 76.0,\n", + " 77.0,\n", + " 78.0,\n", + " 79.0,\n", + " 80.0,\n", + " 81.0,\n", + " 82.0,\n", + " 83.0,\n", + " 84.0,\n", + " 85.0,\n", + " 86.0,\n", + " 87.0,\n", + " 88.0,\n", + " 89.0,\n", + " 90.0,\n", + " 91.0,\n", + " 92.0,\n", + " 93.0,\n", + " 94.0,\n", + " 95.0,\n", + " 96.0,\n", + " 97.0,\n", + " 98.0,\n", + " 99.0,\n", + " 100.0,\n", + " 101.0,\n", + " 102.0,\n", + " 103.0,\n", + " 104.0,\n", + " 105.0,\n", + " 106.0,\n", + " 107.0,\n", + " 108.0,\n", + " 109.0,\n", + " 110.0,\n", + " 111.0,\n", + " 112.0,\n", + " 113.0,\n", + " 114.0,\n", + " 115.0,\n", + " 116.0,\n", + " 117.0,\n", + " 118.0],\n", + " [15.0,\n", + " 16.0,\n", + " 17.0,\n", + " 18.0,\n", + " 19.0,\n", + " 20.0,\n", + " 21.0,\n", + " 22.0,\n", + " 23.0,\n", + " 24.0,\n", + " 25.0,\n", + " 26.0,\n", + " 27.0,\n", + " 28.0,\n", + " 29.0,\n", + " 30.0,\n", + " 31.0,\n", + " 32.0,\n", + " 33.0,\n", + " 34.0,\n", + " 35.0,\n", + " 36.0,\n", + " 37.0,\n", + " 38.0,\n", + " 39.0,\n", + " 40.0,\n", + " 41.0,\n", + " 42.0,\n", + " 43.0,\n", + " 44.0,\n", + " 45.0,\n", + " 46.0,\n", + " 47.0,\n", + " 48.0,\n", + " 49.0,\n", + " 50.0,\n", + " 51.0,\n", + " 52.0,\n", + " 53.0,\n", + " 54.0,\n", + " 55.0,\n", + " 56.0,\n", + " 57.0,\n", + " 58.0,\n", + " 59.0,\n", + " 60.0,\n", + " 61.0,\n", + " 62.0,\n", + " 63.0,\n", + " 64.0,\n", + " 65.0,\n", + " 66.0,\n", + " 67.0,\n", + " 68.0,\n", + " 69.0,\n", + " 70.0,\n", + " 71.0,\n", + " 72.0,\n", + " 73.0,\n", + " 74.0,\n", + " 75.0,\n", + " 76.0,\n", + " 77.0,\n", + " 78.0,\n", + " 79.0,\n", + " 80.0,\n", + " 81.0,\n", + " 82.0,\n", + " 83.0,\n", + " 84.0,\n", + " 85.0,\n", + " 86.0,\n", + " 87.0,\n", + " 88.0,\n", + " 89.0,\n", + " 90.0,\n", + " 91.0,\n", + " 92.0,\n", + " 93.0,\n", + " 94.0,\n", + " 95.0,\n", + " 96.0,\n", + " 97.0,\n", + " 98.0,\n", + " 99.0,\n", + " 100.0,\n", + " 101.0,\n", + " 102.0,\n", + " 103.0,\n", + " 104.0,\n", + " 105.0,\n", + " 106.0,\n", + " 107.0,\n", + " 108.0,\n", + " 109.0,\n", + " 110.0,\n", + " 111.0,\n", + " 112.0,\n", + " 113.0,\n", + " 114.0,\n", + " 115.0,\n", + " 116.0,\n", + " 117.0,\n", + " 118.0,\n", + " 119.0,\n", + " 120.0,\n", + " 121.0,\n", + " 122.0,\n", + " 123.0,\n", + " 124.0,\n", + " 125.0,\n", + " 126.0,\n", + " 127.0,\n", + " 128.0,\n", + " 129.0,\n", + " 130.0,\n", + " 131.0,\n", + " 132.0,\n", + " 133.0,\n", + " 134.0,\n", + " 135.0,\n", + " 136.0,\n", + " 137.0,\n", + " 138.0,\n", + " 139.0,\n", + " 140.0,\n", + " 141.0,\n", + " 142.0,\n", + " 143.0,\n", + " 144.0,\n", + " 145.0,\n", + " 146.0,\n", + " 147.0,\n", + " 148.0,\n", + " 149.0,\n", + " 150.0,\n", + " 151.0,\n", + " 152.0,\n", + " 153.0,\n", + " 154.0,\n", + " 155.0,\n", + " 156.0,\n", + " 157.0,\n", + " 158.0,\n", + " 159.0,\n", + " 160.0,\n", + " 161.0,\n", + " 162.0,\n", + " 163.0,\n", + " 164.0,\n", + " 165.0,\n", + " 166.0,\n", + " 167.0,\n", + " 168.0,\n", + " 169.0,\n", + " 170.0,\n", + " 171.0,\n", + " 172.0,\n", + " 173.0,\n", + " 174.0,\n", + " 175.0,\n", + " 176.0,\n", + " 177.0,\n", + " 178.0,\n", + " 179.0,\n", + " 180.0,\n", + " 181.0,\n", + " 182.0,\n", + " 183.0,\n", + " 184.0,\n", + " 185.0,\n", + " 186.0,\n", + " 187.0,\n", + " 188.0,\n", + " 189.0,\n", + " 190.0,\n", + " 191.0,\n", + " 192.0,\n", + " 193.0,\n", + " 194.0,\n", + " 195.0,\n", + " 196.0,\n", + " 197.0,\n", + " 198.0,\n", + " 199.0,\n", + " 200.0,\n", + " 201.0,\n", + " 202.0,\n", + " 203.0,\n", + " 204.0,\n", + " 205.0,\n", + " 206.0,\n", + " 207.0,\n", + " 208.0,\n", + " 209.0,\n", + " 210.0,\n", + " 211.0,\n", + " 212.0,\n", + " 213.0,\n", + " 214.0,\n", + " 215.0,\n", + " 216.0,\n", + " 217.0,\n", + " 218.0,\n", + " 219.0,\n", + " 220.0,\n", + " 221.0,\n", + " 222.0,\n", + " 223.0,\n", + " 224.0],\n", + " [21.0,\n", + " 22.0,\n", + " 23.0,\n", + " 24.0,\n", + " 25.0,\n", + " 26.0,\n", + " 27.0,\n", + " 28.0,\n", + " 29.0,\n", + " 30.0,\n", + " 31.0,\n", + " 32.0,\n", + " 33.0,\n", + " 34.0,\n", + " 35.0,\n", + " 36.0,\n", + " 37.0,\n", + " 38.0,\n", + " 39.0,\n", + " 40.0,\n", + " 41.0,\n", + " 42.0,\n", + " 43.0,\n", + " 44.0,\n", + " 45.0,\n", + " 46.0,\n", + " 47.0,\n", + " 48.0,\n", + " 49.0,\n", + " 50.0,\n", + " 51.0,\n", + " 52.0,\n", + " 53.0,\n", + " 54.0,\n", + " 55.0,\n", + " 56.0,\n", + " 57.0,\n", + " 58.0,\n", + " 59.0,\n", + " 60.0,\n", + " 61.0,\n", + " 62.0,\n", + " 63.0,\n", + " 64.0,\n", + " 65.0,\n", + " 66.0,\n", + " 67.0,\n", + " 68.0,\n", + " 69.0,\n", + " 70.0,\n", + " 71.0,\n", + " 72.0,\n", + " 73.0,\n", + " 74.0,\n", + " 75.0,\n", + " 76.0,\n", + " 77.0,\n", + " 78.0,\n", + " 79.0,\n", + " 80.0,\n", + " 81.0,\n", + " 82.0,\n", + " 83.0,\n", + " 84.0,\n", + " 85.0,\n", + " 86.0,\n", + " 87.0,\n", + " 88.0,\n", + " 89.0,\n", + " 90.0,\n", + " 91.0,\n", + " 92.0,\n", + " 93.0,\n", + " 94.0,\n", + " 95.0,\n", + " 96.0,\n", + " 97.0,\n", + " 98.0,\n", + " 99.0,\n", + " 100.0,\n", + " 101.0,\n", + " 102.0,\n", + " 103.0,\n", + " 104.0,\n", + " 105.0,\n", + " 106.0,\n", + " 107.0,\n", + " 108.0,\n", + " 109.0,\n", + " 110.0,\n", + " 111.0,\n", + " 112.0,\n", + " 113.0,\n", + " 114.0,\n", + " 115.0,\n", + " 116.0,\n", + " 117.0,\n", + " 118.0,\n", + " 119.0,\n", + " 120.0,\n", + " 121.0,\n", + " 122.0,\n", + " 123.0,\n", + " 124.0,\n", + " 125.0,\n", + " 126.0,\n", + " 127.0,\n", + " 128.0,\n", + " 129.0,\n", + " 130.0,\n", + " 131.0,\n", + " 132.0,\n", + " 133.0,\n", + " 134.0,\n", + " 135.0,\n", + " 136.0,\n", + " 137.0,\n", + " 138.0,\n", + " 139.0,\n", + " 140.0,\n", + " 141.0,\n", + " 142.0,\n", + " 143.0,\n", + " 144.0,\n", + " 145.0,\n", + " 146.0,\n", + " 147.0,\n", + " 148.0,\n", + " 149.0,\n", + " 150.0,\n", + " 151.0,\n", + " 152.0,\n", + " 153.0,\n", + " 154.0,\n", + " 155.0,\n", + " 156.0,\n", + " 157.0,\n", + " 158.0,\n", + " 159.0,\n", + " 160.0,\n", + " 161.0,\n", + " 162.0,\n", + " 163.0,\n", + " 164.0,\n", + " 165.0,\n", + " 166.0,\n", + " 167.0,\n", + " 168.0,\n", + " 169.0,\n", + " 170.0,\n", + " 171.0,\n", + " 172.0,\n", + " 173.0,\n", + " 174.0,\n", + " 175.0,\n", + " 176.0,\n", + " 177.0,\n", + " 178.0,\n", + " 179.0,\n", + " 180.0,\n", + " 181.0,\n", + " 182.0,\n", + " 183.0,\n", + " 184.0,\n", + " 185.0,\n", + " 186.0,\n", + " 187.0,\n", + " 188.0,\n", + " 189.0,\n", + " 190.0,\n", + " 191.0,\n", + " 192.0,\n", + " 193.0,\n", + " 194.0,\n", + " 195.0,\n", + " 196.0,\n", + " 197.0,\n", + " 198.0,\n", + " 199.0,\n", + " 200.0,\n", + " 201.0,\n", + " 202.0,\n", + " 203.0,\n", + " 204.0,\n", + " 205.0,\n", + " 206.0,\n", + " 207.0,\n", + " 208.0,\n", + " 209.0,\n", + " 210.0,\n", + " 211.0,\n", + " 212.0,\n", + " 213.0,\n", + " 214.0,\n", + " 215.0,\n", + " 216.0,\n", + " 217.0,\n", + " 218.0,\n", + " 219.0,\n", + " 220.0,\n", + " 221.0,\n", + " 222.0,\n", + " 223.0,\n", + " 224.0],\n", + " [78.0, 79.0, 80.0, 81.0, 82.0, 83.0, 84.0]]" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "bboxes = scenic_world.predicate(lambda obj:obj.object_type == \"vehicle.car\").get_geo().execute()" + "frame_num = scenic_world.scenic_trajectory_to_frame_num(car_trajectories)\n", + "frame_num" ] }, { "cell_type": "code", - "execution_count": 9, - "id": "53bed3ac", - "metadata": {}, + "execution_count": 12, + "metadata": { + "scrolled": true + }, "outputs": [ { "data": { "text/plain": [ - "(2004, 6)" + "[('scene-0061',\n", + " '0101000080B998A40B18AF7940FC6CF9B2A36F92400000000000000000',\n", + " '01010000803318EB831857E23F4601F891FA8650BFBCAC591AF77B8B3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 3,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080F3524E4E348F79409DFF2E24F95992400000000000000000',\n", + " '0101000080B2ECA093516BE23F5F908AAA2838643F01D6BE9AF2EB8C3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 11,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080BAA395B3466F7940B96C5B7B814392400000000000000000',\n", + " '0101000080BCFD474BB999E23F104DA5BF8C3D403FC56F97F716CF883F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 19,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", + " ('scene-0061',\n", + " '01010000801D00D6DEDF5379409616A483732F92400000000000000000',\n", + " '0101000080BBED8D5513B0E23F205977E90603203FC09D6ACDCE5E863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 27,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", + " ('scene-0061',\n", + " '01010000804A25EE8BAE3A79405355481ECD1C92400000000000000000',\n", + " '010100008062050084FDD1E23F4C388BC38D484FBF5AC0654E90C7883F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 35,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", + " ('scene-0061',\n", + " '01010000808A9426862D217940F9EC95CA440992400000000000000000',\n", + " '0101000080AC5DF8ED5BECE23FDC033CC72E4D60BFBDD6EBFC0D5F8F3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 43,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080318C6E43B8B679406CA968E8C97492400000000000000000',\n", + " '0101000080629FBC42E04DE23F04031074368F61BFEA0FFB8DEAAE873F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 1,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080E6201DFA5B0B794004278515F1F791400000000000000000',\n", + " '0101000080284DAE64E509E33F5D22C36F93D868BF6493FE0A090D893F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 51,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080D4C306D766967940C1438543F15E92400000000000000000',\n", + " '0101000080B8B1C149C665E23F908353A74AFC333F849671E1BAF5893F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 9,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", + " ('scene-0061',\n", + " '01010000804B3AC04518F77840A4A2E58F59E791400000000000000000',\n", + " '01010000800012721B7534E33F42C87137257550BF803344E6AD20853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 59,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", + " ('scene-0061',\n", + " '010100008058B01C59F277794083333CFAC44992400000000000000000',\n", + " '01010000800D9D4FF28A88E23F986F61E8F0C84FBF8EA3025BB2528C3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 17,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080E291B5066FA27940DCB4F9A62C6792400000000000000000',\n", + " '0101000080E468DC088C58E23F20FC81130C2267BF2DB78637DA438C3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 6,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080691A922642E278400214976219D591400000000000000000',\n", + " '0101000080D49B86CC5995E33F0889C2F64A5E493FFE1E1DCD8D8B8B3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 67,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", + " ('scene-0061',\n", + " '01010000803682DAD72E5A794067E5CEDD133492400000000000000000',\n", + " '01010000804A24C37ED0ABE23F18015B122F0240BF5314274B1D70873F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 25,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", + " ('scene-0061',\n", + " '010100008094C5A4296BA77940DA939866896A92400000000000000000',\n", + " '0101000080F4C49C1C3256E23F34D262D5D24F64BF5C2DB409DA618B3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 5,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", + " ('scene-0061',\n", + " '01010000802EB00E2600AA79409BF032313C6C92400000000000000000',\n", + " '0101000080CAC560F86656E23F3C948A1D816A62BFE0F6C7E0B34F8C3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 4,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080BA1FD0705E8379404BBBBC6BC95192400000000000000000',\n", + " '01010000809E793F9A2278E23F63C771DE009765BFBBFAD4847B31893F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 14,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080541B19AC0DD27840D15F6D1BDFC391400000000000000000',\n", + " '010100008084C44981A359E43F6E676948F7427ABF83720A3E2E68933F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 75,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", + " ('scene-0061',\n", + " '01010000801A7B9BB5434079400A558D8B0F2192400000000000000000',\n", + " '01010000802EFFBD0D54C8E23F189E05C2B6763BBF558CA35F1EB8893F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 33,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080C7294C65778A794052F40EC2AE5692400000000000000000',\n", + " '01010000800CA3B068E071E23FAA78E6698ED35E3F162B251FBDBB8D3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 12,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080176C936220B479405805FC4D107392400000000000000000',\n", + " '01010000809472DF49AF4EE23FAFF5E2265FD258BF41FF532CBE60883F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 2,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080F16BDEC7C8857940B5D5D6BE715392400000000000000000',\n", + " '0101000080689A392D9778E23FADBA1EB9B2C255BF989B45F56C328B3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 13,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", + " ('scene-0061',\n", + " '01010000801F0D15CE9C647940283157F5B43B92400000000000000000',\n", + " '0101000080DEEC0281BBA3E23FA08A619ECFB9353F3AC3B6754E3F8B3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 22,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080486DCEC9E6C778407AB044264DB491400000000000000000',\n", + " '0101000080E855C900AA56E53F72505B75DADD89BFD3AA1A10E1868F3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 83,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", + " ('scene-0061',\n", + " '010100008046F5B8569C9D79405E7CE37EE16392400000000000000000',\n", + " '0101000080B5EB11EA2760E23F9D3D5E3EE5955EBF5D465C0801038D3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 7,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080E942F4B0482879408AE5BE14C40E92400000000000000000',\n", + " '01010000806921C51760E6E23F4CCA43A765125FBFE09A6AD84AD98D3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 41,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", + " ('scene-0061',\n", + " '01010000804E6F452E969179404F9E60DA9E5B92400000000000000000',\n", + " '0101000080F27953BFEA6AE23F628563DA6DD15D3F9D671639AE6A8B3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 10,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", + " ('scene-0061',\n", + " '01010000803D309B241F6D79403CF71E02EE4192400000000000000000',\n", + " '010100008007DC95D49A9CE23FC89F67D8DA67463F040EDF8DEF3B893F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 20,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", + " ('scene-0061',\n", + " '010100008085DC1FDDD6687940BFB767FCCE3E92400000000000000000',\n", + " '0101000080304B95BB39A0E23F28F3DC9DD5C7483FEEA44C9096D98A3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 21,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080DE747CDB8FC478403484BD71E0A691400000000000000000',\n", + " '01010000804FE3FC3E0DACE63FF8E0262A5DE187BF8E9F97E5569D8D3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 91,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080177910F5D64979405FC5474D312892400000000000000000',\n", + " '0101000080ED9070C0CCB7E23F100DBB31369F483FE7962323E723883F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 30,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", + " ('scene-0061',\n", + " '010100008057FB0BD9B97E794030A80BBD8A4E92400000000000000000',\n", + " '010100008086B71FE4947CE23F4201C3D48AEE67BF3A28DD8CDA08883F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 15,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080EAE960C6311079409AC06FCDCFFB91400000000000000000',\n", + " '010100008011723B29D106E33F0AF110D6227F5CBFC804EC0F267B8A3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 49,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", + " ('scene-0061',\n", + " '010100008049346597917379408016B7CCA04692400000000000000000',\n", + " '010100008078664A3D1791E23FE0E9D0C006621A3F526A2960F7BF893F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 18,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080113A84CECA4F794054903BC17D2C92400000000000000000',\n", + " '0101000080EB75B373ECB2E23FD02073EE75D5433FD2BCFD398E69863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 28,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", + " ('scene-0061',\n", + " '010100008035A97241CB4D7940802083800F2B92400000000000000000',\n", + " '01010000807C2EB959DAB2E23FF885BB01CC98473F53DCDB2CFC01873F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 29,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080B7C406B0AEC87840EC4285125E9891400000000000000000',\n", + " '01010000800F8FBEE67435E83F4011507EB43389BFCDE4956DD3B5853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 99,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080E2912B4C50317940C1359004AB1592400000000000000000',\n", + " '0101000080E425C098C8DBE23F40CBC5E218A867BFEFB8166A8CD2893F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 38,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", + " ('scene-0061',\n", + " '010100008099245FB38762794096C9003C2C3A92400000000000000000',\n", + " '0101000080CBEE7B92D4A5E23F3886272D27C0363F127A1CE393CE893F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 23,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", + " ('scene-0061',\n", + " '01010000806A394EB48DFB78405875E67213EB91400000000000000000',\n", + " '0101000080D65947CE6829E33FD2AD670F78C553BFB739BE7FDB9A853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 57,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", + " ('scene-0061',\n", + " '010100008093C31D540E58794007503C7E863292400000000000000000',\n", + " '01010000807F87AB1F4BABE23F9CA8E84BE95A43BF5188649E3D4C873F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 26,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", + " ('scene-0061',\n", + " '01010000808BF5C46AF9367940158159C5F81992400000000000000000',\n", + " '0101000080A878969912D5E23F31467A8E1EB458BFEEC0AFF02B49883F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 36,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", + " ('scene-0061',\n", + " '010100008092792D7D2E33794085E2FA8D1A1792400000000000000000',\n", + " '01010000800A18DA51CED9E23FCFD4890B356764BF791FA7D314EB883F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 37,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", + " ('scene-0061',\n", + " '01010000806D8E7AA31AD478401475E9D6418B91400000000000000000',\n", + " '01010000807D1F02ED5CA4E93FA7CE2A2067D98CBF02D042E2673A853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 107,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080473DB9B28B18794004E0D15C810292400000000000000000',\n", + " '0101000080423199492DF6E23FCEFE2102BDB856BF42C301A2E3F9903F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 46,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", + " ('scene-0061',\n", + " '010100008060D99B3BFF4579407A66C0EF592592400000000000000000',\n", + " '010100008050CA2A4BBEBFE23F9869E79E0AA33E3FE2762AE4695F893F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 31,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080BDB3604EFAE87840F065AB2C36DB91400000000000000000',\n", + " '0101000080189CF1907469E33F18FE59072729323F1FB3DDA65FA1873F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 65,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080EEDE31E1EE1B7940CF161DF12C0592400000000000000000',\n", + " '01010000809699447685EFE23F301C6A95D7A65ABFDC0D21BB38CF8F3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 45,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080D70A05B4853C79401F727927371E92400000000000000000',\n", + " '0101000080742E5FE27FCDE23F86BDBB751D1148BF142AFDCF7CB4883F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 34,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080D2AECBDB651F79404740AF00E30792400000000000000000',\n", + " '010100008025AAABF89EEBE23F364A09B1576D61BF24E1555FE4728F3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 44,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", + " ('scene-0061',\n", + " '01010000801E4E8B23A3E37840CD5B3634E08091400000000000000000',\n", + " '010100008031795A37F8E2EA3FDEB617C0791893BFBD77A1EF296C883F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 115,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080A8FA7C325E037940E13430BD82F191400000000000000000',\n", + " '0101000080B807F8817F18E33FF199FCF1575553BF81EC2D85B271873F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 54,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", + " ('scene-0061',\n", + " '010100008056824630982D7940659E908FDC1292400000000000000000',\n", + " '0101000080C82353DEF6DEE23FD7AEFFA94F9C66BF54AAE044C6068B3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 39,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", + " ('scene-0061',\n", + " '01010000801D018237BD2479406D8A9627050C92400000000000000000',\n", + " '010100008004CE7C7494E9E23F17354122C11D59BF15FB734669508E3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 42,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", + " ('scene-0061',\n", + " '0101000080C7696EF9D1D4784008019E7F3CC791400000000000000000',\n", + " '0101000080086ACB72EE2BE43FC4F76ABA06DD76BFA107CA88AD7A913F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 73,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", + " ('scene-0061',\n", + " '01010000802275CEDB8806794027358C0D15F491400000000000000000',\n", + " '010100008047296666E60DE33F4875EDA3160363BF802E4322287B883F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 53,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", + " ('scene-0061',\n", + " '01010000802C764DAF24087940DFA37BF45EF591400000000000000000',\n", + " '010100008092681C268A0CE33F98DB7FDA7A3768BF86B7DB905B3E893F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 52,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080427605012CFB7840B2DE6E981A7691400000000000000000',\n", + " '0101000080E3C9EE125928EC3F33C6B12B1B9997BF5C117E96768B8A3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 123,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080E155BF6CE3EF78406BB9DF3138E191400000000000000000',\n", + " '010100008085B2CACFD249E33F3E6040E5847341BF14B681D7C5E6833F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 62,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080A289A378DA1679404218C0D3290192400000000000000000',\n", + " '010100008004E42BC4E6F8E23F0093E4F354E35ABF423C14F5A9A8903F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 47,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", + " ('scene-0061',\n", + " '010100008074515C81201679407DA910A3386D91400000000000000000',\n", + " '0101000080D85293CB2826ED3F73209C790D6299BFCABC335FD7EF863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 131,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", + " ('scene-0061',\n", + " '01010000809D5EBE8733F47840B9FB0B77E9E491400000000000000000',\n", + " '01010000803E67B704C53CE33F9FCB7DD1F1BC57BFC91339E6C3B8853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 60,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080089DA60338CA78409773868EAEB891400000000000000000',\n", + " '01010000805A6C123EB103E53FDC01F9A6275982BF13602ADE149A923F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 81,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", + " ('scene-0061',\n", + " '01010000802F7A5798980E79406897D33486FA91400000000000000000',\n", + " '0101000080369EA1959D09E33F4E576149B6D263BFDEA8155BF332893F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 50,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", + " ('scene-0061',\n", + " '010100008090CCC75850F17840D6D22A0476E291400000000000000000',\n", + " '0101000080520F3EB1B444E33F6A1DD3D82C2449BFE0158EBAA618843F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 61,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", + " ('scene-0061',\n", + " '01010000806F2CFB2B26DC7840A7DA77932ECF91400000000000000000',\n", + " '0101000080903898B971CDE33F1C03FA44FED94BBF9FA20A56970C903F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 70,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", + " ('scene-0061',\n", + " '010100008087201F26260079401BB2330FE6EE91400000000000000000',\n", + " '01010000804DF97D276B1DE33FB85EBF5219D144BF29813D562BF4853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 55,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080879F851F563479403029D3B0986591400000000000000000',\n", + " '0101000080F193E0E3C0E8ED3FCC509780A7C69BBF3C6616EC4AA0863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 139,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939412460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080DE2BF900BEC4784052D0C2D1F1A991400000000000000000',\n", + " '010100008087344197A857E63F8CED85AECD9287BFFA3018A054588D3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 89,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080814FB5FFB2DF7840A7DF0D73B0D291400000000000000000',\n", + " '01010000808A5B05BF50A9E33FF04FAE491D6A3A3F413472ECA3E18C3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 68,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080204A552294F878404F2D32A097E891400000000000000000',\n", + " '0101000080CF78A846B430E33F0B763C871C3C54BF9A6A278BDBA4853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 58,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", + " ('scene-0061',\n", + " '010100008081EE8B12E1CD7840D6FEC07B46BE91400000000000000000',\n", + " '0101000080501C46A626A2E43F787A409EE1D979BF16CBF84909B4973F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 78,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080B1A58ED510ED7840214088E3C1DE91400000000000000000',\n", + " '0101000080AC3EDF381556E33F326FA76CB43648BFCC4A3BA40C92853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 63,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080EA26FF5C925579404B8FC5FAEE5E91400000000000000000',\n", + " '0101000080D4CCB311047EEE3F38BEE3B60A21A0BF4EC3728B186D853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 147,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940112460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080BE1ADD2D66C6784099AB8EC2109D91400000000000000000',\n", + " '010100008051003BF37FB6E73F8BF3770CD8B489BFB83283D5CDC1873F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 97,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080D4B6F79554D0784004DD89289DC191400000000000000000',\n", + " '0101000080BA234930117AE43F886DDEF8074A76BF10177D61CD91953F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 76,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", + " ('scene-0061',\n", + " '01010000804E1508CC91E37840DFCBB7924ED691400000000000000000',\n", + " '01010000804CAE784B038DE33F862423575492533F2A41C4FB87D7893F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 66,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080D7E6D06FD7C5784034C667030BAF91400000000000000000',\n", + " '010100008037A00122BED1E53F58B07B317B798ABFE2158C85E0438C3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 86,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080A80D75884BDD7840D569A90058D091400000000000000000',\n", + " '0101000080D18DF0C223C0E33FC04B42AE047B2DBF3599837835F08E3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 69,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", + " ('scene-0061',\n", + " '010100008024BAB9C4FAD9784094D40734E8CC91400000000000000000',\n", + " '01010000809E3DDE52BFE7E33FD139410E8FE85CBFCFEA1B98243A903F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 71,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080F468F0FD4D727940B87BC943345A91400000000000000000',\n", + " '0101000080ED60F63428D2EE3F0D37225E8B859EBF20F56046C479813F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 155,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940762460.jpg'),\n", + " ('scene-0061',\n", + " '01010000801F8961299BCF78404B2736796D8F91400000000000000000',\n", + " '0101000080DA70360BCE2FE93F3C5A466EDF6589BFCBEFC8924B94853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 105,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", + " ('scene-0061',\n", + " '01010000801965FB666DC778403C9C5FED3AB391400000000000000000',\n", + " '010100008046F91107EE6DE53FF069D24649608ABF3C91CFC48269903F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 84,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", + " ('scene-0061',\n", + " '01010000808ECF5F20F5D27840FF6CA16AFEC491400000000000000000',\n", + " '0101000080F497CB03B24CE43F3042D6D1E82F7ABFFFE757480182923F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 74,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", + " ('scene-0061',\n", + " '01010000806F97CA1808C578403C55FA4EEEA191400000000000000000',\n", + " '0101000080964DB3CDEA31E73FDE18DC3139058DBF8C73D23323A08D3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 94,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", + " ('scene-0061',\n", + " '01010000805167C0C2ACCE784088A248F25BBF91400000000000000000',\n", + " '01010000802D6914739795E43FFA50904D72B176BF13DF1768E29C973F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 77,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", + " ('scene-0061',\n", + " '010100008014F22B1555CC7840A8C267210EBC91400000000000000000',\n", + " '0101000080BC8DC8BF7AC3E43F0D26990F797C80BF5CC1564F0F94963F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 79,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080D425F8A7128D7940A2274AB9655691400000000000000000',\n", + " '01010000802B6E4FAAEA0DEF3FE050DE3B9DC19BBF765BD509E71A7C3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 163,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941412460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080E9D7DBD67DDF7840E9240866428391400000000000000000',\n", + " '010100008098AE1E3F7A99EA3FDF061215EE9692BF24784EA663A4893F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 113,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080883BC7F3F5C8784096D829AE73B691400000000000000000',\n", + " '0101000080FBF4769F6C2BE53FDE150693912C87BF8073FDEAED82903F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 82,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080CD0B94E4A0C4784046FF60A0E4A491400000000000000000',\n", + " '0101000080A5A5AF923BE3E63F485D990B136289BFEC3B4DF59FA28D3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 92,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080715E1180C7CB78406CE7A03ADE9391400000000000000000',\n", + " '0101000080965BC2419AB6E83FE4DAC790D6918ABF24F4BFD2EDD4853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 102,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", + " ('scene-0061',\n", + " '01010000809FEEF2D28EC67840843925E71CB191400000000000000000',\n", + " '0101000080019A26C3749EE53FAAA6FC17ACCA8ABFD3C84B93C782903F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 85,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", + " ('scene-0061',\n", + " '010100008004A312078EC5784098A2F2D601AE91400000000000000000',\n", + " '0101000080842B9A9151EEE53F3C59DED2CF748BBFC3B72FC6A4018D3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 87,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080F1086CDC2E9B794082FCF58B396292400000000000000000',\n", + " '01010000803F1FAC8A3762E23F6AEA2C02990452BF292AD0330BFE8B3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 8,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080C4182592A9A77940F04C102C0C5391400000000000000000',\n", + " '01010000804C000A21AF32EF3FF7F9692E26129BBFB360757B4E7A7A3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 171,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942112460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080A2AD79798DF378401A3D6A74327991400000000000000000',\n", + " '01010000807AD7E032C1CCEB3FEFCCD3B441B695BFB65DEAD59C7A883F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 121,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080D75DA7DBD0C978409C7A7FAA939691400000000000000000',\n", + " '0101000080C82F7BAA4F69E83F5236F713CB838ABFBA5D3FF937D1863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 100,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080D3C35795A2C47840E9B38C3EF0A891400000000000000000',\n", + " '01010000800A498E4E6872E63F650E9FEAAE4987BFC825AA35B1678D3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 90,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", + " ('scene-0061',\n", + " '0101000080B127C1BD4DD97840946110FF468791400000000000000000',\n", + " '0101000080E4B0B186F61CEA3F16EB034EB5E68FBF2B27638524A6873F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 110,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", + " ('scene-0061',\n", + " '01010000804C7106F5B7C47840AB9F4B9EEBA391400000000000000000',\n", + " '01010000807DD62C9E35FDE63F74C46AB3069B8BBF92667CC25A628F3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 93,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", + " ('scene-0061',\n", + " '01010000800012498075C57840689908B5F79F91400000000000000000',\n", + " '01010000808930F4A2BA65E73F0C0B67E202BD8DBFA90ED6FAE9EC8B3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 95,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", + " ('scene-0061',\n", + " '010100008001C7E3722B7A7940B070B797594B92400000000000000000',\n", + " '0101000080C667BACE7B84E23F864C0755CEF957BFC7886379278C8B3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 16,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", + " ('scene-0061',\n", + " '01010000801B078DDA03C27940D4E99664EA4F91400000000000000000',\n", + " '0101000080ECE74C60823CEF3FC852E523BEFA99BF4664B7B8ADC5823F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 179,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942862460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080CBA42EA58B0F7940A8345C892B6F91400000000000000000',\n", + " '010100008083FE492104F3EC3F0D63F647205B97BFA01E4C567D2F863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 129,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", + " ('scene-0061',\n", + " '010100008053337A90A6C7784050AC74573F9A91400000000000000000',\n", + " '01010000804F2B6516E501E83F705F2BDB0BCE89BFA44FEE4BCC15863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 98,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", + " ('scene-0061',\n", + " '010100008055E3874E0CD67840098E84E9B18991400000000000000000',\n", + " '0101000080123FF3CDA4D4E93F1890BF42A8CC8EBF221B02CC2F7A863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 108,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", + " ('scene-0061',\n", + " '01010000808D98945109EB7840685DEB330D7D91400000000000000000',\n", + " '0101000080551B370DB458EB3F396B045C462192BFD6DD2147C3C2853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 118,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080648A235C70CA7840A239EC4AAE9591400000000000000000',\n", + " '0101000080D916DB8EE283E83FAC93090716FA8BBFEAA029C30D95873F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 101,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", + " ('scene-0061',\n", + " '010100008005124EF139CD784023581ABA0E9291400000000000000000',\n", + " '01010000801E900693A9E6E83F89BE0D570A9E8ABFD4CD4C987EDD853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 103,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", + " ('scene-0061',\n", + " '01010000804D7D4AAC565E79401CF9AB991D3792400000000000000000',\n", + " '01010000809A42F1F393AAE23F10FC466ACE662EBFE2A7D9BDB94D883F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 24,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", + " ('scene-0061',\n", + " '01010000805EA23AF817D87940049588FF554D91400000000000000000',\n", + " '01010000802F38D66DD93DEF3FB9A363FA691697BF6EF9264322F7883F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 187,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943512460.jpg'),\n", + " ('scene-0061',\n", + " '01010000809CD3E39B0A2D7940E43638FE476791400000000000000000',\n", + " '0101000080462B807F92C1ED3FC3AE69FD7E859ABFFE23D284CCF5873F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 137,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939262460.jpg'),\n", + " ('scene-0061',\n", + " '01010000808371D3B748D27840E55E566EDC8C91400000000000000000',\n", + " '01010000804C8A54807279E93F3B77579C83F48ABFF97F30782470863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 106,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080186E3C9F82E678401E0585FD547F91400000000000000000',\n", + " '01010000802BB93F298512EB3F0BC6EE70D0B192BF7E5B334434DA863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 116,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080F39B016221057940CCC087E3847291400000000000000000',\n", + " '01010000803EED62FBD390EC3F49A60FFEE3C896BF88529731A1CF8A3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 126,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080C4DF975017D7784060BE5064E38891400000000000000000',\n", + " '0101000080AEDEA679F2ECE93F85D536B65C778FBFC1691D1EDDB2863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 109,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080D60A94BBA7DB7840BEF5D725AE8591400000000000000000',\n", + " '0101000080AD9CDB6E9E4DEA3FDD8A1182665F90BF23DE415AD054883F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 111,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", + " ('scene-0061',\n", + " '010100008079E639200F447940D85538B9EA2392400000000000000000',\n", + " '01010000809EED188D50C2E23F6004E229883D333F0E771989B2A9893F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 32,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080F13916AC48EE794019C74305BE4A91400000000000000000',\n", + " '01010000805DF53DC1A13EEF3FEF15CC536D3497BF5938EC1D936F8A3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 195,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944162460.jpg'),\n", + " ('scene-0061',\n", + " '01010000805865E2D9144C7940B9B3BB73B26091400000000000000000',\n", + " '0101000080EDA73E38445BEE3FEDB78675C0A79EBF1E20BA9C1E4B843F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 145,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939912460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080C5A5235222FD784011A9707E5B7591400000000000000000',\n", + " '0101000080EB7C741E2E3EEC3F7C0DCAF9D24097BF5ABF9F4AF1968B3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 124,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080C0D96FAF3CE27840D28F779DA88191400000000000000000',\n", + " '01010000809F038437D1CAEA3F6AE3BC445A3693BF7C4788928B22893F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 114,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080BCDB4E8837217940AAF8C144366A91400000000000000000',\n", + " '0101000080E4A23478CA78ED3FB8C435D30F5C9ABF86120D0509FD853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 134,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", + " ('scene-0061',\n", + " '010100008053577F177EE9784013122A7BCF7D91400000000000000000',\n", + " '0101000080CA3949AD4741EB3FACBDEB65EA2492BF30AD5F39C354853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 117,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", + " ('scene-0061',\n", + " '010100008094C90B682C057A404DA408D41B4891400000000000000000',\n", + " '010100008034862686594BEF3F070871C0C46C96BF7480ABED614B8A3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 203,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944862460.jpg'),\n", + " ('scene-0061',\n", + " '01010000802EB5928E53EE78403E47BCCB817B91400000000000000000',\n", + " '0101000080B98A176C0A8AEB3FF8726294540593BFCCBBD712E2B4863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 119,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", + " ('scene-0061',\n", + " '010100008083414089082A79403846393B1F1092400000000000000000',\n", + " '0101000080787CA4164DE4E23FB2118A0FC15E64BFC5B6230F56AD8D3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 40,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080363ACBADF36B7940527D1A06305B91400000000000000000',\n", + " '01010000802B42489CA8C2EE3FA7A5DFE36BCA9DBF6FC2948C8E44813F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 153,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940612460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080CF482E974BF7784034EDBCFFA17791400000000000000000',\n", + " '01010000801C7B420D5BFBEB3F847D4F77E48697BF4E1B7C9F9895893F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 122,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", + " ('scene-0061',\n", + " '01010000809F6F4454A81A79400E608410F46B91400000000000000000',\n", + " '0101000080CC76FFA2C748ED3FD42F5A09AC499ABF5C0097786E12873F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 132,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080A074CECA24407940ECA6EA560C6391400000000000000000',\n", + " '0101000080D504A8320326EE3F53D041E32AEF9ABFB095A0B23251873F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 142,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939662460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080E85095261001794012B7167BEC7391400000000000000000',\n", + " '0101000080E8CE8A10C667EC3F8DD2D31CB8AA96BF7C251A725F238D3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 125,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080D4DD5EB2771F7A40703D011A604591400000000000000000',\n", + " '0101000080FFBEEB4AF67CEF3F23C2CD2D6D3997BFF3654B01585C853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 211,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945612460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080BB689862320779405E9D4782D27191400000000000000000',\n", + " '01010000807E23294E0BA5EC3F1C6C6696D3A596BFC0A0DD43728B883F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 127,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", + " ('scene-0061',\n", + " '010100008028BFE014741379403609BC0E74FE91400000000000000000',\n", + " '0101000080CC41A4D29FFFE23FF664826936B757BF542F01D6FDE08D3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 48,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", + " ('scene-0061',\n", + " '01010000801CE2D842148779400F70D6C9345791400000000000000000',\n", + " '0101000080ECB8CB616E00EF3FA5F53A0EDE969CBF8758253DF2477E3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 161,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941262460.jpg'),\n", + " ('scene-0061',\n", + " '010100008011F49472183979402F643CA88B6491400000000000000000',\n", + " '01010000808FCB4C8D8802EE3F798C59CCB7899BBF8E45696D54CD853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 140,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939512460.jpg'),\n", + " ('scene-0061',\n", + " '01010000805E2D6E9DB0117940D7295CE4846E91400000000000000000',\n", + " '01010000807B5E0AA6DF04ED3F6EDBDBFA9EC897BF0457562A3D70863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 130,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", + " ('scene-0061',\n", + " '01010000807A04F14AEA6079404D416A81F75C91400000000000000000',\n", + " '0101000080A10A5733FAA2EE3F16D7DECE0E409FBF16747FB35521833F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 150,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940362460.jpg'),\n", + " ('scene-0061',\n", + " '010100008099609317D31C7940C35FA1B15F6B91400000000000000000',\n", + " '0101000080100F6BDC8359ED3F9F62AB5024629ABF23C616030BBF863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 133,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080BE887E1BF2257940D1A11427016991400000000000000000',\n", + " '0101000080261D5492EF96ED3F6ABD8242C0169ABFB0218C9B47D8853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 135,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", + " ('scene-0061',\n", + " '01010000807129425E23A0794005C172B4F45391400000000000000000',\n", + " '01010000801489BB34332CEF3FFC3E7BA34F989BBFBB0ED2C87AF7783F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 169,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941912460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080D3168C5895FE784059F7C28E9AED91400000000000000000',\n", + " '01010000809421214A8122E33F2C73FC9D1ECA49BF2AB10C829695853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 56,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080208B266DDE577940A8B0C5CE855E91400000000000000000',\n", + " '01010000808446D68B8685EE3F25C011B52ED39FBF2ACC14FEB70C853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 148,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940162460.jpg'),\n", + " ('scene-0061',\n", + " '01010000807A9522F1EB31794009830475256691400000000000000000',\n", + " '010100008089D355493ADCED3F0C910785464E9BBF1E280722C75B873F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 138,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939362460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080D652EFDBDF7C7940C9A31C6FA15891400000000000000000',\n", + " '01010000803585C4A44CEBEE3FEC81F80F8B469EBFB21E8A17E1EC813F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 158,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941012460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080ACA17EF0C43D79405389B5DD8A6391400000000000000000',\n", + " '0101000080FD7599752C1AEE3F902C4FB7031D9BBF42719495EFD7863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 141,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939612460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080C5696E1CE04479409C12E7F2186291400000000000000000',\n", + " '010100008054BC4D09C53CEE3F485492F261559BBF42C4FB26ACAA863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 143,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939762460.jpg'),\n", + " ('scene-0061',\n", + " '010100008092579AB345BB7940C61EB0FDB55091400000000000000000',\n", + " '0101000080D1B5C6DFD63AEF3F5432AD2A44C098BF657C4A70A6B47A3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 177,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942662460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080A41677A456EA7840E3EF3CC564DC91400000000000000000',\n", + " '0101000080CED04230C963E33F80EC5D2152ECFB3EFC9EE88842B1863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 64,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", + " ('scene-0061',\n", + " '010100008003CC3B32847679402960101C905991400000000000000000',\n", + " '01010000808AF5483ADBDBEE3FCDAE267C71819FBF1A54D9969284813F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 156,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940862460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080EB02EAC3E150794070196338CA5F91400000000000000000',\n", + " '0101000080349C3FBA376DEE3F800495B65626A0BFB626AB05123A853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 146,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940012460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080DEA3D0C0CA967940599AA8691F5591400000000000000000',\n", + " '010100008002455D8A151EEF3FF459D8F81C909CBF805FD662A9597C3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 166,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941662460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080ABA40A897A5C794001D98014B85D91400000000000000000',\n", + " '0101000080B2AE2DD2B094EE3FB8CDAA4AFC419FBF395BD3A62186833F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 149,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940262460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080CEF9BDDF2F6379407030054B975C91400000000000000000',\n", + " '0101000080FF878D3D08AAEE3F35906305C2B99EBF8273A6E233CC823F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 151,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940412460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080A546278016D37940F2CB1AEAEA4D91400000000000000000',\n", + " '0101000080A02016D17B3CEF3F05393600C93398BF1E0667664242863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 185,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943362460.jpg'),\n", + " ('scene-0061',\n", + " '010100008036995B22076E7940D9CA4BF5DC5A91400000000000000000',\n", + " '0101000080AC149716D5C7EE3F5BF89E4BA9C19DBF3EC0876E8B94813F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 154,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940662460.jpg'),\n", + " ('scene-0061',\n", + " '010100008005844179DB907940973BF051E55591400000000000000000',\n", + " '0101000080D7A573E2E214EF3FA967503A01DA9BBF55E055C8F7797C3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 164,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941512460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080CAA47D35DCD778402C4EF94EA5CA91400000000000000000',\n", + " '0101000080009908096102E43F5D3CBF775F9E6DBFF1C36DE3F44C903F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 72,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", + " ('scene-0061',\n", + " '01010000802E06FD7CCCB07940FDCCFD83F55191400000000000000000',\n", + " '01010000801A6F9C967437EF3F5EBBB0070D429BBF8EBDCAE7FD55783F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 174,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942362460.jpg'),\n", + " ('scene-0061',\n", + " '010100008036C7A91AB47879407CCEBFDD3C5991400000000000000000',\n", + " '0101000080B20494441CE1EE3F2954C5A6EC1C9FBFB7E8EC7427B9813F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 157,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940912460.jpg'),\n", + " ('scene-0061',\n", + " '01010000809A6314D958E97940A9A759AE504B91400000000000000000',\n", + " '010100008034B7F0144E3FEF3F54E72E98409C98BF8CF67335D8E6873F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 193,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944012460.jpg'),\n", + " ('scene-0061',\n", + " '010100008000A7D3F400817940261288BB0B5891400000000000000000',\n", + " '0101000080574931EF76F4EE3F158591869CC99DBF8D2DF8847FF2803F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 159,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941112460.jpg'),\n", + " ('scene-0061',\n", + " '010100008054BE7112FE8A7940665DE5D2AC5691400000000000000000',\n", + " '01010000806A9183135F09EF3FD54F11FF25239CBF1FD70A63F97A7D3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 162,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941362460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080C9484A2E6CA979404CB50FD7D55291400000000000000000',\n", + " '01010000800EDEE720D033EF3F6BC8D45B7D5A9BBF72B88E92C3EB7A3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 172,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942162460.jpg'),\n", + " ('scene-0061',\n", + " '010100008069162BF2B7CA7940E96BBEBAE54E91400000000000000000',\n", + " '01010000804F248E19B13CEF3F74BA77E870CD97BF222BE2CCAFAF823F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 182,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943112460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080894A8BFFE0CA7840DEA013DFC9B991400000000000000000',\n", + " '0101000080A57ACEA290EDE43FFF1EA8F15A0581BFD887EFCB12FF933F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 80,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", + " ('scene-0061',\n", + " '01010000809D45BFF2D29479401C786867605591400000000000000000',\n", + " '01010000804D14DCD6F21AEF3F294F6CF2CBA09CBFED0CBA77E4B67B3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 165,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941612460.jpg'),\n", + " ('scene-0061',\n", + " '01010000805E7A6D3A8BFE794061E581E0DD4891400000000000000000',\n", + " '01010000809CEC79CA7745EF3F663BA9BEF54697BFE656449D60EE893F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 201,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944662460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080BC8D8A54819A7940FFB495C9A65491400000000000000000',\n", + " '01010000804423132C2024EF3F4EF1DE730C069CBF9AA64D7A45CC7A3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 167,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941762460.jpg'),\n", + " ('scene-0061',\n", + " '01010000804D553251B8C3794034358468B74F91400000000000000000',\n", + " '0101000080A6B2BBA0483CEF3F10BC479EE6069ABFA6DB9251E622833F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 180,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942912460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080665AF4B501A47940A6DB5FFA7B5391400000000000000000',\n", + " '010100008013CA82C0B02FEF3F50617A3C122C9BBFA2D08C0DBA41793F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 170,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942012460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080F1B644F0AEE079405D7BAB3D534C91400000000000000000',\n", + " '0101000080766E95B8C03CEF3F96B44BBF4F9296BFE47C8C42D60A893F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 190,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943762460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080910DFC7E14C5784097D0B32CF9AB91400000000000000000',\n", + " '01010000807D88B6426325E63F862F5E2E6DC089BF95E5D97BE5F78C3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 88,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", + " ('scene-0061',\n", + " '010100008070BD44D528AD7940F8CD4F6D625291400000000000000000',\n", + " '0101000080D76BD05D9535EF3F0E9499F251C79BBF5D76274FF246793F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 173,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942262460.jpg'),\n", + " ('scene-0061',\n", + " '01010000803507811A53187A40D5F76913104691400000000000000000',\n", + " '0101000080FF4877D20A6EEF3F53815C18679A96BFE0EA26EAD3F3853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 209,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945412460.jpg'),\n", + " ('scene-0061',\n", + " '01010000803BD41B2A12B67940741E4E23555191400000000000000000',\n", + " '0101000080CC66456B413AEF3FE385508869F797BF15B0973C0D59743F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 175,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942512460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080DED26071A2BE79404C0EC7A74F5091400000000000000000',\n", + " '010100008013C1977FDB3BEF3FB8DF9A77CB0A99BF72E53957BECA803F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 178,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942762460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080D219585E6CF6794012798DD7CC4991400000000000000000',\n", + " '010100008090299F3B1D41EF3F4914AEB6031297BFE54B3246319F8B3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 198,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944412460.jpg'),\n", + " ('scene-0061',\n", + " '01010000806D16E3C989DB7940F836C840EF4C91400000000000000000',\n", + " '0101000080FC3D0884143FEF3FF558A7B3925A95BFD01C2B8B87728B3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 188,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943612460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080AF297EA7BBC5784007846B42FD9E91400000000000000000',\n", + " '01010000804D2E3FCEF880E73F72694FF59D798DBF5AA1840711EB8B3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 96,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", + " ('scene-0061',\n", + " '01010000803061BAF046C77940E8F6D4D94C4F91400000000000000000',\n", + " '0101000080DB872B630E3CEF3FF3B4527A553499BFD4A3A35220D3823F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 181,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943012460.jpg'),\n", + " ('scene-0061',\n", + " '01010000800185BF0B65CC794093BB6C3DB34E91400000000000000000',\n", + " '0101000080943194F22D3DEF3F71ABCAAEC56297BF6EF69F933122833F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 183,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943162460.jpg'),\n", + " ('scene-0061',\n", + " '01010000805A6CC13F140F7A40FBE4C6E2054791400000000000000000',\n", + " '010100008088EA404D835BEF3F2C71B402838496BF48A6EC69A1F68A3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 206,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945162460.jpg'),\n", + " ('scene-0061',\n", + " '010100008011D599F7B7D479404851777DBA4D91400000000000000000',\n", + " '010100008064FD244F893CEF3F88E5329B607B98BFCB2B10D726F0863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 186,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943412460.jpg'),\n", + " ('scene-0061',\n", + " '01010000809F6FC41387F1794012D3878F5D4A91400000000000000000',\n", + " '0101000080BA326E10E33FEF3F5AFCE47BFCAA96BF8A318A2FEDFC8B3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 196,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944262460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080BBDD3929F9CD7840964AECE1309191400000000000000000',\n", + " '010100008079161DD104FFE83F7D8E148E81CF8ABF8C33631140B4853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 104,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", + " ('scene-0061',\n", + " '01010000800469C0773EDD7940F1A0B7F3BB4C91400000000000000000',\n", + " '0101000080066CD9CA873EEF3F88E237E4287395BFFA4F1975F3928B3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 189,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943662460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080AF0D857839E4794063A318A8E84B91400000000000000000',\n", + " '0101000080C6FF798E6F3DEF3FBEB44014C2F797BF3A1080032180873F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 191,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943862460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080C489CE739E067A40F2E69227F24791400000000000000000',\n", + " '0101000080646EE65E4C4DEF3F6AC505F95D4696BF5484489AA59E8A3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 204,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944912460.jpg'),\n", + " ('scene-0061',\n", + " '01010000809D8A3D81B1EC7940890223B1ED4A91400000000000000000',\n", + " '01010000802ED4F18CAF3EEF3F22816229A4A397BFE2AEC3584679893F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 194,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944112460.jpg'),\n", + " ('scene-0061',\n", + " '010100008044642740DFDC7840CA5063A1E28491400000000000000000',\n", + " '0101000080828968304266EA3F1BF021235DE490BF58628CF7DFD7883F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 112,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080D1AA10DCC6F4794074BDE084FD4991400000000000000000',\n", + " '0101000080BCD629550341EF3F9B83DE3469BB96BF3AE45AFAD6178C3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 197,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944362460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080EF863387B9F97940B1B57D3D6B4991400000000000000000',\n", + " '01010000802E79B9A66941EF3F02415C81592298BFD46C67F1B8948A3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 199,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944512460.jpg'),\n", + " ('scene-0061',\n", + " '010100008035A69B3B55217A406462F05D344591400000000000000000',\n", + " '0101000080C71F235BAB80EF3F4B806CC19C7497BF14BB2D56483C853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 212,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945662460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080546DBF70D8017A40F78C5DA77C4891400000000000000000',\n", + " '01010000806208AC3B3948EF3F94D80B658E1197BFBBDA43465E118A3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 202,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944762460.jpg'),\n", + " ('scene-0061',\n", + " '010100008009B794F4C2F1784045876B39F87991400000000000000000',\n", + " '0101000080AED53EF576B8EB3F88955BE36C8794BF269D617338A3873F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 120,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", + " ('scene-0061',\n", + " '010100008057DFE12D430D7A40871B6F55374791400000000000000000',\n", + " '01010000800D69329C7058EF3F29DC85D3394C96BFBB34058514878B3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 205,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945112460.jpg'),\n", + " ('scene-0061',\n", + " '01010000802DA4665BAE127A407E0FC69EA44691400000000000000000',\n", + " '0101000080064FA2E34462EF3F3AD888574DE796BF0A7849C60C88883F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 207,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945262460.jpg'),\n", + " ('scene-0061',\n", + " '01010000800FEDAD21E41B7A40F33FA0F4B64591400000000000000000',\n", + " '010100008004319565AD75EF3F8AC9E28219D896BFCE1DC040EF6A853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 210,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945512460.jpg'),\n", + " ('scene-0061',\n", + " '01010000809ABC3D02540B79406CE4EB51797091400000000000000000',\n", + " '0101000080D6DFF800B6CCEC3F46AACDA2E8BF96BF4244EF2D75E6853F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 128,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080F249EE174A2879409C60F7C66C6891400000000000000000',\n", + " '0101000080CF85577969A5ED3FD61AABFC7E269ABFA0BFFEF4FB74863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 136,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939162460.jpg'),\n", + " ('scene-0061',\n", + " '01010000807568FCFDA74979406E58D1412A6191400000000000000000',\n", + " '0101000080FA49ABE5A251EE3FFA0CA7AFD29C9DBF26F27997F7F6843F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 144,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939862460.jpg'),\n", + " ('scene-0061',\n", + " '01010000808F3D7EBA9767794000846457E05B91400000000000000000',\n", + " '0101000080DAB145C979B6EE3F4277EF0BCAE79DBF580D5B6F6745823F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 152,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940512460.jpg'),\n", + " ('scene-0061',\n", + " '010100008088E5B27D168379408762BC44C15791400000000000000000',\n", + " '0101000080CF7A743360F8EE3F383915D4DC589DBFBD2FF930FF707F3F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 160,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941162460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080FC1255362E9E79406D707A4C325491400000000000000000',\n", + " '0101000080881B80C1E529EF3FD4B7FD0AAEA29BBF199097676980793F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 168,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941862460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080BAD8051594B97940D349ACE1E95091400000000000000000',\n", + " '0101000080F47FA2E2C33AEF3F571B996B913298BF5FC983A3A52A773F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 176,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942612460.jpg'),\n", + " ('scene-0061',\n", + " '010100008048D15B56CBCF7940B1906B294D4E91400000000000000000',\n", + " '010100008059039B105B3DEF3FAC3AD98285AE97BF0232B697DFE2843F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 184,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943262460.jpg'),\n", + " ('scene-0061',\n", + " '010100008089DC6C91F5E57940FBD9A177B44B91400000000000000000',\n", + " '01010000809FC01E77633EEF3F114B34E77AA798BF3E863407C186873F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 192,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943912478.jpg'),\n", + " ('scene-0061',\n", + " '0101000080476F5378DBFC7940D201820C0F4991400000000000000000',\n", + " '01010000809882930CD043EF3F71B3C2F93BB897BFCAF13B30DBFA893F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 200,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944612460.jpg'),\n", + " ('scene-0061',\n", + " '0101000080EC0D20D874167A406335BB36404691400000000000000000',\n", + " '0101000080EC036FA9FD69EF3FB8B00FBDC79396BFCD238C1E2179863F',\n", + " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", + " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", + " 208,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945362460.jpg')]" ] }, - "execution_count": 9, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], + "source": [ + "camera_info = []\n", + "for cur_frame_num in frame_num:\n", + " camera_info.append(scenic_world.get_camera(scene_name, cur_frame_num))\n", + "camera_info[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "ename": "TypeError", + "evalue": "unsupported operand type(s) for -=: 'list' and 'str'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mscenic_world\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_overlay_info\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcar_trajectories\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcamera_info\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;32m~\\OneDrive - University of Toronto\\Desktop\\Capstone\\apperception\\apperception\\scenic_world.py\u001b[0m in \u001b[0;36mget_overlay_info\u001b[1;34m(self, trajectory, camera_info)\u001b[0m\n\u001b[0;32m 198\u001b[0m \u001b[0mcamera_config\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'cameraRotation'\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcur_camera_info\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 199\u001b[0m \u001b[0mcamera_config\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'cameraIntrinsic'\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m\u001b[0mcur_camera_info\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 200\u001b[1;33m \u001b[0mtraj_2d\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtransformation\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcentroid_3d\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcamera_config\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# one point of the trajectory in 2d\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 201\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 202\u001b[0m \u001b[0mframenum\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcur_camera_info\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m6\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32m~\\OneDrive - University of Toronto\\Desktop\\Capstone\\apperception\\apperception\\scenic_util.py\u001b[0m in \u001b[0;36mtransformation\u001b[1;34m(centroid_3d, camera_config)\u001b[0m\n\u001b[0;32m 372\u001b[0m \u001b[0mTODO\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mtransformation\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[1;36m3\u001b[0m\u001b[0md\u001b[0m \u001b[0mworld\u001b[0m \u001b[0mcoordinate\u001b[0m \u001b[0mto\u001b[0m \u001b[1;36m2\u001b[0m\u001b[0md\u001b[0m \u001b[0mframe\u001b[0m \u001b[0mcoordinate\u001b[0m \u001b[0mgiven\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mcamera\u001b[0m \u001b[0mconfig\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 373\u001b[0m \t'''\n\u001b[1;32m--> 374\u001b[1;33m \u001b[0mcentroid_3d\u001b[0m \u001b[1;33m-=\u001b[0m \u001b[0mcamera_config\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'egoTranslation'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 375\u001b[0m \u001b[0mcentroid_3d\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mQuaternion\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcamera_config\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'egoRotation'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minverse\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrotation_matrix\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcentroid_3d\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 376\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for -=: 'list' and 'str'" + ] + } + ], + "source": [ + "scenic_world.get_overlay_info(car_trajectories, camera_info)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "bboxes = scenic_world.predicate(lambda obj:obj.object_type == \"vehicle.car\").get_geo().execute()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "bboxes.shape" ] @@ -192,7 +4440,6 @@ { "cell_type": "code", "execution_count": null, - "id": "6bee4c8f", "metadata": {}, "outputs": [], "source": [] @@ -204,7 +4451,8 @@ "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" }, "kernelspec": { - "display_name": "Python 3.7.11 64-bit", + "display_name": "Python 3", + "language": "python", "name": "python3" }, "language_info": { @@ -217,7 +4465,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" + "version": "3.7.8" } }, "nbformat": 4, From 62d7efa2b193cac8ad4d6d421b112f7864fcd1fe Mon Sep 17 00:00:00 2001 From: "Chanwut (Mick) Kittivorawong" Date: Mon, 28 Feb 2022 22:23:46 -0800 Subject: [PATCH 15/26] fix bug --- apperception/scenic_util.py | 98 +++++++++++++++++++++--------------- apperception/scenic_world.py | 46 +++++++++-------- 2 files changed, 82 insertions(+), 62 deletions(-) diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py index 39d67939..1165fefa 100644 --- a/apperception/scenic_util.py +++ b/apperception/scenic_util.py @@ -1,17 +1,9 @@ -import ast -import psycopg2 import numpy as np -import datetime -import cv2 -# from object_tracker import yolov4_deepsort_video_track -from video_util import * -from pymongo import MongoClient +from video_util import bbox_to_data3d, convert_timestamps from pyquaternion import Quaternion import json import os from scenic_box import Box -import time -import pandas as pd CREATE_ITEMTRAJ_SQL ='''CREATE TABLE IF NOT EXISTS Test_Scenic_Item_General_Trajectory( itemId TEXT, @@ -37,10 +29,10 @@ frameNum Int, fileName TEXT, cameraTranslation geometry, - cameraRotation geometry, - cameraIntrinsic real[][], + cameraRotation real[4], + cameraIntrinsic real[3][3], egoTranslation geometry, - egoRotation geometry, + egoRotation real[4], timestamp TEXT );''' @@ -105,33 +97,39 @@ def create_or_insert_scenic_camera_table(conn, world_name, camera): def insert_scenic_camera(conn, world_name, camera_config): #Creating a cursor object using the cursor() method cursor = conn.cursor() + values = [] for config in camera_config: - cursor.execute('''INSERT INTO Test_Scenic_Cameras ( - cameraId, - worldId, - frameId, - frameNum, - fileName, - cameraTranslation, - cameraRotation, - cameraIntrinsic, - egoTranslation, - egoRotation, - timestamp - ) '''+ \ - '''VALUES (\'%s\', \'%s\', \'%s\', %s, \'%s\', \'POINT Z (%s %s %s)\', \'POINT Z (%s %s %s)\', - \'{{%s, %s, %s}, {%s, %s, %s}, {%s, %s, %s}}\', - \'POINT Z (%s %s %s)\', \'POINT Z (%s %s %s)\', \'%s\');''' \ - %(config['camera_id'], world_name, config['frame_id'], config['frame_num'], config['filename'], - config['camera_translation'][0], config['camera_translation'][1], config['camera_translation'][2], - config['camera_rotation'][0], config['camera_rotation'][1], config['camera_rotation'][2], - config['camera_intrinsic'][0][0], config['camera_intrinsic'][0][1], config['camera_intrinsic'][0][2], - config['camera_intrinsic'][1][0], config['camera_intrinsic'][1][1], config['camera_intrinsic'][1][2], - config['camera_intrinsic'][2][0], config['camera_intrinsic'][2][1], config['camera_intrinsic'][2][2], - config['ego_translation'][0], config['ego_translation'][1], config['ego_translation'][2], - config['ego_rotation'][0], config['ego_rotation'][1], config['ego_rotation'][2], - config['timestamp'] - )) + values.append(f'''( + '{config['camera_id']}', + '{world_name}', + '{config['frame_id']}', + {config['frame_num']}, + '{config['filename']}', + 'POINT Z ({' '.join(map(str, config['camera_translation']))})', + ARRAY{config['camera_rotation']}, + ARRAY{config['camera_intrinsic']}, + 'POINT Z ({' '.join(map(str, config['ego_translation']))})', + ARRAY{config['ego_rotation']}, + '{config['timestamp']}' + )''') + + cursor.execute(f''' + INSERT INTO Test_Scenic_Cameras ( + cameraId, + worldId, + frameId, + frameNum, + fileName, + cameraTranslation, + cameraRotation, + cameraIntrinsic, + egoTranslation, + egoRotation, + timestamp + ) + VALUES {','.join(values)};''' + ) + print("New camera inserted successfully.........") conn.commit() @@ -407,8 +405,28 @@ def fetch_camera(conn, scene_name, frame_num): # else: # query = '''SELECT cameraId, ratio, ST_X(origin), ST_Y(origin), ST_Z(origin), ST_X(focalpoints), ST_Y(focalpoints), fov, skev_factor ''' \ # + '''FROM Cameras WHERE cameraId IN (\'%s\') AND worldId = \'%s\';''' %(','.join(cam_id), world_id) - query = '''SELECT cameraId, egoTranslation, egoRotation, cameraTranslation, cameraRotation, cameraIntrinsic, frameNum, fileName ''' \ - + '''FROM Test_Scenic_Cameras WHERE cameraId = '{}' AND frameNum IN {};'''.format(scene_name, tuple(frame_num) ) + # TODO: define ST_XYZ somewhere else + query = f''' + CREATE OR REPLACE FUNCTION ST_XYZ (g geometry) RETURNS real[] AS $$ + BEGIN + RETURN ARRAY[ST_X(g), ST_Y(g), ST_Z(g)]; + END; + $$ LANGUAGE plpgsql; + + SELECT + cameraId, + ST_XYZ(egoTranslation), + egoRotation, + ST_XYZ(cameraTranslation), + cameraRotation, + cameraIntrinsic, + frameNum, + fileName + FROM Test_Scenic_Cameras + WHERE + cameraId = '{scene_name}' AND + frameNum IN {tuple(frame_num)}; + ''' cursor.execute(query) return cursor.fetchall() diff --git a/apperception/scenic_world.py b/apperception/scenic_world.py index 9735b1cc..c6c0476c 100644 --- a/apperception/scenic_world.py +++ b/apperception/scenic_world.py @@ -1,14 +1,17 @@ -from typing import Callable -import psycopg2 -from metadata_context import * -from scenic_context import * +from metadata_context import MetadataContext +from scenic_context import ScenicVideoContext import copy from scenic_world_executer import ScenicWorldExecutor import matplotlib.pyplot as plt -from scenic_util import * +from scenic_util import transformation +import numpy as np +import datetime +import cv2 BASE_VOLUME_QUERY_TEXT = "stbox \'STBOX Z(({x1}, {y1}, {z1}),({x2}, {y2}, {z2}))\'" scenic_world_executor = ScenicWorldExecutor() + + class ScenicWorld: def __init__(self, name, units, enable_tasm=False): @@ -18,7 +21,7 @@ def __init__(self, name, units, enable_tasm=False): self.GetVideo = False self.enable_tasm = enable_tasm # self.AccessedVideoContext = False - + def get_camera(self, scene_name, frame_num): # Change depending if you're on docker or not # TODO: fix get_camera in scenic_world_executor.py @@ -27,19 +30,19 @@ def get_camera(self, scene_name, frame_num): else: scenic_world_executor.connect_db(user="docker", password="docker", database_name="mobilitydb") return scenic_world_executor.get_camera(scene_name, frame_num) - + ######################### ### Video Context #### ######################### def get_lens(self, cam_id=""): return self.get_camera(cam_id).lens - + def get_name(self): return self.VideoContext.get_name() def get_units(self): return self.VideoContext.get_units() - + def item(self, item_id, cam_id, item_type, location): new_context = copy.deepcopy(self) new_context.VideoContext.item(item_id, cam_id, item_type, location) @@ -88,22 +91,22 @@ def get_geo(self, interval = [], distinct = False): new_context = copy.deepcopy(self) new_context.MetadataContext.get_geo(interval, distinct) return new_context - + def get_time(self, distinct = False): new_context = copy.deepcopy(self) new_context.MetadataContext.get_time(distinct) return new_context - + def get_distance(self, interval = [], distinct = False): new_context = copy.deepcopy(self) new_context.MetadataContext.distance(interval, distinct) return new_context - + def get_speed(self, interval = [], distinct = False): new_context = copy.deepcopy(self) new_context.MetadataContext.get_speed(interval, distinct) return new_context - + def get_video(self, cam_id=[]): # Go through all the cameras in 'filtered' world and obtain videos new_context = copy.deepcopy(self) @@ -116,7 +119,7 @@ def interval(self, time_interval): new_context = copy.deepcopy(self) new_context.MetadataContext.interval(time_interval) return new_context - + def execute(self): scenic_world_executor.create_world(self) if self.enable_tasm: @@ -153,7 +156,7 @@ def select_intersection_of_interest_or_use_default(self, cam_id, default=True): print(br) x2, y2, z2 = br return BASE_VOLUME_QUERY_TEXT.format(x1=x1, y1=y1, z1=0, x2=x2, y2=y2, z2=2) - + def scenic_trajectory_to_frame_num(self, trajectory): ''' TODO: fetch the frame number from the trajectory @@ -166,7 +169,7 @@ def scenic_trajectory_to_frame_num(self, trajectory): start_time = self.MetadataContext.start_time for traj in trajectory: current_trajectory = traj[0] - date_times =current_trajectory['datetimes'] + date_times = current_trajectory['datetimes'] frame_num.append([(datetime.datetime.strptime(t, "%Y-%m-%dT%H:%M:%S+00").replace(tzinfo = None) - start_time).total_seconds() for t in date_times]) return frame_num @@ -188,24 +191,23 @@ def get_overlay_info(self, trajectory, camera_info): traj_obj_2d = [] # 2d coordinate list for index in range(len(camera_info_obj)): cur_camera_info = camera_info_obj[index] # camera info of the obejct in one point of the trajectory - centroid_3d = traj_obj_3d[index] # one point of the trajectory in 3d + centroid_3d = np.array(traj_obj_3d[index]) # one point of the trajectory in 3d # in order to fit into the function transformation, we develop a dictionary called camera_config camera_config = {} camera_config['egoTranslation'] = cur_camera_info[1] print(type(camera_config["egoTranslation"])) - camera_config['egoRotation'] = cur_camera_info[2] + camera_config['egoRotation'] = np.array(cur_camera_info[2]) camera_config['cameraTranslation'] = cur_camera_info[3] - camera_config['cameraRotation'] = cur_camera_info[4] - camera_config['cameraIntrinsic'] =cur_camera_info[5] + camera_config['cameraRotation'] = np.array(cur_camera_info[4]) + camera_config['cameraIntrinsic'] = np.array(cur_camera_info[5]) traj_2d = transformation(centroid_3d, camera_config) # one point of the trajectory in 2d framenum = cur_camera_info[6] - filename = cur_camera_info[7] + filename = cur_camera_info[7] traj_obj_2d.append((traj_2d, framenum, filename)) result.append(traj_obj_2d) return result - def scenic_overlay_trajectory(self, scene_name, trajectory): frame_num = self.scenic_trajectory_to_frame_num(trajectory) # frame_num is int[[]], hence camera_info should also be [[]] From 125111f99817ed0fb0e4ca66cefa576b1ae25803 Mon Sep 17 00:00:00 2001 From: "Chanwut (Mick) Kittivorawong" Date: Wed, 2 Mar 2022 14:13:06 -0800 Subject: [PATCH 16/26] remove scenic_* prefix; prepare for combining the original and scenic world --- .gitignore | 3 +- apperception/{scenic_box.py => box.py} | 0 apperception/scenic_context.py | 12 +- apperception/scenic_util.py | 8 +- apperception/scenic_video_context_executor.py | 12 +- apperception/scenic_world.py | 82 +- apperception/scenic_world_executer.py | 4 +- scenic_test.ipynb | 12031 ++++++++++++++-- 8 files changed, 11118 insertions(+), 1034 deletions(-) rename apperception/{scenic_box.py => box.py} (100%) diff --git a/.gitignore b/.gitignore index 14a2861b..d93792c2 100644 --- a/.gitignore +++ b/.gitignore @@ -4,4 +4,5 @@ __pycache__ yolov4-deepsort yolov5-deepsort .mypy_cache -.idea \ No newline at end of file +.idea +.ipynb_checkpoints diff --git a/apperception/scenic_box.py b/apperception/box.py similarity index 100% rename from apperception/scenic_box.py rename to apperception/box.py diff --git a/apperception/scenic_context.py b/apperception/scenic_context.py index 23873f3d..539f5022 100644 --- a/apperception/scenic_context.py +++ b/apperception/scenic_context.py @@ -9,7 +9,7 @@ # Camera node -class ScenicCamera: +class Camera: def __init__(self, scenic_scene_name): self.scenic_scene_name = scenic_scene_name @@ -32,12 +32,12 @@ def add_property(self, properties, property_type, new_prop): # Add a default add_recog_obj = True def recognize(self, sample_data, annotation): # Create object recognition node - object_rec_node = ScenicObjectRecognition(sample_data, annotation) + object_rec_node = ObjectRecognition(sample_data, annotation) self.object_recognition = object_rec_node return object_rec_node # Object Recognition node -class ScenicObjectRecognition: +class ObjectRecognition: def __init__(self, sample_data, annotation): self.sample_data = sample_data self.annotation = annotation @@ -46,7 +46,7 @@ def __init__(self, sample_data, annotation): def add_properties(self, properties): self.properties = properties -class ScenicVideoContext: +class VideoContext: def __init__(self, name, units): self.root = self self.name = name @@ -70,10 +70,10 @@ def get_units(self): return self.units # Establish camera - def scenic_camera(self, scenic_scene_name): + def camera(self, scenic_scene_name): camera_node = self.__get_camera(scenic_scene_name) if not camera_node: - camera_node = ScenicCamera(scenic_scene_name) + camera_node = Camera(scenic_scene_name) self.__add_camera(scenic_scene_name, camera_node) return camera_node diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py index 1165fefa..1d936a4a 100644 --- a/apperception/scenic_util.py +++ b/apperception/scenic_util.py @@ -3,7 +3,7 @@ from pyquaternion import Quaternion import json import os -from scenic_box import Box +from box import Box CREATE_ITEMTRAJ_SQL ='''CREATE TABLE IF NOT EXISTS Test_Scenic_Item_General_Trajectory( itemId TEXT, @@ -77,7 +77,7 @@ def fetch_camera_config(scene_name, sample_data): return camera_config # Create a camera table -def create_or_insert_scenic_camera_table(conn, world_name, camera): +def create_or_insert_camera_table(conn, world_name, camera): #Creating a cursor object using the cursor() method cursor = conn.cursor() ''' @@ -195,7 +195,7 @@ def transform_box(box: Box, camera): # plt.imshow(frame) # plt.show() -def scenic_recognize(scene_name, sample_data, annotation): +def recognize(scene_name, sample_data, annotation): """ return: annotations: { @@ -253,7 +253,7 @@ def scenic_recognize(scene_name, sample_data, annotation): print("Recognization done, saving to database......") return annotations -def add_scenic_recognized_objs(conn, formatted_result, start_time, default_depth=True): +def add_recognized_objs(conn, formatted_result, start_time, default_depth=True): clean_scenic_tables(conn) for item_id in formatted_result: object_type = formatted_result[item_id]["object_type"] diff --git a/apperception/scenic_video_context_executor.py b/apperception/scenic_video_context_executor.py index 68cac8b1..d92b7820 100644 --- a/apperception/scenic_video_context_executor.py +++ b/apperception/scenic_video_context_executor.py @@ -3,14 +3,14 @@ import json -class ScenicVideoContextExecutor: - def __init__(self, conn, new_video_context:ScenicVideoContext=None, tasm=None): +class VideoContextExecutor: + def __init__(self, conn, new_video_context:VideoContext=None, tasm=None): if new_video_context: self.context(new_video_context) self.conn = conn self.tasm = tasm - def context(self, video_context:ScenicVideoContext): + def context(self, video_context:VideoContext): self.current_context = video_context return self @@ -33,7 +33,7 @@ def visit_world(self): def visit_camera(self, camera_node): world_name = self.current_context.name - camera_sql = create_or_insert_scenic_camera_table(self.conn, world_name, camera_node) + camera_sql = create_or_insert_camera_table(self.conn, world_name, camera_node) if camera_node.object_recognition is not None: self.visit_obj_rec(camera_node, camera_node.object_recognition) if self.tasm: @@ -45,8 +45,8 @@ def visit_obj_rec(self, camera_node, object_rec_node): start_time = self.current_context.start_time - tracking_results = scenic_recognize(cam_id, object_rec_node.sample_data, object_rec_node.annotation) - add_scenic_recognized_objs(self.conn, tracking_results, start_time) + tracking_results = recognize(cam_id, object_rec_node.sample_data, object_rec_node.annotation) + add_recognized_objs(self.conn, tracking_results, start_time) if self.tasm: metadata_to_tasm(tracking_results, camera_node.metadata_id, self.tasm) diff --git a/apperception/scenic_world.py b/apperception/scenic_world.py index c6c0476c..186a6808 100644 --- a/apperception/scenic_world.py +++ b/apperception/scenic_world.py @@ -1,7 +1,7 @@ from metadata_context import MetadataContext -from scenic_context import ScenicVideoContext +from scenic_context import VideoContext import copy -from scenic_world_executer import ScenicWorldExecutor +from scenic_world_executer import WorldExecutor import matplotlib.pyplot as plt from scenic_util import transformation import numpy as np @@ -9,15 +9,15 @@ import cv2 BASE_VOLUME_QUERY_TEXT = "stbox \'STBOX Z(({x1}, {y1}, {z1}),({x2}, {y2}, {z2}))\'" -scenic_world_executor = ScenicWorldExecutor() +world_executor = WorldExecutor() -class ScenicWorld: +class World: def __init__(self, name, units, enable_tasm=False): - self.ScenicVideoContext = ScenicVideoContext(name, units) + self.VideoContext = VideoContext(name, units) self.MetadataContext = MetadataContext(single_mode=False) - self.MetadataContext.start_time = self.ScenicVideoContext.start_time + self.MetadataContext.start_time = self.VideoContext.start_time self.GetVideo = False self.enable_tasm = enable_tasm # self.AccessedVideoContext = False @@ -26,10 +26,10 @@ def get_camera(self, scene_name, frame_num): # Change depending if you're on docker or not # TODO: fix get_camera in scenic_world_executor.py if self.enable_tasm: - scenic_world_executor.connect_db(port=5432, user="docker", password="docker", database_name="mobilitydb") + world_executor.connect_db(port=5432, user="docker", password="docker", database_name="mobilitydb") else: - scenic_world_executor.connect_db(user="docker", password="docker", database_name="mobilitydb") - return scenic_world_executor.get_camera(scene_name, frame_num) + world_executor.connect_db(user="docker", password="docker", database_name="mobilitydb") + return world_executor.get_camera(scene_name, frame_num) ######################### ### Video Context #### @@ -48,9 +48,9 @@ def item(self, item_id, cam_id, item_type, location): new_context.VideoContext.item(item_id, cam_id, item_type, location) return new_context - def scenic_camera(self, scenic_scene_name): + def camera(self, scenic_scene_name: str): new_context = copy.deepcopy(self) - new_context.ScenicVideoContext.scenic_camera(scenic_scene_name) + new_context.VideoContext.camera(scenic_scene_name) return new_context def add_properties(self, cam_id, properties, property_type): @@ -60,7 +60,7 @@ def add_properties(self, cam_id, properties, property_type): def recognize(self, cam_id, sample_data, annotation): new_context = copy.deepcopy(self) - new_context.ScenicVideoContext.camera_nodes[cam_id].recognize(sample_data, annotation) + new_context.VideoContext.camera_nodes[cam_id].recognize(sample_data, annotation) return new_context ######################### @@ -121,15 +121,15 @@ def interval(self, time_interval): return new_context def execute(self): - scenic_world_executor.create_world(self) + world_executor.create_world(self) if self.enable_tasm: - scenic_world_executor.enable_tasm() + world_executor.enable_tasm() print("successfully enable tasm during execution time") # Change depending if you're on docker or not - scenic_world_executor.connect_db(port=5432, user="docker", password="docker", database_name="mobilitydb") + world_executor.connect_db(port=5432, user="docker", password="docker", database_name="mobilitydb") else: - scenic_world_executor.connect_db(user="docker", password="docker", database_name="mobilitydb") - return scenic_world_executor.execute() + world_executor.connect_db(user="docker", password="docker", database_name="mobilitydb") + return world_executor.execute() def select_intersection_of_interest_or_use_default(self, cam_id, default=True): print(self.VideoContext.camera_nodes) @@ -157,7 +157,29 @@ def select_intersection_of_interest_or_use_default(self, cam_id, default=True): x2, y2, z2 = br return BASE_VOLUME_QUERY_TEXT.format(x1=x1, y1=y1, z1=0, x2=x2, y2=y2, z2=2) - def scenic_trajectory_to_frame_num(self, trajectory): + def overlay_trajectory(self, scene_name, trajectory): + frame_num = self.trajectory_to_frame_num(trajectory) + # frame_num is int[[]], hence camera_info should also be [[]] + camera_info = [] + for cur_frame_num in frame_num: + camera_info.append(self.get_camera(scene_name, cur_frame_num)) ### TODO: fetch_camera_info in scenic_utils.py + assert len(camera_info) == len(frame_num) + assert len(camera_info[0]) == len(frame_num[0]) + overlay_info = self.get_overlay_info(trajectory, camera_info) + ### TODO: fix the following to overlay the 2d point onto the frame + for traj in trajectory: + current_trajectory = np.asarray(traj[0]) + frame_points = camera.lens.world_to_pixels(current_trajectory.T).T + vs = cv2.VideoCapture(video_file) + frame = vs.read() + frame = cv2.cvtColor(frame[1], cv2.COLOR_BGR2RGB) + for point in frame_points.tolist(): + cv2.circle(frame,tuple([int(point[0]), int(point[1])]),3,(255,0,0)) + plt.figure() + plt.imshow(frame) + plt.show() + + def trajectory_to_frame_num(self, trajectory): ''' TODO: fetch the frame number from the trajectory 1. get the time stamp field from the trajectory @@ -206,26 +228,4 @@ def get_overlay_info(self, trajectory, camera_info): filename = cur_camera_info[7] traj_obj_2d.append((traj_2d, framenum, filename)) result.append(traj_obj_2d) - return result - - def scenic_overlay_trajectory(self, scene_name, trajectory): - frame_num = self.scenic_trajectory_to_frame_num(trajectory) - # frame_num is int[[]], hence camera_info should also be [[]] - camera_info = [] - for cur_frame_num in frame_num: - camera_info.append(self.get_camera(scene_name, cur_frame_num)) ### TODO: fetch_camera_info in scenic_utils.py - assert len(camera_info) == len(frame_num) - assert len(camera_info[0]) == len(frame_num[0]) - overlay_info = self.get_overlay_info(trajectory, camera_info) - ### TODO: fix the following to overlay the 2d point onto the frame - for traj in trajectory: - current_trajectory = np.asarray(traj[0]) - frame_points = camera.lens.world_to_pixels(current_trajectory.T).T - vs = cv2.VideoCapture(video_file) - frame = vs.read() - frame = cv2.cvtColor(frame[1], cv2.COLOR_BGR2RGB) - for point in frame_points.tolist(): - cv2.circle(frame,tuple([int(point[0]), int(point[1])]),3,(255,0,0)) - plt.figure() - plt.imshow(frame) - plt.show() + return result \ No newline at end of file diff --git a/apperception/scenic_world_executer.py b/apperception/scenic_world_executer.py index 9c20a353..7da048d8 100644 --- a/apperception/scenic_world_executer.py +++ b/apperception/scenic_world_executer.py @@ -4,7 +4,7 @@ from scenic_util import * import numpy as np -class ScenicWorldExecutor: +class WorldExecutor: def __init__(self, world=None): if world: self.create_world(world) @@ -91,7 +91,7 @@ def get_video(self, metadata_results): def execute(self): # Edit logic for execution here through checks of whether VideoContext or MetadataContext is being used - video_executor = ScenicVideoContextExecutor(self.conn, self.curr_world.ScenicVideoContext, self.tasm) + video_executor = VideoContextExecutor(self.conn, self.curr_world.VideoContext, self.tasm) video_executor.execute() if self.curr_world.MetadataContext.scan.view == None: diff --git a/scenic_test.ipynb b/scenic_test.ipynb index 38c8011b..b3858e33 100644 --- a/scenic_test.ipynb +++ b/scenic_test.ipynb @@ -3,9 +3,19 @@ { "cell_type": "code", "execution_count": 1, + "id": "11413b36", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/Users/chanwutk/Documents/apperception\n" + ] + } + ], "source": [ + "%cd ..\n", "import os\n", "import sys\n", "sys.path.append(os.path.join(os.getcwd(),\"apperception\"))\n", @@ -26,6 +36,7 @@ { "cell_type": "code", "execution_count": 2, + "id": "c0024fbb", "metadata": {}, "outputs": [], "source": [ @@ -38,6 +49,7 @@ { "cell_type": "code", "execution_count": 3, + "id": "9a9b1ae5", "metadata": {}, "outputs": [], "source": [ @@ -49,7 +61,10 @@ { "cell_type": "code", "execution_count": 4, - "metadata": {}, + "id": "73e281bd", + "metadata": { + "scrolled": true + }, "outputs": [ { "data": { @@ -352,7 +367,10 @@ { "cell_type": "code", "execution_count": 5, - "metadata": {}, + "id": "76c201ef", + "metadata": { + "scrolled": true + }, "outputs": [ { "data": { @@ -581,27 +599,32 @@ { "cell_type": "code", "execution_count": 6, + "id": "70c7a420", "metadata": {}, "outputs": [], "source": [ - "scenic_world = ScenicWorld(name=name, units=units)" + "scenic_world = World(name=name, units=units)" ] }, { "cell_type": "code", "execution_count": 7, + "id": "d1b14857", "metadata": {}, "outputs": [], "source": [ "### Ingest the camera to the world\n", "scene_name = \"scene-0061\"\n", - "scenic_world_61 = scenic_world.scenic_camera(scene_name)" + "scenic_world_61 = scenic_world.camera(scene_name)" ] }, { "cell_type": "code", "execution_count": 8, - "metadata": {}, + "id": "a63b385f", + "metadata": { + "scrolled": true + }, "outputs": [ { "name": "stdout", @@ -624,6 +647,7 @@ { "cell_type": "code", "execution_count": 9, + "id": "7c7de169", "metadata": {}, "outputs": [ { @@ -648,6 +672,7 @@ { "cell_type": "code", "execution_count": 10, + "id": "0fcaf8ac", "metadata": { "scrolled": true }, @@ -667,6 +692,7 @@ { "cell_type": "code", "execution_count": 11, + "id": "b00d7f8c", "metadata": {}, "outputs": [ { @@ -910,6 +936,32 @@ " 23.0,\n", " 24.0,\n", " 25.0,\n", + " 26.0],\n", + " [1.0,\n", + " 2.0,\n", + " 3.0,\n", + " 4.0,\n", + " 5.0,\n", + " 6.0,\n", + " 7.0,\n", + " 8.0,\n", + " 9.0,\n", + " 10.0,\n", + " 11.0,\n", + " 12.0,\n", + " 13.0,\n", + " 14.0,\n", + " 15.0,\n", + " 16.0,\n", + " 17.0,\n", + " 18.0,\n", + " 19.0,\n", + " 20.0,\n", + " 21.0,\n", + " 22.0,\n", + " 23.0,\n", + " 24.0,\n", + " 25.0,\n", " 26.0,\n", " 27.0,\n", " 28.0,\n", @@ -1244,108 +1296,6 @@ " 222.0,\n", " 223.0,\n", " 224.0],\n", - " [2.0,\n", - " 3.0,\n", - " 4.0,\n", - " 5.0,\n", - " 6.0,\n", - " 7.0,\n", - " 8.0,\n", - " 9.0,\n", - " 10.0,\n", - " 11.0,\n", - " 12.0,\n", - " 13.0,\n", - " 14.0,\n", - " 15.0,\n", - " 16.0,\n", - " 17.0,\n", - " 18.0,\n", - " 19.0,\n", - " 20.0,\n", - " 21.0,\n", - " 22.0,\n", - " 23.0,\n", - " 24.0,\n", - " 25.0,\n", - " 26.0,\n", - " 27.0,\n", - " 28.0,\n", - " 29.0,\n", - " 30.0,\n", - " 31.0,\n", - " 32.0,\n", - " 33.0,\n", - " 34.0,\n", - " 35.0,\n", - " 36.0,\n", - " 37.0,\n", - " 38.0,\n", - " 39.0,\n", - " 40.0,\n", - " 41.0,\n", - " 42.0,\n", - " 43.0,\n", - " 44.0,\n", - " 45.0,\n", - " 46.0,\n", - " 47.0,\n", - " 48.0,\n", - " 49.0,\n", - " 50.0,\n", - " 51.0,\n", - " 52.0,\n", - " 53.0,\n", - " 54.0,\n", - " 55.0,\n", - " 56.0,\n", - " 57.0,\n", - " 58.0,\n", - " 59.0,\n", - " 60.0,\n", - " 61.0,\n", - " 62.0,\n", - " 63.0,\n", - " 64.0,\n", - " 65.0,\n", - " 66.0,\n", - " 67.0,\n", - " 68.0,\n", - " 69.0,\n", - " 70.0,\n", - " 71.0,\n", - " 72.0,\n", - " 73.0,\n", - " 74.0,\n", - " 75.0,\n", - " 76.0,\n", - " 77.0],\n", - " [1.0,\n", - " 2.0,\n", - " 3.0,\n", - " 4.0,\n", - " 5.0,\n", - " 6.0,\n", - " 7.0,\n", - " 8.0,\n", - " 9.0,\n", - " 10.0,\n", - " 11.0,\n", - " 12.0,\n", - " 13.0,\n", - " 14.0,\n", - " 15.0,\n", - " 16.0,\n", - " 17.0,\n", - " 18.0,\n", - " 19.0,\n", - " 20.0,\n", - " 21.0,\n", - " 22.0,\n", - " 23.0,\n", - " 24.0,\n", - " 25.0,\n", - " 26.0],\n", " [1.0,\n", " 2.0,\n", " 3.0,\n", @@ -2052,6 +2002,82 @@ " 74.0,\n", " 75.0,\n", " 76.0,\n", + " 77.0],\n", + " [2.0,\n", + " 3.0,\n", + " 4.0,\n", + " 5.0,\n", + " 6.0,\n", + " 7.0,\n", + " 8.0,\n", + " 9.0,\n", + " 10.0,\n", + " 11.0,\n", + " 12.0,\n", + " 13.0,\n", + " 14.0,\n", + " 15.0,\n", + " 16.0,\n", + " 17.0,\n", + " 18.0,\n", + " 19.0,\n", + " 20.0,\n", + " 21.0,\n", + " 22.0,\n", + " 23.0,\n", + " 24.0,\n", + " 25.0,\n", + " 26.0,\n", + " 27.0,\n", + " 28.0,\n", + " 29.0,\n", + " 30.0,\n", + " 31.0,\n", + " 32.0,\n", + " 33.0,\n", + " 34.0,\n", + " 35.0,\n", + " 36.0,\n", + " 37.0,\n", + " 38.0,\n", + " 39.0,\n", + " 40.0,\n", + " 41.0,\n", + " 42.0,\n", + " 43.0,\n", + " 44.0,\n", + " 45.0,\n", + " 46.0,\n", + " 47.0,\n", + " 48.0,\n", + " 49.0,\n", + " 50.0,\n", + " 51.0,\n", + " 52.0,\n", + " 53.0,\n", + " 54.0,\n", + " 55.0,\n", + " 56.0,\n", + " 57.0,\n", + " 58.0,\n", + " 59.0,\n", + " 60.0,\n", + " 61.0,\n", + " 62.0,\n", + " 63.0,\n", + " 64.0,\n", + " 65.0,\n", + " 66.0,\n", + " 67.0,\n", + " 68.0,\n", + " 69.0,\n", + " 70.0,\n", + " 71.0,\n", + " 72.0,\n", + " 73.0,\n", + " 74.0,\n", + " 75.0,\n", + " 76.0,\n", " 77.0,\n", " 78.0,\n", " 79.0,\n", @@ -2665,13 +2691,14 @@ } ], "source": [ - "frame_num = scenic_world.scenic_trajectory_to_frame_num(car_trajectories)\n", + "frame_num = scenic_world.trajectory_to_frame_num(car_trajectories)\n", "frame_num" ] }, { "cell_type": "code", "execution_count": 12, + "id": "56b17993", "metadata": { "scrolled": true }, @@ -2680,1698 +2707,1698 @@ "data": { "text/plain": [ "[('scene-0061',\n", - " '0101000080B998A40B18AF7940FC6CF9B2A36F92400000000000000000',\n", - " '01010000803318EB831857E23F4601F891FA8650BFBCAC591AF77B8B3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [410.94336, 1179.9099, 0.0],\n", + " [0.5731318, -0.001008744, 0.013420039, -0.8193527],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 3,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", " ('scene-0061',\n", - " '0101000080F3524E4E348F79409DFF2E24F95992400000000000000000',\n", - " '0101000080B2ECA093516BE23F5F908AAA2838643F01D6BE9AF2EB8C3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [408.95026, 1174.4933, 0.0],\n", + " [0.57560045, 0.0024681848, 0.01412191, -0.81760544],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 11,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", " ('scene-0061',\n", - " '0101000080BAA395B3466F7940B96C5B7B814392400000000000000000',\n", - " '0101000080BCFD474BB999E23F104DA5BF8C3D403FC56F97F716CF883F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [406.95477, 1168.8765, 0.0],\n", + " [0.5812651, 0.00049561856, 0.0121137425, -0.8136239],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 19,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", " ('scene-0061',\n", - " '01010000801D00D6DEDF5379409616A483732F92400000000000000000',\n", - " '0101000080BBED8D5513B0E23F205977E90603203FC09D6ACDCE5E863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [405.24216, 1163.8628, 0.0],\n", + " [0.5839936, 0.00012216052, 0.010923019, -0.8116848],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 27,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", " ('scene-0061',\n", - " '01010000804A25EE8BAE3A79405355481ECD1C92400000000000000000',\n", - " '010100008062050084FDD1E23F4C388BC38D484FBF5AC0654E90C7883F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [403.6676, 1159.2003, 0.0],\n", + " [0.5881336, -0.000954694, 0.012099387, -0.8086727],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 35,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", " ('scene-0061',\n", - " '01010000808A9426862D217940F9EC95CA440992400000000000000000',\n", - " '0101000080AC5DF8ED5BECE23FDC033CC72E4D60BFBDD6EBFC0D5F8F3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [402.0736, 1154.3171, 0.0],\n", + " [0.5913524, -0.0019899285, 0.015318021, -0.8062653],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 43,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", " ('scene-0061',\n", - " '0101000080318C6E43B8B679406CA968E8C97492400000000000000000',\n", - " '0101000080629FBC42E04DE23F04031074368F61BFEA0FFB8DEAAE873F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [411.41998, 1181.1971, 0.0],\n", + " [0.57200634, -0.0021434845, 0.011564095, -0.82016486],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 1,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg'),\n", " ('scene-0061',\n", - " '0101000080E6201DFA5B0B794004278515F1F791400000000000000000',\n", - " '0101000080284DAE64E509E33F5D22C36F93D868BF6493FE0A090D893F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [400.70996, 1149.9855, 0.0],\n", + " [0.594958, -0.0030329588, 0.012231894, -0.80365795],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 51,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", " ('scene-0061',\n", - " '0101000080D4C306D766967940C1438543F15E92400000000000000000',\n", - " '0101000080B8B1C149C665E23F908353A74AFC333F849671E1BAF5893F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [409.40012, 1175.7356, 0.0],\n", + " [0.57492363, 0.00030495474, 0.012675724, -0.8181088],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 9,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", " ('scene-0061',\n", - " '01010000804B3AC04518F77840A4A2E58F59E791400000000000000000',\n", - " '01010000800012721B7534E33F42C87137257550BF803344E6AD20853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [399.44342, 1145.8374, 0.0],\n", + " [0.6001535, -0.0010044922, 0.010316237, -0.7998177],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 59,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", " ('scene-0061',\n", - " '010100008058B01C59F277794083333CFAC44992400000000000000000',\n", - " '01010000800D9D4FF28A88E23F986F61E8F0C84FBF8EA3025BB2528C3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [407.49667, 1170.4424, 0.0],\n", + " [0.57916784, -0.00096999895, 0.013829607, -0.8150905],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 17,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", " ('scene-0061',\n", - " '0101000080E291B5066FA27940DCB4F9A62C6792400000000000000000',\n", - " '0101000080E468DC088C58E23F20FC81130C2267BF2DB78637DA438C3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [410.1521, 1177.7936, 0.0],\n", + " [0.57330894, -0.0028238522, 0.013801293, -0.81921816],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 6,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", " ('scene-0061',\n", - " '0101000080691A922642E278400214976219D591400000000000000000',\n", - " '0101000080D49B86CC5995E33F0889C2F64A5E493FFE1E1DCD8D8B8B3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [398.14114, 1141.2748, 0.0],\n", + " [0.6119813, 0.00077418005, 0.013449771, -0.7907575],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 67,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", " ('scene-0061',\n", - " '01010000803682DAD72E5A794067E5CEDD133492400000000000000000',\n", - " '01010000804A24C37ED0ABE23F18015B122F0240BF5314274B1D70873F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [405.63644, 1165.0194, 0.0],\n", + " [0.58347344, -0.0004885416, 0.01144431, -0.8120514],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 25,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", " ('scene-0061',\n", - " '010100008094C5A4296BA77940DA939866896A92400000000000000000',\n", - " '0101000080F4C49C1C3256E23F34D262D5D24F64BF5C2DB409DA618B3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [410.46365, 1178.6342, 0.0],\n", + " [0.57302195, -0.0024794692, 0.013370231, -0.8194272],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 5,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", " ('scene-0061',\n", - " '01010000802EB00E2600AA79409BF032313C6C92400000000000000000',\n", - " '0101000080CAC560F86656E23F3C948A1D816A62BFE0F6C7E0B34F8C3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [410.62503, 1179.0588, 0.0],\n", + " [0.57304716, -0.0022480509, 0.013823896, -0.8194027],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 4,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", " ('scene-0061',\n", - " '0101000080BA1FD0705E8379404BBBBC6BC95192400000000000000000',\n", - " '01010000809E793F9A2278E23F63C771DE009765BFBBFAD4847B31893F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [408.21057, 1172.4467, 0.0],\n", + " [0.57716495, -0.0026354806, 0.0123014115, -0.8165307],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 14,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", " ('scene-0061',\n", - " '0101000080541B19AC0DD27840D15F6D1BDFC391400000000000000000',\n", - " '010100008084C44981A359E43F6E676948F7427ABF83720A3E2E68933F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [397.12833, 1136.9679, 0.0],\n", + " [0.6359422, -0.00641152, 0.018952105, -0.7714773],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 75,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", " ('scene-0061',\n", - " '01010000801A7B9BB5434079400A558D8B0F2192400000000000000000',\n", - " '01010000802EFFBD0D54C8E23F189E05C2B6763BBF558CA35F1EB8893F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [404.01654, 1160.2651, 0.0],\n", + " [0.5869541, -0.0004190632, 0.01255821, -0.8095227],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 33,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", " ('scene-0061',\n", - " '0101000080C7294C65778A794052F40EC2AE5692400000000000000000',\n", - " '01010000800CA3B068E071E23FAA78E6698ED35E3F162B251FBDBB8D3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [408.65414, 1173.6707, 0.0],\n", + " [0.57640094, 0.0018814936, 0.01451824, -0.81703585],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 12,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", " ('scene-0061',\n", - " '0101000080176C936220B479405805FC4D107392400000000000000000',\n", - " '01010000809472DF49AF4EE23FAFF5E2265FD258BF41FF532CBE60883F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [411.2579, 1180.7659, 0.0],\n", + " [0.57210505, -0.0015150002, 0.011903272, -0.82009256],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 2,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", " ('scene-0061',\n", - " '0101000080F16BDEC7C8857940B5D5D6BE715392400000000000000000',\n", - " '0101000080689A392D9778E23FADBA1EB9B2C255BF989B45F56C328B3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [408.3615, 1172.8611, 0.0],\n", + " [0.5772205, -0.001328158, 0.013279773, -0.81647927],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 13,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", " ('scene-0061',\n", - " '01010000801F0D15CE9C647940283157F5B43B92400000000000000000',\n", - " '0101000080DEEC0281BBA3E23FA08A619ECFB9353F3AC3B6754E3F8B3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [406.28827, 1166.9268, 0.0],\n", + " [0.58248687, 0.00033150977, 0.013304342, -0.81273115],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 22,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", " ('scene-0061',\n", - " '0101000080486DCEC9E6C778407AB044264DB491400000000000000000',\n", - " '0101000080E855C900AA56E53F72505B75DADD89BFD3AA1A10E1868F3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.49384, 1133.0753, 0.0],\n", + " [0.6668291, -0.012630183, 0.015393981, -0.7449446],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 83,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", " ('scene-0061',\n", - " '010100008046F5B8569C9D79405E7CE37EE16392400000000000000000',\n", - " '0101000080B5EB11EA2760E23F9D3D5E3EE5955EBF5D465C0801038D3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [409.85068, 1176.9702, 0.0],\n", + " [0.57423776, -0.0018667926, 0.014165886, -0.8185639],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 7,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", " ('scene-0061',\n", - " '0101000080E942F4B0482879408AE5BE14C40E92400000000000000000',\n", - " '01010000806921C51760E6E23F4CCA43A765125FBFE09A6AD84AD98D3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [402.51776, 1155.6915, 0.0],\n", + " [0.590622, -0.001896476, 0.014574609, -0.8068145],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 41,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", " ('scene-0061',\n", - " '01010000804E6F452E969179404F9E60DA9E5B92400000000000000000',\n", - " '0101000080F27953BFEA6AE23F628563DA6DD15D3F9D671639AE6A8B3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [409.09915, 1174.9052, 0.0],\n", + " [0.5755514, 0.0018199513, 0.013387071, -0.817654],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 10,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", " ('scene-0061',\n", - " '01010000803D309B241F6D79403CF71E02EE4192400000000000000000',\n", - " '010100008007DC95D49A9CE23FC89F67D8DA67463F040EDF8DEF3B893F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [406.8201, 1168.4824, 0.0],\n", + " [0.5816168, 0.0006837672, 0.012321349, -0.8133693],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 20,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", " ('scene-0061',\n", - " '010100008085DC1FDDD6687940BFB767FCCE3E92400000000000000000',\n", - " '0101000080304B95BB39A0E23F28F3DC9DD5C7483FEEA44C9096D98A3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [406.55246, 1167.7021, 0.0],\n", + " [0.5820588, 0.000756244, 0.013110329, -0.8130407],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 21,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", " ('scene-0061',\n", - " '0101000080DE747CDB8FC478403484BD71E0A691400000000000000000',\n", - " '01010000804FE3FC3E0DACE63FF8E0262A5DE187BF8E9F97E5569D8D3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.28513, 1129.7192, 0.0],\n", + " [0.7085024, -0.011660316, 0.014460257, -0.7054639],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 91,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", " ('scene-0061',\n", - " '0101000080177910F5D64979405FC5474D312892400000000000000000',\n", - " '0101000080ED9070C0CCB7E23F100DBB31369F483FE7962323E723883F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [404.615, 1162.0481, 0.0],\n", + " [0.5849365, 0.0007514014, 0.011787229, -0.8109931],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 30,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", " ('scene-0061',\n", - " '010100008057FB0BD9B97E794030A80BBD8A4E92400000000000000000',\n", - " '010100008086B71FE4947CE23F4201C3D48AEE67BF3A28DD8CDA08883F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [407.92038, 1171.6355, 0.0],\n", + " [0.5777077, -0.002921363, 0.011735637, -0.8161541],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 15,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", " ('scene-0061',\n", - " '0101000080EAE960C6311079409AC06FCDCFFB91400000000000000000',\n", - " '010100008011723B29D106E33F0AF110D6227F5CBFC804EC0F267B8A3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [401.01215, 1150.9529, 0.0],\n", + " [0.59458214, -0.001739296, 0.0129301995, -0.80392903],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 49,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", " ('scene-0061',\n", - " '010100008049346597917379408016B7CCA04692400000000000000000',\n", - " '010100008078664A3D1791E23FE0E9D0C006621A3F526A2960F7BF893F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [407.22305, 1169.657, 0.0],\n", + " [0.5802113, 0.000100642836, 0.012573178, -0.81436896],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 18,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", " ('scene-0061',\n", - " '0101000080113A84CECA4F794054903BC17D2C92400000000000000000',\n", - " '0101000080EB75B373ECB2E23FD02073EE75D5433FD2BCFD398E69863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [404.987, 1163.1228, 0.0],\n", + " [0.5843413, 0.00060528045, 0.010943519, -0.81143403],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 28,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", " ('scene-0061',\n", - " '010100008035A97241CB4D7940802083800F2B92400000000000000000',\n", - " '01010000807C2EB959DAB2E23FF885BB01CC98473F53DCDB2CFC01873F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [404.86212, 1162.7651, 0.0],\n", + " [0.58433264, 0.0007201191, 0.011234255, -0.8114362],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 29,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", " ('scene-0061',\n", - " '0101000080B7C406B0AEC87840EC4285125E9891400000000000000000',\n", - " '01010000800F8FBEE67435E83F4011507EB43389BFCDE4956DD3B5853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.54266, 1126.0919, 0.0],\n", + " [0.75652546, -0.012305651, 0.010600711, -0.6537625],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 99,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", " ('scene-0061',\n", - " '0101000080E2912B4C50317940C1359004AB1592400000000000000000',\n", - " '0101000080E425C098C8DBE23F40CBC5E218A867BFEFB8166A8CD2893F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [403.0821, 1157.417, 0.0],\n", + " [0.58932906, -0.0028877722, 0.01260862, -0.80778956],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 38,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", " ('scene-0061',\n", - " '010100008099245FB38762794096C9003C2C3A92400000000000000000',\n", - " '0101000080CBEE7B92D4A5E23F3886272D27C0363F127A1CE393CE893F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [406.15814, 1166.5432, 0.0],\n", + " [0.582743, 0.00034714656, 0.012601047, -0.81255877],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 23,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", " ('scene-0061',\n", - " '01010000806A394EB48DFB78405875E67213EB91400000000000000000',\n", - " '0101000080D65947CE6829E33FD2AD670F78C553BFB739BE7FDB9A853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [399.7221, 1146.769, 0.0],\n", + " [0.59880483, -0.0012067482, 0.010549273, -0.8008246],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 57,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", " ('scene-0061',\n", - " '010100008093C31D540E58794007503C7E863292400000000000000000',\n", - " '01010000807F87AB1F4BABE23F9CA8E84BE95A43BF5188649E3D4C873F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [405.5035, 1164.6313, 0.0],\n", + " [0.58340985, -0.00059067144, 0.011375886, -0.812098],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 26,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", " ('scene-0061',\n", - " '01010000808BF5C46AF9367940158159C5F81992400000000000000000',\n", - " '0101000080A878969912D5E23F31467A8E1EB458BFEEC0AFF02B49883F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [403.43588, 1158.4929, 0.0],\n", + " [0.58850986, -0.0015077875, 0.011858314, -0.8084017],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 36,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", " ('scene-0061',\n", - " '010100008092792D7D2E33794085E2FA8D1A1792400000000000000000',\n", - " '01010000800A18DA51CED9E23FCFD4890B356764BF791FA7D314EB883F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [403.19885, 1157.7759, 0.0],\n", + " [0.58908767, -0.0024906192, 0.012167132, -0.8079737],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 37,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", " ('scene-0061',\n", - " '01010000806D8E7AA31AD478401475E9D6418B91400000000000000000',\n", - " '01010000807D1F02ED5CA4E93FA7CE2A2067D98CBF02D042E2673A853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [397.2565, 1122.8143, 0.0],\n", + " [0.8013138, -0.014086538, 0.010365306, -0.5979885],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 107,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", " ('scene-0061',\n", - " '0101000080473DB9B28B18794004E0D15C810292400000000000000000',\n", - " '0101000080423199492DF6E23FCEFE2102BDB856BF42C301A2E3F9903F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [401.53412, 1152.6263, 0.0],\n", + " [0.5925509, -0.0013868185, 0.016578251, -0.8053612],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 46,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", " ('scene-0061',\n", - " '010100008060D99B3BFF4579407A66C0EF592592400000000000000000',\n", - " '010100008050CA2A4BBEBFE23F9869E79E0AA33E3FE2762AE4695F893F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [404.37482, 1161.3378, 0.0],\n", + " [0.58590615, 0.0004674817, 0.012389018, -0.8102841],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 31,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", " ('scene-0061',\n", - " '0101000080BDB3604EFAE87840F065AB2C36DB91400000000000000000',\n", - " '0101000080189CF1907469E33F18FE59072729323F1FB3DDA65FA1873F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [398.5611, 1142.8029, 0.0],\n", + " [0.606623, 0.00027711107, 0.011538264, -0.7949059],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 65,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", " ('scene-0061',\n", - " '0101000080EEDE31E1EE1B7940CF161DF12C0592400000000000000000',\n", - " '01010000809699447685EFE23F301C6A95D7A65ABFDC0D21BB38CF8F3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [401.74582, 1153.294, 0.0],\n", + " [0.59173846, -0.0016266924, 0.015531963, -0.8059787],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 45,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", " ('scene-0061',\n", - " '0101000080D70A05B4853C79401F727927371E92400000000000000000',\n", - " '0101000080742E5FE27FCDE23F86BDBB751D1148BF142AFDCF7CB4883F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [403.78265, 1159.5538, 0.0],\n", + " [0.5875854, -0.00073446217, 0.012063002, -0.8090719],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 34,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", " ('scene-0061',\n", - " '0101000080D2AECBDB651F79404740AF00E30792400000000000000000',\n", - " '010100008025AAABF89EEBE23F364A09B1576D61BF24E1555FE4728F3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [401.96237, 1153.9717, 0.0],\n", + " [0.59126234, -0.002127334, 0.015355858, -0.80633026],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 44,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", " ('scene-0061',\n", - " '01010000801E4E8B23A3E37840CD5B3634E08091400000000000000000',\n", - " '010100008031795A37F8E2EA3FDEB617C0791893BFBD77A1EF296C883F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [398.22733, 1120.219, 0.0],\n", + " [0.84020627, -0.018648054, 0.011925056, -0.541815],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 115,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", " ('scene-0061',\n", - " '0101000080A8FA7C325E037940E13430BD82F191400000000000000000',\n", - " '0101000080B807F8817F18E33FF199FCF1575553BF81EC2D85B271873F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [400.2105, 1148.3777, 0.0],\n", + " [0.5967405, -0.0011800155, 0.011447329, -0.8023518],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 54,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", " ('scene-0061',\n", - " '010100008056824630982D7940659E908FDC1292400000000000000000',\n", - " '0101000080C82353DEF6DEE23FD7AEFFA94F9C66BF54AAE044C6068B3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [402.84967, 1156.7153, 0.0],\n", + " [0.5897173, -0.0027600818, 0.013196515, -0.8074972],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 39,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", " ('scene-0061',\n", - " '01010000801D018237BD2479406D8A9627050C92400000000000000000',\n", - " '010100008004CE7C7494E9E23F17354122C11D59BF15FB734669508E3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [402.2962, 1155.005, 0.0],\n", + " [0.5910132, -0.0015329729, 0.01480181, -0.80652463],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 42,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", " ('scene-0061',\n", - " '0101000080C7696EF9D1D4784008019E7F3CC791400000000000000000',\n", - " '0101000080086ACB72EE2BE43FC4F76ABA06DD76BFA107CA88AD7A913F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [397.30127, 1137.8091, 0.0],\n", + " [0.63036275, -0.005581881, 0.01706954, -0.776093],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 73,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", " ('scene-0061',\n", - " '01010000802275CEDB8806794027358C0D15F491400000000000000000',\n", - " '010100008047296666E60DE33F4875EDA3160363BF802E4322287B883F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [400.40842, 1149.0205, 0.0],\n", + " [0.59544677, -0.0023208086, 0.011953653, -0.80330247],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 53,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", " ('scene-0061',\n", - " '01010000802C764DAF24087940DFA37BF45EF591400000000000000000',\n", - " '010100008092681C268A0CE33F98DB7FDA7A3768BF86B7DB905B3E893F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [400.50894, 1149.3428, 0.0],\n", + " [0.5952807, -0.0029561424, 0.0123259695, -0.8034178],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 52,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", " ('scene-0061',\n", - " '0101000080427605012CFB7840B2DE6E981A7691400000000000000000',\n", - " '0101000080E3C9EE125928EC3F33C6B12B1B9997BF5C117E96768B8A3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [399.69824, 1117.526, 0.0],\n", + " [0.8799253, -0.02304499, 0.012961318, -0.4743758],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 123,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", " ('scene-0061',\n", - " '0101000080E155BF6CE3EF78406BB9DF3138E191400000000000000000',\n", - " '010100008085B2CACFD249E33F3E6040E5847341BF14B681D7C5E6833F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [398.993, 1144.3049, 0.0],\n", + " [0.6027616, -0.0005325698, 0.009717508, -0.79786193],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 62,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", " ('scene-0061',\n", - " '0101000080A289A378DA1679404218C0D3290192400000000000000000',\n", - " '010100008004E42BC4E6F8E23F0093E4F354E35ABF423C14F5A9A8903F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [401.42834, 1152.2909, 0.0],\n", + " [0.59288347, -0.0016411142, 0.016268402, -0.80512226],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 47,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", " ('scene-0061',\n", - " '010100008074515C81201679407DA910A3386D91400000000000000000',\n", - " '0101000080D85293CB2826ED3F73209C790D6299BFCABC335FD7EF863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [401.38293, 1115.3053, 0.0],\n", + " [0.9109081, -0.024788104, 0.0111996485, -0.4117117],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 131,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", " ('scene-0061',\n", - " '01010000809D5EBE8733F47840B9FB0B77E9E491400000000000000000',\n", - " '01010000803E67B704C53CE33F9FCB7DD1F1BC57BFC91339E6C3B8853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [399.26257, 1145.228, 0.0],\n", + " [0.60116816, -0.0014488566, 0.010606318, -0.79905087],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 60,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", " ('scene-0061',\n", - " '0101000080089DA60338CA78409773868EAEB891400000000000000000',\n", - " '01010000805A6C123EB103E53FDC01F9A6275982BF13602ADE149A923F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.63867, 1134.1704, 0.0],\n", + " [0.65670073, -0.008959112, 0.0181659, -0.75387925],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 81,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", " ('scene-0061',\n", - " '01010000802F7A5798980E79406897D33486FA91400000000000000000',\n", - " '0101000080369EA1959D09E33F4E576149B6D263BFDEA8155BF332893F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [400.91226, 1150.6311, 0.0],\n", + " [0.5949238, -0.0024198112, 0.012304212, -0.8036843],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 50,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", " ('scene-0061',\n", - " '010100008090CCC75850F17840D6D22A0476E291400000000000000000',\n", - " '0101000080520F3EB1B444E33F6A1DD3D82C2449BFE0158EBAA618843F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [399.08212, 1144.6152, 0.0],\n", + " [0.60213697, -0.0007672519, 0.009812644, -0.79833215],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 61,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", " ('scene-0061',\n", - " '01010000806F2CFB2B26DC7840A7DA77932ECF91400000000000000000',\n", - " '0101000080903898B971CDE33F1C03FA44FED94BBF9FA20A56970C903F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [397.7593, 1139.7955, 0.0],\n", + " [0.61882865, -0.0008499614, 0.015673032, -0.78536916],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 70,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", " ('scene-0061',\n", - " '010100008087201F26260079401BB2330FE6EE91400000000000000000',\n", - " '01010000804DF97D276B1DE33FB85EBF5219D144BF29813D562BF4853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [400.0093, 1147.7246, 0.0],\n", + " [0.5973411, -0.0006352781, 0.0107196225, -0.80191535],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 55,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", " ('scene-0061',\n", - " '0101000080879F851F563479403029D3B0986591400000000000000000',\n", - " '0101000080F193E0E3C0E8ED3FCC509780A7C69BBF3C6616EC4AA0863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [403.27103, 1113.3992, 0.0],\n", + " [0.9346623, -0.027124994, 0.011047921, -0.35432836],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 139,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939412460.jpg'),\n", " ('scene-0061',\n", - " '0101000080DE2BF900BEC4784052D0C2D1F1A991400000000000000000',\n", - " '010100008087344197A857E63F8CED85AECD9287BFFA3018A054588D3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.2964, 1130.4862, 0.0],\n", + " [0.6982005, -0.011510474, 0.014328633, -0.7156663],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 89,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", " ('scene-0061',\n", - " '0101000080814FB5FFB2DF7840A7DF0D73B0D291400000000000000000',\n", - " '01010000808A5B05BF50A9E33FF04FAE491D6A3A3F413472ECA3E18C3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [397.9812, 1140.6724, 0.0],\n", + " [0.6144184, 0.00040305342, 0.014102249, -0.78885424],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 68,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", " ('scene-0061',\n", - " '0101000080204A552294F878404F2D32A097E891400000000000000000',\n", - " '0101000080CF78A846B430E33F0B763C871C3C54BF9A6A278BDBA4853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [399.53616, 1146.1481, 0.0],\n", + " [0.5996953, -0.0012350348, 0.010568347, -0.80015767],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 58,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", " ('scene-0061',\n", - " '010100008081EE8B12E1CD7840D6FEC07B46BE91400000000000000000',\n", - " '0101000080501C46A626A2E43F787A409EE1D979BF16CBF84909B4973F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.86746, 1135.5688, 0.0],\n", + " [0.6447938, -0.0063113035, 0.02314772, -0.7639799],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 78,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", " ('scene-0061',\n", - " '0101000080B1A58ED510ED7840214088E3C1DE91400000000000000000',\n", - " '0101000080AC3EDF381556E33F326FA76CB43648BFCC4A3BA40C92853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [398.81662, 1143.6893, 0.0],\n", + " [0.6042582, -0.00073894317, 0.010532473, -0.79671866],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 63,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", " ('scene-0061',\n", - " '0101000080EA26FF5C925579404B8FC5FAEE5E91400000000000000000',\n", - " '0101000080D4CCB311047EEE3F38BEE3B60A21A0BF4EC3728B186D853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [405.34824, 1111.7334, 0.0],\n", + " [0.9528828, -0.03150209, 0.01046199, -0.30151707],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 147,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940112460.jpg'),\n", " ('scene-0061',\n", - " '0101000080BE1ADD2D66C6784099AB8EC2109D91400000000000000000',\n", - " '010100008051003BF37FB6E73F8BF3770CD8B489BFB83283D5CDC1873F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.39993, 1127.2664, 0.0],\n", + " [0.74102783, -0.012551963, 0.011600121, -0.6712568],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 97,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", " ('scene-0061',\n", - " '0101000080D4B6F79554D0784004DD89289DC191400000000000000000',\n", - " '0101000080BA234930117AE43F886DDEF8074A76BF10177D61CD91953F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [397.02066, 1136.4034, 0.0],\n", + " [0.6399008, -0.0054416955, 0.021064004, -0.76814955],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 76,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", " ('scene-0061',\n", - " '01010000804E1508CC91E37840DFCBB7924ED691400000000000000000',\n", - " '01010000804CAE784B038DE33F862423575492533F2A41C4FB87D7893F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [398.22308, 1141.5768, 0.0],\n", + " [0.61096346, 0.0011945557, 0.0126181245, -0.7915573],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 66,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", " ('scene-0061',\n", - " '0101000080D7E6D06FD7C5784034C667030BAF91400000000000000000',\n", - " '010100008037A00122BED1E53F58B07B317B798ABFE2158C85E0438C3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.36508, 1131.7607, 0.0],\n", + " [0.68185335, -0.01292702, 0.01380134, -0.73124444],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 86,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", " ('scene-0061',\n", - " '0101000080A80D75884BDD7840D569A90058D091400000000000000000',\n", - " '0101000080D18DF0C223C0E33FC04B42AE047B2DBF3599837835F08E3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [397.83093, 1140.0859, 0.0],\n", + " [0.61720455, -0.00022491867, 0.0151066, -0.7866577],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 69,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", " ('scene-0061',\n", - " '010100008024BAB9C4FAD9784094D40734E8CC91400000000000000000',\n", - " '01010000809E3DDE52BFE7E33FD139410E8FE85CBFCFEA1B98243A903F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [397.62372, 1139.2268, 0.0],\n", + " [0.6220395, -0.0017644307, 0.015846798, -0.7828235],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 71,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", " ('scene-0061',\n", - " '0101000080F468F0FD4D727940B87BC943345A91400000000000000000',\n", - " '0101000080ED60F63428D2EE3F0D37225E8B859EBF20F56046C479813F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [407.14404, 1110.551, 0.0],\n", + " [0.96315396, -0.029806307, 0.008533033, -0.26715776],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 155,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940762460.jpg'),\n", " ('scene-0061',\n", - " '01010000801F8961299BCF78404B2736796D8F91400000000000000000',\n", - " '0101000080DA70360BCE2FE93F3C5A466EDF6589BFCBEFC8924B94853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.97537, 1123.8569, 0.0],\n", + " [0.78708553, -0.012401338, 0.010536757, -0.6166292],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 105,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", " ('scene-0061',\n", - " '01010000801965FB666DC778403C9C5FED3AB391400000000000000000',\n", - " '010100008046F91107EE6DE53FF069D24649608ABF3C91CFC48269903F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.4642, 1132.8075, 0.0],\n", + " [0.66966915, -0.012878964, 0.016027492, -0.7423749],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 84,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", " ('scene-0061',\n", - " '01010000808ECF5F20F5D27840FF6CA16AFEC491400000000000000000',\n", - " '0101000080F497CB03B24CE43F3042D6D1E82F7ABFFFE757480182923F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [397.18484, 1137.2484, 0.0],\n", + " [0.6343622, -0.0063933465, 0.018074054, -0.7727982],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 74,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", " ('scene-0061',\n", - " '01010000806F97CA1808C578403C55FA4EEEA191400000000000000000',\n", - " '0101000080964DB3CDEA31E73FDE18DC3139058DBF8C73D23323A08D3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.31448, 1128.4827, 0.0],\n", + " [0.7248434, -0.01417012, 0.014465595, -0.688616],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 94,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", " ('scene-0061',\n", - " '01010000805167C0C2ACCE784088A248F25BBF91400000000000000000',\n", - " '01010000802D6914739795E43FFA50904D72B176BF13DF1768E29C973F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.91718, 1135.8398, 0.0],\n", + " [0.6432607, -0.0055403197, 0.023059404, -0.7652798],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 77,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", " ('scene-0061',\n", - " '010100008014F22B1555CC7840A8C267210EBC91400000000000000000',\n", - " '0101000080BC8DC8BF7AC3E43F0D26990F797C80BF5CC1564F0F94963F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.77078, 1135.0138, 0.0],\n", + " [0.64886224, -0.008049913, 0.022049177, -0.76054376],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 79,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", " ('scene-0061',\n", - " '0101000080D425F8A7128D7940A2274AB9655691400000000000000000',\n", - " '01010000802B6E4FAAEA0DEF3FE050DE3B9DC19BBF765BD509E71A7C3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [408.81705, 1109.5994, 0.0],\n", + " [0.9704488, -0.027105767, 0.0068615936, -0.23968166],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 163,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941412460.jpg'),\n", " ('scene-0061',\n", - " '0101000080E9D7DBD67DDF7840E9240866428391400000000000000000',\n", - " '010100008098AE1E3F7A99EA3FDF061215EE9692BF24784EA663A4893F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [397.96823, 1120.8148, 0.0],\n", + " [0.83123505, -0.018153878, 0.012520579, -0.5554835],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 113,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", " ('scene-0061',\n", - " '0101000080883BC7F3F5C8784096D829AE73B691400000000000000000',\n", - " '0101000080FBF4769F6C2BE53FDE150693912C87BF8073FDEAED82903F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.56006, 1133.6129, 0.0],\n", + " [0.6615508, -0.011315477, 0.016124455, -0.74964154],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 82,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", " ('scene-0061',\n", - " '0101000080CD0B94E4A0C4784046FF60A0E4A491400000000000000000',\n", - " '0101000080A5A5AF923BE3E63F485D990B136289BFEC3B4DF59FA28D3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.28928, 1129.2233, 0.0],\n", + " [0.7152384, -0.012394093, 0.014470339, -0.69862086],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 92,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", " ('scene-0061',\n", - " '0101000080715E1180C7CB78406CE7A03ADE9391400000000000000000',\n", - " '0101000080965BC2419AB6E83FE4DAC790D6918ABF24F4BFD2EDD4853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.7362, 1124.967, 0.0],\n", + " [0.77229035, -0.012973477, 0.0106600365, -0.6350478],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 102,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", " ('scene-0061',\n", - " '01010000809FEEF2D28EC67840843925E71CB191400000000000000000',\n", - " '0101000080019A26C3749EE53FAAA6FC17ACCA8ABFD3C84B93C782903F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.40988, 1132.2782, 0.0],\n", + " [0.6755928, -0.013081879, 0.016123885, -0.7369825],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 85,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", " ('scene-0061',\n", - " '010100008004A312078EC5784098A2F2D601AE91400000000000000000',\n", - " '0101000080842B9A9151EEE53F3C59DED2CF748BBFC3B72FC6A4018D3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.34717, 1131.5018, 0.0],\n", + " [0.68534166, -0.013406395, 0.014163291, -0.7279605],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 87,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", " ('scene-0061',\n", - " '0101000080F1086CDC2E9B794082FCF58B396292400000000000000000',\n", - " '01010000803F1FAC8A3762E23F6AEA2C02990452BF292AD0330BFE8B3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [409.69894, 1176.5562, 0.0],\n", + " [0.57448936, -0.001099729, 0.013668144, -0.81839716],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 8,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", " ('scene-0061',\n", - " '0101000080C4182592A9A77940F04C102C0C5391400000000000000000',\n", - " '01010000804C000A21AF32EF3FF7F9692E26129BBFB360757B4E7A7A3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [410.4789, 1108.7618, 0.0],\n", + " [0.974937, -0.02643642, 0.006464297, -0.22081016],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 171,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942112460.jpg'),\n", " ('scene-0061',\n", - " '0101000080A2AD79798DF378401A3D6A74327991400000000000000000',\n", - " '01010000807AD7E032C1CCEB3FEFCCD3B441B695BFB65DEAD59C7A883F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [399.22205, 1118.2993, 0.0],\n", + " [0.8687445, -0.021203067, 0.011952615, -0.49466214],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 121,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", " ('scene-0061',\n", - " '0101000080D75DA7DBD0C978409C7A7FAA939691400000000000000000',\n", - " '0101000080C82F7BAA4F69E83F5236F713CB838ABFBA5D3FF937D1863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.6135, 1125.6442, 0.0],\n", + " [0.76285535, -0.012946689, 0.011141241, -0.6463435],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 100,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", " ('scene-0061',\n", - " '0101000080D3C35795A2C47840E9B38C3EF0A891400000000000000000',\n", - " '01010000800A498E4E6872E63F650E9FEAAE4987BFC825AA35B1678D3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.2897, 1130.2346, 0.0],\n", + " [0.7014657, -0.011371008, 0.014357934, -0.7124678],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 90,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", " ('scene-0061',\n", - " '0101000080B127C1BD4DD97840946110FF468791400000000000000000',\n", - " '0101000080E4B0B186F61CEA3F16EB034EB5E68FBF2B27638524A6873F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [397.58148, 1121.8193, 0.0],\n", + " [0.8160355, -0.015576759, 0.011547361, -0.5776764],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 110,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", " ('scene-0061',\n", - " '01010000804C7106F5B7C47840AB9F4B9EEBA391400000000000000000',\n", - " '01010000807DD62C9E35FDE63F74C46AB3069B8BBF92667CC25A628F3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.29492, 1128.9801, 0.0],\n", + " [0.71840936, -0.013479283, 0.015324315, -0.69532114],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 93,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", " ('scene-0061',\n", - " '01010000800012498075C57840689908B5F79F91400000000000000000',\n", - " '01010000808930F4A2BA65E73F0C0B67E202BD8DBFA90ED6FAE9EC8B3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.3412, 1127.992, 0.0],\n", + " [0.7311681, -0.014520667, 0.013635471, -0.68190646],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 95,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", " ('scene-0061',\n", - " '010100008001C7E3722B7A7940B070B797594B92400000000000000000',\n", - " '0101000080C667BACE7B84E23F864C0755CEF957BFC7886379278C8B3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [407.63562, 1170.8375, 0.0],\n", + " [0.5786723, -0.001463367, 0.013450917, -0.8154479],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 16,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", " ('scene-0061',\n", - " '01010000801B078DDA03C27940D4E99664EA4F91400000000000000000',\n", - " '0101000080ECE74C60823CEF3FC852E523BEFA99BF4664B7B8ADC5823F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [412.12595, 1107.9789, 0.0],\n", + " [0.9761364, -0.02537057, 0.009166105, -0.21547638],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 179,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942862460.jpg'),\n", " ('scene-0061',\n", - " '0101000080CBA42EA58B0F7940A8345C892B6F91400000000000000000',\n", - " '010100008083FE492104F3EC3F0D63F647205B97BFA01E4C567D2F863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [400.9716, 1115.7925, 0.0],\n", + " [0.90466505, -0.022808556, 0.010832767, -0.4253746],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 129,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", " ('scene-0061',\n", - " '010100008053337A90A6C7784050AC74573F9A91400000000000000000',\n", - " '01010000804F2B6516E501E83F705F2BDB0BCE89BFA44FEE4BCC15863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.47818, 1126.5619, 0.0],\n", + " [0.7502313, -0.012600034, 0.010783764, -0.6609674],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 98,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", " ('scene-0061',\n", - " '010100008055E3874E0CD67840098E84E9B18991400000000000000000',\n", - " '0101000080123FF3CDA4D4E93F1890BF42A8CC8EBF221B02CC2F7A863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [397.378, 1122.4237, 0.0],\n", + " [0.80720747, -0.01503879, 0.01097524, -0.5899741],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 108,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", " ('scene-0061',\n", - " '01010000808D98945109EB7840685DEB330D7D91400000000000000000',\n", - " '0101000080551B370DB458EB3F396B045C462192BFD6DD2147C3C2853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [398.6898, 1119.263, 0.0],\n", + " [0.854578, -0.017705059, 0.010625387, -0.5189123],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 118,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", " ('scene-0061',\n", - " '0101000080648A235C70CA7840A239EC4AAE9591400000000000000000',\n", - " '0101000080D916DB8EE283E83FAC93090716FA8BBFEAA029C30D95873F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.65244, 1125.4202, 0.0],\n", + " [0.7660992, -0.013660595, 0.011514766, -0.64247394],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 101,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", " ('scene-0061',\n", - " '010100008005124EF139CD784023581ABA0E9291400000000000000000',\n", - " '01010000801E900693A9E6E83F89BE0D570A9E8ABFD4CD4C987EDD853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.82666, 1124.5144, 0.0],\n", + " [0.77815706, -0.012996751, 0.010676374, -0.6278445],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 103,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", " ('scene-0061',\n", - " '01010000804D7D4AAC565E79401CF9AB991D3792400000000000000000',\n", - " '01010000809A42F1F393AAE23F10FC466ACE662EBFE2A7D9BDB94D883F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [405.89615, 1165.7789, 0.0],\n", + " [0.5833225, -0.0002319457, 0.011867, -0.81215394],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 24,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", " ('scene-0061',\n", - " '01010000805EA23AF817D87940049588FF554D91400000000000000000',\n", - " '01010000802F38D66DD93DEF3FB9A363FA691697BF6EF9264322F7883F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [413.50586, 1107.334, 0.0],\n", + " [0.97629994, -0.02254644, 0.01219012, -0.21489866],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 187,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943512460.jpg'),\n", " ('scene-0061',\n", - " '01010000809CD3E39B0A2D7940E43638FE476791400000000000000000',\n", - " '0101000080462B807F92C1ED3FC3AE69FD7E859ABFFE23D284CCF5873F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [402.8151, 1113.8203, 0.0],\n", + " [0.9298794, -0.025899872, 0.011699293, -0.36676502],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 137,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939262460.jpg'),\n", " ('scene-0061',\n", - " '01010000808371D3B748D27840E55E566EDC8C91400000000000000000',\n", - " '01010000804C8A54807279E93F3B77579C83F48ABFF97F30782470863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [397.14276, 1123.2152, 0.0],\n", + " [0.7960751, -0.013161686, 0.0109560825, -0.6049555],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 106,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", " ('scene-0061',\n", - " '0101000080186E3C9F82E678401E0585FD547F91400000000000000000',\n", - " '01010000802BB93F298512EB3F0BC6EE70D0B192BF7E5B334434DA863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [398.4069, 1119.833, 0.0],\n", + " [0.84601074, -0.018256433, 0.011158379, -0.5327363],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 116,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", " ('scene-0061',\n", - " '0101000080F39B016221057940CCC087E3847291400000000000000000',\n", - " '01010000803EED62FBD390EC3F49A60FFEE3C896BF88529731A1CF8A3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [400.32065, 1116.6298, 0.0],\n", + " [0.8926792, -0.022250712, 0.013091335, -0.44995263],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 126,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", " ('scene-0061',\n", - " '0101000080C4DF975017D7784060BE5064E38891400000000000000000',\n", - " '0101000080AEDEA679F2ECE93F85D536B65C778FBFC1691D1EDDB2863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [397.4432, 1122.222, 0.0],\n", + " [0.8101742, -0.015364384, 0.011083343, -0.58588296],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 109,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", " ('scene-0061',\n", - " '0101000080D60A94BBA7DB7840BEF5D725AE8591400000000000000000',\n", - " '0101000080AD9CDB6E9E4DEA3FDD8A1182665F90BF23DE415AD054883F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [397.72845, 1121.42, 0.0],\n", + " [0.82197493, -0.015988924, 0.01188052, -0.5691752],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 111,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", " ('scene-0061',\n", - " '010100008079E639200F447940D85538B9EA2392400000000000000000',\n", - " '01010000809EED188D50C2E23F6004E229883D333F0E771989B2A9893F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [404.2537, 1160.9792, 0.0],\n", + " [0.58622, 0.00029358457, 0.012530703, -0.8100549],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 32,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", " ('scene-0061',\n", - " '0101000080F13916AC48EE794019C74305BE4A91400000000000000000',\n", - " '01010000805DF53DC1A13EEF3FEF15CC536D3497BF5938EC1D936F8A3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [414.89273, 1106.6855, 0.0],\n", + " [0.9763955, -0.022660932, 0.012908124, -0.21441014],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 195,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944162460.jpg'),\n", " ('scene-0061',\n", - " '01010000805865E2D9144C7940B9B3BB73B26091400000000000000000',\n", - " '0101000080EDA73E38445BEE3FEDB78675C0A79EBF1E20BA9C1E4B843F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [404.7551, 1112.1743, 0.0],\n", + " [0.94864094, -0.029936798, 0.009908904, -0.31477928],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 145,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939912460.jpg'),\n", " ('scene-0061',\n", - " '0101000080C5A5235222FD784011A9707E5B7591400000000000000000',\n", - " '0101000080EB7C741E2E3EEC3F7C0DCAF9D24097BF5ABF9F4AF1968B3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [399.8209, 1117.3394, 0.0],\n", + " [0.88259035, -0.022708222, 0.0134714935, -0.46940082],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 124,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", " ('scene-0061',\n", - " '0101000080C0D96FAF3CE27840D28F779DA88191400000000000000000',\n", - " '01010000809F038437D1CAEA3F6AE3BC445A3693BF7C4788928B22893F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [398.1398, 1120.4147, 0.0],\n", + " [0.837258, -0.018762026, 0.012272921, -0.5463483],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 114,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", " ('scene-0061',\n", - " '0101000080BCDB4E8837217940AAF8C144366A91400000000000000000',\n", - " '0101000080E4A23478CA78ED3FB8C435D30F5C9ABF86120D0509FD853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [402.07605, 1114.553, 0.0],\n", + " [0.920995, -0.025741814, 0.0107365325, -0.38857475],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 134,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", " ('scene-0061',\n", - " '010100008053577F177EE9784013122A7BCF7D91400000000000000000',\n", - " '0101000080CA3949AD4741EB3FACBDEB65EA2492BF30AD5F39C354853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [398.5933, 1119.4526, 0.0],\n", + " [0.8517187, -0.017718947, 0.010415578, -0.5235959],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 117,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", " ('scene-0061',\n", - " '010100008094C90B682C057A404DA408D41B4891400000000000000000',\n", - " '010100008034862686594BEF3F070871C0C46C96BF7480ABED614B8A3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [416.32333, 1106.0272, 0.0],\n", + " [0.97794795, -0.021899294, 0.012839093, -0.20730017],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 203,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944862460.jpg'),\n", " ('scene-0061',\n", - " '01010000802EB5928E53EE78403E47BCCB817B91400000000000000000',\n", - " '0101000080B98A176C0A8AEB3FF8726294540593BFCCBBD712E2B4863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [398.8954, 1118.8767, 0.0],\n", + " [0.86060065, -0.018575022, 0.011087195, -0.5088207],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 119,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", " ('scene-0061',\n", - " '010100008083414089082A79403846393B1F1092400000000000000000',\n", - " '0101000080787CA4164DE4E23FB2118A0FC15E64BFC5B6230F56AD8D3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [402.62708, 1156.0305, 0.0],\n", + " [0.5903688, -0.0024865884, 0.014490768, -0.8069997],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 40,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", " ('scene-0061',\n", - " '0101000080363ACBADF36B7940527D1A06305B91400000000000000000',\n", - " '01010000802B42489CA8C2EE3FA7A5DFE36BCA9DBF6FC2948C8E44813F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [406.74698, 1110.7969, 0.0],\n", + " [0.96126205, -0.029092489, 0.008431543, -0.27396682],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 153,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940612460.jpg'),\n", " ('scene-0061',\n", - " '0101000080CF482E974BF7784034EDBCFFA17791400000000000000000',\n", - " '01010000801C7B420D5BFBEB3F847D4F77E48697BF4E1B7C9F9895893F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [399.45596, 1117.9082, 0.0],\n", + " [0.87443304, -0.022975512, 0.012492363, -0.4844408],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 122,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", " ('scene-0061',\n", - " '01010000809F6F4454A81A79400E608410F46B91400000000000000000',\n", - " '0101000080CC76FFA2C748ED3FD42F5A09AC499ABF5C0097786E12873F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [401.6661, 1114.9884, 0.0],\n", + " [0.91513425, -0.02567166, 0.011265624, -0.40217328],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 132,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", " ('scene-0061',\n", - " '0101000080A074CECA24407940ECA6EA560C6391400000000000000000',\n", - " '0101000080D504A8320326EE3F53D041E32AEF9ABFB095A0B23251873F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [404.00897, 1112.7621, 0.0],\n", + " [0.9421402, -0.026302977, 0.011385342, -0.3339916],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 142,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939662460.jpg'),\n", " ('scene-0061',\n", - " '0101000080E85095261001794012B7167BEC7391400000000000000000',\n", - " '0101000080E8CE8A10C667EC3F8DD2D31CB8AA96BF7C251A725F238D3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [400.06644, 1116.981, 0.0],\n", + " [0.8876677, -0.022135617, 0.014227625, -0.45973217],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 125,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", " ('scene-0061',\n", - " '0101000080D4DD5EB2771F7A40703D011A604591400000000000000000',\n", - " '0101000080FFBEEB4AF67CEF3F23C2CD2D6D3997BFF3654B01585C853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [417.96674, 1105.3439, 0.0],\n", + " [0.98400414, -0.022680001, 0.010430038, -0.17638777],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 211,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945612460.jpg'),\n", " ('scene-0061',\n", - " '0101000080BB689862320779405E9D4782D27191400000000000000000',\n", - " '01010000807E23294E0BA5EC3F1C6C6696D3A596BFC0A0DD43728B883F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [400.4498, 1116.4556, 0.0],\n", + " [0.89514697, -0.022116954, 0.011984723, -0.44506076],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 127,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", " ('scene-0061',\n", - " '010100008028BFE014741379403609BC0E74FE91400000000000000000',\n", - " '0101000080CC41A4D29FFFE23FF664826936B757BF542F01D6FDE08D3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [401.21585, 1151.6133, 0.0],\n", + " [0.59370416, -0.0014474898, 0.014589294, -0.8045499],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 48,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", " ('scene-0061',\n", - " '01010000801CE2D842148779400F70D6C9345791400000000000000000',\n", - " '0101000080ECB8CB616E00EF3FA5F53A0EDE969CBF8758253DF2477E3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [408.44244, 1109.8015, 0.0],\n", + " [0.96880263, -0.027919263, 0.007392832, -0.2461449],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 161,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941262460.jpg'),\n", " ('scene-0061',\n", - " '010100008011F49472183979402F643CA88B6491400000000000000000',\n", - " '01010000808FCB4C8D8802EE3F798C59CCB7899BBF8E45696D54CD853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [403.56848, 1113.1364, 0.0],\n", + " [0.9378092, -0.02689254, 0.010645541, -0.34594402],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 140,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939512460.jpg'),\n", " ('scene-0061',\n", - " '01010000805E2D6E9DB0117940D7295CE4846E91400000000000000000',\n", - " '01010000807B5E0AA6DF04ED3F6EDBDBFA9EC897BF0457562A3D70863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [401.10562, 1115.6298, 0.0],\n", + " [0.9068449, -0.023226246, 0.010956266, -0.42068133],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 130,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", " ('scene-0061',\n", - " '01010000807A04F14AEA6079404D416A81F75C91400000000000000000',\n", - " '0101000080A10A5733FAA2EE3F16D7DECE0E409FBF16747FB35521833F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [406.0572, 1111.2417, 0.0],\n", + " [0.9573947, -0.030517798, 0.009340925, -0.2870136],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 150,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940362460.jpg'),\n", " ('scene-0061',\n", - " '010100008099609317D31C7940C35FA1B15F6B91400000000000000000',\n", - " '0101000080100F6BDC8359ED3F9F62AB5024629ABF23C616030BBF863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [401.80154, 1114.8435, 0.0],\n", + " [0.91717714, -0.025765007, 0.011106573, -0.39749077],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 133,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", " ('scene-0061',\n", - " '0101000080BE887E1BF2257940D1A11427016991400000000000000000',\n", - " '0101000080261D5492EF96ED3F6ABD8242C0169ABFB0218C9B47D8853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [402.3716, 1114.2511, 0.0],\n", + " [0.9246748, -0.025477413, 0.010666427, -0.37975475],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 135,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", " ('scene-0061',\n", - " '01010000807129425E23A0794005C172B4F45391400000000000000000',\n", - " '01010000801489BB34332CEF3FFC3E7BA34F989BBFBB0ED2C87AF7783F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [410.00864, 1108.989, 0.0],\n", + " [0.97414553, -0.026948208, 0.00609539, -0.2242257],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 169,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941912460.jpg'),\n", " ('scene-0061',\n", - " '0101000080D3168C5895FE784059F7C28E9AED91400000000000000000',\n", - " '01010000809421214A8122E33F2C73FC9D1ECA49BF2AB10C829695853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [399.91147, 1147.4009, 0.0],\n", + " [0.597962, -0.000787034, 0.0105392225, -0.8014547],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 56,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", " ('scene-0061',\n", - " '0101000080208B266DDE577940A8B0C5CE855E91400000000000000000',\n", - " '01010000808446D68B8685EE3F25C011B52ED39FBF2ACC14FEB70C853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [405.4918, 1111.6306, 0.0],\n", + " [0.9537995, -0.031079035, 0.010278165, -0.29865524],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 148,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940162460.jpg'),\n", " ('scene-0061',\n", - " '01010000807A9522F1EB31794009830475256691400000000000000000',\n", - " '010100008089D355493ADCED3F0C910785464E9BBF1E280722C75B873F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [403.12012, 1113.5366, 0.0],\n", + " [0.93313324, -0.026665784, 0.011405521, -0.35835898],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 138,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939362460.jpg'),\n", " ('scene-0061',\n", - " '0101000080D652EFDBDF7C7940C9A31C6FA15891400000000000000000',\n", - " '01010000803585C4A44CEBEE3FEC81F80F8B469EBFB21E8A17E1EC813F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [407.80466, 1110.1576, 0.0],\n", + " [0.96622306, -0.029565975, 0.008752593, -0.25585586],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 158,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941012460.jpg'),\n", " ('scene-0061',\n", - " '0101000080ACA17EF0C43D79405389B5DD8A6391400000000000000000',\n", - " '0101000080FD7599752C1AEE3F902C4FB7031D9BBF42719495EFD7863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [403.8606, 1112.8856, 0.0],\n", + " [0.94069505, -0.02647787, 0.011154053, -0.33803457],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 141,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939612460.jpg'),\n", " ('scene-0061',\n", - " '0101000080C5696E1CE04479409C12E7F2186291400000000000000000',\n", - " '010100008054BC4D09C53CEE3F485492F261559BBF42C4FB26ACAA863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [404.30472, 1112.5244, 0.0],\n", + " [0.94491816, -0.026692897, 0.011067719, -0.3260286],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 143,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939762460.jpg'),\n", " ('scene-0061',\n", - " '010100008092579AB345BB7940C61EB0FDB55091400000000000000000',\n", - " '0101000080D1B5C6DFD63AEF3F5432AD2A44C098BF657C4A70A6B47A3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [411.70453, 1108.1777, 0.0],\n", + " [0.97593254, -0.024170937, 0.006519938, -0.21663088],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 177,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942662460.jpg'),\n", " ('scene-0061',\n", - " '0101000080A41677A456EA7840E3EF3CC564DC91400000000000000000',\n", - " '0101000080CED04230C963E33F80EC5D2152ECFB3EFC9EE88842B1863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [398.64615, 1143.0984, 0.0],\n", + " [0.6059309, 2.662957e-05, 0.011080284, -0.79544014],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 64,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", " ('scene-0061',\n", - " '010100008003CC3B32847679402960101C905991400000000000000000',\n", - " '01010000808AF5483ADBDBEE3FCDAE267C71819FBF1A54D9969284813F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [407.4073, 1110.3907, 0.0],\n", + " [0.96433794, -0.030767225, 0.008553644, -0.2627405],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 156,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940862460.jpg'),\n", " ('scene-0061',\n", - " '0101000080EB02EAC3E150794070196338CA5F91400000000000000000',\n", - " '0101000080349C3FBA376DEE3F800495B65626A0BFB626AB05123A853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [405.0551, 1111.9475, 0.0],\n", + " [0.95083225, -0.031542502, 0.010364667, -0.3079216],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 146,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940012460.jpg'),\n", " ('scene-0061',\n", - " '0101000080DEA3D0C0CA967940599AA8691F5591400000000000000000',\n", - " '010100008002455D8A151EEF3FF459D8F81C909CBF805FD662A9597C3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [409.4245, 1109.2806, 0.0],\n", + " [0.97242236, -0.027893499, 0.0069214455, -0.23144926],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 166,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941662460.jpg'),\n", " ('scene-0061',\n", - " '0101000080ABA40A897A5C794001D98014B85D91400000000000000000',\n", - " '0101000080B2AE2DD2B094EE3FB8CDAA4AFC419FBF395BD3A62186833F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [405.7799, 1111.4298, 0.0],\n", + " [0.95565075, -0.030525152, 0.009533179, -0.29276106],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 149,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940262460.jpg'),\n", " ('scene-0061',\n", - " '0101000080CEF9BDDF2F6379407030054B975C91400000000000000000',\n", - " '0101000080FF878D3D08AAEE3F35906305C2B99EBF8273A6E233CC823F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [406.1992, 1111.1477, 0.0],\n", + " [0.9582559, -0.030005485, 0.009178548, -0.28418496],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 151,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940412460.jpg'),\n", " ('scene-0061',\n", - " '0101000080A546278016D37940F2CB1AEAEA4D91400000000000000000',\n", - " '0101000080A02016D17B3CEF3F05393600C93398BF1E0667664242863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [413.193, 1107.4794, 0.0],\n", + " [0.9761333, -0.023635045, 0.010868567, -0.21560872],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 185,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943362460.jpg'),\n", " ('scene-0061',\n", - " '010100008036995B22076E7940D9CA4BF5DC5A91400000000000000000',\n", - " '0101000080AC149716D5C7EE3F5BF89E4BA9C19DBF3EC0876E8B94813F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [406.87674, 1110.7158, 0.0],\n", + " [0.9618936, -0.029059071, 0.008584107, -0.27173993],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 154,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940662460.jpg'),\n", " ('scene-0061',\n", - " '010100008005844179DB907940973BF051E55591400000000000000000',\n", - " '0101000080D7A573E2E214EF3FA967503A01DA9BBF55E055C8F7797C3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [409.0536, 1109.474, 0.0],\n", + " [0.9712996, -0.02719881, 0.006952255, -0.23619694],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 164,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941512460.jpg'),\n", " ('scene-0061',\n", - " '0101000080CAA47D35DCD778402C4EF94EA5CA91400000000000000000',\n", - " '0101000080009908096102E43F5D3CBF775F9E6DBFF1C36DE3F44C903F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [397.49127, 1138.6614, 0.0],\n", + " [0.6252904, -0.0036155572, 0.015918566, -0.7802214],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 72,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", " ('scene-0061',\n", - " '01010000802E06FD7CCCB07940FDCCFD83F55191400000000000000000',\n", - " '01010000801A6F9C967437EF3F5EBBB0070D429BBF8EBDCAE7FD55783F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [411.04993, 1108.4897, 0.0],\n", + " [0.9755195, -0.026619151, 0.005941383, -0.21821527],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 174,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942362460.jpg'),\n", " ('scene-0061',\n", - " '010100008036C7A91AB47879407CCEBFDD3C5991400000000000000000',\n", - " '0101000080B20494441CE1EE3F2954C5A6EC1C9FBFB7E8EC7427B9813F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [407.54398, 1110.3094, 0.0],\n", + " [0.9649793, -0.030383775, 0.008653935, -0.26041675],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 157,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940912460.jpg'),\n", " ('scene-0061',\n", - " '01010000809A6314D958E97940A9A759AE504B91400000000000000000',\n", - " '010100008034B7F0144E3FEF3F54E72E98409C98BF8CF67335D8E6873F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [414.5842, 1106.8287, 0.0],\n", + " [0.9764777, -0.024033556, 0.01167077, -0.2139569],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 193,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944012460.jpg'),\n", " ('scene-0061',\n", - " '010100008000A7D3F400817940261288BB0B5891400000000000000000',\n", - " '0101000080574931EF76F4EE3F158591869CC99DBF8D2DF8847FF2803F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [408.06274, 1110.0115, 0.0],\n", + " [0.96734184, -0.029089399, 0.008275028, -0.25166455],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 159,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941112460.jpg'),\n", " ('scene-0061',\n", - " '010100008054BE7112FE8A7940665DE5D2AC5691400000000000000000',\n", - " '01010000806A9183135F09EF3FD54F11FF25239CBF1FD70A63F97A7D3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [408.68704, 1109.6688, 0.0],\n", + " [0.969894, -0.02747783, 0.0071973554, -0.24186537],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 162,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941362460.jpg'),\n", " ('scene-0061',\n", - " '0101000080C9484A2E6CA979404CB50FD7D55291400000000000000000',\n", - " '01010000800EDEE720D033EF3F6BC8D45B7D5A9BBF72B88E92C3EB7A3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [410.5889, 1108.7089, 0.0],\n", + " [0.9750748, -0.026712378, 0.0065724985, -0.22016431],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 172,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942162460.jpg'),\n", " ('scene-0061',\n", - " '010100008069162BF2B7CA7940E96BBEBAE54E91400000000000000000',\n", - " '01010000804F248E19B13CEF3F74BA77E870CD97BF222BE2CCAFAF823F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [412.66992, 1107.7244, 0.0],\n", + " [0.9761587, -0.023244632, 0.009124158, -0.21561702],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 182,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943112460.jpg'),\n", " ('scene-0061',\n", - " '0101000080894A8BFFE0CA7840DEA013DFC9B991400000000000000000',\n", - " '0101000080A57ACEA290EDE43FFF1EA8F15A0581BFD887EFCB12FF933F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.67993, 1134.4471, 0.0],\n", + " [0.6539996, -0.008310996, 0.019527715, -0.7561971],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 80,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", " ('scene-0061',\n", - " '01010000809D45BFF2D29479401C786867605591400000000000000000',\n", - " '01010000804D14DCD6F21AEF3F294F6CF2CBA09CBFED0CBA77E4B67B3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [409.3015, 1109.3441, 0.0],\n", + " [0.97203964, -0.027957141, 0.006766217, -0.23304847],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 165,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941612460.jpg'),\n", " ('scene-0061',\n", - " '01010000805E7A6D3A8BFE794061E581E0DD4891400000000000000000',\n", - " '01010000809CEC79CA7745EF3F663BA9BEF54697BFE656449D60EE893F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [415.909, 1106.2167, 0.0],\n", + " [0.97722995, -0.022731628, 0.0126617, -0.21058142],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 201,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944662460.jpg'),\n", " ('scene-0061',\n", - " '0101000080BC8D8A54819A7940FFB495C9A65491400000000000000000',\n", - " '01010000804423132C2024EF3F4EF1DE730C069CBF9AA64D7A45CC7A3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [409.6566, 1109.1628, 0.0],\n", + " [0.97315985, -0.027366824, 0.0065424647, -0.2284034],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 167,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941762460.jpg'),\n", " ('scene-0061',\n", - " '01010000804D553251B8C3794034358468B74F91400000000000000000',\n", - " '0101000080A6B2BBA0483CEF3F10BC479EE6069ABFA6DB9251E622833F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [412.2325, 1107.9291, 0.0],\n", + " [0.97610885, -0.02541695, 0.00934391, -0.21558799],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 180,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942912460.jpg'),\n", " ('scene-0061',\n", - " '0101000080665AF4B501A47940A6DB5FFA7B5391400000000000000000',\n", - " '010100008013CA82C0B02FEF3F50617A3C122C9BBFA2D08C0DBA41793F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [410.25043, 1108.8711, 0.0],\n", + " [0.9745716, -0.026535306, 0.0061661974, -0.22241421],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 170,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942012460.jpg'),\n", " ('scene-0061',\n", - " '0101000080F1B644F0AEE079405D7BAB3D534C91400000000000000000',\n", - " '0101000080766E95B8C03CEF3F96B44BBF4F9296BFE47C8C42D60A893F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [414.04272, 1107.0813, 0.0],\n", + " [0.9761661, -0.02204251, 0.012227701, -0.21555586],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 190,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943762460.jpg'),\n", " ('scene-0061',\n", - " '0101000080910DFC7E14C5784097D0B32CF9AB91400000000000000000',\n", - " '01010000807D88B6426325E63F862F5E2E6DC089BF95E5D97BE5F78C3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.3175, 1130.9933, 0.0],\n", + " [0.6920639, -0.012574055, 0.0141447, -0.7215881],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 88,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", " ('scene-0061',\n", - " '010100008070BD44D528AD7940F8CD4F6D625291400000000000000000',\n", - " '0101000080D76BD05D9535EF3F0E9499F251C79BBF5D76274FF246793F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [410.82248, 1108.5961, 0.0],\n", + " [0.97529095, -0.027127534, 0.0061711753, -0.21916564],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 173,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942262460.jpg'),\n", " ('scene-0061',\n", - " '01010000803507811A53187A40D5F76913104691400000000000000000',\n", - " '0101000080FF4877D20A6EEF3F53815C18679A96BFE0EA26EAD3F3853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [417.5203, 1105.5157, 0.0],\n", + " [0.9821829, -0.022073375, 0.010718971, -0.18631862],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 209,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945412460.jpg'),\n", " ('scene-0061',\n", - " '01010000803BD41B2A12B67940741E4E23555191400000000000000000',\n", - " '0101000080CC66456B413AEF3FE385508869F797BF15B0973C0D59743F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [411.37943, 1108.3331, 0.0],\n", + " [0.97586125, -0.02340474, 0.004967739, -0.21707675],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 175,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942512460.jpg'),\n", " ('scene-0061',\n", - " '0101000080DED26071A2BE79404C0EC7A74F5091400000000000000000',\n", - " '010100008013C1977FDB3BEF3FB8DF9A77CB0A99BF72E53957BECA803F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [411.91467, 1108.0778, 0.0],\n", + " [0.9760568, -0.024455242, 0.008199203, -0.21598104],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 178,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942762460.jpg'),\n", " ('scene-0061',\n", - " '0101000080D219585E6CF6794012798DD7CC4991400000000000000000',\n", - " '010100008090299F3B1D41EF3F4914AEB6031297BFE54B3246319F8B3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [415.40146, 1106.4501, 0.0],\n", + " [0.9766985, -0.022529658, 0.013487229, -0.21300359],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 198,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944412460.jpg'),\n", " ('scene-0061',\n", - " '01010000806D16E3C989DB7940F836C840EF4C91400000000000000000',\n", - " '0101000080FC3D0884143FEF3FF558A7B3925A95BFD01C2B8B87728B3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [413.72113, 1107.2336, 0.0],\n", + " [0.9764502, -0.020853322, 0.013402041, -0.21431404],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 188,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943612460.jpg'),\n", " ('scene-0061',\n", - " '0101000080AF297EA7BBC5784007846B42FD9E91400000000000000000',\n", - " '01010000804D2E3FCEF880E73F72694FF59D798DBF5AA1840711EB8B3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.3583, 1127.7473, 0.0],\n", + " [0.7344936, -0.014392123, 0.013631947, -0.67832595],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 96,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", " ('scene-0061',\n", - " '01010000803061BAF046C77940E8F6D4D94C4F91400000000000000000',\n", - " '0101000080DB872B630E3CEF3FF3B4527A553499BFD4A3A35220D3823F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [412.45483, 1107.8251, 0.0],\n", + " [0.9760811, -0.0246137, 0.009191754, -0.21581335],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 181,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943012460.jpg'),\n", " ('scene-0061',\n", - " '01010000800185BF0B65CC794093BB6C3DB34E91400000000000000000',\n", - " '0101000080943194F22D3DEF3F71ABCAAEC56297BF6EF69F933122833F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [412.77466, 1107.675, 0.0],\n", + " [0.9762182, -0.022837723, 0.009342563, -0.21538149],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 183,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943162460.jpg'),\n", " ('scene-0061',\n", - " '01010000805A6CC13F140F7A40FBE4C6E2054791400000000000000000',\n", - " '010100008088EA404D835BEF3F2C71B402838496BF48A6EC69A1F68A3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [416.94244, 1105.7557, 0.0],\n", + " [0.979921, -0.021989867, 0.013165723, -0.19773196],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 206,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945162460.jpg'),\n", " ('scene-0061',\n", - " '010100008011D599F7B7D479404851777DBA4D91400000000000000000',\n", - " '010100008064FD244F893CEF3F88E5329B607B98BFCB2B10D726F0863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [413.29492, 1107.4321, 0.0],\n", + " [0.97613966, -0.023908148, 0.011200241, -0.2155325],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 186,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943412460.jpg'),\n", " ('scene-0061',\n", - " '01010000809F6FC41387F1794012D3878F5D4A91400000000000000000',\n", - " '0101000080BA326E10E33FEF3F5AFCE47BFCAA96BF8A318A2FEDFC8B3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [415.0955, 1106.5913, 0.0],\n", + " [0.97654873, -0.022136636, 0.013666012, -0.21371907],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 196,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944262460.jpg'),\n", " ('scene-0061',\n", - " '0101000080BBDD3929F9CD7840964AECE1309191400000000000000000',\n", - " '010100008079161DD104FFE83F7D8E148E81CF8ABF8C33631140B4853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [396.87332, 1124.2977, 0.0],\n", + " [0.78113025, -0.0130910985, 0.010597707, -0.6241409],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 104,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", " ('scene-0061',\n", - " '01010000800469C0773EDD7940F1A0B7F3BB4C91400000000000000000',\n", - " '0101000080066CD9CA873EEF3F88E237E4287395BFFA4F1975F3928B3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [413.82776, 1107.1836, 0.0],\n", + " [0.9763831, -0.020947112, 0.013463881, -0.21460654],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 189,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943662460.jpg'),\n", " ('scene-0061',\n", - " '0101000080AF0D857839E4794063A318A8E84B91400000000000000000',\n", - " '0101000080C6FF798E6F3DEF3FBEB44014C2F797BF3A1080032180873F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [414.26404, 1106.9772, 0.0],\n", + " [0.97624946, -0.02340606, 0.011474855, -0.2150754],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 191,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943862460.jpg'),\n", " ('scene-0061',\n", - " '0101000080C489CE739E067A40F2E69227F24791400000000000000000',\n", - " '0101000080646EE65E4C4DEF3F6AC505F95D4696BF5484489AA59E8A3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [416.4137, 1105.9865, 0.0],\n", + " [0.97818583, -0.021752805, 0.012997908, -0.20618038],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 204,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944912460.jpg'),\n", " ('scene-0061',\n", - " '01010000809D8A3D81B1EC7940890223B1ED4A91400000000000000000',\n", - " '01010000802ED4F18CAF3EEF3F22816229A4A397BFE2AEC3584679893F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [414.79333, 1106.7322, 0.0],\n", + " [0.97640204, -0.023085179, 0.012438345, -0.2143627],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 194,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944112460.jpg'),\n", " ('scene-0061',\n", - " '010100008044642740DFDC7840CA5063A1E28491400000000000000000',\n", - " '0101000080828968304266EA3F1BF021235DE490BF58628CF7DFD7883F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [397.8045, 1121.2213, 0.0],\n", + " [0.82498276, -0.016496139, 0.012130499, -0.56478685],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 112,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", " ('scene-0061',\n", - " '0101000080D1AA10DCC6F4794074BDE084FD4991400000000000000000',\n", - " '0101000080BCD629550341EF3F9B83DE3469BB96BF3AE45AFAD6178C3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [415.29855, 1106.4976, 0.0],\n", + " [0.9766862, -0.022199292, 0.013717346, -0.2130802],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 197,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944362460.jpg'),\n", " ('scene-0061',\n", - " '0101000080EF863387B9F97940B1B57D3D6B4991400000000000000000',\n", - " '01010000802E79B9A66941EF3F02415C81592298BFD46C67F1B8948A3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [415.6078, 1106.3547, 0.0],\n", + " [0.97673494, -0.023568533, 0.012978978, -0.21275552],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 199,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944512460.jpg'),\n", " ('scene-0061',\n", - " '010100008035A69B3B55217A406462F05D344591400000000000000000',\n", - " '0101000080C71F235BAB80EF3F4B806CC19C7497BF14BB2D56483C853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [418.0833, 1105.3011, 0.0],\n", + " [0.9844567, -0.022905778, 0.010368886, -0.17381829],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 212,\n", " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945662460.jpg'),\n", " ('scene-0061',\n", - " '0101000080546DBF70D8017A40F78C5DA77C4891400000000000000000',\n", - " '01010000806208AC3B3948EF3F94D80B658E1197BFBBDA43465E118A3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [416.11536, 1106.1217, 0.0],\n", + " [0.97756636, -0.022527909, 0.01272844, -0.20903231],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 202,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944762460.jpg'),\n", " ('scene-0061',\n", - " '010100008009B794F4C2F1784045876B39F87991400000000000000000',\n", - " '0101000080AED53EF576B8EB3F88955BE36C8794BF269D617338A3873F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [399.1101, 1118.4924, 0.0],\n", + " [0.8662677, -0.020047856, 0.011541788, -0.4990443],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 120,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", " ('scene-0061',\n", - " '010100008057DFE12D430D7A40871B6F55374791400000000000000000',\n", - " '01010000800D69329C7058EF3F29DC85D3394C96BFBB34058514878B3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [416.8289, 1105.8041, 0.0],\n", + " [0.9795459, -0.021775154, 0.013441239, -0.19958717],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 205,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945112460.jpg'),\n", " ('scene-0061',\n", - " '01010000802DA4665BAE127A407E0FC69EA44691400000000000000000',\n", - " '0101000080064FA2E34462EF3F3AD888574DE796BF0A7849C60C88883F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [417.16757, 1105.6608, 0.0],\n", + " [0.98074573, -0.022366723, 0.011978244, -0.1936338],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 207,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945262460.jpg'),\n", " ('scene-0061',\n", - " '01010000800FEDAD21E41B7A40F33FA0F4B64591400000000000000000',\n", - " '010100008004319565AD75EF3F8AC9E28219D896BFCE1DC040EF6A853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [417.7432, 1105.4287, 0.0],\n", + " [0.9831149, -0.02230873, 0.010457868, -0.18132299],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 210,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945512460.jpg'),\n", " ('scene-0061',\n", - " '01010000809ABC3D02540B79406CE4EB51797091400000000000000000',\n", - " '0101000080D6DFF800B6CCEC3F46AACDA2E8BF96BF4244EF2D75E6853F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [400.708, 1116.1185, 0.0],\n", + " [0.8999891, -0.022216449, 0.010693469, -0.4352145],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 128,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg'),\n", " ('scene-0061',\n", - " '0101000080F249EE174A2879409C60F7C66C6891400000000000000000',\n", - " '0101000080CF85577969A5ED3FD61AABFC7E269ABFA0BFFEF4FB74863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [402.5181, 1114.1062, 0.0],\n", + " [0.9264419, -0.025537476, 0.0109653175, -0.37541047],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 136,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939162460.jpg'),\n", " ('scene-0061',\n", - " '01010000807568FCFDA74979406E58D1412A6191400000000000000000',\n", - " '0101000080FA49ABE5A251EE3FFA0CA7AFD29C9DBF26F27997F7F6843F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [404.60352, 1112.2913, 0.0],\n", + " [0.94746536, -0.028918544, 0.010236678, -0.31838387],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 144,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939862460.jpg'),\n", " ('scene-0061',\n", - " '01010000808F3D7EBA9767794000846457E05B91400000000000000000',\n", - " '0101000080DAB145C979B6EE3F4277EF0BCAE79DBF580D5B6F6745823F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [406.47455, 1110.9691, 0.0],\n", + " [0.95977485, -0.029204518, 0.00892144, -0.2791052],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 152,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940512460.jpg'),\n", " ('scene-0061',\n", - " '010100008088E5B27D168379408762BC44C15791400000000000000000',\n", - " '0101000080CF7A743360F8EE3F383915D4DC589DBFBD2FF930FF707F3F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [408.193, 1109.9387, 0.0],\n", + " [0.96781933, -0.028659297, 0.007676122, -0.24989098],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 160,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941162460.jpg'),\n", " ('scene-0061',\n", - " '0101000080FC1255362E9E79406D707A4C325491400000000000000000',\n", - " '0101000080881B80C1E529EF3FD4B7FD0AAEA29BBF199097676980793F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [409.8863, 1109.0491, 0.0],\n", + " [0.97386444, -0.026987761, 0.0062259785, -0.22543503],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 168,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941862460.jpg'),\n", " ('scene-0061',\n", - " '0101000080BAD8051594B97940D349ACE1E95091400000000000000000',\n", - " '0101000080F47FA2E2C33AEF3F571B996B913298BF5FC983A3A52A773F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [411.59866, 1108.2284, 0.0],\n", + " [0.9759235, -0.023630401, 0.0056559057, -0.21675555],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 176,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942612460.jpg'),\n", " ('scene-0061',\n", - " '010100008048D15B56CBCF7940B1906B294D4E91400000000000000000',\n", - " '010100008059039B105B3DEF3FAC3AD98285AE97BF0232B697DFE2843F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [412.98715, 1107.5753, 0.0],\n", + " [0.97623974, -0.023126684, 0.010198352, -0.21521425],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 184,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943262460.jpg'),\n", " ('scene-0061',\n", - " '010100008089DC6C91F5E57940FBD9A177B44B91400000000000000000',\n", - " '01010000809FC01E77633EEF3F114B34E77AA798BF3E863407C186873F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [414.37247, 1106.9263, 0.0],\n", + " [0.9763658, -0.024076385, 0.011487491, -0.21447194],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 192,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943912478.jpg'),\n", " ('scene-0061',\n", - " '0101000080476F5378DBFC7940D201820C0F4991400000000000000000',\n", - " '01010000809882930CD043EF3F71B3C2F93BB897BFCAF13B30DBFA893F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [415.8036, 1106.2646, 0.0],\n", + " [0.9770279, -0.023163736, 0.012685502, -0.2114686],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 200,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944612460.jpg'),\n", " ('scene-0061',\n", - " '0101000080EC0D20D874167A406335BB36404691400000000000000000',\n", - " '0101000080EC036FA9FD69EF3FB8B00FBDC79396BFCD238C1E2179863F',\n", - " '0101000080476386D27036FB3FA3B2F1460D54903F8846DBEAE12CF83F',\n", - " '01010000809EDD7A9CBFFCDF3FDB328EC2D518E0BFA921557664FCDF3F',\n", + " [417.40353, 1105.5627, 0.0],\n", + " [0.9816883, -0.022048112, 0.0109732235, -0.1888954],\n", + " [1.7007912, 0.015945632, 1.5109576],\n", + " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", " 208,\n", " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945362460.jpg')]" @@ -4392,27 +4419,10049 @@ { "cell_type": "code", "execution_count": 13, + "id": "ed2962ed", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\n" + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ] }, { - "ename": "TypeError", - "evalue": "unsupported operand type(s) for -=: 'list' and 'str'", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mscenic_world\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_overlay_info\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcar_trajectories\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcamera_info\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;32m~\\OneDrive - University of Toronto\\Desktop\\Capstone\\apperception\\apperception\\scenic_world.py\u001b[0m in \u001b[0;36mget_overlay_info\u001b[1;34m(self, trajectory, camera_info)\u001b[0m\n\u001b[0;32m 198\u001b[0m \u001b[0mcamera_config\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'cameraRotation'\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcur_camera_info\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 199\u001b[0m \u001b[0mcamera_config\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'cameraIntrinsic'\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m\u001b[0mcur_camera_info\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 200\u001b[1;33m \u001b[0mtraj_2d\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtransformation\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcentroid_3d\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcamera_config\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# one point of the trajectory in 2d\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 201\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 202\u001b[0m \u001b[0mframenum\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcur_camera_info\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m6\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32m~\\OneDrive - University of Toronto\\Desktop\\Capstone\\apperception\\apperception\\scenic_util.py\u001b[0m in \u001b[0;36mtransformation\u001b[1;34m(centroid_3d, camera_config)\u001b[0m\n\u001b[0;32m 372\u001b[0m \u001b[0mTODO\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mtransformation\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[1;36m3\u001b[0m\u001b[0md\u001b[0m \u001b[0mworld\u001b[0m \u001b[0mcoordinate\u001b[0m \u001b[0mto\u001b[0m \u001b[1;36m2\u001b[0m\u001b[0md\u001b[0m \u001b[0mframe\u001b[0m \u001b[0mcoordinate\u001b[0m \u001b[0mgiven\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mcamera\u001b[0m \u001b[0mconfig\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 373\u001b[0m \t'''\n\u001b[1;32m--> 374\u001b[1;33m \u001b[0mcentroid_3d\u001b[0m \u001b[1;33m-=\u001b[0m \u001b[0mcamera_config\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'egoTranslation'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 375\u001b[0m \u001b[0mcentroid_3d\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mQuaternion\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcamera_config\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'egoRotation'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0minverse\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrotation_matrix\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcentroid_3d\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 376\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for -=: 'list' and 'str'" + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ] + }, + { + "data": { + "text/plain": [ + "[[(array([[1583.23856331],\n", + " [ 503.09714074]]),\n", + " 3,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", + " (array([[1672.44622714],\n", + " [ 495.63783585]]),\n", + " 11,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", + " (array([[1801.42531047],\n", + " [ 506.85860628]]),\n", + " 19,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", + " (array([[1933.03288266],\n", + " [ 513.06262568]]),\n", + " 27,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", + " (array([[2097.76615143],\n", + " [ 523.77192278]]),\n", + " 35,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", + " (array([[2315.33365545],\n", + " [ 539.53363603]]),\n", + " 43,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", + " (array([[1562.47105967],\n", + " [ 505.75308814]]),\n", + " 1,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg'),\n", + " (array([[2583.20543882],\n", + " [ 552.07201123]]),\n", + " 51,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", + " (array([[1650.21356897],\n", + " [ 501.21857729]]),\n", + " 9,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", + " (array([[2960.58668303],\n", + " [ 555.45359404]]),\n", + " 59,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", + " (array([[1760.22502942],\n", + " [ 509.60057442]]),\n", + " 17,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", + " (array([[1612.98393303],\n", + " [ 509.08789553]]),\n", + " 6,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", + " (array([[3719.74087511],\n", + " [ 582.47431668]]),\n", + " 67,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", + " (array([[1901.11225566],\n", + " [ 513.44062369]]),\n", + " 25,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", + " (array([[1600.66067399],\n", + " [ 507.14188298]]),\n", + " 5,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", + " (array([[1595.19187156],\n", + " [ 506.06889087]]),\n", + " 4,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", + " (array([[1714.2997564 ],\n", + " [ 512.60417651]]),\n", + " 14,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", + " (array([[5689.47741549],\n", + " [ 748.0763832 ]]),\n", + " 75,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", + " (array([[2056.33260892],\n", + " [ 519.09946333]]),\n", + " 33,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", + " (array([[1690.45445428],\n", + " [ 497.19170504]]),\n", + " 12,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", + " (array([[1569.44991322],\n", + " [ 502.86027008]]),\n", + " 2,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", + " (array([[1708.05010926],\n", + " [ 507.62952612]]),\n", + " 13,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", + " (array([[1851.80244938],\n", + " [ 507.91706344]]),\n", + " 22,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", + " (array([[16281.08844515],\n", + " [ 1410.35217171]]),\n", + " 83,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", + " (array([[1629.73744627],\n", + " [ 505.91857202]]),\n", + " 7,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", + " (array([[2251.09670999],\n", + " [ 533.32851898]]),\n", + " 41,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", + " (array([[1666.17480671],\n", + " [ 496.24569809]]),\n", + " 10,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", + " (array([[1812.17842028],\n", + " [ 505.24242525]]),\n", + " 20,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", + " (array([[1831.31343444],\n", + " [ 505.81474857]]),\n", + " 21,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", + " (array([[-10482.69407562],\n", + " [ -166.99729307]]),\n", + " 91,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", + " (array([[1989.23667911],\n", + " [ 511.66561711]]),\n", + " 30,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", + " (array([[1729.99015786],\n", + " [ 513.9803146 ]]),\n", + " 15,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", + " (array([[2518.75418552],\n", + " [ 543.29982144]]),\n", + " 49,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", + " (array([[1779.97600725],\n", + " [ 506.13460135]]),\n", + " 18,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", + " (array([[1954.51482005],\n", + " [ 510.77881331]]),\n", + " 28,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", + " (array([[1964.28625551],\n", + " [ 510.85011794]]),\n", + " 29,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", + " (array([[-2838.49620369],\n", + " [ 288.35603174]]),\n", + " 99,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", + " (array([[2174.08867172],\n", + " [ 531.61492342]]),\n", + " 38,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", + " (array([[1863.02618066],\n", + " [ 507.5947961 ]]),\n", + " 23,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", + " (array([[2868.10169263],\n", + " [ 550.02980998]]),\n", + " 57,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", + " (array([[1912.87014282],\n", + " [ 512.48711114]]),\n", + " 26,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", + " (array([[2128.79178067],\n", + " [ 524.1944701 ]]),\n", + " 36,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", + " (array([[2158.83727209],\n", + " [ 529.22497187]]),\n", + " 37,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", + " (array([[-1275.44255601],\n", + " [ 366.15459743]]),\n", + " 107,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", + " (array([[2407.85062272],\n", + " [ 538.15318056]]),\n", + " 46,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", + " (array([[2014.49528186],\n", + " [ 511.99656649]]),\n", + " 31,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", + " (array([[3390.72088978],\n", + " [ 561.75339199]]),\n", + " 65,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", + " (array([[2366.97974082],\n", + " [ 536.32840048]]),\n", + " 45,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", + " (array([[2081.51954489],\n", + " [ 518.65070459]]),\n", + " 34,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", + " (array([[2330.16495084],\n", + " [ 536.50156984]]),\n", + " 44,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", + " (array([[-614.76118311],\n", + " [ 389.65116762]]),\n", + " 115,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", + " (array([[2701.90396017],\n", + " [ 542.05976538]]),\n", + " 54,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", + " (array([[2194.22014681],\n", + " [ 530.21980452]]),\n", + " 39,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", + " (array([[2275.42221287],\n", + " [ 530.07962226]]),\n", + " 42,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", + " (array([[5059.62483744],\n", + " [ 686.8734955 ]]),\n", + " 73,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", + " (array([[2643.15777293],\n", + " [ 545.55984174]]),\n", + " 53,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", + " (array([[2620.21759973],\n", + " [ 546.40529345]]),\n", + " 52,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", + " (array([[-146.12870923],\n", + " [ 408.38151854]]),\n", + " 123,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", + " (array([[3139.46287802],\n", + " [ 549.58296452]]),\n", + " 62,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", + " (array([[2422.66556745],\n", + " [ 536.98231672]]),\n", + " 47,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", + " (array([[150.39399952],\n", + " [427.6945406 ]]),\n", + " 131,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", + " (array([[3021.66739063],\n", + " [ 551.82950934]]),\n", + " 60,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", + " (array([[10044.38351925],\n", + " [ 990.73211788]]),\n", + " 81,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", + " (array([[2534.70142892],\n", + " [ 540.60773988]]),\n", + " 50,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", + " (array([[3097.31080209],\n", + " [ 549.56391711]]),\n", + " 61,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", + " (array([[4142.98251701],\n", + " [ 604.05461777]]),\n", + " 70,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", + " (array([[2757.94901567],\n", + " [ 539.08094427]]),\n", + " 55,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", + " (array([[364.2654916 ],\n", + " [437.87006865]]),\n", + " 139,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939412460.jpg'),\n", + " (array([[-19077.45549976],\n", + " [ -593.45364212]]),\n", + " 89,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", + " (array([[3861.79040235],\n", + " [ 580.46056399]]),\n", + " 68,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", + " (array([[2916.35171389],\n", + " [ 547.06125252]]),\n", + " 58,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", + " (array([[7046.64959284],\n", + " [ 834.32063264]]),\n", + " 78,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", + " (array([[3233.81500291],\n", + " [ 552.01458435]]),\n", + " 63,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", + " (array([[532.51233353],\n", + " [448.86955629]]),\n", + " 147,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940112460.jpg'),\n", + " (array([[-3927.00087066],\n", + " [ 243.77241192]]),\n", + " 97,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", + " (array([[6170.02352268],\n", + " [ 754.38979699]]),\n", + " 76,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", + " (array([[3638.84602473],\n", + " [ 559.76077534]]),\n", + " 66,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", + " (array([[117958.59449261],\n", + " [ 6651.20088697]]),\n", + " 86,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", + " (array([[4049.09723868],\n", + " [ 585.51165 ]]),\n", + " 69,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", + " (array([[4372.55815253],\n", + " [ 610.16094336]]),\n", + " 71,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", + " (array([[633.15448419],\n", + " [458.96922919]]),\n", + " 155,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940762460.jpg'),\n", + " (array([[-1640.97030191],\n", + " [ 363.95663936]]),\n", + " 105,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", + " (array([[19239.29193738],\n", + " [ 1509.18215076]]),\n", + " 84,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", + " (array([[5468.42430013],\n", + " [ 702.73707645]]),\n", + " 74,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", + " (array([[-5900.39110976],\n", + " [ 148.09668165]]),\n", + " 94,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", + " (array([[6757.77812588],\n", + " [ 759.36021102]]),\n", + " 77,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", + " (array([[7933.05144534],\n", + " [ 837.77471161]]),\n", + " 79,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", + " (array([[708.85009783],\n", + " [470.02848078]]),\n", + " 163,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941412460.jpg'),\n", + " (array([[-741.83047223],\n", + " [ 397.82116679]]),\n", + " 113,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", + " (array([[12320.75671122],\n", + " [ 1033.95323033]]),\n", + " 82,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", + " (array([[-7845.26518725],\n", + " [ 78.81441516]]),\n", + " 92,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", + " (array([[-2101.87428744],\n", + " [ 360.36005795]]),\n", + " 102,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", + " (array([[35166.66139198],\n", + " [ 2192.00877477]]),\n", + " 85,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", + " (array([[-155355.06897681],\n", + " [ -6930.07201434]]),\n", + " 87,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", + " (array([[1634.53455513],\n", + " [ 493.028584 ]]),\n", + " 8,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", + " (array([[762.7910376 ],\n", + " [473.37527678]]),\n", + " 171,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942112460.jpg'),\n", + " (array([[-257.01965462],\n", + " [ 420.43121864]]),\n", + " 121,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", + " (array([[-2487.74870678],\n", + " [ 342.85543533]]),\n", + " 100,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", + " (array([[-14453.42439088],\n", + " [ -200.04115386]]),\n", + " 90,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", + " (array([[-977.27280411],\n", + " [ 397.03587695]]),\n", + " 110,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", + " (array([[-7031.93173648],\n", + " [ 96.86255469]]),\n", + " 93,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", + " (array([[-4858.93687596],\n", + " [ 211.98746202]]),\n", + " 95,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", + " (array([[1747.98149254],\n", + " [ 497.06458958]]),\n", + " 16,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", + " (array([[778.54767326],\n", + " [467.41090929]]),\n", + " 179,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942862460.jpg'),\n", + " (array([[ 98.48260153],\n", + " [438.30522379]]),\n", + " 129,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", + " (array([[-3166.57747263],\n", + " [ 319.97717728]]),\n", + " 98,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", + " (array([[-1142.88751826],\n", + " [ 394.45899966]]),\n", + " 108,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", + " (array([[-418.87941732],\n", + " [ 421.41519204]]),\n", + " 118,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", + " (array([[-2344.65429374],\n", + " [ 345.60853374]]),\n", + " 101,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", + " (array([[-1889.76186385],\n", + " [ 370.67422999]]),\n", + " 103,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", + " (array([[1879.1259691 ],\n", + " [ 496.16014217]]),\n", + " 24,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", + " (array([[781.63698819],\n", + " [459.23768845]]),\n", + " 187,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943512460.jpg'),\n", + " (array([[328.71473195],\n", + " [448.89760094]]),\n", + " 137,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939262460.jpg'),\n", + " (array([[-1375.34622705],\n", + " [ 397.48103796]]),\n", + " 106,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", + " (array([[-519.73005406],\n", + " [ 420.8919645 ]]),\n", + " 116,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", + " (array([[ -9.22912653],\n", + " [432.41844019]]),\n", + " 126,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", + " (array([[-1075.35408214],\n", + " [ 403.74336541]]),\n", + " 109,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", + " (array([[-866.47927254],\n", + " [ 407.56519183]]),\n", + " 111,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", + " (array([[2038.6801857 ],\n", + " [ 493.95826756]]),\n", + " 32,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", + " (array([[789.54350685],\n", + " [460.86116499]]),\n", + " 195,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944162460.jpg'),\n", + " (array([[503.42292542],\n", + " [460.70615363]]),\n", + " 145,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939912460.jpg'),\n", + " (array([[-99.22667708],\n", + " [427.47805504]]),\n", + " 124,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", + " (array([[-623.19408629],\n", + " [ 412.42186851]]),\n", + " 114,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", + " (array([[255.36686578],\n", + " [448.77086328]]),\n", + " 134,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", + " (array([[-445.94684912],\n", + " [ 423.02907531]]),\n", + " 117,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", + " (array([[805.26873158],\n", + " [459.23660809]]),\n", + " 203,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944862460.jpg'),\n", + " (array([[-341.6914838 ],\n", + " [ 424.14549973]]),\n", + " 119,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", + " (array([[2241.82229491],\n", + " [ 514.13660808]]),\n", + " 40,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", + " (array([[620.49451322],\n", + " [466.31117702]]),\n", + " 153,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940612460.jpg'),\n", + " (array([[-188.25081859],\n", + " [ 423.56236281]]),\n", + " 122,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", + " (array([[199.38066814],\n", + " [442.73079984]]),\n", + " 132,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", + " (array([[440.28893346],\n", + " [451.92520466]]),\n", + " 142,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939662460.jpg'),\n", + " (array([[-54.77943772],\n", + " [424.6368745 ]]),\n", + " 125,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", + " (array([[883.10298374],\n", + " [467.72270862]]),\n", + " 211,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945612460.jpg'),\n", + " (array([[ 16.30558952],\n", + " [434.18443584]]),\n", + " 127,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", + " (array([[2490.23363701],\n", + " [ 516.60946512]]),\n", + " 48,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", + " (array([[698.96244768],\n", + " [471.87433634]]),\n", + " 161,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941262460.jpg'),\n", + " (array([[401.85328317],\n", + " [452.75735757]]),\n", + " 140,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939512460.jpg'),\n", + " (array([[124.57991371],\n", + " [441.47393687]]),\n", + " 130,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", + " (array([[583.7091339 ],\n", + " [463.65709337]]),\n", + " 150,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940362460.jpg'),\n", + " (array([[217.95232528],\n", + " [444.2906363 ]]),\n", + " 133,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", + " (array([[284.54014143],\n", + " [448.15584832]]),\n", + " 135,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", + " (array([[758.03646265],\n", + " [476.87656039]]),\n", + " 169,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941912460.jpg'),\n", + " (array([[2825.34748401],\n", + " [ 516.4426473 ]]),\n", + " 56,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", + " (array([[549.86542223],\n", + " [460.40695937]]),\n", + " 148,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940162460.jpg'),\n", + " (array([[360.72877347],\n", + " [449.50231337]]),\n", + " 138,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939362460.jpg'),\n", + " (array([[672.70546347],\n", + " [468.48438979]]),\n", + " 158,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941012460.jpg'),\n", + " (array([[428.28989104],\n", + " [452.75241687]]),\n", + " 141,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939612460.jpg'),\n", + " (array([[466.81401742],\n", + " [454.75598755]]),\n", + " 143,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939762460.jpg'),\n", + " (array([[779.55618932],\n", + " [475.6447674 ]]),\n", + " 177,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942662460.jpg'),\n", + " (array([[3389.56652333],\n", + " [ 524.99490605]]),\n", + " 64,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", + " (array([[653.93674031],\n", + " [468.9689665 ]]),\n", + " 156,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940862460.jpg'),\n", + " (array([[522.30850617],\n", + " [459.46302771]]),\n", + " 146,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940012460.jpg'),\n", + " (array([[739.26777161],\n", + " [474.92582623]]),\n", + " 166,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941662460.jpg'),\n", + " (array([[567.82005917],\n", + " [463.16830697]]),\n", + " 149,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940262460.jpg'),\n", + " (array([[593.28071249],\n", + " [465.20293613]]),\n", + " 151,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940412460.jpg'),\n", + " (array([[783.91065687],\n", + " [465.33841927]]),\n", + " 185,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943362460.jpg'),\n", + " (array([[629.02970119],\n", + " [467.73685868]]),\n", + " 154,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940662460.jpg'),\n", + " (array([[726.95230377],\n", + " [474.44258319]]),\n", + " 164,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941512460.jpg'),\n", + " (array([[4750.62451475],\n", + " [ 599.05035044]]),\n", + " 72,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", + " (array([[775.10382124],\n", + " [478.23683804]]),\n", + " 174,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942362460.jpg'),\n", + " (array([[661.29351704],\n", + " [469.45382447]]),\n", + " 157,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940912460.jpg'),\n", + " (array([[789.46399066],\n", + " [464.06970185]]),\n", + " 193,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944012460.jpg'),\n", + " (array([[685.47444819],\n", + " [470.8085833 ]]),\n", + " 159,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941112460.jpg'),\n", + " (array([[712.15013482],\n", + " [473.7545568 ]]),\n", + " 162,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941362460.jpg'),\n", + " (array([[770.17481886],\n", + " [476.83970411]]),\n", + " 172,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942162460.jpg'),\n", + " (array([[783.82537592],\n", + " [469.61670894]]),\n", + " 182,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943112460.jpg'),\n", + " (array([[9952.21418067],\n", + " [ 871.60288946]]),\n", + " 80,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", + " (array([[736.18341753],\n", + " [476.06263672]]),\n", + " 165,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941612460.jpg'),\n", + " (array([[799.24830483],\n", + " [461.63576845]]),\n", + " 201,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944662460.jpg'),\n", + " (array([[748.58559022],\n", + " [476.76556278]]),\n", + " 167,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941762460.jpg'),\n", + " (array([[783.83153774],\n", + " [470.30886824]]),\n", + " 180,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942912460.jpg'),\n", + " (array([[764.91969786],\n", + " [478.11916662]]),\n", + " 170,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942012460.jpg'),\n", + " (array([[785.9341174 ],\n", + " [462.18601642]]),\n", + " 190,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943762460.jpg'),\n", + " (array([[-25913.63738132],\n", + " [ -635.70851993]]),\n", + " 88,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", + " (array([[773.66998839],\n", + " [478.6604909 ]]),\n", + " 173,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942262460.jpg'),\n", + " (array([[860.90107807],\n", + " [467.84869897]]),\n", + " 209,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945412460.jpg'),\n", + " (array([[780.07559591],\n", + " [479.6164567 ]]),\n", + " 175,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942512460.jpg'),\n", + " (array([[783.41090009],\n", + " [472.38215654]]),\n", + " 178,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942762460.jpg'),\n", + " (array([[793.66481459],\n", + " [459.14751903]]),\n", + " 198,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944412460.jpg'),\n", + " (array([[789.35069847],\n", + " [458.37040667]]),\n", + " 188,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943612460.jpg'),\n", + " (array([[-4279.51185295],\n", + " [ 257.42407621]]),\n", + " 96,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", + " (array([[784.26607977],\n", + " [470.10696801]]),\n", + " 181,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943012460.jpg'),\n", + " (array([[786.13809405],\n", + " [468.50603912]]),\n", + " 183,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943162460.jpg'),\n", + " (array([[833.17640066],\n", + " [460.27687037]]),\n", + " 206,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945162460.jpg'),\n", + " (array([[786.13730679],\n", + " [464.52926156]]),\n", + " 186,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943412460.jpg'),\n", + " (array([[792.12233852],\n", + " [458.00089239]]),\n", + " 196,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944262460.jpg'),\n", + " (array([[-1738.61185611],\n", + " [ 383.56354813]]),\n", + " 104,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", + " (array([[789.09800008],\n", + " [457.78063526]]),\n", + " 189,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943662460.jpg'),\n", + " (array([[788.41583562],\n", + " [463.28075587]]),\n", + " 191,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943862460.jpg'),\n", + " (array([[812.18449213],\n", + " [459.55645515]]),\n", + " 204,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944912460.jpg'),\n", + " (array([[790.58666158],\n", + " [460.88889639]]),\n", + " 194,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944112460.jpg'),\n", + " (array([[-797.38121449],\n", + " [ 405.53459661]]),\n", + " 112,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", + " (array([[794.23464216],\n", + " [457.50050424]]),\n", + " 197,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944362460.jpg'),\n", + " (array([[795.11779981],\n", + " [459.98121721]]),\n", + " 199,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944512460.jpg'),\n", + " (array([[893.44238538],\n", + " [468.14847035]]),\n", + " 212,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945662460.jpg'),\n", + " (array([[805.22139403],\n", + " [459.92707716]]),\n", + " 202,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944762460.jpg'),\n", + " (array([[-266.29342704],\n", + " [ 424.80542208]]),\n", + " 120,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", + " (array([[829.30745172],\n", + " [458.48075077]]),\n", + " 205,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945112460.jpg'),\n", + " (array([[844.17659115],\n", + " [462.71080612]]),\n", + " 207,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945262460.jpg'),\n", + " (array([[874.87146349],\n", + " [467.13315545]]),\n", + " 210,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945512460.jpg'),\n", + " (array([[ 69.65056518],\n", + " [439.00112112]]),\n", + " 128,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg'),\n", + " (array([[306.66199249],\n", + " [447.03159187]]),\n", + " 136,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939162460.jpg'),\n", + " (array([[494.87040495],\n", + " [456.55090027]]),\n", + " 144,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939862460.jpg'),\n", + " (array([[611.7812464 ],\n", + " [464.42618046]]),\n", + " 152,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940512460.jpg'),\n", + " (array([[693.5171868 ],\n", + " [470.30409693]]),\n", + " 160,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941162460.jpg'),\n", + " (array([[759.46744922],\n", + " [474.89608853]]),\n", + " 168,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941862460.jpg'),\n", + " (array([[783.22830111],\n", + " [475.64229809]]),\n", + " 176,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942612460.jpg'),\n", + " (array([[788.39208992],\n", + " [464.68102699]]),\n", + " 184,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943262460.jpg'),\n", + " (array([[791.20429527],\n", + " [462.21286518]]),\n", + " 192,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943912478.jpg'),\n", + " (array([[799.67099818],\n", + " [459.23572459]]),\n", + " 200,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944612460.jpg'),\n", + " (array([[856.795014 ],\n", + " [464.38279264]]),\n", + " 208,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945362460.jpg')],\n", + " [(array([[283.15777714],\n", + " [425.88532419]]),\n", + " 3,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", + " (array([[484.67367196],\n", + " [433.13642919]]),\n", + " 11,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", + " (array([[372.08227411],\n", + " [437.345324 ]]),\n", + " 1,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg'),\n", + " (array([[467.63525903],\n", + " [438.16433163]]),\n", + " 9,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", + " (array([[434.46717347],\n", + " [438.42178867]]),\n", + " 6,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", + " (array([[420.69624213],\n", + " [437.7224591 ]]),\n", + " 5,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", + " (array([[413.76811332],\n", + " [435.91429809]]),\n", + " 4,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", + " (array([[566.73936628],\n", + " [453.35627337]]),\n", + " 14,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", + " (array([[555.51264776],\n", + " [441.09677645]]),\n", + " 12,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", + " (array([[472.27885177],\n", + " [446.63939916]]),\n", + " 2,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", + " (array([[563.94195844],\n", + " [449.17548074]]),\n", + " 13,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", + " (array([[520.55604962],\n", + " [445.85603854]]),\n", + " 7,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", + " (array([[543.10876302],\n", + " [442.59080844]]),\n", + " 10,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", + " (array([[525.27018675],\n", + " [445.82943002]]),\n", + " 8,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg')],\n", + " [(array([[933.37494733],\n", + " [498.27868085]]),\n", + " 3,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", + " (array([[950.96387063],\n", + " [489.77816603]]),\n", + " 11,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", + " (array([[993.61748049],\n", + " [502.99313138]]),\n", + " 19,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", + " (array([[920.9280666 ],\n", + " [498.68209001]]),\n", + " 1,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg'),\n", + " (array([[944.52457547],\n", + " [495.60531558]]),\n", + " 9,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", + " (array([[978.72067244],\n", + " [502.30962341]]),\n", + " 17,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", + " (array([[933.35634475],\n", + " [499.61018612]]),\n", + " 6,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", + " (array([[1009.32957513],\n", + " [ 503.41668981]]),\n", + " 25,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", + " (array([[926.6692726 ],\n", + " [494.75125058]]),\n", + " 5,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", + " (array([[925.9933551 ],\n", + " [493.40049797]]),\n", + " 4,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", + " (array([[956.2771314],\n", + " [500.537134 ]]),\n", + " 14,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", + " (array([[950.32926646],\n", + " [486.37428221]]),\n", + " 12,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", + " (array([[919.39614895],\n", + " [493.4156123 ]]),\n", + " 2,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", + " (array([[955.29768198],\n", + " [495.95917398]]),\n", + " 13,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", + " (array([[982.66001664],\n", + " [489.28507166]]),\n", + " 22,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", + " (array([[927.31400232],\n", + " [487.74019957]]),\n", + " 7,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", + " (array([[935.90924164],\n", + " [481.33339553]]),\n", + " 10,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", + " (array([[973.8085002],\n", + " [488.7475178]]),\n", + " 20,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", + " (array([[978.21214731],\n", + " [488.04612651]]),\n", + " 21,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", + " (array([[950.89653172],\n", + " [495.92977629]]),\n", + " 15,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", + " (array([[962.00712165],\n", + " [486.77022112]]),\n", + " 18,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", + " (array([[980.28929683],\n", + " [487.74871123]]),\n", + " 23,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", + " (array([[989.23473515],\n", + " [492.52868671]]),\n", + " 26,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", + " (array([[927.94875737],\n", + " [485.16366203]]),\n", + " 8,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", + " (array([[953.82729878],\n", + " [488.63164616]]),\n", + " 16,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", + " (array([[984.79038496],\n", + " [490.44569792]]),\n", + " 24,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg')],\n", + " [(array([[1053.25706639],\n", + " [ 500.95476452]]),\n", + " 3,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", + " (array([[1107.16877484],\n", + " [ 496.4991548 ]]),\n", + " 11,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", + " (array([[1204.25014369],\n", + " [ 514.20907029]]),\n", + " 19,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", + " (array([[1334.89024279],\n", + " [ 531.80018505]]),\n", + " 27,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", + " (array([[1564.93524775],\n", + " [ 561.71914075]]),\n", + " 35,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", + " (array([[2158.36851325],\n", + " [ 640.21170018]]),\n", + " 43,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", + " (array([[1039.8756684 ],\n", + " [ 502.90792834]]),\n", + " 1,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg'),\n", + " (array([[4778.54140024],\n", + " [ 961.80227879]]),\n", + " 51,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", + " (array([[1091.2413688 ],\n", + " [ 500.44724469]]),\n", + " 9,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", + " (array([[-3277.05891187],\n", + " [ -13.70541524]]),\n", + " 59,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", + " (array([[1168.93265591],\n", + " [ 511.05879271]]),\n", + " 17,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", + " (array([[1067.95697079],\n", + " [ 504.41159352]]),\n", + " 6,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", + " (array([[-403.19595065],\n", + " [ 313.66412365]]),\n", + " 67,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", + " (array([[1294.84695941],\n", + " [ 526.22839677]]),\n", + " 25,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", + " (array([[1048.13166787],\n", + " [ 501.08653408]]),\n", + " 5,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", + " (array([[1045.51172742],\n", + " [ 499.59369039]]),\n", + " 4,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", + " (array([[1116.83545765],\n", + " [ 510.37145659]]),\n", + " 14,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", + " (array([[ 84.052647 ],\n", + " [360.8300367]]),\n", + " 75,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", + " (array([[1431.12030745],\n", + " [ 539.59422798]]),\n", + " 33,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", + " (array([[1101.53957175],\n", + " [ 494.79818763]]),\n", + " 12,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", + " (array([[1026.87446264],\n", + " [ 496.69646185]]),\n", + " 2,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", + " (array([[1103.84894452],\n", + " [ 502.64698755]]),\n", + " 13,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", + " (array([[1201.74077026],\n", + " [ 508.27287331]]),\n", + " 22,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", + " (array([[296.78859265],\n", + " [400.91263538]]),\n", + " 83,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", + " (array([[1058.48653781],\n", + " [ 498.25577547]]),\n", + " 7,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", + " (array([[1661.89639706],\n", + " [ 565.33359452]]),\n", + " 41,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", + " (array([[1067.85474231],\n", + " [ 490.47743489]]),\n", + " 10,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", + " (array([[1153.25120031],\n", + " [ 502.45301353]]),\n", + " 20,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", + " (array([[1165.58783913],\n", + " [ 502.70663904]]),\n", + " 21,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", + " (array([[439.87856697],\n", + " [413.14190247]]),\n", + " 91,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", + " (array([[1280.7794978],\n", + " [ 516.1449975]]),\n", + " 30,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", + " (array([[1089.13916264],\n", + " [ 503.48943606]]),\n", + " 15,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", + " (array([[1805.14391603],\n", + " [ 569.73263363]]),\n", + " 49,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", + " (array([[1116.636023 ],\n", + " [ 497.23983042]]),\n", + " 18,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", + " (array([[1221.56339287],\n", + " [ 507.28996677]]),\n", + " 28,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", + " (array([[1228.04723996],\n", + " [ 507.38871642]]),\n", + " 29,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", + " (array([[572.36040358],\n", + " [433.75936269]]),\n", + " 99,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", + " (array([[1321.43455812],\n", + " [ 519.40646308]]),\n", + " 38,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", + " (array([[1140.2135718 ],\n", + " [ 495.12109111]]),\n", + " 23,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", + " (array([[2053.46170757],\n", + " [ 579.35460804]]),\n", + " 57,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", + " (array([[1165.53385074],\n", + " [ 501.04518259]]),\n", + " 26,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", + " (array([[1291.45060865],\n", + " [ 513.55610905]]),\n", + " 36,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", + " (array([[1311.10570405],\n", + " [ 517.73907576]]),\n", + " 37,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", + " (array([[636.31827336],\n", + " [441.8084792 ]]),\n", + " 107,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", + " (array([[1408.59390448],\n", + " [ 514.84209537]]),\n", + " 46,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", + " (array([[1188.23989121],\n", + " [ 495.77397774]]),\n", + " 31,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", + " (array([[2374.08112865],\n", + " [ 586.04611379]]),\n", + " 65,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", + " (array([[1382.73100054],\n", + " [ 514.21252368]]),\n", + " 45,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", + " (array([[1221.7193652 ],\n", + " [ 501.69048164]]),\n", + " 34,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", + " (array([[1359.95751177],\n", + " [ 513.86752704]]),\n", + " 44,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", + " (array([[499.684133 ],\n", + " [434.97088008]]),\n", + " 115,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", + " (array([[1502.3026943 ],\n", + " [ 522.78586499]]),\n", + " 54,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", + " (array([[1243.58356603],\n", + " [ 506.33288697]]),\n", + " 39,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", + " (array([[1281.00019101],\n", + " [ 504.46036931]]),\n", + " 42,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", + " (array([[3587.68303396],\n", + " [ 708.66984775]]),\n", + " 73,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", + " (array([[1469.86310046],\n", + " [ 523.64649969]]),\n", + " 53,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", + " (array([[1391.69684286],\n", + " [ 514.14863133]]),\n", + " 52,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", + " (array([[560.26582529],\n", + " [440.68079204]]),\n", + " 123,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", + " (array([[1631.29264598],\n", + " [ 523.51230296]]),\n", + " 62,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", + " (array([[1308.26946724],\n", + " [ 501.41051653]]),\n", + " 47,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", + " (array([[748.2016886 ],\n", + " [455.53857378]]),\n", + " 131,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", + " (array([[1501.15123802],\n", + " [ 508.12856077]]),\n", + " 60,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", + " (array([[3411.27661054],\n", + " [ 651.76979936]]),\n", + " 81,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", + " (array([[1324.45759309],\n", + " [ 500.60974957]]),\n", + " 50,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", + " (array([[1529.01587824],\n", + " [ 507.852805 ]]),\n", + " 61,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", + " (array([[1902.46134676],\n", + " [ 523.96155564]]),\n", + " 70,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", + " (array([[1380.68577512],\n", + " [ 497.90597943]]),\n", + " 55,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", + " (array([[5993.27002968],\n", + " [ 806.80711019]]),\n", + " 89,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", + " (array([[1709.53523193],\n", + " [ 507.2281716 ]]),\n", + " 68,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", + " (array([[1430.35627535],\n", + " [ 501.94141508]]),\n", + " 58,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", + " (array([[2376.23924035],\n", + " [ 567.74793193]]),\n", + " 78,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", + " (array([[1527.24126845],\n", + " [ 504.72714212]]),\n", + " 63,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", + " (array([[28221.76804952],\n", + " [ 1882.34184596]]),\n", + " 97,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", + " (array([[2085.62618684],\n", + " [ 532.19834793]]),\n", + " 76,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", + " (array([[1613.60161954],\n", + " [ 492.30274906]]),\n", + " 66,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", + " (array([[3303.16290148],\n", + " [ 622.72456572]]),\n", + " 86,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", + " (array([[1708.9877025 ],\n", + " [ 499.00848209]]),\n", + " 69,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", + " (array([[1773.39110962],\n", + " [ 497.70237665]]),\n", + " 71,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", + " (array([[-6656.31008078],\n", + " [ 171.06285964]]),\n", + " 105,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", + " (array([[2667.85532218],\n", + " [ 575.53031356]]),\n", + " 84,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", + " (array([[1950.56739385],\n", + " [ 519.37940777]]),\n", + " 74,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", + " (array([[5689.24999186],\n", + " [ 724.82432229]]),\n", + " 94,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", + " (array([[2109.78367915],\n", + " [ 523.09084581]]),\n", + " 77,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", + " (array([[2220.15405082],\n", + " [ 537.56075433]]),\n", + " 79,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", + " (array([[-2377.02013911],\n", + " [ 323.20360867]]),\n", + " 113,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", + " (array([[2456.22121605],\n", + " [ 553.03022731]]),\n", + " 82,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", + " (array([[4286.86300655],\n", + " [ 631.90912707]]),\n", + " 92,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", + " (array([[-481204.65997376],\n", + " [ -18567.50762167]]),\n", + " 102,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", + " (array([[2768.61655285],\n", + " [ 574.05397001]]),\n", + " 85,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", + " (array([[3020.87365256],\n", + " [ 584.30994567]]),\n", + " 87,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", + " (array([[1125.70209834],\n", + " [ 474.97553548]]),\n", + " 8,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", + " (array([[-1221.63900481],\n", + " [ 377.6812799 ]]),\n", + " 121,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", + " (array([[15696.17848042],\n", + " [ 1042.76455542]]),\n", + " 100,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", + " (array([[3555.64504557],\n", + " [ 587.87420069]]),\n", + " 90,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", + " (array([[-4466.31834931],\n", + " [ 260.3979133 ]]),\n", + " 110,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", + " (array([[4382.81706078],\n", + " [ 636.71375374]]),\n", + " 93,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", + " (array([[5494.63794887],\n", + " [ 693.24593536]]),\n", + " 95,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", + " (array([[1212.28560393],\n", + " [ 479.09836989]]),\n", + " 16,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", + " (array([[-541.80353776],\n", + " [ 407.59297015]]),\n", + " 129,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", + " (array([[8656.27863036],\n", + " [ 783.09615685]]),\n", + " 98,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", + " (array([[-6856.33988085],\n", + " [ 161.41763284]]),\n", + " 108,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", + " (array([[-1870.91419929],\n", + " [ 378.16607543]]),\n", + " 118,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", + " (array([[25870.91006585],\n", + " [ 1337.27294498]]),\n", + " 101,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", + " (array([[-80686.60808567],\n", + " [ -2120.92652789]]),\n", + " 103,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", + " (array([[1322.516277 ],\n", + " [ 475.16665841]]),\n", + " 24,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", + " (array([[-10241.75020993],\n", + " [ 123.21732751]]),\n", + " 106,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", + " (array([[-2107.13166982],\n", + " [ 359.877783 ]]),\n", + " 116,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", + " (array([[-757.54935632],\n", + " [ 399.29420289]]),\n", + " 126,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", + " (array([[-4946.34880702],\n", + " [ 266.14437773]]),\n", + " 109,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", + " (array([[-3600.54301024],\n", + " [ 307.14823965]]),\n", + " 111,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", + " (array([[1455.18073006],\n", + " [ 476.8773895 ]]),\n", + " 32,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", + " (array([[-967.88255457],\n", + " [ 387.31124517]]),\n", + " 124,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", + " (array([[-2321.50797297],\n", + " [ 341.25704003]]),\n", + " 114,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", + " (array([[-258.96888633],\n", + " [ 423.62233616]]),\n", + " 134,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", + " (array([[-1737.61619911],\n", + " [ 378.38473884]]),\n", + " 117,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", + " (array([[-1457.78688921],\n", + " [ 384.00288417]]),\n", + " 119,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", + " (array([[1627.20258736],\n", + " [ 488.78582826]]),\n", + " 40,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", + " (array([[-1091.89160259],\n", + " [ 383.45404604]]),\n", + " 122,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", + " (array([[-311.3515231 ],\n", + " [ 419.19624566]]),\n", + " 132,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", + " (array([[-751.02410044],\n", + " [ 393.95225104]]),\n", + " 125,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", + " (array([[-620.54040802],\n", + " [ 407.71630517]]),\n", + " 127,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", + " (array([[1828.86732377],\n", + " [ 491.24421995]]),\n", + " 48,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", + " (array([[-434.70644789],\n", + " [ 417.63144388]]),\n", + " 130,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", + " (array([[-282.93833065],\n", + " [ 420.86939849]]),\n", + " 133,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", + " (array([[-156.06648914],\n", + " [ 425.46758047]]),\n", + " 135,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", + " (array([[2109.32996025],\n", + " [ 497.14429233]]),\n", + " 56,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", + " (array([[2338.78799712],\n", + " [ 498.70514257]]),\n", + " 64,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", + " (array([[2781.39769207],\n", + " [ 529.65348122]]),\n", + " 72,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", + " (array([[3651.61047676],\n", + " [ 590.5879429 ]]),\n", + " 80,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", + " (array([[6978.58087313],\n", + " [ 740.88600753]]),\n", + " 88,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", + " (array([[72129.75325798],\n", + " [ 3604.66725825]]),\n", + " 96,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", + " (array([[-5665.15013961],\n", + " [ 238.54625946]]),\n", + " 104,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", + " (array([[-2191.11689052],\n", + " [ 346.431 ]]),\n", + " 112,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", + " (array([[-1028.89031745],\n", + " [ 390.18054555]]),\n", + " 120,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", + " (array([[-455.25374332],\n", + " [ 414.97176306]]),\n", + " 128,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg')],\n", + " [(array([[686.77815539],\n", + " [471.26054991]]),\n", + " 3,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", + " (array([[683.17036174],\n", + " [463.07061817]]),\n", + " 11,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", + " (array([[688.57004235],\n", + " [471.033247 ]]),\n", + " 19,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", + " (array([[685.31612136],\n", + " [474.43234574]]),\n", + " 27,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", + " (array([[686.1366875 ],\n", + " [475.17504614]]),\n", + " 35,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", + " (array([[682.3823281 ],\n", + " [472.29562409]]),\n", + " 43,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", + " (array([[685.60176189],\n", + " [475.98172007]]),\n", + " 1,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg'),\n", + " (array([[679.66334909],\n", + " [479.76077672]]),\n", + " 51,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", + " (array([[683.60739045],\n", + " [469.09259118]]),\n", + " 9,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", + " (array([[681.19888098],\n", + " [480.32884123]]),\n", + " 59,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", + " (array([[685.49929459],\n", + " [470.07232845]]),\n", + " 17,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", + " (array([[682.93875504],\n", + " [473.12829739]]),\n", + " 6,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", + " (array([[703.28847803],\n", + " [472.83462247]]),\n", + " 67,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", + " (array([[686.63585742],\n", + " [473.85886666]]),\n", + " 25,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", + " (array([[683.76399592],\n", + " [472.56803082]]),\n", + " 5,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", + " (array([[684.82622547],\n", + " [471.32598173]]),\n", + " 4,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", + " (array([[683.56452228],\n", + " [475.13821745]]),\n", + " 14,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", + " (array([[773.83645905],\n", + " [478.52700512]]),\n", + " 75,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", + " (array([[685.2213989 ],\n", + " [471.58846754]]),\n", + " 33,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", + " (array([[684.017947 ],\n", + " [462.37906501]]),\n", + " 12,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", + " (array([[685.08791786],\n", + " [472.51307795]]),\n", + " 2,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", + " (array([[684.79014881],\n", + " [470.24455769]]),\n", + " 13,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", + " (array([[688.23538999],\n", + " [467.4389604 ]]),\n", + " 22,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", + " (array([[881.61478011],\n", + " [500.05051675]]),\n", + " 83,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", + " (array([[684.23975435],\n", + " [469.51936622]]),\n", + " 7,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", + " (array([[684.2693605 ],\n", + " [470.65546049]]),\n", + " 41,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", + " (array([[683.89841469],\n", + " [463.13949582]]),\n", + " 10,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", + " (array([[688.89423817],\n", + " [467.65951276]]),\n", + " 20,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", + " (array([[688.61382536],\n", + " [466.20188053]]),\n", + " 21,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", + " (array([[1056.34467541],\n", + " [ 503.92914915]]),\n", + " 91,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", + " (array([[683.44923997],\n", + " [468.91756026]]),\n", + " 30,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", + " (array([[683.46030636],\n", + " [474.81711845]]),\n", + " 15,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", + " (array([[681.90421926],\n", + " [472.04571551]]),\n", + " 49,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", + " (array([[687.00902325],\n", + " [467.60152187]]),\n", + " 18,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", + " (array([[684.48884978],\n", + " [469.85677728]]),\n", + " 28,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", + " (array([[683.46344414],\n", + " [469.14045664]]),\n", + " 29,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", + " (array([[1325.27546975],\n", + " [ 518.98271238]]),\n", + " 99,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", + " (array([[685.15335732],\n", + " [473.42098743]]),\n", + " 38,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", + " (array([[688.14966027],\n", + " [466.59565516]]),\n", + " 23,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", + " (array([[680.3947589 ],\n", + " [474.85812184]]),\n", + " 57,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", + " (array([[685.5069017 ],\n", + " [470.63869342]]),\n", + " 26,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", + " (array([[685.48319581],\n", + " [471.98090409]]),\n", + " 36,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", + " (array([[685.33434066],\n", + " [473.4022731 ]]),\n", + " 37,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", + " (array([[1716.42217144],\n", + " [ 537.30729581]]),\n", + " 107,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", + " (array([[681.15179519],\n", + " [462.84628567]]),\n", + " 46,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", + " (array([[684.76622397],\n", + " [466.22783067]]),\n", + " 31,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", + " (array([[691.06193262],\n", + " [469.73672991]]),\n", + " 65,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", + " (array([[680.52565709],\n", + " [465.13159953]]),\n", + " 45,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", + " (array([[685.39233818],\n", + " [469.24638398]]),\n", + " 34,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", + " (array([[681.14226307],\n", + " [466.38773698]]),\n", + " 44,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", + " (array([[2331.8735357],\n", + " [ 573.5244468]]),\n", + " 115,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", + " (array([[679.66680635],\n", + " [470.96466303]]),\n", + " 54,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", + " (array([[684.36411741],\n", + " [470.50586854]]),\n", + " 39,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", + " (array([[683.557201 ],\n", + " [465.32862551]]),\n", + " 42,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", + " (array([[756.20760677],\n", + " [471.60167363]]),\n", + " 73,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", + " (array([[677.84203224],\n", + " [472.1976785 ]]),\n", + " 53,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", + " (array([[678.57618059],\n", + " [471.7678324 ]]),\n", + " 52,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", + " (array([[4182.34017041],\n", + " [ 696.20692505]]),\n", + " 123,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", + " (array([[683.98431605],\n", + " [472.13109532]]),\n", + " 62,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", + " (array([[681.16949598],\n", + " [462.08335263]]),\n", + " 47,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", + " (array([[42987.89049207],\n", + " [ 3209.9668267 ]]),\n", + " 131,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", + " (array([[682.42840526],\n", + " [471.13120662]]),\n", + " 60,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", + " (array([[844.76682629],\n", + " [475.83979496]]),\n", + " 81,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", + " (array([[682.00726987],\n", + " [469.80775329]]),\n", + " 50,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", + " (array([[683.1169029 ],\n", + " [471.28166882]]),\n", + " 61,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", + " (array([[721.87916686],\n", + " [461.4648927 ]]),\n", + " 70,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", + " (array([[679.15015754],\n", + " [467.40402867]]),\n", + " 55,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", + " (array([[-3691.99153875],\n", + " [ 202.55936422]]),\n", + " 139,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939412460.jpg'),\n", + " (array([[1010.04280689],\n", + " [ 488.68183645]]),\n", + " 89,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", + " (array([[709.64420979],\n", + " [459.46000608]]),\n", + " 68,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", + " (array([[681.10633065],\n", + " [468.84000919]]),\n", + " 58,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", + " (array([[804.14206032],\n", + " [458.14748476]]),\n", + " 78,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", + " (array([[686.80563145],\n", + " [465.94599498]]),\n", + " 63,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", + " (array([[-1303.88178446],\n", + " [ 343.69826367]]),\n", + " 147,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940112460.jpg'),\n", + " (array([[1227.52886158],\n", + " [ 496.85849562]]),\n", + " 97,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", + " (array([[787.68121322],\n", + " [457.23049275]]),\n", + " 76,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", + " (array([[701.15594345],\n", + " [458.38728051]]),\n", + " 66,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", + " (array([[941.11976007],\n", + " [485.1110166 ]]),\n", + " 86,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", + " (array([[717.32714853],\n", + " [454.47622273]]),\n", + " 69,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", + " (array([[731.37728725],\n", + " [456.22770882]]),\n", + " 71,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", + " (array([[-656.34972575],\n", + " [ 399.9677691 ]]),\n", + " 155,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940762460.jpg'),\n", + " (array([[1569.13232878],\n", + " [ 501.1225268 ]]),\n", + " 105,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", + " (array([[893.43781142],\n", + " [480.37100818]]),\n", + " 84,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", + " (array([[769.4125909 ],\n", + " [461.72540344]]),\n", + " 74,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", + " (array([[1138.59888097],\n", + " [ 487.34109955]]),\n", + " 94,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", + " (array([[799.35901657],\n", + " [448.98940018]]),\n", + " 77,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", + " (array([[818.22175364],\n", + " [456.05008157]]),\n", + " 79,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", + " (array([[-319.61452039],\n", + " [ 432.02014729]]),\n", + " 163,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941412460.jpg'),\n", + " (array([[2149.0351738 ],\n", + " [ 527.11890251]]),\n", + " 113,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", + " (array([[862.70428209],\n", + " [473.65504115]]),\n", + " 82,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", + " (array([[1089.6586519 ],\n", + " [ 479.01664413]]),\n", + " 92,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", + " (array([[1441.00380465],\n", + " [ 491.18380522]]),\n", + " 102,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", + " (array([[916.79982323],\n", + " [475.28504831]]),\n", + " 85,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", + " (array([[955.69454664],\n", + " [479.82334605]]),\n", + " 87,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", + " (array([[684.31451879],\n", + " [459.40863082]]),\n", + " 8,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", + " (array([[-116.12589652],\n", + " [ 447.15902898]]),\n", + " 171,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942112460.jpg'),\n", + " (array([[3351.39573425],\n", + " [ 581.16415696]]),\n", + " 121,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", + " (array([[1370.23864748],\n", + " [ 492.86274415]]),\n", + " 100,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", + " (array([[1025.00018522],\n", + " [ 478.65078761]]),\n", + " 90,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", + " (array([[1903.21294578],\n", + " [ 511.16497341]]),\n", + " 110,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", + " (array([[1105.59296697],\n", + " [ 483.21783526]]),\n", + " 93,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", + " (array([[1172.40538056],\n", + " [ 492.54809648]]),\n", + " 95,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", + " (array([[684.99152167],\n", + " [461.97545487]]),\n", + " 16,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", + " (array([[ -2.92476758],\n", + " [438.44624004]]),\n", + " 179,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942862460.jpg'),\n", + " (array([[12941.91658704],\n", + " [ 1020.92200273]]),\n", + " 129,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", + " (array([[1284.5960526 ],\n", + " [ 494.37220758]]),\n", + " 98,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", + " (array([[1786.09899898],\n", + " [ 516.6453788 ]]),\n", + " 108,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", + " (array([[2729.20785929],\n", + " [ 557.73990454]]),\n", + " 118,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", + " (array([[1393.46411083],\n", + " [ 501.73161866]]),\n", + " 101,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", + " (array([[1489.32532897],\n", + " [ 503.31667068]]),\n", + " 103,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", + " (array([[688.22874133],\n", + " [463.09677637]]),\n", + " 24,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", + " (array([[ 63.46853166],\n", + " [433.13005421]]),\n", + " 187,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943512460.jpg'),\n", + " (array([[-5201.35563953],\n", + " [ 135.3359585 ]]),\n", + " 137,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939262460.jpg'),\n", + " (array([[1658.38905451],\n", + " [ 511.68490134]]),\n", + " 106,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", + " (array([[2474.67905163],\n", + " [ 557.50965587]]),\n", + " 116,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", + " (array([[6187.08828666],\n", + " [ 759.24317438]]),\n", + " 126,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", + " (array([[1823.05816971],\n", + " [ 523.34252981]]),\n", + " 109,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", + " (array([[1990.98637458],\n", + " [ 530.11649661]]),\n", + " 111,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", + " (array([[684.8956205 ],\n", + " [461.77401006]]),\n", + " 32,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", + " (array([[119.86104099],\n", + " [430.6276968 ]]),\n", + " 195,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944162460.jpg'),\n", + " (array([[-1669.22977907],\n", + " [ 324.96282818]]),\n", + " 145,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939912460.jpg'),\n", + " (array([[4470.38960373],\n", + " [ 675.88138707]]),\n", + " 124,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", + " (array([[2268.22461233],\n", + " [ 550.4957901 ]]),\n", + " 114,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", + " (array([[-13102.85824844],\n", + " [ -305.41493762]]),\n", + " 134,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", + " (array([[2636.86763091],\n", + " [ 561.92946547]]),\n", + " 117,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", + " (array([[189.74538582],\n", + " [434.445323 ]]),\n", + " 203,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944862460.jpg'),\n", + " (array([[2947.89371538],\n", + " [ 578.0779607 ]]),\n", + " 119,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", + " (array([[684.67951095],\n", + " [463.53410636]]),\n", + " 40,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", + " (array([[-761.66627794],\n", + " [ 386.61869497]]),\n", + " 153,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940612460.jpg'),\n", + " (array([[3716.48610528],\n", + " [ 639.07684418]]),\n", + " 122,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", + " (array([[-61721.99268843],\n", + " [ -3080.36243488]]),\n", + " 132,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", + " (array([[-2382.18628413],\n", + " [ 294.71844363]]),\n", + " 142,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939662460.jpg'),\n", + " (array([[5175.56257669],\n", + " [ 707.54556204]]),\n", + " 125,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", + " (array([[321.39333085],\n", + " [444.81448951]]),\n", + " 211,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945612460.jpg'),\n", + " (array([[6878.16793621],\n", + " [ 790.91583985]]),\n", + " 127,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", + " (array([[681.50760037],\n", + " [461.06962015]]),\n", + " 48,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", + " (array([[-384.65169648],\n", + " [ 412.83632177]]),\n", + " 161,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941262460.jpg'),\n", + " (array([[-3050.75275629],\n", + " [ 255.70186003]]),\n", + " 140,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939512460.jpg'),\n", + " (array([[16776.52473354],\n", + " [ 1317.61779952]]),\n", + " 130,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", + " (array([[-989.3711678 ],\n", + " [ 366.65100545]]),\n", + " 150,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940362460.jpg'),\n", + " (array([[-27897.77755375],\n", + " [ -1154.00134739]]),\n", + " 133,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", + " (array([[449.43932772],\n", + " [454.28627319]]),\n", + " 219,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946262460.jpg'),\n", + " (array([[-8275.50863058],\n", + " [ -26.71590725]]),\n", + " 135,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", + " (array([[-159.6806175 ],\n", + " [ 429.35987422]]),\n", + " 169,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941912460.jpg'),\n", + " (array([[680.02696811],\n", + " [466.8522811 ]]),\n", + " 56,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", + " (array([[-1232.76192871],\n", + " [ 346.8863571 ]]),\n", + " 148,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940162460.jpg'),\n", + " (array([[-4096.40335109],\n", + " [ 193.25030334]]),\n", + " 138,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939362460.jpg'),\n", + " (array([[-503.42371732],\n", + " [ 399.43231115]]),\n", + " 158,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941012460.jpg'),\n", + " (array([[-2580.63665454],\n", + " [ 289.75004286]]),\n", + " 141,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939612460.jpg'),\n", + " (array([[-2051.45443133],\n", + " [ 318.17850644]]),\n", + " 143,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939762460.jpg'),\n", + " (array([[-28.55682445],\n", + " [440.27553524]]),\n", + " 177,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942662460.jpg'),\n", + " (array([[690.0434449 ],\n", + " [463.28597576]]),\n", + " 64,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", + " (array([[-592.64054232],\n", + " [ 395.19877194]]),\n", + " 156,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940862460.jpg'),\n", + " (array([[-1469.62829127],\n", + " [ 334.21951387]]),\n", + " 146,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940012460.jpg'),\n", + " (array([[-231.99455095],\n", + " [ 424.40667869]]),\n", + " 166,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941662460.jpg'),\n", + " (array([[-1102.55842 ],\n", + " [ 366.66996016]]),\n", + " 149,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940262460.jpg'),\n", + " (array([[-937.19517387],\n", + " [ 378.72499547]]),\n", + " 151,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940412460.jpg'),\n", + " (array([[ 47.34819586],\n", + " [434.95270191]]),\n", + " 185,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943362460.jpg'),\n", + " (array([[-725.92922467],\n", + " [ 394.55851052]]),\n", + " 154,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940662460.jpg'),\n", + " (array([[-282.84239271],\n", + " [ 425.2515132 ]]),\n", + " 164,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941512460.jpg'),\n", + " (array([[740.95399894],\n", + " [460.91449355]]),\n", + " 72,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", + " (array([[-71.50717794],\n", + " [440.75047124]]),\n", + " 174,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942362460.jpg'),\n", + " (array([[-561.46615363],\n", + " [ 403.2083092 ]]),\n", + " 157,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940912460.jpg'),\n", + " (array([[109.41345592],\n", + " [436.92667097]]),\n", + " 193,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944012460.jpg'),\n", + " (array([[-452.41867864],\n", + " [ 412.53402613]]),\n", + " 159,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941112460.jpg'),\n", + " (array([[-341.24879939],\n", + " [ 423.80555162]]),\n", + " 162,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941362460.jpg'),\n", + " (array([[-106.32625702],\n", + " [ 437.37166543]]),\n", + " 172,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942162460.jpg'),\n", + " (array([[ 23.27132126],\n", + " [442.39291349]]),\n", + " 182,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943112460.jpg'),\n", + " (array([[835.68200871],\n", + " [462.80472608]]),\n", + " 80,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", + " (array([[-248.9797618 ],\n", + " [ 430.81914014]]),\n", + " 165,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941612460.jpg'),\n", + " (array([[166.33767186],\n", + " [439.33247158]]),\n", + " 201,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944662460.jpg'),\n", + " (array([[-201.97429034],\n", + " [ 434.4083783 ]]),\n", + " 167,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941762460.jpg'),\n", + " (array([[ 1.88312334],\n", + " [440.48790739]]),\n", + " 180,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942912460.jpg'),\n", + " (array([[-136.7464831],\n", + " [ 441.6222201]]),\n", + " 170,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942012460.jpg'),\n", + " (array([[ 83.47839011],\n", + " [439.67069509]]),\n", + " 190,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943762460.jpg'),\n", + " (array([[983.60177459],\n", + " [481.90926431]]),\n", + " 88,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", + " (array([[-88.55728603],\n", + " [442.86446755]]),\n", + " 173,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942262460.jpg'),\n", + " (array([[283.18244703],\n", + " [451.4045993 ]]),\n", + " 209,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945412460.jpg'),\n", + " (array([[-48.41842823],\n", + " [454.15545389]]),\n", + " 175,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942512460.jpg'),\n", + " (array([[-15.50248503],\n", + " [445.71771114]]),\n", + " 178,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942762460.jpg'),\n", + " (array([[141.93320323],\n", + " [439.63764733]]),\n", + " 198,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944412460.jpg'),\n", + " (array([[ 74.52118256],\n", + " [439.1457565 ]]),\n", + " 188,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943612460.jpg'),\n", + " (array([[1190.92630348],\n", + " [ 489.04004761]]),\n", + " 96,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", + " (array([[ 11.97191802],\n", + " [444.41950582]]),\n", + " 181,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943012460.jpg'),\n", + " (array([[418.64783679],\n", + " [460.84100923]]),\n", + " 217,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946112460.jpg'),\n", + " (array([[ 28.90251777],\n", + " [446.52797358]]),\n", + " 183,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943162460.jpg'),\n", + " (array([[235.64714993],\n", + " [444.18932109]]),\n", + " 206,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945162460.jpg'),\n", + " (array([[ 51.71842419],\n", + " [441.4386851 ]]),\n", + " 186,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943412460.jpg'),\n", + " (array([[129.09870561],\n", + " [439.42827085]]),\n", + " 196,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944262460.jpg'),\n", + " (array([[1515.17634227],\n", + " [ 494.94526422]]),\n", + " 104,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", + " (array([[ 77.93270851],\n", + " [439.75545149]]),\n", + " 189,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943662460.jpg'),\n", + " (array([[ 93.45069573],\n", + " [443.08722686]]),\n", + " 191,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943862460.jpg'),\n", + " (array([[370.76923126],\n", + " [456.36836043]]),\n", + " 214,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945862460.jpg'),\n", + " (array([[195.52912659],\n", + " [443.89036799]]),\n", + " 204,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944912460.jpg'),\n", + " (array([[115.83208666],\n", + " [441.6684963 ]]),\n", + " 194,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944112460.jpg'),\n", + " (array([[2040.13792273],\n", + " [ 514.25304221]]),\n", + " 112,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", + " (array([[138.17662549],\n", + " [440.2931406 ]]),\n", + " 197,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944362460.jpg'),\n", + " (array([[149.47211286],\n", + " [441.43237189]]),\n", + " 199,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944512460.jpg'),\n", + " (array([[514.83420157],\n", + " [471.28210279]]),\n", + " 222,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946612460.jpg'),\n", + " (array([[330.54413198],\n", + " [454.09212648]]),\n", + " 212,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945662460.jpg'),\n", + " (array([[177.56448812],\n", + " [443.81816251]]),\n", + " 202,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944762460.jpg'),\n", + " (array([[3208.50306227],\n", + " [ 563.40787867]]),\n", + " 120,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", + " (array([[227.12025733],\n", + " [444.3877628 ]]),\n", + " 205,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945112460.jpg'),\n", + " (array([[253.3583807 ],\n", + " [448.45969716]]),\n", + " 207,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945262460.jpg'),\n", + " (array([[479.81723166],\n", + " [464.10161256]]),\n", + " 220,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946412460.jpg'),\n", + " (array([[302.35386166],\n", + " [453.71965637]]),\n", + " 210,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945512460.jpg'),\n", + " (array([[8929.49752438],\n", + " [ 811.17189947]]),\n", + " 128,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg'),\n", + " (array([[350.85764559],\n", + " [453.31490687]]),\n", + " 213,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945762460.jpg'),\n", + " (array([[380.2952451 ],\n", + " [455.91026462]]),\n", + " 215,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945912460.jpg'),\n", + " (array([[428.72335206],\n", + " [460.13603638]]),\n", + " 218,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946162460.jpg'),\n", + " (array([[-6954.22196453],\n", + " [ 120.96375787]]),\n", + " 136,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939162460.jpg'),\n", + " (array([[496.53275551],\n", + " [465.50874948]]),\n", + " 221,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946512460.jpg'),\n", + " (array([[524.62976791],\n", + " [468.92931317]]),\n", + " 223,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946662460.jpg'),\n", + " (array([[-1785.35845446],\n", + " [ 338.80750052]]),\n", + " 144,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939862460.jpg'),\n", + " (array([[-845.61298794],\n", + " [ 391.91413411]]),\n", + " 152,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940512460.jpg'),\n", + " (array([[-429.35327155],\n", + " [ 417.61162109]]),\n", + " 160,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941162460.jpg'),\n", + " (array([[-173.38286731],\n", + " [ 436.06204799]]),\n", + " 168,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941862460.jpg'),\n", + " (array([[-34.94361421],\n", + " [447.78495674]]),\n", + " 176,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942612460.jpg'),\n", + " (array([[ 39.42105528],\n", + " [439.58833881]]),\n", + " 184,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943262460.jpg'),\n", + " (array([[ 99.83351234],\n", + " [435.06876846]]),\n", + " 192,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943912478.jpg'),\n", + " (array([[160.28211927],\n", + " [435.4431181 ]]),\n", + " 200,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944612460.jpg'),\n", + " (array([[273.25597841],\n", + " [444.71457787]]),\n", + " 208,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945362460.jpg'),\n", + " (array([[399.02245189],\n", + " [453.96855177]]),\n", + " 216,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946012460.jpg'),\n", + " (array([[543.92997073],\n", + " [468.80791959]]),\n", + " 224,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946762460.jpg')],\n", + " [(array([[1417.97126769],\n", + " [ 499.30163695]]),\n", + " 3,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", + " (array([[1487.76350705],\n", + " [ 492.34976692]]),\n", + " 11,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", + " (array([[1589.84123074],\n", + " [ 503.22441335]]),\n", + " 19,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", + " (array([[1692.1286689 ],\n", + " [ 509.20483617]]),\n", + " 27,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", + " (array([[1819.38818887],\n", + " [ 518.30516289]]),\n", + " 35,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", + " (array([[1985.14056588],\n", + " [ 530.75426447]]),\n", + " 43,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", + " (array([[1400.95015449],\n", + " [ 502.72450709]]),\n", + " 1,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg'),\n", + " (array([[2184.299195 ],\n", + " [ 539.95846459]]),\n", + " 51,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", + " (array([[1469.6217433],\n", + " [ 496.6090724]]),\n", + " 9,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", + " (array([[2460.88007624],\n", + " [ 542.6964679 ]]),\n", + " 59,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", + " (array([[1556.42640245],\n", + " [ 503.67894655]]),\n", + " 17,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", + " (array([[1440.09228652],\n", + " [ 503.73885815]]),\n", + " 6,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", + " (array([[2991.36170366],\n", + " [ 560.94679561]]),\n", + " 67,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", + " (array([[1666.55046397],\n", + " [ 507.60884507]]),\n", + " 25,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", + " (array([[1429.87374418],\n", + " [ 500.75503954]]),\n", + " 5,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", + " (array([[1425.70759224],\n", + " [ 499.65146421]]),\n", + " 4,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", + " (array([[1519.40904331],\n", + " [ 505.60392967]]),\n", + " 14,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", + " (array([[4188.00445364],\n", + " [ 667.29095692]]),\n", + " 75,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", + " (array([[1785.20836739],\n", + " [ 509.88790487]]),\n", + " 33,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", + " (array([[1500.768753 ],\n", + " [ 490.69837144]]),\n", + " 12,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", + " (array([[1404.80292987],\n", + " [ 496.02440093]]),\n", + " 2,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", + " (array([[1514.00616628],\n", + " [ 499.18871651]]),\n", + " 13,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", + " (array([[1626.69676505],\n", + " [ 498.57122939]]),\n", + " 22,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", + " (array([[8085.16834409],\n", + " [ 916.64677893]]),\n", + " 83,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", + " (array([[1452.34220468],\n", + " [ 497.82867354]]),\n", + " 7,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", + " (array([[1932.32577774],\n", + " [ 518.6292798 ]]),\n", + " 41,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", + " (array([[1481.61612288],\n", + " [ 488.4691232 ]]),\n", + " 10,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", + " (array([[1596.6372822],\n", + " [ 496.2764948]]),\n", + " 20,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", + " (array([[1611.53426085],\n", + " [ 496.41286406]]),\n", + " 21,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", + " (array([[-33193.78874787],\n", + " [ -1434.41309621]]),\n", + " 91,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", + " (array([[1733.24871917],\n", + " [ 501.27897312]]),\n", + " 30,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", + " (array([[1532.35114418],\n", + " [ 504.65426049]]),\n", + " 15,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", + " (array([[2135.21904755],\n", + " [ 525.20259418]]),\n", + " 49,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", + " (array([[1571.98217686],\n", + " [ 496.78662085]]),\n", + " 18,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", + " (array([[1707.42751408],\n", + " [ 500.50589032]]),\n", + " 28,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", + " (array([[1714.8696656 ],\n", + " [ 500.39771574]]),\n", + " 29,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", + " (array([[-3625.50282932],\n", + " [ 253.33993163]]),\n", + " 99,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", + " (array([[1872.56832954],\n", + " [ 517.84762295]]),\n", + " 38,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", + " (array([[1634.56840582],\n", + " [ 498.0119811 ]]),\n", + " 23,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", + " (array([[2385.59422599],\n", + " [ 530.68480944]]),\n", + " 57,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", + " (array([[1672.79333757],\n", + " [ 502.63003174]]),\n", + " 26,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", + " (array([[1838.19856499],\n", + " [ 511.75134806]]),\n", + " 36,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", + " (array([[1861.00238955],\n", + " [ 515.97727488]]),\n", + " 37,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", + " (array([[-1487.73997244],\n", + " [ 357.38994922]]),\n", + " 107,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", + " (array([[2052.73892052],\n", + " [ 521.0527247 ]]),\n", + " 46,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", + " (array([[1754.05651046],\n", + " [ 501.74884457]]),\n", + " 31,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", + " (array([[2762.59824683],\n", + " [ 538.02523097]]),\n", + " 65,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", + " (array([[2021.9915769 ],\n", + " [ 520.18721647]]),\n", + " 45,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", + " (array([[1805.5786928 ],\n", + " [ 507.55064578]]),\n", + " 34,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", + " (array([[1994.30178297],\n", + " [ 520.67629546]]),\n", + " 44,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", + " (array([[-701.35636324],\n", + " [ 384.47623667]]),\n", + " 115,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", + " (array([[2276.31915223],\n", + " [ 526.67073186]]),\n", + " 54,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", + " (array([[1895.33595785],\n", + " [ 518.02934822]]),\n", + " 39,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", + " (array([[1957.1831414 ],\n", + " [ 516.74672596]]),\n", + " 42,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", + " (array([[3842.45264086],\n", + " [ 625.36658219]]),\n", + " 73,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", + " (array([[2232.92722153],\n", + " [ 529.82876945]]),\n", + " 53,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", + " (array([[2215.48013238],\n", + " [ 531.78223092]]),\n", + " 52,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", + " (array([[-187.4664813 ],\n", + " [ 404.78483889]]),\n", + " 123,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", + " (array([[2593.29406556],\n", + " [ 533.57538258]]),\n", + " 62,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", + " (array([[2068.07453204],\n", + " [ 522.53829602]]),\n", + " 47,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", + " (array([[126.35898343],\n", + " [425.50796204]]),\n", + " 131,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", + " (array([[2510.22270839],\n", + " [ 532.88227595]]),\n", + " 60,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", + " (array([[6239.90037867],\n", + " [ 774.16710008]]),\n", + " 81,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", + " (array([[2152.68707713],\n", + " [ 524.9331039 ]]),\n", + " 50,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", + " (array([[2564.59924344],\n", + " [ 530.95244975]]),\n", + " 61,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", + " (array([[3277.55625298],\n", + " [ 566.1622557 ]]),\n", + " 70,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", + " (array([[2319.11749745],\n", + " [ 520.78213349]]),\n", + " 55,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", + " (array([[349.5282481 ],\n", + " [439.42997118]]),\n", + " 139,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939412460.jpg'),\n", + " (array([[104241.09609688],\n", + " [ 5855.53623297]]),\n", + " 89,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", + " (array([[3095.57073894],\n", + " [ 546.38978953]]),\n", + " 68,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", + " (array([[2435.13989857],\n", + " [ 526.83610966]]),\n", + " 58,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", + " (array([[4934.61309797],\n", + " [ 698.90839676]]),\n", + " 78,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", + " (array([[2663.20618578],\n", + " [ 529.094213 ]]),\n", + " 63,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", + " (array([[521.97852467],\n", + " [450.60255366]]),\n", + " 147,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940112460.jpg'),\n", + " (array([[-5388.34839126],\n", + " [ 183.58852477]]),\n", + " 97,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", + " (array([[4477.72278128],\n", + " [ 653.97803592]]),\n", + " 76,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", + " (array([[2944.87547244],\n", + " [ 531.63666696]]),\n", + " 66,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", + " (array([[14478.79672962],\n", + " [ 1174.37898092]]),\n", + " 86,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", + " (array([[3219.33897782],\n", + " [ 548.40174579]]),\n", + " 69,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", + " (array([[3427.57524033],\n", + " [ 565.37881916]]),\n", + " 71,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", + " (array([[624.63917852],\n", + " [460.88285391]]),\n", + " 155,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940762460.jpg'),\n", + " (array([[-1922.45940909],\n", + " [ 357.39715306]]),\n", + " 105,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", + " (array([[8919.13428115],\n", + " [ 916.08805826]]),\n", + " 84,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", + " (array([[4087.63846036],\n", + " [ 625.95180976]]),\n", + " 74,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", + " (array([[-9542.67990878],\n", + " [ -14.19319733]]),\n", + " 94,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", + " (array([[4799.64292056],\n", + " [ 652.274421 ]]),\n", + " 77,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", + " (array([[5376.91681242],\n", + " [ 694.86136142]]),\n", + " 79,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", + " (array([[701.83158142],\n", + " [471.46159348]]),\n", + " 163,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941412460.jpg'),\n", + " (array([[-838.25334609],\n", + " [ 396.31041784]]),\n", + " 113,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", + " (array([[7102.83915085],\n", + " [ 771.05886582]]),\n", + " 82,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", + " (array([[-16290.32766927],\n", + " [ -279.97757323]]),\n", + " 92,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", + " (array([[-2555.37820451],\n", + " [ 347.89264261]]),\n", + " 102,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", + " (array([[11069.72320314],\n", + " [ 973.01954359]]),\n", + " 85,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", + " (array([[17820.14655346],\n", + " [ 1260.76725046]]),\n", + " 87,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", + " (array([[1459.03085067],\n", + " [ 486.13848726]]),\n", + " 8,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", + " (array([[753.56336536],\n", + " [474.67323336]]),\n", + " 171,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942112460.jpg'),\n", + " (array([[-307.65288353],\n", + " [ 421.42649383]]),\n", + " 121,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", + " (array([[-3095.8750198 ],\n", + " [ 327.21240545]]),\n", + " 100,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", + " (array([[-180905.57967282],\n", + " [ -7148.0192111 ]]),\n", + " 90,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", + " (array([[-1119.87308093],\n", + " [ 395.88722766]]),\n", + " 110,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", + " (array([[-13151.66712218],\n", + " [ -166.47310579]]),\n", + " 93,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", + " (array([[-7266.98879186],\n", + " [ 110.81946107]]),\n", + " 95,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", + " (array([[1549.60946534],\n", + " [ 489.4790636 ]]),\n", + " 16,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", + " (array([[770.44171517],\n", + " [468.65123249]]),\n", + " 179,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942862460.jpg'),\n", + " (array([[ 72.0710298 ],\n", + " [439.06159289]]),\n", + " 129,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", + " (array([[-4125.53218409],\n", + " [ 289.18509792]]),\n", + " 98,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", + " (array([[-1312.62306142],\n", + " [ 389.19030656]]),\n", + " 108,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", + " (array([[-482.44972954],\n", + " [ 420.0154431 ]]),\n", + " 118,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", + " (array([[-2879.23891756],\n", + " [ 326.08954048]]),\n", + " 101,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", + " (array([[-2254.76766915],\n", + " [ 358.74822803]]),\n", + " 103,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", + " (array([[1653.32684934],\n", + " [ 489.25295769]]),\n", + " 24,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", + " (array([[774.24296182],\n", + " [459.94987638]]),\n", + " 187,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943512460.jpg'),\n", + " (array([[310.20198232],\n", + " [449.06689535]]),\n", + " 137,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939262460.jpg'),\n", + " (array([[-1607.30016313],\n", + " [ 391.51872953]]),\n", + " 106,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", + " (array([[-598.90917861],\n", + " [ 419.1146318 ]]),\n", + " 116,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", + " (array([[-43.42953333],\n", + " [432.05269637]]),\n", + " 126,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", + " (array([[-1240.78429418],\n", + " [ 399.32497482]]),\n", + " 109,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", + " (array([[-994.17282203],\n", + " [ 404.2832061 ]]),\n", + " 111,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", + " (array([[1769.06151033],\n", + " [ 487.54639298]]),\n", + " 32,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", + " (array([[779.25771042],\n", + " [460.56902526]]),\n", + " 195,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944162460.jpg'),\n", + " (array([[487.15639684],\n", + " [459.78117805]]),\n", + " 145,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939912460.jpg'),\n", + " (array([[-143.76890114],\n", + " [ 425.11881869]]),\n", + " 124,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", + " (array([[-722.90287103],\n", + " [ 407.67783907]]),\n", + " 114,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", + " (array([[231.04168992],\n", + " [447.46700658]]),\n", + " 134,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", + " (array([[-507.14035931],\n", + " [ 422.41711071]]),\n", + " 117,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", + " (array([[800.29299228],\n", + " [460.28762591]]),\n", + " 203,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944862460.jpg'),\n", + " (array([[-393.27570236],\n", + " [ 423.77941714]]),\n", + " 119,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", + " (array([[1929.41424572],\n", + " [ 502.40033019]]),\n", + " 40,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", + " (array([[612.90361782],\n", + " [467.22978559]]),\n", + " 153,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940612460.jpg'),\n", + " (array([[-223.65410098],\n", + " [ 421.6007525 ]]),\n", + " 122,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", + " (array([[183.94942701],\n", + " [441.91524561]]),\n", + " 132,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", + " (array([[431.71663166],\n", + " [451.57762576]]),\n", + " 142,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939662460.jpg'),\n", + " (array([[-81.78924947],\n", + " [423.22956363]]),\n", + " 125,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", + " (array([[879.53411612],\n", + " [467.83221832]]),\n", + " 211,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945612460.jpg'),\n", + " (array([[ -6.92734666],\n", + " [433.01788357]]),\n", + " 127,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", + " (array([[2117.27680819],\n", + " [ 514.06173118]]),\n", + " 48,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", + " (array([[695.00252352],\n", + " [466.61226051]]),\n", + " 161,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941262460.jpg'),\n", + " (array([[393.40047754],\n", + " [446.24000957]]),\n", + " 140,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939512460.jpg'),\n", + " (array([[107.32803896],\n", + " [433.43793591]]),\n", + " 130,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", + " (array([[578.51377821],\n", + " [457.90726507]]),\n", + " 150,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940362460.jpg'),\n", + " (array([[204.22130042],\n", + " [436.76678437]]),\n", + " 133,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", + " (array([[973.55670961],\n", + " [473.29840815]]),\n", + " 219,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946262460.jpg'),\n", + " (array([[274.5431714 ],\n", + " [434.96048425]]),\n", + " 135,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", + " (array([[755.15745819],\n", + " [466.89017058]]),\n", + " 169,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941912460.jpg'),\n", + " (array([[2365.15498555],\n", + " [ 526.64167313]]),\n", + " 56,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", + " (array([[545.07503489],\n", + " [448.93399304]]),\n", + " 148,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940162460.jpg'),\n", + " (array([[352.24009639],\n", + " [436.60242415]]),\n", + " 138,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939362460.jpg'),\n", + " (array([[669.34305192],\n", + " [457.90493901]]),\n", + " 158,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941012460.jpg'),\n", + " (array([[418.82164522],\n", + " [439.02310739]]),\n", + " 141,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939612460.jpg'),\n", + " (array([[457.63219527],\n", + " [441.00714515]]),\n", + " 143,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939762460.jpg'),\n", + " (array([[774.6077423 ],\n", + " [464.68140732]]),\n", + " 177,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942662460.jpg'),\n", + " (array([[2759.38804931],\n", + " [ 539.83639314]]),\n", + " 64,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", + " (array([[647.88718121],\n", + " [456.70370571]]),\n", + " 156,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940862460.jpg'),\n", + " (array([[514.28517042],\n", + " [446.09292886]]),\n", + " 146,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940012460.jpg'),\n", + " (array([[733.90756117],\n", + " [463.34755646]]),\n", + " 166,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941662460.jpg'),\n", + " (array([[560.27475434],\n", + " [452.94103571]]),\n", + " 149,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940262460.jpg'),\n", + " (array([[585.68050137],\n", + " [454.83265752]]),\n", + " 151,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940412460.jpg'),\n", + " (array([[778.6633486 ],\n", + " [456.77162015]]),\n", + " 185,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943362460.jpg'),\n", + " (array([[621.92804332],\n", + " [457.62413839]]),\n", + " 154,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940662460.jpg'),\n", + " (array([[720.8273402 ],\n", + " [464.97504899]]),\n", + " 164,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941512460.jpg'),\n", + " (array([[3635.74364713],\n", + " [ 594.1938898 ]]),\n", + " 72,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", + " (array([[769.17892964],\n", + " [471.62279391]]),\n", + " 174,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942362460.jpg'),\n", + " (array([[653.89665024],\n", + " [461.85225577]]),\n", + " 157,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940912460.jpg'),\n", + " (array([[783.87866254],\n", + " [457.73895956]]),\n", + " 193,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944012460.jpg'),\n", + " (array([[678.32366067],\n", + " [463.34779067]]),\n", + " 159,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941112460.jpg'),\n", + " (array([[705.2348861 ],\n", + " [466.44484019]]),\n", + " 162,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941362460.jpg'),\n", + " (array([[763.75226817],\n", + " [469.87528786]]),\n", + " 172,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942162460.jpg'),\n", + " (array([[777.6281194 ],\n", + " [465.35104495]]),\n", + " 182,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943112460.jpg'),\n", + " (array([[6113.30310724],\n", + " [ 732.24873125]]),\n", + " 80,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", + " (array([[728.7945204 ],\n", + " [471.05863778]]),\n", + " 165,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941612460.jpg'),\n", + " (array([[793.28657366],\n", + " [457.42247438]]),\n", + " 201,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944662460.jpg'),\n", + " (array([[741.29528838],\n", + " [471.8165507 ]]),\n", + " 167,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941762460.jpg'),\n", + " (array([[777.43489874],\n", + " [472.21111888]]),\n", + " 180,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942912460.jpg'),\n", + " (array([[757.67862041],\n", + " [479.7480464 ]]),\n", + " 170,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942012460.jpg'),\n", + " (array([[779.60443927],\n", + " [463.84388339]]),\n", + " 190,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943762460.jpg'),\n", + " (array([[38996.39425627],\n", + " [ 1990.23897612]]),\n", + " 88,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", + " (array([[766.55968294],\n", + " [480.26874504]]),\n", + " 173,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942262460.jpg'),\n", + " (array([[855.46635175],\n", + " [469.30360182]]),\n", + " 209,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945412460.jpg'),\n", + " (array([[773.36051999],\n", + " [481.63003504]]),\n", + " 175,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942512460.jpg'),\n", + " (array([[776.80498568],\n", + " [474.38745011]]),\n", + " 178,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942762460.jpg'),\n", + " (array([[787.77808653],\n", + " [461.12023866]]),\n", + " 198,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944412460.jpg'),\n", + " (array([[783.15937921],\n", + " [460.41168404]]),\n", + " 188,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943612460.jpg'),\n", + " (array([[-6136.77820326],\n", + " [ 194.40065211]]),\n", + " 96,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", + " (array([[778.42210664],\n", + " [471.95868356]]),\n", + " 181,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943012460.jpg'),\n", + " (array([[950.00345473],\n", + " [479.42750663]]),\n", + " 217,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946112460.jpg'),\n", + " (array([[779.95779592],\n", + " [470.85523894]]),\n", + " 183,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943162460.jpg'),\n", + " (array([[827.60023699],\n", + " [462.5258277 ]]),\n", + " 206,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945162460.jpg'),\n", + " (array([[780.05082898],\n", + " [466.8590876 ]]),\n", + " 186,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943412460.jpg'),\n", + " (array([[786.39628467],\n", + " [460.31256767]]),\n", + " 196,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944262460.jpg'),\n", + " (array([[-2055.23390468],\n", + " [ 380.11597298]]),\n", + " 104,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", + " (array([[783.76915973],\n", + " [460.0265154 ]]),\n", + " 189,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943662460.jpg'),\n", + " (array([[782.76100979],\n", + " [465.93929141]]),\n", + " 191,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943862460.jpg'),\n", + " (array([[915.58376261],\n", + " [473.38409652]]),\n", + " 214,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945862460.jpg'),\n", + " (array([[806.83928606],\n", + " [462.16433745]]),\n", + " 204,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944912460.jpg'),\n", + " (array([[785.02376981],\n", + " [463.53789217]]),\n", + " 194,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944112460.jpg'),\n", + " (array([[-903.45809755],\n", + " [ 407.18724952]]),\n", + " 112,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", + " (array([[789.35135743],\n", + " [460.01106715]]),\n", + " 197,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944362460.jpg'),\n", + " (array([[790.26709415],\n", + " [462.46081439]]),\n", + " 199,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944512460.jpg'),\n", + " (array([[1028.42711196],\n", + " [ 482.08715637]]),\n", + " 222,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946612460.jpg'),\n", + " (array([[888.06533522],\n", + " [470.97016881]]),\n", + " 212,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945662460.jpg'),\n", + " (array([[800.02365293],\n", + " [462.8527809 ]]),\n", + " 202,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944762460.jpg'),\n", + " (array([[-311.85146319],\n", + " [ 428.02838948]]),\n", + " 120,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", + " (array([[824.71920661],\n", + " [461.27422472]]),\n", + " 205,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945112460.jpg'),\n", + " (array([[839.55610686],\n", + " [465.47435449]]),\n", + " 207,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945262460.jpg'),\n", + " (array([[1000.08845209],\n", + " [ 478.57891414]]),\n", + " 220,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946412460.jpg'),\n", + " (array([[870.16180004],\n", + " [469.8639573 ]]),\n", + " 210,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945512460.jpg'),\n", + " (array([[ 46.66665433],\n", + " [439.49057168]]),\n", + " 128,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg'),\n", + " (array([[903.34991281],\n", + " [469.93428443]]),\n", + " 213,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945762460.jpg'),\n", + " (array([[924.07345858],\n", + " [472.06861151]]),\n", + " 215,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945912460.jpg'),\n", + " (array([[960.02728904],\n", + " [477.94278682]]),\n", + " 218,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946162460.jpg'),\n", + " (array([[293.1066344 ],\n", + " [447.80159019]]),\n", + " 136,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939162460.jpg'),\n", + " (array([[1014.20452478],\n", + " [ 477.44813464]]),\n", + " 221,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946512460.jpg'),\n", + " (array([[1036.95652729],\n", + " [ 477.84632084]]),\n", + " 223,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946662460.jpg'),\n", + " (array([[484.4738008 ],\n", + " [452.58273518]]),\n", + " 144,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939862460.jpg'),\n", + " (array([[603.54160816],\n", + " [460.84600198]]),\n", + " 152,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940512460.jpg'),\n", + " (array([[686.31478981],\n", + " [466.97329973]]),\n", + " 160,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941162460.jpg'),\n", + " (array([[752.36070251],\n", + " [472.26218031]]),\n", + " 168,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941862460.jpg'),\n", + " (array([[776.52960227],\n", + " [473.18341562]]),\n", + " 176,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942612460.jpg'),\n", + " (array([[782.00066392],\n", + " [462.35048851]]),\n", + " 184,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943262460.jpg'),\n", + " (array([[783.91209581],\n", + " [456.16979754]]),\n", + " 192,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943912478.jpg'),\n", + " (array([[792.64437214],\n", + " [453.39154716]]),\n", + " 200,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944612460.jpg'),\n", + " (array([[849.79766203],\n", + " [458.72493851]]),\n", + " 208,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945362460.jpg'),\n", + " (array([[935.26599272],\n", + " [467.53672311]]),\n", + " 216,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946012460.jpg'),\n", + " (array([[1052.71280402],\n", + " [ 476.76094565]]),\n", + " 224,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946762460.jpg')],\n", + " [(array([[1520.30786016],\n", + " [ 499.55273999]]),\n", + " 3,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", + " (array([[1597.26731186],\n", + " [ 488.2365489 ]]),\n", + " 11,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", + " (array([[1704.7927813],\n", + " [ 498.1291805]]),\n", + " 19,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", + " (array([[1810.09280062],\n", + " [ 502.89145893]]),\n", + " 27,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", + " (array([[1938.90929213],\n", + " [ 511.03986987]]),\n", + " 35,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", + " (array([[2101.38420735],\n", + " [ 522.27241561]]),\n", + " 43,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", + " (array([[1504.382053 ],\n", + " [ 499.43422887]]),\n", + " 1,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg'),\n", + " (array([[2295.95323702],\n", + " [ 530.84262 ]]),\n", + " 51,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", + " (array([[1580.59871538],\n", + " [ 493.84500565]]),\n", + " 9,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", + " (array([[2550.5657652 ],\n", + " [ 529.64118747]]),\n", + " 59,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", + " (array([[1672.67820576],\n", + " [ 500.70790263]]),\n", + " 17,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", + " (array([[1548.96109506],\n", + " [ 501.74568306]]),\n", + " 6,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", + " (array([[3020.46871848],\n", + " [ 541.28754163]]),\n", + " 67,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", + " (array([[1787.38622995],\n", + " [ 503.26769703]]),\n", + " 25,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", + " (array([[1532.80526853],\n", + " [ 500.58878287]]),\n", + " 5,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", + " (array([[1528.32799738],\n", + " [ 499.55658256]]),\n", + " 4,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", + " (array([[1627.77548239],\n", + " [ 504.91512101]]),\n", + " 14,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", + " (array([[3989.20933049],\n", + " [ 635.22364359]]),\n", + " 75,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", + " (array([[1900.91110192],\n", + " [ 507.56257845]]),\n", + " 33,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", + " (array([[1608.13854941],\n", + " [ 489.95172003]]),\n", + " 12,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", + " (array([[1506.06546474],\n", + " [ 496.90260236]]),\n", + " 2,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", + " (array([[1622.32135054],\n", + " [ 500.07330091]]),\n", + " 13,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", + " (array([[1740.0685288 ],\n", + " [ 498.96688463]]),\n", + " 22,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", + " (array([[6584.43686218],\n", + " [ 801.41495202]]),\n", + " 83,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", + " (array([[1556.94484433],\n", + " [ 499.05421105]]),\n", + " 7,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", + " (array([[2046.9384392 ],\n", + " [ 518.22850072]]),\n", + " 41,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", + " (array([[1587.93000577],\n", + " [ 488.92870346]]),\n", + " 10,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", + " (array([[1708.8198619 ],\n", + " [ 496.38603981]]),\n", + " 20,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", + " (array([[1724.24125704],\n", + " [ 496.61188206]]),\n", + " 21,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", + " (array([[47113.6503721 ],\n", + " [ 2874.33705863]]),\n", + " 91,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", + " (array([[1848.55558697],\n", + " [ 500.74690984]]),\n", + " 30,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", + " (array([[1641.27518876],\n", + " [ 505.13043191]]),\n", + " 15,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", + " (array([[2240.75071763],\n", + " [ 522.83104267]]),\n", + " 49,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", + " (array([[1682.89540049],\n", + " [ 496.95296567]]),\n", + " 18,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", + " (array([[1822.21135717],\n", + " [ 499.80096262]]),\n", + " 28,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", + " (array([[1829.69038268],\n", + " [ 499.69662694]]),\n", + " 29,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", + " (array([[-5659.99342574],\n", + " [ 179.00433383]]),\n", + " 99,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", + " (array([[1992.72513865],\n", + " [ 516.49074842]]),\n", + " 38,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", + " (array([[1751.66205055],\n", + " [ 497.38594589]]),\n", + " 23,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", + " (array([[2478.5384028 ],\n", + " [ 525.05981339]]),\n", + " 57,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", + " (array([[1790.91597479],\n", + " [ 501.70844986]]),\n", + " 26,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", + " (array([[1958.58326024],\n", + " [ 510.25264603]]),\n", + " 36,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", + " (array([[1981.28235488],\n", + " [ 514.54550847]]),\n", + " 37,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", + " (array([[-2138.1961549 ],\n", + " [ 339.06732842]]),\n", + " 107,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", + " (array([[2167.02892485],\n", + " [ 519.33595678]]),\n", + " 46,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", + " (array([[1873.29185593],\n", + " [ 500.67960681]]),\n", + " 31,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", + " (array([[2814.64955798],\n", + " [ 529.58297566]]),\n", + " 65,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", + " (array([[2137.32502088],\n", + " [ 518.49092098]]),\n", + " 45,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", + " (array([[1925.3060388 ],\n", + " [ 506.33354902]]),\n", + " 34,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", + " (array([[2110.67389117],\n", + " [ 519.19277372]]),\n", + " 44,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", + " (array([[-1074.34586019],\n", + " [ 372.54098436]]),\n", + " 115,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", + " (array([[2376.40562459],\n", + " [ 522.04776227]]),\n", + " 54,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", + " (array([[2013.82668795],\n", + " [ 516.59862272]]),\n", + " 39,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", + " (array([[2074.3735451 ],\n", + " [ 515.10119622]]),\n", + " 42,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", + " (array([[3729.17932401],\n", + " [ 604.35466959]]),\n", + " 73,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", + " (array([[2335.56199234],\n", + " [ 525.72027104]]),\n", + " 53,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", + " (array([[2318.70470746],\n", + " [ 527.67669104]]),\n", + " 52,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", + " (array([[-434.93339397],\n", + " [ 396.07222002]]),\n", + " 123,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", + " (array([[2662.25490852],\n", + " [ 525.70345379]]),\n", + " 62,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", + " (array([[2180.2448244],\n", + " [ 520.1739507]]),\n", + " 47,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", + " (array([[-65.64313096],\n", + " [419.03202851]]),\n", + " 131,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", + " (array([[2586.12518612],\n", + " [ 526.32801492]]),\n", + " 60,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", + " (array([[5463.13662893],\n", + " [ 707.78362512]]),\n", + " 81,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", + " (array([[2259.37648132],\n", + " [ 521.57752247]]),\n", + " 50,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", + " (array([[2634.44923186],\n", + " [ 523.79200862]]),\n", + " 61,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", + " (array([[3254.61807491],\n", + " [ 552.9029591 ]]),\n", + " 70,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", + " (array([[2411.27790913],\n", + " [ 515.98929392]]),\n", + " 55,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", + " (array([[185.74674037],\n", + " [433.16769114]]),\n", + " 139,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939412460.jpg'),\n", + " (array([[18167.79794964],\n", + " [ 1300.164344 ]]),\n", + " 89,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", + " (array([[3095.75978813],\n", + " [ 535.52633235]]),\n", + " 68,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", + " (array([[2516.78001163],\n", + " [ 521.2145415 ]]),\n", + " 58,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", + " (array([[4548.96215468],\n", + " [ 659.29429568]]),\n", + " 78,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", + " (array([[2717.39880698],\n", + " [ 522.13002068]]),\n", + " 63,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", + " (array([[375.86941867],\n", + " [443.84415382]]),\n", + " 147,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940112460.jpg'),\n", + " (array([[-9578.36328978],\n", + " [ 27.75795576]]),\n", + " 97,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", + " (array([[4207.16848899],\n", + " [ 625.12224666]]),\n", + " 76,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", + " (array([[2963.48503656],\n", + " [ 522.64998985]]),\n", + " 66,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", + " (array([[9393.44955058],\n", + " [ 882.40687034]]),\n", + " 86,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", + " (array([[3194.13198816],\n", + " [ 537.77389319]]),\n", + " 69,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", + " (array([[3369.16492084],\n", + " [ 552.68993289]]),\n", + " 71,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", + " (array([[487.30701422],\n", + " [455.01399833]]),\n", + " 155,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940762460.jpg'),\n", + " (array([[-2807.51411213],\n", + " [ 333.06586205]]),\n", + " 105,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", + " (array([[6982.21445306],\n", + " [ 786.98789068]]),\n", + " 84,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", + " (array([[3901.68079994],\n", + " [ 604.44445523]]),\n", + " 74,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", + " (array([[-26228.27927746],\n", + " [ -810.288706 ]]),\n", + " 94,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", + " (array([[4427.50086244],\n", + " [ 634.5875181 ]]),\n", + " 77,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", + " (array([[4833.51429151],\n", + " [ 667.65326279]]),\n", + " 79,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", + " (array([[570.5650474 ],\n", + " [463.43720032]]),\n", + " 163,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941412460.jpg'),\n", + " (array([[-1267.57292521],\n", + " [ 374.60588246]]),\n", + " 113,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", + " (array([[5946.52746526],\n", + " [ 717.04606728]]),\n", + " 82,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", + " (array([[-365062.02849914],\n", + " [ -13811.99448051]]),\n", + " 92,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", + " (array([[-3826.41120927],\n", + " [ 322.3700365 ]]),\n", + " 102,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", + " (array([[8008.88057767],\n", + " [ 787.29784933]]),\n", + " 85,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", + " (array([[10452.35551403],\n", + " [ 872.20506736]]),\n", + " 87,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", + " (array([[1564.40814845],\n", + " [ 484.73867596]]),\n", + " 8,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", + " (array([[626.46771498],\n", + " [471.97017607]]),\n", + " 171,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942112460.jpg'),\n", + " (array([[-592.93778155],\n", + " [ 412.8509103 ]]),\n", + " 121,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", + " (array([[-4800.11585181],\n", + " [ 281.90705623]]),\n", + " 100,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", + " (array([[22255.12393764],\n", + " [ 1294.52203701]]),\n", + " 90,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", + " (array([[-1657.2028304 ],\n", + " [ 382.62048761]]),\n", + " 110,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", + " (array([[-73998.09178362],\n", + " [ -2686.99096825]]),\n", + " 93,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", + " (array([[-15920.69298151],\n", + " [ -221.18670358]]),\n", + " 95,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", + " (array([[1656.43573066],\n", + " [ 488.93113222]]),\n", + " 16,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", + " (array([[645.75052209],\n", + " [464.84390872]]),\n", + " 179,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942862460.jpg'),\n", + " (array([[-137.72091002],\n", + " [ 432.78641524]]),\n", + " 129,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", + " (array([[-6867.95954389],\n", + " [ 212.0227831 ]]),\n", + " 98,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", + " (array([[-1937.66844221],\n", + " [ 373.54589435]]),\n", + " 108,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", + " (array([[-816.0933564 ],\n", + " [ 411.79483091]]),\n", + " 118,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", + " (array([[-4442.21395582],\n", + " [ 281.22581272]]),\n", + " 101,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", + " (array([[-3377.16913332],\n", + " [ 330.79122065]]),\n", + " 103,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", + " (array([[1762.73693961],\n", + " [ 487.96718781]]),\n", + " 24,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", + " (array([[134.5746742 ],\n", + " [438.97579502]]),\n", + " 137,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939262460.jpg'),\n", + " (array([[-2366.64227685],\n", + " [ 367.98198683]]),\n", + " 106,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", + " (array([[-964.88748966],\n", + " [ 405.27638446]]),\n", + " 116,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", + " (array([[-275.07848225],\n", + " [ 421.53866932]]),\n", + " 126,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", + " (array([[-1834.40334531],\n", + " [ 379.06725994]]),\n", + " 109,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", + " (array([[-1491.08949365],\n", + " [ 386.57817746]]),\n", + " 111,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", + " (array([[1878.11043113],\n", + " [ 487.34899025]]),\n", + " 32,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", + " (array([[331.12124936],\n", + " [451.45243324]]),\n", + " 145,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939912460.jpg'),\n", + " (array([[-399.30665993],\n", + " [ 413.66545663]]),\n", + " 124,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", + " (array([[-1133.44748771],\n", + " [ 391.84129308]]),\n", + " 114,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", + " (array([[ 42.84584829],\n", + " [438.68341144]]),\n", + " 134,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", + " (array([[-860.45215049],\n", + " [ 411.96791278]]),\n", + " 117,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", + " (array([[-714.79815186],\n", + " [ 413.73914519]]),\n", + " 119,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", + " (array([[2034.84769765],\n", + " [ 502.6106164 ]]),\n", + " 40,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", + " (array([[467.4307328 ],\n", + " [460.21609384]]),\n", + " 153,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940612460.jpg'),\n", + " (array([[-506.8916898 ],\n", + " [ 410.91434764]]),\n", + " 122,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", + " (array([[-17.99529788],\n", + " [433.98107134]]),\n", + " 132,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", + " (array([[264.23614371],\n", + " [444.98084076]]),\n", + " 142,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939662460.jpg'),\n", + " (array([[-331.70034757],\n", + " [ 411.72546021]]),\n", + " 125,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", + " (array([[-241.65489432],\n", + " [ 422.78484309]]),\n", + " 127,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", + " (array([[2210.02411505],\n", + " [ 505.8370253 ]]),\n", + " 48,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", + " (array([[554.01753674],\n", + " [464.5837524 ]]),\n", + " 161,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941262460.jpg'),\n", + " (array([[220.65050574],\n", + " [443.41165958]]),\n", + " 140,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939512460.jpg'),\n", + " (array([[-108.35078043],\n", + " [ 430.65928805]]),\n", + " 130,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", + " (array([[427.53967027],\n", + " [448.75471776]]),\n", + " 150,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940362460.jpg'),\n", + " (array([[ 6.2193707 ],\n", + " [426.03600963]]),\n", + " 133,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", + " (array([[ 85.28190963],\n", + " [431.0791797 ]]),\n", + " 135,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", + " (array([[619.34172976],\n", + " [464.58972163]]),\n", + " 169,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941912460.jpg'),\n", + " (array([[2434.2483222 ],\n", + " [ 515.92956168]]),\n", + " 56,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", + " (array([[389.23205838],\n", + " [444.54326751]]),\n", + " 148,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940162460.jpg'),\n", + " (array([[173.80513467],\n", + " [432.59626585]]),\n", + " 138,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939362460.jpg'),\n", + " (array([[526.5815778 ],\n", + " [450.96939474]]),\n", + " 158,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941012460.jpg'),\n", + " (array([[252.68960055],\n", + " [432.7340222 ]]),\n", + " 141,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939612460.jpg'),\n", + " (array([[295.92872868],\n", + " [434.88306995]]),\n", + " 143,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939762460.jpg'),\n", + " (array([[645.66563099],\n", + " [460.92922558]]),\n", + " 177,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942662460.jpg'),\n", + " (array([[2784.59514863],\n", + " [ 530.22024888]]),\n", + " 64,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", + " (array([[505.50396994],\n", + " [450.59237383]]),\n", + " 156,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940862460.jpg'),\n", + " (array([[358.20381712],\n", + " [435.74307619]]),\n", + " 146,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940012460.jpg'),\n", + " (array([[598.61724998],\n", + " [455.68383752]]),\n", + " 166,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941662460.jpg'),\n", + " (array([[409.2415045 ],\n", + " [440.57049895]]),\n", + " 149,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940262460.jpg'),\n", + " (array([[437.11252575],\n", + " [442.8511078 ]]),\n", + " 151,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940412460.jpg'),\n", + " (array([[476.82528053],\n", + " [446.24591286]]),\n", + " 154,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940662460.jpg'),\n", + " (array([[584.57730944],\n", + " [454.92217905]]),\n", + " 164,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941512460.jpg'),\n", + " (array([[3507.41350635],\n", + " [ 591.25473272]]),\n", + " 72,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", + " (array([[638.07522288],\n", + " [461.0406266 ]]),\n", + " 174,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942362460.jpg'),\n", + " (array([[511.34607161],\n", + " [449.1068777 ]]),\n", + " 157,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940912460.jpg'),\n", + " (array([[537.92480087],\n", + " [451.1790959 ]]),\n", + " 159,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941112460.jpg'),\n", + " (array([[567.17745211],\n", + " [454.99556382]]),\n", + " 162,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941362460.jpg'),\n", + " (array([[631.54355843],\n", + " [459.14436348]]),\n", + " 172,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942162460.jpg'),\n", + " (array([[650.20478387],\n", + " [453.3364855 ]]),\n", + " 182,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943112460.jpg'),\n", + " (array([[5235.71974031],\n", + " [ 701.71090148]]),\n", + " 80,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", + " (array([[592.33024816],\n", + " [459.57842359]]),\n", + " 165,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941612460.jpg'),\n", + " (array([[605.95847041],\n", + " [460.60179296]]),\n", + " 167,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941762460.jpg'),\n", + " (array([[648.14521923],\n", + " [455.29566502]]),\n", + " 180,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942912460.jpg'),\n", + " (array([[623.75288722],\n", + " [462.13480666]]),\n", + " 170,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942012460.jpg'),\n", + " (array([[13361.11459429],\n", + " [ 1117.22636683]]),\n", + " 88,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", + " (array([[633.18466052],\n", + " [467.65966357]]),\n", + " 173,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942262460.jpg'),\n", + " (array([[640.53907913],\n", + " [470.3068369 ]]),\n", + " 175,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942512460.jpg'),\n", + " (array([[645.24642902],\n", + " [462.69085474]]),\n", + " 178,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942762460.jpg'),\n", + " (array([[-12939.43264512],\n", + " [ -161.28330775]]),\n", + " 96,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", + " (array([[647.38383652],\n", + " [460.40580194]]),\n", + " 181,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943012460.jpg'),\n", + " (array([[648.65854216],\n", + " [465.57355234]]),\n", + " 183,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943162460.jpg'),\n", + " (array([[-3165.44940056],\n", + " [ 347.43762114]]),\n", + " 104,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", + " (array([[-1414.60764878],\n", + " [ 389.88642384]]),\n", + " 112,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", + " (array([[-629.64914099],\n", + " [ 416.36983282]]),\n", + " 120,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", + " (array([[-189.75010984],\n", + " [ 434.0142604 ]]),\n", + " 128,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg'),\n", + " (array([[ 98.43501454],\n", + " [439.69120954]]),\n", + " 136,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939162460.jpg'),\n", + " (array([[316.97177613],\n", + " [449.54580981]]),\n", + " 144,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939862460.jpg'),\n", + " (array([[448.92470887],\n", + " [458.1977374 ]]),\n", + " 152,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940512460.jpg'),\n", + " (array([[539.84225913],\n", + " [464.76828022]]),\n", + " 160,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941162460.jpg'),\n", + " (array([[612.05762234],\n", + " [470.73045084]]),\n", + " 168,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941862460.jpg'),\n", + " (array([[640.64690483],\n", + " [472.60044243]]),\n", + " 176,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942612460.jpg')],\n", + " [(array([[753.11971033],\n", + " [491.47527543]]),\n", + " 3,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", + " (array([[752.92390731],\n", + " [485.4510099 ]]),\n", + " 11,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", + " (array([[756.66426604],\n", + " [499.06870148]]),\n", + " 19,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", + " (array([[749.76760677],\n", + " [510.13654729]]),\n", + " 27,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", + " (array([[741.98674664],\n", + " [522.73199765]]),\n", + " 35,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", + " (array([[717.45996316],\n", + " [542.72203794]]),\n", + " 43,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", + " (array([[755.77083302],\n", + " [494.37994559]]),\n", + " 1,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg'),\n", + " (array([[721.35968778],\n", + " [566.20199169]]),\n", + " 51,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", + " (array([[757.88039949],\n", + " [489.42862576]]),\n", + " 9,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", + " (array([[662.42158199],\n", + " [638.69285372]]),\n", + " 59,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", + " (array([[760.27037907],\n", + " [494.67367898]]),\n", + " 17,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", + " (array([[756.82939689],\n", + " [492.73285034]]),\n", + " 6,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", + " (array([[ -73.66212475],\n", + " [1539.19488978]]),\n", + " 67,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", + " (array([[761.50541182],\n", + " [504.23067806]]),\n", + " 25,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", + " (array([[751.28725985],\n", + " [490.7317152 ]]),\n", + " 5,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", + " (array([[752.34645245],\n", + " [489.30130431]]),\n", + " 4,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", + " (array([[751.63055415],\n", + " [496.77685294]]),\n", + " 14,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", + " (array([[1439.30786765],\n", + " [-323.18119174]]),\n", + " 75,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", + " (array([[750.23466335],\n", + " [506.11712728]]),\n", + " 33,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", + " (array([[752.12191244],\n", + " [482.84284709]]),\n", + " 12,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", + " (array([[747.07940198],\n", + " [488.87498641]]),\n", + " 2,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", + " (array([[747.47310925],\n", + " [490.45850336]]),\n", + " 13,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", + " (array([[750.881416 ],\n", + " [491.60932273]]),\n", + " 22,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", + " (array([[1046.76260016],\n", + " [ 135.41005353]]),\n", + " 83,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", + " (array([[746.66344319],\n", + " [487.71604714]]),\n", + " 7,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", + " (array([[739.2327024 ],\n", + " [510.30748126]]),\n", + " 41,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", + " (array([[740.37143236],\n", + " [481.3540385 ]]),\n", + " 10,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", + " (array([[745.03415028],\n", + " [489.54399927]]),\n", + " 20,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", + " (array([[744.67646149],\n", + " [488.66821228]]),\n", + " 21,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", + " (array([[969.81039024],\n", + " [249.85400423]]),\n", + " 91,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", + " (array([[737.34803077],\n", + " [496.19021377]]),\n", + " 30,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", + " (array([[728.78833156],\n", + " [493.58559647]]),\n", + " 15,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", + " (array([[703.50371896],\n", + " [512.98445408]]),\n", + " 49,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", + " (array([[731.85273713],\n", + " [487.18271724]]),\n", + " 18,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", + " (array([[726.37714668],\n", + " [493.71892563]]),\n", + " 28,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", + " (array([[725.01280448],\n", + " [493.2995996 ]]),\n", + " 29,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", + " (array([[963.9672891 ],\n", + " [325.16168854]]),\n", + " 99,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", + " (array([[701.01420338],\n", + " [500.03019929]]),\n", + " 38,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", + " (array([[715.24186012],\n", + " [486.10268638]]),\n", + " 23,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", + " (array([[657.70677757],\n", + " [519.62301517]]),\n", + " 57,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", + " (array([[710.985946 ],\n", + " [491.32225725]]),\n", + " 26,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", + " (array([[703.23014905],\n", + " [497.44658066]]),\n", + " 36,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", + " (array([[701.82878463],\n", + " [499.62795551]]),\n", + " 37,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", + " (array([[968.54735606],\n", + " [357.14066664]]),\n", + " 107,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", + " (array([[660.54645648],\n", + " [490.93902879]]),\n", + " 46,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", + " (array([[686.17440951],\n", + " [486.8401325 ]]),\n", + " 31,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", + " (array([[604.33069377],\n", + " [518.67343972]]),\n", + " 65,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", + " (array([[662.27544198],\n", + " [492.54596916]]),\n", + " 45,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", + " (array([[683.62650704],\n", + " [491.13962194]]),\n", + " 34,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", + " (array([[665.1889703 ],\n", + " [493.09100418]]),\n", + " 44,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", + " (array([[930.79465856],\n", + " [350.18938662]]),\n", + " 115,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", + " (array([[608.13645262],\n", + " [501.17648912]]),\n", + " 54,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", + " (array([[650.76057005],\n", + " [491.96686483]]),\n", + " 39,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", + " (array([[644.3222665 ],\n", + " [487.94862287]]),\n", + " 42,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", + " (array([[560.70771689],\n", + " [528.41714793]]),\n", + " 73,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", + " (array([[610.3568308 ],\n", + " [501.42313654]]),\n", + " 53,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", + " (array([[584.02050935],\n", + " [497.1582116 ]]),\n", + " 52,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", + " (array([[971.75706953],\n", + " [385.07606121]]),\n", + " 123,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", + " (array([[546.39584901],\n", + " [505.25535256]]),\n", + " 62,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", + " (array([[603.87311134],\n", + " [484.09666714]]),\n", + " 47,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", + " (array([[1058.33002984],\n", + " [ 418.6051489 ]]),\n", + " 131,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", + " (array([[517.57208367],\n", + " [498.22955359]]),\n", + " 60,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", + " (array([[488.44565562],\n", + " [523.04188823]]),\n", + " 81,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", + " (array([[562.95860315],\n", + " [490.95288262]]),\n", + " 50,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", + " (array([[511.49773922],\n", + " [499.53280676]]),\n", + " 61,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", + " (array([[483.97113077],\n", + " [495.43728352]]),\n", + " 70,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", + " (array([[502.14749818],\n", + " [489.77701675]]),\n", + " 55,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", + " (array([[1006.67495408],\n", + " [ 419.17536585]]),\n", + " 139,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939412460.jpg'),\n", + " (array([[495.51147271],\n", + " [543.47975503]]),\n", + " 89,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", + " (array([[444.47008077],\n", + " [488.72988849]]),\n", + " 68,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", + " (array([[488.60000021],\n", + " [492.60423635]]),\n", + " 58,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", + " (array([[439.61975756],\n", + " [489.47953467]]),\n", + " 78,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", + " (array([[425.29053755],\n", + " [490.3086527 ]]),\n", + " 63,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", + " (array([[1018.55578835],\n", + " [ 433.52007094]]),\n", + " 147,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940112460.jpg'),\n", + " (array([[526.18254092],\n", + " [559.88191774]]),\n", + " 97,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", + " (array([[397.87838942],\n", + " [482.84127482]]),\n", + " 76,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", + " (array([[408.35460133],\n", + " [484.5658776 ]]),\n", + " 66,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", + " (array([[362.00869949],\n", + " [511.66097174]]),\n", + " 86,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", + " (array([[341.06355331],\n", + " [476.28918117]]),\n", + " 69,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", + " (array([[339.29478746],\n", + " [477.71663472]]),\n", + " 71,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", + " (array([[995.11295739],\n", + " [439.04168 ]]),\n", + " 155,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940762460.jpg'),\n", + " (array([[552.98747329],\n", + " [569.47824026]]),\n", + " 105,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", + " (array([[346.51811325],\n", + " [503.25465402]]),\n", + " 84,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", + " (array([[337.13953636],\n", + " [481.42469757]]),\n", + " 74,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", + " (array([[368.63806514],\n", + " [508.16288149]]),\n", + " 94,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", + " (array([[269.38085669],\n", + " [460.71491998]]),\n", + " 77,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", + " (array([[266.51613276],\n", + " [467.54414217]]),\n", + " 79,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", + " (array([[977.45391407],\n", + " [443.71153674]]),\n", + " 163,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941412460.jpg'),\n", + " (array([[594.23343496],\n", + " [582.2443823 ]]),\n", + " 113,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", + " (array([[273.01923315],\n", + " [489.39894809]]),\n", + " 82,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", + " (array([[277.50747267],\n", + " [492.23152574]]),\n", + " 92,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", + " (array([[380.74728789],\n", + " [514.25963054]]),\n", + " 102,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", + " (array([[213.0621516 ],\n", + " [484.07271866]]),\n", + " 85,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", + " (array([[227.64029008],\n", + " [490.87444677]]),\n", + " 87,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", + " (array([[511.93720851],\n", + " [466.54446949]]),\n", + " 8,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", + " (array([[953.38080065],\n", + " [447.39651617]]),\n", + " 171,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942112460.jpg'),\n", + " (array([[524.45369823],\n", + " [560.96091821]]),\n", + " 121,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", + " (array([[281.11618174],\n", + " [506.91458161]]),\n", + " 100,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", + " (array([[171.68752015],\n", + " [487.40774068]]),\n", + " 90,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", + " (array([[387.91877232],\n", + " [522.52119267]]),\n", + " 110,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", + " (array([[202.66493116],\n", + " [488.74217698]]),\n", + " 93,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", + " (array([[150.07241431],\n", + " [493.71742934]]),\n", + " 95,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", + " (array([[415.71931002],\n", + " [467.53162909]]),\n", + " 16,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", + " (array([[899.67385503],\n", + " [419.06213889]]),\n", + " 179,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942862460.jpg'),\n", + " (array([[564.00953308],\n", + " [595.35965386]]),\n", + " 129,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", + " (array([[184.2846848 ],\n", + " [502.86313587]]),\n", + " 98,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", + " (array([[233.14046056],\n", + " [511.41253934]]),\n", + " 108,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", + " (array([[357.24593496],\n", + " [527.86375207]]),\n", + " 118,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", + " (array([[147.09006862],\n", + " [501.56831076]]),\n", + " 101,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", + " (array([[170.24719382],\n", + " [505.43402682]]),\n", + " 103,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", + " (array([[349.28602499],\n", + " [469.36397348]]),\n", + " 24,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", + " (array([[886.21947416],\n", + " [404.27319853]]),\n", + " 187,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943512460.jpg'),\n", + " (array([[538.78433237],\n", + " [594.02503346]]),\n", + " 137,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939262460.jpg'),\n", + " (array([[152.31734242],\n", + " [505.80115357]]),\n", + " 106,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", + " (array([[284.36463698],\n", + " [519.14254812]]),\n", + " 116,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", + " (array([[423.46407877],\n", + " [536.28695176]]),\n", + " 126,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", + " (array([[186.37476891],\n", + " [509.32960536]]),\n", + " 109,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", + " (array([[217.02648145],\n", + " [509.66867316]]),\n", + " 111,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", + " (array([[228.30861987],\n", + " [466.63546775]]),\n", + " 32,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", + " (array([[881.59507874],\n", + " [383.00739644]]),\n", + " 195,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944162460.jpg'),\n", + " (array([[575.04765652],\n", + " [630.51216656]]),\n", + " 145,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939912460.jpg'),\n", + " (array([[358.06143143],\n", + " [518.5646108 ]]),\n", + " 124,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", + " (array([[217.98774496],\n", + " [506.950209 ]]),\n", + " 114,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", + " (array([[490.292987 ],\n", + " [554.49543744]]),\n", + " 134,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", + " (array([[230.53551802],\n", + " [509.99889859]]),\n", + " 117,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", + " (array([[889.49673022],\n", + " [386.08614155]]),\n", + " 203,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944862460.jpg'),\n", + " (array([[260.28833103],\n", + " [510.29176904]]),\n", + " 119,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", + " (array([[133.24008741],\n", + " [464.60951515]]),\n", + " 40,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", + " (array([[585.45527798],\n", + " [691.8808036 ]]),\n", + " 153,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940612460.jpg'),\n", + " (array([[276.71868506],\n", + " [505.60168074]]),\n", + " 122,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", + " (array([[428.65759481],\n", + " [525.21224623]]),\n", + " 132,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", + " (array([[538.48109604],\n", + " [549.21975709]]),\n", + " 142,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939662460.jpg'),\n", + " (array([[323.25395499],\n", + " [503.64718533]]),\n", + " 125,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", + " (array([[943.31733325],\n", + " [395.83721828]]),\n", + " 211,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945612460.jpg'),\n", + " (array([[350.56034613],\n", + " [512.80166729]]),\n", + " 127,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", + " (array([[-31.94365538],\n", + " [460.36566943]]),\n", + " 48,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", + " (array([[611.70635097],\n", + " [642.99173698]]),\n", + " 161,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941262460.jpg'),\n", + " (array([[501.83513302],\n", + " [533.25881194]]),\n", + " 140,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939512460.jpg'),\n", + " (array([[370.72021527],\n", + " [513.43554452]]),\n", + " 130,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", + " (array([[589.34763181],\n", + " [569.36729468]]),\n", + " 150,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940362460.jpg'),\n", + " (array([[413.909259 ],\n", + " [518.20950592]]),\n", + " 133,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", + " (array([[1005.99203217],\n", + " [ 403.37098512]]),\n", + " 219,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946262460.jpg'),\n", + " (array([[436.00893383],\n", + " [516.43019546]]),\n", + " 135,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", + " (array([[648.04180049],\n", + " [667.06287815]]),\n", + " 169,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941912460.jpg'),\n", + " (array([[-173.7794014 ],\n", + " [ 470.97677497]]),\n", + " 56,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", + " (array([[577.83209619],\n", + " [543.85740536]]),\n", + " 148,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940162460.jpg'),\n", + " (array([[474.65957938],\n", + " [519.24542073]]),\n", + " 138,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939362460.jpg'),\n", + " (array([[634.75624816],\n", + " [581.70855885]]),\n", + " 158,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941012460.jpg'),\n", + " (array([[504.58756708],\n", + " [516.05227746]]),\n", + " 141,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939612460.jpg'),\n", + " (array([[528.08196215],\n", + " [519.05231097]]),\n", + " 143,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939762460.jpg'),\n", + " (array([[647.35589016],\n", + " [672.51195827]]),\n", + " 177,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942662460.jpg'),\n", + " (array([[-349.69372546],\n", + " [ 467.65711267]]),\n", + " 64,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", + " (array([[637.04932999],\n", + " [553.74221606]]),\n", + " 156,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940862460.jpg'),\n", + " (array([[562.24192012],\n", + " [527.90356495]]),\n", + " 146,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940012460.jpg'),\n", + " (array([[683.20541047],\n", + " [589.07671188]]),\n", + " 166,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941662460.jpg'),\n", + " (array([[589.70062416],\n", + " [526.84246133]]),\n", + " 149,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940262460.jpg'),\n", + " (array([[605.72624393],\n", + " [530.3926932 ]]),\n", + " 151,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940412460.jpg'),\n", + " (array([[631.89513909],\n", + " [665.73440913]]),\n", + " 185,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943362460.jpg'),\n", + " (array([[628.19456051],\n", + " [536.54589787]]),\n", + " 154,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940662460.jpg'),\n", + " (array([[692.20914334],\n", + " [561.74015886]]),\n", + " 164,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941512460.jpg'),\n", + " (array([[-488.01391296],\n", + " [ 451.10927373]]),\n", + " 72,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", + " (array([[728.91444168],\n", + " [574.02970075]]),\n", + " 174,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942362460.jpg'),\n", + " (array([[653.87568062],\n", + " [533.10030284]]),\n", + " 157,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940912460.jpg'),\n", + " (array([[625.19420938],\n", + " [666.3086945 ]]),\n", + " 193,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944012460.jpg'),\n", + " (array([[671.15320067],\n", + " [537.3244686 ]]),\n", + " 159,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941112460.jpg'),\n", + " (array([[690.40902319],\n", + " [544.68958923]]),\n", + " 162,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941362460.jpg'),\n", + " (array([[729.58065005],\n", + " [565.88509799]]),\n", + " 172,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942162460.jpg'),\n", + " (array([[705.49586515],\n", + " [570.68588563]]),\n", + " 182,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943112460.jpg'),\n", + " (array([[-611.05088731],\n", + " [ 434.95857179]]),\n", + " 80,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", + " (array([[703.4530686 ],\n", + " [542.98482631]]),\n", + " 165,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941612460.jpg'),\n", + " (array([[570.69554323],\n", + " [682.59403674]]),\n", + " 201,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944662460.jpg'),\n", + " (array([[712.55493521],\n", + " [546.17125954]]),\n", + " 167,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941762460.jpg'),\n", + " (array([[708.02285179],\n", + " [548.18723536]]),\n", + " 180,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942912460.jpg'),\n", + " (array([[714.21445976],\n", + " [541.99803535]]),\n", + " 170,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942012460.jpg'),\n", + " (array([[667.91180992],\n", + " [561.48752153]]),\n", + " 190,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943762460.jpg'),\n", + " (array([[-567.18217094],\n", + " [ 456.40868869]]),\n", + " 88,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", + " (array([[717.20800692],\n", + " [546.28917214]]),\n", + " 173,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942262460.jpg'),\n", + " (array([[538.88108331],\n", + " [632.457337 ]]),\n", + " 209,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945412460.jpg'),\n", + " (array([[677.96128592],\n", + " [542.30062034]]),\n", + " 175,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942512460.jpg'),\n", + " (array([[672.4191088 ],\n", + " [536.65398995]]),\n", + " 178,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942762460.jpg'),\n", + " (array([[581.15624549],\n", + " [558.23711127]]),\n", + " 198,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944412460.jpg'),\n", + " (array([[637.2020599 ],\n", + " [535.03332292]]),\n", + " 188,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943612460.jpg'),\n", + " (array([[-472.28003486],\n", + " [ 458.99453571]]),\n", + " 96,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", + " (array([[640.02311863],\n", + " [530.19569078]]),\n", + " 181,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943012460.jpg'),\n", + " (array([[570.47120389],\n", + " [671.19366557]]),\n", + " 217,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946112460.jpg'),\n", + " (array([[634.20660565],\n", + " [531.26841264]]),\n", + " 183,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943162460.jpg'),\n", + " (array([[536.22208564],\n", + " [568.89563727]]),\n", + " 206,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945162460.jpg'),\n", + " (array([[622.30852708],\n", + " [529.48841283]]),\n", + " 186,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943412460.jpg'),\n", + " (array([[572.41947295],\n", + " [537.729227 ]]),\n", + " 196,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944262460.jpg'),\n", + " (array([[-390.16024928],\n", + " [ 471.30522301]]),\n", + " 104,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", + " (array([[551.21678294],\n", + " [517.36542622]]),\n", + " 189,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943662460.jpg'),\n", + " (array([[535.56973737],\n", + " [526.37906876]]),\n", + " 191,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943862460.jpg'),\n", + " (array([[483.36697783],\n", + " [592.47774876]]),\n", + " 214,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945862460.jpg'),\n", + " (array([[468.16157377],\n", + " [541.64421781]]),\n", + " 204,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944912460.jpg'),\n", + " (array([[518.59559706],\n", + " [527.29531139]]),\n", + " 194,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944112460.jpg'),\n", + " (array([[-246.47979916],\n", + " [ 467.76487113]]),\n", + " 112,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", + " (array([[433.71078802],\n", + " [518.9388887 ]]),\n", + " 197,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944362460.jpg'),\n", + " (array([[419.73951661],\n", + " [523.25666579]]),\n", + " 199,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944512460.jpg'),\n", + " (array([[429.92384806],\n", + " [627.96546057]]),\n", + " 222,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946612460.jpg'),\n", + " (array([[397.1967781],\n", + " [560.0107632]]),\n", + " 212,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945662460.jpg'),\n", + " (array([[404.20718079],\n", + " [528.41829584]]),\n", + " 202,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944762460.jpg'),\n", + " (array([[-96.05686527],\n", + " [466.77226529]]),\n", + " 120,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", + " (array([[298.78998074],\n", + " [508.56603138]]),\n", + " 205,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945112460.jpg'),\n", + " (array([[295.48584202],\n", + " [515.5302239 ]]),\n", + " 207,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945262460.jpg'),\n", + " (array([[308.84295767],\n", + " [559.37443269]]),\n", + " 220,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946412460.jpg'),\n", + " (array([[295.171748 ],\n", + " [525.41363821]]),\n", + " 210,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945512460.jpg'),\n", + " (array([[ 21.82581406],\n", + " [466.17966869]]),\n", + " 128,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg'),\n", + " (array([[181.03015093],\n", + " [505.05812131]]),\n", + " 213,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945762460.jpg'),\n", + " (array([[179.4617382 ],\n", + " [509.76318517]]),\n", + " 215,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945912460.jpg'),\n", + " (array([[179.37969128],\n", + " [517.64950642]]),\n", + " 218,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946162460.jpg'),\n", + " (array([[167.94271873],\n", + " [468.66110084]]),\n", + " 136,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939162460.jpg'),\n", + " (array([[180.03013938],\n", + " [531.49997773]]),\n", + " 221,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946512460.jpg'),\n", + " (array([[ 39.7280833],\n", + " [511.8248388]]),\n", + " 223,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946662460.jpg'),\n", + " (array([[231.19650004],\n", + " [465.56932048]]),\n", + " 144,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939862460.jpg'),\n", + " (array([[299.3325792 ],\n", + " [471.74163857]]),\n", + " 152,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940512460.jpg'),\n", + " (array([[339.7079059 ],\n", + " [477.32769374]]),\n", + " 160,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941162460.jpg'),\n", + " (array([[364.37817289],\n", + " [483.71069143]]),\n", + " 168,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941862460.jpg'),\n", + " (array([[332.45442414],\n", + " [487.27494077]]),\n", + " 176,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942612460.jpg'),\n", + " (array([[278.42816133],\n", + " [474.29204104]]),\n", + " 184,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943262460.jpg'),\n", + " (array([[123.96532519],\n", + " [454.25116194]]),\n", + " 192,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943912478.jpg'),\n", + " (array([[ 23.5076618 ],\n", + " [449.18974871]]),\n", + " 200,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944612460.jpg'),\n", + " (array([[-44.28980199],\n", + " [455.5825046 ]]),\n", + " 208,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945362460.jpg'),\n", + " (array([[-69.4499552 ],\n", + " [463.30739216]]),\n", + " 216,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946012460.jpg'),\n", + " (array([[-77.7597058 ],\n", + " [485.62339902]]),\n", + " 224,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946762460.jpg')],\n", + " [(array([[918.9666076 ],\n", + " [478.35580923]]),\n", + " 3,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", + " (array([[934.30081621],\n", + " [470.61960965]]),\n", + " 11,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", + " (array([[962.65294856],\n", + " [478.97631847]]),\n", + " 19,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", + " (array([[983.6924351],\n", + " [482.6133235]]),\n", + " 27,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", + " (array([[1011.32314606],\n", + " [ 485.10614389]]),\n", + " 35,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", + " (array([[1041.19614428],\n", + " [ 485.53589723]]),\n", + " 43,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", + " (array([[1066.00105575],\n", + " [ 492.99588171]]),\n", + " 51,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", + " (array([[928.68447316],\n", + " [477.02829624]]),\n", + " 9,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", + " (array([[1106.84383991],\n", + " [ 492.45328791]]),\n", + " 59,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", + " (array([[950.6754309 ],\n", + " [479.49179011]]),\n", + " 17,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", + " (array([[920.88629692],\n", + " [482.14357581]]),\n", + " 6,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", + " (array([[1183.25237668],\n", + " [ 487.74766981]]),\n", + " 67,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", + " (array([[976.00995183],\n", + " [482.77927969]]),\n", + " 25,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", + " (array([[917.88934595],\n", + " [481.71619737]]),\n", + " 5,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", + " (array([[917.5891076 ],\n", + " [480.54008711]]),\n", + " 4,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", + " (array([[939.11726091],\n", + " [484.62608409]]),\n", + " 14,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", + " (array([[1301.41515924],\n", + " [ 504.41644263]]),\n", + " 75,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", + " (array([[996.07488987],\n", + " [482.19843277]]),\n", + " 33,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", + " (array([[935.13700898],\n", + " [471.34742407]]),\n", + " 12,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", + " (array([[911.7980281 ],\n", + " [481.12883339]]),\n", + " 2,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", + " (array([[937.39141795],\n", + " [480.21601651]]),\n", + " 13,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", + " (array([[964.1846153 ],\n", + " [477.67935591]]),\n", + " 22,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", + " (array([[922.70612968],\n", + " [479.5055044 ]]),\n", + " 7,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", + " (array([[1017.81019253],\n", + " [ 484.17487376]]),\n", + " 41,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", + " (array([[929.37343106],\n", + " [472.65111323]]),\n", + " 10,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", + " (array([[956.67051682],\n", + " [477.67875863]]),\n", + " 20,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", + " (array([[959.50327632],\n", + " [476.64684825]]),\n", + " 21,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", + " (array([[979.40983748],\n", + " [479.48636007]]),\n", + " 30,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", + " (array([[939.16114867],\n", + " [485.89824866]]),\n", + " 15,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", + " (array([[1041.99531609],\n", + " [ 486.97054389]]),\n", + " 49,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", + " (array([[949.36483058],\n", + " [477.87020913]]),\n", + " 18,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", + " (array([[973.6970166 ],\n", + " [479.99282511]]),\n", + " 28,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", + " (array([[974.32201942],\n", + " [479.42288654]]),\n", + " 29,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", + " (array([[1002.25443952],\n", + " [ 487.19731164]]),\n", + " 38,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", + " (array([[962.593487 ],\n", + " [477.84791224]]),\n", + " 23,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", + " (array([[1066.47090683],\n", + " [ 488.87113473]]),\n", + " 57,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", + " (array([[968.63534425],\n", + " [481.2186418 ]]),\n", + " 26,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", + " (array([[996.80207068],\n", + " [483.89616307]]),\n", + " 36,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", + " (array([[1000.24758766],\n", + " [ 485.92670588]]),\n", + " 37,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", + " (array([[1024.63237029],\n", + " [ 479.2085053 ]]),\n", + " 46,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", + " (array([[982.51832544],\n", + " [478.12562986]]),\n", + " 31,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", + " (array([[1105.52423674],\n", + " [ 484.38169236]]),\n", + " 65,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", + " (array([[1020.04734085],\n", + " [ 480.84307363]]),\n", + " 45,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", + " (array([[989.59600965],\n", + " [480.52989386]]),\n", + " 34,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", + " (array([[1014.00426897],\n", + " [ 480.78149256]]),\n", + " 44,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", + " (array([[1047.12695364],\n", + " [ 484.6740583 ]]),\n", + " 54,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", + " (array([[1002.46272384],\n", + " [ 484.31696652]]),\n", + " 39,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", + " (array([[1010.71649702],\n", + " [ 479.87881576]]),\n", + " 42,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", + " (array([[1210.01934407],\n", + " [ 494.03980348]]),\n", + " 73,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", + " (array([[1037.64440365],\n", + " [ 485.28759545]]),\n", + " 53,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", + " (array([[1036.23559434],\n", + " [ 486.25656766]]),\n", + " 52,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", + " (array([[1076.72507179],\n", + " [ 484.90549517]]),\n", + " 62,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", + " (array([[1020.96163987],\n", + " [ 477.76954191]]),\n", + " 47,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", + " (array([[1068.23917735],\n", + " [ 485.80007845]]),\n", + " 60,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", + " (array([[1031.63789187],\n", + " [ 484.77852341]]),\n", + " 50,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", + " (array([[1069.68558263],\n", + " [ 484.01888514]]),\n", + " 61,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", + " (array([[1145.83542952],\n", + " [ 479.25758429]]),\n", + " 70,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", + " (array([[1044.36701504],\n", + " [ 481.95704183]]),\n", + " 55,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", + " (array([[1126.44358568],\n", + " [ 477.54788705]]),\n", + " 68,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", + " (array([[1056.79025607],\n", + " [ 483.88709557]]),\n", + " 58,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", + " (array([[1077.03285548],\n", + " [ 482.20505195]]),\n", + " 63,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", + " (array([[1235.64570048],\n", + " [ 485.90257814]]),\n", + " 76,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", + " (array([[1107.2631576 ],\n", + " [ 475.78380042]]),\n", + " 66,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", + " (array([[1134.88649615],\n", + " [ 476.94629608]]),\n", + " 69,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", + " (array([[1155.69880544],\n", + " [ 480.3062664 ]]),\n", + " 71,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", + " (array([[1204.73964037],\n", + " [ 487.43842273]]),\n", + " 74,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", + " (array([[1246.02626603],\n", + " [ 481.22067212]]),\n", + " 77,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", + " (array([[922.00010689],\n", + " [472.67203471]]),\n", + " 8,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", + " (array([[940.5647077 ],\n", + " [474.24784432]]),\n", + " 16,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", + " (array([[961.45825644],\n", + " [474.01647342]]),\n", + " 24,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", + " (array([[977.37497128],\n", + " [472.40847329]]),\n", + " 32,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", + " (array([[997.79435884],\n", + " [474.70601541]]),\n", + " 40,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", + " (array([[1017.00024729],\n", + " [ 472.6674407 ]]),\n", + " 48,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", + " (array([[1039.94523972],\n", + " [ 476.50711637]]),\n", + " 56,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", + " (array([[1078.03474236],\n", + " [ 474.54004563]]),\n", + " 64,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", + " (array([[1160.89335581],\n", + " [ 479.16472624]]),\n", + " 72,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg')],\n", + " [(array([[1334.16979537],\n", + " [ 493.48926404]]),\n", + " 3,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", + " (array([[1389.60755336],\n", + " [ 485.95275086]]),\n", + " 11,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", + " (array([[1470.77193941],\n", + " [ 495.71643221]]),\n", + " 19,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", + " (array([[1548.27356027],\n", + " [ 500.51362509]]),\n", + " 27,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", + " (array([[1642.85448264],\n", + " [ 507.30413337]]),\n", + " 35,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", + " (array([[1760.24523066],\n", + " [ 515.63831002]]),\n", + " 43,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", + " (array([[1897.33083499],\n", + " [ 523.00173243]]),\n", + " 51,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", + " (array([[1376.19772933],\n", + " [ 490.80399168]]),\n", + " 9,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", + " (array([[2075.6571339 ],\n", + " [ 522.61659173]]),\n", + " 59,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", + " (array([[1445.29563971],\n", + " [ 496.52099834]]),\n", + " 17,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", + " (array([[1352.32684059],\n", + " [ 497.75699612]]),\n", + " 6,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", + " (array([[2393.29064509],\n", + " [ 529.51636201]]),\n", + " 67,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", + " (array([[1530.51347196],\n", + " [ 499.61402755]]),\n", + " 25,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", + " (array([[1345.12820372],\n", + " [ 495.37813703]]),\n", + " 5,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", + " (array([[1341.92599337],\n", + " [ 494.29400633]]),\n", + " 4,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", + " (array([[1416.84743349],\n", + " [ 499.36593517]]),\n", + " 14,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", + " (array([[3011.48790978],\n", + " [ 591.40059152]]),\n", + " 75,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", + " (array([[1620.64435252],\n", + " [ 500.71280516]]),\n", + " 33,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", + " (array([[1402.15653753],\n", + " [ 484.87944081]]),\n", + " 12,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", + " (array([[1325.83104851],\n", + " [ 491.6046804 ]]),\n", + " 2,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", + " (array([[1413.84427991],\n", + " [ 493.51395695]]),\n", + " 13,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", + " (array([[1502.82124408],\n", + " [ 491.94671952]]),\n", + " 22,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", + " (array([[4317.88373012],\n", + " [ 682.66609454]]),\n", + " 83,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", + " (array([[1364.33015867],\n", + " [ 492.59905384]]),\n", + " 7,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", + " (array([[1728.92213851],\n", + " [ 507.27762602]]),\n", + " 41,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", + " (array([[1387.83510571],\n", + " [ 483.2583813 ]]),\n", + " 10,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", + " (array([[1479.63500628],\n", + " [ 489.98387408]]),\n", + " 20,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", + " (array([[1491.1559859 ],\n", + " [ 489.82201559]]),\n", + " 21,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", + " (array([[9594.35568768],\n", + " [ 945.56135116]]),\n", + " 91,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", + " (array([[1582.98473398],\n", + " [ 493.56513366]]),\n", + " 30,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", + " (array([[1428.08384597],\n", + " [ 498.40077564]]),\n", + " 15,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", + " (array([[1869.34924517],\n", + " [ 510.81523434]]),\n", + " 49,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", + " (array([[1459.96998365],\n", + " [ 490.40090111]]),\n", + " 18,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", + " (array([[1563.68231708],\n", + " [ 493.02887577]]),\n", + " 28,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", + " (array([[1569.09036905],\n", + " [ 492.78240389]]),\n", + " 29,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", + " (array([[-12238.19076291],\n", + " [ -144.07861326]]),\n", + " 99,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", + " (array([[1686.02077303],\n", + " [ 506.88934867]]),\n", + " 38,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", + " (array([[1508.7854986],\n", + " [ 490.7448899]]),\n", + " 23,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", + " (array([[2033.35649489],\n", + " [ 513.35732523]]),\n", + " 57,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", + " (array([[1537.54571042],\n", + " [ 494.99734007]]),\n", + " 26,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", + " (array([[1661.09242073],\n", + " [ 501.79415069]]),\n", + " 36,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", + " (array([[1677.67386782],\n", + " [ 505.40240369]]),\n", + " 37,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", + " (array([[-2925.00023239],\n", + " [ 296.08977734]]),\n", + " 107,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", + " (array([[1812.61285953],\n", + " [ 506.08001214]]),\n", + " 46,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", + " (array([[1598.73880054],\n", + " [ 492.88145461]]),\n", + " 31,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", + " (array([[2266.47228454],\n", + " [ 514.49394135]]),\n", + " 65,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", + " (array([[1791.08725428],\n", + " [ 506.02278007]]),\n", + " 45,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", + " (array([[1637.10090392],\n", + " [ 497.88481392]]),\n", + " 34,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", + " (array([[1771.86281293],\n", + " [ 506.88654903]]),\n", + " 44,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", + " (array([[-1363.81150452],\n", + " [ 355.52916609]]),\n", + " 115,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", + " (array([[1962.54291572],\n", + " [ 509.41859226]]),\n", + " 54,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", + " (array([[1702.22784546],\n", + " [ 505.64373375]]),\n", + " 39,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", + " (array([[1746.25830208],\n", + " [ 503.20066242]]),\n", + " 42,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", + " (array([[2854.00303732],\n", + " [ 565.06263934]]),\n", + " 73,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", + " (array([[1933.46987609],\n", + " [ 512.57180642]]),\n", + " 53,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", + " (array([[1922.11099072],\n", + " [ 513.56712329]]),\n", + " 52,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", + " (array([[-567.98454982],\n", + " [ 388.10676481]]),\n", + " 123,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", + " (array([[2163.40351815],\n", + " [ 511.5050439 ]]),\n", + " 62,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", + " (array([[1823.17879224],\n", + " [ 505.78272028]]),\n", + " 47,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", + " (array([[-145.07626078],\n", + " [ 414.46314962]]),\n", + " 131,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", + " (array([[2111.1669045 ],\n", + " [ 512.84402673]]),\n", + " 60,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", + " (array([[3798.54962833],\n", + " [ 624.85418045]]),\n", + " 81,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", + " (array([[1880.44069966],\n", + " [ 509.36844547]]),\n", + " 50,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", + " (array([[2144.73212933],\n", + " [ 510.90938868]]),\n", + " 61,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", + " (array([[2560.07702842],\n", + " [ 528.20516066]]),\n", + " 70,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", + " (array([[1988.84696259],\n", + " [ 505.46746716]]),\n", + " 55,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", + " (array([[130.92177054],\n", + " [428.92178532]]),\n", + " 139,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939412460.jpg'),\n", + " (array([[7293.34115056],\n", + " [ 792.3444933 ]]),\n", + " 89,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", + " (array([[2457.5287999 ],\n", + " [ 516.96803273]]),\n", + " 68,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", + " (array([[2063.26422439],\n", + " [ 509.6815062 ]]),\n", + " 58,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", + " (array([[3330.0081002 ],\n", + " [ 596.41740393]]),\n", + " 78,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", + " (array([[2203.46101926],\n", + " [ 508.61030103]]),\n", + " 63,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", + " (array([[333.95815299],\n", + " [441.12677003]]),\n", + " 147,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940112460.jpg'),\n", + " (array([[-69966.13634961],\n", + " [ -2624.25124688]]),\n", + " 97,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", + " (array([[3139.45357837],\n", + " [ 573.76584115]]),\n", + " 76,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", + " (array([[2370.53631674],\n", + " [ 506.56923971]]),\n", + " 66,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", + " (array([[5351.9065425 ],\n", + " [ 691.95122916]]),\n", + " 86,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", + " (array([[2523.66139327],\n", + " [ 515.02200911]]),\n", + " 69,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", + " (array([[2636.04357223],\n", + " [ 525.66517185]]),\n", + " 71,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", + " (array([[451.52660173],\n", + " [453.69674391]]),\n", + " 155,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940762460.jpg'),\n", + " (array([[-4093.63228511],\n", + " [ 284.4593147 ]]),\n", + " 105,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", + " (array([[4483.11890656],\n", + " [ 660.74145848]]),\n", + " 84,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", + " (array([[2962.66127612],\n", + " [ 561.41081276]]),\n", + " 74,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", + " (array([[20942.22139975],\n", + " [ 1454.51329296]]),\n", + " 94,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", + " (array([[3266.78930893],\n", + " [ 578.92530151]]),\n", + " 77,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", + " (array([[3487.22347614],\n", + " [ 600.72924161]]),\n", + " 79,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", + " (array([[-1619.45202977],\n", + " [ 355.50597896]]),\n", + " 113,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", + " (array([[4035.06660466],\n", + " [ 630.34044678]]),\n", + " 82,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", + " (array([[12207.23830769],\n", + " [ 1000.5532177 ]]),\n", + " 92,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", + " (array([[-6300.16659239],\n", + " [ 233.54078401]]),\n", + " 102,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", + " (array([[4875.12621787],\n", + " [ 655.29112104]]),\n", + " 85,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", + " (array([[5664.43152995],\n", + " [ 681.31183935]]),\n", + " 87,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", + " (array([[1368.82648762],\n", + " [ 480.16483794]]),\n", + " 8,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", + " (array([[-753.43177409],\n", + " [ 405.09449463]]),\n", + " 121,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", + " (array([[-8983.72916493],\n", + " [ 133.20002434]]),\n", + " 100,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", + " (array([[7916.39739189],\n", + " [ 757.05111925]]),\n", + " 90,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", + " (array([[-2161.74657547],\n", + " [ 358.75709785]]),\n", + " 110,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", + " (array([[14208.21780603],\n", + " [ 1061.56632332]]),\n", + " 93,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", + " (array([[42552.56376655],\n", + " [ 2267.71507133]]),\n", + " 95,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", + " (array([[1440.58800669],\n", + " [ 483.87063008]]),\n", + " 16,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", + " (array([[-222.39598983],\n", + " [ 425.6985173 ]]),\n", + " 129,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", + " (array([[-18436.94401485],\n", + " [ -235.5205374 ]]),\n", + " 98,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", + " (array([[-2578.06191916],\n", + " [ 343.04277949]]),\n", + " 108,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", + " (array([[-1023.57393281],\n", + " [ 399.82420292]]),\n", + " 118,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", + " (array([[-7836.77073098],\n", + " [ 138.25218443]]),\n", + " 101,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", + " (array([[-5189.77143902],\n", + " [ 260.75404376]]),\n", + " 103,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", + " (array([[1521.2716716 ],\n", + " [ 483.23220441]]),\n", + " 24,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", + " (array([[ 78.46477317],\n", + " [434.96990542]]),\n", + " 137,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939262460.jpg'),\n", + " (array([[-3277.91348066],\n", + " [ 327.94114822]]),\n", + " 106,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", + " (array([[-1213.06720401],\n", + " [ 390.28448983]]),\n", + " 116,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", + " (array([[-378.33978788],\n", + " [ 413.42766334]]),\n", + " 126,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", + " (array([[-2419.97507212],\n", + " [ 352.40817858]]),\n", + " 109,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", + " (array([[-1918.1589017 ],\n", + " [ 365.92921522]]),\n", + " 111,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", + " (array([[1606.27469037],\n", + " [ 482.52891178]]),\n", + " 32,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", + " (array([[287.73359917],\n", + " [448.18425998]]),\n", + " 145,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939912460.jpg'),\n", + " (array([[-522.75388602],\n", + " [ 406.18971018]]),\n", + " 124,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", + " (array([[-1434.25279245],\n", + " [ 376.55102695]]),\n", + " 114,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", + " (array([[-22.48286438],\n", + " [434.55579559]]),\n", + " 134,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", + " (array([[-1080.19515163],\n", + " [ 401.79323176]]),\n", + " 117,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", + " (array([[-899.47614155],\n", + " [ 404.76404864]]),\n", + " 119,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", + " (array([[1720.6520529 ],\n", + " [ 493.31603142]]),\n", + " 40,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", + " (array([[431.39198808],\n", + " [458.2796738 ]]),\n", + " 153,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940612460.jpg'),\n", + " (array([[-650.44814099],\n", + " [ 403.49307083]]),\n", + " 122,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", + " (array([[-89.85205983],\n", + " [430.33395088]]),\n", + " 132,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", + " (array([[216.74693445],\n", + " [442.68513306]]),\n", + " 142,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939662460.jpg'),\n", + " (array([[-445.77973144],\n", + " [ 408.4382094 ]]),\n", + " 125,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", + " (array([[-342.31834094],\n", + " [ 420.26612689]]),\n", + " 127,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", + " (array([[1846.94446799],\n", + " [ 493.05089978]]),\n", + " 48,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", + " (array([[169.57565732],\n", + " [442.73277221]]),\n", + " 140,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939512460.jpg'),\n", + " (array([[-191.06916079],\n", + " [ 429.02591036]]),\n", + " 130,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", + " (array([[388.25724418],\n", + " [454.35308079]]),\n", + " 150,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940362460.jpg'),\n", + " (array([[-65.45392737],\n", + " [432.01765423]]),\n", + " 133,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", + " (array([[ 21.43047226],\n", + " [437.17051819]]),\n", + " 135,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", + " (array([[2006.16722985],\n", + " [ 493.30799461]]),\n", + " 56,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", + " (array([[348.7058409 ],\n", + " [443.06805837]]),\n", + " 148,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940162460.jpg'),\n", + " (array([[118.7280442 ],\n", + " [430.55182668]]),\n", + " 138,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939362460.jpg'),\n", + " (array([[202.3961626 ],\n", + " [435.16995854]]),\n", + " 141,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939612460.jpg'),\n", + " (array([[248.5355029 ],\n", + " [437.39155296]]),\n", + " 143,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939762460.jpg'),\n", + " (array([[2248.70178961],\n", + " [ 506.221173 ]]),\n", + " 64,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", + " (array([[315.31144454],\n", + " [441.12962301]]),\n", + " 146,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940012460.jpg'),\n", + " (array([[369.41877395],\n", + " [446.07508479]]),\n", + " 149,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940262460.jpg'),\n", + " (array([[401.26194107],\n", + " [444.39420303]]),\n", + " 151,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940412460.jpg'),\n", + " (array([[442.9872553 ],\n", + " [447.95230563]]),\n", + " 154,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940662460.jpg'),\n", + " (array([[2728.33435883],\n", + " [ 548.82053864]]),\n", + " 72,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", + " (array([[3713.89406241],\n", + " [ 623.64019153]]),\n", + " 80,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", + " (array([[6488.83020511],\n", + " [ 773.86342525]]),\n", + " 88,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", + " (array([[129029.85593204],\n", + " [ 7283.41587246]]),\n", + " 96,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", + " (array([[-4710.86829419],\n", + " [ 207.64534486]]),\n", + " 104,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", + " (array([[-1797.38359356],\n", + " [ 331.03228852]]),\n", + " 112,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", + " (array([[-787.26255686],\n", + " [ 380.07590207]]),\n", + " 120,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", + " (array([[-275.43111362],\n", + " [ 407.26954167]]),\n", + " 128,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg'),\n", + " (array([[ 43.84479905],\n", + " [420.4169285 ]]),\n", + " 136,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939162460.jpg'),\n", + " (array([[277.88184704],\n", + " [432.93068991]]),\n", + " 144,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939862460.jpg'),\n", + " (array([[416.99732922],\n", + " [443.16100883]]),\n", + " 152,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940512460.jpg')],\n", + " [(array([[1763.74207816],\n", + " [ 488.75530756]]),\n", + " 11,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", + " (array([[1892.95478697],\n", + " [ 498.58501738]]),\n", + " 19,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", + " (array([[2020.85969582],\n", + " [ 503.13634373]]),\n", + " 27,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", + " (array([[2177.98709899],\n", + " [ 512.16221042]]),\n", + " 35,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", + " (array([[2377.69688921],\n", + " [ 525.4518165 ]]),\n", + " 43,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", + " (array([[2613.21251487],\n", + " [ 534.63957799]]),\n", + " 51,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", + " (array([[1740.87298894],\n", + " [ 494.99210676]]),\n", + " 9,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", + " (array([[2931.96478894],\n", + " [ 531.17885458]]),\n", + " 59,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", + " (array([[1851.32888774],\n", + " [ 502.00627597]]),\n", + " 17,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", + " (array([[3538.52362835],\n", + " [ 545.72762104]]),\n", + " 67,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", + " (array([[1989.66255824],\n", + " [ 503.89735014]]),\n", + " 25,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", + " (array([[1804.81774341],\n", + " [ 505.86149015]]),\n", + " 14,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", + " (array([[4935.16773879],\n", + " [ 663.00431348]]),\n", + " 75,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", + " (array([[2137.5242432 ],\n", + " [ 507.71634757]]),\n", + " 33,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", + " (array([[1781.02557493],\n", + " [ 490.00894965]]),\n", + " 12,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", + " (array([[1798.2486935 ],\n", + " [ 500.85939795]]),\n", + " 13,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", + " (array([[1940.82610603],\n", + " [ 499.54410959]]),\n", + " 22,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", + " (array([[9514.57398517],\n", + " [ 916.34303143]]),\n", + " 83,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", + " (array([[2317.65746164],\n", + " [ 520.49070056]]),\n", + " 41,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", + " (array([[1756.9517107 ],\n", + " [ 488.92259755]]),\n", + " 10,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", + " (array([[1903.00167391],\n", + " [ 496.36090558]]),\n", + " 20,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", + " (array([[1921.77493295],\n", + " [ 496.82842557]]),\n", + " 21,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", + " (array([[-36621.82542885],\n", + " [ -1257.58193908]]),\n", + " 91,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", + " (array([[2073.89641794],\n", + " [ 500.57406419]]),\n", + " 30,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", + " (array([[1821.74806672],\n", + " [ 505.78587025]]),\n", + " 15,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", + " (array([[2559.38070834],\n", + " [ 524.68969179]]),\n", + " 49,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", + " (array([[1871.89371681],\n", + " [ 497.25430072]]),\n", + " 18,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", + " (array([[2041.81835793],\n", + " [ 499.51131208]]),\n", + " 28,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", + " (array([[2051.04210295],\n", + " [ 499.48054539]]),\n", + " 29,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", + " (array([[-4313.60591745],\n", + " [ 268.94391563]]),\n", + " 99,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", + " (array([[2245.26288265],\n", + " [ 518.65685678]]),\n", + " 38,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", + " (array([[1950.73800879],\n", + " [ 498.22042082]]),\n", + " 23,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", + " (array([[2849.73481313],\n", + " [ 526.7416395 ]]),\n", + " 57,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", + " (array([[1998.61011535],\n", + " [ 502.41004311]]),\n", + " 26,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", + " (array([[2203.35427615],\n", + " [ 511.63469261]]),\n", + " 36,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", + " (array([[2231.21438747],\n", + " [ 516.38709993]]),\n", + " 37,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", + " (array([[-1860.08798675],\n", + " [ 365.10725419]]),\n", + " 107,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", + " (array([[2461.23985853],\n", + " [ 523.12756367]]),\n", + " 46,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", + " (array([[2099.77062281],\n", + " [ 501.42215792]]),\n", + " 31,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", + " (array([[3281.6401809 ],\n", + " [ 531.81146748]]),\n", + " 65,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", + " (array([[2424.44982309],\n", + " [ 521.76912184]]),\n", + " 45,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", + " (array([[2163.35587354],\n", + " [ 507.35929852]]),\n", + " 34,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", + " (array([[2391.49015951],\n", + " [ 522.47083636]]),\n", + " 44,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", + " (array([[-959.45746244],\n", + " [ 389.29450515]]),\n", + " 115,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", + " (array([[2723.53544638],\n", + " [ 522.66571441]]),\n", + " 54,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", + " (array([[2272.90321836],\n", + " [ 518.00723333]]),\n", + " 39,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", + " (array([[2347.56498482],\n", + " [ 516.93477507]]),\n", + " 42,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", + " (array([[4539.15667046],\n", + " [ 621.95696956]]),\n", + " 73,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", + " (array([[2672.15694402],\n", + " [ 527.00003925]]),\n", + " 53,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", + " (array([[2652.17165248],\n", + " [ 528.3117112 ]]),\n", + " 52,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", + " (array([[3087.43457102],\n", + " [ 524.06276373]]),\n", + " 62,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", + " (array([[2479.61355242],\n", + " [ 522.03143801]]),\n", + " 47,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", + " (array([[2991.26265631],\n", + " [ 527.91736896]]),\n", + " 60,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", + " (array([[7327.22838477],\n", + " [ 772.40140606]]),\n", + " 81,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", + " (array([[2579.18421002],\n", + " [ 522.48760148]]),\n", + " 50,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", + " (array([[3053.09386843],\n", + " [ 522.99741821]]),\n", + " 61,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", + " (array([[3875.53260913],\n", + " [ 559.15050497]]),\n", + " 70,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", + " (array([[2770.56657145],\n", + " [ 517.52730467]]),\n", + " 55,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", + " (array([[132254.2032417 ],\n", + " [ 6158.68390686]]),\n", + " 89,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", + " (array([[3660.95311091],\n", + " [ 539.29516287]]),\n", + " 68,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", + " (array([[2904.18884418],\n", + " [ 521.60636136]]),\n", + " 58,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", + " (array([[5789.91253648],\n", + " [ 701.72285637]]),\n", + " 78,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", + " (array([[3162.52267533],\n", + " [ 524.99144491]]),\n", + " 63,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", + " (array([[-6391.61821153],\n", + " [ 193.53107951]]),\n", + " 97,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", + " (array([[5262.7180265 ],\n", + " [ 659.72962111]]),\n", + " 76,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", + " (array([[3485.74724745],\n", + " [ 524.91694819]]),\n", + " 66,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", + " (array([[16822.49226445],\n", + " [ 1175.80247164]]),\n", + " 86,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", + " (array([[3798.12983269],\n", + " [ 547.23573123]]),\n", + " 69,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", + " (array([[4040.12495322],\n", + " [ 565.55649331]]),\n", + " 71,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", + " (array([[-2377.75777919],\n", + " [ 360.98452645]]),\n", + " 105,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", + " (array([[10370.51964984],\n", + " [ 911.4085527 ]]),\n", + " 84,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", + " (array([[4806.81279094],\n", + " [ 625.96055907]]),\n", + " 74,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", + " (array([[-11324.38673545],\n", + " [ -57.68882787]]),\n", + " 94,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", + " (array([[5610.9021139 ],\n", + " [ 676.52250281]]),\n", + " 77,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", + " (array([[6264.93143316],\n", + " [ 722.01644412]]),\n", + " 79,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", + " (array([[-1126.20070455],\n", + " [ 388.96701439]]),\n", + " 113,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", + " (array([[8250.18752709],\n", + " [ 798.73996873]]),\n", + " 82,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", + " (array([[-19447.78759865],\n", + " [ -246.11616834]]),\n", + " 92,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", + " (array([[-3124.8464056 ],\n", + " [ 359.99726503]]),\n", + " 102,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", + " (array([[12756.44898788],\n", + " [ 950.59444144]]),\n", + " 85,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", + " (array([[20450.50664954],\n", + " [ 1210.62916507]]),\n", + " 87,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", + " (array([[1727.04328133],\n", + " [ 485.40808072]]),\n", + " 8,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", + " (array([[-3768.3860499 ],\n", + " [ 336.67076915]]),\n", + " 100,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", + " (array([[-455607.76616045],\n", + " [ -15126.82302646]]),\n", + " 90,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", + " (array([[-1465.8831346 ],\n", + " [ 399.94266756]]),\n", + " 110,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", + " (array([[-16147.20037523],\n", + " [ -172.90966267]]),\n", + " 93,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", + " (array([[-8877.29023712],\n", + " [ 118.01071518]]),\n", + " 95,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", + " (array([[1840.41773096],\n", + " [ 488.65592437]]),\n", + " 16,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", + " (array([[-5045.30355218],\n", + " [ 302.59473363]]),\n", + " 98,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", + " (array([[-1708.12294312],\n", + " [ 396.10998098]]),\n", + " 108,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", + " (array([[-736.40159547],\n", + " [ 424.43457679]]),\n", + " 118,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", + " (array([[-3581.68530432],\n", + " [ 336.61371396]]),\n", + " 101,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", + " (array([[-2830.74303286],\n", + " [ 369.32132877]]),\n", + " 103,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", + " (array([[1968.03195486],\n", + " [ 486.2022638 ]]),\n", + " 24,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", + " (array([[-2073.93215781],\n", + " [ 390.39045714]]),\n", + " 106,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", + " (array([[-877.96671195],\n", + " [ 416.85619328]]),\n", + " 116,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", + " (array([[-1635.53637171],\n", + " [ 397.28191752]]),\n", + " 109,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", + " (array([[-1342.61625807],\n", + " [ 402.01506971]]),\n", + " 111,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", + " (array([[2105.69317403],\n", + " [ 486.68475955]]),\n", + " 32,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", + " (array([[-1022.08777965],\n", + " [ 408.20514969]]),\n", + " 114,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", + " (array([[-778.06833532],\n", + " [ 425.56365574]]),\n", + " 117,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", + " (array([[2299.39969253],\n", + " [ 500.76242296]]),\n", + " 40,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", + " (array([[2514.06274935],\n", + " [ 501.16637483]]),\n", + " 48,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", + " (array([[2791.21131186],\n", + " [ 497.54223391]]),\n", + " 56,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", + " (array([[3232.04582849],\n", + " [ 500.36443283]]),\n", + " 64,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", + " (array([[4224.21766772],\n", + " [ 550.21853486]]),\n", + " 72,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", + " (array([[6934.54180159],\n", + " [ 687.3439066 ]]),\n", + " 80,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", + " (array([[35771.62818619],\n", + " [ 1664.9352707 ]]),\n", + " 88,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", + " (array([[-7807.94818485],\n", + " [ 175.80841311]]),\n", + " 96,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", + " (array([[-2646.02351496],\n", + " [ 381.48005719]]),\n", + " 104,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", + " (array([[-1254.17646691],\n", + " [ 406.91481689]]),\n", + " 112,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg')],\n", + " [(array([[496.18281536],\n", + " [463.85992363]]),\n", + " 19,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", + " (array([[476.49463914],\n", + " [466.94515188]]),\n", + " 27,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", + " (array([[459.66755016],\n", + " [466.316318 ]]),\n", + " 35,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", + " (array([[433.6610762 ],\n", + " [460.94503912]]),\n", + " 43,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", + " (array([[407.4289932 ],\n", + " [469.27009466]]),\n", + " 51,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", + " (array([[382.40186933],\n", + " [470.40659959]]),\n", + " 59,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", + " (array([[497.55337676],\n", + " [462.6833628 ]]),\n", + " 17,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", + " (array([[370.93339852],\n", + " [460.43657268]]),\n", + " 67,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", + " (array([[481.87636102],\n", + " [466.70652884]]),\n", + " 25,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", + " (array([[406.84031694],\n", + " [459.5297565 ]]),\n", + " 75,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", + " (array([[462.95097165],\n", + " [464.20738515]]),\n", + " 33,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", + " (array([[489.76752838],\n", + " [461.48739452]]),\n", + " 22,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", + " (array([[475.79693965],\n", + " [478.56675564]]),\n", + " 83,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", + " (array([[442.23487292],\n", + " [461.99665657]]),\n", + " 41,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", + " (array([[495.28620834],\n", + " [462.72053116]]),\n", + " 20,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", + " (array([[492.58784877],\n", + " [460.96731042]]),\n", + " 21,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", + " (array([[602.39049608],\n", + " [482.22012502]]),\n", + " 91,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", + " (array([[467.88649686],\n", + " [463.39908691]]),\n", + " 30,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", + " (array([[498.75713026],\n", + " [469.95502078]]),\n", + " 15,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", + " (array([[415.31179251],\n", + " [464.85581635]]),\n", + " 49,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", + " (array([[496.80325486],\n", + " [463.00912525]]),\n", + " 18,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", + " (array([[472.92469507],\n", + " [465.43215304]]),\n", + " 28,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", + " (array([[470.53785151],\n", + " [464.61581408]]),\n", + " 29,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", + " (array([[775.082835 ],\n", + " [494.97539469]]),\n", + " 99,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", + " (array([[450.9875994 ],\n", + " [467.47865277]]),\n", + " 38,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", + " (array([[488.42184553],\n", + " [462.29659685]]),\n", + " 23,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", + " (array([[387.86190422],\n", + " [468.96121586]]),\n", + " 57,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", + " (array([[479.30576531],\n", + " [466.38049888]]),\n", + " 26,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", + " (array([[455.95108964],\n", + " [466.81154065]]),\n", + " 36,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", + " (array([[452.74303946],\n", + " [467.77553433]]),\n", + " 37,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", + " (array([[978.09655538],\n", + " [503.79155885]]),\n", + " 107,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", + " (array([[423.52832555],\n", + " [455.77240407]]),\n", + " 46,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", + " (array([[466.56513084],\n", + " [462.18013267]]),\n", + " 31,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", + " (array([[370.19421807],\n", + " [464.15716344]]),\n", + " 65,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", + " (array([[426.35411352],\n", + " [458.50430043]]),\n", + " 45,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", + " (array([[460.22150667],\n", + " [464.86860759]]),\n", + " 34,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", + " (array([[430.47784105],\n", + " [459.46570713]]),\n", + " 44,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", + " (array([[1215.13005351],\n", + " [ 517.49788667]]),\n", + " 115,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", + " (array([[397.50296496],\n", + " [466.25785007]]),\n", + " 54,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", + " (array([[446.98571284],\n", + " [465.42968722]]),\n", + " 39,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", + " (array([[438.11333101],\n", + " [459.80872805]]),\n", + " 42,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", + " (array([[396.23498697],\n", + " [460.47433988]]),\n", + " 73,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", + " (array([[399.52293397],\n", + " [466.5763337 ]]),\n", + " 53,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", + " (array([[402.26658748],\n", + " [466.79087166]]),\n", + " 52,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", + " (array([[1591.0519044 ],\n", + " [ 542.90095551]]),\n", + " 123,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", + " (array([[374.16741569],\n", + " [468.75568146]]),\n", + " 62,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", + " (array([[421.73899527],\n", + " [456.18090882]]),\n", + " 47,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", + " (array([[2172.48155924],\n", + " [ 584.03382768]]),\n", + " 131,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", + " (array([[379.26192413],\n", + " [467.77162128]]),\n", + " 60,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", + " (array([[450.44006275],\n", + " [463.21764733]]),\n", + " 81,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", + " (array([[413.5389048 ],\n", + " [465.77719625]]),\n", + " 50,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", + " (array([[375.5292233 ],\n", + " [468.51821205]]),\n", + " 61,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", + " (array([[377.88448708],\n", + " [454.79052143]]),\n", + " 70,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", + " (array([[392.71893971],\n", + " [465.89722061]]),\n", + " 55,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", + " (array([[3446.72625743],\n", + " [ 678.55712222]]),\n", + " 139,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939412460.jpg'),\n", + " (array([[568.99472662],\n", + " [477.88762346]]),\n", + " 89,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", + " (array([[372.3838071 ],\n", + " [456.44599892]]),\n", + " 68,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", + " (array([[384.29850356],\n", + " [467.14670988]]),\n", + " 58,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", + " (array([[423.41132742],\n", + " [445.18106383]]),\n", + " 78,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", + " (array([[372.46862174],\n", + " [465.3473438 ]]),\n", + " 63,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", + " (array([[11227.41465461],\n", + " [ 1305.10013652]]),\n", + " 147,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940112460.jpg'),\n", + " (array([[715.72998884],\n", + " [487.12567927]]),\n", + " 97,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", + " (array([[415.06628304],\n", + " [448.59715109]]),\n", + " 76,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", + " (array([[370.96347352],\n", + " [456.40599274]]),\n", + " 66,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", + " (array([[518.69997983],\n", + " [477.35519051]]),\n", + " 86,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", + " (array([[375.43229966],\n", + " [452.79479456]]),\n", + " 69,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", + " (array([[382.81785704],\n", + " [453.50096693]]),\n", + " 71,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", + " (array([[-8661.35074283],\n", + " [ -197.1535286 ]]),\n", + " 155,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940762460.jpg'),\n", + " (array([[907.6447258 ],\n", + " [491.59508477]]),\n", + " 105,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", + " (array([[483.95451641],\n", + " [471.52928793]]),\n", + " 84,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", + " (array([[404.55214183],\n", + " [454.33382663]]),\n", + " 74,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", + " (array([[658.34965994],\n", + " [479.07352025]]),\n", + " 94,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", + " (array([[421.08909984],\n", + " [441.56446508]]),\n", + " 77,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", + " (array([[431.8656152 ],\n", + " [447.87492429]]),\n", + " 79,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", + " (array([[-2734.45655963],\n", + " [ 260.1796133 ]]),\n", + " 163,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941412460.jpg'),\n", + " (array([[1153.74928516],\n", + " [ 503.33900289]]),\n", + " 113,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", + " (array([[462.23794051],\n", + " [466.70003803]]),\n", + " 82,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", + " (array([[625.31197923],\n", + " [475.08022179]]),\n", + " 92,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", + " (array([[841.15582781],\n", + " [488.46063527]]),\n", + " 102,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", + " (array([[500.76521527],\n", + " [470.06683758]]),\n", + " 85,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", + " (array([[529.6368878 ],\n", + " [475.56384114]]),\n", + " 87,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", + " (array([[-1436.05147365],\n", + " [ 346.44577754]]),\n", + " 171,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942112460.jpg'),\n", + " (array([[1461.48629681],\n", + " [ 538.0783443 ]]),\n", + " 121,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", + " (array([[800.98606836],\n", + " [496.65446411]]),\n", + " 100,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", + " (array([[579.25669381],\n", + " [481.43830195]]),\n", + " 90,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", + " (array([[1058.97458196],\n", + " [ 508.83792699]]),\n", + " 110,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", + " (array([[635.9456918 ],\n", + " [484.05681884]]),\n", + " 93,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", + " (array([[680.06906325],\n", + " [490.96689125]]),\n", + " 95,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", + " (array([[497.92838466],\n", + " [464.25291371]]),\n", + " 16,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", + " (array([[-899.76545175],\n", + " [ 344.68833869]]),\n", + " 179,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942862460.jpg'),\n", + " (array([[2007.0268121 ],\n", + " [ 576.85521896]]),\n", + " 129,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", + " (array([[750.29348443],\n", + " [495.82945376]]),\n", + " 98,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", + " (array([[1009.35579411],\n", + " [ 508.0768722 ]]),\n", + " 108,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", + " (array([[1326.82831576],\n", + " [ 526.8156636 ]]),\n", + " 118,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", + " (array([[814.63323149],\n", + " [498.2230044 ]]),\n", + " 101,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", + " (array([[866.50334676],\n", + " [500.34335557]]),\n", + " 103,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", + " (array([[485.90405022],\n", + " [465.49292095]]),\n", + " 24,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", + " (array([[-630.46524613],\n", + " [ 362.84964447]]),\n", + " 187,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943512460.jpg'),\n", + " (array([[3023.54852619],\n", + " [ 661.75594464]]),\n", + " 137,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939262460.jpg'),\n", + " (array([[951.15005629],\n", + " [503.00903588]]),\n", + " 106,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", + " (array([[1257.87300125],\n", + " [ 524.46586343]]),\n", + " 116,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", + " (array([[1776.3217962],\n", + " [ 558.557604 ]]),\n", + " 126,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", + " (array([[1025.5826839 ],\n", + " [ 509.42714008]]),\n", + " 109,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", + " (array([[1094.30684065],\n", + " [ 511.60477227]]),\n", + " 111,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", + " (array([[465.2184913 ],\n", + " [463.28389066]]),\n", + " 32,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", + " (array([[-433.62019493],\n", + " [ 374.0423058 ]]),\n", + " 195,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944162460.jpg'),\n", + " (array([[6717.13689228],\n", + " [1000.19599524]]),\n", + " 145,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939912460.jpg'),\n", + " (array([[1625.54845926],\n", + " [ 550.19729104]]),\n", + " 124,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", + " (array([[1194.07018947],\n", + " [ 520.63015728]]),\n", + " 114,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", + " (array([[2521.61036646],\n", + " [ 625.08616979]]),\n", + " 134,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", + " (array([[1302.92093841],\n", + " [ 526.65421497]]),\n", + " 117,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", + " (array([[-252.73279498],\n", + " [ 387.90420502]]),\n", + " 203,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944862460.jpg'),\n", + " (array([[1379.75972332],\n", + " [ 530.8646496 ]]),\n", + " 119,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", + " (array([[444.03092218],\n", + " [463.6653 ]]),\n", + " 40,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", + " (array([[-15059.5964565 ],\n", + " [ -859.46319025]]),\n", + " 153,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940612460.jpg'),\n", + " (array([[1524.03221438],\n", + " [ 546.77839957]]),\n", + " 122,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", + " (array([[2302.65599012],\n", + " [ 608.21602364]]),\n", + " 132,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", + " (array([[4517.71248662],\n", + " [ 780.35545653]]),\n", + " 142,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939662460.jpg'),\n", + " (array([[1697.68389592],\n", + " [ 551.51782176]]),\n", + " 125,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", + " (array([[-18.8802986],\n", + " [406.8320526]]),\n", + " 211,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945612460.jpg'),\n", + " (array([[1818.12876218],\n", + " [ 562.60115432]]),\n", + " 127,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", + " (array([[418.32508297],\n", + " [461.53007803]]),\n", + " 48,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", + " (array([[-3320.17910395],\n", + " [ 144.65288942]]),\n", + " 161,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941262460.jpg'),\n", + " (array([[3805.01602597],\n", + " [ 729.5134882 ]]),\n", + " 140,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939512460.jpg'),\n", + " (array([[2059.33663203],\n", + " [ 583.05070675]]),\n", + " 130,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", + " (array([[73955.23359842],\n", + " [ 6910.46595701]]),\n", + " 150,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940362460.jpg'),\n", + " (array([[2371.87839068],\n", + " [ 613.77276832]]),\n", + " 133,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", + " (array([[171.12817965],\n", + " [421.14314383]]),\n", + " 219,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946262460.jpg'),\n", + " (array([[2699.87544436],\n", + " [ 637.06346554]]),\n", + " 135,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", + " (array([[-1673.77575711],\n", + " [ 285.56190938]]),\n", + " 169,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941912460.jpg'),\n", + " (array([[391.51444901],\n", + " [469.49162813]]),\n", + " 56,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", + " (array([[13414.37453518],\n", + " [ 1610.00383145]]),\n", + " 148,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940162460.jpg'),\n", + " (array([[3292.88217027],\n", + " [ 687.05334214]]),\n", + " 138,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939362460.jpg'),\n", + " (array([[-4.86384044e+03],\n", + " [-3.79509297e+00]]),\n", + " 158,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941012460.jpg'),\n", + " (array([[4246.11832954],\n", + " [ 760.65904721]]),\n", + " 141,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939612460.jpg'),\n", + " (array([[5187.02644408],\n", + " [ 836.9545799 ]]),\n", + " 143,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939762460.jpg'),\n", + " (array([[-1010.24112635],\n", + " [ 345.27096062]]),\n", + " 177,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942662460.jpg'),\n", + " (array([[371.30401116],\n", + " [467.23083152]]),\n", + " 64,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", + " (array([[-6674.38830591],\n", + " [ -174.73182256]]),\n", + " 156,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940862460.jpg'),\n", + " (array([[8401.12521356],\n", + " [1171.11946262]]),\n", + " 146,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940012460.jpg'),\n", + " (array([[-2096.4550244 ],\n", + " [ 245.13056004]]),\n", + " 166,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941662460.jpg'),\n", + " (array([[22652.39695226],\n", + " [ 2406.05433003]]),\n", + " 149,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940262460.jpg'),\n", + " (array([[-402576.03237036],\n", + " [ -34515.23620512]]),\n", + " 151,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940412460.jpg'),\n", + " (array([[-687.43041253],\n", + " [ 358.86767905]]),\n", + " 185,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943362460.jpg'),\n", + " (array([[-12179.813863 ],\n", + " [ -615.72964846]]),\n", + " 154,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940662460.jpg'),\n", + " (array([[-2449.41033974],\n", + " [ 220.77187001]]),\n", + " 164,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941512460.jpg'),\n", + " (array([[387.77016942],\n", + " [462.25489149]]),\n", + " 72,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", + " (array([[-1210.90843146],\n", + " [ 323.4719665 ]]),\n", + " 174,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942362460.jpg'),\n", + " (array([[-5936.60980268],\n", + " [ -105.45385588]]),\n", + " 157,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940912460.jpg'),\n", + " (array([[-470.35154346],\n", + " [ 371.79472912]]),\n", + " 193,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944012460.jpg'),\n", + " (array([[-4108.36178014],\n", + " [ 66.62669302]]),\n", + " 159,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941112460.jpg'),\n", + " (array([[-2914.91315006],\n", + " [ 181.15530193]]),\n", + " 162,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941362460.jpg'),\n", + " (array([[-1386.12261807],\n", + " [ 307.69207825]]),\n", + " 172,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942162460.jpg'),\n", + " (array([[-784.89451156],\n", + " [ 357.40811365]]),\n", + " 182,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943112460.jpg'),\n", + " (array([[443.58897827],\n", + " [462.44008028]]),\n", + " 80,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", + " (array([[-2205.65772242],\n", + " [ 236.4667037 ]]),\n", + " 165,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941612460.jpg'),\n", + " (array([[-305.71761644],\n", + " [ 383.46021306]]),\n", + " 201,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944662460.jpg'),\n", + " (array([[-1910.18688809],\n", + " [ 263.75782547]]),\n", + " 167,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941762460.jpg'),\n", + " (array([[-876.60571163],\n", + " [ 343.90858704]]),\n", + " 180,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942912460.jpg'),\n", + " (array([[-1543.98928827],\n", + " [ 297.26406577]]),\n", + " 170,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942012460.jpg'),\n", + " (array([[-551.49508397],\n", + " [ 368.81447106]]),\n", + " 190,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943762460.jpg'),\n", + " (array([[550.01330401],\n", + " [483.97153043]]),\n", + " 88,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", + " (array([[-1293.5346371],\n", + " [ 314.5124184]]),\n", + " 173,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942262460.jpg'),\n", + " (array([[-80.81868022],\n", + " [405.49598538]]),\n", + " 209,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945412460.jpg'),\n", + " (array([[-1102.25296141],\n", + " [ 349.47231291]]),\n", + " 175,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942512460.jpg'),\n", + " (array([[-952.66890749],\n", + " [ 347.96321768]]),\n", + " 178,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942762460.jpg'),\n", + " (array([[-368.76018519],\n", + " [ 379.95068375]]),\n", + " 198,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944412460.jpg'),\n", + " (array([[-592.69839731],\n", + " [ 368.54148687]]),\n", + " 188,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943612460.jpg'),\n", + " (array([[692.0462208 ],\n", + " [490.50873819]]),\n", + " 96,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", + " (array([[-830.47348069],\n", + " [ 357.50802135]]),\n", + " 181,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943012460.jpg'),\n", + " (array([[128.34198747],\n", + " [422.28232653]]),\n", + " 217,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946112460.jpg'),\n", + " (array([[-762.98969359],\n", + " [ 366.55511001]]),\n", + " 183,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943162460.jpg'),\n", + " (array([[-163.74495667],\n", + " [ 396.98058929]]),\n", + " 206,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945162460.jpg'),\n", + " (array([[-669.72029657],\n", + " [ 365.28200584]]),\n", + " 186,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943412460.jpg'),\n", + " (array([[-406.29890442],\n", + " [ 380.48841097]]),\n", + " 196,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944262460.jpg'),\n", + " (array([[880.00717452],\n", + " [497.13722665]]),\n", + " 104,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", + " (array([[-578.16458305],\n", + " [ 375.41494499]]),\n", + " 189,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943662460.jpg'),\n", + " (array([[-518.50143957],\n", + " [ 379.1058063 ]]),\n", + " 191,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943862460.jpg'),\n", + " (array([[ 57.73493549],\n", + " [418.15530496]]),\n", + " 214,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945862460.jpg'),\n", + " (array([[-240.30225704],\n", + " [ 395.73000199]]),\n", + " 204,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944912460.jpg'),\n", + " (array([[-446.03477518],\n", + " [ 381.99908487]]),\n", + " 194,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944112460.jpg'),\n", + " (array([[1113.17991669],\n", + " [ 506.02474981]]),\n", + " 112,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", + " (array([[-380.5401912 ],\n", + " [ 387.31031095]]),\n", + " 197,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944362460.jpg'),\n", + " (array([[-346.14008476],\n", + " [ 388.88389967]]),\n", + " 199,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944512460.jpg'),\n", + " (array([[259.02856992],\n", + " [442.3003301 ]]),\n", + " 222,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946612460.jpg'),\n", + " (array([[ -3.94609605],\n", + " [415.70375607]]),\n", + " 212,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945662460.jpg'),\n", + " (array([[-279.49708865],\n", + " [ 395.36964825]]),\n", + " 202,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944762460.jpg'),\n", + " (array([[1435.11904824],\n", + " [ 525.53461682]]),\n", + " 120,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", + " (array([[-179.78039543],\n", + " [ 402.57885151]]),\n", + " 205,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945112460.jpg'),\n", + " (array([[-132.03142304],\n", + " [ 407.93060442]]),\n", + " 207,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945262460.jpg'),\n", + " (array([[212.49571206],\n", + " [433.60216383]]),\n", + " 220,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946412460.jpg'),\n", + " (array([[-49.48604037],\n", + " [415.99975636]]),\n", + " 210,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945512460.jpg'),\n", + " (array([[1908.30420214],\n", + " [ 559.78343109]]),\n", + " 128,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg'),\n", + " (array([[ 27.31568435],\n", + " [416.99149597]]),\n", + " 213,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945762460.jpg'),\n", + " (array([[ 71.99458805],\n", + " [420.98841768]]),\n", + " 215,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945912460.jpg'),\n", + " (array([[142.4808022 ],\n", + " [426.00374176]]),\n", + " 218,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946162460.jpg'),\n", + " (array([[2799.81542147],\n", + " [ 627.08459402]]),\n", + " 136,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939162460.jpg'),\n", + " (array([[234.99256674],\n", + " [436.47658822]]),\n", + " 221,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946512460.jpg'),\n", + " (array([[271.44681724],\n", + " [440.47068317]]),\n", + " 223,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946662460.jpg'),\n", + " (array([[6111.55804317],\n", + " [ 913.26955674]]),\n", + " 144,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939862460.jpg'),\n", + " (array([[-29530.13363847],\n", + " [ -1967.19821131]]),\n", + " 152,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940512460.jpg'),\n", + " (array([[-3811.8725237 ],\n", + " [ 117.15074743]]),\n", + " 160,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941162460.jpg'),\n", + " (array([[-1748.77979554],\n", + " [ 290.29252257]]),\n", + " 168,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941862460.jpg'),\n", + " (array([[-1039.41933151],\n", + " [ 355.33293558]]),\n", + " 176,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942612460.jpg'),\n", + " (array([[-721.9779478 ],\n", + " [ 366.14795992]]),\n", + " 184,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943262460.jpg'),\n", + " (array([[-500.55957554],\n", + " [ 369.97597621]]),\n", + " 192,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943912478.jpg'),\n", + " (array([[-320.03575805],\n", + " [ 381.67754865]]),\n", + " 200,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944612460.jpg'),\n", + " (array([[-97.74766935],\n", + " [401.8057509 ]]),\n", + " 208,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945362460.jpg'),\n", + " (array([[ 99.77023365],\n", + " [417.05573479]]),\n", + " 216,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946012460.jpg'),\n", + " (array([[296.01801208],\n", + " [439.27876819]]),\n", + " 224,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946762460.jpg')],\n", + " [(array([[649.6149932 ],\n", + " [471.91646019]]),\n", + " 27,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", + " (array([[648.20071706],\n", + " [472.29300028]]),\n", + " 35,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", + " (array([[641.7343638 ],\n", + " [468.83473819]]),\n", + " 43,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", + " (array([[636.23693524],\n", + " [477.03553947]]),\n", + " 51,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", + " (array([[634.77593916],\n", + " [477.53259181]]),\n", + " 59,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", + " (array([[653.00590683],\n", + " [469.48910411]]),\n", + " 67,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", + " (array([[651.45597299],\n", + " [471.53854499]]),\n", + " 25,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", + " (array([[718.59921919],\n", + " [474.03842711]]),\n", + " 75,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", + " (array([[647.8039724 ],\n", + " [469.76220017]]),\n", + " 33,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", + " (array([[653.85511404],\n", + " [466.51532801]]),\n", + " 22,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", + " (array([[818.96589834],\n", + " [495.99009904]]),\n", + " 83,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", + " (array([[644.39425766],\n", + " [468.68128586]]),\n", + " 41,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", + " (array([[654.55777036],\n", + " [465.50663539]]),\n", + " 21,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", + " (array([[980.86973459],\n", + " [499.60658381]]),\n", + " 91,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", + " (array([[646.87393047],\n", + " [468.21504997]]),\n", + " 30,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", + " (array([[639.07585007],\n", + " [471.84493861]]),\n", + " 49,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", + " (array([[648.40519531],\n", + " [469.94925092]]),\n", + " 28,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", + " (array([[647.21925296],\n", + " [468.68415083]]),\n", + " 29,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", + " (array([[1218.9230824 ],\n", + " [ 513.73050319]]),\n", + " 99,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", + " (array([[646.20244182],\n", + " [473.43687865]]),\n", + " 38,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", + " (array([[653.58664561],\n", + " [466.76073354]]),\n", + " 23,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", + " (array([[634.62935036],\n", + " [475.08071841]]),\n", + " 57,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", + " (array([[650.10390622],\n", + " [470.83215121]]),\n", + " 26,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", + " (array([[647.11355557],\n", + " [472.11082346]]),\n", + " 36,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", + " (array([[646.59445889],\n", + " [472.87822819]]),\n", + " 37,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", + " (array([[1538.55294677],\n", + " [ 528.66543613]]),\n", + " 107,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", + " (array([[639.36341628],\n", + " [462.94213021]]),\n", + " 46,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", + " (array([[647.83356415],\n", + " [466.63156713]]),\n", + " 31,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", + " (array([[642.09476744],\n", + " [470.32027307]]),\n", + " 65,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", + " (array([[639.15548597],\n", + " [465.27866661]]),\n", + " 45,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", + " (array([[647.58196548],\n", + " [469.07591639]]),\n", + " 34,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", + " (array([[640.2023731 ],\n", + " [465.91021817]]),\n", + " 44,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", + " (array([[1982.23991748],\n", + " [ 558.64540218]]),\n", + " 115,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", + " (array([[635.0607517 ],\n", + " [471.74286901]]),\n", + " 54,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", + " (array([[645.01335026],\n", + " [470.98515828]]),\n", + " 39,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", + " (array([[643.22028132],\n", + " [465.79010497]]),\n", + " 42,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", + " (array([[702.01476663],\n", + " [470.86065629]]),\n", + " 73,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", + " (array([[633.6866405 ],\n", + " [472.16554278]]),\n", + " 53,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", + " (array([[634.62170696],\n", + " [472.65358564]]),\n", + " 52,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", + " (array([[2965.01413154],\n", + " [ 628.87193337]]),\n", + " 123,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", + " (array([[636.27556295],\n", + " [473.46848882]]),\n", + " 62,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", + " (array([[639.17263024],\n", + " [462.08249758]]),\n", + " 47,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", + " (array([[6046.38747362],\n", + " [ 834.60476062]]),\n", + " 131,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", + " (array([[635.44815736],\n", + " [472.64200681]]),\n", + " 60,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", + " (array([[784.45967737],\n", + " [476.53817625]]),\n", + " 81,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", + " (array([[638.93673639],\n", + " [470.97455595]]),\n", + " 50,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", + " (array([[635.68977244],\n", + " [470.65303199]]),\n", + " 61,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", + " (array([[670.05456849],\n", + " [460.31919857]]),\n", + " 70,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", + " (array([[634.07295077],\n", + " [468.58998417]]),\n", + " 55,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", + " (array([[-25681.64238025],\n", + " [ -1271.57732744]]),\n", + " 139,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939412460.jpg'),\n", + " (array([[938.23425767],\n", + " [489.0890268 ]]),\n", + " 89,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", + " (array([[658.67977669],\n", + " [460.73896358]]),\n", + " 68,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", + " (array([[634.88469456],\n", + " [467.86819608]]),\n", + " 58,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", + " (array([[746.56079918],\n", + " [455.53355222]]),\n", + " 78,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", + " (array([[638.57774615],\n", + " [466.98931604]]),\n", + " 63,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", + " (array([[-3111.22311578],\n", + " [ 209.78280866]]),\n", + " 147,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940112460.jpg'),\n", + " (array([[1134.06334552],\n", + " [ 496.85451892]]),\n", + " 97,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", + " (array([[731.48155992],\n", + " [454.61231388]]),\n", + " 76,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", + " (array([[651.11281166],\n", + " [457.06092879]]),\n", + " 66,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", + " (array([[874.40477361],\n", + " [484.93469171]]),\n", + " 86,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", + " (array([[665.76853383],\n", + " [455.07501184]]),\n", + " 69,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", + " (array([[678.87860204],\n", + " [456.69350372]]),\n", + " 71,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", + " (array([[-1542.6411992 ],\n", + " [ 340.60388717]]),\n", + " 155,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940762460.jpg'),\n", + " (array([[1421.95483034],\n", + " [ 500.31614413]]),\n", + " 105,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", + " (array([[829.88118639],\n", + " [480.35634217]]),\n", + " 84,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", + " (array([[714.39762927],\n", + " [462.0206686 ]]),\n", + " 74,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", + " (array([[1055.00564307],\n", + " [ 490.61566724]]),\n", + " 94,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", + " (array([[742.00363249],\n", + " [451.57521871]]),\n", + " 77,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", + " (array([[759.43799094],\n", + " [458.59199587]]),\n", + " 79,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", + " (array([[-905.90785887],\n", + " [ 389.05189138]]),\n", + " 163,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941412460.jpg'),\n", + " (array([[1857.63463466],\n", + " [ 528.16683636]]),\n", + " 113,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", + " (array([[801.08149713],\n", + " [476.80729539]]),\n", + " 82,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", + " (array([[1010.83218816],\n", + " [ 486.10448729]]),\n", + " 92,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", + " (array([[1316.69138952],\n", + " [ 500.16076053]]),\n", + " 102,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", + " (array([[851.44433328],\n", + " [481.32347216]]),\n", + " 85,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", + " (array([[887.76439523],\n", + " [486.17949584]]),\n", + " 87,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", + " (array([[-560.84442669],\n", + " [ 396.22466897]]),\n", + " 171,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942112460.jpg'),\n", + " (array([[2576.95465957],\n", + " [ 585.56971865]]),\n", + " 121,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", + " (array([[1256.86142584],\n", + " [ 505.75190817]]),\n", + " 100,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", + " (array([[951.62347413],\n", + " [489.11425889]]),\n", + " 90,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", + " (array([[1680.02329617],\n", + " [ 525.84434611]]),\n", + " 110,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", + " (array([[1025.02857288],\n", + " [ 494.04762935]]),\n", + " 93,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", + " (array([[1084.92599196],\n", + " [ 500.80788227]]),\n", + " 95,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", + " (array([[-375.01635328],\n", + " [ 401.79884527]]),\n", + " 179,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942862460.jpg'),\n", + " (array([[4842.40836835],\n", + " [ 720.59964531]]),\n", + " 129,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", + " (array([[1183.45773694],\n", + " [ 503.71189817]]),\n", + " 98,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", + " (array([[1592.09377858],\n", + " [ 522.5005283 ]]),\n", + " 108,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", + " (array([[2232.61029421],\n", + " [ 556.81549102]]),\n", + " 118,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", + " (array([[1276.8006295 ],\n", + " [ 507.93748117]]),\n", + " 101,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", + " (array([[1356.62701278],\n", + " [ 509.88258305]]),\n", + " 103,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", + " (array([[653.29079257],\n", + " [465.88515991]]),\n", + " 24,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", + " (array([[-266.61188561],\n", + " [ 404.6134723 ]]),\n", + " 187,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943512460.jpg'),\n", + " (array([[79858.76956704],\n", + " [ 5622.35083535]]),\n", + " 137,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939262460.jpg'),\n", + " (array([[1493.06152981],\n", + " [ 514.2839449 ]]),\n", + " 106,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", + " (array([[2075.17091592],\n", + " [ 551.90742386]]),\n", + " 116,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", + " (array([[3658.26639521],\n", + " [ 650.82132789]]),\n", + " 126,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", + " (array([[1620.39937519],\n", + " [ 524.57168065]]),\n", + " 109,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", + " (array([[1744.94575405],\n", + " [ 529.98622442]]),\n", + " 111,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", + " (array([[647.75724773],\n", + " [463.74263567]]),\n", + " 32,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", + " (array([[-176.18035822],\n", + " [ 407.36094185]]),\n", + " 195,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944162460.jpg'),\n", + " (array([[-4284.81126127],\n", + " [ 118.39310976]]),\n", + " 145,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939912460.jpg'),\n", + " (array([[3082.80486492],\n", + " [ 620.77874313]]),\n", + " 124,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", + " (array([[1939.39727368],\n", + " [ 546.48734639]]),\n", + " 114,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", + " (array([[10817.58126228],\n", + " [ 1128.78052911]]),\n", + " 134,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", + " (array([[2176.80923465],\n", + " [ 555.09333999]]),\n", + " 117,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", + " (array([[-73.33228214],\n", + " [413.98099849]]),\n", + " 203,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944862460.jpg'),\n", + " (array([[2360.73336698],\n", + " [ 565.9302092 ]]),\n", + " 119,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", + " (array([[644.89919982],\n", + " [465.45111157]]),\n", + " 40,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", + " (array([[-1763.50450538],\n", + " [ 304.71030587]]),\n", + " 153,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940612460.jpg'),\n", + " (array([[2757.15536335],\n", + " [ 604.51266365]]),\n", + " 122,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", + " (array([[7351.68305487],\n", + " [ 907.28551592]]),\n", + " 132,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", + " (array([[-7633.52469353],\n", + " [ -73.09298362]]),\n", + " 142,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939662460.jpg'),\n", + " (array([[3342.87206704],\n", + " [ 631.85397964]]),\n", + " 125,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", + " (array([[ 98.12858555],\n", + " [427.06649803]]),\n", + " 211,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945612460.jpg'),\n", + " (array([[3842.28513526],\n", + " [ 660.56473271]]),\n", + " 127,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", + " (array([[639.03983397],\n", + " [463.24763083]]),\n", + " 48,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", + " (array([[-1021.22314783],\n", + " [ 360.61031633]]),\n", + " 161,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941262460.jpg'),\n", + " (array([[-13334.60410239],\n", + " [ -455.18082723]]),\n", + " 140,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939512460.jpg'),\n", + " (array([[5184.47188694],\n", + " [ 746.26745248]]),\n", + " 130,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", + " (array([[-2282.44639082],\n", + " [ 258.79843684]]),\n", + " 150,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940362460.jpg'),\n", + " (array([[8224.07103817],\n", + " [ 964.11299362]]),\n", + " 133,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", + " (array([[254.6379895 ],\n", + " [438.04009527]]),\n", + " 219,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946262460.jpg'),\n", + " (array([[16343.65784906],\n", + " [ 1474.28001824]]),\n", + " 135,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", + " (array([[-634.48153013],\n", + " [ 390.54768532]]),\n", + " 169,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941912460.jpg'),\n", + " (array([[634.69121784],\n", + " [469.5908828 ]]),\n", + " 56,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", + " (array([[-2910.74096584],\n", + " [ 206.79451016]]),\n", + " 148,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940162460.jpg'),\n", + " (array([[-46124.98984086],\n", + " [ -2630.76568596]]),\n", + " 138,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939362460.jpg'),\n", + " (array([[-1241.31315464],\n", + " [ 336.86375036]]),\n", + " 158,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941012460.jpg'),\n", + " (array([[-8956.4395699 ],\n", + " [ -161.17145588]]),\n", + " 141,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939612460.jpg'),\n", + " (array([[-5857.94351617],\n", + " [ 39.7605657 ]]),\n", + " 143,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939762460.jpg'),\n", + " (array([[-417.14437932],\n", + " [ 408.15329914]]),\n", + " 177,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942662460.jpg'),\n", + " (array([[641.27378612],\n", + " [467.28035728]]),\n", + " 64,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", + " (array([[-1413.75655701],\n", + " [ 321.3717477 ]]),\n", + " 156,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940862460.jpg'),\n", + " (array([[-3609.99520661],\n", + " [ 151.63762531]]),\n", + " 146,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940012460.jpg'),\n", + " (array([[-754.94988715],\n", + " [ 378.59927471]]),\n", + " 166,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941662460.jpg'),\n", + " (array([[-2563.18620043],\n", + " [ 238.13038919]]),\n", + " 149,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940262460.jpg'),\n", + " (array([[-2157.33740696],\n", + " [ 270.86522939]]),\n", + " 151,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940412460.jpg'),\n", + " (array([[-292.04165407],\n", + " [ 404.64521964]]),\n", + " 185,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943362460.jpg'),\n", + " (array([[-1686.57035618],\n", + " [ 309.5142111 ]]),\n", + " 154,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940662460.jpg'),\n", + " (array([[-841.89702856],\n", + " [ 375.00205519]]),\n", + " 164,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941512460.jpg'),\n", + " (array([[687.67312395],\n", + " [465.84533368]]),\n", + " 72,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", + " (array([[-487.59001772],\n", + " [ 401.68233576]]),\n", + " 174,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942362460.jpg'),\n", + " (array([[-1352.01256647],\n", + " [ 328.39089614]]),\n", + " 157,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940912460.jpg'),\n", + " (array([[-193.00256462],\n", + " [ 408.44910132]]),\n", + " 193,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944012460.jpg'),\n", + " (array([[-1144.7195687],\n", + " [ 347.8197937]]),\n", + " 159,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941112460.jpg'),\n", + " (array([[-943.52364641],\n", + " [ 368.66092273]]),\n", + " 162,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941362460.jpg'),\n", + " (array([[-545.37693005],\n", + " [ 396.24717279]]),\n", + " 172,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942162460.jpg'),\n", + " (array([[-331.55037913],\n", + " [ 409.64864617]]),\n", + " 182,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943112460.jpg'),\n", + " (array([[775.69721865],\n", + " [469.1435005 ]]),\n", + " 80,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", + " (array([[-783.27872775],\n", + " [ 379.72314757]]),\n", + " 165,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941612460.jpg'),\n", + " (array([[-106.16613898],\n", + " [ 413.27678372]]),\n", + " 201,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944662460.jpg'),\n", + " (array([[-704.09045627],\n", + " [ 386.59373963]]),\n", + " 167,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941762460.jpg'),\n", + " (array([[-366.938234 ],\n", + " [ 408.00075326]]),\n", + " 180,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942912460.jpg'),\n", + " (array([[-595.76824929],\n", + " [ 401.76106936]]),\n", + " 170,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942012460.jpg'),\n", + " (array([[-233.27095378],\n", + " [ 413.07701685]]),\n", + " 190,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943762460.jpg'),\n", + " (array([[913.72293969],\n", + " [487.7798885 ]]),\n", + " 88,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", + " (array([[-515.73858113],\n", + " [ 404.91605246]]),\n", + " 173,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942262460.jpg'),\n", + " (array([[ 49.82821722],\n", + " [433.27683258]]),\n", + " 209,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945412460.jpg'),\n", + " (array([[-450.02823151],\n", + " [ 424.69147566]]),\n", + " 175,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942512460.jpg'),\n", + " (array([[-395.7659521 ],\n", + " [ 416.43540908]]),\n", + " 178,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942762460.jpg'),\n", + " (array([[-142.28499738],\n", + " [ 417.5798493 ]]),\n", + " 198,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944412460.jpg'),\n", + " (array([[-249.37417375],\n", + " [ 415.48281307]]),\n", + " 188,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943612460.jpg'),\n", + " (array([[1101.54402704],\n", + " [ 493.90201857]]),\n", + " 96,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", + " (array([[-350.04780048],\n", + " [ 416.99212664]]),\n", + " 181,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943012460.jpg'),\n", + " (array([[217.91138945],\n", + " [444.561799 ]]),\n", + " 217,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946112460.jpg'),\n", + " (array([[-322.69292361],\n", + " [ 421.01853877]]),\n", + " 183,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943162460.jpg'),\n", + " (array([[-11.7547229 ],\n", + " [425.58269951]]),\n", + " 206,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945162460.jpg'),\n", + " (array([[-284.87263265],\n", + " [ 415.97171558]]),\n", + " 186,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943412460.jpg'),\n", + " (array([[-162.00983545],\n", + " [ 417.81381264]]),\n", + " 196,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944262460.jpg'),\n", + " (array([[1377.97607295],\n", + " [ 499.94679416]]),\n", + " 104,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", + " (array([[-243.51694901],\n", + " [ 417.7829449 ]]),\n", + " 189,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943662460.jpg'),\n", + " (array([[-217.59986609],\n", + " [ 420.4319389 ]]),\n", + " 191,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943862460.jpg'),\n", + " (array([[159.4889065 ],\n", + " [440.54216502]]),\n", + " 214,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945862460.jpg'),\n", + " (array([[-65.30498154],\n", + " [425.23437412]]),\n", + " 204,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944912460.jpg'),\n", + " (array([[-182.39461284],\n", + " [ 419.93690725]]),\n", + " 194,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944112460.jpg'),\n", + " (array([[1780.52499269],\n", + " [ 516.76123959]]),\n", + " 112,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", + " (array([[-148.25931709],\n", + " [ 420.40786336]]),\n", + " 197,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944362460.jpg'),\n", + " (array([[-130.51744472],\n", + " [ 421.25473533]]),\n", + " 199,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944512460.jpg'),\n", + " (array([[331.23070314],\n", + " [459.53472034]]),\n", + " 222,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946612460.jpg'),\n", + " (array([[109.69670149],\n", + " [438.22906159]]),\n", + " 212,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945662460.jpg'),\n", + " (array([[-90.33545294],\n", + " [424.99304712]]),\n", + " 202,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944762460.jpg'),\n", + " (array([[2503.74867417],\n", + " [ 561.0516802 ]]),\n", + " 120,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", + " (array([[-22.98109663],\n", + " [423.73632445]]),\n", + " 205,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945112460.jpg'),\n", + " (array([[ 11.53500425],\n", + " [428.22538314]]),\n", + " 207,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945262460.jpg'),\n", + " (array([[290.52315947],\n", + " [447.91042476]]),\n", + " 220,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946412460.jpg'),\n", + " (array([[ 74.2477107 ],\n", + " [434.60615348]]),\n", + " 210,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945512460.jpg'),\n", + " (array([[4280.00169488],\n", + " [ 664.08561274]]),\n", + " 128,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg'),\n", + " (array([[135.02248517],\n", + " [434.34476132]]),\n", + " 213,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945762460.jpg'),\n", + " (array([[171.30721444],\n", + " [437.53098623]]),\n", + " 215,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945912460.jpg'),\n", + " (array([[230.12831558],\n", + " [441.7999293 ]]),\n", + " 218,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946162460.jpg'),\n", + " (array([[22083.89175394],\n", + " [ 1715.99323471]]),\n", + " 136,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939162460.jpg'),\n", + " (array([[310.09439083],\n", + " [450.08909788]]),\n", + " 221,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946512460.jpg'),\n", + " (array([[342.56018639],\n", + " [454.04521018]]),\n", + " 223,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946662460.jpg'),\n", + " (array([[-4716.54929159],\n", + " [ 113.0792055 ]]),\n", + " 144,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939862460.jpg'),\n", + " (array([[-1946.95364831],\n", + " [ 298.73657043]]),\n", + " 152,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940512460.jpg'),\n", + " (array([[-1102.02208943],\n", + " [ 358.41101317]]),\n", + " 160,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941162460.jpg'),\n", + " (array([[-656.85153973],\n", + " [ 393.5900866 ]]),\n", + " 168,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941862460.jpg'),\n", + " (array([[-427.60199952],\n", + " [ 415.11127003]]),\n", + " 176,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942612460.jpg'),\n", + " (array([[-305.52829753],\n", + " [ 410.26901461]]),\n", + " 184,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943262460.jpg'),\n", + " (array([[-207.82702139],\n", + " [ 403.75614819]]),\n", + " 192,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943912478.jpg'),\n", + " (array([[-114.75979851],\n", + " [ 407.46411729]]),\n", + " 200,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944612460.jpg'),\n", + " (array([[ 37.26329421],\n", + " [420.89676481]]),\n", + " 208,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945362460.jpg'),\n", + " (array([[194.28985395],\n", + " [432.49816981]]),\n", + " 216,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946012460.jpg'),\n", + " (array([[364.78888577],\n", + " [451.33761853]]),\n", + " 224,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946762460.jpg')],\n", + " [(array([[41637.84698733],\n", + " [ 2286.82763324]]),\n", + " 83,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", + " (array([[16513.28833205],\n", + " [ 1149.87423222]]),\n", + " 81,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", + " (array([[9772.13459862],\n", + " [ 881.36468696]]),\n", + " 78,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", + " (array([[71761.24126268],\n", + " [ 3705.96825885]]),\n", + " 84,\n", + " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", + " (array([[11456.36183895],\n", + " [ 972.44697493]]),\n", + " 79,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", + " (array([[23330.9440194 ],\n", + " [ 1457.43190353]]),\n", + " 82,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", + " (array([[14348.16422895],\n", + " [ 1068.40803444]]),\n", + " 80,\n", + " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg')]]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -4421,18 +14470,51 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, + "id": "f82af262", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='object_type', ctx=Load()), ops=[Eq()], comparators=[Str(s='vehicle.car')]))])\n", + "Module(body=[Return(value=Compare(left=Call(func=Name(id='Tmin', ctx=Load()), args=[Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load())], keywords=[]), ops=[GtE()], comparators=[Name(id='start', ctx=Load())]))])\n", + "Module(body=[Return(value=Compare(left=Call(func=Name(id='Tmax', ctx=Load()), args=[Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load())], keywords=[]), ops=[Lt()], comparators=[Name(id='end', ctx=Load())]))])\n", + "Worlds Table created successfully........\n", + "New world inserted successfully........\n", + "Xmin(Test_Scenic_General_Bbox.trajBbox)\n", + "Ymin(Test_Scenic_General_Bbox.trajBbox)\n", + "Zmin(Test_Scenic_General_Bbox.trajBbox)\n", + "Xmax(Test_Scenic_General_Bbox.trajBbox)\n", + "Ymax(Test_Scenic_General_Bbox.trajBbox)\n", + "Zmax(Test_Scenic_General_Bbox.trajBbox)\n", + "SELECT Xmin(Test_Scenic_General_Bbox.trajBbox), Ymin(Test_Scenic_General_Bbox.trajBbox), Zmin(Test_Scenic_General_Bbox.trajBbox), Xmax(Test_Scenic_General_Bbox.trajBbox), Ymax(Test_Scenic_General_Bbox.trajBbox), Zmax(Test_Scenic_General_Bbox.trajBbox) From Test_Scenic_Item_General_Trajectory INNER JOIN Test_Scenic_General_Bbox USING(itemId) Where Test_Scenic_Item_General_Trajectory.objectType='vehicle.car' AND Tmin(Test_Scenic_General_Bbox.trajBbox)>='0001-01-01 00:00:00' AND Tmax(Test_Scenic_General_Bbox.trajBbox)<'9999-12-31 23:59:59.999999';\n", + "\n" + ] + } + ], "source": [ "bboxes = scenic_world.predicate(lambda obj:obj.object_type == \"vehicle.car\").get_geo().execute()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, + "id": "4ca906f9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(2004, 6)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "bboxes.shape" ] @@ -4440,6 +14522,7 @@ { "cell_type": "code", "execution_count": null, + "id": "d57045cc", "metadata": {}, "outputs": [], "source": [] @@ -4451,7 +14534,7 @@ "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -4465,7 +14548,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.8" + "version": "3.7.12" } }, "nbformat": 4, From 9bead62e6b9f8522f4dae8b7f034cd33d4c56a87 Mon Sep 17 00:00:00 2001 From: "Chanwut (Mick) Kittivorawong" Date: Wed, 2 Mar 2022 14:14:02 -0800 Subject: [PATCH 17/26] replace world with scenic_world --- apperception/scenic_context.py | 113 --------- apperception/scenic_video_context_executor.py | 55 ----- apperception/scenic_world.py | 231 ------------------ apperception/scenic_world_executer.py | 159 ------------ apperception/video_context.py | 69 ++---- apperception/video_context_executor.py | 47 +--- apperception/world.py | 101 ++++++-- apperception/world_executor.py | 12 +- scenic_test.ipynb | 25 +- 9 files changed, 125 insertions(+), 687 deletions(-) delete mode 100644 apperception/scenic_context.py delete mode 100644 apperception/scenic_video_context_executor.py delete mode 100644 apperception/scenic_world.py delete mode 100644 apperception/scenic_world_executer.py diff --git a/apperception/scenic_context.py b/apperception/scenic_context.py deleted file mode 100644 index 539f5022..00000000 --- a/apperception/scenic_context.py +++ /dev/null @@ -1,113 +0,0 @@ -import ast -import inspect -import os -from typing import Callable -import uncompyle6 -import psycopg2 -from video_util import * -import datetime - - -# Camera node -class Camera: - def __init__(self, scenic_scene_name): - self.scenic_scene_name = scenic_scene_name - - # Contain objects that still have yet to be added to the backend - # If user calls recognize, those items will have already been - # stored in the backend. These are reserved for objects that users - # have not added to the camera. - self.items = [] - self.object_recognition = None - - - def add_item(self, item): - # Add item - self.items.append(item) - - def add_property(self, properties, property_type, new_prop): - # Add property - self.properties[property_type].append(new_prop) - - # Add a default add_recog_obj = True - def recognize(self, sample_data, annotation): - # Create object recognition node - object_rec_node = ObjectRecognition(sample_data, annotation) - self.object_recognition = object_rec_node - return object_rec_node - -# Object Recognition node -class ObjectRecognition: - def __init__(self, sample_data, annotation): - self.sample_data = sample_data - self.annotation = annotation - self.properties = {} - - def add_properties(self, properties): - self.properties = properties - -class VideoContext: - def __init__(self, name, units): - self.root = self - self.name = name - self.units = units - self.camera_nodes = {} - self.start_time = datetime.datetime(2021, 6, 8, 7, 10, 28) - - # Connect to the database - def connect_db(self, host='localhost', - user=None, - password=None, - port=5432, - database_name=None): - self.conn = psycopg2.connect(database=database_name, user=user, - password=password, host=host, port=port) - - def get_name(self): - return self.name - - def get_units(self): - return self.units - - # Establish camera - def camera(self, scenic_scene_name): - camera_node = self.__get_camera(scenic_scene_name) - if not camera_node: - camera_node = Camera(scenic_scene_name) - self.__add_camera(scenic_scene_name, camera_node) - return camera_node - - def properties(self, cam_id, properties, property_type): - camera_node = self.__get_camera(cam_id) - if not camera_node: - return None - - camera_node.add_properties(properties, property_type) - # Display error - - - - def get_camera(self, cam_id): - return self.__get_camera(cam_id) - - # Get camera - def __get_camera(self, cam_id): - if cam_id in self.camera_nodes.keys(): - return self.camera_nodes[cam_id] - return None - - # Add camera - def __add_camera(self, cam_id, camera_node): - self.camera_nodes[cam_id] = camera_node - - # Remove camera - def remove_camera(self, cam_id): - camera_node = self.__get_camera(cam_id) - self.camera_nodes.remove(camera_node) - - # Clear - def clear(self): - self.camera_nodes = [] - - - diff --git a/apperception/scenic_video_context_executor.py b/apperception/scenic_video_context_executor.py deleted file mode 100644 index d92b7820..00000000 --- a/apperception/scenic_video_context_executor.py +++ /dev/null @@ -1,55 +0,0 @@ -from scenic_context import * -from scenic_util import * - -import json - -class VideoContextExecutor: - def __init__(self, conn, new_video_context:VideoContext=None, tasm=None): - if new_video_context: - self.context(new_video_context) - self.conn = conn - self.tasm = tasm - - def context(self, video_context:VideoContext): - self.current_context = video_context - return self - - def visit(self): - video_query = self.visit_world() - return video_query - - def visit_world(self): - # Query to store world in database - name, units = self.current_context.name, self.current_context.units - world_sql = create_or_insert_world_table(self.conn, name, units) - - all_sqls = [] - cameras = self.current_context.camera_nodes - if len(cameras) != 0: - for c in cameras.values(): - camera_sql = self.visit_camera(c) - all_sqls.append(camera_sql) - return all_sqls - - def visit_camera(self, camera_node): - world_name = self.current_context.name - camera_sql = create_or_insert_camera_table(self.conn, world_name, camera_node) - if camera_node.object_recognition is not None: - self.visit_obj_rec(camera_node, camera_node.object_recognition) - if self.tasm: - video_data_to_tasm(camera_node, camera_node.metadata_id, self.tasm) - return camera_sql - - def visit_obj_rec(self, camera_node, object_rec_node): - cam_id = camera_node.scenic_scene_name - - start_time = self.current_context.start_time - - tracking_results = recognize(cam_id, object_rec_node.sample_data, object_rec_node.annotation) - add_recognized_objs(self.conn, tracking_results, start_time) - if self.tasm: - metadata_to_tasm(tracking_results, camera_node.metadata_id, self.tasm) - - def execute(self): - query = self.visit() - diff --git a/apperception/scenic_world.py b/apperception/scenic_world.py deleted file mode 100644 index 186a6808..00000000 --- a/apperception/scenic_world.py +++ /dev/null @@ -1,231 +0,0 @@ -from metadata_context import MetadataContext -from scenic_context import VideoContext -import copy -from scenic_world_executer import WorldExecutor -import matplotlib.pyplot as plt -from scenic_util import transformation -import numpy as np -import datetime -import cv2 - -BASE_VOLUME_QUERY_TEXT = "stbox \'STBOX Z(({x1}, {y1}, {z1}),({x2}, {y2}, {z2}))\'" -world_executor = WorldExecutor() - - -class World: - - def __init__(self, name, units, enable_tasm=False): - self.VideoContext = VideoContext(name, units) - self.MetadataContext = MetadataContext(single_mode=False) - self.MetadataContext.start_time = self.VideoContext.start_time - self.GetVideo = False - self.enable_tasm = enable_tasm - # self.AccessedVideoContext = False - - def get_camera(self, scene_name, frame_num): - # Change depending if you're on docker or not - # TODO: fix get_camera in scenic_world_executor.py - if self.enable_tasm: - world_executor.connect_db(port=5432, user="docker", password="docker", database_name="mobilitydb") - else: - world_executor.connect_db(user="docker", password="docker", database_name="mobilitydb") - return world_executor.get_camera(scene_name, frame_num) - -######################### -### Video Context #### -######################### - def get_lens(self, cam_id=""): - return self.get_camera(cam_id).lens - - def get_name(self): - return self.VideoContext.get_name() - - def get_units(self): - return self.VideoContext.get_units() - - def item(self, item_id, cam_id, item_type, location): - new_context = copy.deepcopy(self) - new_context.VideoContext.item(item_id, cam_id, item_type, location) - return new_context - - def camera(self, scenic_scene_name: str): - new_context = copy.deepcopy(self) - new_context.VideoContext.camera(scenic_scene_name) - return new_context - - def add_properties(self, cam_id, properties, property_type): - new_context = copy.deepcopy(self) - new_context.VideoContext.properties(cam_id, properties, property_type) - return new_context - - def recognize(self, cam_id, sample_data, annotation): - new_context = copy.deepcopy(self) - new_context.VideoContext.camera_nodes[cam_id].recognize(sample_data, annotation) - return new_context - -######################### -### Metadata Context #### -######################### - - def get_columns(self, *argv, distinct = False): - new_context = copy.deepcopy(self) - new_context.MetadataContext.get_columns(argv, distinct) - return new_context - - def predicate(self, p, evaluated_var = {}): - new_context = copy.deepcopy(self) - new_context.MetadataContext.predicate(p, evaluated_var) - return new_context - - def selectkey(self, distinct = False): - new_context = copy.deepcopy(self) - new_context.MetadataContext.selectkey(distinct) - return new_context - - def get_trajectory(self, interval = [], distinct = False): - new_context = copy.deepcopy(self) - new_context.MetadataContext.get_trajectory(interval, distinct) - return new_context - - def get_geo(self, interval = [], distinct = False): - new_context = copy.deepcopy(self) - new_context.MetadataContext.get_geo(interval, distinct) - return new_context - - def get_time(self, distinct = False): - new_context = copy.deepcopy(self) - new_context.MetadataContext.get_time(distinct) - return new_context - - def get_distance(self, interval = [], distinct = False): - new_context = copy.deepcopy(self) - new_context.MetadataContext.distance(interval, distinct) - return new_context - - def get_speed(self, interval = [], distinct = False): - new_context = copy.deepcopy(self) - new_context.MetadataContext.get_speed(interval, distinct) - return new_context - - def get_video(self, cam_id=[]): - # Go through all the cameras in 'filtered' world and obtain videos - new_context = copy.deepcopy(self) - new_context.GetVideo = True - ## get camera gives the direct results from the data base - new_context.get_video_cams = self.get_camera(cam_id) - return new_context - - def interval(self, time_interval): - new_context = copy.deepcopy(self) - new_context.MetadataContext.interval(time_interval) - return new_context - - def execute(self): - world_executor.create_world(self) - if self.enable_tasm: - world_executor.enable_tasm() - print("successfully enable tasm during execution time") - # Change depending if you're on docker or not - world_executor.connect_db(port=5432, user="docker", password="docker", database_name="mobilitydb") - else: - world_executor.connect_db(user="docker", password="docker", database_name="mobilitydb") - return world_executor.execute() - - def select_intersection_of_interest_or_use_default(self, cam_id, default=True): - print(self.VideoContext.camera_nodes) - camera = self.VideoContext.camera_nodes[cam_id] - video_file = camera.video_file - if default: - x1, y1, z1 = 0.01082532, 2.59647246, 0 - x2, y2, z2 = 3.01034039, 3.35985782, 2 - else: - vs = cv2.VideoCapture(video_file) - frame = vs.read() - frame = frame[1] - cv2.namedWindow("Frame", cv2.WINDOW_NORMAL) - cv2.resizeWindow('Frame', 384, 216) - initBB = cv2.selectROI("Frame", frame, fromCenter=False) - print(initBB) - cv2.destroyAllWindows() - print("world coordinate #1") - tl = camera.lens.pixel_to_world(initBB[:2], 1) - print(tl) - x1, y1, z1 = tl - print("world coordinate #2") - br = camera.lens.pixel_to_world((initBB[0]+initBB[2], initBB[1]+initBB[3]), 1) - print(br) - x2, y2, z2 = br - return BASE_VOLUME_QUERY_TEXT.format(x1=x1, y1=y1, z1=0, x2=x2, y2=y2, z2=2) - - def overlay_trajectory(self, scene_name, trajectory): - frame_num = self.trajectory_to_frame_num(trajectory) - # frame_num is int[[]], hence camera_info should also be [[]] - camera_info = [] - for cur_frame_num in frame_num: - camera_info.append(self.get_camera(scene_name, cur_frame_num)) ### TODO: fetch_camera_info in scenic_utils.py - assert len(camera_info) == len(frame_num) - assert len(camera_info[0]) == len(frame_num[0]) - overlay_info = self.get_overlay_info(trajectory, camera_info) - ### TODO: fix the following to overlay the 2d point onto the frame - for traj in trajectory: - current_trajectory = np.asarray(traj[0]) - frame_points = camera.lens.world_to_pixels(current_trajectory.T).T - vs = cv2.VideoCapture(video_file) - frame = vs.read() - frame = cv2.cvtColor(frame[1], cv2.COLOR_BGR2RGB) - for point in frame_points.tolist(): - cv2.circle(frame,tuple([int(point[0]), int(point[1])]),3,(255,0,0)) - plt.figure() - plt.imshow(frame) - plt.show() - - def trajectory_to_frame_num(self, trajectory): - ''' - TODO: fetch the frame number from the trajectory - 1. get the time stamp field from the trajectory - 2. convert the time stamp to frame number - Refer to 'convert_datetime_to_frame_num' in 'video_util.py' - 3. return the frame number - ''' - frame_num = [] - start_time = self.MetadataContext.start_time - for traj in trajectory: - current_trajectory = traj[0] - date_times = current_trajectory['datetimes'] - frame_num.append([(datetime.datetime.strptime(t, "%Y-%m-%dT%H:%M:%S+00").replace(tzinfo = None) - start_time).total_seconds() for t in date_times]) - return frame_num - - def get_overlay_info(self, trajectory, camera_info): - ''' - TODO: overlay each trajectory 3d coordinate on to the frame specified by the camera_info - 1. for each trajectory, get the 3d coordinate - 2. get the camera_info associated to it - 3. implement the transformation function from 3d to 2d - given the single centroid point and camera configuration - refer to TODO in "senic_utils.py" - 4. return a list of (2d coordinate, frame name/filename) - ''' - result = [] - for traj_num in range(len(trajectory)): - traj_obj = trajectory[traj_num][0] # traj_obj means the trajectory of current object - traj_obj_3d = traj_obj['coordinates'] # 3d coordinate list of the object's trajectory - camera_info_obj = camera_info[traj_num] # camera info list corresponding the 3d coordinate - traj_obj_2d = [] # 2d coordinate list - for index in range(len(camera_info_obj)): - cur_camera_info = camera_info_obj[index] # camera info of the obejct in one point of the trajectory - centroid_3d = np.array(traj_obj_3d[index]) # one point of the trajectory in 3d - # in order to fit into the function transformation, we develop a dictionary called camera_config - camera_config = {} - camera_config['egoTranslation'] = cur_camera_info[1] - print(type(camera_config["egoTranslation"])) - camera_config['egoRotation'] = np.array(cur_camera_info[2]) - camera_config['cameraTranslation'] = cur_camera_info[3] - camera_config['cameraRotation'] = np.array(cur_camera_info[4]) - camera_config['cameraIntrinsic'] = np.array(cur_camera_info[5]) - traj_2d = transformation(centroid_3d, camera_config) # one point of the trajectory in 2d - - framenum = cur_camera_info[6] - filename = cur_camera_info[7] - traj_obj_2d.append((traj_2d, framenum, filename)) - result.append(traj_obj_2d) - return result \ No newline at end of file diff --git a/apperception/scenic_world_executer.py b/apperception/scenic_world_executer.py deleted file mode 100644 index 7da048d8..00000000 --- a/apperception/scenic_world_executer.py +++ /dev/null @@ -1,159 +0,0 @@ -from metadata_context_executor import * -from metadata_context import * -from scenic_video_context_executor import * -from scenic_util import * -import numpy as np - -class WorldExecutor: - def __init__(self, world=None): - if world: - self.create_world(world) - self.tasm = None - - def connect_db(self, - host='localhost', - user=None, - password=None, - port=25432, - database_name=None): - - self.conn = psycopg2.connect(database=database_name, user=user, password=password, host=host, port=port) - - def create_world(self, world): - self.curr_world = world - return self - - def enable_tasm(self): - import tasm - if not self.tasm: - self.tasm = tasm.TASM() - - def get_camera(self, scene_name, frame_num): - assert self.curr_world, self.conn - cameras = fetch_camera(self.conn, scene_name, frame_num) - ### each camera appear like: - ### (cameraId, ratio, origin3d, focalpoints2d, fov, skev_factor) - - return cameras - - def tasm_get_video(self, metadata_results): - ### Get the metadata context executing query text, let tasm get video call it - ### the tasm would execute the query to get the ids, bboxes and timestamps - ### then it can use these to tile the video and get it - cam_nodes = self.curr_world.get_video_cams - tasm = self.curr_world.fetch_tasm() - for cam_node in cam_nodes: - current_metadata_identifier = cam_node.metadata_id - current_video_file = cam_nodes.video_file - tasm.activate_regret_based_tiling(current_video_file, current_metadata_identifier) - for label, timestamps in metadata_results.items(): - tasm.get_video_roi( - f'./output/{label}.mp4', # output path - current_video_file, # name in TASM - current_metadata_identifier, # metadata identifier in TASM - label, # label name - timestamps[0], # first frame inclusive - timestamps[-1] # last frame exclusive - ) - tasm.retile_based_on_regret(current_video_file, current_metadata_identifier) - - - def get_video(self, metadata_results): - start_time = self.curr_world.VideoContext.start_time - # print("Start time is", start_time) - ### The cam nodes are raw data from the database - ### TODO: I forget why we used the data from the db instead of directly fetch - ### from the world - cam_nodes = self.curr_world.get_video_cams - video_files = [] - for i in range(len(cam_nodes)): - cam_id, ratio, cam_x, cam_y, cam_z, focal_x, focal_y, fov, skew_factor = cam_nodes[i] - cam_video_file = self.curr_world.VideoContext.camera_nodes[cam_id].video_file - - transform_matrix = create_transform_matrix(focal_x, focal_y, cam_x, cam_y, skew_factor) - - for item_id, vals in metadata_results.items(): - world_coords, timestamps = vals - # print("timestamps are", timestamps) - world_coords = reformat_fetched_world_coords(world_coords) - - cam_coords = world_to_pixel(world_coords, transform_matrix) - - vid_times = convert_datetime_to_frame_num(start_time, timestamps) - # print(vid_times) - - vid_fname = './output/'+self.curr_world.VideoContext.camera_nodes[cam_id].metadata_id + item_id + '.mp4' - # print(vid_fname) - get_video_roi(vid_fname, cam_video_file, cam_coords, vid_times) - video_files.append(vid_fname) - print("output video files", ','.join(video_files)) - return video_files - - def execute(self): - # Edit logic for execution here through checks of whether VideoContext or MetadataContext is being used - video_executor = VideoContextExecutor(self.conn, self.curr_world.VideoContext, self.tasm) - video_executor.execute() - - if self.curr_world.MetadataContext.scan.view == None: - return - - if self.curr_world.GetVideo: - if self.tasm: - metadata_executor = MetadataContextExecutor(self.conn, self.curr_world.MetadataContext.get_columns(primarykey, time)) - metadata_results = video_fetch_reformat_tasm(metadata_executor.execute()) - return self.tasm_get_video(metadata_results) - else: - metadata_executor = MetadataContextExecutor(self.conn, self.curr_world.MetadataContext.get_columns(primarykey, geometry, time)) - metadata_results = video_fetch_reformat(metadata_executor.execute()) - return self.get_video(metadata_results) - - metadata_executor = MetadataContextExecutor(self.conn, self.curr_world.MetadataContext) - return metadata_executor.execute() - -def create_transform_matrix(focal_x, focal_y, cam_x, cam_y, skew_factor): - alpha = skew_factor - - transform = np.array([[focal_x, alpha, cam_x, 0], - [0, focal_y, cam_y, 0], - [0, 0, 1, 0] - ]) - - return transform - -def reformat_fetched_world_coords(world_coords): - return np.array(world_coords) - -def world_to_pixel(world_coords, transform): - tl_x, tl_y, tl_z, br_x, br_y, br_z = world_coords.T - - tl_world_pixels = np.array([tl_x, tl_y, tl_z, np.ones(len(tl_x))]) - tl_vid_coords = transform @ tl_world_pixels - - br_world_pixels = np.array([br_x, br_y, br_z, np.ones(len(br_x))]) - br_vid_coords = transform @ br_world_pixels - - return np.stack((tl_vid_coords[0], tl_vid_coords[1], br_vid_coords[0], br_vid_coords[1]), axis=0) - -def video_fetch_reformat_tasm(fetched_meta): - result = {} - for meta in fetched_meta: - item_id, timestamp = meta[0], meta[1] - if item_id in result: - result[item_id]['tracked_cnt'].append(timestamp) - else: - result[item_id] = {'tracked_cnt':[timestamp]} - - return result - - -def video_fetch_reformat(fetched_meta): - result = {} - for meta in fetched_meta: - item_id, coordinates, timestamp = meta[0], meta[1:-1], meta[-1] - if item_id in result: - result[item_id][0].append(coordinates) - result[item_id][1].append(timestamp) - else: - result[item_id] = [[coordinates],[timestamp]] - - return result \ No newline at end of file diff --git a/apperception/video_context.py b/apperception/video_context.py index 7212957e..14216f1f 100644 --- a/apperception/video_context.py +++ b/apperception/video_context.py @@ -13,26 +13,16 @@ class Camera: - """Camera node""" - - def __init__( - self, cam_id: str, point: Point, ratio: float, video_file: str, metadata_id: str, lens: Lens - ): - self.cam_id: str = cam_id - self.ratio: float = ratio - self.video_file: str = video_file - self.metadata_id: str = metadata_id - self.properties: Dict[str, list] = {} # TODO: what is the type of properties? + def __init__(self, scenic_scene_name): + self.scenic_scene_name = scenic_scene_name # Contain objects that still have yet to be added to the backend # If user calls recognize, those items will have already been # stored in the backend. These are reserved for objects that users # have not added to the camera. - self.items: List[Item] = [] - self.object_recognition: Optional[ObjectRecognition] = None - self.point: Point = point - self.lens: Lens = lens - self.dimension: Optional[Tuple[int, int]] = None + self.items = [] + self.object_recognition = None + def add_item(self, item: Item): # Add item @@ -43,23 +33,12 @@ def add_property(self, properties, property_type: str, new_prop): # Add property self.properties[property_type].append(new_prop) - def add_lens(self, lens: Lens): - # Add lens - self.lens = lens - - def recognize( - self, - algo: str = "Yolo", - tracker_type: str = "multi", - tracker: Optional[Tracker] = None, - recognition_area: BoundingBox = WHOLE_FRAME, - ): - # Add a default add_recog_obj = True (TODO?) + # Add a default add_recog_obj = True + def recognize(self, sample_data, annotation): # Create object recognition node - if not self.object_recognition: - self.object_recognition = ObjectRecognition(algo, tracker_type, tracker) - self.object_recognition.recognition_areas.append(recognition_area) - return self.object_recognition + object_rec_node = ObjectRecognition(sample_data, annotation) + self.object_recognition = object_rec_node + return object_rec_node @dataclass @@ -72,18 +51,12 @@ class Item: properties: dict = field(default_factory=dict) # TODO: what is the type of properties? -@dataclass +# Object Recognition node class ObjectRecognition: - """Object Recognition node""" - - algo: str - tracker_type: str - tracker: Optional[Tracker] = None - bboxes: list = field(default_factory=list) # TODO: what is the type of bboxes? - labels: Any = None # TODO: what is the type of labels? - tracked_cnt: Any = None # TODO: what is the type of tracked_cnt? - properties: Any = None # TODO: what is the type of properties? - recognition_areas: List[BoundingBox] = field(default_factory=list) + def __init__(self, sample_data, annotation): + self.sample_data = sample_data + self.annotation = annotation + self.properties = {} def add_properties(self, properties): self.properties = properties @@ -110,14 +83,12 @@ def get_name(self): def get_units(self): return self.units - def camera( - self, cam_id: str, point: Point, ratio: float, video_file: str, metadata_id: str, lens: Lens - ): - """Establish camera""" - camera_node = self.__get_camera(cam_id) + # Establish camera + def camera(self, scenic_scene_name): + camera_node = self.__get_camera(scenic_scene_name) if not camera_node: - camera_node = Camera(cam_id, point, ratio, video_file, metadata_id, lens) - self.__add_camera(cam_id, camera_node) + camera_node = Camera(scenic_scene_name) + self.__add_camera(scenic_scene_name, camera_node) return camera_node def properties(self, cam_id: str, properties, property_type): diff --git a/apperception/video_context_executor.py b/apperception/video_context_executor.py index a6f62e8b..aed97cce 100644 --- a/apperception/video_context_executor.py +++ b/apperception/video_context_executor.py @@ -1,14 +1,5 @@ -from typing import Any, Dict, List, Set - -from bounding_box import WHOLE_FRAME, BoundingBox -from video_context import Camera, ObjectRecognition, VideoContext -from video_util import (add_recognized_objs, create_or_insert_camera_table, - create_or_insert_world_table, get_video_dimension, - metadata_to_tasm, recognize, video_data_to_tasm) - -recognized_areas: Dict[str, Set[BoundingBox]] = {} -visited_camera: Set[str] = set() -created_world: Set[str] = set() +from video_context import * +from scenic_util import * class VideoContextExecutor: @@ -57,40 +48,16 @@ def visit_camera(self, camera_node: Camera): if camera_node.object_recognition is not None: self.visit_obj_rec(camera_node, camera_node.object_recognition) if self.tasm: - video_data_to_tasm(camera_node.video_file, camera_node.metadata_id, self.tasm) + video_data_to_tasm(camera_node, camera_node.metadata_id, self.tasm) return camera_sql - def visit_obj_rec(self, camera_node: Camera, object_rec_node: ObjectRecognition): - lens = camera_node.lens - video_file = camera_node.video_file + def visit_obj_rec(self, camera_node, object_rec_node): + cam_id = camera_node.scenic_scene_name start_time = self.current_context.start_time - tracker = object_rec_node.tracker - tracker_type = object_rec_node.tracker_type - algo = object_rec_node.algo - - recognition_areas = object_rec_node.recognition_areas - - if to_recognize_whole_frame(recognition_areas): - tracking_results = recognize(video_file, algo, tracker_type, tracker) - # TODO: @mick remove other recognized object of this camera - add_recognized_objs(self.conn, lens, tracking_results, start_time) - recognized_areas[camera_node.cam_id] = {WHOLE_FRAME} - else: - recognition_areas = sorted(recognition_areas, key=lambda a: a.area, reverse=True) - for recognition_area in recognition_areas: - if is_area_recognized(recognition_area, recognized_areas[camera_node.cam_id]): - continue - - tracking_results = recognize( - video_file, algo, tracker_type, tracker, recognition_area - ) - add_recognized_objs(self.conn, lens, tracking_results, start_time) - # TODO: should remove recognized objects in overlapped areas - - recognized_areas[camera_node.cam_id].add(recognition_area) - + tracking_results = recognize(cam_id, object_rec_node.sample_data, object_rec_node.annotation) + add_recognized_objs(self.conn, tracking_results, start_time) if self.tasm: metadata_to_tasm(tracking_results, camera_node.metadata_id, self.tasm) diff --git a/apperception/world.py b/apperception/world.py index a2cb23a9..45af8618 100644 --- a/apperception/world.py +++ b/apperception/world.py @@ -4,11 +4,13 @@ import matplotlib import matplotlib.pyplot as plt import numpy as np +import datetime from bounding_box import WHOLE_FRAME, BoundingBox from metadata_context import MetadataContext from tracker import Tracker from video_context import VideoContext from world_executor import WorldExecutor +from scenic_util import transformation matplotlib.use("Qt5Agg") @@ -25,20 +27,20 @@ def __init__(self, name, units, enable_tasm=False): self.enable_tasm = enable_tasm # self.AccessedVideoContext = False - def get_camera(self, cam_id=[]): - # Change depending if you're on docker or not + def get_camera(self, scene_name, frame_num): + # Change depending if you're on docker or not + # TODO: fix get_camera in scenic_world_executor.py if self.enable_tasm: world_executor.connect_db( port=5432, user="docker", password="docker", database_name="mobilitydb" ) else: world_executor.connect_db(user="docker", password="docker", database_name="mobilitydb") - return world_executor.get_camera(cam_id) + return world_executor.get_camera(scene_name, frame_num) - ######################### - ### Video Context #### - ######################### - # TODO(@Vanessa): Add a helper function +######################### +### Video Context #### +######################### def get_lens(self, cam_id=""): return self.get_camera(cam_id).lens @@ -52,12 +54,10 @@ def item(self, item_id, cam_id, item_type, location): new_context = copy.deepcopy(self) new_context.VideoContext.item(item_id, cam_id, item_type, location) return new_context - - def camera(self, cam_id, location, ratio, video_file, metadata_identifier, lens): + + def camera(self, scenic_scene_name: str): new_context = copy.deepcopy(self) - new_context.VideoContext.camera( - cam_id, location, ratio, video_file, metadata_identifier, lens - ) + new_context.VideoContext.camera(scenic_scene_name) return new_context def add_properties(self, cam_id, properties, property_type): @@ -65,18 +65,9 @@ def add_properties(self, cam_id, properties, property_type): new_context.VideoContext.properties(cam_id, properties, property_type) return new_context - def recognize( - self, - cam_id: str, - algo: str = "Yolo", - tracker_type: str = "multi", - tracker: Tracker = None, - recognition_area: BoundingBox = WHOLE_FRAME, # bounding box value in percentage not pixel - ): + def recognize(self, cam_id, sample_data, annotation): new_context = copy.deepcopy(self) - new_context.VideoContext.camera_nodes[cam_id].recognize( - algo, tracker_type, tracker, recognition_area - ) + new_context.VideoContext.camera_nodes[cam_id].recognize(sample_data, annotation) return new_context ######################### @@ -175,9 +166,16 @@ def select_intersection_of_interest_or_use_default(self, cam_id, default=True): x2, y2, z2 = br return BASE_VOLUME_QUERY_TEXT.format(x1=x1, y1=y1, z1=0, x2=x2, y2=y2, z2=2) - def overlay_trajectory(self, cam_id, trajectory): - camera = self.VideoContext.get_camera(cam_id) - video_file = camera.video_file + def overlay_trajectory(self, scene_name, trajectory): + frame_num = self.trajectory_to_frame_num(trajectory) + # frame_num is int[[]], hence camera_info should also be [[]] + camera_info = [] + for cur_frame_num in frame_num: + camera_info.append(self.get_camera(scene_name, cur_frame_num)) ### TODO: fetch_camera_info in scenic_utils.py + assert len(camera_info) == len(frame_num) + assert len(camera_info[0]) == len(frame_num[0]) + overlay_info = self.get_overlay_info(trajectory, camera_info) + ### TODO: fix the following to overlay the 2d point onto the frame for traj in trajectory: current_trajectory = np.asarray(traj[0]) frame_points = camera.lens.world_to_pixels(current_trajectory.T).T @@ -189,3 +187,54 @@ def overlay_trajectory(self, cam_id, trajectory): plt.figure() plt.imshow(frame) plt.show() + + def trajectory_to_frame_num(self, trajectory): + ''' + TODO: fetch the frame number from the trajectory + 1. get the time stamp field from the trajectory + 2. convert the time stamp to frame number + Refer to 'convert_datetime_to_frame_num' in 'video_util.py' + 3. return the frame number + ''' + frame_num = [] + start_time = self.MetadataContext.start_time + for traj in trajectory: + current_trajectory = traj[0] + date_times = current_trajectory['datetimes'] + frame_num.append([(datetime.datetime.strptime(t, "%Y-%m-%dT%H:%M:%S+00").replace(tzinfo = None) - start_time).total_seconds() for t in date_times]) + return frame_num + + def get_overlay_info(self, trajectory, camera_info): + ''' + TODO: overlay each trajectory 3d coordinate on to the frame specified by the camera_info + 1. for each trajectory, get the 3d coordinate + 2. get the camera_info associated to it + 3. implement the transformation function from 3d to 2d + given the single centroid point and camera configuration + refer to TODO in "senic_utils.py" + 4. return a list of (2d coordinate, frame name/filename) + ''' + result = [] + for traj_num in range(len(trajectory)): + traj_obj = trajectory[traj_num][0] # traj_obj means the trajectory of current object + traj_obj_3d = traj_obj['coordinates'] # 3d coordinate list of the object's trajectory + camera_info_obj = camera_info[traj_num] # camera info list corresponding the 3d coordinate + traj_obj_2d = [] # 2d coordinate list + for index in range(len(camera_info_obj)): + cur_camera_info = camera_info_obj[index] # camera info of the obejct in one point of the trajectory + centroid_3d = np.array(traj_obj_3d[index]) # one point of the trajectory in 3d + # in order to fit into the function transformation, we develop a dictionary called camera_config + camera_config = {} + camera_config['egoTranslation'] = cur_camera_info[1] + print(type(camera_config["egoTranslation"])) + camera_config['egoRotation'] = np.array(cur_camera_info[2]) + camera_config['cameraTranslation'] = cur_camera_info[3] + camera_config['cameraRotation'] = np.array(cur_camera_info[4]) + camera_config['cameraIntrinsic'] = np.array(cur_camera_info[5]) + traj_2d = transformation(centroid_3d, camera_config) # one point of the trajectory in 2d + + framenum = cur_camera_info[6] + filename = cur_camera_info[7] + traj_obj_2d.append((traj_2d, framenum, filename)) + result.append(traj_obj_2d) + return result \ No newline at end of file diff --git a/apperception/world_executor.py b/apperception/world_executor.py index 27eedeca..34b15a8f 100644 --- a/apperception/world_executor.py +++ b/apperception/world_executor.py @@ -30,11 +30,11 @@ def enable_tasm(self): if not self.tasm: self.tasm = tasm.TASM() - - def get_camera(self, cam_id=[]): + + def get_camera(self, scene_name, frame_num): assert self.curr_world, self.conn - cameras = fetch_camera(self.conn, self.curr_world.get_name(), cam_id) - # each camera appear like: + cameras = fetch_camera(self.conn, scene_name, frame_num) + ### each camera appear like: ### (cameraId, ratio, origin3d, focalpoints2d, fov, skev_factor) return cameras @@ -62,6 +62,10 @@ def tasm_get_video(self, metadata_results): def get_video(self, metadata_results): start_time = self.curr_world.VideoContext.start_time + # print("Start time is", start_time) + ### The cam nodes are raw data from the database + ### TODO: I forget why we used the data from the db instead of directly fetch + ### from the world cam_nodes = self.curr_world.get_video_cams video_files = [] for i in range(len(cam_nodes)): diff --git a/scenic_test.ipynb b/scenic_test.ipynb index b3858e33..725d9b83 100644 --- a/scenic_test.ipynb +++ b/scenic_test.ipynb @@ -23,8 +23,7 @@ "### IMPORTS\n", "import cv2\n", "\n", - "from scenic_world import *\n", - "from world_executor import *\n", + "from world import *\n", "from video_util import *\n", "from metadata_util import *\n", "import json\n", @@ -5268,6 +5267,13 @@ "\n", "\n", "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "\n", "\n", "\n", @@ -5282,14 +5288,6 @@ "\n", "\n", "\n", - "\n", - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ "\n", "\n", "\n", @@ -5822,6 +5820,13 @@ "\n", "\n", "\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "\n", "\n", "\n", From 17e574457568bf4b90aa923c28d5f217999ea63d Mon Sep 17 00:00:00 2001 From: "Chanwut (Mick) Kittivorawong" Date: Wed, 2 Mar 2022 14:38:04 -0800 Subject: [PATCH 18/26] clean up util --- apperception/scenic_util.py | 99 +++++++++++++++----------- apperception/video_context.py | 6 +- apperception/video_context_executor.py | 5 +- scenic_test.ipynb | 30 ++------ 4 files changed, 69 insertions(+), 71 deletions(-) diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py index 1d936a4a..5c95ab46 100644 --- a/apperception/scenic_util.py +++ b/apperception/scenic_util.py @@ -1,11 +1,11 @@ import numpy as np -from video_util import bbox_to_data3d, convert_timestamps from pyquaternion import Quaternion import json import os +import datetime from box import Box -CREATE_ITEMTRAJ_SQL ='''CREATE TABLE IF NOT EXISTS Test_Scenic_Item_General_Trajectory( +CREATE_ITEMTRAJ_SQL ='''CREATE TABLE IF NOT EXISTS Item_General_Trajectory( itemId TEXT, objectType TEXT, frameId TEXT, @@ -15,14 +15,14 @@ PRIMARY KEY (itemId) );''' -CREATE_BBOXES_SQL ='''CREATE TABLE IF NOT EXISTS Test_Scenic_General_Bbox( +CREATE_BBOXES_SQL ='''CREATE TABLE IF NOT EXISTS General_Bbox( itemId TEXT, trajBbox stbox, FOREIGN KEY(itemId) - REFERENCES Test_Scenic_Item_General_Trajectory(itemId) + REFERENCES Item_General_Trajectory(itemId) );''' -CREATE_CAMERA_SQL = '''CREATE TABLE IF NOT EXISTS Test_Scenic_Cameras( +CREATE_CAMERA_SQL = '''CREATE TABLE IF NOT EXISTS Cameras( cameraId TEXT, worldId TEXT, frameId TEXT, @@ -84,17 +84,17 @@ def create_or_insert_camera_table(conn, world_name, camera): Create and Populate A camera table with the given camera object. ''' #Doping Cameras table if already exists. - cursor.execute("DROP TABLE IF EXISTS Test_Scenic_Cameras") + cursor.execute("DROP TABLE IF EXISTS Cameras") # Formal_Scenic_cameras table stands for the formal table which won't be erased # Test for now cursor.execute(CREATE_CAMERA_SQL) print("Camera Table created successfully........") - insert_scenic_camera(conn, world_name, fetch_camera_config(camera.scenic_scene_name, camera.object_recognition.sample_data)) + insert_camera(conn, world_name, fetch_camera_config(camera.scenic_scene_name, camera.object_recognition.sample_data)) return CREATE_CAMERA_SQL # Helper function to insert the camera -def insert_scenic_camera(conn, world_name, camera_config): +def insert_camera(conn, world_name, camera_config): #Creating a cursor object using the cursor() method cursor = conn.cursor() values = [] @@ -114,7 +114,7 @@ def insert_scenic_camera(conn, world_name, camera_config): )''') cursor.execute(f''' - INSERT INTO Test_Scenic_Cameras ( + INSERT INTO Cameras ( cameraId, worldId, frameId, @@ -134,44 +134,44 @@ def insert_scenic_camera(conn, world_name, camera_config): conn.commit() # create collections in db and set index for quick query -def insert_scenic_data(scenic_data_dir, db): - with open(os.path.join(scenic_data_dir, 'v1.0-mini', 'sample_data.json')) as f: +def insert_data(data_dir, db): + with open(os.path.join(data_dir, 'v1.0-mini', 'sample_data.json')) as f: sample_data_json = json.load(f) db['sample_data'].insert_many(sample_data_json) db['sample_data'].create_index('token') db['sample_data'].create_index('filename') - with open(os.path.join(scenic_data_dir, 'v1.0-mini', 'attribute.json')) as f: + with open(os.path.join(data_dir, 'v1.0-mini', 'attribute.json')) as f: attribute_json = json.load(f) db['attribute'].insert_many(attribute_json) db['attribute'].create_index('token') - with open(os.path.join(scenic_data_dir, 'v1.0-mini', 'calibrated_sensor.json')) as f: + with open(os.path.join(data_dir, 'v1.0-mini', 'calibrated_sensor.json')) as f: calibrated_sensor_json = json.load(f) db['calibrated_sensor'].insert_many(calibrated_sensor_json) db['calibrated_sensor'].create_index('token') - with open(os.path.join(scenic_data_dir, 'v1.0-mini', 'category.json')) as f: + with open(os.path.join(data_dir, 'v1.0-mini', 'category.json')) as f: category_json = json.load(f) db['category'].insert_many(category_json) db['category'].create_index('token') - with open(os.path.join(scenic_data_dir, 'v1.0-mini', 'ego_pose.json')) as f: + with open(os.path.join(data_dir, 'v1.0-mini', 'ego_pose.json')) as f: ego_pose_json = json.load(f) db['ego_pose'].insert_many(ego_pose_json) db['ego_pose'].create_index('token') - with open(os.path.join(scenic_data_dir, 'v1.0-mini', 'instance.json')) as f: + with open(os.path.join(data_dir, 'v1.0-mini', 'instance.json')) as f: instance_json = json.load(f) db['instance'].insert_many(instance_json) db['instance'].create_index('token') - with open(os.path.join(scenic_data_dir, 'v1.0-mini', 'sample_annotation.json')) as f: + with open(os.path.join(data_dir, 'v1.0-mini', 'sample_annotation.json')) as f: sample_annotation_json = json.load(f) db['sample_annotation'].insert_many(sample_annotation_json) db['sample_annotation'].create_index('token') - with open(os.path.join(scenic_data_dir, 'v1.0-mini', 'frame_num.json')) as f: + with open(os.path.join(data_dir, 'v1.0-mini', 'frame_num.json')) as f: frame_num_json = json.load(f) db['frame_num'].insert_many(frame_num_json) db['frame_num'].create_index('token') @@ -254,7 +254,7 @@ def recognize(scene_name, sample_data, annotation): return annotations def add_recognized_objs(conn, formatted_result, start_time, default_depth=True): - clean_scenic_tables(conn) + clean_tables(conn) for item_id in formatted_result: object_type = formatted_result[item_id]["object_type"] recognized_bboxes = np.array(formatted_result[item_id]["bboxes"]) @@ -280,11 +280,11 @@ def add_recognized_objs(conn, formatted_result, start_time, default_depth=True): current_br = bottom_right[i] obj_traj.append([current_tl.tolist(), current_br.tolist()]) - scenic_bboxes_to_postgres(conn, item_id, object_type, "default_color", start_time, tracked_cnt, obj_traj, type="yolov4") + bboxes_to_postgres(conn, item_id, object_type, "default_color", start_time, tracked_cnt, obj_traj, type="yolov4") # bbox_to_tasm() # Insert bboxes to postgres -def scenic_bboxes_to_postgres(conn, item_id, object_type, color, start_time, timestamps, bboxes, type='yolov3'): +def bboxes_to_postgres(conn, item_id, object_type, color, start_time, timestamps, bboxes, type='yolov3'): if type == 'yolov3': timestamps = range(timestamps) @@ -295,12 +295,12 @@ def scenic_bboxes_to_postgres(conn, item_id, object_type, color, start_time, tim pairs.append(meta_box[0]) deltas.append(meta_box[1:]) postgres_timestamps = convert_timestamps(start_time, timestamps) - create_or_insert_scenic_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs) + create_or_insert_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs) # print(f"{item_id} saved successfully") # Create general trajectory table -def create_or_insert_scenic_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs): +def create_or_insert_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs): cursor = conn.cursor() ''' Create and Populate A Trajectory table using mobilityDB. @@ -312,29 +312,29 @@ def create_or_insert_scenic_general_trajectory(conn, item_id, object_type, color # Test for now cursor.execute(CREATE_ITEMTRAJ_SQL) - cursor.execute("CREATE INDEX IF NOT EXISTS traj_idx ON Test_Scenic_Item_General_Trajectory USING GiST(trajCentroids);") + cursor.execute("CREATE INDEX IF NOT EXISTS traj_idx ON Item_General_Trajectory USING GiST(trajCentroids);") conn.commit() # Formal_Scenic_General_Bbox table stands for the formal table which won't be erased # Test for now cursor.execute(CREATE_BBOXES_SQL) - cursor.execute("CREATE INDEX IF NOT EXISTS item_idx ON Test_Scenic_General_Bbox(itemId);") - cursor.execute("CREATE INDEX IF NOT EXISTS traj_bbox_idx ON Test_Scenic_General_Bbox USING GiST(trajBbox);") + cursor.execute("CREATE INDEX IF NOT EXISTS item_idx ON General_Bbox(itemId);") + cursor.execute("CREATE INDEX IF NOT EXISTS traj_bbox_idx ON General_Bbox USING GiST(trajBbox);") conn.commit() #Insert the trajectory of the first item - insert_scenic_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs) + insert_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs) # Insert general trajectory -def insert_scenic_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs): +def insert_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs): #Creating a cursor object using the cursor() method cursor = conn.cursor() #Inserting bboxes into Bbox table insert_bbox_trajectory = "" - insert_format = "INSERT INTO Test_Scenic_General_Bbox (itemId, trajBbox) "+ \ + insert_format = "INSERT INTO General_Bbox (itemId, trajBbox) "+ \ "VALUES (\'%s\'," % (item_id) # Insert the item_trajectory separately - insert_trajectory = "INSERT INTO Test_Scenic_Item_General_Trajectory (itemId, objectType, color, trajCentroids, largestBbox) "+ \ + insert_trajectory = "INSERT INTO Item_General_Trajectory (itemId, objectType, color, trajCentroids, largestBbox) "+ \ "VALUES (\'%s\', \'%s\', \'%s\', " % (item_id, object_type, color) traj_centroids = "\'{" min_ltx, min_lty, min_ltz, max_brx, max_bry, max_brz = float('inf'), float('inf'), float('inf'), float('-inf'), float('-inf'), float('-inf') @@ -422,7 +422,7 @@ def fetch_camera(conn, scene_name, frame_num): cameraIntrinsic, frameNum, fileName - FROM Test_Scenic_Cameras + FROM Cameras WHERE cameraId = '{scene_name}' AND frameNum IN {tuple(frame_num)}; @@ -430,19 +430,19 @@ def fetch_camera(conn, scene_name, frame_num): cursor.execute(query) return cursor.fetchall() -def clean_scenic_tables(conn): +def clean_tables(conn): cursor = conn.cursor() - cursor.execute("DROP TABLE IF EXISTS test_scenic_General_Bbox;") - cursor.execute("DROP TABLE IF EXISTS test_scenic_Item_General_Trajectory;") + cursor.execute("DROP TABLE IF EXISTS General_Bbox;") + cursor.execute("DROP TABLE IF EXISTS Item_General_Trajectory;") conn.commit() def export_tables(conn): # create a query to specify which values we want from the database. s = "SELECT *" s += " FROM " - s_trajectory = s + "Test_Scenic_Item_General_Trajectory" - s_bbox = s + "Test_Scenic_General_Bbox" - s_camera = s + "Test_Scenic_Cameras" + s_trajectory = s + "Item_General_Trajectory" + s_bbox = s + "General_Bbox" + s_camera = s + "Cameras" # set up our database connection. db_cursor = conn.cursor() @@ -472,10 +472,27 @@ def import_tables(conn): cur.execute(CREATE_BBOXES_SQL) conn.commit() with open('test_camera.csv', 'r') as camera_f: - cur.copy_expert(file=camera_f, sql="COPY test_scenic_cameras FROM STDIN CSV HEADER DELIMITER as ','") + cur.copy_expert(file=camera_f, sql="COPY Cameras FROM STDIN CSV HEADER DELIMITER as ','") with open('test_trajectory.csv', 'r') as trajectory_f: - cur.copy_expert(file=trajectory_f, sql="COPY test_scenic_item_general_trajectory FROM STDIN CSV HEADER DELIMITER as ','") + cur.copy_expert(file=trajectory_f, sql="COPY Item_General_Trajectory FROM STDIN CSV HEADER DELIMITER as ','") with open('test_bbox.csv', 'r') as bbox_f: - cur.copy_expert(file=bbox_f, sql="COPY test_scenic_general_bbox FROM STDIN CSV HEADER DELIMITER as ','") + cur.copy_expert(file=bbox_f, sql="COPY General_Bbox FROM STDIN CSV HEADER DELIMITER as ','") - conn.commit() \ No newline at end of file + conn.commit() + +# Helper function to convert the timestam to the timestamp formula pg-trajectory uses +def convert_timestamps(start_time, timestamps): + return [str(start_time + datetime.timedelta(seconds=t)) for t in timestamps] + +# Helper function to convert trajectory to centroids +def bbox_to_data3d(bbox): + ''' + Compute the center, x, y, z delta of the bbox + ''' + tl, br = bbox + x_delta = (br[0] - tl[0])/2 + y_delta = (br[1] - tl[1])/2 + z_delta = (br[2] - tl[2])/2 + center = (tl[0] + x_delta, tl[1] + y_delta, tl[2] + z_delta) + + return center, x_delta, y_delta, z_delta \ No newline at end of file diff --git a/apperception/video_context.py b/apperception/video_context.py index 14216f1f..616231f7 100644 --- a/apperception/video_context.py +++ b/apperception/video_context.py @@ -5,11 +5,7 @@ from typing import Any, Dict, List, Optional, Tuple import psycopg2 -from bounding_box import WHOLE_FRAME, BoundingBox -from lens import Lens -from point import Point -from tracker import Tracker -from video_util import Units +import datetime class Camera: diff --git a/apperception/video_context_executor.py b/apperception/video_context_executor.py index aed97cce..f6415e19 100644 --- a/apperception/video_context_executor.py +++ b/apperception/video_context_executor.py @@ -1,5 +1,6 @@ -from video_context import * -from scenic_util import * +from video_context import VideoContext +from video_util import create_or_insert_world_table, video_data_to_tasm, metadata_to_tasm +from scenic_util import create_or_insert_camera_table, recognize, add_recognized_objs class VideoContextExecutor: diff --git a/scenic_test.ipynb b/scenic_test.ipynb index 725d9b83..a82cb5db 100644 --- a/scenic_test.ipynb +++ b/scenic_test.ipynb @@ -5,17 +5,8 @@ "execution_count": 1, "id": "11413b36", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/Users/chanwutk/Documents/apperception\n" - ] - } - ], + "outputs": [], "source": [ - "%cd ..\n", "import os\n", "import sys\n", "sys.path.append(os.path.join(os.getcwd(),\"apperception\"))\n", @@ -24,7 +15,6 @@ "import cv2\n", "\n", "from world import *\n", - "from video_util import *\n", "from metadata_util import *\n", "import json\n", "import pandas as pd\n", @@ -5267,6 +5257,12 @@ "\n", "\n", "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n" ] }, @@ -5815,18 +5811,6 @@ "\n", "\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ "\n", "\n", "\n", From e880a32500897b717874381fcacfa7dae9fca9e4 Mon Sep 17 00:00:00 2001 From: "Chanwut (Mick) Kittivorawong" Date: Wed, 2 Mar 2022 14:42:38 -0800 Subject: [PATCH 19/26] clean up video_util.py --- apperception/video_util.py | 498 +++---------------------------------- 1 file changed, 28 insertions(+), 470 deletions(-) diff --git a/apperception/video_util.py b/apperception/video_util.py index f573c799..9ec85d9e 100644 --- a/apperception/video_util.py +++ b/apperception/video_util.py @@ -1,20 +1,3 @@ -import datetime -from typing import Any, Dict, Optional - -import cv2 -import numpy as np -from bounding_box import WHOLE_FRAME, BoundingBox -from lens import Lens -from object_tracker_yolov4_deepsort import yolov4_deepsort_video_track -from object_tracker_yolov5_deepsort import (TrackedObject, YoloV5Opt, - yolov5_deepsort_video_track) -from tracker import Tracker -from typing_extensions import Literal - -# TODO: add more units -Units = Literal["metrics"] - - def video_data_to_tasm(video_file, metadata_id, t): t.store(video_file, metadata_id) @@ -47,456 +30,31 @@ def bound_height(y): t.add_bulk_metadata(metadata_info) -def convert_datetime_to_frame_num(start_time, date_times): - - return [(t.replace(tzinfo=None) - start_time).total_seconds() for t in date_times] - - -def get_video_roi(file_name, cam_video_file, rois, times): - """ - Get the region of interest from the video, based on bounding box points in - video coordinates. - - Args: - file_name: String of file name to save video as - rois: A list of bounding boxes - time_intervals: A list of time intervals of which frames - """ - - rois = np.array(rois).T - print(rois.shape) - len_x, len_y = np.max(rois.T[2] - rois.T[0]), np.max(rois.T[3] - rois.T[1]) - # len_x, len_y = np.max(rois.T[0][1] - rois.T[0][0]), np.max(rois.T[1][1] - rois.T[1][0]) - - len_x = int(round(len_x)) - len_y = int(round(len_y)) - # print(len_x) - # print(len_y) - vid_writer = cv2.VideoWriter( - file_name, cv2.VideoWriter_fourcc("m", "p", "4", "v"), 30, (len_x, len_y) - ) - # print("rois") - # print(rois) - start_time = int(times[0]) - cap = cv2.VideoCapture(cam_video_file) - frame_cnt = 0 - while cap.isOpened(): - # Capture frame-by-frame - ret, frame = cap.read() - if frame_cnt in times and ret: - i = frame_cnt - start_time - if i >= len(rois): - print("incorrect length:", len(rois)) - break - current_roi = rois[i] - - b_x, b_y, e_x, e_y = current_roi - b_x, b_y = max(0, b_x), max(0, b_y) - # e_x, e_y = current_roi[1] - e_x, e_y = max(0, e_x), max(0, e_y) - diff_y, diff_x = int(abs(e_y - b_y)), int(abs(e_x - b_x)) - pad_y = int((len_y - diff_y) // 2) - pad_x = int((len_x - diff_x) // 2) - - # print("padding") - # print(pad_y) - # print(pad_x) - roi_byte = frame[int(b_y) : int(e_y), int(b_x) : int(e_x), :] - - roi_byte = np.pad( - roi_byte, - pad_width=[ - (pad_y, len_y - diff_y - pad_y), - (pad_x, len_x - diff_x - pad_x), - (0, 0), - ], - ) - frame = cv2.cvtColor(roi_byte, cv2.COLOR_RGB2BGR) - - vid_writer.write(roi_byte) - frame_cnt += 1 - if not ret: - break - - vid_writer.release() - - -def create_or_insert_world_table(conn, name, units: Units): - # Creating a cursor object using the cursor() method - cursor = conn.cursor() - """ - Create and Populate A world table with the given world object. - """ - # Doping Worlds table if already exists. - cursor.execute("DROP TABLE IF EXISTS Worlds;") - # Creating table with the first world - sql = """CREATE TABLE IF NOT EXISTS Worlds( - worldId TEXT PRIMARY KEY, - units TEXT - );""" - cursor.execute(sql) - print("Worlds Table created successfully........") - insert_world(conn, name, units) - return sql - - -def insert_world(conn, name, units: Units): - """Helper function to insert the world""" - # Creating a cursor object using the cursor() method - cursor = conn.cursor() - cursor.execute( - """INSERT INTO Worlds (worldId, units) """ + """VALUES (\'%s\', \'%s\');""" % (name, units) - ) - print("New world inserted successfully........") - # Insert the existing cameras of the current world into the camera table - conn.commit() - - -def create_or_insert_camera_table(conn, world_name, camera): - """Create a camera table""" - # Creating a cursor object using the cursor() method - cursor = conn.cursor() - """ - Create and Populate A camera table with the given camera object. - """ - # Doping Cameras table if already exists. - cursor.execute("DROP TABLE IF EXISTS Cameras") - # Creating table with the first camera - sql = "\n".join( - [ - "CREATE TABLE IF NOT EXISTS Cameras(", - " cameraId TEXT,", - " worldId TEXT,", - " ratio real,", - " origin geometry,", - " focalpoints geometry,", - " fov INTEGER,", - " skev_factor real,", - " width integer,", - " height integer", - ");", - ] - ) - cursor.execute(sql) - print("Camera Table created successfully........") - insert_camera(conn, world_name, camera) - return sql - - -def insert_camera(conn, world_name, camera_node): - """Helper function to insert the camera""" - # Creating a cursor object using the cursor() method - cursor = conn.cursor() - lens = camera_node.lens - focal_x = str(lens.focal_x) - focal_y = str(lens.focal_y) - cam_x, cam_y, cam_z = str(lens.cam_origin[0]), str(lens.cam_origin[1]), str(lens.cam_origin[2]) - width, height = camera_node.dimension - cursor.execute( - """INSERT INTO Cameras (cameraId, worldId, ratio, origin, focalpoints, fov, skev_factor, width, height) """ - + """VALUES (\'%s\', \'%s\', %f, \'POINT Z (%s %s %s)\', \'POINT(%s %s)\', %s, %f, %d, %d);""" - % ( - camera_node.cam_id, - world_name, - camera_node.ratio, - cam_x, - cam_y, - cam_z, - focal_x, - focal_y, - lens.fov, - lens.alpha, - width, - height, - ) - ) - print("New camera inserted successfully.........") - conn.commit() - - -def get_video_dimension(video_file: str): - vid: cv2.VideoCapture = cv2.VideoCapture(video_file) - width = vid.get(cv2.CAP_PROP_FRAME_WIDTH) - height = vid.get(cv2.CAP_PROP_FRAME_HEIGHT) - # width and height are floats - return (int(width), int(height)) - - -def recognize( - video_file: str, - recog_algo: str = "", - tracker_type: str = "default", - customized_tracker: Optional[Tracker] = None, - recognition_area: BoundingBox = WHOLE_FRAME, -): - """Default object recognition (YOLOv5)""" - # recognition = item.ItemRecognition(recog_algo = recog_algo, tracker_type = tracker_type, customized_tracker = customized_tracker) - # return recognition.video_item_recognize(video.byte_array) - if recognition_area.is_whole_frame(): - recognition_area = BoundingBox(0, 0, 100, 100) - if recog_algo == "yolov4": - return yolov4_deepsort_video_track(video_file, recognition_area) - else: - # use YoloV5 as default - return yolov5_deepsort_video_track(YoloV5Opt(video_file, recognition_area=recognition_area)) - - -def add_recognized_objs( - conn: Any, - lens: Lens, - formatted_result: Dict[str, TrackedObject], - start_time: datetime.datetime, - properties: dict = {"color": {}}, - default_depth: bool = True, -): - # TODO: move cleaning to apperception_benchmark.py - clean_tables(conn) - for item_id in formatted_result: - object_type = formatted_result[item_id].object_type - recognized_bboxes = np.array( - [bbox.to_tuples() for bbox in formatted_result[item_id].bboxes] - ) - tracked_cnt = formatted_result[item_id].tracked_cnt - top_left = np.vstack((recognized_bboxes[:, 0, 0], recognized_bboxes[:, 0, 1])) - if default_depth: - top_left_depths = np.ones(len(recognized_bboxes)) - else: - top_left_depths = self.__get_depths_of_points( - recognized_bboxes[:, 0, 0], recognized_bboxes[:, 0, 1] - ) - top_left = lens.pixels_to_world(top_left, top_left_depths) - - # Convert bottom right coordinates to world coordinates - bottom_right = np.vstack((recognized_bboxes[:, 1, 0], recognized_bboxes[:, 1, 1])) - if default_depth: - bottom_right_depths = np.ones(len(tracked_cnt)) - else: - bottom_right_depths = self.__get_depths_of_points( - recognized_bboxes[:, 1, 0], recognized_bboxes[:, 1, 1] - ) - bottom_right = lens.pixels_to_world(bottom_right, bottom_right_depths) - - top_left = np.array(top_left.T) - bottom_right = np.array(bottom_right.T) - obj_traj = [] - for i in range(len(top_left)): - current_tl = top_left[i] - current_br = bottom_right[i] - obj_traj.append([current_tl.tolist(), current_br.tolist()]) - - bbox_to_postgres( - conn, - item_id, - object_type, - "default_color" if item_id not in properties["color"] else properties["color"][item_id], - start_time, - tracked_cnt, - obj_traj, - type="yolov4", - ) - # bbox_to_tasm() - -def convert_timestamps(start_time, timestamps): - """Helper function to convert the timestam to the timestamp formula pg-trajectory uses""" - return [str(start_time + datetime.timedelta(seconds=t)) for t in timestamps] - - -def bbox_to_data3d(bbox): - """Helper function to convert trajectory to centroids - Compute the center, x, y, z delta of the bbox - """ - tl, br = bbox - x_delta = (br[0] - tl[0]) / 2 - y_delta = (br[1] - tl[1]) / 2 - z_delta = (br[2] - tl[2]) / 2 - center = (tl[0] + x_delta, tl[1] + y_delta, tl[2] + z_delta) - - return center, x_delta, y_delta, z_delta - - -def bbox_to_postgres( - conn, item_id, object_type, color, start_time, timestamps, bboxes, type="yolov3" -): - """Insert bboxes to postgres""" - if type == "yolov3": - timestamps = range(timestamps) - - converted_bboxes = [bbox_to_data3d(bbox) for bbox in bboxes] - pairs = [] - deltas = [] - for meta_box in converted_bboxes: - pairs.append(meta_box[0]) - deltas.append(meta_box[1:]) - postgres_timestamps = convert_timestamps(start_time, timestamps) - create_or_insert_general_trajectory( - conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs - ) - print(f"{item_id} saved successfully") - - -# Insert bboxes to postgres -def scenic_bboxes_to_postgres(conn, item_id, object_type, color, start_time, timestamps, bboxes, type='yolov3'): - ### TODO: Modify the following codes to add recognized scenic objects to the database - if type == 'yolov3': - timestamps = range(timestamps) - - converted_bboxes = [bbox_to_data3d(bbox) for bbox in bboxes] - pairs = [] - deltas = [] - for meta_box in converted_bboxes: - pairs.append(meta_box[0]) - deltas.append(meta_box[1:]) - postgres_timestamps = convert_timestamps(start_time, timestamps) - create_or_insert_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs) - print(f"{item_id} saved successfully") - -def clean_tables(conn): - cursor = conn.cursor() - cursor.execute("DROP TABLE IF EXISTS General_Bbox;") - cursor.execute("DROP TABLE IF EXISTS Item_General_Trajectory;") - conn.commit() - - -def create_or_insert_general_trajectory( - conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs -): - """Create general trajectory table""" - # Creating a cursor object using the cursor() method - cursor = conn.cursor() - """ - Create and Populate A Trajectory table using mobilityDB. - Now the timestamp matches, the starting time should be the meta data of the world - Then the timestamp should be the timestamp regarding the world starting time - """ - - # Creating table with the first item - create_itemtraj_sql = """CREATE TABLE IF NOT EXISTS Item_General_Trajectory( - itemId TEXT, - objectType TEXT, - color TEXT, - trajCentroids tgeompoint, - largestBbox stbox, - PRIMARY KEY (itemId) - );""" - cursor.execute(create_itemtraj_sql) - cursor.execute( - "CREATE INDEX IF NOT EXISTS traj_idx ON Item_General_Trajectory USING GiST(trajCentroids);" - ) - conn.commit() - # Creating table with the first item - create_bboxes_sql = """CREATE TABLE IF NOT EXISTS General_Bbox( - itemId TEXT, - trajBbox stbox, - FOREIGN KEY(itemId) - REFERENCES Item_General_Trajectory(itemId) - );""" - cursor.execute(create_bboxes_sql) - cursor.execute("CREATE INDEX IF NOT EXISTS item_idx ON General_Bbox(itemId);") - cursor.execute("CREATE INDEX IF NOT EXISTS traj_bbox_idx ON General_Bbox USING GiST(trajBbox);") - conn.commit() - # Insert the trajectory of the first item - insert_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs) - - -def insert_general_trajectory( - conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs -): - """Insert general trajectory""" - # Creating a cursor object using the cursor() method - cursor = conn.cursor() - # Inserting bboxes into Bbox table - insert_bbox_trajectory = "" - insert_format = "INSERT INTO General_Bbox (itemId, trajBbox) " + "VALUES ('%s'," % (item_id) - # Insert the item_trajectory separately - insert_trajectory = ( - "INSERT INTO Item_General_Trajectory (itemId, objectType, color, trajCentroids, largestBbox) " - + "VALUES ('%s', '%s', '%s', " % (item_id, object_type, color) - ) - traj_centroids = "'{" - min_ltx, min_lty, min_ltz, max_brx, max_bry, max_brz = ( - float("inf"), - float("inf"), - float("inf"), - float("-inf"), - float("-inf"), - float("-inf"), - ) - # max_ltx, max_lty, max_ltz, min_brx, min_bry, min_brz = float('-inf'), float('-inf'), float('-inf'), float('inf'), float('inf'), float('inf') - for i in range(len(postgres_timestamps)): - postgres_timestamp = postgres_timestamps[i] - # Insert bbox - # print(bboxes[i]) - tl, br = bboxes[i] - min_ltx, min_lty, min_ltz, max_brx, max_bry, max_brz = ( - min(tl[0], min_ltx), - min(tl[1], min_lty), - min(tl[2], min_ltz), - max(br[0], max_brx), - max(br[1], max_bry), - max(br[2], max_brz), - ) - # max_ltx, max_lty, max_ltz, min_brx, min_bry, min_brz = max(tl[0], max_ltx), max(tl[1], max_lty), max(tl[2], max_ltz),\ - # min(br[0], min_brx), min(br[1], min_bry), min(br[2], min_brz) - current_bbox_sql = "stbox 'STBOX ZT((%s, %s, %s, %s), (%s, %s, %s, %s))');" % ( - tl[0], - tl[1], - tl[2], - postgres_timestamp, - br[0], - br[1], - br[2], - postgres_timestamp, - ) - insert_bbox_trajectory += insert_format + current_bbox_sql - # Construct trajectory - current_point = pairs[i] - tg_pair_centroid = "POINT Z (%s %s %s)@%s," % ( - str(current_point[0]), - str(current_point[1]), - str(current_point[2]), - postgres_timestamp, - ) - traj_centroids += tg_pair_centroid - traj_centroids = traj_centroids[:-1] - traj_centroids += "}', " - insert_trajectory += traj_centroids - insert_trajectory += ( - "stbox 'STBOX Z((%s, %s, %s)," - % ( - min_ltx, - min_lty, - min_ltz, - ) - + "(%s, %s, %s))'); " % (max_brx, max_bry, max_brz) - ) - cursor.execute(insert_trajectory) - cursor.execute(insert_bbox_trajectory) - # Commit your changes in the database - conn.commit() - - -def merge_trajectory(item_id, new_postgres_timestamps, new_bboxes, new_pairs): - # Fetch the timestamps of the current trajectory from the database - # Filter out the already had timestamp from the new timestamps - # Construct the adding trajectory - # Calling the merge function of mobilitydb - # do the same thing for the bboxes - return - - -def fetch_camera(conn, world_id, cam_id=[]): - cursor = conn.cursor() - - if cam_id == []: - query = ( - """SELECT cameraId, ratio, ST_X(origin), ST_Y(origin), ST_Z(origin), ST_X(focalpoints), ST_Y(focalpoints), fov, skev_factor """ - + """FROM Cameras WHERE worldId = \'%s\';""" % world_id - ) - else: - query = ( - """SELECT cameraId, ratio, ST_X(origin), ST_Y(origin), ST_Z(origin), ST_X(focalpoints), ST_Y(focalpoints), fov, skev_factor """ - + """FROM Cameras WHERE cameraId IN (\'%s\') AND worldId = \'%s\';""" - % (",".join(cam_id), world_id) - ) - cursor.execute(query) - return cursor.fetchall() +def create_or_insert_world_table(conn, name, units): + #Creating a cursor object using the cursor() method + cursor = conn.cursor() + ''' + Create and Populate A world table with the given world object. + ''' + #Doping Worlds table if already exists. + cursor.execute("DROP TABLE IF EXISTS Worlds;") + #Creating table with the first world + sql = '''CREATE TABLE IF NOT EXISTS Worlds( + worldId TEXT PRIMARY KEY, + units TEXT + );''' + cursor.execute(sql) + print("Worlds Table created successfully........") + insert_world(conn, name, units) + return sql + +# Helper function to insert the world +def insert_world(conn, name, units): + #Creating a cursor object using the cursor() method + cursor = conn.cursor() + cursor.execute('''INSERT INTO Worlds (worldId, units) '''+ \ + '''VALUES (\'%s\', \'%s\');''' \ + %(name, units)) + print("New world inserted successfully........") + #Insert the existing cameras of the current world into the camera table + conn.commit() From 30a4071455937020b7b00fd0db26793a59bd64f4 Mon Sep 17 00:00:00 2001 From: "Chanwut (Mick) Kittivorawong" Date: Wed, 2 Mar 2022 15:50:09 -0800 Subject: [PATCH 20/26] clean up --- apperception/world.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/apperception/world.py b/apperception/world.py index 45af8618..b80a57f0 100644 --- a/apperception/world.py +++ b/apperception/world.py @@ -190,7 +190,7 @@ def overlay_trajectory(self, scene_name, trajectory): def trajectory_to_frame_num(self, trajectory): ''' - TODO: fetch the frame number from the trajectory + fetch the frame number from the trajectory 1. get the time stamp field from the trajectory 2. convert the time stamp to frame number Refer to 'convert_datetime_to_frame_num' in 'video_util.py' @@ -201,12 +201,16 @@ def trajectory_to_frame_num(self, trajectory): for traj in trajectory: current_trajectory = traj[0] date_times = current_trajectory['datetimes'] - frame_num.append([(datetime.datetime.strptime(t, "%Y-%m-%dT%H:%M:%S+00").replace(tzinfo = None) - start_time).total_seconds() for t in date_times]) + frame_num.append([ + (datetime.datetime.strptime(t, "%Y-%m-%dT%H:%M:%S+00").replace(tzinfo=None) - start_time).total_seconds() + for t + in date_times + ]) return frame_num def get_overlay_info(self, trajectory, camera_info): ''' - TODO: overlay each trajectory 3d coordinate on to the frame specified by the camera_info + overlay each trajectory 3d coordinate on to the frame specified by the camera_info 1. for each trajectory, get the 3d coordinate 2. get the camera_info associated to it 3. implement the transformation function from 3d to 2d @@ -226,7 +230,6 @@ def get_overlay_info(self, trajectory, camera_info): # in order to fit into the function transformation, we develop a dictionary called camera_config camera_config = {} camera_config['egoTranslation'] = cur_camera_info[1] - print(type(camera_config["egoTranslation"])) camera_config['egoRotation'] = np.array(cur_camera_info[2]) camera_config['cameraTranslation'] = cur_camera_info[3] camera_config['cameraRotation'] = np.array(cur_camera_info[4]) From e83b44e1687106d44ea0e60d140535283d18c6da Mon Sep 17 00:00:00 2001 From: "Chanwut (Mick) Kittivorawong" Date: Thu, 3 Mar 2022 21:31:17 -0800 Subject: [PATCH 21/26] fix errors from rebase --- apperception/metadata_context.py | 2 +- apperception/scenic_util.py | 2 +- apperception/video_context_executor.py | 30 ++++++++++---------------- apperception/video_util.py | 5 ++++- apperception/world_executor.py | 3 +-- 5 files changed, 18 insertions(+), 24 deletions(-) diff --git a/apperception/metadata_context.py b/apperception/metadata_context.py index d7cab6a7..e3273905 100644 --- a/apperception/metadata_context.py +++ b/apperception/metadata_context.py @@ -69,7 +69,7 @@ def __init__(self, func_name: str, parameters: list = []): class asMFJSON(Aggregate): - def __init__(self, func_name="asMFJSON", parameters: list = [], interesting_fields=[""]): + def __init__(self, func_name="asMFJSON", parameters: list = [], interesting_fields=[]): super().__init__(func_name, parameters) self.interesting_fields = interesting_fields diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py index 5c95ab46..ebfb56ea 100644 --- a/apperception/scenic_util.py +++ b/apperception/scenic_util.py @@ -425,7 +425,7 @@ def fetch_camera(conn, scene_name, frame_num): FROM Cameras WHERE cameraId = '{scene_name}' AND - frameNum IN {tuple(frame_num)}; + frameNum IN ({",".join(map(str, frame_num))}); ''' cursor.execute(query) return cursor.fetchall() diff --git a/apperception/video_context_executor.py b/apperception/video_context_executor.py index f6415e19..b1426998 100644 --- a/apperception/video_context_executor.py +++ b/apperception/video_context_executor.py @@ -1,4 +1,6 @@ -from video_context import VideoContext +from typing import Any, List, Set +from bounding_box import BoundingBox +from video_context import Camera, VideoContext from video_util import create_or_insert_world_table, video_data_to_tasm, metadata_to_tasm from scenic_util import create_or_insert_camera_table, recognize, add_recognized_objs @@ -21,31 +23,21 @@ def visit(self): return video_query def visit_world(self): - # Query to store world in database + # Query to store world in database name, units = self.current_context.name, self.current_context.units + world_sql = create_or_insert_world_table(self.conn, name, units) - if name not in created_world: - world_sql = create_or_insert_world_table(self.conn, name, units) - created_world.add(name) - - all_sqls: List[str] = [] + all_sqls = [] cameras = self.current_context.camera_nodes - for c in cameras.values(): - camera_sql = self.visit_camera(c) - all_sqls.append(camera_sql) + if len(cameras) != 0: + for c in cameras.values(): + camera_sql = self.visit_camera(c) + all_sqls.append(camera_sql) return all_sqls def visit_camera(self, camera_node: Camera): world_name = self.current_context.name - camera_sql = "" - - if camera_node.cam_id not in visited_camera: - # Only insert camera once - camera_node.dimension = get_video_dimension(camera_node.video_file) - camera_sql = create_or_insert_camera_table(self.conn, world_name, camera_node) - visited_camera.add(camera_node.cam_id) - recognized_areas[camera_node.cam_id] = set() - + camera_sql = create_or_insert_camera_table(self.conn, world_name, camera_node) if camera_node.object_recognition is not None: self.visit_obj_rec(camera_node, camera_node.object_recognition) if self.tasm: diff --git a/apperception/video_util.py b/apperception/video_util.py index 9ec85d9e..f4d690da 100644 --- a/apperception/video_util.py +++ b/apperception/video_util.py @@ -1,8 +1,11 @@ +from typing import Any, Dict + + def video_data_to_tasm(video_file, metadata_id, t): t.store(video_file, metadata_id) -def metadata_to_tasm(formatted_result: Dict[str, TrackedObject], metadata_id, t): +def metadata_to_tasm(formatted_result: Dict[str, Any], metadata_id, t): import tasm metadata_info = [] diff --git a/apperception/world_executor.py b/apperception/world_executor.py index 34b15a8f..00687d3e 100644 --- a/apperception/world_executor.py +++ b/apperception/world_executor.py @@ -3,8 +3,7 @@ from metadata_context import geometry, primarykey, time from metadata_context_executor import MetadataContextExecutor from video_context_executor import VideoContextExecutor -from video_util import (convert_datetime_to_frame_num, fetch_camera, - get_video_roi) +from scenic_util import (fetch_camera) class WorldExecutor: From 9ba83b85150ade4f2e7882ef12d28b6ac96d9a1f Mon Sep 17 00:00:00 2001 From: "Chanwut (Mick) Kittivorawong" Date: Fri, 4 Mar 2022 11:17:46 -0800 Subject: [PATCH 22/26] clean up insert_general_trajectory --- apperception/scenic_util.py | 86 +- scenic_test.ipynb | 2265 ++++------------------------------- 2 files changed, 293 insertions(+), 2058 deletions(-) diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py index ebfb56ea..fd22c667 100644 --- a/apperception/scenic_util.py +++ b/apperception/scenic_util.py @@ -1,3 +1,4 @@ +from typing import Iterable, List, Tuple, Union import numpy as np from pyquaternion import Quaternion import json @@ -325,44 +326,67 @@ def create_or_insert_general_trajectory(conn, item_id, object_type, color, postg insert_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs) +def join(array: Iterable, delim: str = ','): + return delim.join(map(str, array)) + + # Insert general trajectory -def insert_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs): +def insert_general_trajectory( + conn, + item_id: str, + object_type: str, + color: str, + postgres_timestamps: List[str], + bboxes: List[List[List[float]]], # TODO: should be (float, float, float), (float, float, float))[] + pairs: List[Tuple[float, float, float]] +): #Creating a cursor object using the cursor() method cursor = conn.cursor() + #Inserting bboxes into Bbox table - insert_bbox_trajectory = "" - insert_format = "INSERT INTO General_Bbox (itemId, trajBbox) "+ \ - "VALUES (\'%s\'," % (item_id) - # Insert the item_trajectory separately - insert_trajectory = "INSERT INTO Item_General_Trajectory (itemId, objectType, color, trajCentroids, largestBbox) "+ \ - "VALUES (\'%s\', \'%s\', \'%s\', " % (item_id, object_type, color) - traj_centroids = "\'{" - min_ltx, min_lty, min_ltz, max_brx, max_bry, max_brz = float('inf'), float('inf'), float('inf'), float('-inf'), float('-inf'), float('-inf') - # max_ltx, max_lty, max_ltz, min_brx, min_bry, min_brz = float('-inf'), float('-inf'), float('-inf'), float('inf'), float('inf'), float('inf') - for i in range(len(postgres_timestamps)): - postgres_timestamp = postgres_timestamps[i] + insert_bbox_trajectories_builder = [] + min_tl = np.full(3, np.inf) + max_br = np.full(3, np.NINF) + + traj_centroids = [] + + for timestamp, (tl, br), current_point in zip(postgres_timestamps, bboxes, pairs): + min_tl = np.minimum(tl, min_tl) + max_br = np.maximum(br, max_br) + ### Insert bbox - # print(bboxes[i]) - tl, br = bboxes[i] - min_ltx, min_lty, min_ltz, max_brx, max_bry, max_brz = min(tl[0], min_ltx), min(tl[1], min_lty), min(tl[2], min_ltz),\ - max(br[0], max_brx), max(br[1], max_bry), max(br[2], max_brz) - # max_ltx, max_lty, max_ltz, min_brx, min_bry, min_brz = max(tl[0], max_ltx), max(tl[1], max_lty), max(tl[2], max_ltz),\ - # min(br[0], min_brx), min(br[1], min_bry), min(br[2], min_brz) - current_bbox_sql = "stbox \'STBOX ZT((%s, %s, %s, %s), (%s, %s, %s, %s))\');" \ - %(tl[0], tl[1], tl[2], postgres_timestamp, br[0], br[1], br[2], postgres_timestamp) - insert_bbox_trajectory += insert_format + current_bbox_sql + insert_bbox_trajectories_builder.append(f""" + INSERT INTO General_Bbox (itemId, trajBbox) + VALUES ( + '{item_id}', + STBOX 'STBOX ZT( + ({join([*tl, timestamp])}), + ({join([*br, timestamp])}) + )' + ); + """) + ### Construct trajectory - current_point = pairs[i] - tg_pair_centroid = "POINT Z (%s %s %s)@%s," \ - %(str(current_point[0]), str(current_point[1]), str(current_point[2]), postgres_timestamp) - traj_centroids += tg_pair_centroid - traj_centroids = traj_centroids[:-1] - traj_centroids += "}\', " - insert_trajectory += traj_centroids - insert_trajectory += "stbox \'STBOX Z((%s, %s, %s),"%(min_ltx, min_lty, min_ltz)\ - +"(%s, %s, %s))\'); "%(max_brx, max_bry, max_brz) + traj_centroids.append(f"POINT Z ({join(current_point, ' ')})@{timestamp}") + + # Insert the item_trajectory separately + insert_trajectory = f""" + INSERT INTO Item_General_Trajectory (itemId, objectType, color, trajCentroids, largestBbox) + VALUES ( + '{item_id}', + '{object_type}', + '{color}', + '{{{', '.join(traj_centroids)}}}', + STBOX 'STBOX Z( + ({join(min_tl)}), + ({join(max_br)}) + )' + ); + """ + cursor.execute(insert_trajectory) - cursor.execute(insert_bbox_trajectory) + cursor.execute(''.join(insert_bbox_trajectories_builder)) + # Commit your changes in the database conn.commit() diff --git a/scenic_test.ipynb b/scenic_test.ipynb index a82cb5db..3ce28f1b 100644 --- a/scenic_test.ipynb +++ b/scenic_test.ipynb @@ -623,7 +623,234 @@ "New world inserted successfully........\n", "Camera Table created successfully........\n", "New camera inserted successfully.........\n", - "Recognization done, saving to database......\n" + "Recognization done, saving to database......\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" ] } ], @@ -646,9 +873,9 @@ "Module(body=[Return(value=Compare(left=Attribute(value=Name(id='obj', ctx=Load()), attr='object_type', ctx=Load()), ops=[Eq()], comparators=[Str(s='vehicle.car')]))])\n", "Worlds Table created successfully........\n", "New world inserted successfully........\n", - "atPeriodSet(Test_Scenic_Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}')\n", - "asMFJSON(atPeriodSet(Test_Scenic_Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}'))::json\n", - "SELECT asMFJSON(atPeriodSet(Test_Scenic_Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}'))::json From Test_Scenic_Item_General_Trajectory Where Test_Scenic_Item_General_Trajectory.objectType='vehicle.car';\n", + "atPeriodSet(Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}')\n", + "asMFJSON(atPeriodSet(Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}'))::json\n", + "SELECT asMFJSON(atPeriodSet(Item_General_Trajectory.trajCentroids,'{[0001-01-01 00:00:00, 9999-12-31 23:59:59.999999)}'))::json From Item_General_Trajectory Where Item_General_Trajectory.objectType='vehicle.car';\n", "\n" ] } @@ -4411,2022 +4638,6 @@ "id": "ed2962ed", "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, { "data": { "text/plain": [ @@ -14472,13 +12683,13 @@ "Module(body=[Return(value=Compare(left=Call(func=Name(id='Tmax', ctx=Load()), args=[Attribute(value=Name(id='obj', ctx=Load()), attr='location', ctx=Load())], keywords=[]), ops=[Lt()], comparators=[Name(id='end', ctx=Load())]))])\n", "Worlds Table created successfully........\n", "New world inserted successfully........\n", - "Xmin(Test_Scenic_General_Bbox.trajBbox)\n", - "Ymin(Test_Scenic_General_Bbox.trajBbox)\n", - "Zmin(Test_Scenic_General_Bbox.trajBbox)\n", - "Xmax(Test_Scenic_General_Bbox.trajBbox)\n", - "Ymax(Test_Scenic_General_Bbox.trajBbox)\n", - "Zmax(Test_Scenic_General_Bbox.trajBbox)\n", - "SELECT Xmin(Test_Scenic_General_Bbox.trajBbox), Ymin(Test_Scenic_General_Bbox.trajBbox), Zmin(Test_Scenic_General_Bbox.trajBbox), Xmax(Test_Scenic_General_Bbox.trajBbox), Ymax(Test_Scenic_General_Bbox.trajBbox), Zmax(Test_Scenic_General_Bbox.trajBbox) From Test_Scenic_Item_General_Trajectory INNER JOIN Test_Scenic_General_Bbox USING(itemId) Where Test_Scenic_Item_General_Trajectory.objectType='vehicle.car' AND Tmin(Test_Scenic_General_Bbox.trajBbox)>='0001-01-01 00:00:00' AND Tmax(Test_Scenic_General_Bbox.trajBbox)<'9999-12-31 23:59:59.999999';\n", + "Xmin(General_Bbox.trajBbox)\n", + "Ymin(General_Bbox.trajBbox)\n", + "Zmin(General_Bbox.trajBbox)\n", + "Xmax(General_Bbox.trajBbox)\n", + "Ymax(General_Bbox.trajBbox)\n", + "Zmax(General_Bbox.trajBbox)\n", + "SELECT Xmin(General_Bbox.trajBbox), Ymin(General_Bbox.trajBbox), Zmin(General_Bbox.trajBbox), Xmax(General_Bbox.trajBbox), Ymax(General_Bbox.trajBbox), Zmax(General_Bbox.trajBbox) From Item_General_Trajectory INNER JOIN General_Bbox USING(itemId) Where Item_General_Trajectory.objectType='vehicle.car' AND Tmin(General_Bbox.trajBbox)>='0001-01-01 00:00:00' AND Tmax(General_Bbox.trajBbox)<'9999-12-31 23:59:59.999999';\n", "\n" ] } From 96b1a5ca73e8d56444d5c661ea045a424efca1f2 Mon Sep 17 00:00:00 2001 From: Github Actions Bot Date: Fri, 4 Mar 2022 19:20:36 +0000 Subject: [PATCH 23/26] Automated lint and format fixes --- apperception/box.py | 28 +- apperception/layers.py | 14 +- apperception/metadata_context_executor.py | 2 +- apperception/scenic_generate_df.py | 147 ++-- apperception/scenic_util.py | 820 ++++++++++++---------- apperception/video_context.py | 6 +- apperception/video_context_executor.py | 13 +- apperception/video_util.py | 45 +- apperception/world.py | 78 +- apperception/world_executor.py | 12 +- 10 files changed, 656 insertions(+), 509 deletions(-) diff --git a/apperception/box.py b/apperception/box.py index 1512cf73..7d5c82c2 100644 --- a/apperception/box.py +++ b/apperception/box.py @@ -1,13 +1,11 @@ import numpy as np from pyquaternion import Quaternion + class Box: - """ Simple data class representing a 3d box including, label, score and velocity. """ + """Simple data class representing a 3d box including, label, score and velocity.""" - def __init__(self, - center, - size, - orientation: Quaternion): + def __init__(self, center, size, orientation: Quaternion): """ :param center: Center of box given as x, y, z. :param size: Size of box in width, length, height. @@ -17,7 +15,7 @@ def __init__(self, assert not np.any(np.isnan(size)) assert len(center) == 3 assert len(size) == 3 - assert type(orientation) == Quaternion + assert isinstance(orientation, Quaternion) self.center = np.array(center) self.wlh = np.array(size) @@ -54,11 +52,11 @@ def corners(self, wlh_factor: float = 1.0) -> np.ndarray: The last four are the ones facing backwards. """ w, l, h = self.wlh * wlh_factor - + # 3D bounding box corners. (Convention: x points forward, y to the left, z up.) - x_corners = l / 2 * np.array([1, 1, 1, 1, -1, -1, -1, -1]) - y_corners = w / 2 * np.array([1, -1, -1, 1, 1, -1, -1, 1]) - z_corners = h / 2 * np.array([1, 1, -1, -1, 1, 1, -1, -1]) + x_corners = l / 2 * np.array([1, 1, 1, 1, -1, -1, -1, -1]) + y_corners = w / 2 * np.array([1, -1, -1, 1, 1, -1, -1, 1]) + z_corners = h / 2 * np.array([1, 1, -1, -1, 1, 1, -1, -1]) corners = np.vstack((x_corners, y_corners, z_corners)) # Rotate @@ -79,9 +77,9 @@ def bottom_corners(self) -> np.ndarray: """ return self.corners()[:, [2, 3, 7, 6]] - def view_points(self, points: np.ndarray, view: np.ndarray, normalize = True) -> np.ndarray: + def view_points(self, points: np.ndarray, view: np.ndarray, normalize=True) -> np.ndarray: viewpad = np.eye(4) - viewpad[:view.shape[0], :view.shape[1]] = view + viewpad[: view.shape[0], : view.shape[1]] = view nbr_points = points.shape[1] @@ -95,10 +93,8 @@ def view_points(self, points: np.ndarray, view: np.ndarray, normalize = True) -> return points - def map_2d(self, - view: np.ndarray = np.eye(3), - normalize: bool = True) -> np.ndarray: + def map_2d(self, view: np.ndarray = np.eye(3), normalize: bool = True) -> np.ndarray: corners = self.view_points(self.corners(), view, normalize)[:2, :] - return corners \ No newline at end of file + return corners diff --git a/apperception/layers.py b/apperception/layers.py index 1373d555..6ff00721 100644 --- a/apperception/layers.py +++ b/apperception/layers.py @@ -226,8 +226,8 @@ def __init__(self): self.refl = nn.ReflectionPad2d(1) - self.C1 = 0.01 ** 2 - self.C2 = 0.03 ** 2 + self.C1 = 0.01**2 + self.C2 = 0.03**2 def forward(self, x, y): x = self.refl(x) @@ -236,12 +236,12 @@ def forward(self, x, y): mu_x = self.mu_x_pool(x) mu_y = self.mu_y_pool(y) - sigma_x = self.sig_x_pool(x ** 2) - mu_x ** 2 - sigma_y = self.sig_y_pool(y ** 2) - mu_y ** 2 + sigma_x = self.sig_x_pool(x**2) - mu_x**2 + sigma_y = self.sig_y_pool(y**2) - mu_y**2 sigma_xy = self.sig_xy_pool(x * y) - mu_x * mu_y SSIM_n = (2 * mu_x * mu_y + self.C1) * (2 * sigma_xy + self.C2) - SSIM_d = (mu_x ** 2 + mu_y ** 2 + self.C1) * (sigma_x + sigma_y + self.C2) + SSIM_d = (mu_x**2 + mu_y**2 + self.C1) * (sigma_x + sigma_y + self.C2) return torch.clamp((1 - SSIM_n / SSIM_d) / 2, 0, 1) @@ -250,8 +250,8 @@ def compute_depth_errors(gt, pred): """Computation of error metrics between predicted and ground truth depths""" thresh = torch.max((gt / pred), (pred / gt)) a1 = (thresh < 1.25).float().mean() - a2 = (thresh < 1.25 ** 2).float().mean() - a3 = (thresh < 1.25 ** 3).float().mean() + a2 = (thresh < 1.25**2).float().mean() + a3 = (thresh < 1.25**3).float().mean() rmse = (gt - pred) ** 2 rmse = torch.sqrt(rmse.mean()) diff --git a/apperception/metadata_context_executor.py b/apperception/metadata_context_executor.py index 003bbe75..92827bff 100644 --- a/apperception/metadata_context_executor.py +++ b/apperception/metadata_context_executor.py @@ -125,7 +125,7 @@ def translate_aggregation(aggr_node: Aggregate, aggregated: str): if isinstance(aggr_node, asMFJSON): if len(aggr_node.interesting_fields) > 0: interesting_field = aggr_node.interesting_fields[0] - aggregated = aggregated + "::json->" + "\'"+interesting_field+"\'" + aggregated = aggregated + "::json->" + "'" + interesting_field + "'" else: aggregated = aggregated + "::json" return aggregated diff --git a/apperception/scenic_generate_df.py b/apperception/scenic_generate_df.py index 98852fd3..5e6676ce 100644 --- a/apperception/scenic_generate_df.py +++ b/apperception/scenic_generate_df.py @@ -1,87 +1,148 @@ import json + import pandas as pd + def scenic_generate_df(): - with open('v1.0-mini/v1.0-mini/attribute.json') as f: + with open("v1.0-mini/v1.0-mini/attribute.json") as f: attribute_json = json.load(f) - with open('v1.0-mini/v1.0-mini/calibrated_sensor.json') as f: + with open("v1.0-mini/v1.0-mini/calibrated_sensor.json") as f: calibrated_sensor_json = json.load(f) - with open('v1.0-mini/v1.0-mini/category.json') as f: + with open("v1.0-mini/v1.0-mini/category.json") as f: category_json = json.load(f) - with open('v1.0-mini/v1.0-mini/sample.json') as f: + with open("v1.0-mini/v1.0-mini/sample.json") as f: sample_json = json.load(f) - with open('v1.0-mini/v1.0-mini/sample_data.json') as f: + with open("v1.0-mini/v1.0-mini/sample_data.json") as f: sample_data_json = json.load(f) - with open('v1.0-mini/v1.0-mini/sample_annotation.json') as f: + with open("v1.0-mini/v1.0-mini/sample_annotation.json") as f: sample_annotation_json = json.load(f) - with open('v1.0-mini/v1.0-mini/instance.json') as f: + with open("v1.0-mini/v1.0-mini/instance.json") as f: instance_json = json.load(f) - with open('v1.0-mini/v1.0-mini/scene.json') as f: + with open("v1.0-mini/v1.0-mini/scene.json") as f: scene_json = json.load(f) - with open('v1.0-mini/v1.0-mini/ego_pose.json') as f: + with open("v1.0-mini/v1.0-mini/ego_pose.json") as f: ego_pose_json = json.load(f) df_sample_data = pd.DataFrame(sample_data_json) - df_sample_data = df_sample_data[['token','sample_token', 'calibrated_sensor_token', 'ego_pose_token', 'timestamp', 'fileformat', 'filename', 'prev', 'next']] - df_sample_data = df_sample_data[df_sample_data['fileformat'] == 'jpg'] + df_sample_data = df_sample_data[ + [ + "token", + "sample_token", + "calibrated_sensor_token", + "ego_pose_token", + "timestamp", + "fileformat", + "filename", + "prev", + "next", + ] + ] + df_sample_data = df_sample_data[df_sample_data["fileformat"] == "jpg"] df_sample_data.index = range(len(df_sample_data)) - + df_sample = pd.DataFrame(sample_json) - df_sample.columns = ['sample_token', 'timestamp', 'prev_sample', 'next_sample', 'scene_token'] - df_sample = df_sample[['sample_token', 'prev_sample', 'next_sample', 'scene_token']] + df_sample.columns = ["sample_token", "timestamp", "prev_sample", "next_sample", "scene_token"] + df_sample = df_sample[["sample_token", "prev_sample", "next_sample", "scene_token"]] df_sample_data = pd.merge(df_sample_data, df_sample, on="sample_token", how="left") df_calibrated_sensor = pd.DataFrame(calibrated_sensor_json) - df_calibrated_sensor.columns = ['calibrated_sensor_token', 'sensor_token', 'camera_translation', 'camera_rotation', 'camera_intrinsic'] - df_calibrated_sensor = df_calibrated_sensor[['calibrated_sensor_token', 'camera_translation', 'camera_rotation', 'camera_intrinsic']] - df_sample_data = pd.merge(df_sample_data, df_calibrated_sensor, on="calibrated_sensor_token", how="left") - df_sample_data = df_sample_data.drop(columns=['calibrated_sensor_token']) + df_calibrated_sensor.columns = [ + "calibrated_sensor_token", + "sensor_token", + "camera_translation", + "camera_rotation", + "camera_intrinsic", + ] + df_calibrated_sensor = df_calibrated_sensor[ + ["calibrated_sensor_token", "camera_translation", "camera_rotation", "camera_intrinsic"] + ] + df_sample_data = pd.merge( + df_sample_data, df_calibrated_sensor, on="calibrated_sensor_token", how="left" + ) + df_sample_data = df_sample_data.drop(columns=["calibrated_sensor_token"]) df_ego_pose = pd.DataFrame(ego_pose_json) - df_ego_pose.columns = ['ego_pose_token', 'timestamp', 'ego_rotation', 'ego_translation'] - df_ego_pose = df_ego_pose.drop(columns=['timestamp']) + df_ego_pose.columns = ["ego_pose_token", "timestamp", "ego_rotation", "ego_translation"] + df_ego_pose = df_ego_pose.drop(columns=["timestamp"]) df_sample_data = pd.merge(df_sample_data, df_ego_pose, on="ego_pose_token", how="left") - df_sample_data = df_sample_data.drop(columns=['ego_pose_token']) + df_sample_data = df_sample_data.drop(columns=["ego_pose_token"]) df_scene = pd.DataFrame(scene_json) - df_scene.columns = ['scene_token', 'log_token', 'nbr_samples', 'first_sample_token', 'last_sample_token', 'scene_name', 'description'] - df_scene = df_scene[['scene_token', 'first_sample_token', 'last_sample_token', 'scene_name']] + df_scene.columns = [ + "scene_token", + "log_token", + "nbr_samples", + "first_sample_token", + "last_sample_token", + "scene_name", + "description", + ] + df_scene = df_scene[["scene_token", "first_sample_token", "last_sample_token", "scene_name"]] df_sample_data = pd.merge(df_sample_data, df_scene, on="scene_token", how="left") - df_sample_data = df_sample_data.drop(columns=['scene_token']) + df_sample_data = df_sample_data.drop(columns=["scene_token"]) - df_sample_data['frame_order'] = 0 - for index, row in df_sample_data.iterrows(): - if len(row['prev']) == 0: - df_sample_data.loc[index,'frame_order'] = 1 + df_sample_data["frame_order"] = 0 + for index, row in df_sample_data.iterrows(): + if len(row["prev"]) == 0: + df_sample_data.loc[index, "frame_order"] = 1 i = 2 - next_frame_token = row['next'] + next_frame_token = row["next"] while len(next_frame_token) != 0: - #print(next_frame_token) - cur_index = df_sample_data[df_sample_data['token'] == next_frame_token].index.tolist()[0] - #print(cur_index) - df_sample_data.loc[cur_index,'frame_order'] = i + # print(next_frame_token) + cur_index = df_sample_data[ + df_sample_data["token"] == next_frame_token + ].index.tolist()[0] + # print(cur_index) + df_sample_data.loc[cur_index, "frame_order"] = i i += 1 - next_frame_token = list(df_sample_data[df_sample_data['token'] == next_frame_token]['next'])[0] - - df_sample_data = df_sample_data.drop(columns=['fileformat', 'prev', 'next', 'prev_sample', 'next_sample', 'first_sample_token', 'last_sample_token']) + next_frame_token = list( + df_sample_data[df_sample_data["token"] == next_frame_token]["next"] + )[0] + + df_sample_data = df_sample_data.drop( + columns=[ + "fileformat", + "prev", + "next", + "prev_sample", + "next_sample", + "first_sample_token", + "last_sample_token", + ] + ) df_sample_annotation = pd.DataFrame(sample_annotation_json) - df_sample_annotation = df_sample_annotation[['token', 'sample_token', 'instance_token', 'translation', 'size', 'rotation']] - + df_sample_annotation = df_sample_annotation[ + ["token", "sample_token", "instance_token", "translation", "size", "rotation"] + ] + df_instance = pd.DataFrame(instance_json) df_category = pd.DataFrame(category_json) - df_category.rename(columns={'token': 'cat_token'}, inplace=True) - df_instance = pd.merge(df_instance, df_category, left_on="category_token", right_on="cat_token", how="left") - df_instance = df_instance.drop(columns=['category_token', 'cat_token', 'nbr_annotations', 'first_annotation_token', 'last_annotation_token', 'description']) - df_instance.columns = ['instance_token', 'category'] - df_sample_annotation = pd.merge(df_sample_annotation, df_instance, on="instance_token", how="left") + df_category.rename(columns={"token": "cat_token"}, inplace=True) + df_instance = pd.merge( + df_instance, df_category, left_on="category_token", right_on="cat_token", how="left" + ) + df_instance = df_instance.drop( + columns=[ + "category_token", + "cat_token", + "nbr_annotations", + "first_annotation_token", + "last_annotation_token", + "description", + ] + ) + df_instance.columns = ["instance_token", "category"] + df_sample_annotation = pd.merge( + df_sample_annotation, df_instance, on="instance_token", how="left" + ) return df_sample_data, df_sample_annotation diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py index fd22c667..f4beff5f 100644 --- a/apperception/scenic_util.py +++ b/apperception/scenic_util.py @@ -1,12 +1,13 @@ -from typing import Iterable, List, Tuple, Union -import numpy as np -from pyquaternion import Quaternion +import datetime import json import os -import datetime +from typing import Iterable, List, Tuple + +import numpy as np from box import Box +from pyquaternion import Quaternion -CREATE_ITEMTRAJ_SQL ='''CREATE TABLE IF NOT EXISTS Item_General_Trajectory( +CREATE_ITEMTRAJ_SQL = """CREATE TABLE IF NOT EXISTS Item_General_Trajectory( itemId TEXT, objectType TEXT, frameId TEXT, @@ -14,16 +15,16 @@ trajCentroids tgeompoint, largestBbox stbox, PRIMARY KEY (itemId) - );''' + );""" -CREATE_BBOXES_SQL ='''CREATE TABLE IF NOT EXISTS General_Bbox( +CREATE_BBOXES_SQL = """CREATE TABLE IF NOT EXISTS General_Bbox( itemId TEXT, trajBbox stbox, FOREIGN KEY(itemId) REFERENCES Item_General_Trajectory(itemId) - );''' + );""" -CREATE_CAMERA_SQL = '''CREATE TABLE IF NOT EXISTS Cameras( +CREATE_CAMERA_SQL = """CREATE TABLE IF NOT EXISTS Cameras( cameraId TEXT, worldId TEXT, frameId TEXT, @@ -35,154 +36,176 @@ egoTranslation geometry, egoRotation real[4], timestamp TEXT - );''' + );""" + def fetch_camera_config(scene_name, sample_data): - ''' - return - [{ - camera_id: scene name, - frame_id, - frame_num: the frame sequence number - filename: image file name, - camera_translation, - camera_rotation, - camera_intrinsic(since it's a matrix, save as a nested array), - ego_translation, - ego_rotation, - timestamp - }, - ... - ] - ''' - camera_config = [] - - # TODO: different camera in one frame has same timestamp for same object - # how to store same scene in different cameras - all_frames = sample_data[(sample_data['scene_name'] == scene_name) & (sample_data['filename'].str.contains('/CAM_FRONT/', regex=False))] - - for idx, frame in all_frames.iterrows(): - config = {} - config['camera_id'] = scene_name - config['frame_id'] = frame['sample_token'] - config['frame_num'] = frame['frame_order'] - config['filename'] = frame['filename'] - config['camera_translation'] = frame['camera_translation'] - config['camera_rotation'] = frame['camera_rotation'] - config['camera_intrinsic'] = frame['camera_intrinsic'] - config['ego_translation'] = frame['ego_translation'] - config['ego_rotation'] = frame['ego_rotation'] - config['timestamp'] = frame['timestamp'] - camera_config.append(config) - - return camera_config + """ + return + [{ + camera_id: scene name, + frame_id, + frame_num: the frame sequence number + filename: image file name, + camera_translation, + camera_rotation, + camera_intrinsic(since it's a matrix, save as a nested array), + ego_translation, + ego_rotation, + timestamp + }, + ... + ] + """ + camera_config = [] + + # TODO: different camera in one frame has same timestamp for same object + # how to store same scene in different cameras + all_frames = sample_data[ + (sample_data["scene_name"] == scene_name) + & (sample_data["filename"].str.contains("/CAM_FRONT/", regex=False)) + ] + + for idx, frame in all_frames.iterrows(): + config = {} + config["camera_id"] = scene_name + config["frame_id"] = frame["sample_token"] + config["frame_num"] = frame["frame_order"] + config["filename"] = frame["filename"] + config["camera_translation"] = frame["camera_translation"] + config["camera_rotation"] = frame["camera_rotation"] + config["camera_intrinsic"] = frame["camera_intrinsic"] + config["ego_translation"] = frame["ego_translation"] + config["ego_rotation"] = frame["ego_rotation"] + config["timestamp"] = frame["timestamp"] + camera_config.append(config) + + return camera_config + # Create a camera table + + def create_or_insert_camera_table(conn, world_name, camera): - #Creating a cursor object using the cursor() method - cursor = conn.cursor() - ''' + # Creating a cursor object using the cursor() method + cursor = conn.cursor() + """ Create and Populate A camera table with the given camera object. - ''' - #Doping Cameras table if already exists. - cursor.execute("DROP TABLE IF EXISTS Cameras") - # Formal_Scenic_cameras table stands for the formal table which won't be erased - # Test for now - - cursor.execute(CREATE_CAMERA_SQL) - print("Camera Table created successfully........") - insert_camera(conn, world_name, fetch_camera_config(camera.scenic_scene_name, camera.object_recognition.sample_data)) - return CREATE_CAMERA_SQL + """ + # Doping Cameras table if already exists. + cursor.execute("DROP TABLE IF EXISTS Cameras") + # Formal_Scenic_cameras table stands for the formal table which won't be erased + # Test for now + + cursor.execute(CREATE_CAMERA_SQL) + print("Camera Table created successfully........") + insert_camera( + conn, + world_name, + fetch_camera_config(camera.scenic_scene_name, camera.object_recognition.sample_data), + ) + return CREATE_CAMERA_SQL + # Helper function to insert the camera + + def insert_camera(conn, world_name, camera_config): - #Creating a cursor object using the cursor() method - cursor = conn.cursor() - values = [] - for config in camera_config: - values.append(f'''( + # Creating a cursor object using the cursor() method + cursor = conn.cursor() + values = [] + for config in camera_config: + values.append( + f"""( '{config['camera_id']}', '{world_name}', '{config['frame_id']}', {config['frame_num']}, '{config['filename']}', 'POINT Z ({' '.join(map(str, config['camera_translation']))})', - ARRAY{config['camera_rotation']}, + ARRAY{config['camera_rotation']}, ARRAY{config['camera_intrinsic']}, 'POINT Z ({' '.join(map(str, config['ego_translation']))})', ARRAY{config['ego_rotation']}, '{config['timestamp']}' - )''') + )""" + ) - cursor.execute(f''' + cursor.execute( + f""" INSERT INTO Cameras ( - cameraId, - worldId, - frameId, - frameNum, - fileName, - cameraTranslation, + cameraId, + worldId, + frameId, + frameNum, + fileName, + cameraTranslation, cameraRotation, cameraIntrinsic, egoTranslation, egoRotation, timestamp ) - VALUES {','.join(values)};''' - ) + VALUES {','.join(values)};""" + ) + + print("New camera inserted successfully.........") + conn.commit() - print("New camera inserted successfully.........") - conn.commit() # create collections in db and set index for quick query + + def insert_data(data_dir, db): - with open(os.path.join(data_dir, 'v1.0-mini', 'sample_data.json')) as f: - sample_data_json = json.load(f) - db['sample_data'].insert_many(sample_data_json) - db['sample_data'].create_index('token') - db['sample_data'].create_index('filename') - - with open(os.path.join(data_dir, 'v1.0-mini', 'attribute.json')) as f: - attribute_json = json.load(f) - db['attribute'].insert_many(attribute_json) - db['attribute'].create_index('token') - - with open(os.path.join(data_dir, 'v1.0-mini', 'calibrated_sensor.json')) as f: - calibrated_sensor_json = json.load(f) - db['calibrated_sensor'].insert_many(calibrated_sensor_json) - db['calibrated_sensor'].create_index('token') - - with open(os.path.join(data_dir, 'v1.0-mini', 'category.json')) as f: - category_json = json.load(f) - db['category'].insert_many(category_json) - db['category'].create_index('token') - - with open(os.path.join(data_dir, 'v1.0-mini', 'ego_pose.json')) as f: - ego_pose_json = json.load(f) - db['ego_pose'].insert_many(ego_pose_json) - db['ego_pose'].create_index('token') - - with open(os.path.join(data_dir, 'v1.0-mini', 'instance.json')) as f: - instance_json = json.load(f) - db['instance'].insert_many(instance_json) - db['instance'].create_index('token') - - with open(os.path.join(data_dir, 'v1.0-mini', 'sample_annotation.json')) as f: - sample_annotation_json = json.load(f) - db['sample_annotation'].insert_many(sample_annotation_json) - db['sample_annotation'].create_index('token') - - with open(os.path.join(data_dir, 'v1.0-mini', 'frame_num.json')) as f: - frame_num_json = json.load(f) - db['frame_num'].insert_many(frame_num_json) - db['frame_num'].create_index('token') - -def transform_box(box: Box, camera): - box.translate(-np.array(camera['egoTranslation'])) - box.rotate(Quaternion(camera['egoRotation']).inverse) - - box.translate(-np.array(camera['cameraTranslation'])) - box.rotate(Quaternion(camera['cameraRotation']).inverse) + with open(os.path.join(data_dir, "v1.0-mini", "sample_data.json")) as f: + sample_data_json = json.load(f) + db["sample_data"].insert_many(sample_data_json) + db["sample_data"].create_index("token") + db["sample_data"].create_index("filename") + + with open(os.path.join(data_dir, "v1.0-mini", "attribute.json")) as f: + attribute_json = json.load(f) + db["attribute"].insert_many(attribute_json) + db["attribute"].create_index("token") + + with open(os.path.join(data_dir, "v1.0-mini", "calibrated_sensor.json")) as f: + calibrated_sensor_json = json.load(f) + db["calibrated_sensor"].insert_many(calibrated_sensor_json) + db["calibrated_sensor"].create_index("token") + + with open(os.path.join(data_dir, "v1.0-mini", "category.json")) as f: + category_json = json.load(f) + db["category"].insert_many(category_json) + db["category"].create_index("token") + + with open(os.path.join(data_dir, "v1.0-mini", "ego_pose.json")) as f: + ego_pose_json = json.load(f) + db["ego_pose"].insert_many(ego_pose_json) + db["ego_pose"].create_index("token") + + with open(os.path.join(data_dir, "v1.0-mini", "instance.json")) as f: + instance_json = json.load(f) + db["instance"].insert_many(instance_json) + db["instance"].create_index("token") + + with open(os.path.join(data_dir, "v1.0-mini", "sample_annotation.json")) as f: + sample_annotation_json = json.load(f) + db["sample_annotation"].insert_many(sample_annotation_json) + db["sample_annotation"].create_index("token") + + with open(os.path.join(data_dir, "v1.0-mini", "frame_num.json")) as f: + frame_num_json = json.load(f) + db["frame_num"].insert_many(frame_num_json) + db["frame_num"].create_index("token") + + +def transform_box(box: Box, camera): + box.translate(-np.array(camera["egoTranslation"])) + box.rotate(Quaternion(camera["egoRotation"]).inverse) + + box.translate(-np.array(camera["cameraTranslation"])) + box.rotate(Quaternion(camera["cameraRotation"]).inverse) + # import matplotlib.pyplot as plt # def overlay_bbox(image, corners): @@ -196,166 +219,198 @@ def transform_box(box: Box, camera): # plt.imshow(frame) # plt.show() + def recognize(scene_name, sample_data, annotation): - """ - return: - annotations: { - object_id: { - bboxes: [[[x1, y1, z1], [x2, y2, z2]], ...] - object_type, - frame_num, - frame_id, - } - ... - } - """ + """ + return: + annotations: { + object_id: { + bboxes: [[[x1, y1, z1], [x2, y2, z2]], ...] + object_type, + frame_num, + frame_id, + } + ... + } + """ + + annotations = {} + + # TODO: different camera in one frame has same timestamp for same object + # how to store same scene in different cameras + img_files = sample_data[ + (sample_data["scene_name"] == scene_name) + & (sample_data["filename"].str.contains("/CAM_FRONT/", regex=False)) + ].sort_values(by="frame_order") + + for _, img_file in img_files.iterrows(): + # get bboxes and categories of all the objects appeared in the image file + sample_token = img_file["sample_token"] + frame_num = img_file["frame_order"] + all_annotations = annotation[annotation["sample_token"] == sample_token] + # camera_info = {} + # camera_info['cameraTranslation'] = img_file['camera_translation'] + # camera_info['cameraRotation'] = img_file['camera_rotation'] + # camera_info['cameraIntrinsic'] = np.array(img_file['camera_intrinsic']) + # camera_info['egoRotation'] = img_file['ego_rotation'] + # camera_info['egoTranslation'] = img_file['ego_translation'] + + for _, ann in all_annotations.iterrows(): + item_id = ann["instance_token"] + if item_id not in annotations: + annotations[item_id] = {"bboxes": [], "frame_num": []} + annotations[item_id]["object_type"] = ann["category"] + + box = Box(ann["translation"], ann["size"], Quaternion(ann["rotation"])) + + corners = box.corners() + + # if item_id == '6dd2cbf4c24b4caeb625035869bca7b5': + # # print("corners", corners) + # # transform_box(box, camera_info) + # # print("transformed box: ", box.corners()) + # # corners_2d = box.map_2d(np.array(camera_info['cameraIntrinsic'])) + # corners_2d = transformation(box.center, camera_info) + # print("2d_corner: ", corners_2d) + # overlay_bbox("v1.0-mini/samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg", corners_2d) + + bbox = [corners[:, 1], corners[:, 7]] + annotations[item_id]["bboxes"].append(bbox) + annotations[item_id]["frame_num"].append(int(frame_num)) + + print("Recognization done, saving to database......") + return annotations - annotations = {} - - # TODO: different camera in one frame has same timestamp for same object - # how to store same scene in different cameras - img_files = sample_data[(sample_data['scene_name'] == scene_name) & (sample_data['filename'].str.contains('/CAM_FRONT/', regex=False))].sort_values(by='frame_order') - - for _, img_file in img_files.iterrows(): - # get bboxes and categories of all the objects appeared in the image file - sample_token = img_file['sample_token'] - frame_num = img_file['frame_order'] - all_annotations = annotation[annotation['sample_token'] == sample_token] - # camera_info = {} - # camera_info['cameraTranslation'] = img_file['camera_translation'] - # camera_info['cameraRotation'] = img_file['camera_rotation'] - # camera_info['cameraIntrinsic'] = np.array(img_file['camera_intrinsic']) - # camera_info['egoRotation'] = img_file['ego_rotation'] - # camera_info['egoTranslation'] = img_file['ego_translation'] - - for _, ann in all_annotations.iterrows(): - item_id = ann['instance_token'] - if item_id not in annotations: - annotations[item_id] = {'bboxes': [], 'frame_num': []} - annotations[item_id]['object_type'] = ann['category'] - - box = Box(ann['translation'], ann['size'], Quaternion(ann['rotation'])) - - corners = box.corners() - - # if item_id == '6dd2cbf4c24b4caeb625035869bca7b5': - # # print("corners", corners) - # # transform_box(box, camera_info) - # # print("transformed box: ", box.corners()) - # # corners_2d = box.map_2d(np.array(camera_info['cameraIntrinsic'])) - # corners_2d = transformation(box.center, camera_info) - # print("2d_corner: ", corners_2d) - # overlay_bbox("v1.0-mini/samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg", corners_2d) - - bbox = [corners[:, 1], corners[:, 7]] - annotations[item_id]['bboxes'].append(bbox) - annotations[item_id]['frame_num'].append(int(frame_num)) - - print("Recognization done, saving to database......") - return annotations def add_recognized_objs(conn, formatted_result, start_time, default_depth=True): - clean_tables(conn) - for item_id in formatted_result: - object_type = formatted_result[item_id]["object_type"] - recognized_bboxes = np.array(formatted_result[item_id]["bboxes"]) - tracked_cnt = formatted_result[item_id]["frame_num"] - top_left = np.vstack((recognized_bboxes[:,0,0], recognized_bboxes[:,0,1], recognized_bboxes[:,0,2])) - # if default_depth: - # top_left_depths = np.ones(len(recognized_bboxes)) - # else: - # top_left_depths = self.__get_depths_of_points(recognized_bboxes[:,0,0], recognized_bboxes[:,0,1]) - - # # Convert bottom right coordinates to world coordinates - bottom_right = np.vstack((recognized_bboxes[:,1,0], recognized_bboxes[:,1,1], recognized_bboxes[:,1,2])) - # if default_depth: - # bottom_right_depths = np.ones(len(tracked_cnt)) - # else: - # bottom_right_depths = self.__get_depths_of_points(recognized_bboxes[:,1,0], recognized_bboxes[:,1,1]) - - top_left = np.array(top_left.T) - bottom_right = np.array(bottom_right.T) - obj_traj = [] - for i in range(len(top_left)): - current_tl = top_left[i] - current_br = bottom_right[i] - obj_traj.append([current_tl.tolist(), current_br.tolist()]) - - bboxes_to_postgres(conn, item_id, object_type, "default_color", start_time, tracked_cnt, obj_traj, type="yolov4") - # bbox_to_tasm() + clean_tables(conn) + for item_id in formatted_result: + object_type = formatted_result[item_id]["object_type"] + recognized_bboxes = np.array(formatted_result[item_id]["bboxes"]) + tracked_cnt = formatted_result[item_id]["frame_num"] + top_left = np.vstack( + (recognized_bboxes[:, 0, 0], recognized_bboxes[:, 0, 1], recognized_bboxes[:, 0, 2]) + ) + # if default_depth: + # top_left_depths = np.ones(len(recognized_bboxes)) + # else: + # top_left_depths = self.__get_depths_of_points(recognized_bboxes[:,0,0], recognized_bboxes[:,0,1]) + + # # Convert bottom right coordinates to world coordinates + bottom_right = np.vstack( + (recognized_bboxes[:, 1, 0], recognized_bboxes[:, 1, 1], recognized_bboxes[:, 1, 2]) + ) + # if default_depth: + # bottom_right_depths = np.ones(len(tracked_cnt)) + # else: + # bottom_right_depths = self.__get_depths_of_points(recognized_bboxes[:,1,0], recognized_bboxes[:,1,1]) + + top_left = np.array(top_left.T) + bottom_right = np.array(bottom_right.T) + obj_traj = [] + for i in range(len(top_left)): + current_tl = top_left[i] + current_br = bottom_right[i] + obj_traj.append([current_tl.tolist(), current_br.tolist()]) + + bboxes_to_postgres( + conn, + item_id, + object_type, + "default_color", + start_time, + tracked_cnt, + obj_traj, + type="yolov4", + ) + # bbox_to_tasm() + # Insert bboxes to postgres -def bboxes_to_postgres(conn, item_id, object_type, color, start_time, timestamps, bboxes, type='yolov3'): - if type == 'yolov3': - timestamps = range(timestamps) - converted_bboxes = [bbox_to_data3d(bbox) for bbox in bboxes] - pairs = [] - deltas = [] - for meta_box in converted_bboxes: - pairs.append(meta_box[0]) - deltas.append(meta_box[1:]) - postgres_timestamps = convert_timestamps(start_time, timestamps) - create_or_insert_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs) - # print(f"{item_id} saved successfully") + +def bboxes_to_postgres( + conn, item_id, object_type, color, start_time, timestamps, bboxes, type="yolov3" +): + if type == "yolov3": + timestamps = range(timestamps) + + converted_bboxes = [bbox_to_data3d(bbox) for bbox in bboxes] + pairs = [] + deltas = [] + for meta_box in converted_bboxes: + pairs.append(meta_box[0]) + deltas.append(meta_box[1:]) + postgres_timestamps = convert_timestamps(start_time, timestamps) + create_or_insert_general_trajectory( + conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs + ) + # print(f"{item_id} saved successfully") # Create general trajectory table -def create_or_insert_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs): - cursor = conn.cursor() - ''' +def create_or_insert_general_trajectory( + conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs +): + cursor = conn.cursor() + """ Create and Populate A Trajectory table using mobilityDB. Now the timestamp matches, the starting time should be the meta data of the world Then the timestamp should be the timestamp regarding the world starting time - ''' - - # Formal_Scenic_Item_General_Trajectory table stands for the formal table which won't be erased - # Test for now - - cursor.execute(CREATE_ITEMTRAJ_SQL) - cursor.execute("CREATE INDEX IF NOT EXISTS traj_idx ON Item_General_Trajectory USING GiST(trajCentroids);") - conn.commit() - # Formal_Scenic_General_Bbox table stands for the formal table which won't be erased - # Test for now - - cursor.execute(CREATE_BBOXES_SQL) - cursor.execute("CREATE INDEX IF NOT EXISTS item_idx ON General_Bbox(itemId);") - cursor.execute("CREATE INDEX IF NOT EXISTS traj_bbox_idx ON General_Bbox USING GiST(trajBbox);") - conn.commit() - #Insert the trajectory of the first item - insert_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs) - - -def join(array: Iterable, delim: str = ','): - return delim.join(map(str, array)) + """ + + # Formal_Scenic_Item_General_Trajectory table stands for the formal table which won't be erased + # Test for now + + cursor.execute(CREATE_ITEMTRAJ_SQL) + cursor.execute( + "CREATE INDEX IF NOT EXISTS traj_idx ON Item_General_Trajectory USING GiST(trajCentroids);" + ) + conn.commit() + # Formal_Scenic_General_Bbox table stands for the formal table which won't be erased + # Test for now + + cursor.execute(CREATE_BBOXES_SQL) + cursor.execute("CREATE INDEX IF NOT EXISTS item_idx ON General_Bbox(itemId);") + cursor.execute("CREATE INDEX IF NOT EXISTS traj_bbox_idx ON General_Bbox USING GiST(trajBbox);") + conn.commit() + # Insert the trajectory of the first item + insert_general_trajectory(conn, item_id, object_type, color, postgres_timestamps, bboxes, pairs) + + +def join(array: Iterable, delim: str = ","): + return delim.join(map(str, array)) # Insert general trajectory def insert_general_trajectory( - conn, - item_id: str, - object_type: str, - color: str, - postgres_timestamps: List[str], - bboxes: List[List[List[float]]], # TODO: should be (float, float, float), (float, float, float))[] - pairs: List[Tuple[float, float, float]] + conn, + item_id: str, + object_type: str, + color: str, + postgres_timestamps: List[str], + bboxes: List[ + List[List[float]] + ], # TODO: should be (float, float, float), (float, float, float))[] + pairs: List[Tuple[float, float, float]], ): - #Creating a cursor object using the cursor() method - cursor = conn.cursor() + # Creating a cursor object using the cursor() method + cursor = conn.cursor() - #Inserting bboxes into Bbox table - insert_bbox_trajectories_builder = [] - min_tl = np.full(3, np.inf) - max_br = np.full(3, np.NINF) + # Inserting bboxes into Bbox table + insert_bbox_trajectories_builder = [] + min_tl = np.full(3, np.inf) + max_br = np.full(3, np.NINF) - traj_centroids = [] + traj_centroids = [] - for timestamp, (tl, br), current_point in zip(postgres_timestamps, bboxes, pairs): - min_tl = np.minimum(tl, min_tl) - max_br = np.maximum(br, max_br) + for timestamp, (tl, br), current_point in zip(postgres_timestamps, bboxes, pairs): + min_tl = np.minimum(tl, min_tl) + max_br = np.maximum(br, max_br) - ### Insert bbox - insert_bbox_trajectories_builder.append(f""" + # Insert bbox + insert_bbox_trajectories_builder.append( + f""" INSERT INTO General_Bbox (itemId, trajBbox) VALUES ( '{item_id}', @@ -364,13 +419,14 @@ def insert_general_trajectory( ({join([*br, timestamp])}) )' ); - """) + """ + ) - ### Construct trajectory - traj_centroids.append(f"POINT Z ({join(current_point, ' ')})@{timestamp}") + # Construct trajectory + traj_centroids.append(f"POINT Z ({join(current_point, ' ')})@{timestamp}") - # Insert the item_trajectory separately - insert_trajectory = f""" + # Insert the item_trajectory separately + insert_trajectory = f""" INSERT INTO Item_General_Trajectory (itemId, objectType, color, trajCentroids, largestBbox) VALUES ( '{item_id}', @@ -384,53 +440,59 @@ def insert_general_trajectory( ); """ - cursor.execute(insert_trajectory) - cursor.execute(''.join(insert_bbox_trajectories_builder)) + cursor.execute(insert_trajectory) + cursor.execute("".join(insert_bbox_trajectories_builder)) + + # Commit your changes in the database + conn.commit() + - # Commit your changes in the database - conn.commit() - def transformation(centroid_3d, camera_config): - ''' - TODO: transformation from 3d world coordinate to 2d frame coordinate given the camera config - ''' - centroid_3d -= camera_config['egoTranslation'] - centroid_3d = np.dot(Quaternion(camera_config['egoRotation']).inverse.rotation_matrix, centroid_3d) - - centroid_3d -= camera_config['cameraTranslation'] - centroid_3d = np.dot(Quaternion(camera_config['cameraRotation']).inverse.rotation_matrix, centroid_3d) - - view = camera_config['cameraIntrinsic'] - viewpad = np.eye(4) - viewpad[:view.shape[0], :view.shape[1]] = view - - # Do operation in homogenous coordinates. - centroid_3d = centroid_3d.reshape((3, 1)) - centroid_3d = np.concatenate((centroid_3d, np.ones((1, 1)))) - centroid_3d = np.dot(viewpad, centroid_3d) - centroid_3d = centroid_3d[:3, :] - - centroid_3d = centroid_3d / centroid_3d[2:3, :].repeat(3, 0).reshape(3, 1) - return centroid_3d[:2, :] - + """ + TODO: transformation from 3d world coordinate to 2d frame coordinate given the camera config + """ + centroid_3d -= camera_config["egoTranslation"] + centroid_3d = np.dot( + Quaternion(camera_config["egoRotation"]).inverse.rotation_matrix, centroid_3d + ) + + centroid_3d -= camera_config["cameraTranslation"] + centroid_3d = np.dot( + Quaternion(camera_config["cameraRotation"]).inverse.rotation_matrix, centroid_3d + ) + + view = camera_config["cameraIntrinsic"] + viewpad = np.eye(4) + viewpad[: view.shape[0], : view.shape[1]] = view + + # Do operation in homogenous coordinates. + centroid_3d = centroid_3d.reshape((3, 1)) + centroid_3d = np.concatenate((centroid_3d, np.ones((1, 1)))) + centroid_3d = np.dot(viewpad, centroid_3d) + centroid_3d = centroid_3d[:3, :] + + centroid_3d = centroid_3d / centroid_3d[2:3, :].repeat(3, 0).reshape(3, 1) + return centroid_3d[:2, :] + + def fetch_camera(conn, scene_name, frame_num): - ''' - TODO: Fix fetch camera that given a scene_name and frame_num, return the corresponding camera metadata - scene_name: str - frame_num: int[] - return a list of metadata info for each frame_num - ''' - - cursor = conn.cursor() - # query = '''SELECT camera_info from camera_table where camera_table.camera_id == scene_name and camera_table.frame_num in frame_num''' - # if cam_id == []: - # query = '''SELECT cameraId, ratio, ST_X(origin), ST_Y(origin), ST_Z(origin), ST_X(focalpoints), ST_Y(focalpoints), fov, skev_factor ''' \ - # + '''FROM Cameras WHERE worldId = \'%s\';''' %world_id - # else: - # query = '''SELECT cameraId, ratio, ST_X(origin), ST_Y(origin), ST_Z(origin), ST_X(focalpoints), ST_Y(focalpoints), fov, skev_factor ''' \ - # + '''FROM Cameras WHERE cameraId IN (\'%s\') AND worldId = \'%s\';''' %(','.join(cam_id), world_id) - # TODO: define ST_XYZ somewhere else - query = f''' + """ + TODO: Fix fetch camera that given a scene_name and frame_num, return the corresponding camera metadata + scene_name: str + frame_num: int[] + return a list of metadata info for each frame_num + """ + + cursor = conn.cursor() + # query = '''SELECT camera_info from camera_table where camera_table.camera_id == scene_name and camera_table.frame_num in frame_num''' + # if cam_id == []: + # query = '''SELECT cameraId, ratio, ST_X(origin), ST_Y(origin), ST_Z(origin), ST_X(focalpoints), ST_Y(focalpoints), fov, skev_factor ''' \ + # + '''FROM Cameras WHERE worldId = \'%s\';''' %world_id + # else: + # query = '''SELECT cameraId, ratio, ST_X(origin), ST_Y(origin), ST_Z(origin), ST_X(focalpoints), ST_Y(focalpoints), fov, skev_factor ''' \ + # + '''FROM Cameras WHERE cameraId IN (\'%s\') AND worldId = \'%s\';''' %(','.join(cam_id), world_id) + # TODO: define ST_XYZ somewhere else + query = f""" CREATE OR REPLACE FUNCTION ST_XYZ (g geometry) RETURNS real[] AS $$ BEGIN RETURN ARRAY[ST_X(g), ST_Y(g), ST_Z(g)]; @@ -450,73 +512,85 @@ def fetch_camera(conn, scene_name, frame_num): WHERE cameraId = '{scene_name}' AND frameNum IN ({",".join(map(str, frame_num))}); - ''' - cursor.execute(query) - return cursor.fetchall() + """ + cursor.execute(query) + return cursor.fetchall() + def clean_tables(conn): - cursor = conn.cursor() - cursor.execute("DROP TABLE IF EXISTS General_Bbox;") - cursor.execute("DROP TABLE IF EXISTS Item_General_Trajectory;") - conn.commit() - + cursor = conn.cursor() + cursor.execute("DROP TABLE IF EXISTS General_Bbox;") + cursor.execute("DROP TABLE IF EXISTS Item_General_Trajectory;") + conn.commit() + + def export_tables(conn): - # create a query to specify which values we want from the database. - s = "SELECT *" - s += " FROM " - s_trajectory = s + "Item_General_Trajectory" - s_bbox = s + "General_Bbox" - s_camera = s + "Cameras" - - # set up our database connection. - db_cursor = conn.cursor() - - # Use the COPY function on the SQL we created above. - SQL_trajectory_output = "COPY ({0}) TO STDOUT WITH CSV HEADER".format(s_trajectory) - SQL_bbox_output = "COPY ({0}) TO STDOUT WITH CSV HEADER".format(s_bbox) - SQL_camera_output = "COPY ({0}) TO STDOUT WITH CSV HEADER".format(s_camera) - - # Set up a variable to store our file path and name. - trajectory_file = "test_trajectory.csv" - with open(trajectory_file, 'w') as trajectory_output: - db_cursor.copy_expert(SQL_trajectory_output, trajectory_output) - - bbox_file = "test_bbox.csv" - with open(bbox_file, 'w') as bbox_output: - db_cursor.copy_expert(SQL_bbox_output, bbox_output) - - camera_file = "test_camera.csv" - with open(camera_file, 'w') as camera_output: - db_cursor.copy_expert(SQL_camera_output, camera_output) + # create a query to specify which values we want from the database. + s = "SELECT *" + s += " FROM " + s_trajectory = s + "Item_General_Trajectory" + s_bbox = s + "General_Bbox" + s_camera = s + "Cameras" + + # set up our database connection. + db_cursor = conn.cursor() + + # Use the COPY function on the SQL we created above. + SQL_trajectory_output = "COPY ({0}) TO STDOUT WITH CSV HEADER".format(s_trajectory) + SQL_bbox_output = "COPY ({0}) TO STDOUT WITH CSV HEADER".format(s_bbox) + SQL_camera_output = "COPY ({0}) TO STDOUT WITH CSV HEADER".format(s_camera) + + # Set up a variable to store our file path and name. + trajectory_file = "test_trajectory.csv" + with open(trajectory_file, "w") as trajectory_output: + db_cursor.copy_expert(SQL_trajectory_output, trajectory_output) + + bbox_file = "test_bbox.csv" + with open(bbox_file, "w") as bbox_output: + db_cursor.copy_expert(SQL_bbox_output, bbox_output) + + camera_file = "test_camera.csv" + with open(camera_file, "w") as camera_output: + db_cursor.copy_expert(SQL_camera_output, camera_output) + def import_tables(conn): - cur = conn.cursor() - cur.execute(CREATE_CAMERA_SQL) - cur.execute(CREATE_ITEMTRAJ_SQL) - cur.execute(CREATE_BBOXES_SQL) - conn.commit() - with open('test_camera.csv', 'r') as camera_f: - cur.copy_expert(file=camera_f, sql="COPY Cameras FROM STDIN CSV HEADER DELIMITER as ','") - with open('test_trajectory.csv', 'r') as trajectory_f: - cur.copy_expert(file=trajectory_f, sql="COPY Item_General_Trajectory FROM STDIN CSV HEADER DELIMITER as ','") - with open('test_bbox.csv', 'r') as bbox_f: - cur.copy_expert(file=bbox_f, sql="COPY General_Bbox FROM STDIN CSV HEADER DELIMITER as ','") - - conn.commit() - + cur = conn.cursor() + cur.execute(CREATE_CAMERA_SQL) + cur.execute(CREATE_ITEMTRAJ_SQL) + cur.execute(CREATE_BBOXES_SQL) + conn.commit() + with open("test_camera.csv", "r") as camera_f: + cur.copy_expert(file=camera_f, sql="COPY Cameras FROM STDIN CSV HEADER DELIMITER as ','") + with open("test_trajectory.csv", "r") as trajectory_f: + cur.copy_expert( + file=trajectory_f, + sql="COPY Item_General_Trajectory FROM STDIN CSV HEADER DELIMITER as ','", + ) + with open("test_bbox.csv", "r") as bbox_f: + cur.copy_expert(file=bbox_f, sql="COPY General_Bbox FROM STDIN CSV HEADER DELIMITER as ','") + + conn.commit() + + # Helper function to convert the timestam to the timestamp formula pg-trajectory uses + + def convert_timestamps(start_time, timestamps): - return [str(start_time + datetime.timedelta(seconds=t)) for t in timestamps] + return [str(start_time + datetime.timedelta(seconds=t)) for t in timestamps] + # Helper function to convert trajectory to centroids + + def bbox_to_data3d(bbox): - ''' - Compute the center, x, y, z delta of the bbox - ''' - tl, br = bbox - x_delta = (br[0] - tl[0])/2 - y_delta = (br[1] - tl[1])/2 - z_delta = (br[2] - tl[2])/2 - center = (tl[0] + x_delta, tl[1] + y_delta, tl[2] + z_delta) - - return center, x_delta, y_delta, z_delta \ No newline at end of file + """ + Compute the center, x, y, z delta of the bbox + """ + tl, br = bbox + x_delta = (br[0] - tl[0]) / 2 + y_delta = (br[1] - tl[1]) / 2 + z_delta = (br[2] - tl[2]) / 2 + center = (tl[0] + x_delta, tl[1] + y_delta, tl[2] + z_delta) + + return center, x_delta, y_delta, z_delta diff --git a/apperception/video_context.py b/apperception/video_context.py index 616231f7..89cb46c7 100644 --- a/apperception/video_context.py +++ b/apperception/video_context.py @@ -2,10 +2,9 @@ import datetime from dataclasses import dataclass, field -from typing import Any, Dict, List, Optional, Tuple +from typing import Any, Dict, Optional import psycopg2 -import datetime class Camera: @@ -16,10 +15,9 @@ def __init__(self, scenic_scene_name): # If user calls recognize, those items will have already been # stored in the backend. These are reserved for objects that users # have not added to the camera. - self.items = [] + self.items = [] self.object_recognition = None - def add_item(self, item: Item): # Add item self.items.append(item) diff --git a/apperception/video_context_executor.py b/apperception/video_context_executor.py index b1426998..7d178969 100644 --- a/apperception/video_context_executor.py +++ b/apperception/video_context_executor.py @@ -1,8 +1,11 @@ from typing import Any, List, Set + from bounding_box import BoundingBox +from scenic_util import (add_recognized_objs, create_or_insert_camera_table, + recognize) from video_context import Camera, VideoContext -from video_util import create_or_insert_world_table, video_data_to_tasm, metadata_to_tasm -from scenic_util import create_or_insert_camera_table, recognize, add_recognized_objs +from video_util import (create_or_insert_world_table, metadata_to_tasm, + video_data_to_tasm) class VideoContextExecutor: @@ -23,7 +26,7 @@ def visit(self): return video_query def visit_world(self): - # Query to store world in database + # Query to store world in database name, units = self.current_context.name, self.current_context.units world_sql = create_or_insert_world_table(self.conn, name, units) @@ -49,7 +52,9 @@ def visit_obj_rec(self, camera_node, object_rec_node): start_time = self.current_context.start_time - tracking_results = recognize(cam_id, object_rec_node.sample_data, object_rec_node.annotation) + tracking_results = recognize( + cam_id, object_rec_node.sample_data, object_rec_node.annotation + ) add_recognized_objs(self.conn, tracking_results, start_time) if self.tasm: metadata_to_tasm(tracking_results, camera_node.metadata_id, self.tasm) diff --git a/apperception/video_util.py b/apperception/video_util.py index f4d690da..a08d777a 100644 --- a/apperception/video_util.py +++ b/apperception/video_util.py @@ -34,30 +34,33 @@ def bound_height(y): def create_or_insert_world_table(conn, name, units): - #Creating a cursor object using the cursor() method - cursor = conn.cursor() - ''' + # Creating a cursor object using the cursor() method + cursor = conn.cursor() + """ Create and Populate A world table with the given world object. - ''' - #Doping Worlds table if already exists. - cursor.execute("DROP TABLE IF EXISTS Worlds;") - #Creating table with the first world - sql = '''CREATE TABLE IF NOT EXISTS Worlds( + """ + # Doping Worlds table if already exists. + cursor.execute("DROP TABLE IF EXISTS Worlds;") + # Creating table with the first world + sql = """CREATE TABLE IF NOT EXISTS Worlds( worldId TEXT PRIMARY KEY, units TEXT - );''' - cursor.execute(sql) - print("Worlds Table created successfully........") - insert_world(conn, name, units) - return sql + );""" + cursor.execute(sql) + print("Worlds Table created successfully........") + insert_world(conn, name, units) + return sql + # Helper function to insert the world + + def insert_world(conn, name, units): - #Creating a cursor object using the cursor() method - cursor = conn.cursor() - cursor.execute('''INSERT INTO Worlds (worldId, units) '''+ \ - '''VALUES (\'%s\', \'%s\');''' \ - %(name, units)) - print("New world inserted successfully........") - #Insert the existing cameras of the current world into the camera table - conn.commit() + # Creating a cursor object using the cursor() method + cursor = conn.cursor() + cursor.execute( + """INSERT INTO Worlds (worldId, units) """ + """VALUES (\'%s\', \'%s\');""" % (name, units) + ) + print("New world inserted successfully........") + # Insert the existing cameras of the current world into the camera table + conn.commit() diff --git a/apperception/world.py b/apperception/world.py index b80a57f0..f5eedbdc 100644 --- a/apperception/world.py +++ b/apperception/world.py @@ -1,16 +1,14 @@ import copy +import datetime import cv2 import matplotlib import matplotlib.pyplot as plt import numpy as np -import datetime -from bounding_box import WHOLE_FRAME, BoundingBox from metadata_context import MetadataContext -from tracker import Tracker +from scenic_util import transformation from video_context import VideoContext from world_executor import WorldExecutor -from scenic_util import transformation matplotlib.use("Qt5Agg") @@ -28,7 +26,7 @@ def __init__(self, name, units, enable_tasm=False): # self.AccessedVideoContext = False def get_camera(self, scene_name, frame_num): - # Change depending if you're on docker or not + # Change depending if you're on docker or not # TODO: fix get_camera in scenic_world_executor.py if self.enable_tasm: world_executor.connect_db( @@ -38,9 +36,9 @@ def get_camera(self, scene_name, frame_num): world_executor.connect_db(user="docker", password="docker", database_name="mobilitydb") return world_executor.get_camera(scene_name, frame_num) -######################### -### Video Context #### -######################### + ######################### + ### Video Context #### + ######################### def get_lens(self, cam_id=""): return self.get_camera(cam_id).lens @@ -171,11 +169,13 @@ def overlay_trajectory(self, scene_name, trajectory): # frame_num is int[[]], hence camera_info should also be [[]] camera_info = [] for cur_frame_num in frame_num: - camera_info.append(self.get_camera(scene_name, cur_frame_num)) ### TODO: fetch_camera_info in scenic_utils.py + camera_info.append( + self.get_camera(scene_name, cur_frame_num) + ) # TODO: fetch_camera_info in scenic_utils.py assert len(camera_info) == len(frame_num) assert len(camera_info[0]) == len(frame_num[0]) overlay_info = self.get_overlay_info(trajectory, camera_info) - ### TODO: fix the following to overlay the 2d point onto the frame + # TODO: fix the following to overlay the 2d point onto the frame for traj in trajectory: current_trajectory = np.asarray(traj[0]) frame_points = camera.lens.world_to_pixels(current_trajectory.T).T @@ -189,55 +189,65 @@ def overlay_trajectory(self, scene_name, trajectory): plt.show() def trajectory_to_frame_num(self, trajectory): - ''' + """ fetch the frame number from the trajectory 1. get the time stamp field from the trajectory 2. convert the time stamp to frame number Refer to 'convert_datetime_to_frame_num' in 'video_util.py' 3. return the frame number - ''' + """ frame_num = [] start_time = self.MetadataContext.start_time for traj in trajectory: current_trajectory = traj[0] - date_times = current_trajectory['datetimes'] - frame_num.append([ - (datetime.datetime.strptime(t, "%Y-%m-%dT%H:%M:%S+00").replace(tzinfo=None) - start_time).total_seconds() - for t - in date_times - ]) + date_times = current_trajectory["datetimes"] + frame_num.append( + [ + ( + datetime.datetime.strptime(t, "%Y-%m-%dT%H:%M:%S+00").replace(tzinfo=None) + - start_time + ).total_seconds() + for t in date_times + ] + ) return frame_num def get_overlay_info(self, trajectory, camera_info): - ''' + """ overlay each trajectory 3d coordinate on to the frame specified by the camera_info 1. for each trajectory, get the 3d coordinate 2. get the camera_info associated to it - 3. implement the transformation function from 3d to 2d + 3. implement the transformation function from 3d to 2d given the single centroid point and camera configuration refer to TODO in "senic_utils.py" 4. return a list of (2d coordinate, frame name/filename) - ''' + """ result = [] for traj_num in range(len(trajectory)): - traj_obj = trajectory[traj_num][0] # traj_obj means the trajectory of current object - traj_obj_3d = traj_obj['coordinates'] # 3d coordinate list of the object's trajectory - camera_info_obj = camera_info[traj_num] # camera info list corresponding the 3d coordinate - traj_obj_2d = [] # 2d coordinate list + traj_obj = trajectory[traj_num][0] # traj_obj means the trajectory of current object + traj_obj_3d = traj_obj["coordinates"] # 3d coordinate list of the object's trajectory + camera_info_obj = camera_info[ + traj_num + ] # camera info list corresponding the 3d coordinate + traj_obj_2d = [] # 2d coordinate list for index in range(len(camera_info_obj)): - cur_camera_info = camera_info_obj[index] # camera info of the obejct in one point of the trajectory - centroid_3d = np.array(traj_obj_3d[index]) # one point of the trajectory in 3d + cur_camera_info = camera_info_obj[ + index + ] # camera info of the obejct in one point of the trajectory + centroid_3d = np.array(traj_obj_3d[index]) # one point of the trajectory in 3d # in order to fit into the function transformation, we develop a dictionary called camera_config camera_config = {} - camera_config['egoTranslation'] = cur_camera_info[1] - camera_config['egoRotation'] = np.array(cur_camera_info[2]) - camera_config['cameraTranslation'] = cur_camera_info[3] - camera_config['cameraRotation'] = np.array(cur_camera_info[4]) - camera_config['cameraIntrinsic'] = np.array(cur_camera_info[5]) - traj_2d = transformation(centroid_3d, camera_config) # one point of the trajectory in 2d + camera_config["egoTranslation"] = cur_camera_info[1] + camera_config["egoRotation"] = np.array(cur_camera_info[2]) + camera_config["cameraTranslation"] = cur_camera_info[3] + camera_config["cameraRotation"] = np.array(cur_camera_info[4]) + camera_config["cameraIntrinsic"] = np.array(cur_camera_info[5]) + traj_2d = transformation( + centroid_3d, camera_config + ) # one point of the trajectory in 2d framenum = cur_camera_info[6] filename = cur_camera_info[7] traj_obj_2d.append((traj_2d, framenum, filename)) result.append(traj_obj_2d) - return result \ No newline at end of file + return result diff --git a/apperception/world_executor.py b/apperception/world_executor.py index 00687d3e..14933bab 100644 --- a/apperception/world_executor.py +++ b/apperception/world_executor.py @@ -2,8 +2,8 @@ import psycopg2 from metadata_context import geometry, primarykey, time from metadata_context_executor import MetadataContextExecutor +from scenic_util import fetch_camera from video_context_executor import VideoContextExecutor -from scenic_util import (fetch_camera) class WorldExecutor: @@ -29,11 +29,11 @@ def enable_tasm(self): if not self.tasm: self.tasm = tasm.TASM() - + def get_camera(self, scene_name, frame_num): assert self.curr_world, self.conn cameras = fetch_camera(self.conn, scene_name, frame_num) - ### each camera appear like: + # each camera appear like: ### (cameraId, ratio, origin3d, focalpoints2d, fov, skev_factor) return cameras @@ -62,9 +62,9 @@ def tasm_get_video(self, metadata_results): def get_video(self, metadata_results): start_time = self.curr_world.VideoContext.start_time # print("Start time is", start_time) - ### The cam nodes are raw data from the database - ### TODO: I forget why we used the data from the db instead of directly fetch - ### from the world + # The cam nodes are raw data from the database + # TODO: I forget why we used the data from the db instead of directly fetch + # from the world cam_nodes = self.curr_world.get_video_cams video_files = [] for i in range(len(cam_nodes)): From 14868f255e152474ae622119878faf968439c2ea Mon Sep 17 00:00:00 2001 From: "Chanwut (Mick) Kittivorawong" Date: Fri, 4 Mar 2022 11:31:05 -0800 Subject: [PATCH 24/26] indent using spaces --- apperception/scenic_util.py | 213 +++++++++++++++++++----------------- 1 file changed, 110 insertions(+), 103 deletions(-) diff --git a/apperception/scenic_util.py b/apperception/scenic_util.py index f4beff5f..e92b51eb 100644 --- a/apperception/scenic_util.py +++ b/apperception/scenic_util.py @@ -7,36 +7,42 @@ from box import Box from pyquaternion import Quaternion -CREATE_ITEMTRAJ_SQL = """CREATE TABLE IF NOT EXISTS Item_General_Trajectory( - itemId TEXT, - objectType TEXT, - frameId TEXT, - color TEXT, - trajCentroids tgeompoint, - largestBbox stbox, - PRIMARY KEY (itemId) - );""" - -CREATE_BBOXES_SQL = """CREATE TABLE IF NOT EXISTS General_Bbox( - itemId TEXT, - trajBbox stbox, - FOREIGN KEY(itemId) - REFERENCES Item_General_Trajectory(itemId) - );""" - -CREATE_CAMERA_SQL = """CREATE TABLE IF NOT EXISTS Cameras( - cameraId TEXT, - worldId TEXT, - frameId TEXT, - frameNum Int, - fileName TEXT, - cameraTranslation geometry, - cameraRotation real[4], - cameraIntrinsic real[3][3], - egoTranslation geometry, - egoRotation real[4], - timestamp TEXT - );""" +CREATE_ITEMTRAJ_SQL = """ +CREATE TABLE IF NOT EXISTS Item_General_Trajectory( + itemId TEXT, + objectType TEXT, + frameId TEXT, + color TEXT, + trajCentroids tgeompoint, + largestBbox stbox, + PRIMARY KEY (itemId) +); +""" + +CREATE_BBOXES_SQL = """ +CREATE TABLE IF NOT EXISTS General_Bbox( + itemId TEXT, + trajBbox stbox, + FOREIGN KEY(itemId) + REFERENCES Item_General_Trajectory(itemId) +); +""" + +CREATE_CAMERA_SQL = """ +CREATE TABLE IF NOT EXISTS Cameras( + cameraId TEXT, + worldId TEXT, + frameId TEXT, + frameNum Int, + fileName TEXT, + cameraTranslation geometry, + cameraRotation real[4], + cameraIntrinsic real[3][3], + egoTranslation geometry, + egoRotation real[4], + timestamp TEXT +); +""" def fetch_camera_config(scene_name, sample_data): @@ -90,8 +96,8 @@ def create_or_insert_camera_table(conn, world_name, camera): # Creating a cursor object using the cursor() method cursor = conn.cursor() """ - Create and Populate A camera table with the given camera object. - """ + Create and Populate A camera table with the given camera object. + """ # Doping Cameras table if already exists. cursor.execute("DROP TABLE IF EXISTS Cameras") # Formal_Scenic_cameras table stands for the formal table which won't be erased @@ -117,36 +123,37 @@ def insert_camera(conn, world_name, camera_config): for config in camera_config: values.append( f"""( - '{config['camera_id']}', - '{world_name}', - '{config['frame_id']}', - {config['frame_num']}, - '{config['filename']}', - 'POINT Z ({' '.join(map(str, config['camera_translation']))})', - ARRAY{config['camera_rotation']}, - ARRAY{config['camera_intrinsic']}, - 'POINT Z ({' '.join(map(str, config['ego_translation']))})', - ARRAY{config['ego_rotation']}, - '{config['timestamp']}' - )""" + '{config['camera_id']}', + '{world_name}', + '{config['frame_id']}', + {config['frame_num']}, + '{config['filename']}', + 'POINT Z ({' '.join(map(str, config['camera_translation']))})', + ARRAY{config['camera_rotation']}, + ARRAY{config['camera_intrinsic']}, + 'POINT Z ({' '.join(map(str, config['ego_translation']))})', + ARRAY{config['ego_rotation']}, + '{config['timestamp']}' + )""" ) cursor.execute( f""" - INSERT INTO Cameras ( - cameraId, - worldId, - frameId, - frameNum, - fileName, - cameraTranslation, - cameraRotation, - cameraIntrinsic, - egoTranslation, - egoRotation, - timestamp - ) - VALUES {','.join(values)};""" + INSERT INTO Cameras ( + cameraId, + worldId, + frameId, + frameNum, + fileName, + cameraTranslation, + cameraRotation, + cameraIntrinsic, + egoTranslation, + egoRotation, + timestamp + ) + VALUES {','.join(values)}; + """ ) print("New camera inserted successfully.........") @@ -354,10 +361,10 @@ def create_or_insert_general_trajectory( ): cursor = conn.cursor() """ - Create and Populate A Trajectory table using mobilityDB. - Now the timestamp matches, the starting time should be the meta data of the world - Then the timestamp should be the timestamp regarding the world starting time - """ + Create and Populate A Trajectory table using mobilityDB. + Now the timestamp matches, the starting time should be the meta data of the world + Then the timestamp should be the timestamp regarding the world starting time + """ # Formal_Scenic_Item_General_Trajectory table stands for the formal table which won't be erased # Test for now @@ -411,15 +418,15 @@ def insert_general_trajectory( # Insert bbox insert_bbox_trajectories_builder.append( f""" - INSERT INTO General_Bbox (itemId, trajBbox) - VALUES ( - '{item_id}', - STBOX 'STBOX ZT( - ({join([*tl, timestamp])}), - ({join([*br, timestamp])}) - )' - ); - """ + INSERT INTO General_Bbox (itemId, trajBbox) + VALUES ( + '{item_id}', + STBOX 'STBOX ZT( + ({join([*tl, timestamp])}), + ({join([*br, timestamp])}) + )' + ); + """ ) # Construct trajectory @@ -427,18 +434,18 @@ def insert_general_trajectory( # Insert the item_trajectory separately insert_trajectory = f""" - INSERT INTO Item_General_Trajectory (itemId, objectType, color, trajCentroids, largestBbox) - VALUES ( - '{item_id}', - '{object_type}', - '{color}', - '{{{', '.join(traj_centroids)}}}', - STBOX 'STBOX Z( - ({join(min_tl)}), - ({join(max_br)}) - )' - ); - """ + INSERT INTO Item_General_Trajectory (itemId, objectType, color, trajCentroids, largestBbox) + VALUES ( + '{item_id}', + '{object_type}', + '{color}', + '{{{', '.join(traj_centroids)}}}', + STBOX 'STBOX Z( + ({join(min_tl)}), + ({join(max_br)}) + )' + ); + """ cursor.execute(insert_trajectory) cursor.execute("".join(insert_bbox_trajectories_builder)) @@ -493,26 +500,26 @@ def fetch_camera(conn, scene_name, frame_num): # + '''FROM Cameras WHERE cameraId IN (\'%s\') AND worldId = \'%s\';''' %(','.join(cam_id), world_id) # TODO: define ST_XYZ somewhere else query = f""" - CREATE OR REPLACE FUNCTION ST_XYZ (g geometry) RETURNS real[] AS $$ - BEGIN - RETURN ARRAY[ST_X(g), ST_Y(g), ST_Z(g)]; - END; - $$ LANGUAGE plpgsql; - - SELECT - cameraId, - ST_XYZ(egoTranslation), - egoRotation, - ST_XYZ(cameraTranslation), - cameraRotation, - cameraIntrinsic, - frameNum, - fileName - FROM Cameras - WHERE - cameraId = '{scene_name}' AND - frameNum IN ({",".join(map(str, frame_num))}); - """ + CREATE OR REPLACE FUNCTION ST_XYZ (g geometry) RETURNS real[] AS $$ + BEGIN + RETURN ARRAY[ST_X(g), ST_Y(g), ST_Z(g)]; + END; + $$ LANGUAGE plpgsql; + + SELECT + cameraId, + ST_XYZ(egoTranslation), + egoRotation, + ST_XYZ(cameraTranslation), + cameraRotation, + cameraIntrinsic, + frameNum, + fileName + FROM Cameras + WHERE + cameraId = '{scene_name}' AND + frameNum IN ({",".join(map(str, frame_num))}); + """ cursor.execute(query) return cursor.fetchall() From 8ad68e70c3296d8ce6e02892a368ec84a6c92998 Mon Sep 17 00:00:00 2001 From: "Chanwut (Mick) Kittivorawong" Date: Fri, 4 Mar 2022 11:46:14 -0800 Subject: [PATCH 25/26] clean up --- apperception/metadata_context_executor.py | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/apperception/metadata_context_executor.py b/apperception/metadata_context_executor.py index 92827bff..c9f753f0 100644 --- a/apperception/metadata_context_executor.py +++ b/apperception/metadata_context_executor.py @@ -4,6 +4,7 @@ from metadata_context import (Aggregate, Column, Filter, MetadataContext, Predicate, Project, Scan, asMFJSON) from metadata_util import common_aggregation, metadata_view +from scenic_util import join class MetadataContextExecutor: @@ -117,15 +118,12 @@ def execute(self, create_view: bool = False, view_name: str = ""): def translate_aggregation(aggr_node: Aggregate, aggregated: str): - aggregated = aggr_node.func_name + "(" + aggregated - for param in aggr_node.parameters: - aggregated = aggregated + "," + param - aggregated += ")" - if aggr_node.func_name in common_aggregation: - if isinstance(aggr_node, asMFJSON): - if len(aggr_node.interesting_fields) > 0: - interesting_field = aggr_node.interesting_fields[0] - aggregated = aggregated + "::json->" + "'" + interesting_field + "'" - else: - aggregated = aggregated + "::json" + aggregated = f"{aggr_node.func_name}({aggregated},{join(aggr_node.parameters)})" + + if isinstance(aggr_node, asMFJSON) and aggr_node.func_name in common_aggregation: + if len(aggr_node.interesting_fields) > 0: + interesting_field = aggr_node.interesting_fields[0] + aggregated += f"::json->'{interesting_field}'" + else: + aggregated += "::json" return aggregated From b3966a30ec714941c674df8469b844769c00557b Mon Sep 17 00:00:00 2001 From: "Chanwut (Mick) Kittivorawong" Date: Fri, 4 Mar 2022 12:56:44 -0800 Subject: [PATCH 26/26] add support for directly import all mini dataset, have uploaded the data to drive + delete jupyter for mere + fix bug --- apperception/metadata_context_executor.py | 2 +- scenic_test.ipynb | 10907 ++------------------ 2 files changed, 625 insertions(+), 10284 deletions(-) diff --git a/apperception/metadata_context_executor.py b/apperception/metadata_context_executor.py index c9f753f0..345fa649 100644 --- a/apperception/metadata_context_executor.py +++ b/apperception/metadata_context_executor.py @@ -118,7 +118,7 @@ def execute(self, create_view: bool = False, view_name: str = ""): def translate_aggregation(aggr_node: Aggregate, aggregated: str): - aggregated = f"{aggr_node.func_name}({aggregated},{join(aggr_node.parameters)})" + aggregated = f"{aggr_node.func_name}({join([aggregated, *aggr_node.parameters])})" if isinstance(aggr_node, asMFJSON) and aggr_node.func_name in common_aggregation: if len(aggr_node.interesting_fields) > 0: diff --git a/scenic_test.ipynb b/scenic_test.ipynb index 3ce28f1b..94e51926 100644 --- a/scenic_test.ipynb +++ b/scenic_test.ipynb @@ -3,7 +3,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "11413b36", + "id": "a644cff5", "metadata": {}, "outputs": [], "source": [ @@ -15,6 +15,8 @@ "import cv2\n", "\n", "from world import *\n", + "from world_executor import *\n", + "from video_util import *\n", "from metadata_util import *\n", "import json\n", "import pandas as pd\n", @@ -25,7 +27,24 @@ { "cell_type": "code", "execution_count": 2, - "id": "c0024fbb", + "id": "230d3b5e", + "metadata": {}, + "outputs": [], + "source": [ + "### Directly import all mini data to db without using the API\n", + "### Make sure you've downloaded the data from drive\n", + "from scenic_util import *\n", + "import psycopg2\n", + "conn = psycopg2.connect(\n", + " database=\"mobilitydb\", user=\"docker\", password=\"docker\", host=\"localhost\", port=25432)\n", + "clean_tables(conn)\n", + "import_tables(conn)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "923f1ffe", "metadata": {}, "outputs": [], "source": [ @@ -37,8 +56,8 @@ }, { "cell_type": "code", - "execution_count": 3, - "id": "9a9b1ae5", + "execution_count": 4, + "id": "7d950c6f", "metadata": {}, "outputs": [], "source": [ @@ -49,11 +68,9 @@ }, { "cell_type": "code", - "execution_count": 4, - "id": "73e281bd", - "metadata": { - "scrolled": true - }, + "execution_count": 5, + "id": "8b533a16", + "metadata": {}, "outputs": [ { "data": { @@ -344,7 +361,7 @@ "[14008 rows x 11 columns]" ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -355,11 +372,9 @@ }, { "cell_type": "code", - "execution_count": 5, - "id": "76c201ef", - "metadata": { - "scrolled": true - }, + "execution_count": 6, + "id": "0ab854a0", + "metadata": {}, "outputs": [ { "data": { @@ -576,7 +591,7 @@ "[18538 rows x 7 columns]" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -587,8 +602,8 @@ }, { "cell_type": "code", - "execution_count": 6, - "id": "70c7a420", + "execution_count": 7, + "id": "6e47833c", "metadata": {}, "outputs": [], "source": [ @@ -597,8 +612,8 @@ }, { "cell_type": "code", - "execution_count": 7, - "id": "d1b14857", + "execution_count": 8, + "id": "8ec55131", "metadata": {}, "outputs": [], "source": [ @@ -609,11 +624,9 @@ }, { "cell_type": "code", - "execution_count": 8, - "id": "a63b385f", - "metadata": { - "scrolled": true - }, + "execution_count": 9, + "id": "d117b196", + "metadata": {}, "outputs": [ { "name": "stdout", @@ -623,247 +636,87 @@ "New world inserted successfully........\n", "Camera Table created successfully........\n", "New camera inserted successfully.........\n", - "Recognization done, saving to database......\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" + "Recognization done, saving to database......\n" ] } ], "source": [ "### Call execute on the world to run the detection algorithm and save the real data to the database\n", - "recognized_scenic_world = scenic_world_61.recognize(scene_name, df_sample_data, df_annotation)\n", - "recognized_scenic_world.execute()" + "recognized_scenic_world_61 = scenic_world_61.recognize(scene_name, df_sample_data, df_annotation)\n", + "recognized_scenic_world_61.execute()" ] }, { "cell_type": "code", - "execution_count": 9, - "id": "7c7de169", + "execution_count": 10, + "id": "aa92c3e8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Worlds Table created successfully........\n", + "New world inserted successfully........\n", + "Camera Table created successfully........\n", + "New camera inserted successfully.........\n", + "Recognization done, saving to database......\n", + "Worlds Table created successfully........\n", + "New world inserted successfully........\n", + "Camera Table created successfully........\n", + "New camera inserted successfully.........\n", + "Recognization done, saving to database......\n", + "Worlds Table created successfully........\n", + "New world inserted successfully........\n", + "Camera Table created successfully........\n", + "New camera inserted successfully.........\n", + "Recognization done, saving to database......\n", + "Worlds Table created successfully........\n", + "New world inserted successfully........\n", + "Camera Table created successfully........\n", + "New camera inserted successfully.........\n", + "Recognization done, saving to database......\n", + "Worlds Table created successfully........\n", + "New world inserted successfully........\n", + "Camera Table created successfully........\n", + "New camera inserted successfully.........\n", + "Recognization done, saving to database......\n", + "Worlds Table created successfully........\n", + "New world inserted successfully........\n", + "Camera Table created successfully........\n", + "New camera inserted successfully.........\n", + "Recognization done, saving to database......\n", + "Worlds Table created successfully........\n", + "New world inserted successfully........\n", + "Camera Table created successfully........\n", + "New camera inserted successfully.........\n", + "Recognization done, saving to database......\n", + "Worlds Table created successfully........\n", + "New world inserted successfully........\n", + "Camera Table created successfully........\n", + "New camera inserted successfully.........\n", + "Recognization done, saving to database......\n", + "Worlds Table created successfully........\n", + "New world inserted successfully........\n", + "Camera Table created successfully........\n", + "New camera inserted successfully.........\n", + "Recognization done, saving to database......\n" + ] + } + ], + "source": [ + "scenes = [\"scene-0103\",\"scene-0553\", \"scene-0655\", \"scene-0757\", \"scene-0796\",\n", + " \"scene-0916\", \"scene-1077\", \"scene-1094\", \"scene-1100\"]\n", + "for scene in scenes:\n", + " current_scenic_world = scenic_world.camera(scene)\n", + " current_recognized_scenic_world = current_scenic_world.recognize(scene, df_sample_data, df_annotation)\n", + " current_recognized_scenic_world.execute()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "20e5891a", "metadata": {}, "outputs": [ { @@ -887,8 +740,8 @@ }, { "cell_type": "code", - "execution_count": 10, - "id": "0fcaf8ac", + "execution_count": 12, + "id": "8561179d", "metadata": { "scrolled": true }, @@ -897,7 +750,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'type': 'MovingPoint', 'coordinates': [[353.794, 1132.355, 0.602], [353.776, 1132.363, 0.622], [353.776, 1132.363, 0.622], [353.776, 1132.363, 0.622], [353.776, 1132.363, 0.622], [353.776, 1132.363, 0.622], [353.776, 1132.363, 0.622], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.759, 1132.37, 0.642], [353.741, 1132.378, 0.662], [353.741, 1132.378, 0.662], [353.741, 1132.378, 0.662], [353.741, 1132.378, 0.662], [353.741, 1132.378, 0.662], [353.741, 1132.378, 0.662], [353.724, 1132.385, 0.682], [353.724, 1132.385, 0.682], [353.724, 1132.385, 0.682], [353.724, 1132.385, 0.682], [353.724, 1132.385, 0.682], [353.724, 1132.385, 0.682], [353.755, 1132.372, 0.677], [353.755, 1132.372, 0.677], [353.755, 1132.372, 0.677], [353.755, 1132.372, 0.677], [353.755, 1132.372, 0.677], [353.786, 1132.358, 0.672], [353.786, 1132.358, 0.672], [353.786, 1132.358, 0.672], [353.786, 1132.358, 0.672], [353.786, 1132.358, 0.672], [353.786, 1132.358, 0.672], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.755, 1132.441, 0.705], [353.83, 1132.369, 0.737], [353.83, 1132.369, 0.737], [353.83, 1132.369, 0.737], [353.83, 1132.369, 0.737], [353.83, 1132.369, 0.737], [353.83, 1132.369, 0.737], [353.905, 1132.296, 0.77], [353.905, 1132.296, 0.77], [353.905, 1132.296, 0.77], [353.905, 1132.296, 0.77], [353.905, 1132.296, 0.77], [353.905, 1132.296, 0.77], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.911, 1132.305, 0.802], [353.906, 1132.322, 0.859], [353.906, 1132.322, 0.859], [353.906, 1132.322, 0.859], [353.906, 1132.322, 0.859], [353.906, 1132.322, 0.859], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.9, 1132.339, 0.916], [353.924, 1132.329, 1.151], [353.924, 1132.329, 1.151], [353.924, 1132.329, 1.151], [353.924, 1132.329, 1.151], [353.924, 1132.329, 1.151], [353.924, 1132.329, 1.151], [354.008, 1132.468, 1.186], [354.008, 1132.468, 1.186], [354.008, 1132.468, 1.186], [354.008, 1132.468, 1.186], [354.008, 1132.468, 1.186], [354.008, 1132.468, 1.186], [354.035, 1132.468, 1.196], [354.035, 1132.468, 1.196], [354.035, 1132.468, 1.196], [354.035, 1132.468, 1.196], [354.035, 1132.468, 1.196], [354.063, 1132.468, 1.206], [354.063, 1132.468, 1.206], [354.063, 1132.468, 1.206], [354.063, 1132.468, 1.206], [354.063, 1132.468, 1.206], [354.091, 1132.468, 1.216], [354.091, 1132.468, 1.216], [354.091, 1132.468, 1.216], [354.091, 1132.468, 1.216], [354.091, 1132.468, 1.216], [354.091, 1132.468, 1.216], [354.038, 1132.593, 1.366], [354.038, 1132.593, 1.366], [354.038, 1132.593, 1.366], [354.038, 1132.593, 1.366], [354.038, 1132.593, 1.366], [354.038, 1132.593, 1.366], [354.104, 1132.795, 1.367], [354.104, 1132.795, 1.367], [354.104, 1132.795, 1.367], [354.104, 1132.795, 1.367], [354.104, 1132.795, 1.367], [354.104, 1132.795, 1.367], [354.026, 1132.642, 1.267], [354.026, 1132.642, 1.267], [354.026, 1132.642, 1.267], [354.026, 1132.642, 1.267], [354.026, 1132.642, 1.267], [354.02, 1132.667, 1.28], [354.02, 1132.667, 1.28], [354.02, 1132.667, 1.28], [354.02, 1132.667, 1.28], [354.02, 1132.667, 1.28], [354.02, 1132.667, 1.28], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.014, 1132.691, 1.294], [354.009, 1132.716, 1.307], [354.009, 1132.716, 1.307], [354.009, 1132.716, 1.307], [354.009, 1132.716, 1.307], [354.009, 1132.716, 1.307], [354.009, 1132.716, 1.307], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [354.003, 1132.741, 1.32], [353.997, 1132.765, 1.333], [353.997, 1132.765, 1.333], [353.997, 1132.765, 1.333], [353.997, 1132.765, 1.333], [353.997, 1132.765, 1.333], [353.997, 1132.765, 1.333], [353.991, 1132.79, 1.346], [353.991, 1132.79, 1.346], [353.991, 1132.79, 1.346], [353.991, 1132.79, 1.346], [353.991, 1132.79, 1.346], [353.991, 1132.79, 1.346], [353.985, 1132.815, 1.359], [353.985, 1132.815, 1.359], [353.985, 1132.815, 1.359], [353.985, 1132.815, 1.359], [353.985, 1132.815, 1.359], [353.979, 1132.839, 1.372], [353.979, 1132.839, 1.372], [353.979, 1132.839, 1.372], [353.979, 1132.839, 1.372], [353.979, 1132.839, 1.372], [353.973, 1132.864, 1.346], [353.973, 1132.864, 1.346], [353.973, 1132.864, 1.346], [353.973, 1132.864, 1.346], [353.973, 1132.864, 1.346], [353.973, 1132.864, 1.346], [353.967, 1132.889, 1.32], [353.967, 1132.889, 1.32], [353.967, 1132.889, 1.32], [353.967, 1132.889, 1.32], [353.967, 1132.889, 1.32], [353.967, 1132.889, 1.32], [353.961, 1132.913, 1.294], [353.961, 1132.913, 1.294], [353.961, 1132.913, 1.294], [353.961, 1132.913, 1.294], [353.961, 1132.913, 1.294], [353.961, 1132.913, 1.294], [353.956, 1132.938, 1.268], [353.956, 1132.938, 1.268], [353.956, 1132.938, 1.268], [353.956, 1132.938, 1.268], [353.956, 1132.938, 1.268], [353.956, 1132.938, 1.268], [353.95, 1132.963, 1.242], [353.95, 1132.963, 1.242], [353.95, 1132.963, 1.242], [353.95, 1132.963, 1.242], [353.95, 1132.963, 1.242], [353.944, 1132.987, 1.216], [353.944, 1132.987, 1.216], [353.944, 1132.987, 1.216], [353.944, 1132.987, 1.216], [353.944, 1132.987, 1.216], [353.944, 1132.987, 1.216]], 'datetimes': ['2021-06-08T07:10:29+00', '2021-06-08T07:10:30+00', '2021-06-08T07:10:31+00', '2021-06-08T07:10:32+00', '2021-06-08T07:10:33+00', '2021-06-08T07:10:34+00', '2021-06-08T07:10:35+00', '2021-06-08T07:10:36+00', '2021-06-08T07:10:37+00', '2021-06-08T07:10:38+00', '2021-06-08T07:10:39+00', '2021-06-08T07:10:40+00', '2021-06-08T07:10:41+00', '2021-06-08T07:10:42+00', '2021-06-08T07:10:43+00', '2021-06-08T07:10:44+00', '2021-06-08T07:10:45+00', '2021-06-08T07:10:46+00', '2021-06-08T07:10:47+00', '2021-06-08T07:10:48+00', '2021-06-08T07:10:49+00', '2021-06-08T07:10:50+00', '2021-06-08T07:10:51+00', '2021-06-08T07:10:52+00', '2021-06-08T07:10:53+00', '2021-06-08T07:10:54+00', '2021-06-08T07:10:55+00', '2021-06-08T07:10:56+00', '2021-06-08T07:10:57+00', '2021-06-08T07:10:58+00', '2021-06-08T07:10:59+00', '2021-06-08T07:11:00+00', '2021-06-08T07:11:01+00', '2021-06-08T07:11:02+00', '2021-06-08T07:11:03+00', '2021-06-08T07:11:04+00', '2021-06-08T07:11:05+00', '2021-06-08T07:11:06+00', '2021-06-08T07:11:07+00', '2021-06-08T07:11:08+00', '2021-06-08T07:11:09+00', '2021-06-08T07:11:10+00', '2021-06-08T07:11:11+00', '2021-06-08T07:11:12+00', '2021-06-08T07:11:13+00', '2021-06-08T07:11:14+00', '2021-06-08T07:11:15+00', '2021-06-08T07:11:16+00', '2021-06-08T07:11:17+00', '2021-06-08T07:11:18+00', '2021-06-08T07:11:19+00', '2021-06-08T07:11:20+00', '2021-06-08T07:11:21+00', '2021-06-08T07:11:22+00', '2021-06-08T07:11:23+00', '2021-06-08T07:11:24+00', '2021-06-08T07:11:25+00', '2021-06-08T07:11:26+00', '2021-06-08T07:11:27+00', '2021-06-08T07:11:28+00', '2021-06-08T07:11:29+00', '2021-06-08T07:11:30+00', '2021-06-08T07:11:31+00', '2021-06-08T07:11:32+00', '2021-06-08T07:11:33+00', '2021-06-08T07:11:34+00', '2021-06-08T07:11:35+00', '2021-06-08T07:11:36+00', '2021-06-08T07:11:37+00', '2021-06-08T07:11:38+00', '2021-06-08T07:11:39+00', '2021-06-08T07:11:40+00', '2021-06-08T07:11:41+00', '2021-06-08T07:11:42+00', '2021-06-08T07:11:43+00', '2021-06-08T07:11:44+00', '2021-06-08T07:11:45+00', '2021-06-08T07:11:46+00', '2021-06-08T07:11:47+00', '2021-06-08T07:11:48+00', '2021-06-08T07:11:49+00', '2021-06-08T07:11:50+00', '2021-06-08T07:11:51+00', '2021-06-08T07:11:52+00', '2021-06-08T07:11:53+00', '2021-06-08T07:11:54+00', '2021-06-08T07:11:55+00', '2021-06-08T07:11:56+00', '2021-06-08T07:11:57+00', '2021-06-08T07:11:58+00', '2021-06-08T07:11:59+00', '2021-06-08T07:12:00+00', '2021-06-08T07:12:01+00', '2021-06-08T07:12:02+00', '2021-06-08T07:12:03+00', '2021-06-08T07:12:04+00', '2021-06-08T07:12:05+00', '2021-06-08T07:12:06+00', '2021-06-08T07:12:07+00', '2021-06-08T07:12:08+00', '2021-06-08T07:12:09+00', '2021-06-08T07:12:10+00', '2021-06-08T07:12:11+00', '2021-06-08T07:12:12+00', '2021-06-08T07:12:13+00', '2021-06-08T07:12:14+00', '2021-06-08T07:12:15+00', '2021-06-08T07:12:16+00', '2021-06-08T07:12:17+00', '2021-06-08T07:12:18+00', '2021-06-08T07:12:19+00', '2021-06-08T07:12:20+00', '2021-06-08T07:12:21+00', '2021-06-08T07:12:22+00', '2021-06-08T07:12:23+00', '2021-06-08T07:12:24+00', '2021-06-08T07:12:25+00', '2021-06-08T07:12:26+00', '2021-06-08T07:12:27+00', '2021-06-08T07:12:28+00', '2021-06-08T07:12:29+00', '2021-06-08T07:12:30+00', '2021-06-08T07:12:31+00', '2021-06-08T07:12:32+00', '2021-06-08T07:12:33+00', '2021-06-08T07:12:34+00', '2021-06-08T07:12:35+00', '2021-06-08T07:12:36+00', '2021-06-08T07:12:37+00', '2021-06-08T07:12:38+00', '2021-06-08T07:12:39+00', '2021-06-08T07:12:40+00', '2021-06-08T07:12:41+00', '2021-06-08T07:12:42+00', '2021-06-08T07:12:43+00', '2021-06-08T07:12:44+00', '2021-06-08T07:12:45+00', '2021-06-08T07:12:46+00', '2021-06-08T07:12:47+00', '2021-06-08T07:12:48+00', '2021-06-08T07:12:49+00', '2021-06-08T07:12:50+00', '2021-06-08T07:12:51+00', '2021-06-08T07:12:52+00', '2021-06-08T07:12:53+00', '2021-06-08T07:12:54+00', '2021-06-08T07:12:55+00', '2021-06-08T07:12:56+00', '2021-06-08T07:12:57+00', '2021-06-08T07:12:58+00', '2021-06-08T07:12:59+00', '2021-06-08T07:13:00+00', '2021-06-08T07:13:01+00', '2021-06-08T07:13:02+00', '2021-06-08T07:13:03+00', '2021-06-08T07:13:04+00', '2021-06-08T07:13:05+00', '2021-06-08T07:13:06+00', '2021-06-08T07:13:07+00', '2021-06-08T07:13:08+00', '2021-06-08T07:13:09+00', '2021-06-08T07:13:10+00', '2021-06-08T07:13:11+00', '2021-06-08T07:13:12+00', '2021-06-08T07:13:13+00', '2021-06-08T07:13:14+00', '2021-06-08T07:13:15+00', '2021-06-08T07:13:16+00', '2021-06-08T07:13:17+00', '2021-06-08T07:13:18+00', '2021-06-08T07:13:19+00', '2021-06-08T07:13:20+00', '2021-06-08T07:13:21+00', '2021-06-08T07:13:22+00', '2021-06-08T07:13:23+00', '2021-06-08T07:13:24+00', '2021-06-08T07:13:25+00', '2021-06-08T07:13:26+00', '2021-06-08T07:13:27+00', '2021-06-08T07:13:28+00', '2021-06-08T07:13:29+00', '2021-06-08T07:13:30+00', '2021-06-08T07:13:31+00', '2021-06-08T07:13:32+00', '2021-06-08T07:13:33+00', '2021-06-08T07:13:34+00', '2021-06-08T07:13:35+00', '2021-06-08T07:13:36+00', '2021-06-08T07:13:37+00', '2021-06-08T07:13:38+00', '2021-06-08T07:13:39+00', '2021-06-08T07:13:40+00', '2021-06-08T07:13:41+00', '2021-06-08T07:13:42+00', '2021-06-08T07:13:43+00', '2021-06-08T07:13:44+00', '2021-06-08T07:13:45+00', '2021-06-08T07:13:46+00', '2021-06-08T07:13:47+00', '2021-06-08T07:13:48+00', '2021-06-08T07:13:49+00', '2021-06-08T07:13:50+00', '2021-06-08T07:13:51+00', '2021-06-08T07:13:52+00', '2021-06-08T07:13:53+00', '2021-06-08T07:13:54+00', '2021-06-08T07:13:55+00', '2021-06-08T07:13:56+00', '2021-06-08T07:13:57+00', '2021-06-08T07:13:58+00', '2021-06-08T07:13:59+00', '2021-06-08T07:14:00+00'], 'interpolations': ['Discrete']}\n" + "{'type': 'MovingPoint', 'coordinates': [[1274.66, 839.935, -2.533], [1277.163, 844.229, -2.332], [1277.163, 844.229, -2.332], [1277.163, 844.229, -2.332], [1277.163, 844.229, -2.332], [1277.163, 844.229, -2.332], [1277.163, 844.229, -2.332], [1279.663, 848.518, -2.132], [1279.663, 848.518, -2.132], [1279.663, 848.518, -2.132], [1279.663, 848.518, -2.132], [1279.663, 848.518, -2.132], [1279.663, 848.518, -2.132], [1282.163, 852.808, -1.932], [1282.163, 852.808, -1.932], [1282.163, 852.808, -1.932], [1282.163, 852.808, -1.932], [1282.163, 852.808, -1.932], [1282.163, 852.808, -1.932], [1284.663, 857.097, -1.732], [1284.663, 857.097, -1.732], [1284.663, 857.097, -1.732], [1284.663, 857.097, -1.732], [1284.663, 857.097, -1.732], [1284.663, 857.097, -1.732], [1287.271, 861.538, -1.532], [1287.271, 861.538, -1.532], [1287.271, 861.538, -1.532], [1287.271, 861.538, -1.532], [1287.271, 861.538, -1.532], [1287.271, 861.538, -1.532], [1289.88, 865.978, -1.332], [1289.88, 865.978, -1.332], [1289.88, 865.978, -1.332], [1289.88, 865.978, -1.332], [1289.88, 865.978, -1.332], [1289.88, 865.978, -1.332], [1292.531, 870.49, -1.132], [1292.531, 870.49, -1.132], [1292.531, 870.49, -1.132], [1292.531, 870.49, -1.132], [1292.531, 870.49, -1.132], [1295.179, 874.996, -0.932], [1295.179, 874.996, -0.932], [1295.179, 874.996, -0.932], [1295.179, 874.996, -0.932], [1295.179, 874.996, -0.932], [1295.179, 874.996, -0.932], [1297.827, 879.503, -0.732], [1297.827, 879.503, -0.732], [1297.827, 879.503, -0.732], [1297.827, 879.503, -0.732], [1297.827, 879.503, -0.732], [1297.827, 879.503, -0.732], [1300.211, 883.561, -0.552], [1300.211, 883.561, -0.552], [1300.211, 883.561, -0.552], [1300.211, 883.561, -0.552], [1300.211, 883.561, -0.552], [1302.907, 888.039, -0.352], [1302.907, 888.039, -0.352], [1302.907, 888.039, -0.352], [1302.907, 888.039, -0.352], [1302.907, 888.039, -0.352], [1302.907, 888.039, -0.352], [1305.599, 892.512, -0.152], [1305.599, 892.512, -0.152], [1305.599, 892.512, -0.152], [1305.599, 892.512, -0.152], [1305.599, 892.512, -0.152], [1305.599, 892.512, -0.152], [1308.295, 896.99, 0.048], [1308.295, 896.99, 0.048], [1308.295, 896.99, 0.048], [1308.295, 896.99, 0.048], [1308.295, 896.99, 0.048], [1308.295, 896.99, 0.048], [1311.161, 901.318, 0.248], [1311.161, 901.318, 0.248], [1311.161, 901.318, 0.248], [1311.161, 901.318, 0.248], [1311.161, 901.318, 0.248], [1311.161, 901.318, 0.248], [1314.03, 905.65, 0.448], [1314.03, 905.65, 0.448], [1314.03, 905.65, 0.448], [1314.03, 905.65, 0.448], [1314.03, 905.65, 0.448], [1314.03, 905.65, 0.448], [1317.051, 909.62, 0.648], [1317.051, 909.62, 0.648], [1317.051, 909.62, 0.648], [1317.051, 909.62, 0.648], [1317.051, 909.62, 0.648], [1317.051, 909.62, 0.648], [1320.368, 913.979, 0.868], [1320.368, 913.979, 0.868], [1320.368, 913.979, 0.868], [1320.368, 913.979, 0.868], [1320.368, 913.979, 0.868], [1320.368, 913.979, 0.868], [1320.368, 913.979, 0.868], [1323.386, 917.944, 1.069], [1323.386, 917.944, 1.069], [1323.386, 917.944, 1.069], [1323.386, 917.944, 1.069], [1323.386, 917.944, 1.069], [1323.386, 917.944, 1.069], [1326.526, 921.885, 1.264], [1326.526, 921.885, 1.264], [1326.526, 921.885, 1.264], [1326.526, 921.885, 1.264], [1326.526, 921.885, 1.264], [1326.526, 921.885, 1.264], [1329.666, 925.825, 1.459], [1329.666, 925.825, 1.459], [1329.666, 925.825, 1.459], [1329.666, 925.825, 1.459], [1329.666, 925.825, 1.459], [1329.666, 925.825, 1.459], [1332.648, 929.409, 1.634], [1332.648, 929.409, 1.634], [1332.648, 929.409, 1.634], [1332.648, 929.409, 1.634], [1332.648, 929.409, 1.634], [1336.29, 933.785, 1.849], [1336.29, 933.785, 1.849], [1336.29, 933.785, 1.849], [1336.29, 933.785, 1.849], [1336.29, 933.785, 1.849], [1336.29, 933.785, 1.849], [1336.29, 933.785, 1.849], [1339.72, 937.612, 1.944], [1339.72, 937.612, 1.944], [1339.72, 937.612, 1.944], [1339.72, 937.612, 1.944], [1339.72, 937.612, 1.944], [1339.72, 937.612, 1.944], [1343.249, 941.349, 2.039], [1343.249, 941.349, 2.039], [1343.249, 941.349, 2.039], [1343.249, 941.349, 2.039], [1343.249, 941.349, 2.039], [1343.249, 941.349, 2.039], [1346.489, 945.051, 2.196], [1346.489, 945.051, 2.196], [1346.489, 945.051, 2.196], [1346.489, 945.051, 2.196], [1346.489, 945.051, 2.196], [1346.489, 945.051, 2.196], [1349.728, 948.753, 2.354], [1349.728, 948.753, 2.354], [1349.728, 948.753, 2.354], [1349.728, 948.753, 2.354], [1349.728, 948.753, 2.354], [1349.728, 948.753, 2.354], [1352.964, 952.451, 2.511], [1352.964, 952.451, 2.511], [1352.964, 952.451, 2.511], [1352.964, 952.451, 2.511], [1352.964, 952.451, 2.511], [1352.964, 952.451, 2.511], [1356.208, 956.157, 2.669], [1356.208, 956.157, 2.669], [1356.208, 956.157, 2.669], [1356.208, 956.157, 2.669], [1356.208, 956.157, 2.669], [1356.208, 956.157, 2.669], [1359.33, 959.938, 2.846], [1359.33, 959.938, 2.846], [1359.33, 959.938, 2.846], [1359.33, 959.938, 2.846], [1359.33, 959.938, 2.846], [1359.33, 959.938, 2.846], [1362.448, 963.716, 3.024], [1362.448, 963.716, 3.024], [1362.448, 963.716, 3.024], [1362.448, 963.716, 3.024], [1362.448, 963.716, 3.024], [1362.448, 963.716, 3.024], [1365.567, 967.493, 3.201], [1365.567, 967.493, 3.201], [1365.567, 967.493, 3.201], [1365.567, 967.493, 3.201], [1365.567, 967.493, 3.201], [1365.567, 967.493, 3.201], [1368.689, 971.275, 3.379], [1368.689, 971.275, 3.379], [1368.689, 971.275, 3.379], [1368.689, 971.275, 3.379], [1368.689, 971.275, 3.379], [1368.689, 971.275, 3.379], [1371.805, 975.048, 3.556], [1371.805, 975.048, 3.556], [1371.805, 975.048, 3.556], [1371.805, 975.048, 3.556], [1371.805, 975.048, 3.556], [1374.802, 978.921, 3.734], [1374.802, 978.921, 3.734], [1374.802, 978.921, 3.734], [1374.802, 978.921, 3.734], [1374.802, 978.921, 3.734], [1374.802, 978.921, 3.734], [1377.8, 982.794, 3.911], [1377.8, 982.794, 3.911], [1377.8, 982.794, 3.911], [1377.8, 982.794, 3.911], [1377.8, 982.794, 3.911], [1377.8, 982.794, 3.911]], 'datetimes': ['2021-06-08T07:10:29+00', '2021-06-08T07:10:30+00', '2021-06-08T07:10:31+00', '2021-06-08T07:10:32+00', '2021-06-08T07:10:33+00', '2021-06-08T07:10:34+00', '2021-06-08T07:10:35+00', '2021-06-08T07:10:36+00', '2021-06-08T07:10:37+00', '2021-06-08T07:10:38+00', '2021-06-08T07:10:39+00', '2021-06-08T07:10:40+00', '2021-06-08T07:10:41+00', '2021-06-08T07:10:42+00', '2021-06-08T07:10:43+00', '2021-06-08T07:10:44+00', '2021-06-08T07:10:45+00', '2021-06-08T07:10:46+00', '2021-06-08T07:10:47+00', '2021-06-08T07:10:48+00', '2021-06-08T07:10:49+00', '2021-06-08T07:10:50+00', '2021-06-08T07:10:51+00', '2021-06-08T07:10:52+00', '2021-06-08T07:10:53+00', '2021-06-08T07:10:54+00', '2021-06-08T07:10:55+00', '2021-06-08T07:10:56+00', '2021-06-08T07:10:57+00', '2021-06-08T07:10:58+00', '2021-06-08T07:10:59+00', '2021-06-08T07:11:00+00', '2021-06-08T07:11:01+00', '2021-06-08T07:11:02+00', '2021-06-08T07:11:03+00', '2021-06-08T07:11:04+00', '2021-06-08T07:11:05+00', '2021-06-08T07:11:06+00', '2021-06-08T07:11:07+00', '2021-06-08T07:11:08+00', '2021-06-08T07:11:09+00', '2021-06-08T07:11:10+00', '2021-06-08T07:11:11+00', '2021-06-08T07:11:12+00', '2021-06-08T07:11:13+00', '2021-06-08T07:11:14+00', '2021-06-08T07:11:15+00', '2021-06-08T07:11:16+00', '2021-06-08T07:11:17+00', '2021-06-08T07:11:18+00', '2021-06-08T07:11:19+00', '2021-06-08T07:11:20+00', '2021-06-08T07:11:21+00', '2021-06-08T07:11:22+00', '2021-06-08T07:11:23+00', '2021-06-08T07:11:24+00', '2021-06-08T07:11:25+00', '2021-06-08T07:11:26+00', '2021-06-08T07:11:27+00', '2021-06-08T07:11:28+00', '2021-06-08T07:11:29+00', '2021-06-08T07:11:30+00', '2021-06-08T07:11:31+00', '2021-06-08T07:11:32+00', '2021-06-08T07:11:33+00', '2021-06-08T07:11:34+00', '2021-06-08T07:11:35+00', '2021-06-08T07:11:36+00', '2021-06-08T07:11:37+00', '2021-06-08T07:11:38+00', '2021-06-08T07:11:39+00', '2021-06-08T07:11:40+00', '2021-06-08T07:11:41+00', '2021-06-08T07:11:42+00', '2021-06-08T07:11:43+00', '2021-06-08T07:11:44+00', '2021-06-08T07:11:45+00', '2021-06-08T07:11:46+00', '2021-06-08T07:11:47+00', '2021-06-08T07:11:48+00', '2021-06-08T07:11:49+00', '2021-06-08T07:11:50+00', '2021-06-08T07:11:51+00', '2021-06-08T07:11:52+00', '2021-06-08T07:11:53+00', '2021-06-08T07:11:54+00', '2021-06-08T07:11:55+00', '2021-06-08T07:11:56+00', '2021-06-08T07:11:57+00', '2021-06-08T07:11:58+00', '2021-06-08T07:11:59+00', '2021-06-08T07:12:00+00', '2021-06-08T07:12:01+00', '2021-06-08T07:12:02+00', '2021-06-08T07:12:03+00', '2021-06-08T07:12:04+00', '2021-06-08T07:12:05+00', '2021-06-08T07:12:06+00', '2021-06-08T07:12:07+00', '2021-06-08T07:12:08+00', '2021-06-08T07:12:09+00', '2021-06-08T07:12:10+00', '2021-06-08T07:12:11+00', '2021-06-08T07:12:12+00', '2021-06-08T07:12:13+00', '2021-06-08T07:12:14+00', '2021-06-08T07:12:15+00', '2021-06-08T07:12:16+00', '2021-06-08T07:12:17+00', '2021-06-08T07:12:18+00', '2021-06-08T07:12:19+00', '2021-06-08T07:12:20+00', '2021-06-08T07:12:21+00', '2021-06-08T07:12:22+00', '2021-06-08T07:12:23+00', '2021-06-08T07:12:24+00', '2021-06-08T07:12:25+00', '2021-06-08T07:12:26+00', '2021-06-08T07:12:27+00', '2021-06-08T07:12:28+00', '2021-06-08T07:12:29+00', '2021-06-08T07:12:30+00', '2021-06-08T07:12:31+00', '2021-06-08T07:12:32+00', '2021-06-08T07:12:33+00', '2021-06-08T07:12:34+00', '2021-06-08T07:12:35+00', '2021-06-08T07:12:36+00', '2021-06-08T07:12:37+00', '2021-06-08T07:12:38+00', '2021-06-08T07:12:39+00', '2021-06-08T07:12:40+00', '2021-06-08T07:12:41+00', '2021-06-08T07:12:42+00', '2021-06-08T07:12:43+00', '2021-06-08T07:12:44+00', '2021-06-08T07:12:45+00', '2021-06-08T07:12:46+00', '2021-06-08T07:12:47+00', '2021-06-08T07:12:48+00', '2021-06-08T07:12:49+00', '2021-06-08T07:12:50+00', '2021-06-08T07:12:51+00', '2021-06-08T07:12:52+00', '2021-06-08T07:12:53+00', '2021-06-08T07:12:54+00', '2021-06-08T07:12:55+00', '2021-06-08T07:12:56+00', '2021-06-08T07:12:57+00', '2021-06-08T07:12:58+00', '2021-06-08T07:12:59+00', '2021-06-08T07:13:00+00', '2021-06-08T07:13:01+00', '2021-06-08T07:13:02+00', '2021-06-08T07:13:03+00', '2021-06-08T07:13:04+00', '2021-06-08T07:13:05+00', '2021-06-08T07:13:06+00', '2021-06-08T07:13:07+00', '2021-06-08T07:13:08+00', '2021-06-08T07:13:09+00', '2021-06-08T07:13:10+00', '2021-06-08T07:13:11+00', '2021-06-08T07:13:12+00', '2021-06-08T07:13:13+00', '2021-06-08T07:13:14+00', '2021-06-08T07:13:15+00', '2021-06-08T07:13:16+00', '2021-06-08T07:13:17+00', '2021-06-08T07:13:18+00', '2021-06-08T07:13:19+00', '2021-06-08T07:13:20+00', '2021-06-08T07:13:21+00', '2021-06-08T07:13:22+00', '2021-06-08T07:13:23+00', '2021-06-08T07:13:24+00', '2021-06-08T07:13:25+00', '2021-06-08T07:13:26+00', '2021-06-08T07:13:27+00', '2021-06-08T07:13:28+00', '2021-06-08T07:13:29+00', '2021-06-08T07:13:30+00', '2021-06-08T07:13:31+00', '2021-06-08T07:13:32+00', '2021-06-08T07:13:33+00', '2021-06-08T07:13:34+00', '2021-06-08T07:13:35+00', '2021-06-08T07:13:36+00', '2021-06-08T07:13:37+00', '2021-06-08T07:13:38+00', '2021-06-08T07:13:39+00', '2021-06-08T07:13:40+00', '2021-06-08T07:13:41+00', '2021-06-08T07:13:42+00', '2021-06-08T07:13:43+00', '2021-06-08T07:13:44+00', '2021-06-08T07:13:45+00', '2021-06-08T07:13:46+00', '2021-06-08T07:13:47+00', '2021-06-08T07:13:48+00', '2021-06-08T07:13:49+00', '2021-06-08T07:13:50+00', '2021-06-08T07:13:51+00', '2021-06-08T07:13:52+00', '2021-06-08T07:13:53+00', '2021-06-08T07:13:54+00', '2021-06-08T07:13:55+00', '2021-06-08T07:13:56+00', '2021-06-08T07:13:57+00'], 'interpolations': ['Discrete']}\n" ] } ], @@ -907,8 +760,8 @@ }, { "cell_type": "code", - "execution_count": 11, - "id": "b00d7f8c", + "execution_count": 14, + "id": "48cf27c4", "metadata": {}, "outputs": [ { @@ -1122,11 +975,7 @@ " 206.0,\n", " 207.0,\n", " 208.0,\n", - " 209.0,\n", - " 210.0,\n", - " 211.0,\n", - " 212.0],\n", - " [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0],\n", + " 209.0],\n", " [1.0,\n", " 2.0,\n", " 3.0,\n", @@ -1152,7 +1001,64 @@ " 23.0,\n", " 24.0,\n", " 25.0,\n", - " 26.0],\n", + " 26.0,\n", + " 27.0,\n", + " 28.0,\n", + " 29.0,\n", + " 30.0,\n", + " 31.0,\n", + " 32.0,\n", + " 33.0,\n", + " 34.0,\n", + " 35.0,\n", + " 36.0,\n", + " 37.0,\n", + " 38.0,\n", + " 39.0,\n", + " 40.0,\n", + " 41.0,\n", + " 42.0,\n", + " 43.0,\n", + " 44.0,\n", + " 45.0,\n", + " 46.0,\n", + " 47.0,\n", + " 48.0,\n", + " 49.0,\n", + " 50.0,\n", + " 51.0,\n", + " 52.0,\n", + " 53.0,\n", + " 54.0,\n", + " 55.0,\n", + " 56.0,\n", + " 57.0,\n", + " 58.0,\n", + " 59.0,\n", + " 60.0,\n", + " 61.0,\n", + " 62.0,\n", + " 63.0,\n", + " 64.0,\n", + " 65.0,\n", + " 66.0,\n", + " 67.0,\n", + " 68.0,\n", + " 69.0,\n", + " 70.0,\n", + " 71.0,\n", + " 72.0,\n", + " 73.0,\n", + " 74.0,\n", + " 75.0,\n", + " 76.0,\n", + " 77.0,\n", + " 78.0,\n", + " 79.0,\n", + " 80.0,\n", + " 81.0,\n", + " 82.0,\n", + " 83.0],\n", " [1.0,\n", " 2.0,\n", " 3.0,\n", @@ -1260,34 +1166,7 @@ " 105.0,\n", " 106.0,\n", " 107.0,\n", - " 108.0,\n", - " 109.0,\n", - " 110.0,\n", - " 111.0,\n", - " 112.0,\n", - " 113.0,\n", - " 114.0,\n", - " 115.0,\n", - " 116.0,\n", - " 117.0,\n", - " 118.0,\n", - " 119.0,\n", - " 120.0,\n", - " 121.0,\n", - " 122.0,\n", - " 123.0,\n", - " 124.0,\n", - " 125.0,\n", - " 126.0,\n", - " 127.0,\n", - " 128.0,\n", - " 129.0,\n", - " 130.0,\n", - " 131.0,\n", - " 132.0,\n", - " 133.0,\n", - " 134.0,\n", - " 135.0],\n", + " 108.0],\n", " [1.0,\n", " 2.0,\n", " 3.0,\n", @@ -1511,7 +1390,15 @@ " 221.0,\n", " 222.0,\n", " 223.0,\n", - " 224.0],\n", + " 224.0,\n", + " 225.0,\n", + " 226.0,\n", + " 227.0,\n", + " 228.0,\n", + " 229.0,\n", + " 230.0,\n", + " 231.0,\n", + " 232.0],\n", " [1.0,\n", " 2.0,\n", " 3.0,\n", @@ -1691,51 +1578,7 @@ " 177.0,\n", " 178.0,\n", " 179.0,\n", - " 180.0,\n", - " 181.0,\n", - " 182.0,\n", - " 183.0,\n", - " 184.0,\n", - " 185.0,\n", - " 186.0,\n", - " 187.0,\n", - " 188.0,\n", - " 189.0,\n", - " 190.0,\n", - " 191.0,\n", - " 192.0,\n", - " 193.0,\n", - " 194.0,\n", - " 195.0,\n", - " 196.0,\n", - " 197.0,\n", - " 198.0,\n", - " 199.0,\n", - " 200.0,\n", - " 201.0,\n", - " 202.0,\n", - " 203.0,\n", - " 204.0,\n", - " 205.0,\n", - " 206.0,\n", - " 207.0,\n", - " 208.0,\n", - " 209.0,\n", - " 210.0,\n", - " 211.0,\n", - " 212.0,\n", - " 213.0,\n", - " 214.0,\n", - " 215.0,\n", - " 216.0,\n", - " 217.0,\n", - " 218.0,\n", - " 219.0,\n", - " 220.0,\n", - " 221.0,\n", - " 222.0,\n", - " 223.0,\n", - " 224.0],\n", + " 180.0],\n", " [1.0,\n", " 2.0,\n", " 3.0,\n", @@ -1918,32 +1761,81 @@ " 180.0,\n", " 181.0,\n", " 182.0,\n", - " 183.0],\n", - " [1.0,\n", - " 2.0,\n", - " 3.0,\n", - " 4.0,\n", - " 5.0,\n", - " 6.0,\n", - " 7.0,\n", - " 8.0,\n", - " 9.0,\n", - " 10.0,\n", - " 11.0,\n", - " 12.0,\n", - " 13.0,\n", - " 14.0,\n", - " 15.0,\n", - " 16.0,\n", - " 17.0,\n", - " 18.0,\n", - " 19.0,\n", - " 20.0,\n", - " 21.0,\n", - " 22.0,\n", - " 23.0,\n", - " 24.0,\n", - " 25.0,\n", + " 183.0,\n", + " 184.0,\n", + " 185.0,\n", + " 186.0,\n", + " 187.0,\n", + " 188.0,\n", + " 189.0,\n", + " 190.0,\n", + " 191.0,\n", + " 192.0,\n", + " 193.0,\n", + " 194.0,\n", + " 195.0,\n", + " 196.0,\n", + " 197.0,\n", + " 198.0,\n", + " 199.0,\n", + " 200.0,\n", + " 201.0,\n", + " 202.0,\n", + " 203.0,\n", + " 204.0,\n", + " 205.0,\n", + " 206.0,\n", + " 207.0,\n", + " 208.0,\n", + " 209.0,\n", + " 210.0,\n", + " 211.0,\n", + " 212.0,\n", + " 213.0,\n", + " 214.0,\n", + " 215.0,\n", + " 216.0,\n", + " 217.0,\n", + " 218.0,\n", + " 219.0,\n", + " 220.0,\n", + " 221.0,\n", + " 222.0,\n", + " 223.0,\n", + " 224.0,\n", + " 225.0,\n", + " 226.0,\n", + " 227.0,\n", + " 228.0,\n", + " 229.0,\n", + " 230.0,\n", + " 231.0,\n", + " 232.0],\n", + " [1.0,\n", + " 2.0,\n", + " 3.0,\n", + " 4.0,\n", + " 5.0,\n", + " 6.0,\n", + " 7.0,\n", + " 8.0,\n", + " 9.0,\n", + " 10.0,\n", + " 11.0,\n", + " 12.0,\n", + " 13.0,\n", + " 14.0,\n", + " 15.0,\n", + " 16.0,\n", + " 17.0,\n", + " 18.0,\n", + " 19.0,\n", + " 20.0,\n", + " 21.0,\n", + " 22.0,\n", + " 23.0,\n", + " 24.0,\n", + " 25.0,\n", " 26.0,\n", " 27.0,\n", " 28.0,\n", @@ -2142,8 +2034,17 @@ " 221.0,\n", " 222.0,\n", " 223.0,\n", - " 224.0],\n", - " [2.0,\n", + " 224.0,\n", + " 225.0,\n", + " 226.0,\n", + " 227.0,\n", + " 228.0,\n", + " 229.0,\n", + " 230.0,\n", + " 231.0,\n", + " 232.0],\n", + " [1.0,\n", + " 2.0,\n", " 3.0,\n", " 4.0,\n", " 5.0,\n", @@ -2218,8 +2119,148 @@ " 74.0,\n", " 75.0,\n", " 76.0,\n", - " 77.0],\n", - " [2.0,\n", + " 77.0,\n", + " 78.0,\n", + " 79.0,\n", + " 80.0,\n", + " 81.0,\n", + " 82.0,\n", + " 83.0,\n", + " 84.0,\n", + " 85.0,\n", + " 86.0,\n", + " 87.0,\n", + " 88.0,\n", + " 89.0,\n", + " 90.0,\n", + " 91.0,\n", + " 92.0,\n", + " 93.0,\n", + " 94.0,\n", + " 95.0,\n", + " 96.0,\n", + " 97.0,\n", + " 98.0,\n", + " 99.0,\n", + " 100.0,\n", + " 101.0,\n", + " 102.0,\n", + " 103.0,\n", + " 104.0,\n", + " 105.0,\n", + " 106.0,\n", + " 107.0,\n", + " 108.0,\n", + " 109.0,\n", + " 110.0,\n", + " 111.0,\n", + " 112.0,\n", + " 113.0,\n", + " 114.0,\n", + " 115.0,\n", + " 116.0,\n", + " 117.0,\n", + " 118.0,\n", + " 119.0,\n", + " 120.0,\n", + " 121.0,\n", + " 122.0,\n", + " 123.0,\n", + " 124.0,\n", + " 125.0,\n", + " 126.0,\n", + " 127.0,\n", + " 128.0,\n", + " 129.0,\n", + " 130.0,\n", + " 131.0,\n", + " 132.0,\n", + " 133.0,\n", + " 134.0,\n", + " 135.0,\n", + " 136.0,\n", + " 137.0,\n", + " 138.0,\n", + " 139.0,\n", + " 140.0,\n", + " 141.0,\n", + " 142.0,\n", + " 143.0,\n", + " 144.0,\n", + " 145.0,\n", + " 146.0,\n", + " 147.0,\n", + " 148.0,\n", + " 149.0,\n", + " 150.0,\n", + " 151.0,\n", + " 152.0,\n", + " 153.0,\n", + " 154.0,\n", + " 155.0,\n", + " 156.0,\n", + " 157.0,\n", + " 158.0,\n", + " 159.0,\n", + " 160.0,\n", + " 161.0,\n", + " 162.0,\n", + " 163.0,\n", + " 164.0,\n", + " 165.0,\n", + " 166.0,\n", + " 167.0,\n", + " 168.0,\n", + " 169.0,\n", + " 170.0,\n", + " 171.0,\n", + " 172.0,\n", + " 173.0,\n", + " 174.0,\n", + " 175.0,\n", + " 176.0,\n", + " 177.0,\n", + " 178.0,\n", + " 179.0,\n", + " 180.0,\n", + " 181.0,\n", + " 182.0,\n", + " 183.0,\n", + " 184.0,\n", + " 185.0,\n", + " 186.0,\n", + " 187.0,\n", + " 188.0,\n", + " 189.0,\n", + " 190.0,\n", + " 191.0,\n", + " 192.0,\n", + " 193.0,\n", + " 194.0,\n", + " 195.0,\n", + " 196.0,\n", + " 197.0],\n", + " [1.0,\n", + " 2.0,\n", + " 3.0,\n", + " 4.0,\n", + " 5.0,\n", + " 6.0,\n", + " 7.0,\n", + " 8.0,\n", + " 9.0,\n", + " 10.0,\n", + " 11.0,\n", + " 12.0,\n", + " 13.0,\n", + " 14.0,\n", + " 15.0,\n", + " 16.0,\n", + " 17.0,\n", + " 18.0,\n", + " 19.0],\n", + " [1.0,\n", + " 2.0,\n", " 3.0,\n", " 4.0,\n", " 5.0,\n", @@ -2372,8 +2413,16 @@ " 152.0,\n", " 153.0,\n", " 154.0,\n", - " 155.0],\n", - " [8.0,\n", + " 155.0,\n", + " 156.0],\n", + " [1.0,\n", + " 2.0,\n", + " 3.0,\n", + " 4.0,\n", + " 5.0,\n", + " 6.0,\n", + " 7.0,\n", + " 8.0,\n", " 9.0,\n", " 10.0,\n", " 11.0,\n", @@ -2424,67 +2473,15 @@ " 56.0,\n", " 57.0,\n", " 58.0,\n", - " 59.0,\n", - " 60.0,\n", - " 61.0,\n", - " 62.0,\n", - " 63.0,\n", - " 64.0,\n", - " 65.0,\n", - " 66.0,\n", - " 67.0,\n", - " 68.0,\n", - " 69.0,\n", - " 70.0,\n", - " 71.0,\n", - " 72.0,\n", - " 73.0,\n", - " 74.0,\n", - " 75.0,\n", - " 76.0,\n", - " 77.0,\n", - " 78.0,\n", - " 79.0,\n", - " 80.0,\n", - " 81.0,\n", - " 82.0,\n", - " 83.0,\n", - " 84.0,\n", - " 85.0,\n", - " 86.0,\n", - " 87.0,\n", - " 88.0,\n", - " 89.0,\n", - " 90.0,\n", - " 91.0,\n", - " 92.0,\n", - " 93.0,\n", - " 94.0,\n", - " 95.0,\n", - " 96.0,\n", - " 97.0,\n", - " 98.0,\n", - " 99.0,\n", - " 100.0,\n", - " 101.0,\n", - " 102.0,\n", - " 103.0,\n", - " 104.0,\n", - " 105.0,\n", - " 106.0,\n", - " 107.0,\n", - " 108.0,\n", - " 109.0,\n", - " 110.0,\n", - " 111.0,\n", - " 112.0,\n", - " 113.0,\n", - " 114.0,\n", - " 115.0,\n", - " 116.0,\n", - " 117.0,\n", - " 118.0],\n", - " [15.0,\n", + " 59.0],\n", + " [8.0,\n", + " 9.0,\n", + " 10.0,\n", + " 11.0,\n", + " 12.0,\n", + " 13.0,\n", + " 14.0,\n", + " 15.0,\n", " 16.0,\n", " 17.0,\n", " 18.0,\n", @@ -2564,6 +2561,59 @@ " 92.0,\n", " 93.0,\n", " 94.0,\n", + " 95.0],\n", + " [43.0,\n", + " 44.0,\n", + " 45.0,\n", + " 46.0,\n", + " 47.0,\n", + " 48.0,\n", + " 49.0,\n", + " 50.0,\n", + " 51.0,\n", + " 52.0,\n", + " 53.0,\n", + " 54.0,\n", + " 55.0,\n", + " 56.0,\n", + " 57.0,\n", + " 58.0,\n", + " 59.0,\n", + " 60.0,\n", + " 61.0,\n", + " 62.0,\n", + " 63.0,\n", + " 64.0,\n", + " 65.0,\n", + " 66.0,\n", + " 67.0,\n", + " 68.0,\n", + " 69.0,\n", + " 70.0,\n", + " 71.0,\n", + " 72.0,\n", + " 73.0,\n", + " 74.0,\n", + " 75.0,\n", + " 76.0,\n", + " 77.0,\n", + " 78.0,\n", + " 79.0,\n", + " 80.0,\n", + " 81.0,\n", + " 82.0,\n", + " 83.0,\n", + " 84.0,\n", + " 85.0,\n", + " 86.0,\n", + " 87.0,\n", + " 88.0,\n", + " 89.0,\n", + " 90.0,\n", + " 91.0,\n", + " 92.0,\n", + " 93.0,\n", + " 94.0,\n", " 95.0,\n", " 96.0,\n", " 97.0,\n", @@ -2693,126 +2743,10 @@ " 221.0,\n", " 222.0,\n", " 223.0,\n", - " 224.0],\n", - " [21.0,\n", - " 22.0,\n", - " 23.0,\n", - " 24.0,\n", - " 25.0,\n", - " 26.0,\n", - " 27.0,\n", - " 28.0,\n", - " 29.0,\n", - " 30.0,\n", - " 31.0,\n", - " 32.0,\n", - " 33.0,\n", - " 34.0,\n", - " 35.0,\n", - " 36.0,\n", - " 37.0,\n", - " 38.0,\n", - " 39.0,\n", - " 40.0,\n", - " 41.0,\n", - " 42.0,\n", - " 43.0,\n", - " 44.0,\n", - " 45.0,\n", - " 46.0,\n", - " 47.0,\n", - " 48.0,\n", - " 49.0,\n", - " 50.0,\n", - " 51.0,\n", - " 52.0,\n", - " 53.0,\n", - " 54.0,\n", - " 55.0,\n", - " 56.0,\n", - " 57.0,\n", - " 58.0,\n", - " 59.0,\n", - " 60.0,\n", - " 61.0,\n", - " 62.0,\n", - " 63.0,\n", - " 64.0,\n", - " 65.0,\n", - " 66.0,\n", - " 67.0,\n", - " 68.0,\n", - " 69.0,\n", - " 70.0,\n", - " 71.0,\n", - " 72.0,\n", - " 73.0,\n", - " 74.0,\n", - " 75.0,\n", - " 76.0,\n", - " 77.0,\n", - " 78.0,\n", - " 79.0,\n", - " 80.0,\n", - " 81.0,\n", - " 82.0,\n", - " 83.0,\n", - " 84.0,\n", - " 85.0,\n", - " 86.0,\n", - " 87.0,\n", - " 88.0,\n", - " 89.0,\n", - " 90.0,\n", - " 91.0,\n", - " 92.0,\n", - " 93.0,\n", - " 94.0,\n", - " 95.0,\n", - " 96.0,\n", - " 97.0,\n", - " 98.0,\n", - " 99.0,\n", - " 100.0,\n", - " 101.0,\n", - " 102.0,\n", - " 103.0,\n", - " 104.0,\n", - " 105.0,\n", - " 106.0,\n", - " 107.0,\n", - " 108.0,\n", - " 109.0,\n", - " 110.0,\n", - " 111.0,\n", - " 112.0,\n", - " 113.0,\n", - " 114.0,\n", - " 115.0,\n", - " 116.0,\n", - " 117.0,\n", - " 118.0,\n", - " 119.0,\n", - " 120.0,\n", - " 121.0,\n", - " 122.0,\n", - " 123.0,\n", - " 124.0,\n", - " 125.0,\n", - " 126.0,\n", - " 127.0,\n", - " 128.0,\n", - " 129.0,\n", - " 130.0,\n", - " 131.0,\n", - " 132.0,\n", - " 133.0,\n", - " 134.0,\n", - " 135.0,\n", - " 136.0,\n", - " 137.0,\n", - " 138.0,\n", - " 139.0,\n", + " 224.0,\n", + " 225.0,\n", + " 226.0],\n", + " [139.0,\n", " 140.0,\n", " 141.0,\n", " 142.0,\n", @@ -2897,11 +2831,128 @@ " 221.0,\n", " 222.0,\n", " 223.0,\n", - " 224.0],\n", - " [78.0, 79.0, 80.0, 81.0, 82.0, 83.0, 84.0]]" + " 224.0,\n", + " 225.0,\n", + " 226.0,\n", + " 227.0,\n", + " 228.0,\n", + " 229.0,\n", + " 230.0,\n", + " 231.0,\n", + " 232.0],\n", + " [163.0,\n", + " 164.0,\n", + " 165.0,\n", + " 166.0,\n", + " 167.0,\n", + " 168.0,\n", + " 169.0,\n", + " 170.0,\n", + " 171.0,\n", + " 172.0,\n", + " 173.0,\n", + " 174.0,\n", + " 175.0,\n", + " 176.0,\n", + " 177.0,\n", + " 178.0,\n", + " 179.0,\n", + " 180.0,\n", + " 181.0,\n", + " 182.0,\n", + " 183.0,\n", + " 184.0,\n", + " 185.0,\n", + " 186.0,\n", + " 187.0,\n", + " 188.0,\n", + " 189.0,\n", + " 190.0,\n", + " 191.0,\n", + " 192.0,\n", + " 193.0,\n", + " 194.0,\n", + " 195.0,\n", + " 196.0,\n", + " 197.0,\n", + " 198.0,\n", + " 199.0,\n", + " 200.0,\n", + " 201.0,\n", + " 202.0,\n", + " 203.0,\n", + " 204.0,\n", + " 205.0,\n", + " 206.0,\n", + " 207.0,\n", + " 208.0,\n", + " 209.0,\n", + " 210.0,\n", + " 211.0,\n", + " 212.0,\n", + " 213.0,\n", + " 214.0,\n", + " 215.0,\n", + " 216.0,\n", + " 217.0,\n", + " 218.0,\n", + " 219.0,\n", + " 220.0,\n", + " 221.0,\n", + " 222.0,\n", + " 223.0,\n", + " 224.0,\n", + " 225.0,\n", + " 226.0,\n", + " 227.0,\n", + " 228.0,\n", + " 229.0,\n", + " 230.0,\n", + " 231.0,\n", + " 232.0],\n", + " [193.0,\n", + " 194.0,\n", + " 195.0,\n", + " 196.0,\n", + " 197.0,\n", + " 198.0,\n", + " 199.0,\n", + " 200.0,\n", + " 201.0,\n", + " 202.0,\n", + " 203.0,\n", + " 204.0,\n", + " 205.0,\n", + " 206.0,\n", + " 207.0,\n", + " 208.0,\n", + " 209.0,\n", + " 210.0,\n", + " 211.0,\n", + " 212.0,\n", + " 213.0,\n", + " 214.0,\n", + " 215.0,\n", + " 216.0,\n", + " 217.0,\n", + " 218.0,\n", + " 219.0,\n", + " 220.0,\n", + " 221.0,\n", + " 222.0,\n", + " 223.0,\n", + " 224.0,\n", + " 225.0,\n", + " 226.0,\n", + " 227.0,\n", + " 228.0,\n", + " 229.0,\n", + " 230.0,\n", + " 231.0,\n", + " 232.0]]" ] }, - "execution_count": 11, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -2913,8 +2964,8 @@ }, { "cell_type": "code", - "execution_count": 12, - "id": "56b17993", + "execution_count": 15, + "id": "41c8bf00", "metadata": { "scrolled": true }, @@ -2922,1705 +2973,10 @@ { "data": { "text/plain": [ - "[('scene-0061',\n", - " [410.94336, 1179.9099, 0.0],\n", - " [0.5731318, -0.001008744, 0.013420039, -0.8193527],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 3,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", - " ('scene-0061',\n", - " [408.95026, 1174.4933, 0.0],\n", - " [0.57560045, 0.0024681848, 0.01412191, -0.81760544],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 11,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", - " ('scene-0061',\n", - " [406.95477, 1168.8765, 0.0],\n", - " [0.5812651, 0.00049561856, 0.0121137425, -0.8136239],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 19,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", - " ('scene-0061',\n", - " [405.24216, 1163.8628, 0.0],\n", - " [0.5839936, 0.00012216052, 0.010923019, -0.8116848],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 27,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", - " ('scene-0061',\n", - " [403.6676, 1159.2003, 0.0],\n", - " [0.5881336, -0.000954694, 0.012099387, -0.8086727],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 35,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", - " ('scene-0061',\n", - " [402.0736, 1154.3171, 0.0],\n", - " [0.5913524, -0.0019899285, 0.015318021, -0.8062653],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 43,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", - " ('scene-0061',\n", - " [411.41998, 1181.1971, 0.0],\n", - " [0.57200634, -0.0021434845, 0.011564095, -0.82016486],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 1,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg'),\n", - " ('scene-0061',\n", - " [400.70996, 1149.9855, 0.0],\n", - " [0.594958, -0.0030329588, 0.012231894, -0.80365795],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 51,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", - " ('scene-0061',\n", - " [409.40012, 1175.7356, 0.0],\n", - " [0.57492363, 0.00030495474, 0.012675724, -0.8181088],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 9,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", - " ('scene-0061',\n", - " [399.44342, 1145.8374, 0.0],\n", - " [0.6001535, -0.0010044922, 0.010316237, -0.7998177],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 59,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", - " ('scene-0061',\n", - " [407.49667, 1170.4424, 0.0],\n", - " [0.57916784, -0.00096999895, 0.013829607, -0.8150905],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 17,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", - " ('scene-0061',\n", - " [410.1521, 1177.7936, 0.0],\n", - " [0.57330894, -0.0028238522, 0.013801293, -0.81921816],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 6,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", - " ('scene-0061',\n", - " [398.14114, 1141.2748, 0.0],\n", - " [0.6119813, 0.00077418005, 0.013449771, -0.7907575],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 67,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", - " ('scene-0061',\n", - " [405.63644, 1165.0194, 0.0],\n", - " [0.58347344, -0.0004885416, 0.01144431, -0.8120514],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 25,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", - " ('scene-0061',\n", - " [410.46365, 1178.6342, 0.0],\n", - " [0.57302195, -0.0024794692, 0.013370231, -0.8194272],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 5,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", - " ('scene-0061',\n", - " [410.62503, 1179.0588, 0.0],\n", - " [0.57304716, -0.0022480509, 0.013823896, -0.8194027],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 4,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", - " ('scene-0061',\n", - " [408.21057, 1172.4467, 0.0],\n", - " [0.57716495, -0.0026354806, 0.0123014115, -0.8165307],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 14,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", - " ('scene-0061',\n", - " [397.12833, 1136.9679, 0.0],\n", - " [0.6359422, -0.00641152, 0.018952105, -0.7714773],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 75,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", - " ('scene-0061',\n", - " [404.01654, 1160.2651, 0.0],\n", - " [0.5869541, -0.0004190632, 0.01255821, -0.8095227],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 33,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", - " ('scene-0061',\n", - " [408.65414, 1173.6707, 0.0],\n", - " [0.57640094, 0.0018814936, 0.01451824, -0.81703585],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 12,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", - " ('scene-0061',\n", - " [411.2579, 1180.7659, 0.0],\n", - " [0.57210505, -0.0015150002, 0.011903272, -0.82009256],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 2,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", - " ('scene-0061',\n", - " [408.3615, 1172.8611, 0.0],\n", - " [0.5772205, -0.001328158, 0.013279773, -0.81647927],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 13,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", - " ('scene-0061',\n", - " [406.28827, 1166.9268, 0.0],\n", - " [0.58248687, 0.00033150977, 0.013304342, -0.81273115],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 22,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", - " ('scene-0061',\n", - " [396.49384, 1133.0753, 0.0],\n", - " [0.6668291, -0.012630183, 0.015393981, -0.7449446],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 83,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", - " ('scene-0061',\n", - " [409.85068, 1176.9702, 0.0],\n", - " [0.57423776, -0.0018667926, 0.014165886, -0.8185639],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 7,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", - " ('scene-0061',\n", - " [402.51776, 1155.6915, 0.0],\n", - " [0.590622, -0.001896476, 0.014574609, -0.8068145],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 41,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", - " ('scene-0061',\n", - " [409.09915, 1174.9052, 0.0],\n", - " [0.5755514, 0.0018199513, 0.013387071, -0.817654],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 10,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", - " ('scene-0061',\n", - " [406.8201, 1168.4824, 0.0],\n", - " [0.5816168, 0.0006837672, 0.012321349, -0.8133693],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 20,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", - " ('scene-0061',\n", - " [406.55246, 1167.7021, 0.0],\n", - " [0.5820588, 0.000756244, 0.013110329, -0.8130407],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 21,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", - " ('scene-0061',\n", - " [396.28513, 1129.7192, 0.0],\n", - " [0.7085024, -0.011660316, 0.014460257, -0.7054639],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 91,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", - " ('scene-0061',\n", - " [404.615, 1162.0481, 0.0],\n", - " [0.5849365, 0.0007514014, 0.011787229, -0.8109931],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 30,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", - " ('scene-0061',\n", - " [407.92038, 1171.6355, 0.0],\n", - " [0.5777077, -0.002921363, 0.011735637, -0.8161541],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 15,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", - " ('scene-0061',\n", - " [401.01215, 1150.9529, 0.0],\n", - " [0.59458214, -0.001739296, 0.0129301995, -0.80392903],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 49,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", - " ('scene-0061',\n", - " [407.22305, 1169.657, 0.0],\n", - " [0.5802113, 0.000100642836, 0.012573178, -0.81436896],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 18,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", - " ('scene-0061',\n", - " [404.987, 1163.1228, 0.0],\n", - " [0.5843413, 0.00060528045, 0.010943519, -0.81143403],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 28,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", - " ('scene-0061',\n", - " [404.86212, 1162.7651, 0.0],\n", - " [0.58433264, 0.0007201191, 0.011234255, -0.8114362],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 29,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", - " ('scene-0061',\n", - " [396.54266, 1126.0919, 0.0],\n", - " [0.75652546, -0.012305651, 0.010600711, -0.6537625],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 99,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", - " ('scene-0061',\n", - " [403.0821, 1157.417, 0.0],\n", - " [0.58932906, -0.0028877722, 0.01260862, -0.80778956],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 38,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", - " ('scene-0061',\n", - " [406.15814, 1166.5432, 0.0],\n", - " [0.582743, 0.00034714656, 0.012601047, -0.81255877],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 23,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", - " ('scene-0061',\n", - " [399.7221, 1146.769, 0.0],\n", - " [0.59880483, -0.0012067482, 0.010549273, -0.8008246],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 57,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", - " ('scene-0061',\n", - " [405.5035, 1164.6313, 0.0],\n", - " [0.58340985, -0.00059067144, 0.011375886, -0.812098],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 26,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", - " ('scene-0061',\n", - " [403.43588, 1158.4929, 0.0],\n", - " [0.58850986, -0.0015077875, 0.011858314, -0.8084017],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 36,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", - " ('scene-0061',\n", - " [403.19885, 1157.7759, 0.0],\n", - " [0.58908767, -0.0024906192, 0.012167132, -0.8079737],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 37,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", - " ('scene-0061',\n", - " [397.2565, 1122.8143, 0.0],\n", - " [0.8013138, -0.014086538, 0.010365306, -0.5979885],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 107,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", - " ('scene-0061',\n", - " [401.53412, 1152.6263, 0.0],\n", - " [0.5925509, -0.0013868185, 0.016578251, -0.8053612],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 46,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", - " ('scene-0061',\n", - " [404.37482, 1161.3378, 0.0],\n", - " [0.58590615, 0.0004674817, 0.012389018, -0.8102841],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 31,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", - " ('scene-0061',\n", - " [398.5611, 1142.8029, 0.0],\n", - " [0.606623, 0.00027711107, 0.011538264, -0.7949059],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 65,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", - " ('scene-0061',\n", - " [401.74582, 1153.294, 0.0],\n", - " [0.59173846, -0.0016266924, 0.015531963, -0.8059787],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 45,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", - " ('scene-0061',\n", - " [403.78265, 1159.5538, 0.0],\n", - " [0.5875854, -0.00073446217, 0.012063002, -0.8090719],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 34,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", - " ('scene-0061',\n", - " [401.96237, 1153.9717, 0.0],\n", - " [0.59126234, -0.002127334, 0.015355858, -0.80633026],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 44,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", - " ('scene-0061',\n", - " [398.22733, 1120.219, 0.0],\n", - " [0.84020627, -0.018648054, 0.011925056, -0.541815],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 115,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", - " ('scene-0061',\n", - " [400.2105, 1148.3777, 0.0],\n", - " [0.5967405, -0.0011800155, 0.011447329, -0.8023518],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 54,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", - " ('scene-0061',\n", - " [402.84967, 1156.7153, 0.0],\n", - " [0.5897173, -0.0027600818, 0.013196515, -0.8074972],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 39,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", - " ('scene-0061',\n", - " [402.2962, 1155.005, 0.0],\n", - " [0.5910132, -0.0015329729, 0.01480181, -0.80652463],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 42,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", - " ('scene-0061',\n", - " [397.30127, 1137.8091, 0.0],\n", - " [0.63036275, -0.005581881, 0.01706954, -0.776093],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 73,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", - " ('scene-0061',\n", - " [400.40842, 1149.0205, 0.0],\n", - " [0.59544677, -0.0023208086, 0.011953653, -0.80330247],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 53,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", - " ('scene-0061',\n", - " [400.50894, 1149.3428, 0.0],\n", - " [0.5952807, -0.0029561424, 0.0123259695, -0.8034178],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 52,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", - " ('scene-0061',\n", - " [399.69824, 1117.526, 0.0],\n", - " [0.8799253, -0.02304499, 0.012961318, -0.4743758],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 123,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", - " ('scene-0061',\n", - " [398.993, 1144.3049, 0.0],\n", - " [0.6027616, -0.0005325698, 0.009717508, -0.79786193],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 62,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", - " ('scene-0061',\n", - " [401.42834, 1152.2909, 0.0],\n", - " [0.59288347, -0.0016411142, 0.016268402, -0.80512226],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 47,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", - " ('scene-0061',\n", - " [401.38293, 1115.3053, 0.0],\n", - " [0.9109081, -0.024788104, 0.0111996485, -0.4117117],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 131,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", - " ('scene-0061',\n", - " [399.26257, 1145.228, 0.0],\n", - " [0.60116816, -0.0014488566, 0.010606318, -0.79905087],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 60,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", - " ('scene-0061',\n", - " [396.63867, 1134.1704, 0.0],\n", - " [0.65670073, -0.008959112, 0.0181659, -0.75387925],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 81,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", - " ('scene-0061',\n", - " [400.91226, 1150.6311, 0.0],\n", - " [0.5949238, -0.0024198112, 0.012304212, -0.8036843],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 50,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", - " ('scene-0061',\n", - " [399.08212, 1144.6152, 0.0],\n", - " [0.60213697, -0.0007672519, 0.009812644, -0.79833215],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 61,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", - " ('scene-0061',\n", - " [397.7593, 1139.7955, 0.0],\n", - " [0.61882865, -0.0008499614, 0.015673032, -0.78536916],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 70,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", - " ('scene-0061',\n", - " [400.0093, 1147.7246, 0.0],\n", - " [0.5973411, -0.0006352781, 0.0107196225, -0.80191535],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 55,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", - " ('scene-0061',\n", - " [403.27103, 1113.3992, 0.0],\n", - " [0.9346623, -0.027124994, 0.011047921, -0.35432836],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 139,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939412460.jpg'),\n", - " ('scene-0061',\n", - " [396.2964, 1130.4862, 0.0],\n", - " [0.6982005, -0.011510474, 0.014328633, -0.7156663],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 89,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", - " ('scene-0061',\n", - " [397.9812, 1140.6724, 0.0],\n", - " [0.6144184, 0.00040305342, 0.014102249, -0.78885424],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 68,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", - " ('scene-0061',\n", - " [399.53616, 1146.1481, 0.0],\n", - " [0.5996953, -0.0012350348, 0.010568347, -0.80015767],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 58,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", - " ('scene-0061',\n", - " [396.86746, 1135.5688, 0.0],\n", - " [0.6447938, -0.0063113035, 0.02314772, -0.7639799],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 78,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", - " ('scene-0061',\n", - " [398.81662, 1143.6893, 0.0],\n", - " [0.6042582, -0.00073894317, 0.010532473, -0.79671866],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 63,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", - " ('scene-0061',\n", - " [405.34824, 1111.7334, 0.0],\n", - " [0.9528828, -0.03150209, 0.01046199, -0.30151707],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 147,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940112460.jpg'),\n", - " ('scene-0061',\n", - " [396.39993, 1127.2664, 0.0],\n", - " [0.74102783, -0.012551963, 0.011600121, -0.6712568],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 97,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", - " ('scene-0061',\n", - " [397.02066, 1136.4034, 0.0],\n", - " [0.6399008, -0.0054416955, 0.021064004, -0.76814955],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 76,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", - " ('scene-0061',\n", - " [398.22308, 1141.5768, 0.0],\n", - " [0.61096346, 0.0011945557, 0.0126181245, -0.7915573],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 66,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", - " ('scene-0061',\n", - " [396.36508, 1131.7607, 0.0],\n", - " [0.68185335, -0.01292702, 0.01380134, -0.73124444],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 86,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", - " ('scene-0061',\n", - " [397.83093, 1140.0859, 0.0],\n", - " [0.61720455, -0.00022491867, 0.0151066, -0.7866577],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 69,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", - " ('scene-0061',\n", - " [397.62372, 1139.2268, 0.0],\n", - " [0.6220395, -0.0017644307, 0.015846798, -0.7828235],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 71,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", - " ('scene-0061',\n", - " [407.14404, 1110.551, 0.0],\n", - " [0.96315396, -0.029806307, 0.008533033, -0.26715776],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 155,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940762460.jpg'),\n", - " ('scene-0061',\n", - " [396.97537, 1123.8569, 0.0],\n", - " [0.78708553, -0.012401338, 0.010536757, -0.6166292],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 105,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", - " ('scene-0061',\n", - " [396.4642, 1132.8075, 0.0],\n", - " [0.66966915, -0.012878964, 0.016027492, -0.7423749],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 84,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", - " ('scene-0061',\n", - " [397.18484, 1137.2484, 0.0],\n", - " [0.6343622, -0.0063933465, 0.018074054, -0.7727982],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 74,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", - " ('scene-0061',\n", - " [396.31448, 1128.4827, 0.0],\n", - " [0.7248434, -0.01417012, 0.014465595, -0.688616],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 94,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", - " ('scene-0061',\n", - " [396.91718, 1135.8398, 0.0],\n", - " [0.6432607, -0.0055403197, 0.023059404, -0.7652798],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 77,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", - " ('scene-0061',\n", - " [396.77078, 1135.0138, 0.0],\n", - " [0.64886224, -0.008049913, 0.022049177, -0.76054376],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 79,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", - " ('scene-0061',\n", - " [408.81705, 1109.5994, 0.0],\n", - " [0.9704488, -0.027105767, 0.0068615936, -0.23968166],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 163,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941412460.jpg'),\n", - " ('scene-0061',\n", - " [397.96823, 1120.8148, 0.0],\n", - " [0.83123505, -0.018153878, 0.012520579, -0.5554835],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 113,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", - " ('scene-0061',\n", - " [396.56006, 1133.6129, 0.0],\n", - " [0.6615508, -0.011315477, 0.016124455, -0.74964154],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 82,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", - " ('scene-0061',\n", - " [396.28928, 1129.2233, 0.0],\n", - " [0.7152384, -0.012394093, 0.014470339, -0.69862086],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 92,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", - " ('scene-0061',\n", - " [396.7362, 1124.967, 0.0],\n", - " [0.77229035, -0.012973477, 0.0106600365, -0.6350478],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 102,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", - " ('scene-0061',\n", - " [396.40988, 1132.2782, 0.0],\n", - " [0.6755928, -0.013081879, 0.016123885, -0.7369825],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 85,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", - " ('scene-0061',\n", - " [396.34717, 1131.5018, 0.0],\n", - " [0.68534166, -0.013406395, 0.014163291, -0.7279605],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 87,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", - " ('scene-0061',\n", - " [409.69894, 1176.5562, 0.0],\n", - " [0.57448936, -0.001099729, 0.013668144, -0.81839716],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 8,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", - " ('scene-0061',\n", - " [410.4789, 1108.7618, 0.0],\n", - " [0.974937, -0.02643642, 0.006464297, -0.22081016],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 171,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942112460.jpg'),\n", - " ('scene-0061',\n", - " [399.22205, 1118.2993, 0.0],\n", - " [0.8687445, -0.021203067, 0.011952615, -0.49466214],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 121,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", - " ('scene-0061',\n", - " [396.6135, 1125.6442, 0.0],\n", - " [0.76285535, -0.012946689, 0.011141241, -0.6463435],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 100,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", - " ('scene-0061',\n", - " [396.2897, 1130.2346, 0.0],\n", - " [0.7014657, -0.011371008, 0.014357934, -0.7124678],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 90,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", - " ('scene-0061',\n", - " [397.58148, 1121.8193, 0.0],\n", - " [0.8160355, -0.015576759, 0.011547361, -0.5776764],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 110,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", - " ('scene-0061',\n", - " [396.29492, 1128.9801, 0.0],\n", - " [0.71840936, -0.013479283, 0.015324315, -0.69532114],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 93,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", - " ('scene-0061',\n", - " [396.3412, 1127.992, 0.0],\n", - " [0.7311681, -0.014520667, 0.013635471, -0.68190646],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 95,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", - " ('scene-0061',\n", - " [407.63562, 1170.8375, 0.0],\n", - " [0.5786723, -0.001463367, 0.013450917, -0.8154479],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 16,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", - " ('scene-0061',\n", - " [412.12595, 1107.9789, 0.0],\n", - " [0.9761364, -0.02537057, 0.009166105, -0.21547638],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 179,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942862460.jpg'),\n", - " ('scene-0061',\n", - " [400.9716, 1115.7925, 0.0],\n", - " [0.90466505, -0.022808556, 0.010832767, -0.4253746],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 129,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", - " ('scene-0061',\n", - " [396.47818, 1126.5619, 0.0],\n", - " [0.7502313, -0.012600034, 0.010783764, -0.6609674],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 98,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", - " ('scene-0061',\n", - " [397.378, 1122.4237, 0.0],\n", - " [0.80720747, -0.01503879, 0.01097524, -0.5899741],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 108,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", - " ('scene-0061',\n", - " [398.6898, 1119.263, 0.0],\n", - " [0.854578, -0.017705059, 0.010625387, -0.5189123],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 118,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", - " ('scene-0061',\n", - " [396.65244, 1125.4202, 0.0],\n", - " [0.7660992, -0.013660595, 0.011514766, -0.64247394],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 101,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", - " ('scene-0061',\n", - " [396.82666, 1124.5144, 0.0],\n", - " [0.77815706, -0.012996751, 0.010676374, -0.6278445],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 103,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", - " ('scene-0061',\n", - " [405.89615, 1165.7789, 0.0],\n", - " [0.5833225, -0.0002319457, 0.011867, -0.81215394],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 24,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", - " ('scene-0061',\n", - " [413.50586, 1107.334, 0.0],\n", - " [0.97629994, -0.02254644, 0.01219012, -0.21489866],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 187,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943512460.jpg'),\n", - " ('scene-0061',\n", - " [402.8151, 1113.8203, 0.0],\n", - " [0.9298794, -0.025899872, 0.011699293, -0.36676502],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 137,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939262460.jpg'),\n", - " ('scene-0061',\n", - " [397.14276, 1123.2152, 0.0],\n", - " [0.7960751, -0.013161686, 0.0109560825, -0.6049555],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 106,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", - " ('scene-0061',\n", - " [398.4069, 1119.833, 0.0],\n", - " [0.84601074, -0.018256433, 0.011158379, -0.5327363],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 116,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", - " ('scene-0061',\n", - " [400.32065, 1116.6298, 0.0],\n", - " [0.8926792, -0.022250712, 0.013091335, -0.44995263],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 126,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", - " ('scene-0061',\n", - " [397.4432, 1122.222, 0.0],\n", - " [0.8101742, -0.015364384, 0.011083343, -0.58588296],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 109,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", - " ('scene-0061',\n", - " [397.72845, 1121.42, 0.0],\n", - " [0.82197493, -0.015988924, 0.01188052, -0.5691752],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 111,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", - " ('scene-0061',\n", - " [404.2537, 1160.9792, 0.0],\n", - " [0.58622, 0.00029358457, 0.012530703, -0.8100549],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 32,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", - " ('scene-0061',\n", - " [414.89273, 1106.6855, 0.0],\n", - " [0.9763955, -0.022660932, 0.012908124, -0.21441014],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 195,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944162460.jpg'),\n", - " ('scene-0061',\n", - " [404.7551, 1112.1743, 0.0],\n", - " [0.94864094, -0.029936798, 0.009908904, -0.31477928],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 145,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939912460.jpg'),\n", - " ('scene-0061',\n", - " [399.8209, 1117.3394, 0.0],\n", - " [0.88259035, -0.022708222, 0.0134714935, -0.46940082],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 124,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", - " ('scene-0061',\n", - " [398.1398, 1120.4147, 0.0],\n", - " [0.837258, -0.018762026, 0.012272921, -0.5463483],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 114,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", - " ('scene-0061',\n", - " [402.07605, 1114.553, 0.0],\n", - " [0.920995, -0.025741814, 0.0107365325, -0.38857475],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 134,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", - " ('scene-0061',\n", - " [398.5933, 1119.4526, 0.0],\n", - " [0.8517187, -0.017718947, 0.010415578, -0.5235959],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 117,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", - " ('scene-0061',\n", - " [416.32333, 1106.0272, 0.0],\n", - " [0.97794795, -0.021899294, 0.012839093, -0.20730017],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 203,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944862460.jpg'),\n", - " ('scene-0061',\n", - " [398.8954, 1118.8767, 0.0],\n", - " [0.86060065, -0.018575022, 0.011087195, -0.5088207],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 119,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", - " ('scene-0061',\n", - " [402.62708, 1156.0305, 0.0],\n", - " [0.5903688, -0.0024865884, 0.014490768, -0.8069997],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 40,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", - " ('scene-0061',\n", - " [406.74698, 1110.7969, 0.0],\n", - " [0.96126205, -0.029092489, 0.008431543, -0.27396682],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 153,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940612460.jpg'),\n", - " ('scene-0061',\n", - " [399.45596, 1117.9082, 0.0],\n", - " [0.87443304, -0.022975512, 0.012492363, -0.4844408],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 122,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", - " ('scene-0061',\n", - " [401.6661, 1114.9884, 0.0],\n", - " [0.91513425, -0.02567166, 0.011265624, -0.40217328],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 132,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", - " ('scene-0061',\n", - " [404.00897, 1112.7621, 0.0],\n", - " [0.9421402, -0.026302977, 0.011385342, -0.3339916],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 142,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939662460.jpg'),\n", - " ('scene-0061',\n", - " [400.06644, 1116.981, 0.0],\n", - " [0.8876677, -0.022135617, 0.014227625, -0.45973217],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 125,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", - " ('scene-0061',\n", - " [417.96674, 1105.3439, 0.0],\n", - " [0.98400414, -0.022680001, 0.010430038, -0.17638777],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 211,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945612460.jpg'),\n", - " ('scene-0061',\n", - " [400.4498, 1116.4556, 0.0],\n", - " [0.89514697, -0.022116954, 0.011984723, -0.44506076],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 127,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", - " ('scene-0061',\n", - " [401.21585, 1151.6133, 0.0],\n", - " [0.59370416, -0.0014474898, 0.014589294, -0.8045499],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 48,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", - " ('scene-0061',\n", - " [408.44244, 1109.8015, 0.0],\n", - " [0.96880263, -0.027919263, 0.007392832, -0.2461449],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 161,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941262460.jpg'),\n", - " ('scene-0061',\n", - " [403.56848, 1113.1364, 0.0],\n", - " [0.9378092, -0.02689254, 0.010645541, -0.34594402],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 140,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939512460.jpg'),\n", - " ('scene-0061',\n", - " [401.10562, 1115.6298, 0.0],\n", - " [0.9068449, -0.023226246, 0.010956266, -0.42068133],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 130,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", - " ('scene-0061',\n", - " [406.0572, 1111.2417, 0.0],\n", - " [0.9573947, -0.030517798, 0.009340925, -0.2870136],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 150,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940362460.jpg'),\n", - " ('scene-0061',\n", - " [401.80154, 1114.8435, 0.0],\n", - " [0.91717714, -0.025765007, 0.011106573, -0.39749077],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 133,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", - " ('scene-0061',\n", - " [402.3716, 1114.2511, 0.0],\n", - " [0.9246748, -0.025477413, 0.010666427, -0.37975475],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 135,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", - " ('scene-0061',\n", - " [410.00864, 1108.989, 0.0],\n", - " [0.97414553, -0.026948208, 0.00609539, -0.2242257],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 169,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941912460.jpg'),\n", - " ('scene-0061',\n", - " [399.91147, 1147.4009, 0.0],\n", - " [0.597962, -0.000787034, 0.0105392225, -0.8014547],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 56,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", - " ('scene-0061',\n", - " [405.4918, 1111.6306, 0.0],\n", - " [0.9537995, -0.031079035, 0.010278165, -0.29865524],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 148,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940162460.jpg'),\n", - " ('scene-0061',\n", - " [403.12012, 1113.5366, 0.0],\n", - " [0.93313324, -0.026665784, 0.011405521, -0.35835898],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 138,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939362460.jpg'),\n", - " ('scene-0061',\n", - " [407.80466, 1110.1576, 0.0],\n", - " [0.96622306, -0.029565975, 0.008752593, -0.25585586],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 158,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941012460.jpg'),\n", - " ('scene-0061',\n", - " [403.8606, 1112.8856, 0.0],\n", - " [0.94069505, -0.02647787, 0.011154053, -0.33803457],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 141,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939612460.jpg'),\n", - " ('scene-0061',\n", - " [404.30472, 1112.5244, 0.0],\n", - " [0.94491816, -0.026692897, 0.011067719, -0.3260286],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 143,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939762460.jpg'),\n", - " ('scene-0061',\n", - " [411.70453, 1108.1777, 0.0],\n", - " [0.97593254, -0.024170937, 0.006519938, -0.21663088],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 177,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942662460.jpg'),\n", - " ('scene-0061',\n", - " [398.64615, 1143.0984, 0.0],\n", - " [0.6059309, 2.662957e-05, 0.011080284, -0.79544014],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 64,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", - " ('scene-0061',\n", - " [407.4073, 1110.3907, 0.0],\n", - " [0.96433794, -0.030767225, 0.008553644, -0.2627405],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 156,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940862460.jpg'),\n", - " ('scene-0061',\n", - " [405.0551, 1111.9475, 0.0],\n", - " [0.95083225, -0.031542502, 0.010364667, -0.3079216],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 146,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940012460.jpg'),\n", - " ('scene-0061',\n", - " [409.4245, 1109.2806, 0.0],\n", - " [0.97242236, -0.027893499, 0.0069214455, -0.23144926],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 166,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941662460.jpg'),\n", - " ('scene-0061',\n", - " [405.7799, 1111.4298, 0.0],\n", - " [0.95565075, -0.030525152, 0.009533179, -0.29276106],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 149,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940262460.jpg'),\n", - " ('scene-0061',\n", - " [406.1992, 1111.1477, 0.0],\n", - " [0.9582559, -0.030005485, 0.009178548, -0.28418496],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 151,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940412460.jpg'),\n", - " ('scene-0061',\n", - " [413.193, 1107.4794, 0.0],\n", - " [0.9761333, -0.023635045, 0.010868567, -0.21560872],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 185,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943362460.jpg'),\n", - " ('scene-0061',\n", - " [406.87674, 1110.7158, 0.0],\n", - " [0.9618936, -0.029059071, 0.008584107, -0.27173993],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 154,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940662460.jpg'),\n", - " ('scene-0061',\n", - " [409.0536, 1109.474, 0.0],\n", - " [0.9712996, -0.02719881, 0.006952255, -0.23619694],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 164,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941512460.jpg'),\n", - " ('scene-0061',\n", - " [397.49127, 1138.6614, 0.0],\n", - " [0.6252904, -0.0036155572, 0.015918566, -0.7802214],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 72,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", - " ('scene-0061',\n", - " [411.04993, 1108.4897, 0.0],\n", - " [0.9755195, -0.026619151, 0.005941383, -0.21821527],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 174,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942362460.jpg'),\n", - " ('scene-0061',\n", - " [407.54398, 1110.3094, 0.0],\n", - " [0.9649793, -0.030383775, 0.008653935, -0.26041675],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 157,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940912460.jpg'),\n", - " ('scene-0061',\n", - " [414.5842, 1106.8287, 0.0],\n", - " [0.9764777, -0.024033556, 0.01167077, -0.2139569],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 193,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944012460.jpg'),\n", - " ('scene-0061',\n", - " [408.06274, 1110.0115, 0.0],\n", - " [0.96734184, -0.029089399, 0.008275028, -0.25166455],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 159,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941112460.jpg'),\n", - " ('scene-0061',\n", - " [408.68704, 1109.6688, 0.0],\n", - " [0.969894, -0.02747783, 0.0071973554, -0.24186537],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 162,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941362460.jpg'),\n", - " ('scene-0061',\n", - " [410.5889, 1108.7089, 0.0],\n", - " [0.9750748, -0.026712378, 0.0065724985, -0.22016431],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 172,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942162460.jpg'),\n", - " ('scene-0061',\n", - " [412.66992, 1107.7244, 0.0],\n", - " [0.9761587, -0.023244632, 0.009124158, -0.21561702],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 182,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943112460.jpg'),\n", - " ('scene-0061',\n", - " [396.67993, 1134.4471, 0.0],\n", - " [0.6539996, -0.008310996, 0.019527715, -0.7561971],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 80,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", - " ('scene-0061',\n", - " [409.3015, 1109.3441, 0.0],\n", - " [0.97203964, -0.027957141, 0.006766217, -0.23304847],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 165,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941612460.jpg'),\n", - " ('scene-0061',\n", - " [415.909, 1106.2167, 0.0],\n", - " [0.97722995, -0.022731628, 0.0126617, -0.21058142],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 201,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944662460.jpg'),\n", - " ('scene-0061',\n", - " [409.6566, 1109.1628, 0.0],\n", - " [0.97315985, -0.027366824, 0.0065424647, -0.2284034],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 167,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941762460.jpg'),\n", - " ('scene-0061',\n", - " [412.2325, 1107.9291, 0.0],\n", - " [0.97610885, -0.02541695, 0.00934391, -0.21558799],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 180,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942912460.jpg'),\n", - " ('scene-0061',\n", - " [410.25043, 1108.8711, 0.0],\n", - " [0.9745716, -0.026535306, 0.0061661974, -0.22241421],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 170,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942012460.jpg'),\n", - " ('scene-0061',\n", - " [414.04272, 1107.0813, 0.0],\n", - " [0.9761661, -0.02204251, 0.012227701, -0.21555586],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 190,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943762460.jpg'),\n", - " ('scene-0061',\n", - " [396.3175, 1130.9933, 0.0],\n", - " [0.6920639, -0.012574055, 0.0141447, -0.7215881],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 88,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", - " ('scene-0061',\n", - " [410.82248, 1108.5961, 0.0],\n", - " [0.97529095, -0.027127534, 0.0061711753, -0.21916564],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 173,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942262460.jpg'),\n", - " ('scene-0061',\n", - " [417.5203, 1105.5157, 0.0],\n", - " [0.9821829, -0.022073375, 0.010718971, -0.18631862],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 209,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945412460.jpg'),\n", - " ('scene-0061',\n", - " [411.37943, 1108.3331, 0.0],\n", - " [0.97586125, -0.02340474, 0.004967739, -0.21707675],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 175,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942512460.jpg'),\n", - " ('scene-0061',\n", - " [411.91467, 1108.0778, 0.0],\n", - " [0.9760568, -0.024455242, 0.008199203, -0.21598104],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 178,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942762460.jpg'),\n", - " ('scene-0061',\n", - " [415.40146, 1106.4501, 0.0],\n", - " [0.9766985, -0.022529658, 0.013487229, -0.21300359],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 198,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944412460.jpg'),\n", - " ('scene-0061',\n", - " [413.72113, 1107.2336, 0.0],\n", - " [0.9764502, -0.020853322, 0.013402041, -0.21431404],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 188,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943612460.jpg'),\n", - " ('scene-0061',\n", - " [396.3583, 1127.7473, 0.0],\n", - " [0.7344936, -0.014392123, 0.013631947, -0.67832595],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 96,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", - " ('scene-0061',\n", - " [412.45483, 1107.8251, 0.0],\n", - " [0.9760811, -0.0246137, 0.009191754, -0.21581335],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 181,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943012460.jpg'),\n", - " ('scene-0061',\n", - " [412.77466, 1107.675, 0.0],\n", - " [0.9762182, -0.022837723, 0.009342563, -0.21538149],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 183,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943162460.jpg'),\n", - " ('scene-0061',\n", - " [416.94244, 1105.7557, 0.0],\n", - " [0.979921, -0.021989867, 0.013165723, -0.19773196],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 206,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945162460.jpg'),\n", - " ('scene-0061',\n", - " [413.29492, 1107.4321, 0.0],\n", - " [0.97613966, -0.023908148, 0.011200241, -0.2155325],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 186,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943412460.jpg'),\n", - " ('scene-0061',\n", - " [415.0955, 1106.5913, 0.0],\n", - " [0.97654873, -0.022136636, 0.013666012, -0.21371907],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 196,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944262460.jpg'),\n", - " ('scene-0061',\n", - " [396.87332, 1124.2977, 0.0],\n", - " [0.78113025, -0.0130910985, 0.010597707, -0.6241409],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 104,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", - " ('scene-0061',\n", - " [413.82776, 1107.1836, 0.0],\n", - " [0.9763831, -0.020947112, 0.013463881, -0.21460654],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 189,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943662460.jpg'),\n", - " ('scene-0061',\n", - " [414.26404, 1106.9772, 0.0],\n", - " [0.97624946, -0.02340606, 0.011474855, -0.2150754],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 191,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943862460.jpg'),\n", - " ('scene-0061',\n", - " [416.4137, 1105.9865, 0.0],\n", - " [0.97818583, -0.021752805, 0.012997908, -0.20618038],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 204,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944912460.jpg'),\n", - " ('scene-0061',\n", - " [414.79333, 1106.7322, 0.0],\n", - " [0.97640204, -0.023085179, 0.012438345, -0.2143627],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 194,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944112460.jpg'),\n", - " ('scene-0061',\n", - " [397.8045, 1121.2213, 0.0],\n", - " [0.82498276, -0.016496139, 0.012130499, -0.56478685],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 112,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", - " ('scene-0061',\n", - " [415.29855, 1106.4976, 0.0],\n", - " [0.9766862, -0.022199292, 0.013717346, -0.2130802],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 197,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944362460.jpg'),\n", - " ('scene-0061',\n", - " [415.6078, 1106.3547, 0.0],\n", - " [0.97673494, -0.023568533, 0.012978978, -0.21275552],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 199,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944512460.jpg'),\n", - " ('scene-0061',\n", - " [418.0833, 1105.3011, 0.0],\n", - " [0.9844567, -0.022905778, 0.010368886, -0.17381829],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 212,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945662460.jpg'),\n", - " ('scene-0061',\n", - " [416.11536, 1106.1217, 0.0],\n", - " [0.97756636, -0.022527909, 0.01272844, -0.20903231],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 202,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944762460.jpg'),\n", - " ('scene-0061',\n", - " [399.1101, 1118.4924, 0.0],\n", - " [0.8662677, -0.020047856, 0.011541788, -0.4990443],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 120,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", - " ('scene-0061',\n", - " [416.8289, 1105.8041, 0.0],\n", - " [0.9795459, -0.021775154, 0.013441239, -0.19958717],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 205,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945112460.jpg'),\n", - " ('scene-0061',\n", - " [417.16757, 1105.6608, 0.0],\n", - " [0.98074573, -0.022366723, 0.011978244, -0.1936338],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 207,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945262460.jpg'),\n", - " ('scene-0061',\n", - " [417.7432, 1105.4287, 0.0],\n", - " [0.9831149, -0.02230873, 0.010457868, -0.18132299],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 210,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945512460.jpg'),\n", - " ('scene-0061',\n", - " [400.708, 1116.1185, 0.0],\n", - " [0.8999891, -0.022216449, 0.010693469, -0.4352145],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 128,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg'),\n", - " ('scene-0061',\n", - " [402.5181, 1114.1062, 0.0],\n", - " [0.9264419, -0.025537476, 0.0109653175, -0.37541047],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 136,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939162460.jpg'),\n", - " ('scene-0061',\n", - " [404.60352, 1112.2913, 0.0],\n", - " [0.94746536, -0.028918544, 0.010236678, -0.31838387],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 144,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939862460.jpg'),\n", - " ('scene-0061',\n", - " [406.47455, 1110.9691, 0.0],\n", - " [0.95977485, -0.029204518, 0.00892144, -0.2791052],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 152,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940512460.jpg'),\n", - " ('scene-0061',\n", - " [408.193, 1109.9387, 0.0],\n", - " [0.96781933, -0.028659297, 0.007676122, -0.24989098],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 160,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941162460.jpg'),\n", - " ('scene-0061',\n", - " [409.8863, 1109.0491, 0.0],\n", - " [0.97386444, -0.026987761, 0.0062259785, -0.22543503],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 168,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941862460.jpg'),\n", - " ('scene-0061',\n", - " [411.59866, 1108.2284, 0.0],\n", - " [0.9759235, -0.023630401, 0.0056559057, -0.21675555],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 176,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942612460.jpg'),\n", - " ('scene-0061',\n", - " [412.98715, 1107.5753, 0.0],\n", - " [0.97623974, -0.023126684, 0.010198352, -0.21521425],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 184,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943262460.jpg'),\n", - " ('scene-0061',\n", - " [414.37247, 1106.9263, 0.0],\n", - " [0.9763658, -0.024076385, 0.011487491, -0.21447194],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 192,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943912478.jpg'),\n", - " ('scene-0061',\n", - " [415.8036, 1106.2646, 0.0],\n", - " [0.9770279, -0.023163736, 0.012685502, -0.2114686],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 200,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944612460.jpg'),\n", - " ('scene-0061',\n", - " [417.40353, 1105.5627, 0.0],\n", - " [0.9816883, -0.022048112, 0.0109732235, -0.1888954],\n", - " [1.7007912, 0.015945632, 1.5109576],\n", - " [0.49980155, -0.5030316, 0.49977982, -0.49737084],\n", - " [[1266.4172, 0.0, 816.267], [0.0, 1266.4172, 491.50708], [0.0, 0.0, 1.0]],\n", - " 208,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945362460.jpg')]" + "[]" ] }, - "execution_count": 12, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -4634,8032 +2990,17 @@ }, { "cell_type": "code", - "execution_count": 13, - "id": "ed2962ed", + "execution_count": 16, + "id": "1a8aea00", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[[(array([[1583.23856331],\n", - " [ 503.09714074]]),\n", - " 3,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", - " (array([[1672.44622714],\n", - " [ 495.63783585]]),\n", - " 11,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", - " (array([[1801.42531047],\n", - " [ 506.85860628]]),\n", - " 19,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", - " (array([[1933.03288266],\n", - " [ 513.06262568]]),\n", - " 27,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", - " (array([[2097.76615143],\n", - " [ 523.77192278]]),\n", - " 35,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", - " (array([[2315.33365545],\n", - " [ 539.53363603]]),\n", - " 43,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", - " (array([[1562.47105967],\n", - " [ 505.75308814]]),\n", - " 1,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg'),\n", - " (array([[2583.20543882],\n", - " [ 552.07201123]]),\n", - " 51,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", - " (array([[1650.21356897],\n", - " [ 501.21857729]]),\n", - " 9,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", - " (array([[2960.58668303],\n", - " [ 555.45359404]]),\n", - " 59,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", - " (array([[1760.22502942],\n", - " [ 509.60057442]]),\n", - " 17,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", - " (array([[1612.98393303],\n", - " [ 509.08789553]]),\n", - " 6,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", - " (array([[3719.74087511],\n", - " [ 582.47431668]]),\n", - " 67,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", - " (array([[1901.11225566],\n", - " [ 513.44062369]]),\n", - " 25,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", - " (array([[1600.66067399],\n", - " [ 507.14188298]]),\n", - " 5,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", - " (array([[1595.19187156],\n", - " [ 506.06889087]]),\n", - " 4,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", - " (array([[1714.2997564 ],\n", - " [ 512.60417651]]),\n", - " 14,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", - " (array([[5689.47741549],\n", - " [ 748.0763832 ]]),\n", - " 75,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", - " (array([[2056.33260892],\n", - " [ 519.09946333]]),\n", - " 33,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", - " (array([[1690.45445428],\n", - " [ 497.19170504]]),\n", - " 12,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", - " (array([[1569.44991322],\n", - " [ 502.86027008]]),\n", - " 2,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", - " (array([[1708.05010926],\n", - " [ 507.62952612]]),\n", - " 13,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", - " (array([[1851.80244938],\n", - " [ 507.91706344]]),\n", - " 22,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", - " (array([[16281.08844515],\n", - " [ 1410.35217171]]),\n", - " 83,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", - " (array([[1629.73744627],\n", - " [ 505.91857202]]),\n", - " 7,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", - " (array([[2251.09670999],\n", - " [ 533.32851898]]),\n", - " 41,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", - " (array([[1666.17480671],\n", - " [ 496.24569809]]),\n", - " 10,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", - " (array([[1812.17842028],\n", - " [ 505.24242525]]),\n", - " 20,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", - " (array([[1831.31343444],\n", - " [ 505.81474857]]),\n", - " 21,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", - " (array([[-10482.69407562],\n", - " [ -166.99729307]]),\n", - " 91,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", - " (array([[1989.23667911],\n", - " [ 511.66561711]]),\n", - " 30,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", - " (array([[1729.99015786],\n", - " [ 513.9803146 ]]),\n", - " 15,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", - " (array([[2518.75418552],\n", - " [ 543.29982144]]),\n", - " 49,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", - " (array([[1779.97600725],\n", - " [ 506.13460135]]),\n", - " 18,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", - " (array([[1954.51482005],\n", - " [ 510.77881331]]),\n", - " 28,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", - " (array([[1964.28625551],\n", - " [ 510.85011794]]),\n", - " 29,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", - " (array([[-2838.49620369],\n", - " [ 288.35603174]]),\n", - " 99,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", - " (array([[2174.08867172],\n", - " [ 531.61492342]]),\n", - " 38,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", - " (array([[1863.02618066],\n", - " [ 507.5947961 ]]),\n", - " 23,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", - " (array([[2868.10169263],\n", - " [ 550.02980998]]),\n", - " 57,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", - " (array([[1912.87014282],\n", - " [ 512.48711114]]),\n", - " 26,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", - " (array([[2128.79178067],\n", - " [ 524.1944701 ]]),\n", - " 36,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", - " (array([[2158.83727209],\n", - " [ 529.22497187]]),\n", - " 37,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", - " (array([[-1275.44255601],\n", - " [ 366.15459743]]),\n", - " 107,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", - " (array([[2407.85062272],\n", - " [ 538.15318056]]),\n", - " 46,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", - " (array([[2014.49528186],\n", - " [ 511.99656649]]),\n", - " 31,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", - " (array([[3390.72088978],\n", - " [ 561.75339199]]),\n", - " 65,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", - " (array([[2366.97974082],\n", - " [ 536.32840048]]),\n", - " 45,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", - " (array([[2081.51954489],\n", - " [ 518.65070459]]),\n", - " 34,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", - " (array([[2330.16495084],\n", - " [ 536.50156984]]),\n", - " 44,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", - " (array([[-614.76118311],\n", - " [ 389.65116762]]),\n", - " 115,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", - " (array([[2701.90396017],\n", - " [ 542.05976538]]),\n", - " 54,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", - " (array([[2194.22014681],\n", - " [ 530.21980452]]),\n", - " 39,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", - " (array([[2275.42221287],\n", - " [ 530.07962226]]),\n", - " 42,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", - " (array([[5059.62483744],\n", - " [ 686.8734955 ]]),\n", - " 73,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", - " (array([[2643.15777293],\n", - " [ 545.55984174]]),\n", - " 53,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", - " (array([[2620.21759973],\n", - " [ 546.40529345]]),\n", - " 52,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", - " (array([[-146.12870923],\n", - " [ 408.38151854]]),\n", - " 123,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", - " (array([[3139.46287802],\n", - " [ 549.58296452]]),\n", - " 62,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", - " (array([[2422.66556745],\n", - " [ 536.98231672]]),\n", - " 47,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", - " (array([[150.39399952],\n", - " [427.6945406 ]]),\n", - " 131,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", - " (array([[3021.66739063],\n", - " [ 551.82950934]]),\n", - " 60,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", - " (array([[10044.38351925],\n", - " [ 990.73211788]]),\n", - " 81,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", - " (array([[2534.70142892],\n", - " [ 540.60773988]]),\n", - " 50,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", - " (array([[3097.31080209],\n", - " [ 549.56391711]]),\n", - " 61,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", - " (array([[4142.98251701],\n", - " [ 604.05461777]]),\n", - " 70,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", - " (array([[2757.94901567],\n", - " [ 539.08094427]]),\n", - " 55,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", - " (array([[364.2654916 ],\n", - " [437.87006865]]),\n", - " 139,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939412460.jpg'),\n", - " (array([[-19077.45549976],\n", - " [ -593.45364212]]),\n", - " 89,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", - " (array([[3861.79040235],\n", - " [ 580.46056399]]),\n", - " 68,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", - " (array([[2916.35171389],\n", - " [ 547.06125252]]),\n", - " 58,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", - " (array([[7046.64959284],\n", - " [ 834.32063264]]),\n", - " 78,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", - " (array([[3233.81500291],\n", - " [ 552.01458435]]),\n", - " 63,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", - " (array([[532.51233353],\n", - " [448.86955629]]),\n", - " 147,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940112460.jpg'),\n", - " (array([[-3927.00087066],\n", - " [ 243.77241192]]),\n", - " 97,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", - " (array([[6170.02352268],\n", - " [ 754.38979699]]),\n", - " 76,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", - " (array([[3638.84602473],\n", - " [ 559.76077534]]),\n", - " 66,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", - " (array([[117958.59449261],\n", - " [ 6651.20088697]]),\n", - " 86,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", - " (array([[4049.09723868],\n", - " [ 585.51165 ]]),\n", - " 69,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", - " (array([[4372.55815253],\n", - " [ 610.16094336]]),\n", - " 71,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", - " (array([[633.15448419],\n", - " [458.96922919]]),\n", - " 155,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940762460.jpg'),\n", - " (array([[-1640.97030191],\n", - " [ 363.95663936]]),\n", - " 105,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", - " (array([[19239.29193738],\n", - " [ 1509.18215076]]),\n", - " 84,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", - " (array([[5468.42430013],\n", - " [ 702.73707645]]),\n", - " 74,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", - " (array([[-5900.39110976],\n", - " [ 148.09668165]]),\n", - " 94,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", - " (array([[6757.77812588],\n", - " [ 759.36021102]]),\n", - " 77,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", - " (array([[7933.05144534],\n", - " [ 837.77471161]]),\n", - " 79,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", - " (array([[708.85009783],\n", - " [470.02848078]]),\n", - " 163,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941412460.jpg'),\n", - " (array([[-741.83047223],\n", - " [ 397.82116679]]),\n", - " 113,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", - " (array([[12320.75671122],\n", - " [ 1033.95323033]]),\n", - " 82,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", - " (array([[-7845.26518725],\n", - " [ 78.81441516]]),\n", - " 92,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", - " (array([[-2101.87428744],\n", - " [ 360.36005795]]),\n", - " 102,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", - " (array([[35166.66139198],\n", - " [ 2192.00877477]]),\n", - " 85,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", - " (array([[-155355.06897681],\n", - " [ -6930.07201434]]),\n", - " 87,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", - " (array([[1634.53455513],\n", - " [ 493.028584 ]]),\n", - " 8,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", - " (array([[762.7910376 ],\n", - " [473.37527678]]),\n", - " 171,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942112460.jpg'),\n", - " (array([[-257.01965462],\n", - " [ 420.43121864]]),\n", - " 121,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", - " (array([[-2487.74870678],\n", - " [ 342.85543533]]),\n", - " 100,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", - " (array([[-14453.42439088],\n", - " [ -200.04115386]]),\n", - " 90,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", - " (array([[-977.27280411],\n", - " [ 397.03587695]]),\n", - " 110,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", - " (array([[-7031.93173648],\n", - " [ 96.86255469]]),\n", - " 93,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", - " (array([[-4858.93687596],\n", - " [ 211.98746202]]),\n", - " 95,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", - " (array([[1747.98149254],\n", - " [ 497.06458958]]),\n", - " 16,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", - " (array([[778.54767326],\n", - " [467.41090929]]),\n", - " 179,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942862460.jpg'),\n", - " (array([[ 98.48260153],\n", - " [438.30522379]]),\n", - " 129,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", - " (array([[-3166.57747263],\n", - " [ 319.97717728]]),\n", - " 98,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", - " (array([[-1142.88751826],\n", - " [ 394.45899966]]),\n", - " 108,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", - " (array([[-418.87941732],\n", - " [ 421.41519204]]),\n", - " 118,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", - " (array([[-2344.65429374],\n", - " [ 345.60853374]]),\n", - " 101,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", - " (array([[-1889.76186385],\n", - " [ 370.67422999]]),\n", - " 103,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", - " (array([[1879.1259691 ],\n", - " [ 496.16014217]]),\n", - " 24,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", - " (array([[781.63698819],\n", - " [459.23768845]]),\n", - " 187,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943512460.jpg'),\n", - " (array([[328.71473195],\n", - " [448.89760094]]),\n", - " 137,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939262460.jpg'),\n", - " (array([[-1375.34622705],\n", - " [ 397.48103796]]),\n", - " 106,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", - " (array([[-519.73005406],\n", - " [ 420.8919645 ]]),\n", - " 116,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", - " (array([[ -9.22912653],\n", - " [432.41844019]]),\n", - " 126,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", - " (array([[-1075.35408214],\n", - " [ 403.74336541]]),\n", - " 109,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", - " (array([[-866.47927254],\n", - " [ 407.56519183]]),\n", - " 111,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", - " (array([[2038.6801857 ],\n", - " [ 493.95826756]]),\n", - " 32,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", - " (array([[789.54350685],\n", - " [460.86116499]]),\n", - " 195,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944162460.jpg'),\n", - " (array([[503.42292542],\n", - " [460.70615363]]),\n", - " 145,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939912460.jpg'),\n", - " (array([[-99.22667708],\n", - " [427.47805504]]),\n", - " 124,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", - " (array([[-623.19408629],\n", - " [ 412.42186851]]),\n", - " 114,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", - " (array([[255.36686578],\n", - " [448.77086328]]),\n", - " 134,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", - " (array([[-445.94684912],\n", - " [ 423.02907531]]),\n", - " 117,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", - " (array([[805.26873158],\n", - " [459.23660809]]),\n", - " 203,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944862460.jpg'),\n", - " (array([[-341.6914838 ],\n", - " [ 424.14549973]]),\n", - " 119,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", - " (array([[2241.82229491],\n", - " [ 514.13660808]]),\n", - " 40,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", - " (array([[620.49451322],\n", - " [466.31117702]]),\n", - " 153,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940612460.jpg'),\n", - " (array([[-188.25081859],\n", - " [ 423.56236281]]),\n", - " 122,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", - " (array([[199.38066814],\n", - " [442.73079984]]),\n", - " 132,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", - " (array([[440.28893346],\n", - " [451.92520466]]),\n", - " 142,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939662460.jpg'),\n", - " (array([[-54.77943772],\n", - " [424.6368745 ]]),\n", - " 125,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", - " (array([[883.10298374],\n", - " [467.72270862]]),\n", - " 211,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945612460.jpg'),\n", - " (array([[ 16.30558952],\n", - " [434.18443584]]),\n", - " 127,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", - " (array([[2490.23363701],\n", - " [ 516.60946512]]),\n", - " 48,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", - " (array([[698.96244768],\n", - " [471.87433634]]),\n", - " 161,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941262460.jpg'),\n", - " (array([[401.85328317],\n", - " [452.75735757]]),\n", - " 140,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939512460.jpg'),\n", - " (array([[124.57991371],\n", - " [441.47393687]]),\n", - " 130,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", - " (array([[583.7091339 ],\n", - " [463.65709337]]),\n", - " 150,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940362460.jpg'),\n", - " (array([[217.95232528],\n", - " [444.2906363 ]]),\n", - " 133,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", - " (array([[284.54014143],\n", - " [448.15584832]]),\n", - " 135,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", - " (array([[758.03646265],\n", - " [476.87656039]]),\n", - " 169,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941912460.jpg'),\n", - " (array([[2825.34748401],\n", - " [ 516.4426473 ]]),\n", - " 56,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", - " (array([[549.86542223],\n", - " [460.40695937]]),\n", - " 148,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940162460.jpg'),\n", - " (array([[360.72877347],\n", - " [449.50231337]]),\n", - " 138,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939362460.jpg'),\n", - " (array([[672.70546347],\n", - " [468.48438979]]),\n", - " 158,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941012460.jpg'),\n", - " (array([[428.28989104],\n", - " [452.75241687]]),\n", - " 141,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939612460.jpg'),\n", - " (array([[466.81401742],\n", - " [454.75598755]]),\n", - " 143,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939762460.jpg'),\n", - " (array([[779.55618932],\n", - " [475.6447674 ]]),\n", - " 177,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942662460.jpg'),\n", - " (array([[3389.56652333],\n", - " [ 524.99490605]]),\n", - " 64,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", - " (array([[653.93674031],\n", - " [468.9689665 ]]),\n", - " 156,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940862460.jpg'),\n", - " (array([[522.30850617],\n", - " [459.46302771]]),\n", - " 146,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940012460.jpg'),\n", - " (array([[739.26777161],\n", - " [474.92582623]]),\n", - " 166,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941662460.jpg'),\n", - " (array([[567.82005917],\n", - " [463.16830697]]),\n", - " 149,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940262460.jpg'),\n", - " (array([[593.28071249],\n", - " [465.20293613]]),\n", - " 151,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940412460.jpg'),\n", - " (array([[783.91065687],\n", - " [465.33841927]]),\n", - " 185,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943362460.jpg'),\n", - " (array([[629.02970119],\n", - " [467.73685868]]),\n", - " 154,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940662460.jpg'),\n", - " (array([[726.95230377],\n", - " [474.44258319]]),\n", - " 164,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941512460.jpg'),\n", - " (array([[4750.62451475],\n", - " [ 599.05035044]]),\n", - " 72,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", - " (array([[775.10382124],\n", - " [478.23683804]]),\n", - " 174,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942362460.jpg'),\n", - " (array([[661.29351704],\n", - " [469.45382447]]),\n", - " 157,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940912460.jpg'),\n", - " (array([[789.46399066],\n", - " [464.06970185]]),\n", - " 193,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944012460.jpg'),\n", - " (array([[685.47444819],\n", - " [470.8085833 ]]),\n", - " 159,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941112460.jpg'),\n", - " (array([[712.15013482],\n", - " [473.7545568 ]]),\n", - " 162,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941362460.jpg'),\n", - " (array([[770.17481886],\n", - " [476.83970411]]),\n", - " 172,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942162460.jpg'),\n", - " (array([[783.82537592],\n", - " [469.61670894]]),\n", - " 182,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943112460.jpg'),\n", - " (array([[9952.21418067],\n", - " [ 871.60288946]]),\n", - " 80,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", - " (array([[736.18341753],\n", - " [476.06263672]]),\n", - " 165,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941612460.jpg'),\n", - " (array([[799.24830483],\n", - " [461.63576845]]),\n", - " 201,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944662460.jpg'),\n", - " (array([[748.58559022],\n", - " [476.76556278]]),\n", - " 167,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941762460.jpg'),\n", - " (array([[783.83153774],\n", - " [470.30886824]]),\n", - " 180,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942912460.jpg'),\n", - " (array([[764.91969786],\n", - " [478.11916662]]),\n", - " 170,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942012460.jpg'),\n", - " (array([[785.9341174 ],\n", - " [462.18601642]]),\n", - " 190,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943762460.jpg'),\n", - " (array([[-25913.63738132],\n", - " [ -635.70851993]]),\n", - " 88,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", - " (array([[773.66998839],\n", - " [478.6604909 ]]),\n", - " 173,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942262460.jpg'),\n", - " (array([[860.90107807],\n", - " [467.84869897]]),\n", - " 209,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945412460.jpg'),\n", - " (array([[780.07559591],\n", - " [479.6164567 ]]),\n", - " 175,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942512460.jpg'),\n", - " (array([[783.41090009],\n", - " [472.38215654]]),\n", - " 178,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942762460.jpg'),\n", - " (array([[793.66481459],\n", - " [459.14751903]]),\n", - " 198,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944412460.jpg'),\n", - " (array([[789.35069847],\n", - " [458.37040667]]),\n", - " 188,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943612460.jpg'),\n", - " (array([[-4279.51185295],\n", - " [ 257.42407621]]),\n", - " 96,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", - " (array([[784.26607977],\n", - " [470.10696801]]),\n", - " 181,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943012460.jpg'),\n", - " (array([[786.13809405],\n", - " [468.50603912]]),\n", - " 183,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943162460.jpg'),\n", - " (array([[833.17640066],\n", - " [460.27687037]]),\n", - " 206,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945162460.jpg'),\n", - " (array([[786.13730679],\n", - " [464.52926156]]),\n", - " 186,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943412460.jpg'),\n", - " (array([[792.12233852],\n", - " [458.00089239]]),\n", - " 196,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944262460.jpg'),\n", - " (array([[-1738.61185611],\n", - " [ 383.56354813]]),\n", - " 104,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", - " (array([[789.09800008],\n", - " [457.78063526]]),\n", - " 189,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943662460.jpg'),\n", - " (array([[788.41583562],\n", - " [463.28075587]]),\n", - " 191,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943862460.jpg'),\n", - " (array([[812.18449213],\n", - " [459.55645515]]),\n", - " 204,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944912460.jpg'),\n", - " (array([[790.58666158],\n", - " [460.88889639]]),\n", - " 194,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944112460.jpg'),\n", - " (array([[-797.38121449],\n", - " [ 405.53459661]]),\n", - " 112,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", - " (array([[794.23464216],\n", - " [457.50050424]]),\n", - " 197,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944362460.jpg'),\n", - " (array([[795.11779981],\n", - " [459.98121721]]),\n", - " 199,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944512460.jpg'),\n", - " (array([[893.44238538],\n", - " [468.14847035]]),\n", - " 212,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945662460.jpg'),\n", - " (array([[805.22139403],\n", - " [459.92707716]]),\n", - " 202,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944762460.jpg'),\n", - " (array([[-266.29342704],\n", - " [ 424.80542208]]),\n", - " 120,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", - " (array([[829.30745172],\n", - " [458.48075077]]),\n", - " 205,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945112460.jpg'),\n", - " (array([[844.17659115],\n", - " [462.71080612]]),\n", - " 207,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945262460.jpg'),\n", - " (array([[874.87146349],\n", - " [467.13315545]]),\n", - " 210,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945512460.jpg'),\n", - " (array([[ 69.65056518],\n", - " [439.00112112]]),\n", - " 128,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg'),\n", - " (array([[306.66199249],\n", - " [447.03159187]]),\n", - " 136,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939162460.jpg'),\n", - " (array([[494.87040495],\n", - " [456.55090027]]),\n", - " 144,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939862460.jpg'),\n", - " (array([[611.7812464 ],\n", - " [464.42618046]]),\n", - " 152,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940512460.jpg'),\n", - " (array([[693.5171868 ],\n", - " [470.30409693]]),\n", - " 160,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941162460.jpg'),\n", - " (array([[759.46744922],\n", - " [474.89608853]]),\n", - " 168,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941862460.jpg'),\n", - " (array([[783.22830111],\n", - " [475.64229809]]),\n", - " 176,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942612460.jpg'),\n", - " (array([[788.39208992],\n", - " [464.68102699]]),\n", - " 184,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943262460.jpg'),\n", - " (array([[791.20429527],\n", - " [462.21286518]]),\n", - " 192,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943912478.jpg'),\n", - " (array([[799.67099818],\n", - " [459.23572459]]),\n", - " 200,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944612460.jpg'),\n", - " (array([[856.795014 ],\n", - " [464.38279264]]),\n", - " 208,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945362460.jpg')],\n", - " [(array([[283.15777714],\n", - " [425.88532419]]),\n", - " 3,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", - " (array([[484.67367196],\n", - " [433.13642919]]),\n", - " 11,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", - " (array([[372.08227411],\n", - " [437.345324 ]]),\n", - " 1,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg'),\n", - " (array([[467.63525903],\n", - " [438.16433163]]),\n", - " 9,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", - " (array([[434.46717347],\n", - " [438.42178867]]),\n", - " 6,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", - " (array([[420.69624213],\n", - " [437.7224591 ]]),\n", - " 5,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", - " (array([[413.76811332],\n", - " [435.91429809]]),\n", - " 4,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", - " (array([[566.73936628],\n", - " [453.35627337]]),\n", - " 14,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", - " (array([[555.51264776],\n", - " [441.09677645]]),\n", - " 12,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", - " (array([[472.27885177],\n", - " [446.63939916]]),\n", - " 2,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", - " (array([[563.94195844],\n", - " [449.17548074]]),\n", - " 13,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", - " (array([[520.55604962],\n", - " [445.85603854]]),\n", - " 7,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", - " (array([[543.10876302],\n", - " [442.59080844]]),\n", - " 10,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", - " (array([[525.27018675],\n", - " [445.82943002]]),\n", - " 8,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg')],\n", - " [(array([[933.37494733],\n", - " [498.27868085]]),\n", - " 3,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", - " (array([[950.96387063],\n", - " [489.77816603]]),\n", - " 11,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", - " (array([[993.61748049],\n", - " [502.99313138]]),\n", - " 19,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", - " (array([[920.9280666 ],\n", - " [498.68209001]]),\n", - " 1,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg'),\n", - " (array([[944.52457547],\n", - " [495.60531558]]),\n", - " 9,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", - " (array([[978.72067244],\n", - " [502.30962341]]),\n", - " 17,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", - " (array([[933.35634475],\n", - " [499.61018612]]),\n", - " 6,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", - " (array([[1009.32957513],\n", - " [ 503.41668981]]),\n", - " 25,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", - " (array([[926.6692726 ],\n", - " [494.75125058]]),\n", - " 5,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", - " (array([[925.9933551 ],\n", - " [493.40049797]]),\n", - " 4,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", - " (array([[956.2771314],\n", - " [500.537134 ]]),\n", - " 14,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", - " (array([[950.32926646],\n", - " [486.37428221]]),\n", - " 12,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", - " (array([[919.39614895],\n", - " [493.4156123 ]]),\n", - " 2,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", - " (array([[955.29768198],\n", - " [495.95917398]]),\n", - " 13,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", - " (array([[982.66001664],\n", - " [489.28507166]]),\n", - " 22,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", - " (array([[927.31400232],\n", - " [487.74019957]]),\n", - " 7,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", - " (array([[935.90924164],\n", - " [481.33339553]]),\n", - " 10,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", - " (array([[973.8085002],\n", - " [488.7475178]]),\n", - " 20,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", - " (array([[978.21214731],\n", - " [488.04612651]]),\n", - " 21,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", - " (array([[950.89653172],\n", - " [495.92977629]]),\n", - " 15,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", - " (array([[962.00712165],\n", - " [486.77022112]]),\n", - " 18,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", - " (array([[980.28929683],\n", - " [487.74871123]]),\n", - " 23,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", - " (array([[989.23473515],\n", - " [492.52868671]]),\n", - " 26,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", - " (array([[927.94875737],\n", - " [485.16366203]]),\n", - " 8,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", - " (array([[953.82729878],\n", - " [488.63164616]]),\n", - " 16,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", - " (array([[984.79038496],\n", - " [490.44569792]]),\n", - " 24,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg')],\n", - " [(array([[1053.25706639],\n", - " [ 500.95476452]]),\n", - " 3,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", - " (array([[1107.16877484],\n", - " [ 496.4991548 ]]),\n", - " 11,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", - " (array([[1204.25014369],\n", - " [ 514.20907029]]),\n", - " 19,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", - " (array([[1334.89024279],\n", - " [ 531.80018505]]),\n", - " 27,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", - " (array([[1564.93524775],\n", - " [ 561.71914075]]),\n", - " 35,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", - " (array([[2158.36851325],\n", - " [ 640.21170018]]),\n", - " 43,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", - " (array([[1039.8756684 ],\n", - " [ 502.90792834]]),\n", - " 1,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg'),\n", - " (array([[4778.54140024],\n", - " [ 961.80227879]]),\n", - " 51,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", - " (array([[1091.2413688 ],\n", - " [ 500.44724469]]),\n", - " 9,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", - " (array([[-3277.05891187],\n", - " [ -13.70541524]]),\n", - " 59,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", - " (array([[1168.93265591],\n", - " [ 511.05879271]]),\n", - " 17,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", - " (array([[1067.95697079],\n", - " [ 504.41159352]]),\n", - " 6,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", - " (array([[-403.19595065],\n", - " [ 313.66412365]]),\n", - " 67,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", - " (array([[1294.84695941],\n", - " [ 526.22839677]]),\n", - " 25,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", - " (array([[1048.13166787],\n", - " [ 501.08653408]]),\n", - " 5,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", - " (array([[1045.51172742],\n", - " [ 499.59369039]]),\n", - " 4,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", - " (array([[1116.83545765],\n", - " [ 510.37145659]]),\n", - " 14,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", - " (array([[ 84.052647 ],\n", - " [360.8300367]]),\n", - " 75,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", - " (array([[1431.12030745],\n", - " [ 539.59422798]]),\n", - " 33,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", - " (array([[1101.53957175],\n", - " [ 494.79818763]]),\n", - " 12,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", - " (array([[1026.87446264],\n", - " [ 496.69646185]]),\n", - " 2,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", - " (array([[1103.84894452],\n", - " [ 502.64698755]]),\n", - " 13,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", - " (array([[1201.74077026],\n", - " [ 508.27287331]]),\n", - " 22,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", - " (array([[296.78859265],\n", - " [400.91263538]]),\n", - " 83,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", - " (array([[1058.48653781],\n", - " [ 498.25577547]]),\n", - " 7,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", - " (array([[1661.89639706],\n", - " [ 565.33359452]]),\n", - " 41,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", - " (array([[1067.85474231],\n", - " [ 490.47743489]]),\n", - " 10,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", - " (array([[1153.25120031],\n", - " [ 502.45301353]]),\n", - " 20,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", - " (array([[1165.58783913],\n", - " [ 502.70663904]]),\n", - " 21,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", - " (array([[439.87856697],\n", - " [413.14190247]]),\n", - " 91,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", - " (array([[1280.7794978],\n", - " [ 516.1449975]]),\n", - " 30,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", - " (array([[1089.13916264],\n", - " [ 503.48943606]]),\n", - " 15,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", - " (array([[1805.14391603],\n", - " [ 569.73263363]]),\n", - " 49,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", - " (array([[1116.636023 ],\n", - " [ 497.23983042]]),\n", - " 18,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", - " (array([[1221.56339287],\n", - " [ 507.28996677]]),\n", - " 28,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", - " (array([[1228.04723996],\n", - " [ 507.38871642]]),\n", - " 29,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", - " (array([[572.36040358],\n", - " [433.75936269]]),\n", - " 99,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", - " (array([[1321.43455812],\n", - " [ 519.40646308]]),\n", - " 38,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", - " (array([[1140.2135718 ],\n", - " [ 495.12109111]]),\n", - " 23,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", - " (array([[2053.46170757],\n", - " [ 579.35460804]]),\n", - " 57,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", - " (array([[1165.53385074],\n", - " [ 501.04518259]]),\n", - " 26,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", - " (array([[1291.45060865],\n", - " [ 513.55610905]]),\n", - " 36,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", - " (array([[1311.10570405],\n", - " [ 517.73907576]]),\n", - " 37,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", - " (array([[636.31827336],\n", - " [441.8084792 ]]),\n", - " 107,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", - " (array([[1408.59390448],\n", - " [ 514.84209537]]),\n", - " 46,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", - " (array([[1188.23989121],\n", - " [ 495.77397774]]),\n", - " 31,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", - " (array([[2374.08112865],\n", - " [ 586.04611379]]),\n", - " 65,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", - " (array([[1382.73100054],\n", - " [ 514.21252368]]),\n", - " 45,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", - " (array([[1221.7193652 ],\n", - " [ 501.69048164]]),\n", - " 34,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", - " (array([[1359.95751177],\n", - " [ 513.86752704]]),\n", - " 44,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", - " (array([[499.684133 ],\n", - " [434.97088008]]),\n", - " 115,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", - " (array([[1502.3026943 ],\n", - " [ 522.78586499]]),\n", - " 54,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", - " (array([[1243.58356603],\n", - " [ 506.33288697]]),\n", - " 39,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", - " (array([[1281.00019101],\n", - " [ 504.46036931]]),\n", - " 42,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", - " (array([[3587.68303396],\n", - " [ 708.66984775]]),\n", - " 73,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", - " (array([[1469.86310046],\n", - " [ 523.64649969]]),\n", - " 53,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", - " (array([[1391.69684286],\n", - " [ 514.14863133]]),\n", - " 52,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", - " (array([[560.26582529],\n", - " [440.68079204]]),\n", - " 123,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", - " (array([[1631.29264598],\n", - " [ 523.51230296]]),\n", - " 62,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", - " (array([[1308.26946724],\n", - " [ 501.41051653]]),\n", - " 47,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", - " (array([[748.2016886 ],\n", - " [455.53857378]]),\n", - " 131,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", - " (array([[1501.15123802],\n", - " [ 508.12856077]]),\n", - " 60,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", - " (array([[3411.27661054],\n", - " [ 651.76979936]]),\n", - " 81,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", - " (array([[1324.45759309],\n", - " [ 500.60974957]]),\n", - " 50,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", - " (array([[1529.01587824],\n", - " [ 507.852805 ]]),\n", - " 61,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", - " (array([[1902.46134676],\n", - " [ 523.96155564]]),\n", - " 70,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", - " (array([[1380.68577512],\n", - " [ 497.90597943]]),\n", - " 55,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", - " (array([[5993.27002968],\n", - " [ 806.80711019]]),\n", - " 89,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", - " (array([[1709.53523193],\n", - " [ 507.2281716 ]]),\n", - " 68,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", - " (array([[1430.35627535],\n", - " [ 501.94141508]]),\n", - " 58,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", - " (array([[2376.23924035],\n", - " [ 567.74793193]]),\n", - " 78,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", - " (array([[1527.24126845],\n", - " [ 504.72714212]]),\n", - " 63,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", - " (array([[28221.76804952],\n", - " [ 1882.34184596]]),\n", - " 97,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", - " (array([[2085.62618684],\n", - " [ 532.19834793]]),\n", - " 76,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", - " (array([[1613.60161954],\n", - " [ 492.30274906]]),\n", - " 66,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", - " (array([[3303.16290148],\n", - " [ 622.72456572]]),\n", - " 86,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", - " (array([[1708.9877025 ],\n", - " [ 499.00848209]]),\n", - " 69,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", - " (array([[1773.39110962],\n", - " [ 497.70237665]]),\n", - " 71,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", - " (array([[-6656.31008078],\n", - " [ 171.06285964]]),\n", - " 105,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", - " (array([[2667.85532218],\n", - " [ 575.53031356]]),\n", - " 84,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", - " (array([[1950.56739385],\n", - " [ 519.37940777]]),\n", - " 74,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", - " (array([[5689.24999186],\n", - " [ 724.82432229]]),\n", - " 94,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", - " (array([[2109.78367915],\n", - " [ 523.09084581]]),\n", - " 77,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", - " (array([[2220.15405082],\n", - " [ 537.56075433]]),\n", - " 79,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", - " (array([[-2377.02013911],\n", - " [ 323.20360867]]),\n", - " 113,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", - " (array([[2456.22121605],\n", - " [ 553.03022731]]),\n", - " 82,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", - " (array([[4286.86300655],\n", - " [ 631.90912707]]),\n", - " 92,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", - " (array([[-481204.65997376],\n", - " [ -18567.50762167]]),\n", - " 102,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", - " (array([[2768.61655285],\n", - " [ 574.05397001]]),\n", - " 85,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", - " (array([[3020.87365256],\n", - " [ 584.30994567]]),\n", - " 87,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", - " (array([[1125.70209834],\n", - " [ 474.97553548]]),\n", - " 8,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", - " (array([[-1221.63900481],\n", - " [ 377.6812799 ]]),\n", - " 121,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", - " (array([[15696.17848042],\n", - " [ 1042.76455542]]),\n", - " 100,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", - " (array([[3555.64504557],\n", - " [ 587.87420069]]),\n", - " 90,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", - " (array([[-4466.31834931],\n", - " [ 260.3979133 ]]),\n", - " 110,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", - " (array([[4382.81706078],\n", - " [ 636.71375374]]),\n", - " 93,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", - " (array([[5494.63794887],\n", - " [ 693.24593536]]),\n", - " 95,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", - " (array([[1212.28560393],\n", - " [ 479.09836989]]),\n", - " 16,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", - " (array([[-541.80353776],\n", - " [ 407.59297015]]),\n", - " 129,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", - " (array([[8656.27863036],\n", - " [ 783.09615685]]),\n", - " 98,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", - " (array([[-6856.33988085],\n", - " [ 161.41763284]]),\n", - " 108,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", - " (array([[-1870.91419929],\n", - " [ 378.16607543]]),\n", - " 118,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", - " (array([[25870.91006585],\n", - " [ 1337.27294498]]),\n", - " 101,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", - " (array([[-80686.60808567],\n", - " [ -2120.92652789]]),\n", - " 103,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", - " (array([[1322.516277 ],\n", - " [ 475.16665841]]),\n", - " 24,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", - " (array([[-10241.75020993],\n", - " [ 123.21732751]]),\n", - " 106,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", - " (array([[-2107.13166982],\n", - " [ 359.877783 ]]),\n", - " 116,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", - " (array([[-757.54935632],\n", - " [ 399.29420289]]),\n", - " 126,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", - " (array([[-4946.34880702],\n", - " [ 266.14437773]]),\n", - " 109,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", - " (array([[-3600.54301024],\n", - " [ 307.14823965]]),\n", - " 111,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", - " (array([[1455.18073006],\n", - " [ 476.8773895 ]]),\n", - " 32,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", - " (array([[-967.88255457],\n", - " [ 387.31124517]]),\n", - " 124,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", - " (array([[-2321.50797297],\n", - " [ 341.25704003]]),\n", - " 114,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", - " (array([[-258.96888633],\n", - " [ 423.62233616]]),\n", - " 134,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", - " (array([[-1737.61619911],\n", - " [ 378.38473884]]),\n", - " 117,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", - " (array([[-1457.78688921],\n", - " [ 384.00288417]]),\n", - " 119,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", - " (array([[1627.20258736],\n", - " [ 488.78582826]]),\n", - " 40,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", - " (array([[-1091.89160259],\n", - " [ 383.45404604]]),\n", - " 122,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", - " (array([[-311.3515231 ],\n", - " [ 419.19624566]]),\n", - " 132,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", - " (array([[-751.02410044],\n", - " [ 393.95225104]]),\n", - " 125,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", - " (array([[-620.54040802],\n", - " [ 407.71630517]]),\n", - " 127,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", - " (array([[1828.86732377],\n", - " [ 491.24421995]]),\n", - " 48,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", - " (array([[-434.70644789],\n", - " [ 417.63144388]]),\n", - " 130,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", - " (array([[-282.93833065],\n", - " [ 420.86939849]]),\n", - " 133,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", - " (array([[-156.06648914],\n", - " [ 425.46758047]]),\n", - " 135,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", - " (array([[2109.32996025],\n", - " [ 497.14429233]]),\n", - " 56,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", - " (array([[2338.78799712],\n", - " [ 498.70514257]]),\n", - " 64,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", - " (array([[2781.39769207],\n", - " [ 529.65348122]]),\n", - " 72,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", - " (array([[3651.61047676],\n", - " [ 590.5879429 ]]),\n", - " 80,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", - " (array([[6978.58087313],\n", - " [ 740.88600753]]),\n", - " 88,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", - " (array([[72129.75325798],\n", - " [ 3604.66725825]]),\n", - " 96,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", - " (array([[-5665.15013961],\n", - " [ 238.54625946]]),\n", - " 104,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", - " (array([[-2191.11689052],\n", - " [ 346.431 ]]),\n", - " 112,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", - " (array([[-1028.89031745],\n", - " [ 390.18054555]]),\n", - " 120,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", - " (array([[-455.25374332],\n", - " [ 414.97176306]]),\n", - " 128,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg')],\n", - " [(array([[686.77815539],\n", - " [471.26054991]]),\n", - " 3,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", - " (array([[683.17036174],\n", - " [463.07061817]]),\n", - " 11,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", - " (array([[688.57004235],\n", - " [471.033247 ]]),\n", - " 19,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", - " (array([[685.31612136],\n", - " [474.43234574]]),\n", - " 27,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", - " (array([[686.1366875 ],\n", - " [475.17504614]]),\n", - " 35,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", - " (array([[682.3823281 ],\n", - " [472.29562409]]),\n", - " 43,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", - " (array([[685.60176189],\n", - " [475.98172007]]),\n", - " 1,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg'),\n", - " (array([[679.66334909],\n", - " [479.76077672]]),\n", - " 51,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", - " (array([[683.60739045],\n", - " [469.09259118]]),\n", - " 9,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", - " (array([[681.19888098],\n", - " [480.32884123]]),\n", - " 59,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", - " (array([[685.49929459],\n", - " [470.07232845]]),\n", - " 17,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", - " (array([[682.93875504],\n", - " [473.12829739]]),\n", - " 6,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", - " (array([[703.28847803],\n", - " [472.83462247]]),\n", - " 67,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", - " (array([[686.63585742],\n", - " [473.85886666]]),\n", - " 25,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", - " (array([[683.76399592],\n", - " [472.56803082]]),\n", - " 5,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", - " (array([[684.82622547],\n", - " [471.32598173]]),\n", - " 4,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", - " (array([[683.56452228],\n", - " [475.13821745]]),\n", - " 14,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", - " (array([[773.83645905],\n", - " [478.52700512]]),\n", - " 75,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", - " (array([[685.2213989 ],\n", - " [471.58846754]]),\n", - " 33,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", - " (array([[684.017947 ],\n", - " [462.37906501]]),\n", - " 12,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", - " (array([[685.08791786],\n", - " [472.51307795]]),\n", - " 2,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", - " (array([[684.79014881],\n", - " [470.24455769]]),\n", - " 13,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", - " (array([[688.23538999],\n", - " [467.4389604 ]]),\n", - " 22,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", - " (array([[881.61478011],\n", - " [500.05051675]]),\n", - " 83,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", - " (array([[684.23975435],\n", - " [469.51936622]]),\n", - " 7,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", - " (array([[684.2693605 ],\n", - " [470.65546049]]),\n", - " 41,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", - " (array([[683.89841469],\n", - " [463.13949582]]),\n", - " 10,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", - " (array([[688.89423817],\n", - " [467.65951276]]),\n", - " 20,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", - " (array([[688.61382536],\n", - " [466.20188053]]),\n", - " 21,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", - " (array([[1056.34467541],\n", - " [ 503.92914915]]),\n", - " 91,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", - " (array([[683.44923997],\n", - " [468.91756026]]),\n", - " 30,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", - " (array([[683.46030636],\n", - " [474.81711845]]),\n", - " 15,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", - " (array([[681.90421926],\n", - " [472.04571551]]),\n", - " 49,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", - " (array([[687.00902325],\n", - " [467.60152187]]),\n", - " 18,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", - " (array([[684.48884978],\n", - " [469.85677728]]),\n", - " 28,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", - " (array([[683.46344414],\n", - " [469.14045664]]),\n", - " 29,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", - " (array([[1325.27546975],\n", - " [ 518.98271238]]),\n", - " 99,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", - " (array([[685.15335732],\n", - " [473.42098743]]),\n", - " 38,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", - " (array([[688.14966027],\n", - " [466.59565516]]),\n", - " 23,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", - " (array([[680.3947589 ],\n", - " [474.85812184]]),\n", - " 57,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", - " (array([[685.5069017 ],\n", - " [470.63869342]]),\n", - " 26,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", - " (array([[685.48319581],\n", - " [471.98090409]]),\n", - " 36,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", - " (array([[685.33434066],\n", - " [473.4022731 ]]),\n", - " 37,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", - " (array([[1716.42217144],\n", - " [ 537.30729581]]),\n", - " 107,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", - " (array([[681.15179519],\n", - " [462.84628567]]),\n", - " 46,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", - " (array([[684.76622397],\n", - " [466.22783067]]),\n", - " 31,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", - " (array([[691.06193262],\n", - " [469.73672991]]),\n", - " 65,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", - " (array([[680.52565709],\n", - " [465.13159953]]),\n", - " 45,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", - " (array([[685.39233818],\n", - " [469.24638398]]),\n", - " 34,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", - " (array([[681.14226307],\n", - " [466.38773698]]),\n", - " 44,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", - " (array([[2331.8735357],\n", - " [ 573.5244468]]),\n", - " 115,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", - " (array([[679.66680635],\n", - " [470.96466303]]),\n", - " 54,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", - " (array([[684.36411741],\n", - " [470.50586854]]),\n", - " 39,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", - " (array([[683.557201 ],\n", - " [465.32862551]]),\n", - " 42,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", - " (array([[756.20760677],\n", - " [471.60167363]]),\n", - " 73,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", - " (array([[677.84203224],\n", - " [472.1976785 ]]),\n", - " 53,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", - " (array([[678.57618059],\n", - " [471.7678324 ]]),\n", - " 52,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", - " (array([[4182.34017041],\n", - " [ 696.20692505]]),\n", - " 123,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", - " (array([[683.98431605],\n", - " [472.13109532]]),\n", - " 62,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", - " (array([[681.16949598],\n", - " [462.08335263]]),\n", - " 47,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", - " (array([[42987.89049207],\n", - " [ 3209.9668267 ]]),\n", - " 131,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", - " (array([[682.42840526],\n", - " [471.13120662]]),\n", - " 60,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", - " (array([[844.76682629],\n", - " [475.83979496]]),\n", - " 81,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", - " (array([[682.00726987],\n", - " [469.80775329]]),\n", - " 50,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", - " (array([[683.1169029 ],\n", - " [471.28166882]]),\n", - " 61,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", - " (array([[721.87916686],\n", - " [461.4648927 ]]),\n", - " 70,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", - " (array([[679.15015754],\n", - " [467.40402867]]),\n", - " 55,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", - " (array([[-3691.99153875],\n", - " [ 202.55936422]]),\n", - " 139,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939412460.jpg'),\n", - " (array([[1010.04280689],\n", - " [ 488.68183645]]),\n", - " 89,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", - " (array([[709.64420979],\n", - " [459.46000608]]),\n", - " 68,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", - " (array([[681.10633065],\n", - " [468.84000919]]),\n", - " 58,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", - " (array([[804.14206032],\n", - " [458.14748476]]),\n", - " 78,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", - " (array([[686.80563145],\n", - " [465.94599498]]),\n", - " 63,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", - " (array([[-1303.88178446],\n", - " [ 343.69826367]]),\n", - " 147,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940112460.jpg'),\n", - " (array([[1227.52886158],\n", - " [ 496.85849562]]),\n", - " 97,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", - " (array([[787.68121322],\n", - " [457.23049275]]),\n", - " 76,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", - " (array([[701.15594345],\n", - " [458.38728051]]),\n", - " 66,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", - " (array([[941.11976007],\n", - " [485.1110166 ]]),\n", - " 86,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", - " (array([[717.32714853],\n", - " [454.47622273]]),\n", - " 69,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", - " (array([[731.37728725],\n", - " [456.22770882]]),\n", - " 71,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", - " (array([[-656.34972575],\n", - " [ 399.9677691 ]]),\n", - " 155,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940762460.jpg'),\n", - " (array([[1569.13232878],\n", - " [ 501.1225268 ]]),\n", - " 105,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", - " (array([[893.43781142],\n", - " [480.37100818]]),\n", - " 84,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", - " (array([[769.4125909 ],\n", - " [461.72540344]]),\n", - " 74,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", - " (array([[1138.59888097],\n", - " [ 487.34109955]]),\n", - " 94,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", - " (array([[799.35901657],\n", - " [448.98940018]]),\n", - " 77,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", - " (array([[818.22175364],\n", - " [456.05008157]]),\n", - " 79,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", - " (array([[-319.61452039],\n", - " [ 432.02014729]]),\n", - " 163,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941412460.jpg'),\n", - " (array([[2149.0351738 ],\n", - " [ 527.11890251]]),\n", - " 113,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", - " (array([[862.70428209],\n", - " [473.65504115]]),\n", - " 82,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", - " (array([[1089.6586519 ],\n", - " [ 479.01664413]]),\n", - " 92,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", - " (array([[1441.00380465],\n", - " [ 491.18380522]]),\n", - " 102,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", - " (array([[916.79982323],\n", - " [475.28504831]]),\n", - " 85,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", - " (array([[955.69454664],\n", - " [479.82334605]]),\n", - " 87,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", - " (array([[684.31451879],\n", - " [459.40863082]]),\n", - " 8,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", - " (array([[-116.12589652],\n", - " [ 447.15902898]]),\n", - " 171,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942112460.jpg'),\n", - " (array([[3351.39573425],\n", - " [ 581.16415696]]),\n", - " 121,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", - " (array([[1370.23864748],\n", - " [ 492.86274415]]),\n", - " 100,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", - " (array([[1025.00018522],\n", - " [ 478.65078761]]),\n", - " 90,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", - " (array([[1903.21294578],\n", - " [ 511.16497341]]),\n", - " 110,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", - " (array([[1105.59296697],\n", - " [ 483.21783526]]),\n", - " 93,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", - " (array([[1172.40538056],\n", - " [ 492.54809648]]),\n", - " 95,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", - " (array([[684.99152167],\n", - " [461.97545487]]),\n", - " 16,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", - " (array([[ -2.92476758],\n", - " [438.44624004]]),\n", - " 179,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942862460.jpg'),\n", - " (array([[12941.91658704],\n", - " [ 1020.92200273]]),\n", - " 129,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", - " (array([[1284.5960526 ],\n", - " [ 494.37220758]]),\n", - " 98,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", - " (array([[1786.09899898],\n", - " [ 516.6453788 ]]),\n", - " 108,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", - " (array([[2729.20785929],\n", - " [ 557.73990454]]),\n", - " 118,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", - " (array([[1393.46411083],\n", - " [ 501.73161866]]),\n", - " 101,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", - " (array([[1489.32532897],\n", - " [ 503.31667068]]),\n", - " 103,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", - " (array([[688.22874133],\n", - " [463.09677637]]),\n", - " 24,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", - " (array([[ 63.46853166],\n", - " [433.13005421]]),\n", - " 187,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943512460.jpg'),\n", - " (array([[-5201.35563953],\n", - " [ 135.3359585 ]]),\n", - " 137,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939262460.jpg'),\n", - " (array([[1658.38905451],\n", - " [ 511.68490134]]),\n", - " 106,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", - " (array([[2474.67905163],\n", - " [ 557.50965587]]),\n", - " 116,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", - " (array([[6187.08828666],\n", - " [ 759.24317438]]),\n", - " 126,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", - " (array([[1823.05816971],\n", - " [ 523.34252981]]),\n", - " 109,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", - " (array([[1990.98637458],\n", - " [ 530.11649661]]),\n", - " 111,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", - " (array([[684.8956205 ],\n", - " [461.77401006]]),\n", - " 32,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", - " (array([[119.86104099],\n", - " [430.6276968 ]]),\n", - " 195,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944162460.jpg'),\n", - " (array([[-1669.22977907],\n", - " [ 324.96282818]]),\n", - " 145,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939912460.jpg'),\n", - " (array([[4470.38960373],\n", - " [ 675.88138707]]),\n", - " 124,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", - " (array([[2268.22461233],\n", - " [ 550.4957901 ]]),\n", - " 114,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", - " (array([[-13102.85824844],\n", - " [ -305.41493762]]),\n", - " 134,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", - " (array([[2636.86763091],\n", - " [ 561.92946547]]),\n", - " 117,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", - " (array([[189.74538582],\n", - " [434.445323 ]]),\n", - " 203,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944862460.jpg'),\n", - " (array([[2947.89371538],\n", - " [ 578.0779607 ]]),\n", - " 119,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", - " (array([[684.67951095],\n", - " [463.53410636]]),\n", - " 40,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", - " (array([[-761.66627794],\n", - " [ 386.61869497]]),\n", - " 153,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940612460.jpg'),\n", - " (array([[3716.48610528],\n", - " [ 639.07684418]]),\n", - " 122,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", - " (array([[-61721.99268843],\n", - " [ -3080.36243488]]),\n", - " 132,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", - " (array([[-2382.18628413],\n", - " [ 294.71844363]]),\n", - " 142,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939662460.jpg'),\n", - " (array([[5175.56257669],\n", - " [ 707.54556204]]),\n", - " 125,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", - " (array([[321.39333085],\n", - " [444.81448951]]),\n", - " 211,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945612460.jpg'),\n", - " (array([[6878.16793621],\n", - " [ 790.91583985]]),\n", - " 127,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", - " (array([[681.50760037],\n", - " [461.06962015]]),\n", - " 48,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", - " (array([[-384.65169648],\n", - " [ 412.83632177]]),\n", - " 161,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941262460.jpg'),\n", - " (array([[-3050.75275629],\n", - " [ 255.70186003]]),\n", - " 140,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939512460.jpg'),\n", - " (array([[16776.52473354],\n", - " [ 1317.61779952]]),\n", - " 130,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", - " (array([[-989.3711678 ],\n", - " [ 366.65100545]]),\n", - " 150,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940362460.jpg'),\n", - " (array([[-27897.77755375],\n", - " [ -1154.00134739]]),\n", - " 133,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", - " (array([[449.43932772],\n", - " [454.28627319]]),\n", - " 219,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946262460.jpg'),\n", - " (array([[-8275.50863058],\n", - " [ -26.71590725]]),\n", - " 135,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", - " (array([[-159.6806175 ],\n", - " [ 429.35987422]]),\n", - " 169,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941912460.jpg'),\n", - " (array([[680.02696811],\n", - " [466.8522811 ]]),\n", - " 56,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", - " (array([[-1232.76192871],\n", - " [ 346.8863571 ]]),\n", - " 148,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940162460.jpg'),\n", - " (array([[-4096.40335109],\n", - " [ 193.25030334]]),\n", - " 138,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939362460.jpg'),\n", - " (array([[-503.42371732],\n", - " [ 399.43231115]]),\n", - " 158,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941012460.jpg'),\n", - " (array([[-2580.63665454],\n", - " [ 289.75004286]]),\n", - " 141,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939612460.jpg'),\n", - " (array([[-2051.45443133],\n", - " [ 318.17850644]]),\n", - " 143,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939762460.jpg'),\n", - " (array([[-28.55682445],\n", - " [440.27553524]]),\n", - " 177,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942662460.jpg'),\n", - " (array([[690.0434449 ],\n", - " [463.28597576]]),\n", - " 64,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", - " (array([[-592.64054232],\n", - " [ 395.19877194]]),\n", - " 156,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940862460.jpg'),\n", - " (array([[-1469.62829127],\n", - " [ 334.21951387]]),\n", - " 146,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940012460.jpg'),\n", - " (array([[-231.99455095],\n", - " [ 424.40667869]]),\n", - " 166,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941662460.jpg'),\n", - " (array([[-1102.55842 ],\n", - " [ 366.66996016]]),\n", - " 149,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940262460.jpg'),\n", - " (array([[-937.19517387],\n", - " [ 378.72499547]]),\n", - " 151,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940412460.jpg'),\n", - " (array([[ 47.34819586],\n", - " [434.95270191]]),\n", - " 185,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943362460.jpg'),\n", - " (array([[-725.92922467],\n", - " [ 394.55851052]]),\n", - " 154,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940662460.jpg'),\n", - " (array([[-282.84239271],\n", - " [ 425.2515132 ]]),\n", - " 164,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941512460.jpg'),\n", - " (array([[740.95399894],\n", - " [460.91449355]]),\n", - " 72,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", - " (array([[-71.50717794],\n", - " [440.75047124]]),\n", - " 174,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942362460.jpg'),\n", - " (array([[-561.46615363],\n", - " [ 403.2083092 ]]),\n", - " 157,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940912460.jpg'),\n", - " (array([[109.41345592],\n", - " [436.92667097]]),\n", - " 193,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944012460.jpg'),\n", - " (array([[-452.41867864],\n", - " [ 412.53402613]]),\n", - " 159,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941112460.jpg'),\n", - " (array([[-341.24879939],\n", - " [ 423.80555162]]),\n", - " 162,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941362460.jpg'),\n", - " (array([[-106.32625702],\n", - " [ 437.37166543]]),\n", - " 172,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942162460.jpg'),\n", - " (array([[ 23.27132126],\n", - " [442.39291349]]),\n", - " 182,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943112460.jpg'),\n", - " (array([[835.68200871],\n", - " [462.80472608]]),\n", - " 80,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", - " (array([[-248.9797618 ],\n", - " [ 430.81914014]]),\n", - " 165,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941612460.jpg'),\n", - " (array([[166.33767186],\n", - " [439.33247158]]),\n", - " 201,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944662460.jpg'),\n", - " (array([[-201.97429034],\n", - " [ 434.4083783 ]]),\n", - " 167,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941762460.jpg'),\n", - " (array([[ 1.88312334],\n", - " [440.48790739]]),\n", - " 180,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942912460.jpg'),\n", - " (array([[-136.7464831],\n", - " [ 441.6222201]]),\n", - " 170,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942012460.jpg'),\n", - " (array([[ 83.47839011],\n", - " [439.67069509]]),\n", - " 190,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943762460.jpg'),\n", - " (array([[983.60177459],\n", - " [481.90926431]]),\n", - " 88,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", - " (array([[-88.55728603],\n", - " [442.86446755]]),\n", - " 173,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942262460.jpg'),\n", - " (array([[283.18244703],\n", - " [451.4045993 ]]),\n", - " 209,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945412460.jpg'),\n", - " (array([[-48.41842823],\n", - " [454.15545389]]),\n", - " 175,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942512460.jpg'),\n", - " (array([[-15.50248503],\n", - " [445.71771114]]),\n", - " 178,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942762460.jpg'),\n", - " (array([[141.93320323],\n", - " [439.63764733]]),\n", - " 198,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944412460.jpg'),\n", - " (array([[ 74.52118256],\n", - " [439.1457565 ]]),\n", - " 188,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943612460.jpg'),\n", - " (array([[1190.92630348],\n", - " [ 489.04004761]]),\n", - " 96,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", - " (array([[ 11.97191802],\n", - " [444.41950582]]),\n", - " 181,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943012460.jpg'),\n", - " (array([[418.64783679],\n", - " [460.84100923]]),\n", - " 217,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946112460.jpg'),\n", - " (array([[ 28.90251777],\n", - " [446.52797358]]),\n", - " 183,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943162460.jpg'),\n", - " (array([[235.64714993],\n", - " [444.18932109]]),\n", - " 206,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945162460.jpg'),\n", - " (array([[ 51.71842419],\n", - " [441.4386851 ]]),\n", - " 186,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943412460.jpg'),\n", - " (array([[129.09870561],\n", - " [439.42827085]]),\n", - " 196,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944262460.jpg'),\n", - " (array([[1515.17634227],\n", - " [ 494.94526422]]),\n", - " 104,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", - " (array([[ 77.93270851],\n", - " [439.75545149]]),\n", - " 189,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943662460.jpg'),\n", - " (array([[ 93.45069573],\n", - " [443.08722686]]),\n", - " 191,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943862460.jpg'),\n", - " (array([[370.76923126],\n", - " [456.36836043]]),\n", - " 214,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945862460.jpg'),\n", - " (array([[195.52912659],\n", - " [443.89036799]]),\n", - " 204,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944912460.jpg'),\n", - " (array([[115.83208666],\n", - " [441.6684963 ]]),\n", - " 194,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944112460.jpg'),\n", - " (array([[2040.13792273],\n", - " [ 514.25304221]]),\n", - " 112,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", - " (array([[138.17662549],\n", - " [440.2931406 ]]),\n", - " 197,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944362460.jpg'),\n", - " (array([[149.47211286],\n", - " [441.43237189]]),\n", - " 199,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944512460.jpg'),\n", - " (array([[514.83420157],\n", - " [471.28210279]]),\n", - " 222,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946612460.jpg'),\n", - " (array([[330.54413198],\n", - " [454.09212648]]),\n", - " 212,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945662460.jpg'),\n", - " (array([[177.56448812],\n", - " [443.81816251]]),\n", - " 202,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944762460.jpg'),\n", - " (array([[3208.50306227],\n", - " [ 563.40787867]]),\n", - " 120,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", - " (array([[227.12025733],\n", - " [444.3877628 ]]),\n", - " 205,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945112460.jpg'),\n", - " (array([[253.3583807 ],\n", - " [448.45969716]]),\n", - " 207,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945262460.jpg'),\n", - " (array([[479.81723166],\n", - " [464.10161256]]),\n", - " 220,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946412460.jpg'),\n", - " (array([[302.35386166],\n", - " [453.71965637]]),\n", - " 210,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945512460.jpg'),\n", - " (array([[8929.49752438],\n", - " [ 811.17189947]]),\n", - " 128,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg'),\n", - " (array([[350.85764559],\n", - " [453.31490687]]),\n", - " 213,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945762460.jpg'),\n", - " (array([[380.2952451 ],\n", - " [455.91026462]]),\n", - " 215,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945912460.jpg'),\n", - " (array([[428.72335206],\n", - " [460.13603638]]),\n", - " 218,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946162460.jpg'),\n", - " (array([[-6954.22196453],\n", - " [ 120.96375787]]),\n", - " 136,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939162460.jpg'),\n", - " (array([[496.53275551],\n", - " [465.50874948]]),\n", - " 221,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946512460.jpg'),\n", - " (array([[524.62976791],\n", - " [468.92931317]]),\n", - " 223,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946662460.jpg'),\n", - " (array([[-1785.35845446],\n", - " [ 338.80750052]]),\n", - " 144,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939862460.jpg'),\n", - " (array([[-845.61298794],\n", - " [ 391.91413411]]),\n", - " 152,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940512460.jpg'),\n", - " (array([[-429.35327155],\n", - " [ 417.61162109]]),\n", - " 160,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941162460.jpg'),\n", - " (array([[-173.38286731],\n", - " [ 436.06204799]]),\n", - " 168,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941862460.jpg'),\n", - " (array([[-34.94361421],\n", - " [447.78495674]]),\n", - " 176,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942612460.jpg'),\n", - " (array([[ 39.42105528],\n", - " [439.58833881]]),\n", - " 184,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943262460.jpg'),\n", - " (array([[ 99.83351234],\n", - " [435.06876846]]),\n", - " 192,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943912478.jpg'),\n", - " (array([[160.28211927],\n", - " [435.4431181 ]]),\n", - " 200,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944612460.jpg'),\n", - " (array([[273.25597841],\n", - " [444.71457787]]),\n", - " 208,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945362460.jpg'),\n", - " (array([[399.02245189],\n", - " [453.96855177]]),\n", - " 216,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946012460.jpg'),\n", - " (array([[543.92997073],\n", - " [468.80791959]]),\n", - " 224,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946762460.jpg')],\n", - " [(array([[1417.97126769],\n", - " [ 499.30163695]]),\n", - " 3,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", - " (array([[1487.76350705],\n", - " [ 492.34976692]]),\n", - " 11,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", - " (array([[1589.84123074],\n", - " [ 503.22441335]]),\n", - " 19,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", - " (array([[1692.1286689 ],\n", - " [ 509.20483617]]),\n", - " 27,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", - " (array([[1819.38818887],\n", - " [ 518.30516289]]),\n", - " 35,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", - " (array([[1985.14056588],\n", - " [ 530.75426447]]),\n", - " 43,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", - " (array([[1400.95015449],\n", - " [ 502.72450709]]),\n", - " 1,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg'),\n", - " (array([[2184.299195 ],\n", - " [ 539.95846459]]),\n", - " 51,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", - " (array([[1469.6217433],\n", - " [ 496.6090724]]),\n", - " 9,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", - " (array([[2460.88007624],\n", - " [ 542.6964679 ]]),\n", - " 59,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", - " (array([[1556.42640245],\n", - " [ 503.67894655]]),\n", - " 17,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", - " (array([[1440.09228652],\n", - " [ 503.73885815]]),\n", - " 6,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", - " (array([[2991.36170366],\n", - " [ 560.94679561]]),\n", - " 67,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", - " (array([[1666.55046397],\n", - " [ 507.60884507]]),\n", - " 25,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", - " (array([[1429.87374418],\n", - " [ 500.75503954]]),\n", - " 5,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", - " (array([[1425.70759224],\n", - " [ 499.65146421]]),\n", - " 4,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", - " (array([[1519.40904331],\n", - " [ 505.60392967]]),\n", - " 14,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", - " (array([[4188.00445364],\n", - " [ 667.29095692]]),\n", - " 75,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", - " (array([[1785.20836739],\n", - " [ 509.88790487]]),\n", - " 33,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", - " (array([[1500.768753 ],\n", - " [ 490.69837144]]),\n", - " 12,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", - " (array([[1404.80292987],\n", - " [ 496.02440093]]),\n", - " 2,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", - " (array([[1514.00616628],\n", - " [ 499.18871651]]),\n", - " 13,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", - " (array([[1626.69676505],\n", - " [ 498.57122939]]),\n", - " 22,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", - " (array([[8085.16834409],\n", - " [ 916.64677893]]),\n", - " 83,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", - " (array([[1452.34220468],\n", - " [ 497.82867354]]),\n", - " 7,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", - " (array([[1932.32577774],\n", - " [ 518.6292798 ]]),\n", - " 41,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", - " (array([[1481.61612288],\n", - " [ 488.4691232 ]]),\n", - " 10,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", - " (array([[1596.6372822],\n", - " [ 496.2764948]]),\n", - " 20,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", - " (array([[1611.53426085],\n", - " [ 496.41286406]]),\n", - " 21,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", - " (array([[-33193.78874787],\n", - " [ -1434.41309621]]),\n", - " 91,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", - " (array([[1733.24871917],\n", - " [ 501.27897312]]),\n", - " 30,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", - " (array([[1532.35114418],\n", - " [ 504.65426049]]),\n", - " 15,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", - " (array([[2135.21904755],\n", - " [ 525.20259418]]),\n", - " 49,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", - " (array([[1571.98217686],\n", - " [ 496.78662085]]),\n", - " 18,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", - " (array([[1707.42751408],\n", - " [ 500.50589032]]),\n", - " 28,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", - " (array([[1714.8696656 ],\n", - " [ 500.39771574]]),\n", - " 29,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", - " (array([[-3625.50282932],\n", - " [ 253.33993163]]),\n", - " 99,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", - " (array([[1872.56832954],\n", - " [ 517.84762295]]),\n", - " 38,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", - " (array([[1634.56840582],\n", - " [ 498.0119811 ]]),\n", - " 23,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", - " (array([[2385.59422599],\n", - " [ 530.68480944]]),\n", - " 57,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", - " (array([[1672.79333757],\n", - " [ 502.63003174]]),\n", - " 26,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", - " (array([[1838.19856499],\n", - " [ 511.75134806]]),\n", - " 36,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", - " (array([[1861.00238955],\n", - " [ 515.97727488]]),\n", - " 37,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", - " (array([[-1487.73997244],\n", - " [ 357.38994922]]),\n", - " 107,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", - " (array([[2052.73892052],\n", - " [ 521.0527247 ]]),\n", - " 46,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", - " (array([[1754.05651046],\n", - " [ 501.74884457]]),\n", - " 31,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", - " (array([[2762.59824683],\n", - " [ 538.02523097]]),\n", - " 65,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", - " (array([[2021.9915769 ],\n", - " [ 520.18721647]]),\n", - " 45,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", - " (array([[1805.5786928 ],\n", - " [ 507.55064578]]),\n", - " 34,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", - " (array([[1994.30178297],\n", - " [ 520.67629546]]),\n", - " 44,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", - " (array([[-701.35636324],\n", - " [ 384.47623667]]),\n", - " 115,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", - " (array([[2276.31915223],\n", - " [ 526.67073186]]),\n", - " 54,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", - " (array([[1895.33595785],\n", - " [ 518.02934822]]),\n", - " 39,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", - " (array([[1957.1831414 ],\n", - " [ 516.74672596]]),\n", - " 42,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", - " (array([[3842.45264086],\n", - " [ 625.36658219]]),\n", - " 73,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", - " (array([[2232.92722153],\n", - " [ 529.82876945]]),\n", - " 53,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", - " (array([[2215.48013238],\n", - " [ 531.78223092]]),\n", - " 52,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", - " (array([[-187.4664813 ],\n", - " [ 404.78483889]]),\n", - " 123,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", - " (array([[2593.29406556],\n", - " [ 533.57538258]]),\n", - " 62,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", - " (array([[2068.07453204],\n", - " [ 522.53829602]]),\n", - " 47,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", - " (array([[126.35898343],\n", - " [425.50796204]]),\n", - " 131,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", - " (array([[2510.22270839],\n", - " [ 532.88227595]]),\n", - " 60,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", - " (array([[6239.90037867],\n", - " [ 774.16710008]]),\n", - " 81,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", - " (array([[2152.68707713],\n", - " [ 524.9331039 ]]),\n", - " 50,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", - " (array([[2564.59924344],\n", - " [ 530.95244975]]),\n", - " 61,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", - " (array([[3277.55625298],\n", - " [ 566.1622557 ]]),\n", - " 70,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", - " (array([[2319.11749745],\n", - " [ 520.78213349]]),\n", - " 55,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", - " (array([[349.5282481 ],\n", - " [439.42997118]]),\n", - " 139,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939412460.jpg'),\n", - " (array([[104241.09609688],\n", - " [ 5855.53623297]]),\n", - " 89,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", - " (array([[3095.57073894],\n", - " [ 546.38978953]]),\n", - " 68,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", - " (array([[2435.13989857],\n", - " [ 526.83610966]]),\n", - " 58,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", - " (array([[4934.61309797],\n", - " [ 698.90839676]]),\n", - " 78,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", - " (array([[2663.20618578],\n", - " [ 529.094213 ]]),\n", - " 63,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", - " (array([[521.97852467],\n", - " [450.60255366]]),\n", - " 147,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940112460.jpg'),\n", - " (array([[-5388.34839126],\n", - " [ 183.58852477]]),\n", - " 97,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", - " (array([[4477.72278128],\n", - " [ 653.97803592]]),\n", - " 76,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", - " (array([[2944.87547244],\n", - " [ 531.63666696]]),\n", - " 66,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", - " (array([[14478.79672962],\n", - " [ 1174.37898092]]),\n", - " 86,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", - " (array([[3219.33897782],\n", - " [ 548.40174579]]),\n", - " 69,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", - " (array([[3427.57524033],\n", - " [ 565.37881916]]),\n", - " 71,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", - " (array([[624.63917852],\n", - " [460.88285391]]),\n", - " 155,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940762460.jpg'),\n", - " (array([[-1922.45940909],\n", - " [ 357.39715306]]),\n", - " 105,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", - " (array([[8919.13428115],\n", - " [ 916.08805826]]),\n", - " 84,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", - " (array([[4087.63846036],\n", - " [ 625.95180976]]),\n", - " 74,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", - " (array([[-9542.67990878],\n", - " [ -14.19319733]]),\n", - " 94,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", - " (array([[4799.64292056],\n", - " [ 652.274421 ]]),\n", - " 77,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", - " (array([[5376.91681242],\n", - " [ 694.86136142]]),\n", - " 79,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", - " (array([[701.83158142],\n", - " [471.46159348]]),\n", - " 163,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941412460.jpg'),\n", - " (array([[-838.25334609],\n", - " [ 396.31041784]]),\n", - " 113,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", - " (array([[7102.83915085],\n", - " [ 771.05886582]]),\n", - " 82,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", - " (array([[-16290.32766927],\n", - " [ -279.97757323]]),\n", - " 92,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", - " (array([[-2555.37820451],\n", - " [ 347.89264261]]),\n", - " 102,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", - " (array([[11069.72320314],\n", - " [ 973.01954359]]),\n", - " 85,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", - " (array([[17820.14655346],\n", - " [ 1260.76725046]]),\n", - " 87,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", - " (array([[1459.03085067],\n", - " [ 486.13848726]]),\n", - " 8,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", - " (array([[753.56336536],\n", - " [474.67323336]]),\n", - " 171,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942112460.jpg'),\n", - " (array([[-307.65288353],\n", - " [ 421.42649383]]),\n", - " 121,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", - " (array([[-3095.8750198 ],\n", - " [ 327.21240545]]),\n", - " 100,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", - " (array([[-180905.57967282],\n", - " [ -7148.0192111 ]]),\n", - " 90,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", - " (array([[-1119.87308093],\n", - " [ 395.88722766]]),\n", - " 110,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", - " (array([[-13151.66712218],\n", - " [ -166.47310579]]),\n", - " 93,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", - " (array([[-7266.98879186],\n", - " [ 110.81946107]]),\n", - " 95,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", - " (array([[1549.60946534],\n", - " [ 489.4790636 ]]),\n", - " 16,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", - " (array([[770.44171517],\n", - " [468.65123249]]),\n", - " 179,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942862460.jpg'),\n", - " (array([[ 72.0710298 ],\n", - " [439.06159289]]),\n", - " 129,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", - " (array([[-4125.53218409],\n", - " [ 289.18509792]]),\n", - " 98,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", - " (array([[-1312.62306142],\n", - " [ 389.19030656]]),\n", - " 108,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", - " (array([[-482.44972954],\n", - " [ 420.0154431 ]]),\n", - " 118,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", - " (array([[-2879.23891756],\n", - " [ 326.08954048]]),\n", - " 101,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", - " (array([[-2254.76766915],\n", - " [ 358.74822803]]),\n", - " 103,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", - " (array([[1653.32684934],\n", - " [ 489.25295769]]),\n", - " 24,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", - " (array([[774.24296182],\n", - " [459.94987638]]),\n", - " 187,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943512460.jpg'),\n", - " (array([[310.20198232],\n", - " [449.06689535]]),\n", - " 137,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939262460.jpg'),\n", - " (array([[-1607.30016313],\n", - " [ 391.51872953]]),\n", - " 106,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", - " (array([[-598.90917861],\n", - " [ 419.1146318 ]]),\n", - " 116,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", - " (array([[-43.42953333],\n", - " [432.05269637]]),\n", - " 126,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", - " (array([[-1240.78429418],\n", - " [ 399.32497482]]),\n", - " 109,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", - " (array([[-994.17282203],\n", - " [ 404.2832061 ]]),\n", - " 111,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", - " (array([[1769.06151033],\n", - " [ 487.54639298]]),\n", - " 32,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", - " (array([[779.25771042],\n", - " [460.56902526]]),\n", - " 195,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944162460.jpg'),\n", - " (array([[487.15639684],\n", - " [459.78117805]]),\n", - " 145,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939912460.jpg'),\n", - " (array([[-143.76890114],\n", - " [ 425.11881869]]),\n", - " 124,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", - " (array([[-722.90287103],\n", - " [ 407.67783907]]),\n", - " 114,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", - " (array([[231.04168992],\n", - " [447.46700658]]),\n", - " 134,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", - " (array([[-507.14035931],\n", - " [ 422.41711071]]),\n", - " 117,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", - " (array([[800.29299228],\n", - " [460.28762591]]),\n", - " 203,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944862460.jpg'),\n", - " (array([[-393.27570236],\n", - " [ 423.77941714]]),\n", - " 119,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", - " (array([[1929.41424572],\n", - " [ 502.40033019]]),\n", - " 40,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", - " (array([[612.90361782],\n", - " [467.22978559]]),\n", - " 153,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940612460.jpg'),\n", - " (array([[-223.65410098],\n", - " [ 421.6007525 ]]),\n", - " 122,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", - " (array([[183.94942701],\n", - " [441.91524561]]),\n", - " 132,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", - " (array([[431.71663166],\n", - " [451.57762576]]),\n", - " 142,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939662460.jpg'),\n", - " (array([[-81.78924947],\n", - " [423.22956363]]),\n", - " 125,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", - " (array([[879.53411612],\n", - " [467.83221832]]),\n", - " 211,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945612460.jpg'),\n", - " (array([[ -6.92734666],\n", - " [433.01788357]]),\n", - " 127,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", - " (array([[2117.27680819],\n", - " [ 514.06173118]]),\n", - " 48,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", - " (array([[695.00252352],\n", - " [466.61226051]]),\n", - " 161,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941262460.jpg'),\n", - " (array([[393.40047754],\n", - " [446.24000957]]),\n", - " 140,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939512460.jpg'),\n", - " (array([[107.32803896],\n", - " [433.43793591]]),\n", - " 130,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", - " (array([[578.51377821],\n", - " [457.90726507]]),\n", - " 150,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940362460.jpg'),\n", - " (array([[204.22130042],\n", - " [436.76678437]]),\n", - " 133,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", - " (array([[973.55670961],\n", - " [473.29840815]]),\n", - " 219,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946262460.jpg'),\n", - " (array([[274.5431714 ],\n", - " [434.96048425]]),\n", - " 135,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", - " (array([[755.15745819],\n", - " [466.89017058]]),\n", - " 169,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941912460.jpg'),\n", - " (array([[2365.15498555],\n", - " [ 526.64167313]]),\n", - " 56,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", - " (array([[545.07503489],\n", - " [448.93399304]]),\n", - " 148,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940162460.jpg'),\n", - " (array([[352.24009639],\n", - " [436.60242415]]),\n", - " 138,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939362460.jpg'),\n", - " (array([[669.34305192],\n", - " [457.90493901]]),\n", - " 158,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941012460.jpg'),\n", - " (array([[418.82164522],\n", - " [439.02310739]]),\n", - " 141,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939612460.jpg'),\n", - " (array([[457.63219527],\n", - " [441.00714515]]),\n", - " 143,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939762460.jpg'),\n", - " (array([[774.6077423 ],\n", - " [464.68140732]]),\n", - " 177,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942662460.jpg'),\n", - " (array([[2759.38804931],\n", - " [ 539.83639314]]),\n", - " 64,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", - " (array([[647.88718121],\n", - " [456.70370571]]),\n", - " 156,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940862460.jpg'),\n", - " (array([[514.28517042],\n", - " [446.09292886]]),\n", - " 146,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940012460.jpg'),\n", - " (array([[733.90756117],\n", - " [463.34755646]]),\n", - " 166,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941662460.jpg'),\n", - " (array([[560.27475434],\n", - " [452.94103571]]),\n", - " 149,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940262460.jpg'),\n", - " (array([[585.68050137],\n", - " [454.83265752]]),\n", - " 151,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940412460.jpg'),\n", - " (array([[778.6633486 ],\n", - " [456.77162015]]),\n", - " 185,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943362460.jpg'),\n", - " (array([[621.92804332],\n", - " [457.62413839]]),\n", - " 154,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940662460.jpg'),\n", - " (array([[720.8273402 ],\n", - " [464.97504899]]),\n", - " 164,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941512460.jpg'),\n", - " (array([[3635.74364713],\n", - " [ 594.1938898 ]]),\n", - " 72,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", - " (array([[769.17892964],\n", - " [471.62279391]]),\n", - " 174,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942362460.jpg'),\n", - " (array([[653.89665024],\n", - " [461.85225577]]),\n", - " 157,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940912460.jpg'),\n", - " (array([[783.87866254],\n", - " [457.73895956]]),\n", - " 193,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944012460.jpg'),\n", - " (array([[678.32366067],\n", - " [463.34779067]]),\n", - " 159,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941112460.jpg'),\n", - " (array([[705.2348861 ],\n", - " [466.44484019]]),\n", - " 162,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941362460.jpg'),\n", - " (array([[763.75226817],\n", - " [469.87528786]]),\n", - " 172,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942162460.jpg'),\n", - " (array([[777.6281194 ],\n", - " [465.35104495]]),\n", - " 182,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943112460.jpg'),\n", - " (array([[6113.30310724],\n", - " [ 732.24873125]]),\n", - " 80,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", - " (array([[728.7945204 ],\n", - " [471.05863778]]),\n", - " 165,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941612460.jpg'),\n", - " (array([[793.28657366],\n", - " [457.42247438]]),\n", - " 201,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944662460.jpg'),\n", - " (array([[741.29528838],\n", - " [471.8165507 ]]),\n", - " 167,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941762460.jpg'),\n", - " (array([[777.43489874],\n", - " [472.21111888]]),\n", - " 180,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942912460.jpg'),\n", - " (array([[757.67862041],\n", - " [479.7480464 ]]),\n", - " 170,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942012460.jpg'),\n", - " (array([[779.60443927],\n", - " [463.84388339]]),\n", - " 190,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943762460.jpg'),\n", - " (array([[38996.39425627],\n", - " [ 1990.23897612]]),\n", - " 88,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", - " (array([[766.55968294],\n", - " [480.26874504]]),\n", - " 173,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942262460.jpg'),\n", - " (array([[855.46635175],\n", - " [469.30360182]]),\n", - " 209,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945412460.jpg'),\n", - " (array([[773.36051999],\n", - " [481.63003504]]),\n", - " 175,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942512460.jpg'),\n", - " (array([[776.80498568],\n", - " [474.38745011]]),\n", - " 178,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942762460.jpg'),\n", - " (array([[787.77808653],\n", - " [461.12023866]]),\n", - " 198,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944412460.jpg'),\n", - " (array([[783.15937921],\n", - " [460.41168404]]),\n", - " 188,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943612460.jpg'),\n", - " (array([[-6136.77820326],\n", - " [ 194.40065211]]),\n", - " 96,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", - " (array([[778.42210664],\n", - " [471.95868356]]),\n", - " 181,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943012460.jpg'),\n", - " (array([[950.00345473],\n", - " [479.42750663]]),\n", - " 217,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946112460.jpg'),\n", - " (array([[779.95779592],\n", - " [470.85523894]]),\n", - " 183,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943162460.jpg'),\n", - " (array([[827.60023699],\n", - " [462.5258277 ]]),\n", - " 206,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945162460.jpg'),\n", - " (array([[780.05082898],\n", - " [466.8590876 ]]),\n", - " 186,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943412460.jpg'),\n", - " (array([[786.39628467],\n", - " [460.31256767]]),\n", - " 196,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944262460.jpg'),\n", - " (array([[-2055.23390468],\n", - " [ 380.11597298]]),\n", - " 104,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", - " (array([[783.76915973],\n", - " [460.0265154 ]]),\n", - " 189,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943662460.jpg'),\n", - " (array([[782.76100979],\n", - " [465.93929141]]),\n", - " 191,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943862460.jpg'),\n", - " (array([[915.58376261],\n", - " [473.38409652]]),\n", - " 214,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945862460.jpg'),\n", - " (array([[806.83928606],\n", - " [462.16433745]]),\n", - " 204,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944912460.jpg'),\n", - " (array([[785.02376981],\n", - " [463.53789217]]),\n", - " 194,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944112460.jpg'),\n", - " (array([[-903.45809755],\n", - " [ 407.18724952]]),\n", - " 112,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", - " (array([[789.35135743],\n", - " [460.01106715]]),\n", - " 197,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944362460.jpg'),\n", - " (array([[790.26709415],\n", - " [462.46081439]]),\n", - " 199,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944512460.jpg'),\n", - " (array([[1028.42711196],\n", - " [ 482.08715637]]),\n", - " 222,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946612460.jpg'),\n", - " (array([[888.06533522],\n", - " [470.97016881]]),\n", - " 212,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945662460.jpg'),\n", - " (array([[800.02365293],\n", - " [462.8527809 ]]),\n", - " 202,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944762460.jpg'),\n", - " (array([[-311.85146319],\n", - " [ 428.02838948]]),\n", - " 120,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", - " (array([[824.71920661],\n", - " [461.27422472]]),\n", - " 205,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945112460.jpg'),\n", - " (array([[839.55610686],\n", - " [465.47435449]]),\n", - " 207,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945262460.jpg'),\n", - " (array([[1000.08845209],\n", - " [ 478.57891414]]),\n", - " 220,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946412460.jpg'),\n", - " (array([[870.16180004],\n", - " [469.8639573 ]]),\n", - " 210,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945512460.jpg'),\n", - " (array([[ 46.66665433],\n", - " [439.49057168]]),\n", - " 128,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg'),\n", - " (array([[903.34991281],\n", - " [469.93428443]]),\n", - " 213,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945762460.jpg'),\n", - " (array([[924.07345858],\n", - " [472.06861151]]),\n", - " 215,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945912460.jpg'),\n", - " (array([[960.02728904],\n", - " [477.94278682]]),\n", - " 218,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946162460.jpg'),\n", - " (array([[293.1066344 ],\n", - " [447.80159019]]),\n", - " 136,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939162460.jpg'),\n", - " (array([[1014.20452478],\n", - " [ 477.44813464]]),\n", - " 221,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946512460.jpg'),\n", - " (array([[1036.95652729],\n", - " [ 477.84632084]]),\n", - " 223,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946662460.jpg'),\n", - " (array([[484.4738008 ],\n", - " [452.58273518]]),\n", - " 144,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939862460.jpg'),\n", - " (array([[603.54160816],\n", - " [460.84600198]]),\n", - " 152,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940512460.jpg'),\n", - " (array([[686.31478981],\n", - " [466.97329973]]),\n", - " 160,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941162460.jpg'),\n", - " (array([[752.36070251],\n", - " [472.26218031]]),\n", - " 168,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941862460.jpg'),\n", - " (array([[776.52960227],\n", - " [473.18341562]]),\n", - " 176,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942612460.jpg'),\n", - " (array([[782.00066392],\n", - " [462.35048851]]),\n", - " 184,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943262460.jpg'),\n", - " (array([[783.91209581],\n", - " [456.16979754]]),\n", - " 192,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943912478.jpg'),\n", - " (array([[792.64437214],\n", - " [453.39154716]]),\n", - " 200,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944612460.jpg'),\n", - " (array([[849.79766203],\n", - " [458.72493851]]),\n", - " 208,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945362460.jpg'),\n", - " (array([[935.26599272],\n", - " [467.53672311]]),\n", - " 216,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946012460.jpg'),\n", - " (array([[1052.71280402],\n", - " [ 476.76094565]]),\n", - " 224,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946762460.jpg')],\n", - " [(array([[1520.30786016],\n", - " [ 499.55273999]]),\n", - " 3,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", - " (array([[1597.26731186],\n", - " [ 488.2365489 ]]),\n", - " 11,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", - " (array([[1704.7927813],\n", - " [ 498.1291805]]),\n", - " 19,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", - " (array([[1810.09280062],\n", - " [ 502.89145893]]),\n", - " 27,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", - " (array([[1938.90929213],\n", - " [ 511.03986987]]),\n", - " 35,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", - " (array([[2101.38420735],\n", - " [ 522.27241561]]),\n", - " 43,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", - " (array([[1504.382053 ],\n", - " [ 499.43422887]]),\n", - " 1,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg'),\n", - " (array([[2295.95323702],\n", - " [ 530.84262 ]]),\n", - " 51,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", - " (array([[1580.59871538],\n", - " [ 493.84500565]]),\n", - " 9,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", - " (array([[2550.5657652 ],\n", - " [ 529.64118747]]),\n", - " 59,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", - " (array([[1672.67820576],\n", - " [ 500.70790263]]),\n", - " 17,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", - " (array([[1548.96109506],\n", - " [ 501.74568306]]),\n", - " 6,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", - " (array([[3020.46871848],\n", - " [ 541.28754163]]),\n", - " 67,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", - " (array([[1787.38622995],\n", - " [ 503.26769703]]),\n", - " 25,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", - " (array([[1532.80526853],\n", - " [ 500.58878287]]),\n", - " 5,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", - " (array([[1528.32799738],\n", - " [ 499.55658256]]),\n", - " 4,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", - " (array([[1627.77548239],\n", - " [ 504.91512101]]),\n", - " 14,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", - " (array([[3989.20933049],\n", - " [ 635.22364359]]),\n", - " 75,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", - " (array([[1900.91110192],\n", - " [ 507.56257845]]),\n", - " 33,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", - " (array([[1608.13854941],\n", - " [ 489.95172003]]),\n", - " 12,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", - " (array([[1506.06546474],\n", - " [ 496.90260236]]),\n", - " 2,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", - " (array([[1622.32135054],\n", - " [ 500.07330091]]),\n", - " 13,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", - " (array([[1740.0685288 ],\n", - " [ 498.96688463]]),\n", - " 22,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", - " (array([[6584.43686218],\n", - " [ 801.41495202]]),\n", - " 83,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", - " (array([[1556.94484433],\n", - " [ 499.05421105]]),\n", - " 7,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", - " (array([[2046.9384392 ],\n", - " [ 518.22850072]]),\n", - " 41,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", - " (array([[1587.93000577],\n", - " [ 488.92870346]]),\n", - " 10,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", - " (array([[1708.8198619 ],\n", - " [ 496.38603981]]),\n", - " 20,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", - " (array([[1724.24125704],\n", - " [ 496.61188206]]),\n", - " 21,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", - " (array([[47113.6503721 ],\n", - " [ 2874.33705863]]),\n", - " 91,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", - " (array([[1848.55558697],\n", - " [ 500.74690984]]),\n", - " 30,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", - " (array([[1641.27518876],\n", - " [ 505.13043191]]),\n", - " 15,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", - " (array([[2240.75071763],\n", - " [ 522.83104267]]),\n", - " 49,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", - " (array([[1682.89540049],\n", - " [ 496.95296567]]),\n", - " 18,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", - " (array([[1822.21135717],\n", - " [ 499.80096262]]),\n", - " 28,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", - " (array([[1829.69038268],\n", - " [ 499.69662694]]),\n", - " 29,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", - " (array([[-5659.99342574],\n", - " [ 179.00433383]]),\n", - " 99,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", - " (array([[1992.72513865],\n", - " [ 516.49074842]]),\n", - " 38,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", - " (array([[1751.66205055],\n", - " [ 497.38594589]]),\n", - " 23,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", - " (array([[2478.5384028 ],\n", - " [ 525.05981339]]),\n", - " 57,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", - " (array([[1790.91597479],\n", - " [ 501.70844986]]),\n", - " 26,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", - " (array([[1958.58326024],\n", - " [ 510.25264603]]),\n", - " 36,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", - " (array([[1981.28235488],\n", - " [ 514.54550847]]),\n", - " 37,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", - " (array([[-2138.1961549 ],\n", - " [ 339.06732842]]),\n", - " 107,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", - " (array([[2167.02892485],\n", - " [ 519.33595678]]),\n", - " 46,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", - " (array([[1873.29185593],\n", - " [ 500.67960681]]),\n", - " 31,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", - " (array([[2814.64955798],\n", - " [ 529.58297566]]),\n", - " 65,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", - " (array([[2137.32502088],\n", - " [ 518.49092098]]),\n", - " 45,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", - " (array([[1925.3060388 ],\n", - " [ 506.33354902]]),\n", - " 34,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", - " (array([[2110.67389117],\n", - " [ 519.19277372]]),\n", - " 44,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", - " (array([[-1074.34586019],\n", - " [ 372.54098436]]),\n", - " 115,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", - " (array([[2376.40562459],\n", - " [ 522.04776227]]),\n", - " 54,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", - " (array([[2013.82668795],\n", - " [ 516.59862272]]),\n", - " 39,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", - " (array([[2074.3735451 ],\n", - " [ 515.10119622]]),\n", - " 42,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", - " (array([[3729.17932401],\n", - " [ 604.35466959]]),\n", - " 73,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", - " (array([[2335.56199234],\n", - " [ 525.72027104]]),\n", - " 53,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", - " (array([[2318.70470746],\n", - " [ 527.67669104]]),\n", - " 52,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", - " (array([[-434.93339397],\n", - " [ 396.07222002]]),\n", - " 123,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", - " (array([[2662.25490852],\n", - " [ 525.70345379]]),\n", - " 62,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", - " (array([[2180.2448244],\n", - " [ 520.1739507]]),\n", - " 47,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", - " (array([[-65.64313096],\n", - " [419.03202851]]),\n", - " 131,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", - " (array([[2586.12518612],\n", - " [ 526.32801492]]),\n", - " 60,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", - " (array([[5463.13662893],\n", - " [ 707.78362512]]),\n", - " 81,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", - " (array([[2259.37648132],\n", - " [ 521.57752247]]),\n", - " 50,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", - " (array([[2634.44923186],\n", - " [ 523.79200862]]),\n", - " 61,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", - " (array([[3254.61807491],\n", - " [ 552.9029591 ]]),\n", - " 70,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", - " (array([[2411.27790913],\n", - " [ 515.98929392]]),\n", - " 55,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", - " (array([[185.74674037],\n", - " [433.16769114]]),\n", - " 139,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939412460.jpg'),\n", - " (array([[18167.79794964],\n", - " [ 1300.164344 ]]),\n", - " 89,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", - " (array([[3095.75978813],\n", - " [ 535.52633235]]),\n", - " 68,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", - " (array([[2516.78001163],\n", - " [ 521.2145415 ]]),\n", - " 58,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", - " (array([[4548.96215468],\n", - " [ 659.29429568]]),\n", - " 78,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", - " (array([[2717.39880698],\n", - " [ 522.13002068]]),\n", - " 63,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", - " (array([[375.86941867],\n", - " [443.84415382]]),\n", - " 147,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940112460.jpg'),\n", - " (array([[-9578.36328978],\n", - " [ 27.75795576]]),\n", - " 97,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", - " (array([[4207.16848899],\n", - " [ 625.12224666]]),\n", - " 76,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", - " (array([[2963.48503656],\n", - " [ 522.64998985]]),\n", - " 66,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", - " (array([[9393.44955058],\n", - " [ 882.40687034]]),\n", - " 86,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", - " (array([[3194.13198816],\n", - " [ 537.77389319]]),\n", - " 69,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", - " (array([[3369.16492084],\n", - " [ 552.68993289]]),\n", - " 71,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", - " (array([[487.30701422],\n", - " [455.01399833]]),\n", - " 155,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940762460.jpg'),\n", - " (array([[-2807.51411213],\n", - " [ 333.06586205]]),\n", - " 105,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", - " (array([[6982.21445306],\n", - " [ 786.98789068]]),\n", - " 84,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", - " (array([[3901.68079994],\n", - " [ 604.44445523]]),\n", - " 74,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", - " (array([[-26228.27927746],\n", - " [ -810.288706 ]]),\n", - " 94,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", - " (array([[4427.50086244],\n", - " [ 634.5875181 ]]),\n", - " 77,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", - " (array([[4833.51429151],\n", - " [ 667.65326279]]),\n", - " 79,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", - " (array([[570.5650474 ],\n", - " [463.43720032]]),\n", - " 163,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941412460.jpg'),\n", - " (array([[-1267.57292521],\n", - " [ 374.60588246]]),\n", - " 113,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", - " (array([[5946.52746526],\n", - " [ 717.04606728]]),\n", - " 82,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", - " (array([[-365062.02849914],\n", - " [ -13811.99448051]]),\n", - " 92,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", - " (array([[-3826.41120927],\n", - " [ 322.3700365 ]]),\n", - " 102,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", - " (array([[8008.88057767],\n", - " [ 787.29784933]]),\n", - " 85,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", - " (array([[10452.35551403],\n", - " [ 872.20506736]]),\n", - " 87,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", - " (array([[1564.40814845],\n", - " [ 484.73867596]]),\n", - " 8,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", - " (array([[626.46771498],\n", - " [471.97017607]]),\n", - " 171,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942112460.jpg'),\n", - " (array([[-592.93778155],\n", - " [ 412.8509103 ]]),\n", - " 121,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", - " (array([[-4800.11585181],\n", - " [ 281.90705623]]),\n", - " 100,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", - " (array([[22255.12393764],\n", - " [ 1294.52203701]]),\n", - " 90,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", - " (array([[-1657.2028304 ],\n", - " [ 382.62048761]]),\n", - " 110,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", - " (array([[-73998.09178362],\n", - " [ -2686.99096825]]),\n", - " 93,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", - " (array([[-15920.69298151],\n", - " [ -221.18670358]]),\n", - " 95,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", - " (array([[1656.43573066],\n", - " [ 488.93113222]]),\n", - " 16,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", - " (array([[645.75052209],\n", - " [464.84390872]]),\n", - " 179,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942862460.jpg'),\n", - " (array([[-137.72091002],\n", - " [ 432.78641524]]),\n", - " 129,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", - " (array([[-6867.95954389],\n", - " [ 212.0227831 ]]),\n", - " 98,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", - " (array([[-1937.66844221],\n", - " [ 373.54589435]]),\n", - " 108,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", - " (array([[-816.0933564 ],\n", - " [ 411.79483091]]),\n", - " 118,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", - " (array([[-4442.21395582],\n", - " [ 281.22581272]]),\n", - " 101,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", - " (array([[-3377.16913332],\n", - " [ 330.79122065]]),\n", - " 103,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", - " (array([[1762.73693961],\n", - " [ 487.96718781]]),\n", - " 24,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", - " (array([[134.5746742 ],\n", - " [438.97579502]]),\n", - " 137,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939262460.jpg'),\n", - " (array([[-2366.64227685],\n", - " [ 367.98198683]]),\n", - " 106,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", - " (array([[-964.88748966],\n", - " [ 405.27638446]]),\n", - " 116,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", - " (array([[-275.07848225],\n", - " [ 421.53866932]]),\n", - " 126,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", - " (array([[-1834.40334531],\n", - " [ 379.06725994]]),\n", - " 109,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", - " (array([[-1491.08949365],\n", - " [ 386.57817746]]),\n", - " 111,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", - " (array([[1878.11043113],\n", - " [ 487.34899025]]),\n", - " 32,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", - " (array([[331.12124936],\n", - " [451.45243324]]),\n", - " 145,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939912460.jpg'),\n", - " (array([[-399.30665993],\n", - " [ 413.66545663]]),\n", - " 124,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", - " (array([[-1133.44748771],\n", - " [ 391.84129308]]),\n", - " 114,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", - " (array([[ 42.84584829],\n", - " [438.68341144]]),\n", - " 134,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", - " (array([[-860.45215049],\n", - " [ 411.96791278]]),\n", - " 117,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", - " (array([[-714.79815186],\n", - " [ 413.73914519]]),\n", - " 119,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", - " (array([[2034.84769765],\n", - " [ 502.6106164 ]]),\n", - " 40,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", - " (array([[467.4307328 ],\n", - " [460.21609384]]),\n", - " 153,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940612460.jpg'),\n", - " (array([[-506.8916898 ],\n", - " [ 410.91434764]]),\n", - " 122,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", - " (array([[-17.99529788],\n", - " [433.98107134]]),\n", - " 132,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", - " (array([[264.23614371],\n", - " [444.98084076]]),\n", - " 142,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939662460.jpg'),\n", - " (array([[-331.70034757],\n", - " [ 411.72546021]]),\n", - " 125,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", - " (array([[-241.65489432],\n", - " [ 422.78484309]]),\n", - " 127,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", - " (array([[2210.02411505],\n", - " [ 505.8370253 ]]),\n", - " 48,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", - " (array([[554.01753674],\n", - " [464.5837524 ]]),\n", - " 161,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941262460.jpg'),\n", - " (array([[220.65050574],\n", - " [443.41165958]]),\n", - " 140,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939512460.jpg'),\n", - " (array([[-108.35078043],\n", - " [ 430.65928805]]),\n", - " 130,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", - " (array([[427.53967027],\n", - " [448.75471776]]),\n", - " 150,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940362460.jpg'),\n", - " (array([[ 6.2193707 ],\n", - " [426.03600963]]),\n", - " 133,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", - " (array([[ 85.28190963],\n", - " [431.0791797 ]]),\n", - " 135,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", - " (array([[619.34172976],\n", - " [464.58972163]]),\n", - " 169,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941912460.jpg'),\n", - " (array([[2434.2483222 ],\n", - " [ 515.92956168]]),\n", - " 56,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", - " (array([[389.23205838],\n", - " [444.54326751]]),\n", - " 148,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940162460.jpg'),\n", - " (array([[173.80513467],\n", - " [432.59626585]]),\n", - " 138,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939362460.jpg'),\n", - " (array([[526.5815778 ],\n", - " [450.96939474]]),\n", - " 158,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941012460.jpg'),\n", - " (array([[252.68960055],\n", - " [432.7340222 ]]),\n", - " 141,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939612460.jpg'),\n", - " (array([[295.92872868],\n", - " [434.88306995]]),\n", - " 143,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939762460.jpg'),\n", - " (array([[645.66563099],\n", - " [460.92922558]]),\n", - " 177,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942662460.jpg'),\n", - " (array([[2784.59514863],\n", - " [ 530.22024888]]),\n", - " 64,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", - " (array([[505.50396994],\n", - " [450.59237383]]),\n", - " 156,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940862460.jpg'),\n", - " (array([[358.20381712],\n", - " [435.74307619]]),\n", - " 146,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940012460.jpg'),\n", - " (array([[598.61724998],\n", - " [455.68383752]]),\n", - " 166,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941662460.jpg'),\n", - " (array([[409.2415045 ],\n", - " [440.57049895]]),\n", - " 149,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940262460.jpg'),\n", - " (array([[437.11252575],\n", - " [442.8511078 ]]),\n", - " 151,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940412460.jpg'),\n", - " (array([[476.82528053],\n", - " [446.24591286]]),\n", - " 154,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940662460.jpg'),\n", - " (array([[584.57730944],\n", - " [454.92217905]]),\n", - " 164,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941512460.jpg'),\n", - " (array([[3507.41350635],\n", - " [ 591.25473272]]),\n", - " 72,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", - " (array([[638.07522288],\n", - " [461.0406266 ]]),\n", - " 174,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942362460.jpg'),\n", - " (array([[511.34607161],\n", - " [449.1068777 ]]),\n", - " 157,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940912460.jpg'),\n", - " (array([[537.92480087],\n", - " [451.1790959 ]]),\n", - " 159,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941112460.jpg'),\n", - " (array([[567.17745211],\n", - " [454.99556382]]),\n", - " 162,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941362460.jpg'),\n", - " (array([[631.54355843],\n", - " [459.14436348]]),\n", - " 172,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942162460.jpg'),\n", - " (array([[650.20478387],\n", - " [453.3364855 ]]),\n", - " 182,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943112460.jpg'),\n", - " (array([[5235.71974031],\n", - " [ 701.71090148]]),\n", - " 80,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", - " (array([[592.33024816],\n", - " [459.57842359]]),\n", - " 165,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941612460.jpg'),\n", - " (array([[605.95847041],\n", - " [460.60179296]]),\n", - " 167,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941762460.jpg'),\n", - " (array([[648.14521923],\n", - " [455.29566502]]),\n", - " 180,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942912460.jpg'),\n", - " (array([[623.75288722],\n", - " [462.13480666]]),\n", - " 170,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942012460.jpg'),\n", - " (array([[13361.11459429],\n", - " [ 1117.22636683]]),\n", - " 88,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", - " (array([[633.18466052],\n", - " [467.65966357]]),\n", - " 173,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942262460.jpg'),\n", - " (array([[640.53907913],\n", - " [470.3068369 ]]),\n", - " 175,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942512460.jpg'),\n", - " (array([[645.24642902],\n", - " [462.69085474]]),\n", - " 178,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942762460.jpg'),\n", - " (array([[-12939.43264512],\n", - " [ -161.28330775]]),\n", - " 96,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", - " (array([[647.38383652],\n", - " [460.40580194]]),\n", - " 181,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943012460.jpg'),\n", - " (array([[648.65854216],\n", - " [465.57355234]]),\n", - " 183,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943162460.jpg'),\n", - " (array([[-3165.44940056],\n", - " [ 347.43762114]]),\n", - " 104,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", - " (array([[-1414.60764878],\n", - " [ 389.88642384]]),\n", - " 112,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", - " (array([[-629.64914099],\n", - " [ 416.36983282]]),\n", - " 120,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", - " (array([[-189.75010984],\n", - " [ 434.0142604 ]]),\n", - " 128,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg'),\n", - " (array([[ 98.43501454],\n", - " [439.69120954]]),\n", - " 136,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939162460.jpg'),\n", - " (array([[316.97177613],\n", - " [449.54580981]]),\n", - " 144,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939862460.jpg'),\n", - " (array([[448.92470887],\n", - " [458.1977374 ]]),\n", - " 152,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940512460.jpg'),\n", - " (array([[539.84225913],\n", - " [464.76828022]]),\n", - " 160,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941162460.jpg'),\n", - " (array([[612.05762234],\n", - " [470.73045084]]),\n", - " 168,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941862460.jpg'),\n", - " (array([[640.64690483],\n", - " [472.60044243]]),\n", - " 176,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942612460.jpg')],\n", - " [(array([[753.11971033],\n", - " [491.47527543]]),\n", - " 3,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", - " (array([[752.92390731],\n", - " [485.4510099 ]]),\n", - " 11,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", - " (array([[756.66426604],\n", - " [499.06870148]]),\n", - " 19,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", - " (array([[749.76760677],\n", - " [510.13654729]]),\n", - " 27,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", - " (array([[741.98674664],\n", - " [522.73199765]]),\n", - " 35,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", - " (array([[717.45996316],\n", - " [542.72203794]]),\n", - " 43,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", - " (array([[755.77083302],\n", - " [494.37994559]]),\n", - " 1,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927612460.jpg'),\n", - " (array([[721.35968778],\n", - " [566.20199169]]),\n", - " 51,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", - " (array([[757.88039949],\n", - " [489.42862576]]),\n", - " 9,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", - " (array([[662.42158199],\n", - " [638.69285372]]),\n", - " 59,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", - " (array([[760.27037907],\n", - " [494.67367898]]),\n", - " 17,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", - " (array([[756.82939689],\n", - " [492.73285034]]),\n", - " 6,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", - " (array([[ -73.66212475],\n", - " [1539.19488978]]),\n", - " 67,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", - " (array([[761.50541182],\n", - " [504.23067806]]),\n", - " 25,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", - " (array([[751.28725985],\n", - " [490.7317152 ]]),\n", - " 5,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", - " (array([[752.34645245],\n", - " [489.30130431]]),\n", - " 4,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", - " (array([[751.63055415],\n", - " [496.77685294]]),\n", - " 14,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", - " (array([[1439.30786765],\n", - " [-323.18119174]]),\n", - " 75,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", - " (array([[750.23466335],\n", - " [506.11712728]]),\n", - " 33,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", - " (array([[752.12191244],\n", - " [482.84284709]]),\n", - " 12,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", - " (array([[747.07940198],\n", - " [488.87498641]]),\n", - " 2,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", - " (array([[747.47310925],\n", - " [490.45850336]]),\n", - " 13,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", - " (array([[750.881416 ],\n", - " [491.60932273]]),\n", - " 22,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", - " (array([[1046.76260016],\n", - " [ 135.41005353]]),\n", - " 83,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", - " (array([[746.66344319],\n", - " [487.71604714]]),\n", - " 7,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", - " (array([[739.2327024 ],\n", - " [510.30748126]]),\n", - " 41,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", - " (array([[740.37143236],\n", - " [481.3540385 ]]),\n", - " 10,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", - " (array([[745.03415028],\n", - " [489.54399927]]),\n", - " 20,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", - " (array([[744.67646149],\n", - " [488.66821228]]),\n", - " 21,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", - " (array([[969.81039024],\n", - " [249.85400423]]),\n", - " 91,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", - " (array([[737.34803077],\n", - " [496.19021377]]),\n", - " 30,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", - " (array([[728.78833156],\n", - " [493.58559647]]),\n", - " 15,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", - " (array([[703.50371896],\n", - " [512.98445408]]),\n", - " 49,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", - " (array([[731.85273713],\n", - " [487.18271724]]),\n", - " 18,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", - " (array([[726.37714668],\n", - " [493.71892563]]),\n", - " 28,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", - " (array([[725.01280448],\n", - " [493.2995996 ]]),\n", - " 29,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", - " (array([[963.9672891 ],\n", - " [325.16168854]]),\n", - " 99,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", - " (array([[701.01420338],\n", - " [500.03019929]]),\n", - " 38,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", - " (array([[715.24186012],\n", - " [486.10268638]]),\n", - " 23,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", - " (array([[657.70677757],\n", - " [519.62301517]]),\n", - " 57,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", - " (array([[710.985946 ],\n", - " [491.32225725]]),\n", - " 26,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", - " (array([[703.23014905],\n", - " [497.44658066]]),\n", - " 36,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", - " (array([[701.82878463],\n", - " [499.62795551]]),\n", - " 37,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", - " (array([[968.54735606],\n", - " [357.14066664]]),\n", - " 107,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", - " (array([[660.54645648],\n", - " [490.93902879]]),\n", - " 46,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", - " (array([[686.17440951],\n", - " [486.8401325 ]]),\n", - " 31,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", - " (array([[604.33069377],\n", - " [518.67343972]]),\n", - " 65,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", - " (array([[662.27544198],\n", - " [492.54596916]]),\n", - " 45,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", - " (array([[683.62650704],\n", - " [491.13962194]]),\n", - " 34,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", - " (array([[665.1889703 ],\n", - " [493.09100418]]),\n", - " 44,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", - " (array([[930.79465856],\n", - " [350.18938662]]),\n", - " 115,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", - " (array([[608.13645262],\n", - " [501.17648912]]),\n", - " 54,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", - " (array([[650.76057005],\n", - " [491.96686483]]),\n", - " 39,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", - " (array([[644.3222665 ],\n", - " [487.94862287]]),\n", - " 42,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", - " (array([[560.70771689],\n", - " [528.41714793]]),\n", - " 73,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", - " (array([[610.3568308 ],\n", - " [501.42313654]]),\n", - " 53,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", - " (array([[584.02050935],\n", - " [497.1582116 ]]),\n", - " 52,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", - " (array([[971.75706953],\n", - " [385.07606121]]),\n", - " 123,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", - " (array([[546.39584901],\n", - " [505.25535256]]),\n", - " 62,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", - " (array([[603.87311134],\n", - " [484.09666714]]),\n", - " 47,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", - " (array([[1058.33002984],\n", - " [ 418.6051489 ]]),\n", - " 131,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", - " (array([[517.57208367],\n", - " [498.22955359]]),\n", - " 60,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", - " (array([[488.44565562],\n", - " [523.04188823]]),\n", - " 81,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", - " (array([[562.95860315],\n", - " [490.95288262]]),\n", - " 50,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", - " (array([[511.49773922],\n", - " [499.53280676]]),\n", - " 61,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", - " (array([[483.97113077],\n", - " [495.43728352]]),\n", - " 70,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", - " (array([[502.14749818],\n", - " [489.77701675]]),\n", - " 55,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", - " (array([[1006.67495408],\n", - " [ 419.17536585]]),\n", - " 139,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939412460.jpg'),\n", - " (array([[495.51147271],\n", - " [543.47975503]]),\n", - " 89,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", - " (array([[444.47008077],\n", - " [488.72988849]]),\n", - " 68,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", - " (array([[488.60000021],\n", - " [492.60423635]]),\n", - " 58,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", - " (array([[439.61975756],\n", - " [489.47953467]]),\n", - " 78,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", - " (array([[425.29053755],\n", - " [490.3086527 ]]),\n", - " 63,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", - " (array([[1018.55578835],\n", - " [ 433.52007094]]),\n", - " 147,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940112460.jpg'),\n", - " (array([[526.18254092],\n", - " [559.88191774]]),\n", - " 97,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", - " (array([[397.87838942],\n", - " [482.84127482]]),\n", - " 76,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", - " (array([[408.35460133],\n", - " [484.5658776 ]]),\n", - " 66,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", - " (array([[362.00869949],\n", - " [511.66097174]]),\n", - " 86,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", - " (array([[341.06355331],\n", - " [476.28918117]]),\n", - " 69,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", - " (array([[339.29478746],\n", - " [477.71663472]]),\n", - " 71,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", - " (array([[995.11295739],\n", - " [439.04168 ]]),\n", - " 155,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940762460.jpg'),\n", - " (array([[552.98747329],\n", - " [569.47824026]]),\n", - " 105,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", - " (array([[346.51811325],\n", - " [503.25465402]]),\n", - " 84,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", - " (array([[337.13953636],\n", - " [481.42469757]]),\n", - " 74,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", - " (array([[368.63806514],\n", - " [508.16288149]]),\n", - " 94,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", - " (array([[269.38085669],\n", - " [460.71491998]]),\n", - " 77,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", - " (array([[266.51613276],\n", - " [467.54414217]]),\n", - " 79,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", - " (array([[977.45391407],\n", - " [443.71153674]]),\n", - " 163,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941412460.jpg'),\n", - " (array([[594.23343496],\n", - " [582.2443823 ]]),\n", - " 113,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", - " (array([[273.01923315],\n", - " [489.39894809]]),\n", - " 82,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", - " (array([[277.50747267],\n", - " [492.23152574]]),\n", - " 92,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", - " (array([[380.74728789],\n", - " [514.25963054]]),\n", - " 102,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", - " (array([[213.0621516 ],\n", - " [484.07271866]]),\n", - " 85,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", - " (array([[227.64029008],\n", - " [490.87444677]]),\n", - " 87,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", - " (array([[511.93720851],\n", - " [466.54446949]]),\n", - " 8,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", - " (array([[953.38080065],\n", - " [447.39651617]]),\n", - " 171,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942112460.jpg'),\n", - " (array([[524.45369823],\n", - " [560.96091821]]),\n", - " 121,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", - " (array([[281.11618174],\n", - " [506.91458161]]),\n", - " 100,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", - " (array([[171.68752015],\n", - " [487.40774068]]),\n", - " 90,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", - " (array([[387.91877232],\n", - " [522.52119267]]),\n", - " 110,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", - " (array([[202.66493116],\n", - " [488.74217698]]),\n", - " 93,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", - " (array([[150.07241431],\n", - " [493.71742934]]),\n", - " 95,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", - " (array([[415.71931002],\n", - " [467.53162909]]),\n", - " 16,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", - " (array([[899.67385503],\n", - " [419.06213889]]),\n", - " 179,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942862460.jpg'),\n", - " (array([[564.00953308],\n", - " [595.35965386]]),\n", - " 129,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", - " (array([[184.2846848 ],\n", - " [502.86313587]]),\n", - " 98,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", - " (array([[233.14046056],\n", - " [511.41253934]]),\n", - " 108,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", - " (array([[357.24593496],\n", - " [527.86375207]]),\n", - " 118,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", - " (array([[147.09006862],\n", - " [501.56831076]]),\n", - " 101,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", - " (array([[170.24719382],\n", - " [505.43402682]]),\n", - " 103,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", - " (array([[349.28602499],\n", - " [469.36397348]]),\n", - " 24,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", - " (array([[886.21947416],\n", - " [404.27319853]]),\n", - " 187,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943512460.jpg'),\n", - " (array([[538.78433237],\n", - " [594.02503346]]),\n", - " 137,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939262460.jpg'),\n", - " (array([[152.31734242],\n", - " [505.80115357]]),\n", - " 106,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", - " (array([[284.36463698],\n", - " [519.14254812]]),\n", - " 116,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", - " (array([[423.46407877],\n", - " [536.28695176]]),\n", - " 126,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", - " (array([[186.37476891],\n", - " [509.32960536]]),\n", - " 109,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", - " (array([[217.02648145],\n", - " [509.66867316]]),\n", - " 111,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", - " (array([[228.30861987],\n", - " [466.63546775]]),\n", - " 32,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", - " (array([[881.59507874],\n", - " [383.00739644]]),\n", - " 195,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944162460.jpg'),\n", - " (array([[575.04765652],\n", - " [630.51216656]]),\n", - " 145,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939912460.jpg'),\n", - " (array([[358.06143143],\n", - " [518.5646108 ]]),\n", - " 124,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", - " (array([[217.98774496],\n", - " [506.950209 ]]),\n", - " 114,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", - " (array([[490.292987 ],\n", - " [554.49543744]]),\n", - " 134,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", - " (array([[230.53551802],\n", - " [509.99889859]]),\n", - " 117,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", - " (array([[889.49673022],\n", - " [386.08614155]]),\n", - " 203,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944862460.jpg'),\n", - " (array([[260.28833103],\n", - " [510.29176904]]),\n", - " 119,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", - " (array([[133.24008741],\n", - " [464.60951515]]),\n", - " 40,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", - " (array([[585.45527798],\n", - " [691.8808036 ]]),\n", - " 153,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940612460.jpg'),\n", - " (array([[276.71868506],\n", - " [505.60168074]]),\n", - " 122,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", - " (array([[428.65759481],\n", - " [525.21224623]]),\n", - " 132,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", - " (array([[538.48109604],\n", - " [549.21975709]]),\n", - " 142,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939662460.jpg'),\n", - " (array([[323.25395499],\n", - " [503.64718533]]),\n", - " 125,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", - " (array([[943.31733325],\n", - " [395.83721828]]),\n", - " 211,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945612460.jpg'),\n", - " (array([[350.56034613],\n", - " [512.80166729]]),\n", - " 127,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", - " (array([[-31.94365538],\n", - " [460.36566943]]),\n", - " 48,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", - " (array([[611.70635097],\n", - " [642.99173698]]),\n", - " 161,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941262460.jpg'),\n", - " (array([[501.83513302],\n", - " [533.25881194]]),\n", - " 140,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939512460.jpg'),\n", - " (array([[370.72021527],\n", - " [513.43554452]]),\n", - " 130,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", - " (array([[589.34763181],\n", - " [569.36729468]]),\n", - " 150,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940362460.jpg'),\n", - " (array([[413.909259 ],\n", - " [518.20950592]]),\n", - " 133,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", - " (array([[1005.99203217],\n", - " [ 403.37098512]]),\n", - " 219,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946262460.jpg'),\n", - " (array([[436.00893383],\n", - " [516.43019546]]),\n", - " 135,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", - " (array([[648.04180049],\n", - " [667.06287815]]),\n", - " 169,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941912460.jpg'),\n", - " (array([[-173.7794014 ],\n", - " [ 470.97677497]]),\n", - " 56,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", - " (array([[577.83209619],\n", - " [543.85740536]]),\n", - " 148,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940162460.jpg'),\n", - " (array([[474.65957938],\n", - " [519.24542073]]),\n", - " 138,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939362460.jpg'),\n", - " (array([[634.75624816],\n", - " [581.70855885]]),\n", - " 158,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941012460.jpg'),\n", - " (array([[504.58756708],\n", - " [516.05227746]]),\n", - " 141,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939612460.jpg'),\n", - " (array([[528.08196215],\n", - " [519.05231097]]),\n", - " 143,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939762460.jpg'),\n", - " (array([[647.35589016],\n", - " [672.51195827]]),\n", - " 177,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942662460.jpg'),\n", - " (array([[-349.69372546],\n", - " [ 467.65711267]]),\n", - " 64,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", - " (array([[637.04932999],\n", - " [553.74221606]]),\n", - " 156,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940862460.jpg'),\n", - " (array([[562.24192012],\n", - " [527.90356495]]),\n", - " 146,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940012460.jpg'),\n", - " (array([[683.20541047],\n", - " [589.07671188]]),\n", - " 166,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941662460.jpg'),\n", - " (array([[589.70062416],\n", - " [526.84246133]]),\n", - " 149,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940262460.jpg'),\n", - " (array([[605.72624393],\n", - " [530.3926932 ]]),\n", - " 151,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940412460.jpg'),\n", - " (array([[631.89513909],\n", - " [665.73440913]]),\n", - " 185,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943362460.jpg'),\n", - " (array([[628.19456051],\n", - " [536.54589787]]),\n", - " 154,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940662460.jpg'),\n", - " (array([[692.20914334],\n", - " [561.74015886]]),\n", - " 164,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941512460.jpg'),\n", - " (array([[-488.01391296],\n", - " [ 451.10927373]]),\n", - " 72,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", - " (array([[728.91444168],\n", - " [574.02970075]]),\n", - " 174,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942362460.jpg'),\n", - " (array([[653.87568062],\n", - " [533.10030284]]),\n", - " 157,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940912460.jpg'),\n", - " (array([[625.19420938],\n", - " [666.3086945 ]]),\n", - " 193,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944012460.jpg'),\n", - " (array([[671.15320067],\n", - " [537.3244686 ]]),\n", - " 159,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941112460.jpg'),\n", - " (array([[690.40902319],\n", - " [544.68958923]]),\n", - " 162,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941362460.jpg'),\n", - " (array([[729.58065005],\n", - " [565.88509799]]),\n", - " 172,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942162460.jpg'),\n", - " (array([[705.49586515],\n", - " [570.68588563]]),\n", - " 182,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943112460.jpg'),\n", - " (array([[-611.05088731],\n", - " [ 434.95857179]]),\n", - " 80,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", - " (array([[703.4530686 ],\n", - " [542.98482631]]),\n", - " 165,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941612460.jpg'),\n", - " (array([[570.69554323],\n", - " [682.59403674]]),\n", - " 201,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944662460.jpg'),\n", - " (array([[712.55493521],\n", - " [546.17125954]]),\n", - " 167,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941762460.jpg'),\n", - " (array([[708.02285179],\n", - " [548.18723536]]),\n", - " 180,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942912460.jpg'),\n", - " (array([[714.21445976],\n", - " [541.99803535]]),\n", - " 170,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942012460.jpg'),\n", - " (array([[667.91180992],\n", - " [561.48752153]]),\n", - " 190,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943762460.jpg'),\n", - " (array([[-567.18217094],\n", - " [ 456.40868869]]),\n", - " 88,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", - " (array([[717.20800692],\n", - " [546.28917214]]),\n", - " 173,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942262460.jpg'),\n", - " (array([[538.88108331],\n", - " [632.457337 ]]),\n", - " 209,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945412460.jpg'),\n", - " (array([[677.96128592],\n", - " [542.30062034]]),\n", - " 175,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942512460.jpg'),\n", - " (array([[672.4191088 ],\n", - " [536.65398995]]),\n", - " 178,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942762460.jpg'),\n", - " (array([[581.15624549],\n", - " [558.23711127]]),\n", - " 198,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944412460.jpg'),\n", - " (array([[637.2020599 ],\n", - " [535.03332292]]),\n", - " 188,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943612460.jpg'),\n", - " (array([[-472.28003486],\n", - " [ 458.99453571]]),\n", - " 96,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", - " (array([[640.02311863],\n", - " [530.19569078]]),\n", - " 181,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943012460.jpg'),\n", - " (array([[570.47120389],\n", - " [671.19366557]]),\n", - " 217,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946112460.jpg'),\n", - " (array([[634.20660565],\n", - " [531.26841264]]),\n", - " 183,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943162460.jpg'),\n", - " (array([[536.22208564],\n", - " [568.89563727]]),\n", - " 206,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945162460.jpg'),\n", - " (array([[622.30852708],\n", - " [529.48841283]]),\n", - " 186,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943412460.jpg'),\n", - " (array([[572.41947295],\n", - " [537.729227 ]]),\n", - " 196,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944262460.jpg'),\n", - " (array([[-390.16024928],\n", - " [ 471.30522301]]),\n", - " 104,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", - " (array([[551.21678294],\n", - " [517.36542622]]),\n", - " 189,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943662460.jpg'),\n", - " (array([[535.56973737],\n", - " [526.37906876]]),\n", - " 191,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943862460.jpg'),\n", - " (array([[483.36697783],\n", - " [592.47774876]]),\n", - " 214,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945862460.jpg'),\n", - " (array([[468.16157377],\n", - " [541.64421781]]),\n", - " 204,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944912460.jpg'),\n", - " (array([[518.59559706],\n", - " [527.29531139]]),\n", - " 194,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944112460.jpg'),\n", - " (array([[-246.47979916],\n", - " [ 467.76487113]]),\n", - " 112,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", - " (array([[433.71078802],\n", - " [518.9388887 ]]),\n", - " 197,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944362460.jpg'),\n", - " (array([[419.73951661],\n", - " [523.25666579]]),\n", - " 199,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944512460.jpg'),\n", - " (array([[429.92384806],\n", - " [627.96546057]]),\n", - " 222,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946612460.jpg'),\n", - " (array([[397.1967781],\n", - " [560.0107632]]),\n", - " 212,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945662460.jpg'),\n", - " (array([[404.20718079],\n", - " [528.41829584]]),\n", - " 202,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944762460.jpg'),\n", - " (array([[-96.05686527],\n", - " [466.77226529]]),\n", - " 120,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", - " (array([[298.78998074],\n", - " [508.56603138]]),\n", - " 205,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945112460.jpg'),\n", - " (array([[295.48584202],\n", - " [515.5302239 ]]),\n", - " 207,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945262460.jpg'),\n", - " (array([[308.84295767],\n", - " [559.37443269]]),\n", - " 220,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946412460.jpg'),\n", - " (array([[295.171748 ],\n", - " [525.41363821]]),\n", - " 210,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945512460.jpg'),\n", - " (array([[ 21.82581406],\n", - " [466.17966869]]),\n", - " 128,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg'),\n", - " (array([[181.03015093],\n", - " [505.05812131]]),\n", - " 213,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945762460.jpg'),\n", - " (array([[179.4617382 ],\n", - " [509.76318517]]),\n", - " 215,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945912460.jpg'),\n", - " (array([[179.37969128],\n", - " [517.64950642]]),\n", - " 218,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946162460.jpg'),\n", - " (array([[167.94271873],\n", - " [468.66110084]]),\n", - " 136,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939162460.jpg'),\n", - " (array([[180.03013938],\n", - " [531.49997773]]),\n", - " 221,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946512460.jpg'),\n", - " (array([[ 39.7280833],\n", - " [511.8248388]]),\n", - " 223,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946662460.jpg'),\n", - " (array([[231.19650004],\n", - " [465.56932048]]),\n", - " 144,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939862460.jpg'),\n", - " (array([[299.3325792 ],\n", - " [471.74163857]]),\n", - " 152,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940512460.jpg'),\n", - " (array([[339.7079059 ],\n", - " [477.32769374]]),\n", - " 160,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941162460.jpg'),\n", - " (array([[364.37817289],\n", - " [483.71069143]]),\n", - " 168,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941862460.jpg'),\n", - " (array([[332.45442414],\n", - " [487.27494077]]),\n", - " 176,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942612460.jpg'),\n", - " (array([[278.42816133],\n", - " [474.29204104]]),\n", - " 184,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943262460.jpg'),\n", - " (array([[123.96532519],\n", - " [454.25116194]]),\n", - " 192,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943912478.jpg'),\n", - " (array([[ 23.5076618 ],\n", - " [449.18974871]]),\n", - " 200,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944612460.jpg'),\n", - " (array([[-44.28980199],\n", - " [455.5825046 ]]),\n", - " 208,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945362460.jpg'),\n", - " (array([[-69.4499552 ],\n", - " [463.30739216]]),\n", - " 216,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946012460.jpg'),\n", - " (array([[-77.7597058 ],\n", - " [485.62339902]]),\n", - " 224,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946762460.jpg')],\n", - " [(array([[918.9666076 ],\n", - " [478.35580923]]),\n", - " 3,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", - " (array([[934.30081621],\n", - " [470.61960965]]),\n", - " 11,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", - " (array([[962.65294856],\n", - " [478.97631847]]),\n", - " 19,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", - " (array([[983.6924351],\n", - " [482.6133235]]),\n", - " 27,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", - " (array([[1011.32314606],\n", - " [ 485.10614389]]),\n", - " 35,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", - " (array([[1041.19614428],\n", - " [ 485.53589723]]),\n", - " 43,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", - " (array([[1066.00105575],\n", - " [ 492.99588171]]),\n", - " 51,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", - " (array([[928.68447316],\n", - " [477.02829624]]),\n", - " 9,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", - " (array([[1106.84383991],\n", - " [ 492.45328791]]),\n", - " 59,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", - " (array([[950.6754309 ],\n", - " [479.49179011]]),\n", - " 17,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", - " (array([[920.88629692],\n", - " [482.14357581]]),\n", - " 6,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", - " (array([[1183.25237668],\n", - " [ 487.74766981]]),\n", - " 67,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", - " (array([[976.00995183],\n", - " [482.77927969]]),\n", - " 25,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", - " (array([[917.88934595],\n", - " [481.71619737]]),\n", - " 5,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", - " (array([[917.5891076 ],\n", - " [480.54008711]]),\n", - " 4,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", - " (array([[939.11726091],\n", - " [484.62608409]]),\n", - " 14,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", - " (array([[1301.41515924],\n", - " [ 504.41644263]]),\n", - " 75,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", - " (array([[996.07488987],\n", - " [482.19843277]]),\n", - " 33,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", - " (array([[935.13700898],\n", - " [471.34742407]]),\n", - " 12,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", - " (array([[911.7980281 ],\n", - " [481.12883339]]),\n", - " 2,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", - " (array([[937.39141795],\n", - " [480.21601651]]),\n", - " 13,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", - " (array([[964.1846153 ],\n", - " [477.67935591]]),\n", - " 22,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", - " (array([[922.70612968],\n", - " [479.5055044 ]]),\n", - " 7,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", - " (array([[1017.81019253],\n", - " [ 484.17487376]]),\n", - " 41,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", - " (array([[929.37343106],\n", - " [472.65111323]]),\n", - " 10,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", - " (array([[956.67051682],\n", - " [477.67875863]]),\n", - " 20,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", - " (array([[959.50327632],\n", - " [476.64684825]]),\n", - " 21,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", - " (array([[979.40983748],\n", - " [479.48636007]]),\n", - " 30,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", - " (array([[939.16114867],\n", - " [485.89824866]]),\n", - " 15,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", - " (array([[1041.99531609],\n", - " [ 486.97054389]]),\n", - " 49,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", - " (array([[949.36483058],\n", - " [477.87020913]]),\n", - " 18,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", - " (array([[973.6970166 ],\n", - " [479.99282511]]),\n", - " 28,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", - " (array([[974.32201942],\n", - " [479.42288654]]),\n", - " 29,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", - " (array([[1002.25443952],\n", - " [ 487.19731164]]),\n", - " 38,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", - " (array([[962.593487 ],\n", - " [477.84791224]]),\n", - " 23,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", - " (array([[1066.47090683],\n", - " [ 488.87113473]]),\n", - " 57,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", - " (array([[968.63534425],\n", - " [481.2186418 ]]),\n", - " 26,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", - " (array([[996.80207068],\n", - " [483.89616307]]),\n", - " 36,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", - " (array([[1000.24758766],\n", - " [ 485.92670588]]),\n", - " 37,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", - " (array([[1024.63237029],\n", - " [ 479.2085053 ]]),\n", - " 46,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", - " (array([[982.51832544],\n", - " [478.12562986]]),\n", - " 31,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", - " (array([[1105.52423674],\n", - " [ 484.38169236]]),\n", - " 65,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", - " (array([[1020.04734085],\n", - " [ 480.84307363]]),\n", - " 45,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", - " (array([[989.59600965],\n", - " [480.52989386]]),\n", - " 34,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", - " (array([[1014.00426897],\n", - " [ 480.78149256]]),\n", - " 44,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", - " (array([[1047.12695364],\n", - " [ 484.6740583 ]]),\n", - " 54,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", - " (array([[1002.46272384],\n", - " [ 484.31696652]]),\n", - " 39,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", - " (array([[1010.71649702],\n", - " [ 479.87881576]]),\n", - " 42,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", - " (array([[1210.01934407],\n", - " [ 494.03980348]]),\n", - " 73,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", - " (array([[1037.64440365],\n", - " [ 485.28759545]]),\n", - " 53,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", - " (array([[1036.23559434],\n", - " [ 486.25656766]]),\n", - " 52,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", - " (array([[1076.72507179],\n", - " [ 484.90549517]]),\n", - " 62,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", - " (array([[1020.96163987],\n", - " [ 477.76954191]]),\n", - " 47,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", - " (array([[1068.23917735],\n", - " [ 485.80007845]]),\n", - " 60,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", - " (array([[1031.63789187],\n", - " [ 484.77852341]]),\n", - " 50,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", - " (array([[1069.68558263],\n", - " [ 484.01888514]]),\n", - " 61,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", - " (array([[1145.83542952],\n", - " [ 479.25758429]]),\n", - " 70,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", - " (array([[1044.36701504],\n", - " [ 481.95704183]]),\n", - " 55,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", - " (array([[1126.44358568],\n", - " [ 477.54788705]]),\n", - " 68,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", - " (array([[1056.79025607],\n", - " [ 483.88709557]]),\n", - " 58,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", - " (array([[1077.03285548],\n", - " [ 482.20505195]]),\n", - " 63,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", - " (array([[1235.64570048],\n", - " [ 485.90257814]]),\n", - " 76,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", - " (array([[1107.2631576 ],\n", - " [ 475.78380042]]),\n", - " 66,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", - " (array([[1134.88649615],\n", - " [ 476.94629608]]),\n", - " 69,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", - " (array([[1155.69880544],\n", - " [ 480.3062664 ]]),\n", - " 71,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", - " (array([[1204.73964037],\n", - " [ 487.43842273]]),\n", - " 74,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", - " (array([[1246.02626603],\n", - " [ 481.22067212]]),\n", - " 77,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", - " (array([[922.00010689],\n", - " [472.67203471]]),\n", - " 8,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", - " (array([[940.5647077 ],\n", - " [474.24784432]]),\n", - " 16,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", - " (array([[961.45825644],\n", - " [474.01647342]]),\n", - " 24,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", - " (array([[977.37497128],\n", - " [472.40847329]]),\n", - " 32,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", - " (array([[997.79435884],\n", - " [474.70601541]]),\n", - " 40,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", - " (array([[1017.00024729],\n", - " [ 472.6674407 ]]),\n", - " 48,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", - " (array([[1039.94523972],\n", - " [ 476.50711637]]),\n", - " 56,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", - " (array([[1078.03474236],\n", - " [ 474.54004563]]),\n", - " 64,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", - " (array([[1160.89335581],\n", - " [ 479.16472624]]),\n", - " 72,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg')],\n", - " [(array([[1334.16979537],\n", - " [ 493.48926404]]),\n", - " 3,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927762460.jpg'),\n", - " (array([[1389.60755336],\n", - " [ 485.95275086]]),\n", - " 11,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", - " (array([[1470.77193941],\n", - " [ 495.71643221]]),\n", - " 19,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", - " (array([[1548.27356027],\n", - " [ 500.51362509]]),\n", - " 27,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", - " (array([[1642.85448264],\n", - " [ 507.30413337]]),\n", - " 35,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", - " (array([[1760.24523066],\n", - " [ 515.63831002]]),\n", - " 43,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", - " (array([[1897.33083499],\n", - " [ 523.00173243]]),\n", - " 51,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", - " (array([[1376.19772933],\n", - " [ 490.80399168]]),\n", - " 9,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", - " (array([[2075.6571339 ],\n", - " [ 522.61659173]]),\n", - " 59,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", - " (array([[1445.29563971],\n", - " [ 496.52099834]]),\n", - " 17,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", - " (array([[1352.32684059],\n", - " [ 497.75699612]]),\n", - " 6,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928012460.jpg'),\n", - " (array([[2393.29064509],\n", - " [ 529.51636201]]),\n", - " 67,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", - " (array([[1530.51347196],\n", - " [ 499.61402755]]),\n", - " 25,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", - " (array([[1345.12820372],\n", - " [ 495.37813703]]),\n", - " 5,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927912477.jpg'),\n", - " (array([[1341.92599337],\n", - " [ 494.29400633]]),\n", - " 4,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927862460.jpg'),\n", - " (array([[1416.84743349],\n", - " [ 499.36593517]]),\n", - " 14,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", - " (array([[3011.48790978],\n", - " [ 591.40059152]]),\n", - " 75,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", - " (array([[1620.64435252],\n", - " [ 500.71280516]]),\n", - " 33,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", - " (array([[1402.15653753],\n", - " [ 484.87944081]]),\n", - " 12,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", - " (array([[1325.83104851],\n", - " [ 491.6046804 ]]),\n", - " 2,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402927662460.jpg'),\n", - " (array([[1413.84427991],\n", - " [ 493.51395695]]),\n", - " 13,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", - " (array([[1502.82124408],\n", - " [ 491.94671952]]),\n", - " 22,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", - " (array([[4317.88373012],\n", - " [ 682.66609454]]),\n", - " 83,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", - " (array([[1364.33015867],\n", - " [ 492.59905384]]),\n", - " 7,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928112460.jpg'),\n", - " (array([[1728.92213851],\n", - " [ 507.27762602]]),\n", - " 41,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", - " (array([[1387.83510571],\n", - " [ 483.2583813 ]]),\n", - " 10,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", - " (array([[1479.63500628],\n", - " [ 489.98387408]]),\n", - " 20,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", - " (array([[1491.1559859 ],\n", - " [ 489.82201559]]),\n", - " 21,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", - " (array([[9594.35568768],\n", - " [ 945.56135116]]),\n", - " 91,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", - " (array([[1582.98473398],\n", - " [ 493.56513366]]),\n", - " 30,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", - " (array([[1428.08384597],\n", - " [ 498.40077564]]),\n", - " 15,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", - " (array([[1869.34924517],\n", - " [ 510.81523434]]),\n", - " 49,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", - " (array([[1459.96998365],\n", - " [ 490.40090111]]),\n", - " 18,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", - " (array([[1563.68231708],\n", - " [ 493.02887577]]),\n", - " 28,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", - " (array([[1569.09036905],\n", - " [ 492.78240389]]),\n", - " 29,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", - " (array([[-12238.19076291],\n", - " [ -144.07861326]]),\n", - " 99,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", - " (array([[1686.02077303],\n", - " [ 506.88934867]]),\n", - " 38,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", - " (array([[1508.7854986],\n", - " [ 490.7448899]]),\n", - " 23,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", - " (array([[2033.35649489],\n", - " [ 513.35732523]]),\n", - " 57,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", - " (array([[1537.54571042],\n", - " [ 494.99734007]]),\n", - " 26,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", - " (array([[1661.09242073],\n", - " [ 501.79415069]]),\n", - " 36,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", - " (array([[1677.67386782],\n", - " [ 505.40240369]]),\n", - " 37,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", - " (array([[-2925.00023239],\n", - " [ 296.08977734]]),\n", - " 107,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", - " (array([[1812.61285953],\n", - " [ 506.08001214]]),\n", - " 46,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", - " (array([[1598.73880054],\n", - " [ 492.88145461]]),\n", - " 31,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", - " (array([[2266.47228454],\n", - " [ 514.49394135]]),\n", - " 65,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", - " (array([[1791.08725428],\n", - " [ 506.02278007]]),\n", - " 45,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", - " (array([[1637.10090392],\n", - " [ 497.88481392]]),\n", - " 34,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", - " (array([[1771.86281293],\n", - " [ 506.88654903]]),\n", - " 44,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", - " (array([[-1363.81150452],\n", - " [ 355.52916609]]),\n", - " 115,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", - " (array([[1962.54291572],\n", - " [ 509.41859226]]),\n", - " 54,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", - " (array([[1702.22784546],\n", - " [ 505.64373375]]),\n", - " 39,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", - " (array([[1746.25830208],\n", - " [ 503.20066242]]),\n", - " 42,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", - " (array([[2854.00303732],\n", - " [ 565.06263934]]),\n", - " 73,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", - " (array([[1933.46987609],\n", - " [ 512.57180642]]),\n", - " 53,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", - " (array([[1922.11099072],\n", - " [ 513.56712329]]),\n", - " 52,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", - " (array([[-567.98454982],\n", - " [ 388.10676481]]),\n", - " 123,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", - " (array([[2163.40351815],\n", - " [ 511.5050439 ]]),\n", - " 62,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", - " (array([[1823.17879224],\n", - " [ 505.78272028]]),\n", - " 47,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", - " (array([[-145.07626078],\n", - " [ 414.46314962]]),\n", - " 131,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", - " (array([[2111.1669045 ],\n", - " [ 512.84402673]]),\n", - " 60,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", - " (array([[3798.54962833],\n", - " [ 624.85418045]]),\n", - " 81,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", - " (array([[1880.44069966],\n", - " [ 509.36844547]]),\n", - " 50,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", - " (array([[2144.73212933],\n", - " [ 510.90938868]]),\n", - " 61,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", - " (array([[2560.07702842],\n", - " [ 528.20516066]]),\n", - " 70,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", - " (array([[1988.84696259],\n", - " [ 505.46746716]]),\n", - " 55,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", - " (array([[130.92177054],\n", - " [428.92178532]]),\n", - " 139,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939412460.jpg'),\n", - " (array([[7293.34115056],\n", - " [ 792.3444933 ]]),\n", - " 89,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", - " (array([[2457.5287999 ],\n", - " [ 516.96803273]]),\n", - " 68,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", - " (array([[2063.26422439],\n", - " [ 509.6815062 ]]),\n", - " 58,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", - " (array([[3330.0081002 ],\n", - " [ 596.41740393]]),\n", - " 78,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", - " (array([[2203.46101926],\n", - " [ 508.61030103]]),\n", - " 63,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", - " (array([[333.95815299],\n", - " [441.12677003]]),\n", - " 147,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940112460.jpg'),\n", - " (array([[-69966.13634961],\n", - " [ -2624.25124688]]),\n", - " 97,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", - " (array([[3139.45357837],\n", - " [ 573.76584115]]),\n", - " 76,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", - " (array([[2370.53631674],\n", - " [ 506.56923971]]),\n", - " 66,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", - " (array([[5351.9065425 ],\n", - " [ 691.95122916]]),\n", - " 86,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", - " (array([[2523.66139327],\n", - " [ 515.02200911]]),\n", - " 69,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", - " (array([[2636.04357223],\n", - " [ 525.66517185]]),\n", - " 71,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", - " (array([[451.52660173],\n", - " [453.69674391]]),\n", - " 155,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940762460.jpg'),\n", - " (array([[-4093.63228511],\n", - " [ 284.4593147 ]]),\n", - " 105,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", - " (array([[4483.11890656],\n", - " [ 660.74145848]]),\n", - " 84,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", - " (array([[2962.66127612],\n", - " [ 561.41081276]]),\n", - " 74,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", - " (array([[20942.22139975],\n", - " [ 1454.51329296]]),\n", - " 94,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", - " (array([[3266.78930893],\n", - " [ 578.92530151]]),\n", - " 77,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", - " (array([[3487.22347614],\n", - " [ 600.72924161]]),\n", - " 79,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", - " (array([[-1619.45202977],\n", - " [ 355.50597896]]),\n", - " 113,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", - " (array([[4035.06660466],\n", - " [ 630.34044678]]),\n", - " 82,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", - " (array([[12207.23830769],\n", - " [ 1000.5532177 ]]),\n", - " 92,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", - " (array([[-6300.16659239],\n", - " [ 233.54078401]]),\n", - " 102,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", - " (array([[4875.12621787],\n", - " [ 655.29112104]]),\n", - " 85,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", - " (array([[5664.43152995],\n", - " [ 681.31183935]]),\n", - " 87,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", - " (array([[1368.82648762],\n", - " [ 480.16483794]]),\n", - " 8,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", - " (array([[-753.43177409],\n", - " [ 405.09449463]]),\n", - " 121,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", - " (array([[-8983.72916493],\n", - " [ 133.20002434]]),\n", - " 100,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", - " (array([[7916.39739189],\n", - " [ 757.05111925]]),\n", - " 90,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", - " (array([[-2161.74657547],\n", - " [ 358.75709785]]),\n", - " 110,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", - " (array([[14208.21780603],\n", - " [ 1061.56632332]]),\n", - " 93,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", - " (array([[42552.56376655],\n", - " [ 2267.71507133]]),\n", - " 95,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", - " (array([[1440.58800669],\n", - " [ 483.87063008]]),\n", - " 16,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", - " (array([[-222.39598983],\n", - " [ 425.6985173 ]]),\n", - " 129,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", - " (array([[-18436.94401485],\n", - " [ -235.5205374 ]]),\n", - " 98,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", - " (array([[-2578.06191916],\n", - " [ 343.04277949]]),\n", - " 108,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", - " (array([[-1023.57393281],\n", - " [ 399.82420292]]),\n", - " 118,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", - " (array([[-7836.77073098],\n", - " [ 138.25218443]]),\n", - " 101,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", - " (array([[-5189.77143902],\n", - " [ 260.75404376]]),\n", - " 103,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", - " (array([[1521.2716716 ],\n", - " [ 483.23220441]]),\n", - " 24,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", - " (array([[ 78.46477317],\n", - " [434.96990542]]),\n", - " 137,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939262460.jpg'),\n", - " (array([[-3277.91348066],\n", - " [ 327.94114822]]),\n", - " 106,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", - " (array([[-1213.06720401],\n", - " [ 390.28448983]]),\n", - " 116,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", - " (array([[-378.33978788],\n", - " [ 413.42766334]]),\n", - " 126,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", - " (array([[-2419.97507212],\n", - " [ 352.40817858]]),\n", - " 109,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", - " (array([[-1918.1589017 ],\n", - " [ 365.92921522]]),\n", - " 111,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", - " (array([[1606.27469037],\n", - " [ 482.52891178]]),\n", - " 32,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", - " (array([[287.73359917],\n", - " [448.18425998]]),\n", - " 145,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939912460.jpg'),\n", - " (array([[-522.75388602],\n", - " [ 406.18971018]]),\n", - " 124,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", - " (array([[-1434.25279245],\n", - " [ 376.55102695]]),\n", - " 114,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", - " (array([[-22.48286438],\n", - " [434.55579559]]),\n", - " 134,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", - " (array([[-1080.19515163],\n", - " [ 401.79323176]]),\n", - " 117,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", - " (array([[-899.47614155],\n", - " [ 404.76404864]]),\n", - " 119,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", - " (array([[1720.6520529 ],\n", - " [ 493.31603142]]),\n", - " 40,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", - " (array([[431.39198808],\n", - " [458.2796738 ]]),\n", - " 153,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940612460.jpg'),\n", - " (array([[-650.44814099],\n", - " [ 403.49307083]]),\n", - " 122,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", - " (array([[-89.85205983],\n", - " [430.33395088]]),\n", - " 132,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", - " (array([[216.74693445],\n", - " [442.68513306]]),\n", - " 142,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939662460.jpg'),\n", - " (array([[-445.77973144],\n", - " [ 408.4382094 ]]),\n", - " 125,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", - " (array([[-342.31834094],\n", - " [ 420.26612689]]),\n", - " 127,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", - " (array([[1846.94446799],\n", - " [ 493.05089978]]),\n", - " 48,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", - " (array([[169.57565732],\n", - " [442.73277221]]),\n", - " 140,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939512460.jpg'),\n", - " (array([[-191.06916079],\n", - " [ 429.02591036]]),\n", - " 130,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", - " (array([[388.25724418],\n", - " [454.35308079]]),\n", - " 150,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940362460.jpg'),\n", - " (array([[-65.45392737],\n", - " [432.01765423]]),\n", - " 133,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", - " (array([[ 21.43047226],\n", - " [437.17051819]]),\n", - " 135,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", - " (array([[2006.16722985],\n", - " [ 493.30799461]]),\n", - " 56,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", - " (array([[348.7058409 ],\n", - " [443.06805837]]),\n", - " 148,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940162460.jpg'),\n", - " (array([[118.7280442 ],\n", - " [430.55182668]]),\n", - " 138,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939362460.jpg'),\n", - " (array([[202.3961626 ],\n", - " [435.16995854]]),\n", - " 141,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939612460.jpg'),\n", - " (array([[248.5355029 ],\n", - " [437.39155296]]),\n", - " 143,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939762460.jpg'),\n", - " (array([[2248.70178961],\n", - " [ 506.221173 ]]),\n", - " 64,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", - " (array([[315.31144454],\n", - " [441.12962301]]),\n", - " 146,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940012460.jpg'),\n", - " (array([[369.41877395],\n", - " [446.07508479]]),\n", - " 149,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940262460.jpg'),\n", - " (array([[401.26194107],\n", - " [444.39420303]]),\n", - " 151,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940412460.jpg'),\n", - " (array([[442.9872553 ],\n", - " [447.95230563]]),\n", - " 154,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940662460.jpg'),\n", - " (array([[2728.33435883],\n", - " [ 548.82053864]]),\n", - " 72,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", - " (array([[3713.89406241],\n", - " [ 623.64019153]]),\n", - " 80,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", - " (array([[6488.83020511],\n", - " [ 773.86342525]]),\n", - " 88,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", - " (array([[129029.85593204],\n", - " [ 7283.41587246]]),\n", - " 96,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", - " (array([[-4710.86829419],\n", - " [ 207.64534486]]),\n", - " 104,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", - " (array([[-1797.38359356],\n", - " [ 331.03228852]]),\n", - " 112,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", - " (array([[-787.26255686],\n", - " [ 380.07590207]]),\n", - " 120,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", - " (array([[-275.43111362],\n", - " [ 407.26954167]]),\n", - " 128,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg'),\n", - " (array([[ 43.84479905],\n", - " [420.4169285 ]]),\n", - " 136,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939162460.jpg'),\n", - " (array([[277.88184704],\n", - " [432.93068991]]),\n", - " 144,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939862460.jpg'),\n", - " (array([[416.99732922],\n", - " [443.16100883]]),\n", - " 152,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940512460.jpg')],\n", - " [(array([[1763.74207816],\n", - " [ 488.75530756]]),\n", - " 11,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928412460.jpg'),\n", - " (array([[1892.95478697],\n", - " [ 498.58501738]]),\n", - " 19,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", - " (array([[2020.85969582],\n", - " [ 503.13634373]]),\n", - " 27,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", - " (array([[2177.98709899],\n", - " [ 512.16221042]]),\n", - " 35,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", - " (array([[2377.69688921],\n", - " [ 525.4518165 ]]),\n", - " 43,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", - " (array([[2613.21251487],\n", - " [ 534.63957799]]),\n", - " 51,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", - " (array([[1740.87298894],\n", - " [ 494.99210676]]),\n", - " 9,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928262460.jpg'),\n", - " (array([[2931.96478894],\n", - " [ 531.17885458]]),\n", - " 59,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", - " (array([[1851.32888774],\n", - " [ 502.00627597]]),\n", - " 17,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", - " (array([[3538.52362835],\n", - " [ 545.72762104]]),\n", - " 67,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", - " (array([[1989.66255824],\n", - " [ 503.89735014]]),\n", - " 25,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", - " (array([[1804.81774341],\n", - " [ 505.86149015]]),\n", - " 14,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928662460.jpg'),\n", - " (array([[4935.16773879],\n", - " [ 663.00431348]]),\n", - " 75,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", - " (array([[2137.5242432 ],\n", - " [ 507.71634757]]),\n", - " 33,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", - " (array([[1781.02557493],\n", - " [ 490.00894965]]),\n", - " 12,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928512460.jpg'),\n", - " (array([[1798.2486935 ],\n", - " [ 500.85939795]]),\n", - " 13,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928612460.jpg'),\n", - " (array([[1940.82610603],\n", - " [ 499.54410959]]),\n", - " 22,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", - " (array([[9514.57398517],\n", - " [ 916.34303143]]),\n", - " 83,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", - " (array([[2317.65746164],\n", - " [ 520.49070056]]),\n", - " 41,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", - " (array([[1756.9517107 ],\n", - " [ 488.92259755]]),\n", - " 10,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928362460.jpg'),\n", - " (array([[1903.00167391],\n", - " [ 496.36090558]]),\n", - " 20,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", - " (array([[1921.77493295],\n", - " [ 496.82842557]]),\n", - " 21,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", - " (array([[-36621.82542885],\n", - " [ -1257.58193908]]),\n", - " 91,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", - " (array([[2073.89641794],\n", - " [ 500.57406419]]),\n", - " 30,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", - " (array([[1821.74806672],\n", - " [ 505.78587025]]),\n", - " 15,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", - " (array([[2559.38070834],\n", - " [ 524.68969179]]),\n", - " 49,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", - " (array([[1871.89371681],\n", - " [ 497.25430072]]),\n", - " 18,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", - " (array([[2041.81835793],\n", - " [ 499.51131208]]),\n", - " 28,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", - " (array([[2051.04210295],\n", - " [ 499.48054539]]),\n", - " 29,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", - " (array([[-4313.60591745],\n", - " [ 268.94391563]]),\n", - " 99,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", - " (array([[2245.26288265],\n", - " [ 518.65685678]]),\n", - " 38,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", - " (array([[1950.73800879],\n", - " [ 498.22042082]]),\n", - " 23,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", - " (array([[2849.73481313],\n", - " [ 526.7416395 ]]),\n", - " 57,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", - " (array([[1998.61011535],\n", - " [ 502.41004311]]),\n", - " 26,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", - " (array([[2203.35427615],\n", - " [ 511.63469261]]),\n", - " 36,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", - " (array([[2231.21438747],\n", - " [ 516.38709993]]),\n", - " 37,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", - " (array([[-1860.08798675],\n", - " [ 365.10725419]]),\n", - " 107,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", - " (array([[2461.23985853],\n", - " [ 523.12756367]]),\n", - " 46,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", - " (array([[2099.77062281],\n", - " [ 501.42215792]]),\n", - " 31,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", - " (array([[3281.6401809 ],\n", - " [ 531.81146748]]),\n", - " 65,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", - " (array([[2424.44982309],\n", - " [ 521.76912184]]),\n", - " 45,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", - " (array([[2163.35587354],\n", - " [ 507.35929852]]),\n", - " 34,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", - " (array([[2391.49015951],\n", - " [ 522.47083636]]),\n", - " 44,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", - " (array([[-959.45746244],\n", - " [ 389.29450515]]),\n", - " 115,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", - " (array([[2723.53544638],\n", - " [ 522.66571441]]),\n", - " 54,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", - " (array([[2272.90321836],\n", - " [ 518.00723333]]),\n", - " 39,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", - " (array([[2347.56498482],\n", - " [ 516.93477507]]),\n", - " 42,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", - " (array([[4539.15667046],\n", - " [ 621.95696956]]),\n", - " 73,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", - " (array([[2672.15694402],\n", - " [ 527.00003925]]),\n", - " 53,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", - " (array([[2652.17165248],\n", - " [ 528.3117112 ]]),\n", - " 52,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", - " (array([[3087.43457102],\n", - " [ 524.06276373]]),\n", - " 62,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", - " (array([[2479.61355242],\n", - " [ 522.03143801]]),\n", - " 47,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", - " (array([[2991.26265631],\n", - " [ 527.91736896]]),\n", - " 60,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", - " (array([[7327.22838477],\n", - " [ 772.40140606]]),\n", - " 81,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", - " (array([[2579.18421002],\n", - " [ 522.48760148]]),\n", - " 50,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", - " (array([[3053.09386843],\n", - " [ 522.99741821]]),\n", - " 61,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", - " (array([[3875.53260913],\n", - " [ 559.15050497]]),\n", - " 70,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", - " (array([[2770.56657145],\n", - " [ 517.52730467]]),\n", - " 55,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", - " (array([[132254.2032417 ],\n", - " [ 6158.68390686]]),\n", - " 89,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", - " (array([[3660.95311091],\n", - " [ 539.29516287]]),\n", - " 68,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", - " (array([[2904.18884418],\n", - " [ 521.60636136]]),\n", - " 58,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", - " (array([[5789.91253648],\n", - " [ 701.72285637]]),\n", - " 78,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", - " (array([[3162.52267533],\n", - " [ 524.99144491]]),\n", - " 63,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", - " (array([[-6391.61821153],\n", - " [ 193.53107951]]),\n", - " 97,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", - " (array([[5262.7180265 ],\n", - " [ 659.72962111]]),\n", - " 76,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", - " (array([[3485.74724745],\n", - " [ 524.91694819]]),\n", - " 66,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", - " (array([[16822.49226445],\n", - " [ 1175.80247164]]),\n", - " 86,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", - " (array([[3798.12983269],\n", - " [ 547.23573123]]),\n", - " 69,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", - " (array([[4040.12495322],\n", - " [ 565.55649331]]),\n", - " 71,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", - " (array([[-2377.75777919],\n", - " [ 360.98452645]]),\n", - " 105,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", - " (array([[10370.51964984],\n", - " [ 911.4085527 ]]),\n", - " 84,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", - " (array([[4806.81279094],\n", - " [ 625.96055907]]),\n", - " 74,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", - " (array([[-11324.38673545],\n", - " [ -57.68882787]]),\n", - " 94,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", - " (array([[5610.9021139 ],\n", - " [ 676.52250281]]),\n", - " 77,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", - " (array([[6264.93143316],\n", - " [ 722.01644412]]),\n", - " 79,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", - " (array([[-1126.20070455],\n", - " [ 388.96701439]]),\n", - " 113,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", - " (array([[8250.18752709],\n", - " [ 798.73996873]]),\n", - " 82,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", - " (array([[-19447.78759865],\n", - " [ -246.11616834]]),\n", - " 92,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", - " (array([[-3124.8464056 ],\n", - " [ 359.99726503]]),\n", - " 102,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", - " (array([[12756.44898788],\n", - " [ 950.59444144]]),\n", - " 85,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", - " (array([[20450.50664954],\n", - " [ 1210.62916507]]),\n", - " 87,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", - " (array([[1727.04328133],\n", - " [ 485.40808072]]),\n", - " 8,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928162460.jpg'),\n", - " (array([[-3768.3860499 ],\n", - " [ 336.67076915]]),\n", - " 100,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", - " (array([[-455607.76616045],\n", - " [ -15126.82302646]]),\n", - " 90,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", - " (array([[-1465.8831346 ],\n", - " [ 399.94266756]]),\n", - " 110,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", - " (array([[-16147.20037523],\n", - " [ -172.90966267]]),\n", - " 93,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", - " (array([[-8877.29023712],\n", - " [ 118.01071518]]),\n", - " 95,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", - " (array([[1840.41773096],\n", - " [ 488.65592437]]),\n", - " 16,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", - " (array([[-5045.30355218],\n", - " [ 302.59473363]]),\n", - " 98,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", - " (array([[-1708.12294312],\n", - " [ 396.10998098]]),\n", - " 108,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", - " (array([[-736.40159547],\n", - " [ 424.43457679]]),\n", - " 118,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", - " (array([[-3581.68530432],\n", - " [ 336.61371396]]),\n", - " 101,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", - " (array([[-2830.74303286],\n", - " [ 369.32132877]]),\n", - " 103,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", - " (array([[1968.03195486],\n", - " [ 486.2022638 ]]),\n", - " 24,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", - " (array([[-2073.93215781],\n", - " [ 390.39045714]]),\n", - " 106,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", - " (array([[-877.96671195],\n", - " [ 416.85619328]]),\n", - " 116,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", - " (array([[-1635.53637171],\n", - " [ 397.28191752]]),\n", - " 109,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", - " (array([[-1342.61625807],\n", - " [ 402.01506971]]),\n", - " 111,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", - " (array([[2105.69317403],\n", - " [ 486.68475955]]),\n", - " 32,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", - " (array([[-1022.08777965],\n", - " [ 408.20514969]]),\n", - " 114,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", - " (array([[-778.06833532],\n", - " [ 425.56365574]]),\n", - " 117,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", - " (array([[2299.39969253],\n", - " [ 500.76242296]]),\n", - " 40,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", - " (array([[2514.06274935],\n", - " [ 501.16637483]]),\n", - " 48,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", - " (array([[2791.21131186],\n", - " [ 497.54223391]]),\n", - " 56,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", - " (array([[3232.04582849],\n", - " [ 500.36443283]]),\n", - " 64,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", - " (array([[4224.21766772],\n", - " [ 550.21853486]]),\n", - " 72,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", - " (array([[6934.54180159],\n", - " [ 687.3439066 ]]),\n", - " 80,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", - " (array([[35771.62818619],\n", - " [ 1664.9352707 ]]),\n", - " 88,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", - " (array([[-7807.94818485],\n", - " [ 175.80841311]]),\n", - " 96,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", - " (array([[-2646.02351496],\n", - " [ 381.48005719]]),\n", - " 104,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", - " (array([[-1254.17646691],\n", - " [ 406.91481689]]),\n", - " 112,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg')],\n", - " [(array([[496.18281536],\n", - " [463.85992363]]),\n", - " 19,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929112460.jpg'),\n", - " (array([[476.49463914],\n", - " [466.94515188]]),\n", - " 27,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", - " (array([[459.66755016],\n", - " [466.316318 ]]),\n", - " 35,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", - " (array([[433.6610762 ],\n", - " [460.94503912]]),\n", - " 43,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", - " (array([[407.4289932 ],\n", - " [469.27009466]]),\n", - " 51,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", - " (array([[382.40186933],\n", - " [470.40659959]]),\n", - " 59,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", - " (array([[497.55337676],\n", - " [462.6833628 ]]),\n", - " 17,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928912460.jpg'),\n", - " (array([[370.93339852],\n", - " [460.43657268]]),\n", - " 67,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", - " (array([[481.87636102],\n", - " [466.70652884]]),\n", - " 25,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", - " (array([[406.84031694],\n", - " [459.5297565 ]]),\n", - " 75,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", - " (array([[462.95097165],\n", - " [464.20738515]]),\n", - " 33,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", - " (array([[489.76752838],\n", - " [461.48739452]]),\n", - " 22,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", - " (array([[475.79693965],\n", - " [478.56675564]]),\n", - " 83,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", - " (array([[442.23487292],\n", - " [461.99665657]]),\n", - " 41,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", - " (array([[495.28620834],\n", - " [462.72053116]]),\n", - " 20,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929162460.jpg'),\n", - " (array([[492.58784877],\n", - " [460.96731042]]),\n", - " 21,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", - " (array([[602.39049608],\n", - " [482.22012502]]),\n", - " 91,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", - " (array([[467.88649686],\n", - " [463.39908691]]),\n", - " 30,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", - " (array([[498.75713026],\n", - " [469.95502078]]),\n", - " 15,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928762460.jpg'),\n", - " (array([[415.31179251],\n", - " [464.85581635]]),\n", - " 49,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", - " (array([[496.80325486],\n", - " [463.00912525]]),\n", - " 18,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929012460.jpg'),\n", - " (array([[472.92469507],\n", - " [465.43215304]]),\n", - " 28,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", - " (array([[470.53785151],\n", - " [464.61581408]]),\n", - " 29,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", - " (array([[775.082835 ],\n", - " [494.97539469]]),\n", - " 99,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", - " (array([[450.9875994 ],\n", - " [467.47865277]]),\n", - " 38,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", - " (array([[488.42184553],\n", - " [462.29659685]]),\n", - " 23,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", - " (array([[387.86190422],\n", - " [468.96121586]]),\n", - " 57,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", - " (array([[479.30576531],\n", - " [466.38049888]]),\n", - " 26,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", - " (array([[455.95108964],\n", - " [466.81154065]]),\n", - " 36,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", - " (array([[452.74303946],\n", - " [467.77553433]]),\n", - " 37,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", - " (array([[978.09655538],\n", - " [503.79155885]]),\n", - " 107,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", - " (array([[423.52832555],\n", - " [455.77240407]]),\n", - " 46,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", - " (array([[466.56513084],\n", - " [462.18013267]]),\n", - " 31,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", - " (array([[370.19421807],\n", - " [464.15716344]]),\n", - " 65,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", - " (array([[426.35411352],\n", - " [458.50430043]]),\n", - " 45,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", - " (array([[460.22150667],\n", - " [464.86860759]]),\n", - " 34,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", - " (array([[430.47784105],\n", - " [459.46570713]]),\n", - " 44,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", - " (array([[1215.13005351],\n", - " [ 517.49788667]]),\n", - " 115,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", - " (array([[397.50296496],\n", - " [466.25785007]]),\n", - " 54,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", - " (array([[446.98571284],\n", - " [465.42968722]]),\n", - " 39,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", - " (array([[438.11333101],\n", - " [459.80872805]]),\n", - " 42,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", - " (array([[396.23498697],\n", - " [460.47433988]]),\n", - " 73,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", - " (array([[399.52293397],\n", - " [466.5763337 ]]),\n", - " 53,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", - " (array([[402.26658748],\n", - " [466.79087166]]),\n", - " 52,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", - " (array([[1591.0519044 ],\n", - " [ 542.90095551]]),\n", - " 123,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", - " (array([[374.16741569],\n", - " [468.75568146]]),\n", - " 62,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", - " (array([[421.73899527],\n", - " [456.18090882]]),\n", - " 47,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", - " (array([[2172.48155924],\n", - " [ 584.03382768]]),\n", - " 131,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", - " (array([[379.26192413],\n", - " [467.77162128]]),\n", - " 60,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", - " (array([[450.44006275],\n", - " [463.21764733]]),\n", - " 81,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", - " (array([[413.5389048 ],\n", - " [465.77719625]]),\n", - " 50,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", - " (array([[375.5292233 ],\n", - " [468.51821205]]),\n", - " 61,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", - " (array([[377.88448708],\n", - " [454.79052143]]),\n", - " 70,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", - " (array([[392.71893971],\n", - " [465.89722061]]),\n", - " 55,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", - " (array([[3446.72625743],\n", - " [ 678.55712222]]),\n", - " 139,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939412460.jpg'),\n", - " (array([[568.99472662],\n", - " [477.88762346]]),\n", - " 89,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", - " (array([[372.3838071 ],\n", - " [456.44599892]]),\n", - " 68,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", - " (array([[384.29850356],\n", - " [467.14670988]]),\n", - " 58,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", - " (array([[423.41132742],\n", - " [445.18106383]]),\n", - " 78,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", - " (array([[372.46862174],\n", - " [465.3473438 ]]),\n", - " 63,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", - " (array([[11227.41465461],\n", - " [ 1305.10013652]]),\n", - " 147,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940112460.jpg'),\n", - " (array([[715.72998884],\n", - " [487.12567927]]),\n", - " 97,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", - " (array([[415.06628304],\n", - " [448.59715109]]),\n", - " 76,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", - " (array([[370.96347352],\n", - " [456.40599274]]),\n", - " 66,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", - " (array([[518.69997983],\n", - " [477.35519051]]),\n", - " 86,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", - " (array([[375.43229966],\n", - " [452.79479456]]),\n", - " 69,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", - " (array([[382.81785704],\n", - " [453.50096693]]),\n", - " 71,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", - " (array([[-8661.35074283],\n", - " [ -197.1535286 ]]),\n", - " 155,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940762460.jpg'),\n", - " (array([[907.6447258 ],\n", - " [491.59508477]]),\n", - " 105,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", - " (array([[483.95451641],\n", - " [471.52928793]]),\n", - " 84,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", - " (array([[404.55214183],\n", - " [454.33382663]]),\n", - " 74,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", - " (array([[658.34965994],\n", - " [479.07352025]]),\n", - " 94,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", - " (array([[421.08909984],\n", - " [441.56446508]]),\n", - " 77,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", - " (array([[431.8656152 ],\n", - " [447.87492429]]),\n", - " 79,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", - " (array([[-2734.45655963],\n", - " [ 260.1796133 ]]),\n", - " 163,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941412460.jpg'),\n", - " (array([[1153.74928516],\n", - " [ 503.33900289]]),\n", - " 113,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", - " (array([[462.23794051],\n", - " [466.70003803]]),\n", - " 82,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", - " (array([[625.31197923],\n", - " [475.08022179]]),\n", - " 92,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", - " (array([[841.15582781],\n", - " [488.46063527]]),\n", - " 102,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", - " (array([[500.76521527],\n", - " [470.06683758]]),\n", - " 85,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", - " (array([[529.6368878 ],\n", - " [475.56384114]]),\n", - " 87,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", - " (array([[-1436.05147365],\n", - " [ 346.44577754]]),\n", - " 171,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942112460.jpg'),\n", - " (array([[1461.48629681],\n", - " [ 538.0783443 ]]),\n", - " 121,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", - " (array([[800.98606836],\n", - " [496.65446411]]),\n", - " 100,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", - " (array([[579.25669381],\n", - " [481.43830195]]),\n", - " 90,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", - " (array([[1058.97458196],\n", - " [ 508.83792699]]),\n", - " 110,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", - " (array([[635.9456918 ],\n", - " [484.05681884]]),\n", - " 93,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", - " (array([[680.06906325],\n", - " [490.96689125]]),\n", - " 95,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", - " (array([[497.92838466],\n", - " [464.25291371]]),\n", - " 16,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402928862460.jpg'),\n", - " (array([[-899.76545175],\n", - " [ 344.68833869]]),\n", - " 179,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942862460.jpg'),\n", - " (array([[2007.0268121 ],\n", - " [ 576.85521896]]),\n", - " 129,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", - " (array([[750.29348443],\n", - " [495.82945376]]),\n", - " 98,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", - " (array([[1009.35579411],\n", - " [ 508.0768722 ]]),\n", - " 108,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", - " (array([[1326.82831576],\n", - " [ 526.8156636 ]]),\n", - " 118,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", - " (array([[814.63323149],\n", - " [498.2230044 ]]),\n", - " 101,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", - " (array([[866.50334676],\n", - " [500.34335557]]),\n", - " 103,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", - " (array([[485.90405022],\n", - " [465.49292095]]),\n", - " 24,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", - " (array([[-630.46524613],\n", - " [ 362.84964447]]),\n", - " 187,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943512460.jpg'),\n", - " (array([[3023.54852619],\n", - " [ 661.75594464]]),\n", - " 137,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939262460.jpg'),\n", - " (array([[951.15005629],\n", - " [503.00903588]]),\n", - " 106,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", - " (array([[1257.87300125],\n", - " [ 524.46586343]]),\n", - " 116,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", - " (array([[1776.3217962],\n", - " [ 558.557604 ]]),\n", - " 126,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", - " (array([[1025.5826839 ],\n", - " [ 509.42714008]]),\n", - " 109,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", - " (array([[1094.30684065],\n", - " [ 511.60477227]]),\n", - " 111,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", - " (array([[465.2184913 ],\n", - " [463.28389066]]),\n", - " 32,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", - " (array([[-433.62019493],\n", - " [ 374.0423058 ]]),\n", - " 195,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944162460.jpg'),\n", - " (array([[6717.13689228],\n", - " [1000.19599524]]),\n", - " 145,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939912460.jpg'),\n", - " (array([[1625.54845926],\n", - " [ 550.19729104]]),\n", - " 124,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", - " (array([[1194.07018947],\n", - " [ 520.63015728]]),\n", - " 114,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", - " (array([[2521.61036646],\n", - " [ 625.08616979]]),\n", - " 134,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", - " (array([[1302.92093841],\n", - " [ 526.65421497]]),\n", - " 117,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", - " (array([[-252.73279498],\n", - " [ 387.90420502]]),\n", - " 203,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944862460.jpg'),\n", - " (array([[1379.75972332],\n", - " [ 530.8646496 ]]),\n", - " 119,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", - " (array([[444.03092218],\n", - " [463.6653 ]]),\n", - " 40,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", - " (array([[-15059.5964565 ],\n", - " [ -859.46319025]]),\n", - " 153,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940612460.jpg'),\n", - " (array([[1524.03221438],\n", - " [ 546.77839957]]),\n", - " 122,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", - " (array([[2302.65599012],\n", - " [ 608.21602364]]),\n", - " 132,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", - " (array([[4517.71248662],\n", - " [ 780.35545653]]),\n", - " 142,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939662460.jpg'),\n", - " (array([[1697.68389592],\n", - " [ 551.51782176]]),\n", - " 125,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", - " (array([[-18.8802986],\n", - " [406.8320526]]),\n", - " 211,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945612460.jpg'),\n", - " (array([[1818.12876218],\n", - " [ 562.60115432]]),\n", - " 127,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", - " (array([[418.32508297],\n", - " [461.53007803]]),\n", - " 48,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", - " (array([[-3320.17910395],\n", - " [ 144.65288942]]),\n", - " 161,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941262460.jpg'),\n", - " (array([[3805.01602597],\n", - " [ 729.5134882 ]]),\n", - " 140,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939512460.jpg'),\n", - " (array([[2059.33663203],\n", - " [ 583.05070675]]),\n", - " 130,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", - " (array([[73955.23359842],\n", - " [ 6910.46595701]]),\n", - " 150,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940362460.jpg'),\n", - " (array([[2371.87839068],\n", - " [ 613.77276832]]),\n", - " 133,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", - " (array([[171.12817965],\n", - " [421.14314383]]),\n", - " 219,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946262460.jpg'),\n", - " (array([[2699.87544436],\n", - " [ 637.06346554]]),\n", - " 135,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", - " (array([[-1673.77575711],\n", - " [ 285.56190938]]),\n", - " 169,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941912460.jpg'),\n", - " (array([[391.51444901],\n", - " [469.49162813]]),\n", - " 56,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", - " (array([[13414.37453518],\n", - " [ 1610.00383145]]),\n", - " 148,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940162460.jpg'),\n", - " (array([[3292.88217027],\n", - " [ 687.05334214]]),\n", - " 138,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939362460.jpg'),\n", - " (array([[-4.86384044e+03],\n", - " [-3.79509297e+00]]),\n", - " 158,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941012460.jpg'),\n", - " (array([[4246.11832954],\n", - " [ 760.65904721]]),\n", - " 141,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939612460.jpg'),\n", - " (array([[5187.02644408],\n", - " [ 836.9545799 ]]),\n", - " 143,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939762460.jpg'),\n", - " (array([[-1010.24112635],\n", - " [ 345.27096062]]),\n", - " 177,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942662460.jpg'),\n", - " (array([[371.30401116],\n", - " [467.23083152]]),\n", - " 64,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", - " (array([[-6674.38830591],\n", - " [ -174.73182256]]),\n", - " 156,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940862460.jpg'),\n", - " (array([[8401.12521356],\n", - " [1171.11946262]]),\n", - " 146,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940012460.jpg'),\n", - " (array([[-2096.4550244 ],\n", - " [ 245.13056004]]),\n", - " 166,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941662460.jpg'),\n", - " (array([[22652.39695226],\n", - " [ 2406.05433003]]),\n", - " 149,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940262460.jpg'),\n", - " (array([[-402576.03237036],\n", - " [ -34515.23620512]]),\n", - " 151,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940412460.jpg'),\n", - " (array([[-687.43041253],\n", - " [ 358.86767905]]),\n", - " 185,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943362460.jpg'),\n", - " (array([[-12179.813863 ],\n", - " [ -615.72964846]]),\n", - " 154,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940662460.jpg'),\n", - " (array([[-2449.41033974],\n", - " [ 220.77187001]]),\n", - " 164,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941512460.jpg'),\n", - " (array([[387.77016942],\n", - " [462.25489149]]),\n", - " 72,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", - " (array([[-1210.90843146],\n", - " [ 323.4719665 ]]),\n", - " 174,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942362460.jpg'),\n", - " (array([[-5936.60980268],\n", - " [ -105.45385588]]),\n", - " 157,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940912460.jpg'),\n", - " (array([[-470.35154346],\n", - " [ 371.79472912]]),\n", - " 193,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944012460.jpg'),\n", - " (array([[-4108.36178014],\n", - " [ 66.62669302]]),\n", - " 159,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941112460.jpg'),\n", - " (array([[-2914.91315006],\n", - " [ 181.15530193]]),\n", - " 162,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941362460.jpg'),\n", - " (array([[-1386.12261807],\n", - " [ 307.69207825]]),\n", - " 172,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942162460.jpg'),\n", - " (array([[-784.89451156],\n", - " [ 357.40811365]]),\n", - " 182,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943112460.jpg'),\n", - " (array([[443.58897827],\n", - " [462.44008028]]),\n", - " 80,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", - " (array([[-2205.65772242],\n", - " [ 236.4667037 ]]),\n", - " 165,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941612460.jpg'),\n", - " (array([[-305.71761644],\n", - " [ 383.46021306]]),\n", - " 201,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944662460.jpg'),\n", - " (array([[-1910.18688809],\n", - " [ 263.75782547]]),\n", - " 167,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941762460.jpg'),\n", - " (array([[-876.60571163],\n", - " [ 343.90858704]]),\n", - " 180,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942912460.jpg'),\n", - " (array([[-1543.98928827],\n", - " [ 297.26406577]]),\n", - " 170,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942012460.jpg'),\n", - " (array([[-551.49508397],\n", - " [ 368.81447106]]),\n", - " 190,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943762460.jpg'),\n", - " (array([[550.01330401],\n", - " [483.97153043]]),\n", - " 88,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", - " (array([[-1293.5346371],\n", - " [ 314.5124184]]),\n", - " 173,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942262460.jpg'),\n", - " (array([[-80.81868022],\n", - " [405.49598538]]),\n", - " 209,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945412460.jpg'),\n", - " (array([[-1102.25296141],\n", - " [ 349.47231291]]),\n", - " 175,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942512460.jpg'),\n", - " (array([[-952.66890749],\n", - " [ 347.96321768]]),\n", - " 178,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942762460.jpg'),\n", - " (array([[-368.76018519],\n", - " [ 379.95068375]]),\n", - " 198,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944412460.jpg'),\n", - " (array([[-592.69839731],\n", - " [ 368.54148687]]),\n", - " 188,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943612460.jpg'),\n", - " (array([[692.0462208 ],\n", - " [490.50873819]]),\n", - " 96,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", - " (array([[-830.47348069],\n", - " [ 357.50802135]]),\n", - " 181,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943012460.jpg'),\n", - " (array([[128.34198747],\n", - " [422.28232653]]),\n", - " 217,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946112460.jpg'),\n", - " (array([[-762.98969359],\n", - " [ 366.55511001]]),\n", - " 183,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943162460.jpg'),\n", - " (array([[-163.74495667],\n", - " [ 396.98058929]]),\n", - " 206,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945162460.jpg'),\n", - " (array([[-669.72029657],\n", - " [ 365.28200584]]),\n", - " 186,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943412460.jpg'),\n", - " (array([[-406.29890442],\n", - " [ 380.48841097]]),\n", - " 196,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944262460.jpg'),\n", - " (array([[880.00717452],\n", - " [497.13722665]]),\n", - " 104,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", - " (array([[-578.16458305],\n", - " [ 375.41494499]]),\n", - " 189,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943662460.jpg'),\n", - " (array([[-518.50143957],\n", - " [ 379.1058063 ]]),\n", - " 191,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943862460.jpg'),\n", - " (array([[ 57.73493549],\n", - " [418.15530496]]),\n", - " 214,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945862460.jpg'),\n", - " (array([[-240.30225704],\n", - " [ 395.73000199]]),\n", - " 204,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944912460.jpg'),\n", - " (array([[-446.03477518],\n", - " [ 381.99908487]]),\n", - " 194,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944112460.jpg'),\n", - " (array([[1113.17991669],\n", - " [ 506.02474981]]),\n", - " 112,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", - " (array([[-380.5401912 ],\n", - " [ 387.31031095]]),\n", - " 197,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944362460.jpg'),\n", - " (array([[-346.14008476],\n", - " [ 388.88389967]]),\n", - " 199,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944512460.jpg'),\n", - " (array([[259.02856992],\n", - " [442.3003301 ]]),\n", - " 222,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946612460.jpg'),\n", - " (array([[ -3.94609605],\n", - " [415.70375607]]),\n", - " 212,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945662460.jpg'),\n", - " (array([[-279.49708865],\n", - " [ 395.36964825]]),\n", - " 202,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944762460.jpg'),\n", - " (array([[1435.11904824],\n", - " [ 525.53461682]]),\n", - " 120,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", - " (array([[-179.78039543],\n", - " [ 402.57885151]]),\n", - " 205,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945112460.jpg'),\n", - " (array([[-132.03142304],\n", - " [ 407.93060442]]),\n", - " 207,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945262460.jpg'),\n", - " (array([[212.49571206],\n", - " [433.60216383]]),\n", - " 220,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946412460.jpg'),\n", - " (array([[-49.48604037],\n", - " [415.99975636]]),\n", - " 210,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945512460.jpg'),\n", - " (array([[1908.30420214],\n", - " [ 559.78343109]]),\n", - " 128,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg'),\n", - " (array([[ 27.31568435],\n", - " [416.99149597]]),\n", - " 213,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945762460.jpg'),\n", - " (array([[ 71.99458805],\n", - " [420.98841768]]),\n", - " 215,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945912460.jpg'),\n", - " (array([[142.4808022 ],\n", - " [426.00374176]]),\n", - " 218,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946162460.jpg'),\n", - " (array([[2799.81542147],\n", - " [ 627.08459402]]),\n", - " 136,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939162460.jpg'),\n", - " (array([[234.99256674],\n", - " [436.47658822]]),\n", - " 221,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946512460.jpg'),\n", - " (array([[271.44681724],\n", - " [440.47068317]]),\n", - " 223,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946662460.jpg'),\n", - " (array([[6111.55804317],\n", - " [ 913.26955674]]),\n", - " 144,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939862460.jpg'),\n", - " (array([[-29530.13363847],\n", - " [ -1967.19821131]]),\n", - " 152,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940512460.jpg'),\n", - " (array([[-3811.8725237 ],\n", - " [ 117.15074743]]),\n", - " 160,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941162460.jpg'),\n", - " (array([[-1748.77979554],\n", - " [ 290.29252257]]),\n", - " 168,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941862460.jpg'),\n", - " (array([[-1039.41933151],\n", - " [ 355.33293558]]),\n", - " 176,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942612460.jpg'),\n", - " (array([[-721.9779478 ],\n", - " [ 366.14795992]]),\n", - " 184,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943262460.jpg'),\n", - " (array([[-500.55957554],\n", - " [ 369.97597621]]),\n", - " 192,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943912478.jpg'),\n", - " (array([[-320.03575805],\n", - " [ 381.67754865]]),\n", - " 200,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944612460.jpg'),\n", - " (array([[-97.74766935],\n", - " [401.8057509 ]]),\n", - " 208,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945362460.jpg'),\n", - " (array([[ 99.77023365],\n", - " [417.05573479]]),\n", - " 216,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946012460.jpg'),\n", - " (array([[296.01801208],\n", - " [439.27876819]]),\n", - " 224,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946762460.jpg')],\n", - " [(array([[649.6149932 ],\n", - " [471.91646019]]),\n", - " 27,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929762460.jpg'),\n", - " (array([[648.20071706],\n", - " [472.29300028]]),\n", - " 35,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930412460.jpg'),\n", - " (array([[641.7343638 ],\n", - " [468.83473819]]),\n", - " 43,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931112460.jpg'),\n", - " (array([[636.23693524],\n", - " [477.03553947]]),\n", - " 51,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931762460.jpg'),\n", - " (array([[634.77593916],\n", - " [477.53259181]]),\n", - " 59,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932412460.jpg'),\n", - " (array([[653.00590683],\n", - " [469.48910411]]),\n", - " 67,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933162460.jpg'),\n", - " (array([[651.45597299],\n", - " [471.53854499]]),\n", - " 25,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929612460.jpg'),\n", - " (array([[718.59921919],\n", - " [474.03842711]]),\n", - " 75,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933912460.jpg'),\n", - " (array([[647.8039724 ],\n", - " [469.76220017]]),\n", - " 33,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930262460.jpg'),\n", - " (array([[653.85511404],\n", - " [466.51532801]]),\n", - " 22,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929362460.jpg'),\n", - " (array([[818.96589834],\n", - " [495.99009904]]),\n", - " 83,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", - " (array([[644.39425766],\n", - " [468.68128586]]),\n", - " 41,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930912460.jpg'),\n", - " (array([[654.55777036],\n", - " [465.50663539]]),\n", - " 21,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929262460.jpg'),\n", - " (array([[980.86973459],\n", - " [499.60658381]]),\n", - " 91,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935262460.jpg'),\n", - " (array([[646.87393047],\n", - " [468.21504997]]),\n", - " 30,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930012460.jpg'),\n", - " (array([[639.07585007],\n", - " [471.84493861]]),\n", - " 49,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931612460.jpg'),\n", - " (array([[648.40519531],\n", - " [469.94925092]]),\n", - " 28,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929863782.jpg'),\n", - " (array([[647.21925296],\n", - " [468.68415083]]),\n", - " 29,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929912460.jpg'),\n", - " (array([[1218.9230824 ],\n", - " [ 513.73050319]]),\n", - " 99,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936012460.jpg'),\n", - " (array([[646.20244182],\n", - " [473.43687865]]),\n", - " 38,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930662460.jpg'),\n", - " (array([[653.58664561],\n", - " [466.76073354]]),\n", - " 23,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929412460.jpg'),\n", - " (array([[634.62935036],\n", - " [475.08071841]]),\n", - " 57,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932262460.jpg'),\n", - " (array([[650.10390622],\n", - " [470.83215121]]),\n", - " 26,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929662460.jpg'),\n", - " (array([[647.11355557],\n", - " [472.11082346]]),\n", - " 36,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930512460.jpg'),\n", - " (array([[646.59445889],\n", - " [472.87822819]]),\n", - " 37,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930612460.jpg'),\n", - " (array([[1538.55294677],\n", - " [ 528.66543613]]),\n", - " 107,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936762460.jpg'),\n", - " (array([[639.36341628],\n", - " [462.94213021]]),\n", - " 46,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931362460.jpg'),\n", - " (array([[647.83356415],\n", - " [466.63156713]]),\n", - " 31,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930112460.jpg'),\n", - " (array([[642.09476744],\n", - " [470.32027307]]),\n", - " 65,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932912460.jpg'),\n", - " (array([[639.15548597],\n", - " [465.27866661]]),\n", - " 45,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931262460.jpg'),\n", - " (array([[647.58196548],\n", - " [469.07591639]]),\n", - " 34,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930362460.jpg'),\n", - " (array([[640.2023731 ],\n", - " [465.91021817]]),\n", - " 44,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931162460.jpg'),\n", - " (array([[1982.23991748],\n", - " [ 558.64540218]]),\n", - " 115,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937412460.jpg'),\n", - " (array([[635.0607517 ],\n", - " [471.74286901]]),\n", - " 54,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932012460.jpg'),\n", - " (array([[645.01335026],\n", - " [470.98515828]]),\n", - " 39,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930762460.jpg'),\n", - " (array([[643.22028132],\n", - " [465.79010497]]),\n", - " 42,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931012486.jpg'),\n", - " (array([[702.01476663],\n", - " [470.86065629]]),\n", - " 73,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933762460.jpg'),\n", - " (array([[633.6866405 ],\n", - " [472.16554278]]),\n", - " 53,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931912460.jpg'),\n", - " (array([[634.62170696],\n", - " [472.65358564]]),\n", - " 52,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931862460.jpg'),\n", - " (array([[2965.01413154],\n", - " [ 628.87193337]]),\n", - " 123,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938112460.jpg'),\n", - " (array([[636.27556295],\n", - " [473.46848882]]),\n", - " 62,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932662460.jpg'),\n", - " (array([[639.17263024],\n", - " [462.08249758]]),\n", - " 47,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931412460.jpg'),\n", - " (array([[6046.38747362],\n", - " [ 834.60476062]]),\n", - " 131,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938762460.jpg'),\n", - " (array([[635.44815736],\n", - " [472.64200681]]),\n", - " 60,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932512460.jpg'),\n", - " (array([[784.45967737],\n", - " [476.53817625]]),\n", - " 81,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", - " (array([[638.93673639],\n", - " [470.97455595]]),\n", - " 50,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931662460.jpg'),\n", - " (array([[635.68977244],\n", - " [470.65303199]]),\n", - " 61,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932612460.jpg'),\n", - " (array([[670.05456849],\n", - " [460.31919857]]),\n", - " 70,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933412460.jpg'),\n", - " (array([[634.07295077],\n", - " [468.58998417]]),\n", - " 55,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932112460.jpg'),\n", - " (array([[-25681.64238025],\n", - " [ -1271.57732744]]),\n", - " 139,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939412460.jpg'),\n", - " (array([[938.23425767],\n", - " [489.0890268 ]]),\n", - " 89,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935112460.jpg'),\n", - " (array([[658.67977669],\n", - " [460.73896358]]),\n", - " 68,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933262460.jpg'),\n", - " (array([[634.88469456],\n", - " [467.86819608]]),\n", - " 58,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932362460.jpg'),\n", - " (array([[746.56079918],\n", - " [455.53355222]]),\n", - " 78,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", - " (array([[638.57774615],\n", - " [466.98931604]]),\n", - " 63,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932762460.jpg'),\n", - " (array([[-3111.22311578],\n", - " [ 209.78280866]]),\n", - " 147,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940112460.jpg'),\n", - " (array([[1134.06334552],\n", - " [ 496.85451892]]),\n", - " 97,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935762460.jpg'),\n", - " (array([[731.48155992],\n", - " [454.61231388]]),\n", - " 76,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934012460.jpg'),\n", - " (array([[651.11281166],\n", - " [457.06092879]]),\n", - " 66,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933112460.jpg'),\n", - " (array([[874.40477361],\n", - " [484.93469171]]),\n", - " 86,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934862460.jpg'),\n", - " (array([[665.76853383],\n", - " [455.07501184]]),\n", - " 69,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933362467.jpg'),\n", - " (array([[678.87860204],\n", - " [456.69350372]]),\n", - " 71,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933512460.jpg'),\n", - " (array([[-1542.6411992 ],\n", - " [ 340.60388717]]),\n", - " 155,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940762460.jpg'),\n", - " (array([[1421.95483034],\n", - " [ 500.31614413]]),\n", - " 105,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936512460.jpg'),\n", - " (array([[829.88118639],\n", - " [480.35634217]]),\n", - " 84,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", - " (array([[714.39762927],\n", - " [462.0206686 ]]),\n", - " 74,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933862509.jpg'),\n", - " (array([[1055.00564307],\n", - " [ 490.61566724]]),\n", - " 94,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935512460.jpg'),\n", - " (array([[742.00363249],\n", - " [451.57521871]]),\n", - " 77,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934112460.jpg'),\n", - " (array([[759.43799094],\n", - " [458.59199587]]),\n", - " 79,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", - " (array([[-905.90785887],\n", - " [ 389.05189138]]),\n", - " 163,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941412460.jpg'),\n", - " (array([[1857.63463466],\n", - " [ 528.16683636]]),\n", - " 113,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937262460.jpg'),\n", - " (array([[801.08149713],\n", - " [476.80729539]]),\n", - " 82,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", - " (array([[1010.83218816],\n", - " [ 486.10448729]]),\n", - " 92,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935362460.jpg'),\n", - " (array([[1316.69138952],\n", - " [ 500.16076053]]),\n", - " 102,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936262460.jpg'),\n", - " (array([[851.44433328],\n", - " [481.32347216]]),\n", - " 85,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934762460.jpg'),\n", - " (array([[887.76439523],\n", - " [486.17949584]]),\n", - " 87,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934912460.jpg'),\n", - " (array([[-560.84442669],\n", - " [ 396.22466897]]),\n", - " 171,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942112460.jpg'),\n", - " (array([[2576.95465957],\n", - " [ 585.56971865]]),\n", - " 121,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937912460.jpg'),\n", - " (array([[1256.86142584],\n", - " [ 505.75190817]]),\n", - " 100,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936112460.jpg'),\n", - " (array([[951.62347413],\n", - " [489.11425889]]),\n", - " 90,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935162463.jpg'),\n", - " (array([[1680.02329617],\n", - " [ 525.84434611]]),\n", - " 110,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937012460.jpg'),\n", - " (array([[1025.02857288],\n", - " [ 494.04762935]]),\n", - " 93,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935412467.jpg'),\n", - " (array([[1084.92599196],\n", - " [ 500.80788227]]),\n", - " 95,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935612460.jpg'),\n", - " (array([[-375.01635328],\n", - " [ 401.79884527]]),\n", - " 179,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942862460.jpg'),\n", - " (array([[4842.40836835],\n", - " [ 720.59964531]]),\n", - " 129,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938612460.jpg'),\n", - " (array([[1183.45773694],\n", - " [ 503.71189817]]),\n", - " 98,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935912460.jpg'),\n", - " (array([[1592.09377858],\n", - " [ 522.5005283 ]]),\n", - " 108,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936862460.jpg'),\n", - " (array([[2232.61029421],\n", - " [ 556.81549102]]),\n", - " 118,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937662460.jpg'),\n", - " (array([[1276.8006295 ],\n", - " [ 507.93748117]]),\n", - " 101,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936162460.jpg'),\n", - " (array([[1356.62701278],\n", - " [ 509.88258305]]),\n", - " 103,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936362460.jpg'),\n", - " (array([[653.29079257],\n", - " [465.88515991]]),\n", - " 24,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402929512460.jpg'),\n", - " (array([[-266.61188561],\n", - " [ 404.6134723 ]]),\n", - " 187,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943512460.jpg'),\n", - " (array([[79858.76956704],\n", - " [ 5622.35083535]]),\n", - " 137,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939262460.jpg'),\n", - " (array([[1493.06152981],\n", - " [ 514.2839449 ]]),\n", - " 106,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936662460.jpg'),\n", - " (array([[2075.17091592],\n", - " [ 551.90742386]]),\n", - " 116,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937512460.jpg'),\n", - " (array([[3658.26639521],\n", - " [ 650.82132789]]),\n", - " 126,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938362460.jpg'),\n", - " (array([[1620.39937519],\n", - " [ 524.57168065]]),\n", - " 109,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936912460.jpg'),\n", - " (array([[1744.94575405],\n", - " [ 529.98622442]]),\n", - " 111,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937112460.jpg'),\n", - " (array([[647.75724773],\n", - " [463.74263567]]),\n", - " 32,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930162460.jpg'),\n", - " (array([[-176.18035822],\n", - " [ 407.36094185]]),\n", - " 195,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944162460.jpg'),\n", - " (array([[-4284.81126127],\n", - " [ 118.39310976]]),\n", - " 145,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939912460.jpg'),\n", - " (array([[3082.80486492],\n", - " [ 620.77874313]]),\n", - " 124,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938162460.jpg'),\n", - " (array([[1939.39727368],\n", - " [ 546.48734639]]),\n", - " 114,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937362460.jpg'),\n", - " (array([[10817.58126228],\n", - " [ 1128.78052911]]),\n", - " 134,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939012460.jpg'),\n", - " (array([[2176.80923465],\n", - " [ 555.09333999]]),\n", - " 117,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937612460.jpg'),\n", - " (array([[-73.33228214],\n", - " [413.98099849]]),\n", - " 203,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944862460.jpg'),\n", - " (array([[2360.73336698],\n", - " [ 565.9302092 ]]),\n", - " 119,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937762460.jpg'),\n", - " (array([[644.89919982],\n", - " [465.45111157]]),\n", - " 40,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402930862460.jpg'),\n", - " (array([[-1763.50450538],\n", - " [ 304.71030587]]),\n", - " 153,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940612460.jpg'),\n", - " (array([[2757.15536335],\n", - " [ 604.51266365]]),\n", - " 122,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938012460.jpg'),\n", - " (array([[7351.68305487],\n", - " [ 907.28551592]]),\n", - " 132,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938862460.jpg'),\n", - " (array([[-7633.52469353],\n", - " [ -73.09298362]]),\n", - " 142,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939662460.jpg'),\n", - " (array([[3342.87206704],\n", - " [ 631.85397964]]),\n", - " 125,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938262460.jpg'),\n", - " (array([[ 98.12858555],\n", - " [427.06649803]]),\n", - " 211,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945612460.jpg'),\n", - " (array([[3842.28513526],\n", - " [ 660.56473271]]),\n", - " 127,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938412460.jpg'),\n", - " (array([[639.03983397],\n", - " [463.24763083]]),\n", - " 48,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402931512460.jpg'),\n", - " (array([[-1021.22314783],\n", - " [ 360.61031633]]),\n", - " 161,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941262460.jpg'),\n", - " (array([[-13334.60410239],\n", - " [ -455.18082723]]),\n", - " 140,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939512460.jpg'),\n", - " (array([[5184.47188694],\n", - " [ 746.26745248]]),\n", - " 130,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938662460.jpg'),\n", - " (array([[-2282.44639082],\n", - " [ 258.79843684]]),\n", - " 150,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940362460.jpg'),\n", - " (array([[8224.07103817],\n", - " [ 964.11299362]]),\n", - " 133,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938912460.jpg'),\n", - " (array([[254.6379895 ],\n", - " [438.04009527]]),\n", - " 219,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946262460.jpg'),\n", - " (array([[16343.65784906],\n", - " [ 1474.28001824]]),\n", - " 135,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939112460.jpg'),\n", - " (array([[-634.48153013],\n", - " [ 390.54768532]]),\n", - " 169,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941912460.jpg'),\n", - " (array([[634.69121784],\n", - " [469.5908828 ]]),\n", - " 56,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932162460.jpg'),\n", - " (array([[-2910.74096584],\n", - " [ 206.79451016]]),\n", - " 148,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940162460.jpg'),\n", - " (array([[-46124.98984086],\n", - " [ -2630.76568596]]),\n", - " 138,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939362460.jpg'),\n", - " (array([[-1241.31315464],\n", - " [ 336.86375036]]),\n", - " 158,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941012460.jpg'),\n", - " (array([[-8956.4395699 ],\n", - " [ -161.17145588]]),\n", - " 141,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939612460.jpg'),\n", - " (array([[-5857.94351617],\n", - " [ 39.7605657 ]]),\n", - " 143,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939762460.jpg'),\n", - " (array([[-417.14437932],\n", - " [ 408.15329914]]),\n", - " 177,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942662460.jpg'),\n", - " (array([[641.27378612],\n", - " [467.28035728]]),\n", - " 64,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402932862460.jpg'),\n", - " (array([[-1413.75655701],\n", - " [ 321.3717477 ]]),\n", - " 156,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940862460.jpg'),\n", - " (array([[-3609.99520661],\n", - " [ 151.63762531]]),\n", - " 146,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940012460.jpg'),\n", - " (array([[-754.94988715],\n", - " [ 378.59927471]]),\n", - " 166,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941662460.jpg'),\n", - " (array([[-2563.18620043],\n", - " [ 238.13038919]]),\n", - " 149,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940262460.jpg'),\n", - " (array([[-2157.33740696],\n", - " [ 270.86522939]]),\n", - " 151,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940412460.jpg'),\n", - " (array([[-292.04165407],\n", - " [ 404.64521964]]),\n", - " 185,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943362460.jpg'),\n", - " (array([[-1686.57035618],\n", - " [ 309.5142111 ]]),\n", - " 154,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940662460.jpg'),\n", - " (array([[-841.89702856],\n", - " [ 375.00205519]]),\n", - " 164,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941512460.jpg'),\n", - " (array([[687.67312395],\n", - " [465.84533368]]),\n", - " 72,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402933612460.jpg'),\n", - " (array([[-487.59001772],\n", - " [ 401.68233576]]),\n", - " 174,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942362460.jpg'),\n", - " (array([[-1352.01256647],\n", - " [ 328.39089614]]),\n", - " 157,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940912460.jpg'),\n", - " (array([[-193.00256462],\n", - " [ 408.44910132]]),\n", - " 193,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944012460.jpg'),\n", - " (array([[-1144.7195687],\n", - " [ 347.8197937]]),\n", - " 159,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941112460.jpg'),\n", - " (array([[-943.52364641],\n", - " [ 368.66092273]]),\n", - " 162,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941362460.jpg'),\n", - " (array([[-545.37693005],\n", - " [ 396.24717279]]),\n", - " 172,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942162460.jpg'),\n", - " (array([[-331.55037913],\n", - " [ 409.64864617]]),\n", - " 182,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943112460.jpg'),\n", - " (array([[775.69721865],\n", - " [469.1435005 ]]),\n", - " 80,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg'),\n", - " (array([[-783.27872775],\n", - " [ 379.72314757]]),\n", - " 165,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941612460.jpg'),\n", - " (array([[-106.16613898],\n", - " [ 413.27678372]]),\n", - " 201,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944662460.jpg'),\n", - " (array([[-704.09045627],\n", - " [ 386.59373963]]),\n", - " 167,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941762460.jpg'),\n", - " (array([[-366.938234 ],\n", - " [ 408.00075326]]),\n", - " 180,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942912460.jpg'),\n", - " (array([[-595.76824929],\n", - " [ 401.76106936]]),\n", - " 170,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942012460.jpg'),\n", - " (array([[-233.27095378],\n", - " [ 413.07701685]]),\n", - " 190,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943762460.jpg'),\n", - " (array([[913.72293969],\n", - " [487.7798885 ]]),\n", - " 88,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935012460.jpg'),\n", - " (array([[-515.73858113],\n", - " [ 404.91605246]]),\n", - " 173,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942262460.jpg'),\n", - " (array([[ 49.82821722],\n", - " [433.27683258]]),\n", - " 209,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945412460.jpg'),\n", - " (array([[-450.02823151],\n", - " [ 424.69147566]]),\n", - " 175,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942512460.jpg'),\n", - " (array([[-395.7659521 ],\n", - " [ 416.43540908]]),\n", - " 178,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942762460.jpg'),\n", - " (array([[-142.28499738],\n", - " [ 417.5798493 ]]),\n", - " 198,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944412460.jpg'),\n", - " (array([[-249.37417375],\n", - " [ 415.48281307]]),\n", - " 188,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943612460.jpg'),\n", - " (array([[1101.54402704],\n", - " [ 493.90201857]]),\n", - " 96,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402935662460.jpg'),\n", - " (array([[-350.04780048],\n", - " [ 416.99212664]]),\n", - " 181,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943012460.jpg'),\n", - " (array([[217.91138945],\n", - " [444.561799 ]]),\n", - " 217,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946112460.jpg'),\n", - " (array([[-322.69292361],\n", - " [ 421.01853877]]),\n", - " 183,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943162460.jpg'),\n", - " (array([[-11.7547229 ],\n", - " [425.58269951]]),\n", - " 206,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945162460.jpg'),\n", - " (array([[-284.87263265],\n", - " [ 415.97171558]]),\n", - " 186,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943412460.jpg'),\n", - " (array([[-162.00983545],\n", - " [ 417.81381264]]),\n", - " 196,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944262460.jpg'),\n", - " (array([[1377.97607295],\n", - " [ 499.94679416]]),\n", - " 104,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402936412460.jpg'),\n", - " (array([[-243.51694901],\n", - " [ 417.7829449 ]]),\n", - " 189,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943662460.jpg'),\n", - " (array([[-217.59986609],\n", - " [ 420.4319389 ]]),\n", - " 191,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943862460.jpg'),\n", - " (array([[159.4889065 ],\n", - " [440.54216502]]),\n", - " 214,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945862460.jpg'),\n", - " (array([[-65.30498154],\n", - " [425.23437412]]),\n", - " 204,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944912460.jpg'),\n", - " (array([[-182.39461284],\n", - " [ 419.93690725]]),\n", - " 194,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944112460.jpg'),\n", - " (array([[1780.52499269],\n", - " [ 516.76123959]]),\n", - " 112,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937162460.jpg'),\n", - " (array([[-148.25931709],\n", - " [ 420.40786336]]),\n", - " 197,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944362460.jpg'),\n", - " (array([[-130.51744472],\n", - " [ 421.25473533]]),\n", - " 199,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944512460.jpg'),\n", - " (array([[331.23070314],\n", - " [459.53472034]]),\n", - " 222,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946612460.jpg'),\n", - " (array([[109.69670149],\n", - " [438.22906159]]),\n", - " 212,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945662460.jpg'),\n", - " (array([[-90.33545294],\n", - " [424.99304712]]),\n", - " 202,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944762460.jpg'),\n", - " (array([[2503.74867417],\n", - " [ 561.0516802 ]]),\n", - " 120,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402937862460.jpg'),\n", - " (array([[-22.98109663],\n", - " [423.73632445]]),\n", - " 205,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945112460.jpg'),\n", - " (array([[ 11.53500425],\n", - " [428.22538314]]),\n", - " 207,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945262460.jpg'),\n", - " (array([[290.52315947],\n", - " [447.91042476]]),\n", - " 220,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946412460.jpg'),\n", - " (array([[ 74.2477107 ],\n", - " [434.60615348]]),\n", - " 210,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945512460.jpg'),\n", - " (array([[4280.00169488],\n", - " [ 664.08561274]]),\n", - " 128,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402938512460.jpg'),\n", - " (array([[135.02248517],\n", - " [434.34476132]]),\n", - " 213,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945762460.jpg'),\n", - " (array([[171.30721444],\n", - " [437.53098623]]),\n", - " 215,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945912460.jpg'),\n", - " (array([[230.12831558],\n", - " [441.7999293 ]]),\n", - " 218,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946162460.jpg'),\n", - " (array([[22083.89175394],\n", - " [ 1715.99323471]]),\n", - " 136,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939162460.jpg'),\n", - " (array([[310.09439083],\n", - " [450.08909788]]),\n", - " 221,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946512460.jpg'),\n", - " (array([[342.56018639],\n", - " [454.04521018]]),\n", - " 223,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946662460.jpg'),\n", - " (array([[-4716.54929159],\n", - " [ 113.0792055 ]]),\n", - " 144,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402939862460.jpg'),\n", - " (array([[-1946.95364831],\n", - " [ 298.73657043]]),\n", - " 152,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402940512460.jpg'),\n", - " (array([[-1102.02208943],\n", - " [ 358.41101317]]),\n", - " 160,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941162460.jpg'),\n", - " (array([[-656.85153973],\n", - " [ 393.5900866 ]]),\n", - " 168,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402941862460.jpg'),\n", - " (array([[-427.60199952],\n", - " [ 415.11127003]]),\n", - " 176,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402942612460.jpg'),\n", - " (array([[-305.52829753],\n", - " [ 410.26901461]]),\n", - " 184,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943262460.jpg'),\n", - " (array([[-207.82702139],\n", - " [ 403.75614819]]),\n", - " 192,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402943912478.jpg'),\n", - " (array([[-114.75979851],\n", - " [ 407.46411729]]),\n", - " 200,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402944612460.jpg'),\n", - " (array([[ 37.26329421],\n", - " [420.89676481]]),\n", - " 208,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402945362460.jpg'),\n", - " (array([[194.28985395],\n", - " [432.49816981]]),\n", - " 216,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946012460.jpg'),\n", - " (array([[364.78888577],\n", - " [451.33761853]]),\n", - " 224,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402946762460.jpg')],\n", - " [(array([[41637.84698733],\n", - " [ 2286.82763324]]),\n", - " 83,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934612460.jpg'),\n", - " (array([[16513.28833205],\n", - " [ 1149.87423222]]),\n", - " 81,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934412460.jpg'),\n", - " (array([[9772.13459862],\n", - " [ 881.36468696]]),\n", - " 78,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934162460.jpg'),\n", - " (array([[71761.24126268],\n", - " [ 3705.96825885]]),\n", - " 84,\n", - " 'samples/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934662484.jpg'),\n", - " (array([[11456.36183895],\n", - " [ 972.44697493]]),\n", - " 79,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934262460.jpg'),\n", - " (array([[23330.9440194 ],\n", - " [ 1457.43190353]]),\n", - " 82,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934512460.jpg'),\n", - " (array([[14348.16422895],\n", - " [ 1068.40803444]]),\n", - " 80,\n", - " 'sweeps/CAM_FRONT/n015-2018-07-24-11-22-45+0800__CAM_FRONT__1532402934362460.jpg')]]" + "[[], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []]" ] }, - "execution_count": 13, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -12670,8 +3011,8 @@ }, { "cell_type": "code", - "execution_count": 14, - "id": "f82af262", + "execution_count": 17, + "id": "8c317508", "metadata": {}, "outputs": [ { @@ -12700,17 +3041,17 @@ }, { "cell_type": "code", - "execution_count": 15, - "id": "4ca906f9", + "execution_count": 18, + "id": "39186ac0", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(2004, 6)" + "(2183, 6)" ] }, - "execution_count": 15, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -12722,7 +3063,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d57045cc", + "id": "43b9020a", "metadata": {}, "outputs": [], "source": []