diff --git a/drake_stuff/mbp_robot_arm_joint_limit_stuff/Model_photo_testing.ipynb b/drake_stuff/mbp_robot_arm_joint_limit_stuff/Model_photo_testing.ipynb new file mode 100644 index 00000000..c272fca5 --- /dev/null +++ b/drake_stuff/mbp_robot_arm_joint_limit_stuff/Model_photo_testing.ipynb @@ -0,0 +1,1055 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "model_name = 'CERBERUS_ANYMAL_C_SENSOR_CONFIG_2'\n", + "model_name = 'Panda with Ignition position controller model'\n", + "model_name = 'ur5_rg2'\n", + "model_name = 'NAO with Ignition position controller'\n", + "model_name = 'mpl_right_arm'" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "gazebo_plugin_location = '/home/marcogg/ModelPhotoShoot/build/'\n", + "temp_dir = '/home/marcogg/repro/drake_stuff/mbp_robot_arm_joint_limit_stuff/temporal'\n", + "model_dir = '/home/marcogg/repro/drake_stuff/mbp_robot_arm_joint_limit_stuff/repos/' + model_name\n", + "model_file = 'model.sdf'" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "!mkdir -p $temp_dir/visual/pics/default_pose/" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/marcogg/repro/drake_stuff/mbp_robot_arm_joint_limit_stuff/repos/MPL right arm\n" + ] + } + ], + "source": [ + "%cd \"$model_dir\"" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/home/marcogg/repro/drake_stuff/mbp_robot_arm_joint_limit_stuff/repos/mpl_right_arm/model.sdf\n", + "end load\n", + "start init\n", + "end init\n", + "on world\n", + "end on world\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "waiting to load\n", + "update\n", + "update:scene\n", + "update:scene:init\n", + "update\n", + "update:scene:initialized: mpl_right_arm\n", + "vis cannot\n", + "update\n", + "^C\n" + ] + } + ], + "source": [ + "!GAZEBO_PLUGIN_PATH=$gazebo_plugin_location gzserver -s libmodelphotoshoot.so worlds/blank.world --propshop-save $temp_dir/visual/pics/default_pose/ --propshop-model \"$model_dir/$model_file\" --data-file $temp_dir/visual/pics/default_pose/poses.txt" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "!mkdir -p $temp_dir/visual/pics/random_pose/" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1;33mWarning [Model.cc:212]\u001b[0m Non-unique names detected in XML children of model with name[naoH25V40].\r\n" + ] + } + ], + "source": [ + "!GAZEBO_PLUGIN_PATH=$gazebo_plugin_location gzserver -s libmodelphotoshoot.so worlds/blank.world --propshop-save $temp_dir/visual/pics/random_pose/ --propshop-model \"$model_dir/$model_file\" --data-file $temp_dir/visual/pics/random_pose/poses.txt --random-joints" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import sys\n", + "from PIL import Image\n", + "\n", + "from pydrake.all import (\n", + " FindResourceOrThrow,\n", + " Parser,\n", + " AddMultibodyPlantSceneGraph,\n", + " ConnectMeshcatVisualizer,\n", + " DiagramBuilder,\n", + " JacobianWrtVariable,\n", + " Simulator,\n", + ")\n", + "from pydrake.geometry.render import (\n", + " ClippingRange,\n", + " DepthRange,\n", + " ColorRenderCamera,\n", + " RenderCameraCore,\n", + " DepthRenderCamera,\n", + " RenderLabel,\n", + " MakeRenderEngineVtk,\n", + " RenderEngineVtkParams,\n", + ")\n", + "from pydrake.geometry import (\n", + " DrakeVisualizer,\n", + " HalfSpace,\n", + " FrameId,\n", + ")\n", + "from pydrake.systems.sensors import (\n", + " CameraInfo,\n", + " RgbdSensor,\n", + ")\n", + "from pydrake.math import RigidTransform, RollPitchYaw\n", + "import pydrake.multibody as mb\n", + "import multibody_extras as me\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def xyz_rpy_deg(xyz, rpy_deg):\n", + " \"\"\"Shorthand for defining a pose.\"\"\"\n", + " rpy_deg = np.asarray(rpy_deg)\n", + " return RigidTransform(RollPitchYaw(rpy_deg * np.pi / 180), xyz)\n", + " \n", + "def make_parser(plant):\n", + " parser = Parser(plant)\n", + " parser.package_map().PopulateFromFolder(\"/home/marcogg/repro/drake_stuff/mbp_robot_arm_joint_limit_stuff/repos/\")\n", + " return parser\n", + "\n", + "def create_camera(builder, world_id, X_WB, color_camera, depth_camera, scene_graph):\n", + " sensor = RgbdSensor(\n", + " world_id, X_PB=X_WB,\n", + " color_camera=color_camera,\n", + " depth_camera=depth_camera)\n", + " builder.AddSystem(sensor)\n", + " builder.Connect(\n", + " scene_graph.get_query_output_port(),\n", + " sensor.query_object_input_port())\n", + " return sensor\n", + " \n", + "def generate_images_and_IoT(simulator, sensor, temp_directory, poses_dir, num_image):\n", + " \n", + " context = simulator.get_context()\n", + " sensor_context = sensor.GetMyMutableContextFromRoot(context)\n", + " \n", + " color = sensor.color_image_output_port().Eval(sensor_context).data\n", + " image = Image.frombytes('RGBA', (960,540), color)\n", + " \n", + " image.save( temp_directory + '/pics/' + poses_dir + '/' + str(num_image) + '_drake.png')\n", + " \n", + " with Image.open(temp_directory + '/pics/' + poses_dir + '/' + str(num_image) + '.png') as im1:\n", + " px1 = im1.load()\n", + " \n", + " with image as im2:\n", + " px2 = im2.load()\n", + " \n", + " union_count = 0\n", + " intersection = 0\n", + " for i in range(960):\n", + " for j in range(540):\n", + " if px1[i,j] != (204, 229,255) or px2[i,j] != (204, 229, 255,255):\n", + " union_count += 1\n", + " if px1[i,j] != (204, 229,255) and px2[i,j] != (204, 229, 255,255):\n", + " intersection +=1\n", + " print(intersection/union_count)\n", + " return im1, im2" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "pose_directory = 'default_pose'\n", + "temp_directory = temp_dir + '/visual/'" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 0 0\n", + "You can open the visualizer by visiting the following URL:\n", + "http://127.0.0.1:7001/static/\n", + "Connected to meshcat-server.\n" + ] + } + ], + "source": [ + "builder = DiagramBuilder()\n", + "plant, scene_graph = AddMultibodyPlantSceneGraph(builder, 0.0)\n", + "\n", + "parser = Parser(plant)\n", + "model = make_parser(plant).AddModelFromFile(model_file)\n", + "\n", + "model_bodies = me.get_bodies(plant, {model})\n", + "\n", + "frame_W = plant.world_frame()\n", + "frame_B = model_bodies[0].body_frame()\n", + "\n", + "if (len(plant.GetBodiesWeldedTo(plant.world_body())) <2):\n", + " plant.WeldFrames(frame_W, frame_B)\n", + "\n", + "#Creating cameras:\n", + "renderer_name = 'renderer'\n", + "scene_graph.AddRenderer(\n", + " renderer_name, MakeRenderEngineVtk(RenderEngineVtkParams()))\n", + "\n", + "#camera_info = CameraInfo(width=960, height=540, fov_y=0.62803)\n", + "camera_info = CameraInfo(width=960, height=540, focal_x=831.382036787, focal_y=831.382036787, center_x=480, center_y=270)\n", + "\n", + "# N.B. These properties are chosen arbitrarily.\n", + "color_camera = ColorRenderCamera(\n", + " RenderCameraCore(\n", + " renderer_name,\n", + " camera_info,\n", + " ClippingRange(0.01, 10.0),\n", + " RigidTransform()))\n", + "\n", + "depth_camera = DepthRenderCamera (\n", + " RenderCameraCore(\n", + " renderer_name,\n", + " camera_info,\n", + " ClippingRange(0.01, 10.0),\n", + " RigidTransform()),\n", + " DepthRange(0.01, 10.0))\n", + "\n", + "world_id = plant.GetBodyFrameIdOrThrow(plant.world_body().index())\n", + "\n", + "random_poses = {}\n", + "# Read camera translation calculated and applied on gazebo\n", + "# we read the random positions file as it contains everything:\n", + "trans_x = 0\n", + "trans_y = 0\n", + "trans_z = 0\n", + "with open (temp_directory + '/pics/' + pose_directory + '/poses.txt', 'r') as datafile:\n", + " for line in datafile:\n", + " if line.startswith(\"Translation:\"):\n", + " line_split = line.split(' ')\n", + " # we make the value negative since gazebo moved the robot \n", + " # and in drake we move the camera\n", + " trans_x = -float(line_split[1])\n", + " trans_y = -float(line_split[2])\n", + " trans_z = -float(line_split[3])\n", + " else:\n", + " line_split = line.split(' ')\n", + " if line_split[1] == 'nan':\n", + " random_poses[line_split[0]] = 0\n", + " else:\n", + " random_poses[line_split[0]] = float(line_split[1])\n", + "\n", + "print(trans_x, trans_y, trans_z)\n", + "\n", + "#Creating perspective cam\n", + "X_WB = xyz_rpy_deg([1.6 + trans_x, -1.6 + trans_y, 1.2 + trans_z], [-120, 0, 45])\n", + "sensor_perspective = create_camera(builder, world_id, X_WB, color_camera, depth_camera, scene_graph)\n", + "\n", + "#Creating top cam\n", + "X_WB = xyz_rpy_deg([0 + trans_x, 0 + trans_y, 2.2 + trans_z], [-180, 0, -90])\n", + "sensor_top = create_camera(builder, world_id, X_WB, color_camera, depth_camera, scene_graph)\n", + "\n", + "#Creating front cam\n", + "X_WB = xyz_rpy_deg([2.2 + trans_x, 0 + trans_y, 0 + trans_z], [-90, 0, 90])\n", + "sensor_front = create_camera(builder, world_id, X_WB, color_camera, depth_camera, scene_graph)\n", + "\n", + "#Creating side cam\n", + "X_WB = xyz_rpy_deg([0 + trans_x, 2.2 + trans_y, 0 + trans_z], [-90, 0, 180])\n", + "sensor_side = create_camera(builder, world_id, X_WB, color_camera, depth_camera, scene_graph)\n", + "\n", + "#Creating back cam\n", + "X_WB = xyz_rpy_deg([-2.2 + trans_x, 0 + trans_y, 0 + trans_z], [-90, 0, -90])\n", + "sensor_back = create_camera(builder, world_id, X_WB, color_camera, depth_camera, scene_graph)\n", + "\n", + "DrakeVisualizer.AddToBuilder(builder, scene_graph)\n", + "\n", + "plant.gravity_field().set_gravity_vector(np.array([0,0,0], dtype = np.float64))\n", + "\n", + "meshcat_vis = ConnectMeshcatVisualizer(builder, scene_graph, zmq_url=\"new\", open_browser=False)\n", + "\n", + "plant.Finalize()\n", + "diagram = builder.Build()\n", + "\n", + "simulator = Simulator(diagram)\n", + "simulator.Initialize()\n", + "\n", + "dofs = plant.num_actuated_dofs();\n", + "if (dofs != plant.num_positions()):\n", + " raise ValueError('Error on converted model: Num positions is not equal to num actuated dofs.')\n", + "\n", + "if (pose_directory == 'random_pose'):\n", + " joint_positions = [0] * dofs\n", + " for joint_name, pose in random_poses.items():\n", + " joint = plant.GetJointByName(joint_name)\n", + " joint_positions[joint.position_start()] = pose\n", + "\n", + " sim_plant_context = plant.GetMyContextFromRoot(simulator.get_mutable_context())\n", + " plant.get_actuation_input_port(model).FixValue(sim_plant_context, np.zeros((dofs,1)))\n", + " plant.SetPositions(sim_plant_context, model, joint_positions)\n", + "\n", + " simulator.AdvanceTo(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: '/home/marcogg/repro/drake_stuff/mbp_robot_arm_joint_limit_stuff/temporal/visual//pics/default_pose/1.png'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mim1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mim2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgenerate_images_and_IoT\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msimulator\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msensor_perspective\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtemp_directory\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpose_directory\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m\u001b[0m in \u001b[0;36mgenerate_images_and_IoT\u001b[0;34m(simulator, sensor, temp_directory, poses_dir, num_image)\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0mimage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msave\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0mtemp_directory\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'/pics/'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mposes_dir\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'/'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnum_image\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'_drake.png'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 31\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 32\u001b[0;31m \u001b[0;32mwith\u001b[0m \u001b[0mImage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtemp_directory\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'/pics/'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mposes_dir\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'/'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnum_image\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m'.png'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mim1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 33\u001b[0m \u001b[0mpx1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mim1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 34\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/lib/python3/dist-packages/PIL/Image.py\u001b[0m in \u001b[0;36mopen\u001b[0;34m(fp, mode)\u001b[0m\n\u001b[1;32m 2807\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2808\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfilename\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2809\u001b[0;31m \u001b[0mfp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbuiltins\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilename\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"rb\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2810\u001b[0m \u001b[0mexclusive_fp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2811\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '/home/marcogg/repro/drake_stuff/mbp_robot_arm_joint_limit_stuff/temporal/visual//pics/default_pose/1.png'" + ] + } + ], + "source": [ + "im1, im2 = generate_images_and_IoT(simulator, sensor_perspective, temp_directory, pose_directory, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'im1' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mim1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'im1' is not defined" + ] + } + ], + "source": [ + "im1" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'im2' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mim2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'im2' is not defined" + ] + } + ], + "source": [ + "im2" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.3243637040022321\n" + ] + } + ], + "source": [ + "im1, im2 = generate_images_and_IoT(simulator, sensor_top, temp_directory, pose_directory, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "im1" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "im2" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.16019912016670526\n" + ] + } + ], + "source": [ + "im1, im2 = generate_images_and_IoT(simulator, sensor_front, temp_directory, pose_directory, 3)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "im1" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "im2" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.1464219318687649\n" + ] + } + ], + "source": [ + "im1, im2 = generate_images_and_IoT(simulator, sensor_side, temp_directory, pose_directory, 4)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "im1" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "im2" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.18050363398295918\n" + ] + } + ], + "source": [ + "im1, im2 = generate_images_and_IoT(simulator, sensor_back, temp_directory, pose_directory, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "im1" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA8AAAAIcCAYAAAA5Xcd7AAB+JklEQVR4nO3deZxkZ33f+2/VqXNq771nlWaXRivaEUIIMLvZhR07hmsW+4ZgbC65xLl2HJPc6904wVkcQ5zEBmwTB9vYGDBeWAQYjNDCaN810uzd093VtdfZqu4fPc+jUzU10z2ANDNdn/frVa+e6a469dRpXi/xnd/z/H6pOw/3egIAAGv27ds+py/9xSc0OzOt8fFxlUolFQoF5fN55XI5ZbNZeZ4nz/Pkuq5c11Umk5HjOEqn00qn05KkXq+nbrerKIoURZHCMLQP3/fl+746nY46nY5arZYajYaq1aoWF5f0sjf/uK5/yevO8p0AAOD8kjnbCwAA4HzSqFX00B1f1dYtmzU2NqZyuax8Pn9S+HVdV57nKZPJyHVdOY5jA3AqlZL0TADOZDKK41iu69oAbF6XfCSv+9CdX9Ml17xQpbHJs3xHAAA4f6SoAAMAsDbNWkX/+yO/IjcVa3JyUqVS6aTwmwzAmUzGPpLV32QA7vV6iuPYPsIwtNXgIAgUBIGtBLfbbbXbbTUaDS0vLytSRj/87n+tIiEYAIA1oQIMAMAazB96Ql/8s/+p2G9qdtMmlctlFQoFFQoF5XI55XI5u+3ZVG+T4TdZ/R0MwI7j2ACcTqft8wcfyQAdRZEWFhb0Vx/7D3rx635MW3dffpbvEAAA5z4CMAAAp9Bp1VU5dkAP3v0NLRx6XKV8Xqnuynlfc+53MPwOq/wOhtfBANzr9WzwTQZg85rkn8014jhWp9NRIZfRNz73CVUqFV1w0fN03YteqU3b957lOwcAwLmJAAwAQMLCkaf0+L3f0vHDTyrVjZRxM8o4jjZv3qxMJqN0Oq2JiYmTml4lz+qa4Du49Tm5/dkw54BTqZT9mgzKg8E5+Wi1WpqcnFQQBJqenlYYVHXn3/2JOh1fW3Zfrr3X3KzpzTvOzo0EAOAcRAAGAOCE2z7zCTWPP6WJiQnNTo0rm82eFFh93x/a8flUld/BADyMCbpxHPdViJN/Tj5XWgnOpVJJxWJRxWJRvRMtPXq9nnzfV7e9pNv/+g81sfVivfA1P/r9vlUAAJyXCMAAAJwQtWvasmWLyuWyer2eXNeVJLtFudvtqtPprDrqaNjZ3WTlNslcu3cGPSnNtul8Pq+xsTG7NnPtMAyVSqVUKBS03Kx8/24QAADnOQIwAAAnjI+Pa3Ji5XxvKpWS4zjqdrv2EYahstmsHMfpa3iV3Op8qjO/w7Y/SysVXbMNOhmETXMs8+fkw8wOTlafzfXNa6IoWjkrnPKfuxsIAMA5jgAMAMAJ45NTKuTTKpVKNvzGcWy/BkEgz/OUSqWGNrgaFngHH6cyuO3ZhGEThE3wNV/b7bY8z1Ov17OhPBnAoyhaeZ0XPle3DwCAcx4BGACAEzw3o1zOUy6XUyaTURRFiqLIBuBks6tTnfEddob3dMHXMJXgU73ehNtutyvHceyW61wuZ/9snmPGMHW7XXn+2rdWAwCw3hGAAQA4wc2sBNpsNmvDbLI51bDuzoMBd1jYNcH2dNZyBjjZFTq59Xrw/HEmk1G321Wj0ZDn8p96AAAM/qsIAMAJmYxjq7zJKqwk2xTLVFlPJRlkzRZmU91NXm/wOck/J/8+yARuE8CT1ehkQDdNsjpR53u4IwAArC8EYAAATsgkqqmSTgqmjuPYKqzUH2YHG1UNPk5ltded6rWm+my2PpuHCcOSToTj4PtybwAAWA8IwAAAnJBOp+32Z/N3M14olUr1jUUyX01TKlPlNX8fdm3zmmRV2Xw1Da7Mnwf/PiwUmxFKwx6S5HmeHIcKMAAABgEYAIAT0ikpk8kMbUKV7MxsOkMnw3FyDq+RHHGUvN6wbdLJDs/JEHy6R6/Xs9Vqc/3k10wmo/Tq/bcAABgZBGAAAIwTW4qHMZXb5GikZABeefnwtDkYqAevO1j5PZPHqT+KmQlMAgYAwCAAAwBwQi+On5mfO2TLcbfbtaOR4ji2W437rjHkzG7yzHAyDK8l/CbnECe/Zx7J9xz8Gsexet34+3yXAAA4fxGAAQA4IY4jhWHYd9Y3+TDB91QBeHBr8+DPTOOqwe8PC8DDAq8J4GYN5mHmAw9bb5cADACARQAGAOCEbhwrDEO7tXgwlJrZu+l0WlEUDa0AS8NHIQ3rHG1+vpbqb/LPgyHYjGcyPzfvZX4OAABWEIABADghikIFQaAoipRKpfq2GpsAaiqryXFIUv+opGFzfZMzgZNdoJMV4GTVd1gAHqz8ZrNZZTIZxXHcd13TrMv3fUVR+NzfSAAAzlEEYAAATgjD/gCcPO+bDKO+7/cFYBN8jcEAnPz+6QLw6c76DgZg3/f7OlInmfPFQRAoDAnAAAAYBGAAAE4IgsB+NduckwE4jmO1Wi0VCgWFYbjqFujB8HuqM8Crnf0dVv3tdrtqt9t96xisNqfTaYUnPhMAACAAAwBghWGkTqdjz9Qmz9uaRzqdVhAEp9wCbf6c/F6yq/SwCvDpuj4PO/NrKtWO4ygMQ3v9wTPEnU7HhnoAAEAABgDACsJQYRjK9/2+AJwMpFNTUzp+/Lgcx5HjOENn/5rt0IOh2ARgqX8M0mrnfpMhODyxxiiKNDU1pTAMFcexHMdROp22Z4KfCcBsgQYAwCAAAwBwQhAEarfbNkyasUPJgJpKpWzlddiW5qTkdmQzqmhw27RprHW67c/J8JusAqfTafm+b9drQrtZe7vdlh/4z/ZtAwDgvEEABgDghGajrrFSQel02m4rjqKor0orSZ7nqVqt2uA5zODWZ3Mm14Ro85xTjUEaDL/J87+NRkNxHNvtzSb8mnBugrDv++q0O8/NzQMA4DxAAAYA4IR6vaaxckndbtduY47juC/ESivbl5eWlpTL5WzwTD6kk88Bm6B7ugrwWs8BV6tVbdiwQb7v2/WYh1m3qQDXG/Xn5N4BAHA+IAADAHBCo15XpVKxZ2ql4R2dU6mUFhYWlM/nNT09fVIIHnxdMvwOjiwyPxsWgoedA65Wq1peXtbmzZvV6XT61pT8GsexGo2GatXlZ+dmAQBwHiIAAwBwQqvdUbValSTb5XnYOd90Oq2dO3fqvvvu044dOzQ1NaVyuXzS2CPzNRl+h41BGhaCTegNgkBBEKjRaKharerIkSPavXu3Op3O0DCdvEa73VabLdAAAFgEYAAATmh3fHnNpj2v63mePQ9sqrumk3M6ndaVV16pKIq0sLCgKIpUKBTkeZ48z1Mmk7Hncc3rTzUHeFjwTY47arVaOnz4sDZu3Kjdu3fbcDsYuLvdrm2UZQNwhyZYAAAYBGAAAE7o+KG6UcV2Vk4G2eRD6q8QF4tFBUGg48ePq1gsampqSp7n9b0mDENlMpm+qrI54xtFkVzX7TvzGwSBKpWKDh8+rPn5eV1zzTV9HalN+B22TToIAsVxrHa7rUjO2bylAACcUwjAAACcEERdNaoVtdttW/11XVeZTEbZbFbZbPakaq6p8qZSKRWLRTmOo3q9rqNHj6rb7apUKqlYLMp1Xft60wgrGXbDMFSz2VSlUtGjjz6qjRs36rLLLtPmzZu1ceNGBUFw0jnhXq9nX+/7vg2/3W5XQRCo0+koV546y3cVAIBzBwEYAIATukprcXHRbmM24dd1XVsRzuVyfUF22FfHcTQ9PW0DsgnNZntykqnkZjIZlUolFQoFbdq0Sb1eT77v922LNn8245lMyDUVX/PVbJ0OgkCbStNn41YCAHBOIgADAHCCly/qqaee0tTUlFzXleu6fUE4k8nYcJzNZm1V12xtdhyn7+xvOp22rzvVqKTkw8z5TZ4HNn83IbjT6djtzSbommAdhmHf9yqVirZfet1ZvqsAAJw7CMAAAJzwrvf9gpaXFvX1L35W+VxO+Xzeht1sNqtcLmcDcfL7ycZXg2eGe72eDc69Xu+kLdCmk3MQBIqiyJ4NTp7pNeHW9335vm+ru+Z7nU7H/iwMQ7VaLXU6vl70ytfr7T/982fzlgIAcE5J3Xk40UISAIB1Iui01aotqb58XA/fe4eeeuQ+RWGobRddoWte+DJt2XnpaV//jS9/Xp/71Mf1lb/5y5XtycWiisWiCoWCDca5XE6FQsEG4mQINueHu93uSVXhZAXYnOWNokhxHNut0r1ez1Z2k4G31WrZsNvpdNRqtdRsNtVoNBVFkV76mjfp9T/yTt38stee9vMdfvJB7fvHr+jg4w8o47racfGV2vu861WenFVhbEpeNv99+10AAHCuIAADANaFuUNP6P5vf1X1pXl1w7bS6snzXKUdR2bwkGka1W63tbCwoFCu3vf//e6q1/7a3/2V/vTjv6s7/uHLKpdLdtzR5OSkrQybSrBpmOU4jg3AZmu0qQYnJZtZRVGkdDptq76mKhyGodrttg2+lUrFjkeq1xu6/uYf0D95x3v14le9cdXP8rn/9Xt6fN/XtXXrVlvFNtuyu2aUUhCqq5Qcr6Cx6Y267LpbtOGCXd/NrwUAgHMKARgAcF47duBx3fPNv9Xi4SdtEymz/diMIjIjhsIwVLfbVavV0r333it3fLPe94v/fs3vdec3vqyP/dff1J3f+LKKxaLCMFQul9OWLVs0Pj6ufD5vzw6bRxzHymQyfUF48AywaYwVx7ENwOY8rwm/1WpVR44cUafTked5Nvi+86d/Xtff/ANr/gz1akX/6f99ny7ZdaGmp6eVy+XsGWdzj0wAj+PYVpint+zS8174Sm28cM+Z/YIAADiHEIABAOelVr2qL//FH2h57mlNTk6qWCwqn8/bplSpVMp2bzYB1IS6+fl5TVx4hfY870YVSmNn/N53fOPL+ts//4Rufd0r1Wg29Sef/CM9/PDD2rNnj+r1umZmZlQsFuV5njqdjl1HcnyS9EwANk2uTKB+prpb1/LysiqViq644gr96I+9TcViQX/x+S/qNW/5cV1/88vOeO21pXl12k195c8+qosvukilUslu2U6eOU6OaGq1Wmq1WqpUKprctEMvedPbVSiNn/F7AwBwthGAAQDnnVZ9WZ//w/8kpxdoYmLChs1SqWTDpunAbLozS1IURcpkMvrOPfeqXqsqlUqrG0dyC+Oa3nShdl92nTZsu+iM1vKZj/+2Lt+zTZWlJf3ar/6yfN9XoVDoq0b/0A/9kMbHx7Vx40Zt3LjRjkhaXFzU3Nycjh07pmq1qk9/+tOKoshWXVutlhzH0b/54L/T9PS0Hnj8gN70jv/7jNY3f+BRPfHg3Vo8dkBhu66Mk1EURWq3W3rJS15iq7+STupEbUK57/s2BFerVXXTnl791vcRggEA5x0CMADgvNKqL+tv/9fvyE3FGhsbU7lcVj6ft42pzNbjYU2npGcaTz3yyCO247IJftVqTZXKkjbtvEyXXf9ibbhg95rX9ZmP/7Ymiln9q//7fZKkQqGgQqGgcrmsD33oQ5qcnNTExITGxsaUy+UkSb7vq1arqVKpqFKp6Od+7ufUbrdVr9fVbDbV6/X0b3/p1xSnvTMKvvMHn9ADd35Vx/Y/qKmpKY2Pj9tGXGZM0rFjx/Syl71MxWKx796Y88imGhyGoZ01bIJ5tVpVLFcv/5GfUqFMCAYAnD8YgwQAOG+06sv620/+jjynq4mJSZXLZRUKBeVyOXuWNTmz14TfwQAsSVu2bLFnbzudjrrdrkqlkqanp7S4eFRf/tOPanLzTr34DT+ufLG86tpMQH3bfQ9q29ZN+rVf+rdqt9vas2ftZ2Y3bNig22+/Xd1uT//ne35anbCr17/r59b8+nazpq/91R9q6eh+TU5O6qKLLrINutLptA3eYRhqeXnZdrRO3pvklmwTgF3XVafTsdvJ0+m0qtWqvvip39UrfuS9hGAAwHmDCjAA4Lzxd3/yu2ovH9P09LTK5bJKpZLy+bwNecnwm6wAD+r1elpYWJC00oU5CAJJKxXZZrOpIAjUbDZVr9cV9hxd//K3aHbr2rsgH587on/xtlfpB1/9Sr3oRS/S7OysxsfHVSwWbYdoaaXpldlevLy8rOPHj+sb3/iGvvC3f6/f/qO/1ezGLWt/z8NP6o4v/rncVKxyuWzfy3yVZJuC1Wo1Pfzww7r++uu1YcOGvuuY2cTmzLRpxBUEgTqdjtrttr03lUpFnain1/74B9b0jwQAAJxtVIABAOeF+UNPqDp/QLOzs33zeE34TQZg0wV6WAVYWgnAjz32mK655hpFUaRcLqc4ju08306nY4N0o9HQN/7qD1Sc2qoXve6tyq+haVYhX9Dzr79W27dvP+l9h+n1enad27dv1403XKdCvrCm+9JuVPX1z39SzcXDmpycVLk8ftK8YnNfzGziTqej4om5xp7n9V0vGYDNPyAM20Zutkn7x4/rr//ko/qhn/xXa1ovAABnEwEYAHBeeOD2L6tcLtvtzrlcTp7n2Udy+/NgAB5mfn5e+XzedoaO47hvi2+yY7PjOGq1Kvrin35El157izLZgkrjk8oXysoWSkqlpKDTWnm0m6ouV1Qem5AkNRoNZTIZhWGocrmssbExFQor4bbVaqlWq9kzv/V6XZJUHhvXsQOPamx8Ul6+KC9XkJcrqNeT/FZD7VZdjWpFkd/SQ3d9TV66q9nZWRUKBRtsTUdsc2/MPXFdV/l8XoVCoa8BlmG2QHe73aHbx5Pbo6MoUrlc1tzcEc0dfEIbL1z7mWkAAM4GAjAA4Jy3cOQpVY49penp6ZOaXZlKbTL4mhA7WAFOVmBNOHQcxwZgs1262+32Pddc12m19J2v/pWirpTPZVUslVeqxq6rjOcpJSmVSisKA+3etUO9Xk+1Wk3Ly8t9n8dcezCcp9Npdbtd7dyxXccfv1sV11Ov11VPUhQECk5sR242Gur4HaVT0vTUlAqFkg215ky0+YcBUxlP3hsTjpPbsZNrGxZ8TdU3OVM5m80qn8+rVCpp3z9+Ra8mAAMAznEEYADAOW/ft75itzsPnvNNVnuT534Ht+6mUqm+UGu2AzuOYyueJgyawDfsMTExoenpaUmyTbhc17VbsX3fVxAE9mu9XtfTTz9tu00nw/VglXn79u0ql8s2uJqvvu+r0+koDEO1Wi01Gg2lUikdP37c3hfTCTtZ9fU8z96z5D3J5/N2zeb9zZqS96jX69n7au5PMkinUikbgtOKnpP/LQAA8L0gAAMAznmdZk35E2dVk4F3sMqbDJTJhzFYcTXXMqE02TAr2RHZbPf1PE9BEGhpaUlHjx5VEAT2dYOVaBMcTbg0gTG5jmTo7Ha7evrpp/u2GSe3GpvZvKlUys48npiYkOM4fVvBzcNsE89ms/a9zecz63Rd96Q1mT8PeyTvueM4ymazarfbK5V0t7+SDADAuYgADAA45+U9Rwp10mijYUHXBFfzZ+nk4CtJQRDYQGhCqvlqArGZD2y2WydHApkGUp7n9YVfSfasbTqdtmeLzXslq9LmvSTZ0Os4jnq9noIgUBzHkmQDsOnIbKq3yS3OpjJuwm+yEjy4FXyw8ZWRvHenMnjPTdW8G4Vr+VUCAHBWEYABAOe8XhTIO7Fdue/7p9mqbLoYn3StIQEvGehc17UBOFmBTW69LhQKfcHTVIDN+garpcnq66nCunnPZBdm8zNTDTZnb8MwtFXYZDV3WFMwU4VOymQy9rO5rtt3X5L3b/CeDrt/Zg1+0DmD3ygAAGcHARgAcM7z2w155bI9RzsYFJOP1bY9G6cKwqeqMKfTaRUKBTmOoyiKbLU1efZY0tCt2cnwm/w6GCqToTP5mczP4jhWt9u1ITh5Djp5bfOew8JvMtgnq+DJnw+7r8O+b9aaSqUU+q0z+I0CAHB2EIABAOc8x8spDFe22CbPxyb/PGxWrQlnw5hAN/hzE+5M2DZNozzPUxiGyuVytuKaPA8r6bTh2RgWSJPvfapqtiT7mU0INkE82eU5OaN3WBXcnGkOgsCOgBp2X5L3NvkYDMFhGCoIAjlubk2/SwAAziYCMADgnBf30sr0YnU6HWWz2b4GUYPdnk1oHPz+IBMABxtfmS3PySqquWay23MydJr3kk6u8g5rMjXMYDV4WHU4GUrDMJTv+zb8D67DfI7B9+52u+p0Oup0Omq323YLdHIdg++VbMSVfCTDs+NmT/v5AAA4FxCAAQDnvKibUjpeqb6aZlCDs36l/vC2WgDesWOHDcDJKmsYhup0On3bfM3ZYEm263Ky8rpaY67Vwq8xeA53WCXYhF9zTRNCk+eFzZrNXGHpmeq0CcBmTJOprCfXkKzwJgOv2Xptqs/mz0EQKDs2trZfJgAAZxEBGABwzsuXJ9Q6vqxsNqtOp9M3ash0bjbBbbAqOyyE9no93XDDDTZImtfHcSzf99VqtWxHZtNkyrw+OeJocB3PRQA2Ibbb7fatyzzHVIXNtuxsNmvPApvXtlotWwUuFApD33uwApwMu8lHu92W7/vq+XSBBgCc+wjAAIBz3tUv+AF9+U8/Yrsb+75/UvgdFoAHz98Ok6wAm7Bnrp+cnzvYZGpwNu73EnyNweZdw7owJxt9mbVLOikgJzs8J+9Ht9u1/5CQzWbl+37fGk63BToZfJMVZN/3VcgWzuizAgBwNhCAAQDnvDCKtLCwYANwsrtxsnprqrXDqrKDTFg0IXKwwVQmk7Hbh41hgXq1ubnPJvPZBhtpJUOr2Q5u7lkcx2q32+p2u7ZanJTs+HyqCrDZQp08S/ziG178XH98AADOGAEYAHDO+9ynPqYjR45oYmKib+RQMqgl5/SeqgKcDMKm0ZX5/uCYIRMWTUBMVpwHuzUP67ZsnnumVeBTbYMeHD2UPJ88rGtzGIZqt9t9DbLMazudjuI4VrPZVC6X6wvQp6oAmwDs+75831e73Var1VKr1dKxY8dO+scCAADORQRgAMA574mH79ehp57SzMyM3XKcDGqm2jmsM/OwCvDi4qJmZ2dtyE0y13Mcpy8AS88E5eT7r7bF+vtpMHwPq9YmQ6sJwEmpVEr1el29Xk+1Wu2k8LuWAGwqv81mU41GQwcOHNT+fbdpy46Ln7N7AQDAd4MADAA4p0VRqMMHnlQcxzp69KiKxaKk/upvJpNRNpvt6w49uA1aemZ7cKVSUT6fP3H9ZyrBnufZUJkM0pJO2k5tGk0lq7RnWu1dq2FbnJMV4cFtz8kxRel0WkEQ2OtkMhnV63V1u101Go2+0UmnCsDJ7s8mALdaLdXrde3fv19Hjx7Rp//iL3Xj69+lTMYd+hkAADgXEIABAOe05uNfV+ivnFk9dOiQcrmcLrjgAntuN4oieZ7XVwE2wdeE2GRDKbP9t1KpKJPJKAgCpdNpRVGksbExG2pNl2cTIpMV32T4fK6cajt0siI8WAGWVgJztVq1Z5pd11Wr1ZIkNRqNk7ppm3AtyYZoUwFOnv+t1+uq1Wo6cOCAut2u9mzfoqN3f14XPv/Nz9k9AQDgTBGAAQDntJnZDdq8ebOefvppSdLTTz+tsbExG/7CMJTneXY2r+ncnNwGbUKrCbO+79tqbb1eVz6ft/NzS6WSUqmUraKaanLyjGsqlVKtVtP4+Lg8z7PffzarwEYQBKrX6/I8b9Xtyr1eT81mU7VaTY7j2LFHvu/bJlitVqtvRJJ5SM8E4GHnf+v1up544gk1m02FYahyuaxtO/fo7LUEAwBgdQRgAMA57cEH7tf4+Lg9i9tsNvXYY49p9+7diqJI+Xxenucpm83aAGxGGJmtvearCbRBEOjo0aMaGxtTpVJRuVy210mlUvZa5iyweV1y1JAZBZTP5+3M3WdDssocx7EdQ5Tsgp08B518mLO6QRCo1Wqp0WhofHzcXs/8Q0Cv17P/SGDuk/lqArCZ+RuGoZrNpo4dO6ajR4/awH3VVVep0vA1Mfus3QoAAL5nBGAAwDlt69atuvnmm/Xtb39b0krgq1arWlhYsLNps9msstls3xbo5Dlgs63ZVICjKFKr1VKn01GlUlEYhpqYmLCvN+HXBODBhlq9Xs+GQlOBfi6YzxuGoaRnZhj3er2Tzv6aYGoqtktLS6pWq/J9X7VaTbt27VIQBDbsmoZgyYry4Gxkc61arab5+XkFQaA4jlUsFjU7O6tS9rlrCAYAwHeDAAwAOKc5bk7XXnutbVaVTqfVarV05MgRu/U2m83K8zw5jmO/JsOvCcDJc7Ou6+rw4cNqt9u2iVYul5Pruspms33nbU0INFVXU131PE9hGD4n3aC73a6tOrdaLRv4kz9Pfj6zPbzT6ajRaKher+vIkSNqt9sql8tqNBq2mm0q2IOf11R/TZhutVryfV/z8/NaWlqyz7n44ovlOM7KtZ/VuwAAwPeGAAwAOKftP3xcpUyoq6++Wvfcc489j1upVNRoNLRlyxYbBjOZjFzXVTqdtuHQnAlONsKSViqevu9r8+bNmpubUz6fV7lctmdpTzV7V3pmK3Iul1M2m/2uZ/6eCbM123S7dl3XbgsfPL9rqt3m7G6r1VKlUtHBgwe1uLio6667TgsLCye9R/IfCUx111SVzXWazaaWlpZshTiKIt16663qdrt66vBxXbn7WbsFAAB8zwjAAIBz2o4rXqClR7+hN7zhDbrjjjtswDWNqg4cOKDx8XFbxU1WfZNNsMxrzNdMJqNOp6Mvffkr2r7tQrXbbbXbbdsQa1in5eRX3/dVLBaVyTz7/yk1oT2TyahYLMr3fRu8zWdKdolOdoTudDpqt9uqVqtqtlravHmzFhcXJcl+zuRrhm2BNk2zGo2GGo2GXVMcx7riiit09dVXa3FxURddc8uzfi8AAPheEIABAOe0ThDps5//G73+ta/WFVdcoQceeKBvbE8URapWq8rn88rn8zYIm6BstkSboJqcj9toNPTy171Fd37977Vp0yb5vm8rnqcLv1EUqd1uK5vNPuf3I5vNqtlsKp/P22CfrFYPzgQ2Z3fr9bpe8+Z/qm9+6fM23JqmYcn7EgSBPeNs7ke73e7rnG3OC0dRpHe9613qdrv67F//rf7pzhuVe87vCAAAa0cABgCc0/7yjz6ie/fdpeuueZ7e//7362d/9me1tLRkA7C0Uo2s1+taXl6W67oqFouS1Lc1Otmp2QTgjZu26Euf+zMptXKu2HRYNiEyef1kyHQcx1ZCz4ZOp2Pn+g4ylVmzjdmcGa7WavrS5/5cu3bv0dEjh+woJbNt3HS2NsE3lUrZe2Kq6oapvl9zzTW66qqrdPfdd+u+fXcp90cf1Tvf/++ey1sBAMAZoV0jAOCcNn/kaTmOo4985CPKZDJ63/veJ0m2KmlCXhRFNvRVKhXbKfrIkSOam5vTU089pYMHD+rAgQPqdDqanJxUp93U+Pi4/snb32MbPJkQmNwCLT2zXdhUQTudTt+IoudSo9Hom91rAu/gGV5T/W21WnrL296t8fEx+Z2Wpqen5XmeFhcXNTc3pwMHDujYsWM6cuSIjh8/rkqloqWlJXU6HVvxTt5r3/c1Pj6uN73pTXr66af10Y9+VI7jaP7I02flfgAAsFYEYADAOe3g/seVTqc1MzOjD37wg0qlUnrNa16jjRs3qlQqKZvN2vO+Zh7w7OysfuM3fkNf//rX9ZM/+ZMqFArq9Xratm2bXvSiF2nv3r1yHEdhGCqdTuvSq56vZrOpTqdjg55pApXc+mxCp7QSgM+GXq9nw3cyBCc7OCcruSYAX3bNjUqn0wrDUJlMRnv37tWLXvQibd++Xb1eT4VCQT/1Uz+lX/mVX9HVV18tSXYbeTqdVi6XU7lcVrFY1Itf/GLdfPPNSqfT+uAHP6jZ2Vml02kd3P/4WbknAACsFVugAQDntHa7pbFS0Ta2+qVf+iXt3LlTV111ldLptI4fP25n8przqj//8z+vyy67TIcOHdJnP/tZLS8vq1gsanp6Wq7r2m3OzWZTy8vLmpzdqHQme1IINjN+zXlZw2y5Plt83+/7e7ISbGYFm/DbbDaVymQ1ObNJc3NzmpiYUC6XUyqVkuu6mpmZ0dzcnJaWlvRnf/Zn+tCHPqTf+q3f0l133aX/8l/+iz1X7XmeXNdVPp/X5s2bde+99+qLX/yitm/fbv8BotFonqU7AgDA2lABBgCc0xyvaAOoGXn0wAMP6Bvf+IYymYx27Ngh13XleZ48z9OePXvUbrf1zW9+U+95z3t09OhRRVGk6elpjY2N2bBm5uROb7pATsbV3uddr0ajoU6nc1IINluMk2OOgiA4a/ek3W7bPyebgZnqr/kMZgbw3iuvk5PJaGbzhX1zix3H0djYmGZmZhTHsY4dO6YPfOADuv3225VOp7Vnzx47Y9l1Xe3atUtTU1P6/Oc/rwcffFDZbFZbt26155Edr3jW7gkAAGtBBRgAcE676LLn6emH7lIcx8pms9q9e7fuvfdeNZtNfe5zn5PjOBofH9ctt9yiSy+9VPfcc48+8pGPaP/+/fYa4+Pj2rRpk93Sa860RlGkS593nXZdfLle+8Pv0G/+P19Vq9WyI5HMnN8oivrGKkn9IfR0zmQ+8FrPFCe3QJvK72D4bbfbK82vqlW99oferl0XX65Lr7xOd3ztb+xnLxQKSqVS2rRpkxYXF+256V/8xV/Uzp07dckll+gNb3iDHnroIe3bt0/79u2zs4c9z9Pu3bvt/YnjWBdddvWa1g8AwNlCAAYAnNNe8fof1u/u+6btvrxp0yZ1u13df//99pxupVLRZz7zGX3mM5+xrzOjklzX1WWXXaaZmRmlUilb0Y2iSIWxKb3nZ39JknTpVTfooiuv1/Kxp1Uul1UoFNTpdJTL5VQoFGxTLHONtQZgaW0h+EwaanU6HXuWN9msy/f9vvBbq9V08ZXX65KrbpAkvedf/ZIe2Hd73z0w26Avu+wyfec731EYhur1etq/f7/279+vL3zhC5LU13Xb8zxdccUV2rRpk9LptD0z/YrX//CaPwMAAGcDW6ABAOe0q298ier1usIwVCqVUqFQ0MaNG3XddddpcnLSNoIy1Vkz8zeTyWhqako33HCDpqenlc/n5TiOnY/bbDb1i7/1e9qw+QL7Xj/8jp9WrVZTrVZTo9Ho6wwtPTNiqNPp2O3Raw2up3vemXaTNh2wk6OaTAhtt9tqNpv2c7zl7T9tX7dh8wX6xd/672q1WvY+OI6jXC6n6elpPf/5z9fGjRvt/UtWvc19npyc1HXXXaeNGzfaCnIYhqrX67r6xpec0ecAAOC5RgUYAHDOu/z6WzT/9MNqt9vyPE/j4+MqFosqFouan59Xq9XS0tKSms2mSqWSNm/eLNd1NTs7q4mJCWUyGYVhaENfEATa+7zn68rrXtj3PnuvvF47L7laxw89rkKhYKu/hULBBmiz3bjX66nVaimfzw9d87Cq76m+N+y1p2K2P8dxrDAM5TiOut2ufN+34bfRaGh5eVk7LrlKe6+8ru/1V173Qu193vO1eORJ5fN5RVGkTCajsbEx+zlNY7HDhw+r2WyqWCxqampKhUJBGzZssPfU/GNAGIa67LoXnfZ3CADAuYAADAA45936tnfrl//F/6FsNqs4jpXJZGxYm5iYULvdtrNvs9msJKlYLCqXy0lS34zgdrut48eP633/7+8Mfa83vfXd+s2f+0l7fRO0W62WDZvmHOywUUjJkLtaCF4t/A77udl6bUY0SbLdq1utlprNpqrVqiqVit72M28d+hnf9s8/oA++90dtgytzz3K5nHK5nMbHx9VsNrVt2zb5vi/P85RKpZTP55XP5/u2kgdBoPn5eb37X/+Hoe8FAMC5hAAMADjnXX7Njdp5ydVaOrq/bxyR4zg2qPZ6vb7ZuIOjgUw4XFxc1J7Lr9OV19009L0uvfr5tgpcLBZVKpVUq9XsvGHXdW3wNV8Hg+qwkGv+ngzEyXO1w64xqNfrqd1uq9vtqt1uK5/P2y3a5vPV63VVKhUdOXpU177wZUM/45XXvVAXXXG9Dj3xgN3qbK5vtkRns9lT3lPTRKzRaKher2vHJVfr8mtuHPpeAACcSzgDDAA4L/zsr/wXKZNTrVZTtVpVtVpVvV63Z3XNuVjTBKrRaNhHpVJRvV5XvV5XrjShn//13z3te/3gD/245ubmtLy8rEajYefpmjPBJvgmG2GZsJj8e9KZnAEevE7y2mYLdHLOb6PRULPZtHONDx06pOtvfsVpP+PP//rvKlcat/fFfFZzrXa7bcdBmaZaJvCa+1+tViUnq3/1y//5tO8FAMC5ggAMADgvTM9u0q999M8UK6OlpSXVajUbSk0QNmGwWq3aLcG1Wk31el3z8/OSk9Vv/f5nNL1h82nf6/kvfpU6Qdz3PmabcaPRULvdVhRFp9wCnazqrhZuz+S1kuT7vq0AJ8O5aXy1tLSkMO7qp//1r53+fm7YrH//+38lOVnNz8+rXq+rVqup1WrZ8UnJe1qv1/sabFUqFcWpjH71o3+qqdlNp30vAADOFWyBBgCcN6Y3bNKv/bc/07//4P+lx+6/UxMTE4qiyG7XlZ7ZYtztdtXpdJROp1WpVLT3ec/Xz/3a72p6w9rC2jt+8p/rz//kE1pYWFC5XJbneXZ7cBiG6na7arVaJ4XWYVufB0PtameEh/3dvNb3ffV6PTuiKVkFXlhYUKfj633v/5fafMGONdzPzfrQ//yMfvMX3quH77ldU1NT6na7yuVydt5x8nP4vi/XdbW8vKw9l1+nn/3l/0z4BQCcVwjAAIDzytTsJv3aRz+l++/+lj79hx/V7V/9GxWLRUkrza5SqZTtUNxsNnXjS16jf/nj79GV179wlSv3+6F3/7yuvuJi/dtf/DcqlUo2AKfTaTUajZMqwCbMDgu+hjk7a8YHNZtNZbPZvnPNyesMOx9szgCbUUxm2/LCwoKOHTum/++Xf1W7bnrzmj/n9IZN+tD/+LTuu/Ob+rM//Ihu/+rfqlQs2pFRvV7Prs/cz/f/+Ht0+bUvOKP7CQDAuYAADAA4L11x7Qt0xYkQdsfX/15//elP6u5v3SZ1peddd4t+8Na36vkvfuV3ff1UKq3dL/whbd72+zp+/Liy2axtBBUEgQ3aq1WAk+HV9307O7jX6ymKIkmyTaiM022TbrfbiuPYVn7r9boWFxc1Pz+vrdv3aNdNt55UVV6LK69/of1Hgm9/7e/1hb/4pO7+x9ukVEpXXf9ivfYtb9UNt3z39xMAgHMBARgAcN674ZZXPivhLJVK6T0/+Xb9p//8O1peXrYhOAgCxXF8UhOsYVXfJBN+k68JgkC5XG5oaB3c/myqsZlMRkEQ2EZUy8vLUtrR//Xed39X4XfQ81/8yu/pHw8AADhXEYABADiNC659rX70R47p937v95ROp5VKpZROp9Xr9frOAPd6PXW7XXt2Vjq5knvkyBG7TVuSDhw4oEwmo1KpdNJ4JPOabrfb9x6tVstuge50OlpYWNDRo0f1z/7ZP9PM5cPHHgEAgBUEYAAATiNfGtNNt75Xf/3Fr+n44f3K5/PyPE9xHJ8UgKWV5lvJMJus4h47dkwPP/ywfV2hUNBFF12k3bt3980JHlb5NY9ms6lut6swDNVut7WwsKALdl2im259rzKu9xzfHQAAzi+MQQIAYBUZ19Nb//m/0tLSkoIgkO/7iqJI7XbbVmkHK7Xme8lHEAQ6fvy4XvGKV+iVr3ylFhcXhz7vVNcyFWDz3mEYammpore++2cJvwAArAEVYAAA1uDK627S5de+ULXjB1UoFOw25MGKr2mUJZ0813dxcVEXXnih9uzZo1QqpW3btqlSqfRdw7z+VGHadIEOgkDNZlOXX3uTrrjupuf+hgAAcB6iAgwAwBrd+n+8W7V63Z4BzuVyp6zgxnF80p8dx9HmzZvlOI4cx9GWLVsUBMEpn3+qyrA5a1yv13Xr2/7Z2b4tAACcN6gAAwCwRtfe9AOqVauanZlRr9eT53l91VvTCfpUFeDx8XHNzMzIcRylUinNzs6q1WopjmNJz1R/B1+frAJns1n1ej2FYahqtaprbvqBs3AnAAA4PxGAAQA4A9e+8OVaOPSYDcAmvPZ6Pdsl2hhsZjU9Pa1isWifl8vlVC6XFcdxX/AdvEav11Mcx4rjWJ7n2fFJ177w5c/hJwcA4PzHFmgAAM7Ay1/3Q/J9X3EcK5PJKAxDRVE09BHHsf0ax7F27Nghz/MUBIGCIJDneZqcnLQ/T74m+TDvEYahXNdVGIYKgkAvf90Pne3bAQDAeYUKMAAAZ+DCXXvVarWUyWSUyWTsGV7HcWxld1gVWJIcx5HnefZ52WxWW7dutVVkaXj112x/DsPQVoBbrZYu2Hnxc/OhAQBYJwjAAACcga3bd6vVaqlYLCqOY/m+3xeAT7UNWlqZEZzL5ez3MpmMrfoag69NNsYKw9BWiFutlrZu3/0cfGIAANYPAjAAAGdoasMW+c2qyuWyHYVkOjsPBmDpmRDsOI6CIFCr1er7frIJ1uDrTPiN41hBEKhUKqnX62lqw5Zn+2MCALDuEIABADhDuy65UvfdfptSqZRarZa63a4ymUxfFTjJBN3kGCNpJfAmnz8YgJPV3yiK1Ol0lE6nFUWRdu698jn4pAAArC8EYAAAztALXvxKPXrP7XYrcrfbleu6fSH4VNXc5JZo6ZkQvJbqrwnAXjanG2+hAzQAAGeKAAwAwBnaefHliuNYnU5HjUbDBmATggebYaVSqZOC76Dkc5LNr0z35zAM1Wq11Gg0FHe72nnx5c/65wQAYL0hAAMAcIYu3HmxgiBQtVq1QTWfz9vRSIMhOPkYxgTe5MOEXxOA2+22Go2G6vW6wiDQhXSABgDgjBGAAQA4QweeeEQbtmxTrVbrC7a9Xq/vXG8ul1OpVFIul1M2m1Uul5PnefI8T5LsPOBOpyPf9+X7vur1utrttt3+bH7ebDZVr9dVrVa1Ycs2HXjyEW3btfds3gYAAM47BGAAAM7QgScf0Y5dF6ndXtb09LS2bt2qUqkk13VXzuh6nhzHUTabVTabled5fVukTWB2XdcG5kwmY58TBIGiKLIzhsMwVKPRUKvVUrvd1vZdFxGAAQD4LhCAAQA4A616VUceu1uX7d6qsbFLlc/n5bqurdimUin71XRxNs2vkmd8zddkcyzz1TS+Ss4B9jxPF198sbZtW6k8H3vsO2rd+BIVyuNn83YAAHBeSa/+FAAAIEnN2rI++/H/oHxGKhQKymRW/h152BnetT4Gw28yLA/+XVqZJVwoFJTLSJ/7xIfVrC2fxTsCAMD5hQAMAMAaNGvL+vP//utyU7HGx8f7tjIPBtZkmB0MtGsJw6d6rbTSLdpxHI2NjSmjSJ/+H79JCAYAYI0IwAAArMG9t39FbipWsVi0Z32TXZ3PJMwOe82pKsCDrzFnhl3XXTl3nIp037dvey5vBQAA5y3OAAMAsAY3vfJWbb/oMj32rc+fFH4l2fCaTqdPCr+DQdd0jj7dc4ZVfw3TZTqbzerFt/6f2rKDZlgAAKwFFWAAANZoy469qrR7UiL8muZXJrSaBlbmkWyENawqnHwMvm7wz91uV9KJJlqplCrtHuEXAIAzQAAGAOAMvODlb9Jjjz2hIAj6KrSnCq+DQfhUZ3+TIXjwq+kIbR5BEOixx5/QC17x5rN9OwAAOK+wBRoAgDOwadsebbhgp44ePaxyuazJycm+hliGGYc0WP1NboEeVv3tdruKokhRFPV9r9frKYoiVSoV1et1bdy6U5su3H2W7gIAAOcnAjAAAENUKwv66z/5PT3+4D6lJF10xbW64ZZXaddl12p6y05FzSWl02k1Gg2lUimVy+WTGl1lMpmh26DT6fTQbdBxHCuKIoVhaAOw+Vm9Xlev11M6nVaxWNT0ll2SpCcfvFt3fP3v9Nj9d6snac9lV+u1//TdGp+cOXs3DwCAc1TqzsMDnTUAAID+10d+TQce2Wfn/ZptzmEYqdNpa2pmVls3b9LMzIwcx7GNqaSVWb2ZTEae5ymfzyufzyuXyymbzcrzPDs/OIoiBUEg3/fV6XTU6XTUbrfl+76iKDppnFIcx1pYWNCRo3NaXJhXLpeX62bkOI5SqZSiKFKr1dK2vVfrx37qF87m7QMA4JxEBRgAgCEevvdObb9gs0qlkqSVxlNhGMr3fY2Pj8n3fT3yyCO64447ND4+ruuvv14PP/ywrr76arvFOQxDOY7TF5BNSJZkq71hGNogHIahpJXmWmEYat++fdq7d6/uuOMO1Wo1jY2NqVAoaOPGjZKkbDarTCZjr9toNPTwvXc+x3cLAIDzAwEYAIAhqtVlebu2K5fLyfM8SVIYhnZbchAEKhQKKhaLqtfruu2223Trrbdq+/btKhQKevLJJ22wNSHYBOFer2cDsnmOeXS7Xbmuq71796rVaimfz+vTn/60crmcNm3apEKhoGw2q2w2q3Q6Lcdx5LquJNlr1Ou1s3nrAAA4ZxGAAQAY4vJrblI2G2tiYsJWV8225CiK5Pu+PM+T53lyXVf1el1/93d/pw984APatGmTisWi7rzzzr5zvZnMynZlwzS7Sp75jeNY11xzjSYmJnTs2DH9zd/8jcbGxlQqlVQsFm0gN1up0+m03VLd7Xbl+74uvfoFZ+WeAQBwrmMMEgAAQ7zm1h9Tu9NRqVRSoVBQPp9XsVhUsVhUoVCwodT8vFwuy3VdffSjH1W1WtXk5KTGxsZOnBteqfKaiu+pHnEca3x8XJOTk6pWq/rIRz4i13VVLpdVLBbt+5XLZRUKBVuBzufzKhQKGh8fV8f39Zo3/9OzffsAADgnUQEGAGCIC/dcoVq1qnq9rptuuklxHGtubk7Ly8tKp9OK41jZbFZjY2OanZ1VvV7XsWPHtLi4qA9/+MN673vfq40bN6parfZ1eDYVYNO0ynzfNLzauHGjjh07pt/93d9VEASanp7Wpk2bVC6X+0Ytma3PExMTmpqa0tTUlFKplO648y5duOeKs3XbAAA4pxGAAQA4hWtuvEWvf9VLlcvlJEk7duzQ4cOHdeed/U2mzBiksbExLS8v67777tNv//Zv661vfasNv8lOzibIJuf8mke1WtUf//EfK45jXXnllZqYmLBnhpPMVumtW7faLdq9Xk+3vOw1z8GdAQDg/MQWaAAATuGH3/gaG34lKZ1O64ILLtDMzMkzdk1AzeVy2rNnj4Ig0K//+q+r1Wr1VYBN6B32aLVa+tVf/VUFQaA9e/bY9x4Mv5I0MzOjCy64oK+rdCqV0ktfeN33+zYAALBuMAcYAIABm3XktD8/cuSIbr/99r7vVatVPfnkk7r//vu1b98+pdNpTU1NaceOHXrnO98pz/P65gCbLtBm/FEQBPrYxz6mxcVFHThwQHEc6+qrr9YVV1yhXbt2aXx8vO/9brzxRm3ZsuW06zyq0/8cAIBRQwAGAIyc2/7qj/XU4w+qvryoWmVR41MzyhXKuuKKK3Tr616xpmv8xV/8hSTpk5/8pB544AGVSiVNTExo8+bNarVauuuuu3TjjTfql37pl/TYY4/Jdd2+7s3SShdoM7ooDENt375d//W//ld98Ytf1BVXXKFyuayjR49qeXlZjUZDF198sW666SZdfPHFuvXWW9e0zqPaoq/+1Sf0xCMPqLIwJ/V6mpjeoF2XPE8/8KYf/+5uIAAA5ynOAAMARkr1+GG5waIu2rZR2raxb3vxi19wzZqusbCwoMcee0zbtm1Ts9nU1q1bdd1112l2dlZbtmzRU089pV/4hV/QVVddJUlaXFxUtVq1W52HnQGenp7WpZdeqt/5nd/RPffcoy984QvauXOnjhw5ouPHj+vJJ5/UQw89pEajoU6no1tuuWXoVuxBm3qH5YZVXbLrAmnXBeqZf/cOK6oeP6zx2a1neAcBADh/UQEGAIyUb33hk7pwtiTf9+W6bt8Z2ssvv1z5fH7Va3ziE5/Qy172Mh07dsx+z8z0zeVyOnz4sN7whjfYny0tLemOO+6Q67pyXbevAmxGIN1www2ampqyr/nMZz6jCy+8UJ1OR5lMxr5maWlJYRhqcXFRb3/729f0mfft26coiiStzAoOw1DZbFYHF5p6wWt+bE3XAABgPaACDAAYGfOHntShJ+7XlqkbtHnz5pN+bkYUrebtb3+74jhWEARDf55Op1WtVjU2NiZJmpyc1NTUlJaXl+U4jq0Cm+ZYU1NTmpyctNXZWq2mbdu2aWJi4qQGWFNTU9q+ffua12reP47jvu8dP35ch5+4X/OHntSGC3at+VoAAJzP6AINABgZ3/riXyrreZqbm7PV2OTDVFnXatg1XNdVPp/X17/+dfV6PfV6PXW7Xe3YsaNvy3Pyzzt27LBzgHu9nm677Tbl83l5njf0+sYf/MEfrGmd6XT6pGvMzc0p63m6/cufOaPPDADA+YwADAAYCYf3P6KDj9+vXC6nIAjUaDTkOE7fI7kd+lQ+//nPS5KCIDjp9eaRzWb1wAMP9IXciYkJTUxM9G17jqJI4+PjmpiY6AvF9913n7LZ7CmvbyrPa1mvJGUymb7XNxoN+b6vXC6nQ48/oCNPPfrd31gAAM4jBGAAwEj46hf+XJ7nKQxDpdNpPfXUU4rjuC8YrsXrXvc6SdIXvvCFk4KleXiep7GxMTUajb45v1u2bLGjj0zn5y1btvQ9p16vq1wuy/O8odfOZDL6whe+IEl6xzveMXSNlUpFn/jEJ+zf0+m0fX0cx9q/f7/S6bTCMJTruvrqF/78e7y7AACcHwjAAICR8PiDd9sg6Hme4jjWvffeqziO+5pMGabSe6rvvfa1r+0LlslHFEVKp9M6dOiQrfYGQaCJiQn5vt/3mJiYsGE4DEMdPHjQXmPYtdPptF772teedp2f/exn9cpXvtL+3Xy+OI51zz33qNvt2gpzOp3W4w9+5/txiwEAOOcRgAEA616tsqh2s6FeryfHcVQqlVQsFiVJt99+u60K93o9ffzjH9fRo0dtpfdjH/uYPvaxj0laqf4ePXpUH//4x0+7RblarWppaUmf+tSn1Ol01Ol0bOAtlUr2e+Vy2X7ffO9Tn/qUFhYWbMOsU22xPt06TXfoj3/84+r1erba+61vfUuSVCwWVS6Xlclk1Ov11G7WVassPoe/EQAAzg4CMABg3dv/yL1KqadOpyNJymazmp6elud5kqT77rtPjuMolUrpjW98oz75yU/qrrvukiS9853v1Ete8hJJ0m233aZPfvKTeuMb36hUKjU0nPq+r2azqUajYYPs/Py8lpeXNTc3p4mJCbXbbbXbbY2Pj2tubq7vOZVKRe12W81mU77vD32P5Dpvu+02SdJLXvISvfOd75Qk3XXXXSet87777lMqlVI2m9XU1JSy2awkqdPpKKWe9j9633P4GwEA4OxgDBIAYN27985/lCS1Wi11u125rquNGzeqXq+r2WyqUqmoXq9rbGxMk5OT+omf+An9wR/8ge699169+c1v1je/+U29//3v16te9Sr9xE/8hCYnJyWdPDapWq3q6aef1sGDB9VqtbS4uKjHHntMnU5H2Wx2JWymUqrVapKkQ4cOqdfrKZfL2aZUS0tLchzHboXevn27xsfHT/pMZp1//Md/rA9/+MP60R/9UU1MTOgv//IvValU+tZZr9dVqVTkeZ4KhYI2b96sAwcOqNvtqtVqqdfr6b67/lFX3fjSZ/G3AADA2UcABgCse/XasqSVym+r1VIqlVIul9PExIRqtZqCINDjjz+urVu3SloJlx/4wAfs69/2trfpbW9720nXNQG40+lo3759arVa8jxPrVbrRJW3o3vvvVfZXE4pSXEcq91u23m/Dz74oAqFgu3m7Pu+Wu22giBQq9VSq9XSvn37VCgUdPXVVyuXy/W9/+TkpH7mZ35GP/MzP2O/9653veukdT7++OOSJM/zND4+brdvt1otZbNZpVIpNeu17/LuAgBw/iAAAwDWvThaGRsUhqFarZbS6bTS6bQ2btyo+fl51Wo1HTx48Iyu2e12lU6n1W639aUvfUlxHKtQKKjX62lxcVFRFMn3fV18/Sv00mt3KZVK6eChw/pP//G37dbrIAj0/vf/C1144QXq9Xr64h2P6otf/JKiKNLRo0e1bds29Xo9zc/P60tf+pJe8YpXKJ/P2/deq4MHD9r5xBs3blQqlZK0UhE3I5XiMDijzw8AwPmIAAwAWPeisD8A93o9eZ6ndDqtqakpzc/Pq9fr6Utf+pJe/vKX65577rFze8fHx1WtVrW8vKzl5WXb4OqJJ57Qj/7oj+prX/uawjDU+Pi4isWiwjBUNptVFEXyPFc79l6pcGa3JGnD1BW64KIv69v/8CVJ0vNf9HJtuOo1Ck4E0gt3puR5ruI4VqlUUrfbVbFYVBRFWl5e1uc//3m9+MUv1v/+3/9bu3fv1tTUlJ0jPGytV111lb70pS/ZivPExITy+bxc11UqlVKr1VIURer1egqCzln4zQAA8NwiAAMA1r0w8NXtdm3YMxXQTCajUqmkUqmkxcVFfepTn9K3v/1t3X777UqlUn2PXq+nbrerXq+nXq+n2dlZffrTn1axWNTs7KwmJyfV6/XUarVUrVbtjOGt23fbdaRSKb33Fz6k955inRu3brMjkKrVqsIwVC6X09TUlNLptI4fP65Pf/rTeuSRR/S1r33Nri2dTts1Jh833nijnnrqKd18880qFAoql8s2/JrPY+5J6BOAAQDrHwEYALDuhYGvXq+nOI4lrZzFjeNYuVxO5XJZ4+PjqlQquvTSS+X7vm655RY743cwAJvXplIpFQoFXXDBBdqyZYtc19XCwoI9v+s4jpRK6ciBJ7Rl2+5VVmiklEqtvG+73bZzgmdmZjQ5OalsNquDBw9q7969uuiii/pmAycDcBzHNtxeeumlSqfTmpiYsKOPgiCwVeFut6tut6sg8J+luw8AwLmDAAwAWPeiMLBBz/B9X4VCQYVCwW4hXlpa0tjYmDzPk+u6JwVMcw0Tgi+44AJdfPHFGhsbU61W0/LysqIoUhCsvF9K0tOPP7zmADx/9IBSKZ3YkhwojmO5rtu3xmSH6EwmY88zDwb0MAztNcw26WKxaEc1GXEcr4RmzgADAEYAc4ABAOteFIZKpVI27CW3M5stxpOTk6rVarZB1ckV0kCdTsfO6K3X67r88su1ZcsWFYtFWylObiuWpLu+9bU1r/PI009IiWuYNabTaTu+6IorrlC9Xredpjudjg3cJuCb985ms6rVapqcnOyb/WvuQSqVUhRFkqQ4jr4/NxsAgHMYFWAAwLpnzgCb7sm+7ysIAoVhKNd1NT4+rtnZWT3wwAMqFAp9ld+kIAiUTqcVx7HS6bQ2bNigVCol3/ftWVxp5Wxxt9tVKpXSwvzcmtf5nTu+KZ0Ip5lMxn41QTWbzWp2dlZxHKvVaimOY2UyGRvajWQlOAgCzc7Oanx83G5/7nQ6ds3mvoRUgAEAI4AADABY98IwUO9EFTedTqvb7drKqeM4yufzmpqa0vbt23XhhReq0+nYkNjprDSHyuVyKhaLyufzymazGhsbs1Vlc7bYhNZcLmersX67ueZ1zh87YkNpLpez1d9er6coipTJZOQ4ji655BLV6/VTrjObzSqXyymXy2l5eVnT09N2RFMQBPJ93/5jgK1w+5wBBgCsfwRgAMC6FwS+XCdttymboGoqwK7ramxsTL/+679uO0SvhQm/ye7QjuMol8vZ9zIziNd0vdC375/L5eQ4Tt+WbdN86zWvec2ar2lCr7QyBspsrTYNvkx4pwkWAGAUcAYYALDuBSe2+5qwJ8l2TTYh1nVdhWG45muayqkJqKZrtGkyZbZJp9Vd/WInOGnZCrDnebbia6rAySC8VmEYyvM8+znNWk3QNusMCcAAgBFAAAYArHvBiRm3JrCa7cnJ0UFRFNmKaxzHajb7ty6bLcdxHNsqalLy/K/ZvixJrWZ9zetsN+o2mJotz5JstTY54zeKIsVxLN/3Va/3v0ez2bRh18wVNq8zkvei2+32dYYGAGC9Ygs0AGBdi6NIcdztC4/JICip73umQlosFvueUy6X+6q+g6+TVsJvsilVOp1Ws15b81ob9aoyJ4K0qQC7rnvS85Lv6bqu7e5sFItFWylOBv6kZAB2HEfdOFYcRXIy/F8DAMD6xX/lAADrWhQ9s615tS3EyYBsmkQlw+ZgUE5+X3pmW3Q+n7ddoaMwVOB35GVzq6611ahpYmJCvV5PnucNHW1k/mwqwslALj2zhXpY0Dc/T1Z+7TVP3CsCMABgPWMLNABgXYuiUM6JBliO49juz8nzvsMqwiYgJh+D4XdYRdmc2zWNsNLplFqN1avAzXpVqVRa6XRanufZCvCp3iv59XRrHfyMZvu0GYdkmnWtbJVe+xloAADORwRgAMC6FkcrnZ7T6ZVwaQLwsG3BgwaD5GAAHRYyzdxe0xQrlUqpuYYA3KgtK5VO2aZXJpQOe/9TreFU252HfS4TgM0a3UxGcRSt+loAAM5nBGAAwLoWhaEymYxtUmXGAiW3CQ/bKpw0LGgO+5n5sxmttBJmHbUaqzfCajZqck6E5mw2K9d17Xblwfc83RrW8hlMADZbqR3Hkeu6isK1j2wCAOB8RAAGAKxrURjYzs7SSvhLdnE+3XbmYU73fFP5zWQyymazJ6rA6TV1gm7Va0qnV6q/ruvaSnJyLvGptkGfbq3DAvrgPTDbpgnAAID1jk4XAIB1zfc7iqLINrRyXdeOMhoWEJNVV0k2gJ7u/O9gEyzTRbrVaimdTqu9hgDcbNTs1udisbjSmXmgCZYJr8lgPPh1WCgeXKuZCZwM2VEUyT8xLgoAgPWKAAwAWNf8dlvdbs9ugS4UCjYEDguVp6uqnqoam7yOCZXFYlELCwvSmZwBPrEGM4JpcJu2WWdyLWey/dk8TPg3QTudTqvb7cnvtFddJwAA5zMCMABgXQsD354BNhXebrcr3/c1Nzcn13XleZ4cx7HPM52cTSMrqX/rtBmlZL6ahlK9Xk+1Ws2er/U8T+lUSoeffnLVdR56+kmlUrJzf4MgkO/76vV6WlpaUi6Xs+s06zKNvZJnnJPrMuuNoshWfX3fV6fT6Qv9K9dwFPr+s/eLAADgHEAABgCsa2HQUTbr2cpsGIZaXl7Wvffeq1wuZ8/bmgBsxg+ZYPhMM6tnAmYyOMZxrDAM1Wg0NDk5qVarpTiO7XU8z1OzvoYxSI2qPM+zgTyOY7XbbXU6Hc3NzalQKNi1JCvDyYBu1mJ+bsYdmQAcRZGiKFK73Va321V4okGYabwVhmyBBgCsbwRgAMC6Fvjtvpm6rVZLzWZTlUpFvu/bSqvZFmzO4UrqC8Gm2up5nv3+YEAuFArK5/PKZDK2E3Q2m1UUrl5ZjcPAdn92XVe9Xk+VSkXz8/Oq1Wq2gpuc9WsCran0JsOvpL5t06Yxl5kxPDU1pWazaSvIrucpYAs0AGCdIwADANa1Tru5shX5RNDzPE+tVktjY2PKZDLyfV9hGNoAPKwJ1uDDhF8TiLPZrPL5vDqdjg3PpVLJVpi78erzdbtxZANzqVTqO2+8YcMGtdttG9jNGebBM8LDulKbz2RCuakut1ot+w8DjuPIcz357db38c4DAHDuIQADANa1px572FZVfd/X5s2btWnTJlsJNZXVKIoUhmHfFmepv/GV0ev1lMlklMvl+qq27XZbxWJRhUJBR44c0bFjx+Q4jnprCMC9OLIBfcuWLbrgggvUaDTUbreVz+ftdmZz3jgMw1OuzXw1W6ST27wdx7HXmZub0+Li4onzxa72P/6wbn7V93jDAQA4hxGAAQDr2vyxI8pkVv5zl8lktG3bNl111VX2vK0ktVotPf7447r77ruVy+X6QrGZH2zOCJsQ2el0dOONN2rTpk3K5/MqFov2HG4mk1GtVlMmk1E+n1e8hgAcR6GtGBeLRV1wwQWK49hur242m2q326rVavrKV75yRuu89tprtWfPHhUKBUlSGIYKgkD33nuvHn74YXtv5o8e/r7ffwAAziUEYADAulatLCh94hys4ziamZnRzMyMyuVy33nfIAj0ne98R36iE7IJkYZpLBVFkVKplPbs2aMNGzYol8v1vWcURdq5c6fuvvvulaZVawnAcSTHcZTL5bRr1y7NzMzY4G50Oh0dP35cqVTqjNa5bds27d692/6s2+2qXq9rZmZGjuPYzti15cUzuLMAAJx/CMAAgHVteWlBYwXPblsul8vK5XJ9s4CllfFDrdbJZ2CT83YHjY2NSZJ83+87I1yv1zU/P2+bZPlRvOo6e92uvBPNtubm5jQ5OamxsbGTzvaWy+UzXqfrugrDsO95uVxO5XLZNgeLokj1OgEYALC+EYABAOtao1ZRMTujXq+nfD4vx3FUq9VUKBRsBTiVSsl1XS0vL9sRSIPBc7ARlun+HIbhSc9ttVrqdDr27G0QBauuM6WuMhlPhUJB7XZbrVbLjl5Kvq/ZEt1oNIY2v0o+V1rZ7uy6rg37pgLcbrflOI7y+bza7bbiOFa9Wnk2fgUAAJwzCMAAgHWr025J3VjZbFaO46hUKqlWq2l8fFzlctk+r9vtamZmRvfff7+e//znD71WJpOxD9d1VSgUFEWRDbkmcC4vL2thYUGVykqYjONY9Xpj1bU2Gk3lvIyCIFCtVtPCwoIcx9Hk5KTdomzm/E5PTyufz9vu1eYxzIEDBzQzM2PHIZkQ3Wq1VK/XVSqVFAQrI5jUjeS3W8rmC2d6qwEAOC8QgAEA61a9uqRcLmfHFY2Pj6vRaCiOYwVBYAOtqbSGYahrr71WlUrFBl3znEEzMzO2qZSpvpqGVL1eTxMTE1paWpLv+2q3m6uutd1uqtPJKpfLaXJy0m5LNo2wTNXZdV1dfvnlWlhYOOkaJgibYDw5Oam7775bnudJUt/s4JVgXtfExIQajYZ831c2l1OtWtEsARgAsE4RgAEA61ajuizP81bm3HqepqamlM1m1W63Va1W+wKuqerOzs5qw4YNdqvxYIMpo1gs9v3dhOBCoaDp6WnFcaxCoaBOp6NWc/UKcKtRV7uQV7lcVrlc1vT0dF/ATs703bRpU18F2zBdoU212Dzf9/2+YByGoVqtlrLZrKampjQ/P29nATeqFc1u2vrd3G4AAM55BGAAwLrVqFWUSczojeNYU1NT2rBhg/L5fN8Z4F6vp507d2rXrl22qVU6nbaPQeYMcbKTtLTSkbnb7WpyclK+76/M4fWyq641461s0/Z9XxMTEyoUCioWi7Z6Kz3TwXl2dvakAC6tVHjNo9frKZvNaufOnUqn08pms/I8z17DzBY+dOiQOp3OiX8EyKhR4xwwAGD9IgADANatenVJbiajbDarVCql6elpZbNZu5V4MOBOTU3Zzs5rkU6nbaBMNqHKZDIqFouamppSqVTS8cXlVa+VSjn2NcVi0W67Nmd7TVBPp9PKZDJrXufU1JQd05QMyFEUKZvNanp6Wp7n2Sp4vbq05s8PAMD5hgAMAFi3Hr3/OyoWiyoUCvI8T3Ec2zCYHBtkGkRddNFFdtvxWpjgO/jIZDKK41jFYlH5fF6u6656rYzrKp/P2/CbyWTs9Qc7UJ/JGi+66KK+LtHms6dSKXtPxsfH1Wq1VCwW9dgD+/TCV7xpzdcHAOB8QgAGAKxbTz16nzZMT8pxHBUKBZVKJUmS53knhUppJSy6rtu3pfl04jjuG5nU7XYlyYbL8fHxla3H2dyq1/KyOWWzWU1MTJy0vuRWbbP+tej1errooovsmkyYlmTHOJVKJRUKBfm+r8nJST316H1rujYAAOcjAjAAYF2qLS+qGwWamJhQGIbKZrMqFovK5XLKZDK2s7IJhKlUSlddddXQ876nYppjmQCc3BLd7XY1NjZ24gzw6oHVdVeadZXL5b7t2cOC+loDeiqV0vOe9zw5jmMrwMlKtbkn2ezKGeXx8XHNzR9XfXlR5YnpNd8HAADOF2v/rzwAAOeRQ088pGKhYAOl4zi26/OwcClpaGfl00lWaIddM5fLrYwvWkMTLPfEOWXzmtNd+0yYs8LDrmnOQ6fTablmC3Yhr4NPPnxG7wEAwPmCAAwAWJdu/9rfKZ/P2e3EpvGTGRNkztcmz/F2Op2+RlGrPZJbnwe/1+v11G631ev11rQFOuvl+l5zumufyRo7nU7f65KvD4Kgr4FXoVBQLpfTnd/48rP96wEA4KxgCzQAYF166J5va++eXXYsURzH6nQ6diaupJO2FC8sLGjz5s1rfo84jiX1bytOBsxWq7XSFMtdfQt0xvNsKI2i6LRboM9km/bCwoI2btxo12m+RlEk3/fVarXs50in0yqVStr/yP1rvj4AAOcTAjAAYJ1K2/ArSZ1OR61WS+12W77v2wZWyS3F+/bts2FxLXzfl/RMsExWWKMoUrvdVhAEa9sC7WUVhm3V63W12227VXtYADZndtdi3759eulLX2r/bkJ6FEX2nnQ6HcVxbM8xHzv89JqvDwDA+YQADABYly67+ga1lw6rUqmo0+konU6rWq2q1+up1Wqd1O05lUrp29/+tl796lev+T2iKFIQBJJ00jbjMAxVrVYVhqHcwviq13K9nMJGTdVqVc1m027dHtYB+kwC8Le//W3deOONfWOQTADudruq1WpqtVryfV9LS0taWlrS+NTsmq8PAMD5hAAMAFiXnv/iV+uT//WX5XmeFhcXlc1m1e12tbS0JEl9s3m73a4ymYzuueeeM3qPer3eF4DNVus4jpVOp1Wv19VqtbRx0+oBuDQ2oWPHn7YV4GazKcdx5DiODcHSSgAuFotrXuM999yjer1ut1VLstXeer2uOI5Vq9VUr9fleZ4OHjyoC/dec0b3AQCA8wUBGACwLl127Qv1yGNPaP/+/dqwYYOKxaIajYYajYad02vm4kZRJNd1FYZhX6V0NY1GQ81mU5L6tj7HcaxMJqOlpSUFYaSrbrh51WtddcMLdeDhO7W0tKTl5WVFUSTHcfq2QktSsVg8ozWGYahKpaIwDJXJZOxnDoJA9XpdjUZDx48fV6PR0AMPPKBGq613fuBX13x9AADOJwRgAMC69Mi939bzrrhM09PTymQyOnz4sJ544glls1l1Oh1Jz1SBoyiS53manp4+o3C5vLys5eVlSc8E4DAMFcexDdjV5WVduOvSVa+1bfelWl5e2aK9sLCgIAjs6KZkAD7TkD49Pa3jx48rCAJlMhl7DUmqVqs6evSo0um0Lr30Uu3Zs2dlC/TExJqvDwDA+YQADABYl+aeflgXX3yxstmsCoWCNmzYoP379+vQoUM6duyYCoWCPQcchqFyuZy2b99uOyKvxcGDB1WtViU90wgrDEOFYahsNqvDhw+r1fHV7a5+zbjbVbvj69ChQ0qlUvJ9X+l0Wp7nyXEc+zwTsNdq+/btOnz4sDqdjlzXteeTTffner2uq6++WoVCQe12W9PT0zr46D3aftEVa34PAADOFwRgAMC6VF+c09TUlAqFgg2M27Zt06FDh9RoNFQoFPqen0qldP3119vq6Fo89NBDqtVqknRSkylzxnasVNDBJx7SxPSG017r0BMPaWKspLm5ObVarZM6VJs/HzlyRC95yUvWvMarrrpK+/bts6OfzDpbrZZKpZIuvPBC5fN55XI5FYtFtdtttWqLa74+AADnEwIwAGBdClo17dx7sa3ytlotbdy4UePj41pcXNTTTz+tubk5LS6uhL3JyUkVi8W+kUGr+au/+iul0yvjlkywHB8f19jYmGZnZzU7O6t8Pq+H7rldVz7/9KH1oX2368ILL1S73dby8rKOHz+uWq1mK8ypVEpxHKvb7eq9733vmtfoeZ7CMNT+/fs1NzenDRs2aOvWrdq9e7emp6e1YcMGpVIpFQoFWx1+6sDhNV8fAIDzCQEYALAu5ccm5TiOisWiUqmUstms0um0SqWSpqamdN111ymbzcp1XTmOo1QqJcdx7PngtXjd616nfD6v2dlZTU5OanJyUlEU2YZTpplVmBlb9VpjY2OaLuyS67qamJiwjbkymYwqlYoqlYrm5+dVr9fPaI0XXXSRdu3apV6vpziOFYahfN9XrVbT2NiY8vm87YJtqtZRHK35+gAAnE8IwACAdWlq44VqNpc1NjYm13XtVmjf9xWGoWq1mlKpVF+TqWw223fedjVvectbtLCwYKu/pkJrxhft2LFD3W5X+49UVr2Wm0lr17ZdchxH9Xq9b6zS2NiYxsbGtGPHDuVyObVarTWvsVKpyPd9uy07CAJb6U2n08rlcspkMvbs8pEjR9RLu6tfGACA8xABGACwLu26/Ab94+c+plwup82bN9sOyKVSSalUSrVaTYuLi6pWq8pmsyoWi5qYmFAul1vzeywtLalSqajb7arb7arX62l6eto23vJ9X3EcK5f1Vr1W1nPVarWUzWZVLpfVarXk+77m5+fV7XbtVu7x8XHl8/k1r7Fer2t5eVnNZlNBEKxUmqen7ZbvTCajTCajbrer48ePa3FxUZNbL17z9QEAOJ8QgAEA69LMlh3Kjm/UwYMHNTU1ZSu9hUJBU1NTSqVS6vV6SqfTtgKcTqd1+PDaz7/u3btXjuP0XcNxHLXbbcVxbOcOR6nVuzaXiwWViq5KpZJKpZK63a7Gx8cVx7GtBpvHwsLCmtd47bXX2nBuXm8+u+/76na7kqQgCHTw4EF1naxe8Io3r/n6AACcTwjAAIB165bXvU1f+8zva35+XoVCQel0WnEcq1AoaGxs5VyumQUsrcwDrlardrt08mG2NScfxWJR5XK57z3jOFaxWFSz2dTy8rK63a7q9dqqa63XaxrLTyqOY5XLZRWLRXs+uf95dbmue9L6hq2x1WppamrKVr+lZ2YA12o1tVotpdNpdbtdzc/PS25Bb3jHTytfXP3MMgAA5yMCMABg3cqXxnT5DS/VI9/+O23dutWefx0fH1cQBMpms7YCas7x7ty5074+OdpIUt9YIvN383rzM1NZPX78uIIgUDqdVmVp9bFCS4sLunDTtH2tCbHpdLpvLYVC4aQt0KutM45j+z0zYzgMQzWbTXW7XeVyOS0sLOjyG15J+AUArGsEYADAupYrTapSranT6ahSqahcLisIAvm+L8dx5HmeDZnfreT24na7raWlJbXbbXU6HZXLZR2fO7bqNebnjil77fPUaDTsNVKplPL5vA3Cg8H2THW7XUVRJN/3+0JwKpVSpVpXtjTxPV0fAIBzHQEYALCulSdn1Gq2bFOpbDardrutXC5nOyGbADwsYA5+b7Daajo/x3GsKIrUbDbVbDa1sLCgVCqlYrGoRqO+6jobJzo/+76vTqejTCajbDYrSXIcR5lMxs4cPpP1Jb/X6/XsmKZOp6MgCNRut+V5nlqtpsoTM6uuEwCA8xkBGACwrmXzRWW8rA192WzWzsId3GKcSqVWDcHJgJkMlGEYKggCLS8va2lpSa1Wy54PdjKrjxVyTpzTTafTqtfrOn78uK3Yep4n13XtXODkek61tuT3zGeT1Ff99X1f7XZbhUJBjptVNl9cdZ0AAJzPCMAAgHVvZuNWOwM3CAIbhJPhd1h4lIZXhQ0zT9dc02wvNoIgkCQViuVTXcIyz4miyH7P931Vq1W5rqtsNqtsNmvHIZ1uTaf6HKlUSp1OR51OR+12W0EQ2KZYMxu2rLpGAADOdwRgAMC61lg6qg0TebulOJPJ2KCaTqcVRZENwINB2Pz5dIHTjBhKjkIyrzHXK5VWr6ya53S73b4zyaZKHYahoig67XnlYes1wdc8oihSEASKokiO4yibzcpxHM2MZdVYPKrS9OZV1woAwPmKAAwAWNd6ka/p6WmFYSjXdW3gHQyrhgmuw/580rVPXGfw7yZsZrNZpVIplYu5Vdc5Xi5Ikt2ibc77mkfSqdYy+HmSXwf/3Ov1FMexMpmMPM/T9PS0elFn1XUCAHA+IwADANa1pWMHFIehHMeR67q2W3MyMEqnDpVJpzojbJ5rqrWm8uu6rtLptLxsYdV1etmVOcWe5/VVogcry8PeN7nOwbA7+NmSlelut6t8fqU63m63VZk7qPLGnQIAYL0iAAMA1rV0WFc7CDQ+Pi7XddXpdPoC4WC4nJ6eVibzzH8egyBQo9FQvV5Xo9HQ4uKi/v7v/1533HGHfuAHfkBvf/vb7XNNN+g4jm3ITKfTSjur/+fWOdHl2YRz0106lUr1VYA/8YlP6Ctf+YpuuOEGvfKVr9T09LRKpZLK5bJKpZI8z7PPjaJIi4vPzCA2oTfJXD8IAuXj5hrvKgAA5ycCMABg3eo063rqqae1aXbKnv81IdWES7PVOJ1O68Mf/rB27typTqdjxxmZJlEm0JpxR5dccoluvvlmZTIZW4GNoshWmB3HUbFYlOd5dpzR6XjeSoOrUqmkWq1mzwInRx+lUindfPPNOnr0qJrNpj73uc/JcZy+AO95norFoorFonK5nHq9nm699Va7dlMBNus06/M8T/v3P63pvXXlCqs37QIA4HxEAAYArFuNpaNyUl2Vy2Xlcjnl83k1m82TArB5fOc739HY2Jhcd2Vs0djYmJ2/m9w2bKq8W7asdE42odJ0VTaji8x7lsqrB8pSuaxCoWC3TkdRpE6nY2cXm5C7efNmbdq0SZlMxgb3wa3ZZi2tVktvfOMb5ThO37Zvs37TBMvzPJXLZS0sLKqxdIwADABYtwjAAIB168j+h7Rp40aVSiXlcjl5nifHcWwANiHYPF7zmtdocnJSURQpk8nYkCnJVk/NbN4wDJXP5yX1V4dNwExWYQvF0qprLZZWQrok5XI5VatV+77JRlzZbFazs7N9Ha3NWs3zoyhSFEVyXVePPfaYNm3a1Nf8yoT4dDqtTCajfD6vXq+njRs36Oj+hzVzwUXf998FAADnAgIwAGDdqhx5UjuuuVqFQkGe550UgJMNpFKplMrlssbHx21lNdnh2WxvjqLIztPN5/MKgqDvOiZ45vN55fN5eZ6njOsNXV9SxvXs+d1cLqdWq9W3ZdkolUoqFosqFFYaa5kKtQnqJtibdQZB0FcdTp4xTlaAJWlmZkaH9t3zvdxyAADOaQRgAMC6VF84rE2bNqpcLiubXTlfa7Yl1+t1WwVNmpqaUqm0Uq3NZDJyXbeva7LZOmxm6BYKBXU6HVtVNZXhTCajQqGgYrGoXq+nMOoOW2KfMOrakUTFYlG1Wk1hGPbN7E2lUva6xWJRruuq1+v1nTE2Ta5837cB2Eie/TVV6mw2q2w2awP/xo0b1Fg8rNL01u/HrwEAgHMKARgAsC499eCd2jw9bbc+m3CZzWbVaDROqgL3ej15nqd8Pq9sNmvn7w4GYLO92JzLNdcw4deMFhofH1c2m1Wn01FwopHW6QRhaMPs+Pi4lpeX7TpNNdc8Jicn7WdKngWWngm5+Xxevu+f9BlNUJdk/2HAjGtKpVKanp7W0w/drctfRAAGAKw/BGAAwLqzNHdQ8wcf06aJK+zWZzNj18zZNdVcExAl2TCYy+X6ArD0zIgjE3RNADZndM33e72exsfHVS6X5bquqtWqSmMTq665NDYp3/c1NjZmt2KbLtRRFPU1uyoWi0qn03Jd1wbg5BnfOI5td+pkF2sTfk0ANvfDdV27hbrX62n+4GPaMn9IkxsueBZ+OwAAnD3p1Z8CAMD55Yuf/rhKxYJmZ2dtQHQcR2NjY/bMqwmzyYZYjuPYc7uDD/M6Exjz+bwNx4OV4VKppHw+r263qyAItenC3auuefO2XfKDZyrIpnGXCcBmu7bZBm3CunkMW2sul7OzhZNbn3u9njKZjLLZrMbGxuQ4jq0mz87OqlQs6O8//fFn9XcEAMDZQAAGAKwrTz1yn5qN2kndk00HZdd1VSgUbOXXBMNer2eD4GCgNKHXfDXXSAZgE1RnZmbsKKVer6e270vO6nOAe2lPnY5vw2m5XNbMzIytLJuq7WAAHhbWzc9MZ+jkFm4TgnO5nK12J8comXvSbtb11CP3Phu/IgAAzhoCMABgXdn3rS/r0ot2qNfrqVqt2iZS3W5X6XRaExMTKhaLdjuwCYVmm3G327VbgpPnbh3HsQ2qJicnVSwW7bZhU/0tFot2+3MqlVIURWr7oVJuftV1pzJZtcOVIJ3sSF0qlfoqwI7jqFwua3JyUqVSyY5DSm6RdhxHruvaz2y2e5tHr9dTuVzWxMSE/cwmaFerVXW7XV128S7de/ttz+avCgCA5xxngAEA68oTjzygH3z3O3XbbbepVqtpenraBlVJyufzmpiYUKvVshViEwp7vZ4ajYba7bYNkslwaZhq8djYmNLptKIoUqFQUD6ft+8XhqF831e7Udd0xl113ZlsQc3asoJggx1rND09rU6no06nI9/3bZhdWlqyjbGSazLVXTPj1/f9vvPO5nOae1AoFGxlOQxDdTod1et1NRoNvfSlL9U//o9PfL9+LQAAnBMIwACAdeXIwf26/fbbdeTIEe3atUvtdtvO/pVkm1SZLcJhGCqOY3mepyeffFLlclmFQsFWVpONsIx8Pt83gmhqasqOJkqn0yudn4NAnU5H7XZbfrOqbHH8tOuOQ1/tdkuNRkNRFNmtzJs3b1az2VSr1bJVXd/3FYah2u123zVMCDbjk5rNpoIg0N69e23Vd2pqygb2ZGXZXK/T6ejo0aP61re+pYNPP/F9/M0AAHD2EYABAOtKeWxCt99+u5aWlrRnzx7Nzs4qlUqd1C15fHxc6XTadnButVoaGxvT5s2bNT09rampKeVyOTtGqd1uq9FoqNlsKp1Oq16vK5vNat++fXrxi18sz/PU6XQURZHtvhyGoZrNphqV46sG4E6jqiAI7Rxhx3HsTF8zUukf/uEf9OpXv1qlUkmZTEZxHKtUKtmmWyZ01+t11et1LS0tqV6vS5ImJiaUyWRsp+hms3nSeKdms6m5uTk99dRTmpubU6k88Wz/ugAAeE4RgAEA68oV19yoqD6no0ePamFhQUtLS0qlUrYjsqn8BkGgTCZj5/622237s3K5rHK5bF8jyY49cl23rxr7qle9ym4bdhynb8txEAQKg44+++d/rHe+/9+ddt3N6qI6rZWxR2arswnsrVZLnufpVa961YnO0oHt4GwCerLJl+uubLlut9tqt9tKp9MqFouSpFarZbc9m+Zd3W5XnU5Hx44d08LCgur1uvbu3St3bNOz+JsCAOC5RxMsAMC68uq3/Li2b9+uYrGoxx57TAcOHFCj0VC9XlcQBH3nfbvdrt32axplmdBpnmMeqVTKns01Z4OllQZY1WrVbnduNpsrVd9GQ61WS77v61tf//Kq6/7Mn/6ROp22Wq2WvUaz2bTrq9VqtrpsKsTpdNoG9GHrTaVSNtx2Op2+qq8J6kEQqF6v2+rv008/rXw+rx07duhVb37bs/q7AgDguUYFGACwrpSnNqo4tVlvf8e79Od/9ikdOnRIxWJRU1NT6nQ6faOCTNg153ZNU6zBMGm+Z55rgnCv11OlUpHv+/accHLmbhAEqlarevrJx1Zd91f+9rPa9CNvURAEtjPzYMCtVCqampqyITzZnGtw7Ua321Wr1bJ/NsHXnBM2j6WlJR0+fFjtdltvf+e71I7SKk1t/D79VgAAODdQAQYArDuXv/B1ilKeXnDTzfra176mhx9+WJVKxc7TNWdlTXdlE2B7vZ49F2zC4rCqqgmgvV5P7Xa7r8uyGSdkmms1Gg1tuXDHqmuOu13bAMu83jSpMg/T9Gq16q9ZvyTbFMt8TvO5zXioKIpUqVT08MMP66tf/apuvOmFiuTpspte+6z9fgAAOFuoAAMA1h3Hy+mi579axw9/RI1mU3fddZfGx8eVz6/M4zXna82II0l2hFAqlbKzgU2HZGOwCiytnLPtdru2EmtCZRzHWl5eVqPR0DXPv3nVNd/0kleo0Wj0VXmTlVwTtk1IH6z+muea6rNZuwnynU7H/t2sL4oitdttHTlyRPfdd5+arZaclHTRDa+S4+W+6/sPAMC5igowAGBdyng53fjGf65rn3+zFivLWlhYsFXgYdVVMzM3uYV52EOSDcGmWpus/po/h2GoRqOhRqOhH7z1x1Zd7+t/+O22y/TprmlCejK4J0Nvct6vWa85+zysUl2pVLS4uKhj88d19fU36flvfDfhFwCwblEBBgCsW9l8QT/7G/9Tj95/lz7+4X+jqakplctl5fN5u53ZNLPyfV+STgqKkk6qtCbPDZuQaX5uKsBhGKparerhRx7V+y+7dtW17rn8Wt173wO6+OKLNT093Td7OPnnTqdjq7/JQG7efzA4my3QJjAn19fpdLSwsKADBw7ogx/+mPZcds13fa8BADgfEIABAOvexVdcp43bL9Hc3JzK5bI2bXpmvI8Jj2ackKm0mgCZfI70zJbiVCrVF4CT83SDINDy8rLuuusuXXrNTWte5xXX36w777xTk5OTmpyctO9lmnVJzwTgZIXXGBaAU6mUoijq61ptquALCwuam5vT1NbdhF8AwEhgCzQAYCS861/8W3WilObm5rS8vNzXBKrb7Wp5edkGyzAMVa/XVa1WVa/X7Tgj3/dPGnWUDJRBENjnPfXUU3r6wEG96k1vXfMaX/dP3qEDBw9p//79tlFVEAR927bNNmkzIsm8X6vV6ltzEATqdrvKZDL2Mya3Pi8vL2tubk6dOK13vO+Dz+KdBwDg3EEFGAAwEsrjU7r1ne/Xn/23X1WpVJLjOIrjWNls1lZH8/m8PQvcbrdtt+ek5Axdz/MUhqGtxprq77Fjx3Tvvfdq1yVX6ZKrbljzGi953g3adelVuvfeezUxMaEtW7bYa5ttz61WS61WS9ls1m7jTjLrMGvJZDJ2JFMURbYT9NLSkubm5vRD7/4Flccnv/cbDADAeYAADAAYGdv2XKaxDds1Pz+vdDqtUqmkcrlsu0JPTU0pk8kok8n0zdodbDJlqr379+/XQw89pJtuuknpdNpWih988EHlShP6qX/9G2e8xp/+hQ/pP37wvXrooYdUKpWUy+VUKBQUx7H+8R//UXv37tXWrVuVSqXkuq5dq+kMnVxnNptVFEVaWlpSo9FQJpNRrVZTs9nU/Py8xjZs04W7L30W7jQAAOcmAjAAYKS86JVv1F//8X+R67qq1Wpqt9uamprSxRdfrKmpKVtV9Tyvr7nUYJdl01gql8vpjjvu0Pj4uHK5nObm5vTUU0/pnf/ilzQxNXvG65uYmtUbfuzd+v0Pf1Dj4+PauHGjxsbG9Oijj+rqq6/W9PS0xsfH5bquDekmACfXGwSBrVa3Wi09+uijWlpaUj6fVxAEqtVq+sHXv/37em8BADjXpe48nBgyCADAOvTIfXfqa3/9KVWOPS1JSjmu4nCl6/PevXt15ZVXasuWLXJdV67rDp2zO1gFjqJIrVZLy8vLWlxc1J133qkwDHXs2DE1Wh0VCwX9wn/8Y41PzpzRWquVBf3q+9+qZrOpUjGvTZs2KYoi3XLLLZqZmdHExIQKhcJJVephc4GTTbnm5uZ077336uGHH15prOXm1IsDSdLU5h265Qd/RHuvvO77dcsBADgnEYABAOtWq1HT//5vv6E7/uHLKpRKmp2ekiS5rqupqSlddtlluuSSS5TNZuV53poCcPKMbbvdtiH48OHD+uxnP6taraZt27ap3W5ry67L9dO/+B/OaM2/8ysf0NEnH1Q+n9eTTz6psbExvelNb9IFF1ygyclJFQoF5fP5VQOwWWuyQVcQBHrkkUf04IMPamFhQWEYSpKOL1bUrNf0/Be9TD/6nn+tQmns+/hbAADg3EEABgCsS61GVX/5P39TqThQp9PRo48+qte+9rWanJzU7OyscrmcstlsX/hNBsnVKsBxHKvT6diu0Gae7sMPPyxJqtVq2r//KX387+47o3W//VVXaNfOnSqXy0qn07r44ou1bds2TU5OamxsTIVCQblcbuj2ZzPr16x3MAgnu1T7vq/5+XktLy/rc5/7nC666CIVCgXJyepNP/n/qFAa//7+QgAAOAdwBhgAsC797af+uzKKNTE9rXK5rJe85CU2PJrQ63neSU2kkiHYBGDThVlaCZfmq3mu4zjK5/OamZnRBRdcoCeeeOJE1+VQd/7DF3X9i16xpjXf+Q9ftJ2as9msdu3apZmZGeXzeWWz2aHrHAztRiqV6psTbAK+67r2s3uep5mZGb373e/W3NycGo2GKpWK/u5P/4fe/K5/+f36VQAAcM5gDjAAYN05duBx1Y8f1MzMjDZt2qTNmzcrn8/3BV7HcfpGCCWrvibUJv8+LGwmH47jKJfLafPmzZqamlIQBIrjWN/8yhfWvO5vfPmv1Y1jtVotbdy4UVu2bLHbnVd7/9W+n5ROp5XJZGwYzufz2rx5szZt2qSZmRk1Fg5p7uAT37ffBwAA5woCMABg3fn2bZ/X1NSU8vm8crlcX5U3GQZNsyjzMNuEzbbmZrOpVquldrs99PnSM8HZ8zzlcjnl8yuNqxzHURRFOnboqTWve+7w04qiSJ7naXJy0q7f87y+6u7gWiTZ88hm3e12W77v2znFyeea10uy4T2Tydj1T0xM6Nu3ff67uvcAAJzL2AINAFh3DjyyT5dffrkKhcJJ44zMw2xr7vV66nQ6knRSpTTJhOBCoWBfL/UHSNd1lUqllM/nVS6X1ev1tDB3ZM3rXpg7ol6vp1KppEKhoFQqddJcYmllS7YJ3rVabdXrmrCbyWTsmeBhQd51XRUKBXU6HT344D1rXjcAAOcLAjAAYF05/MSDmp2dled5chzHNq5KhmBJthrcarXO6PqtVkvlctmGSOmZKrDruraKumXLFt15551nFICPHzusXq+nqakpFQoFe1Z5WEMuSVpeXj6jtUtSNpu1c4zNwzT16na7ymQy8jxPGzbM6vCTD2rrrsvO+D0AADhXEYABAOvKvm99WeVyWZlMRvl8Xq7r2gpqKpVSHMfyfV9PPvnk0Nefrgo8+PM9e/bYZlnmYQKrCZSO42j+6CFt2HzBaa87f/SQ0um0wjBUNpuVtBJWk9fu9XryfV8PPPCAfV1yW/Mwp/v5xo0bbQU72fSr2WyqVCrp3ttvIwADANYVAjAAYF154v47tHfvXjmOYyubvV5PjUZDn//8yrnWbdu26cCBA2d87cF5wFdffbVc19XS0pKuuOIKPfHEE1peXlalUtGhQ4fUarU0Pj6u42sIwMePHpIkVSoVPf744wqCQAcOHNDExIR2796t+++/X1NTUwrDUPv27Tttk6sz9frXv95WhuM4ttutH3vgzu/pugAAnGsIwACAdeV5N/6A/OUj+m///fc1Xl45z2rm9c7Pz/fN8U2G2eTIoLX60z/901P+LJVKqVQqSZKOHNyvy699wWmvdeTgfvu6L3/5y2e8lrUY1rnacRz9wz/8g91ync1mtf+pA5qendVb/smPPSvrAADgbCEAAwDWlZe++Z2SpBte9xP6N+9+s+JuV4uLizp48OBzuo5er7fSwMrNat8d39Ar33T6MLnvjm8o466c+T3Tc8lrdaqgX6vVdOGFFypXKKrbk/71h35PL3r5656VNQAAcDal7jy8yuEhAADOU9XKov7wIx/S8bljajZqajUbarea6rRb8jttBX5HQeArCgKFYaAwCBRF4arXzWRcuZ4n1/WU8Tx5XlZeNqdsLq9cvqB8oahCsaRiaUwTUzP68ff8S81s3HLaax6fO6I/+ui/1/LS4llb6+zGTXr7T/0/GpucXvM9BgDgfEIABgAAAACMhPTZXgAAAAAAAM8FAjAAAAAAYCQQgAEAAAAAI4EADAAAAAAYCQRgAAAAAMBIIAADAAAAAEYCARgAAAAAMBIIwAAAAACAkUAABgAAAACMBAIwAAAAAGAkEIABAAAAACOBAAwAAAAAGAkEYAAAAADASCAAAwAAAABGAgEYAAAAADASCMAAAAAAgJFAAAYAAAAAjAQCMAAAAABgJBCAAQAAAAAjgQAMAAAAABgJBGAAAAAAwEggAAMAAAAARgIBGAAAAAAwEgjAAAAAAICRQAAGAAAAAIwEAjAAAAAAYCQQgAEAAAAAI4EADAAAAAAYCQRgAAAAAMBIIAADAAAAAEYCARgAAAAAMBIIwAAAAACAkUAABgAAAACMBAIwAAAAAGAkEIABAAAAACOBAAwAAAAAGAkEYAAAAADASCAAAwAAAABGAgEYAAAAADASCMAAAAAAgJFAAAYAAAAAjAQCMAAAAABgJBCAAQAAAAAjgQAMAAAAABgJBGAAAAAAwEggAAMAAAAARgIBGAAAAAAwEgjAAAAAAICRQAAGAAAAAIwEAjAAAAAAYCQQgAEAAAAAI4EADAAAAAAYCQRgAAAAAMBIIAADAAAAAEYCARgAAAAAMBIIwAAAAACAkUAABgAAAACMBAIwAAAAAGAkEIABAAAAACOBAAwAAAAAGAkEYAAAAADASCAAAwAAAABGAgEYAAAAADASCMAAAAAAgJFAAAYAAAAAjAQCMAAAAABgJBCAAQAAAAAjgQAMAAAAABgJBGAAAAAAwEggAAMAAAAARgIBGAAAAAAwEgjAAAAAAICRQAAGAAAAAIwEAjAAAAAAYCQQgAEAAAAAI4EADAAAAAAYCQRgAAAAAMBIIAADAAAAAEYCARgAAAAAMBIIwAAAAACAkUAABgAAAACMBAIwAAAAAGAkEIABAAAAACOBAAwAAAAAGAkEYAAAAADASCAAAwAAAABGAgEYAAAAADASCMAAAAAAgJFAAAYAAAAAjAQCMAAAAABgJBCAAQAAAAAjgQAMAAAAABgJBGAAAAAAwEggAAMAAAAARgIBGAAAAAAwEgjAAAAAAICRQAAGAAAAAIwEAjAAAAAAYCQQgAEAAAAAI4EADAAAAAAYCQRgAAAAAMBIIAADAAAAAEYCARgAAAAAMBIIwAAAAACAkUAABgAAAACMBAIwAAAAAGAkEIABAAAAACOBAAwAAAAAGAkEYAAAAADASCAAAwAAAABGAgEYAAAAADASCMAAAAAAgJFAAAYAAAAAjAQCMAAAAABgJBCAAQAAAAAjgQAMAAAAABgJBGAAAAAAwEggAAMAAAAARgIBGAAAAAAwEgjAAAAAAICRQAAGAAAAAIwEAjAAAAAAYCQQgAEAAAAAI4EADAAAAAAYCQRgAAAAAMBIIAADAAAAAEYCARgAAAAAMBIIwAAAAACAkUAABgAAAACMBAIwAAAAAGAkEIABAAAAACOBAAwAAAAAGAkEYAAAAADASCAAAwAAAABGAgEYAAAAADASCMAAAAAAgJFAAAYAAAAAjAQCMAAAAABgJBCAAQAAAAAjgQAMAAAAABgJBGAAAAAAwEggAAMAAAAARgIBGAAAAAAwEgjAAAAAAICRQAAGAAAAAIwEAjAAAAAAYCQQgAEAAAAAI4EADAAAAAAYCQRgAAAAAMBIIAADAAAAAEYCARgAAAAAMBIIwAAAAACAkUAABgAAAACMBAIwAAAAAGAkEIABAAAAACOBAAwAAAAAGAkEYAAAAADASCAAAwAAAABGAgEYAAAAADASCMAAAAAAgJFAAAYAAAAAjAQCMAAAAABgJBCAAQAAAAAjgQAMAAAAABgJBGAAAAAAwEggAAMAAAAARgIBGAAAAAAwEgjAAAAAAICRQAAGAAAAAIwEAjAAAAAAYCQQgAEAAAAAI4EADAAAAAAYCQRgAAAAAMBIIAADAAAAAEYCARgAAAAAMBIIwAAAAACAkUAABgAAAACMBAIwAAAAAGAkEIABAAAAACOBAAwAAAAAGAkEYAAAAADASCAAAwAAAABGAgEYAAAAADASCMAAAAAAgJFAAAYAAAAAjAQCMAAAAABgJBCAAQAAAAAjgQAMAAAAABgJBGAAAAAAwEggAAMAAAAARgIBGAAAAAAwEgjAAAAAAICRQAAGAAAAAIwEAjAAAAAAYCQQgAEAAAAAI4EADAAAAAAYCQRgAAAAAMBIIAADAAAAAEYCARgAAAAAMBIIwAAAAACAkUAABgAAAACMBAIwAAAAAGAkEIABAAAAACOBAAwAAAAAGAkEYAAAAADASCAAAwAAAABGAgEYAAAAADASCMAAAAAAgJFAAAYAAAAAjAQCMAAAAABgJBCAAQAAAAAjgQAMAAAAABgJBGAAAAAAwEggAAMAAAAARgIBGAAAAAAwEgjAAAAAAICRQAAGAAAAAIwEAjAAAAAAYCQQgAEAAAAAI4EADAAAAAAYCQRgAAAAAMBIIAADAAAAAEYCARgAAAAAMBIIwAAAAACAkUAABgAAAACMBAIwAAAAAGAkEIABAAAAACOBAAwAAAAAGAkEYAAAAADASCAAAwAAAABGAgEYAAAAADASCMAAAAAAgJFAAAYAAAAAjAQCMAAAAABgJBCAAQAAAAAjgQAMAAAAABgJBGAAAAAAwEggAAMAAAAARgIBGAAAAAAwEgjAAAAAAICRQAAGAAAAAIwEAjAAAAAAYCQQgAEAAAAAI4EADAAAAAAYCQRgAAAAAMBIIAADAAAAAEYCARgAAAAAMBIIwAAAAACAkUAABgAAAACMBAIwAAAAAGAkEIABAAAAACOBAAwAAAAAGAkEYAAAAADASCAAAwAAAABGAgEYAAAAADASCMAAAAAAgJFAAAYAAAAAjAQCMAAAAABgJBCAAQAAAAAjgQAMAAAAABgJBGAAAAAAwEggAAMAAAAARgIBGAAAAAAwEgjAAAAAAICRQAAGAAAAAIwEAjAAAAAAYCQQgAEAAAAAI4EADAAAAAAYCQRgAAAAAMBIIAADAAAAAEYCARgAAAAAMBIIwAAAAACAkUAABgAAAACMBAIwAAAAAGAkEIABAAAAACOBAAwAAAAAGAkEYAAAAADASCAAAwAAAABGAgEYAAAAADASCMAAAAAAgJFAAAYAAAAAjAQCMAAAAABgJBCAAQAAAAAjgQAMAAAAABgJBGAAAAAAwEggAAMAAAAARgIBGAAAAAAwEgjAAAAAAICRQAAGAAAAAIwEAjAAAAAAYCQQgAEAAAAAI4EADAAAAAAYCQRgAAAAAMBIIAADAAAAAEYCARgAAAAAMBIIwAAAAACAkUAABgAAAACMBAIwAAAAAGAkEIABAAAAACOBAAwAAAAAGAkEYAAAAADASCAAAwAAAABGAgEYAAAAADASCMAAAAAAgJFAAAYAAAAAjAQCMAAAAABgJBCAAQAAAAAj4f8HAoHZ4yka18gAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "im2" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[831.38203679, 0. , 480. ],\n", + " [ 0. , 831.38203679, 270. ],\n", + " [ 0. , 0. , 1. ]])" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "camera_info.intrinsic_matrix()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/drake_stuff/mbp_robot_arm_joint_limit_stuff/README.md b/drake_stuff/mbp_robot_arm_joint_limit_stuff/README.md index c7ecf2c9..9674a8cd 100644 --- a/drake_stuff/mbp_robot_arm_joint_limit_stuff/README.md +++ b/drake_stuff/mbp_robot_arm_joint_limit_stuff/README.md @@ -2,44 +2,39 @@ ## Prereqs -Tested on Ubuntu 18.04 (Bionic). Needs ROS1 Melodic, Drake prereqs, and -pyassimp. +Tested on Ubuntu 20.04 (Focal). -## Setup +- Install Ignition Gazebo (Model Photo Shoot plugin is needed): + +- Ensure Drake prereqs are installed: + +- Install additional packages: + `sudo apt install imagemagick` -You can just run this: +## Example -```sh -./setup.sh -``` +For rendering CERBERUS: + -This will: +Download archive to `/tmp/CERBERUS_ANYMAL_C_SENSOR_CONFIG_2.zip`. -* Set up a small `virtualenv` with Drake and JupyterLab -* Clone `ur_description` and, uh, convert it to format that Drake can use :( +```sh +# Download data. +mkdir -p repos && cd repos +# Manually download archive to /tmp/CERBERUS_ANYMAL_C_SENSOR_CONFIG_2.zip +unzip /tmp/CERBERUS_ANYMAL_C_SENSOR_CONFIG_2.zip -d ./CERBERUS_ANYMAL_C_SENSOR_CONFIG_2/ -## Running +# You can run the setup, transformation and tests through: +cd .. +./setup_transform_test.sh ${PWD}/repos/CERBERUS_ANYMAL_C_SENSOR_CONFIG_2/ model.sdf -```sh -./setup.sh jupyter lab ./joint_limits.ipynb -``` +# Or you can run each step separately: +cd .. +source setup.sh -## PyAssimp hacks +./format_model_and_generate_manifest.sh ${PWD}/repos/CERBERUS_ANYMAL_C_SENSOR_CONFIG_2/ model.sdf + +./compare_model_via_drake_and_ingition_images.sh ${PWD}/repos/CERBERUS_ANYMAL_C_SENSOR_CONFIG_2/ model.sdf -```sh -cd assimp -# In assimp source tree. -git clone https://github.com/assimp/assimp -b v5.0.1 -src_dir=${PWD} -# install_dir=${src_dir}/build/install -install_dir=~/proj/tri/repo/repro/drake_stuff/mbp_robot_arm_joint_limit_stuff/venv -mkdir -p build && cd build -cmake .. -DCMAKE_INSTALL_PREFIX=${install_dir} -GNinja -ninja install - -cd ${src_dir}/port/PyAssimp/ -python3 ./setup.py install --prefix ${install_dir} - -cd ${install_dir}/lib/python3.6/site-packages/pyassimp -ln -s ../../../libassimp.so ./ ``` + diff --git a/drake_stuff/mbp_robot_arm_joint_limit_stuff/assimp_issue.py b/drake_stuff/mbp_robot_arm_joint_limit_stuff/assimp_issue.py index ecaa4d49..764fe7bc 100644 --- a/drake_stuff/mbp_robot_arm_joint_limit_stuff/assimp_issue.py +++ b/drake_stuff/mbp_robot_arm_joint_limit_stuff/assimp_issue.py @@ -13,7 +13,6 @@ def load_mesh(mesh_file): def get_mesh_vertices(scene): - def print_transforms(node, prefix=""): print(indent(str(node.transformation), prefix)) for child in node.children: diff --git a/drake_stuff/mbp_robot_arm_joint_limit_stuff/compare_model_via_drake_and_ingition_images.sh b/drake_stuff/mbp_robot_arm_joint_limit_stuff/compare_model_via_drake_and_ingition_images.sh new file mode 100644 index 00000000..922343c7 --- /dev/null +++ b/drake_stuff/mbp_robot_arm_joint_limit_stuff/compare_model_via_drake_and_ingition_images.sh @@ -0,0 +1,13 @@ +#!/bin/bash + +if [[ $# -lt 1 || $# -gt 2 ]]; then + echo "Please provide path to model directory and model file name." + echo " Usage:" + echo " $bash compare_model_via_drake_and_ignition_images.sh " + return 1 +fi + +temp_directory=$(mktemp -d) +echo "Saving temporal test files to: ${temp_directory}" + +./test_models.py "$1" "$2" "$temp_directory" diff --git a/drake_stuff/mbp_robot_arm_joint_limit_stuff/format_model_and_generate_manifest.sh b/drake_stuff/mbp_robot_arm_joint_limit_stuff/format_model_and_generate_manifest.sh new file mode 100644 index 00000000..4b392cab --- /dev/null +++ b/drake_stuff/mbp_robot_arm_joint_limit_stuff/format_model_and_generate_manifest.sh @@ -0,0 +1,42 @@ +#!/bin/bash + +_cur_dir=$(cd $(dirname ${BASH_SOURCE}) && pwd) + +_provision_repos() { ( + set -eu + cd ${_cur_dir} + repo_dir=${PWD}/repos + completion_token=2021-03-12.1 + completion_file=$1/.completion-token + + if [[ "$2" == *\.sdf ]] + then + ./render_ur_urdfs.py "$1" "$2" + else + if [[ -f ${completion_file} && "$(cat ${completion_file})" == "${completion_token}" ]]; then + return 0 + fi + set -x + rm -rf ${repo_dir} + + mkdir ${repo_dir} && cd ${repo_dir} + + git clone https://github.com/ros-industrial/universal_robot + cd universal_robot/ + git checkout e8234318cc94 # From melodic-devel-staging + # Er... dunno what to do about this, so hackzzz + cd ${_cur_dir} + ./ros_setup.bash ./render_ur_urdfs.py "$1" "$2" + fi + + echo "${completion_token}" > ${completion_file} +) } + +if [[ $# -lt 1 || $# -gt 2 ]]; then + echo "Please provide path to model directory and model file name." + echo " Usage:" + echo " $bash format_model_and_generate_manifest.sh " + return 1 +fi + +_provision_repos "$1" "$2" diff --git a/drake_stuff/mbp_robot_arm_joint_limit_stuff/multibody_extras.py b/drake_stuff/mbp_robot_arm_joint_limit_stuff/multibody_extras.py index 1d6bf4e6..5a10d036 100644 --- a/drake_stuff/mbp_robot_arm_joint_limit_stuff/multibody_extras.py +++ b/drake_stuff/mbp_robot_arm_joint_limit_stuff/multibody_extras.py @@ -19,20 +19,22 @@ def _get_plant_aggregate(num_func, get_func, index_cls, model_instances=None): def get_model_instances(plant): # TODO(eric.cousineau): Hoist this somewhere? return _get_plant_aggregate( - plant.num_model_instances, lambda x: x, - ModelInstanceIndex) + plant.num_model_instances, lambda x: x, ModelInstanceIndex + ) def get_bodies(plant, model_instances=None): # TODO(eric.cousineau): Hoist this somewhere? return _get_plant_aggregate( - plant.num_bodies, plant.get_body, BodyIndex, model_instances) + plant.num_bodies, plant.get_body, BodyIndex, model_instances + ) def get_frames(plant, model_instances=None): # TODO(eric.cousineau): Hoist this somewhere? return _get_plant_aggregate( - plant.num_frames, plant.get_frame, FrameIndex, model_instances) + plant.num_frames, plant.get_frame, FrameIndex, model_instances + ) def get_frames_attached_to(plant, bodies): @@ -47,7 +49,8 @@ def get_frames_attached_to(plant, bodies): def get_joints(plant, model_instances=None): # TODO(eric.cousineau): Hoist this somewhere? return _get_plant_aggregate( - plant.num_joints, plant.get_joint, JointIndex, model_instances) + plant.num_joints, plant.get_joint, JointIndex, model_instances + ) def is_joint_solely_connected_to(joint, bodies): @@ -60,15 +63,17 @@ def is_joint_solely_connected_to(joint, bodies): def get_joints_solely_connected_to(plant, bodies): # TODO(eric.cousineau): Hoist this somewhere? return [ - joint for joint in get_joints(plant) - if is_joint_solely_connected_to(joint, bodies)] + joint + for joint in get_joints(plant) + if is_joint_solely_connected_to(joint, bodies) + ] def get_joint_actuators(plant, model_instances=None): # TODO(eric.cousineau): Hoist this somewhere? return _get_plant_aggregate( - plant.num_actuators, plant.get_joint_actuator, - JointActuatorIndex) + plant.num_actuators, plant.get_joint_actuator, JointActuatorIndex + ) def get_joint_actuators_affecting_joints(plant, joints): @@ -105,7 +110,7 @@ def get_joint_positions(plant, context, joint): q = plant.GetPositions(context) start = joint.position_start() count = joint.num_positions() - return q[start:start + count].copy() + return q[start : start + count].copy() def set_joint_positions(plant, context, joint, qj): @@ -113,7 +118,7 @@ def set_joint_positions(plant, context, joint, qj): q = plant.GetPositions(context) start = joint.position_start() count = joint.num_positions() - q[start:start + count] = qj + q[start : start + count] = qj plant.SetPositions(context, q) @@ -122,7 +127,7 @@ def get_joint_velocities(plant, context, joint): v = plant.GetVelocities(context) start = joint.velocity_start() count = joint.num_velocities() - return v[start:start + count].copy() + return v[start : start + count].copy() def set_joint_velocities(plant, context, joint, vj): @@ -130,5 +135,5 @@ def set_joint_velocities(plant, context, joint, vj): v = plant.GetVelocities(context) start = joint.velocity_start() count = joint.num_velocities() - v[start:start + count] = vj + v[start : start + count] = vj plant.SetVelocities(context, v) diff --git a/drake_stuff/mbp_robot_arm_joint_limit_stuff/process_util.py b/drake_stuff/mbp_robot_arm_joint_limit_stuff/process_util.py index c416a622..dfa1d130 100644 --- a/drake_stuff/mbp_robot_arm_joint_limit_stuff/process_util.py +++ b/drake_stuff/mbp_robot_arm_joint_limit_stuff/process_util.py @@ -98,7 +98,7 @@ def __init__(self, streams, on_new_text=tuple()): def clear(self): self._text = "" - def get_text(self, timeout=0.): + def get_text(self, timeout=0.0): """ Gets current text. @param timeout Timeout for polling each stream. If None, will not @@ -132,9 +132,10 @@ class CapturedProcess(object): controlling realtime stuff. For complex state machine process interaction, use `pexpect`. """ + def __init__( - self, args, stderr=STDOUT, on_new_text=None, simple_encoding=True, - **kwargs): + self, args, stderr=STDOUT, on_new_text=None, simple_encoding=True, **kwargs + ): # Python processes don't like buffering by default. args = ["env", "PYTHONUNBUFFERED=1", "stdbuf", "-o0"] + args self._args = args diff --git a/drake_stuff/mbp_robot_arm_joint_limit_stuff/pyassimp_hacks.md b/drake_stuff/mbp_robot_arm_joint_limit_stuff/pyassimp_hacks.md new file mode 100644 index 00000000..78fefcd0 --- /dev/null +++ b/drake_stuff/mbp_robot_arm_joint_limit_stuff/pyassimp_hacks.md @@ -0,0 +1,21 @@ +## PyAssimp hacks + +To build `pyassimp` from source: + +```sh +cd assimp +# In assimp source tree. +git clone https://github.com/assimp/assimp -b v5.0.1 +src_dir=${PWD} +# install_dir=${src_dir}/build/install +install_dir=~/proj/tri/repo/repro/drake_stuff/mbp_robot_arm_joint_limit_stuff/venv +mkdir -p build && cd build +cmake .. -DCMAKE_INSTALL_PREFIX=${install_dir} -GNinja +ninja install + +cd ${src_dir}/port/PyAssimp/ +python3 ./setup.py install --prefix ${install_dir} + +cd ${install_dir}/lib/python3.6/site-packages/pyassimp +ln -s ../../../libassimp.so ./ +``` diff --git a/drake_stuff/mbp_robot_arm_joint_limit_stuff/render_ur_urdfs.py b/drake_stuff/mbp_robot_arm_joint_limit_stuff/render_ur_urdfs.py index 49f8a819..5e4ecf20 100755 --- a/drake_stuff/mbp_robot_arm_joint_limit_stuff/render_ur_urdfs.py +++ b/drake_stuff/mbp_robot_arm_joint_limit_stuff/render_ur_urdfs.py @@ -14,9 +14,14 @@ import sys from textwrap import indent +from lxml import etree import numpy as np import pyassimp import yaml +import argparse +import re +import fileinput +from PIL import Image from process_util import CapturedProcess, bind_print_prefixed @@ -36,7 +41,7 @@ def shell(cmd, check=True): def subshell(cmd, check=True, stderr=None, strip=True): - """Executs a subshell in a capture.""" + """Executes a subshell in a capture.""" eprint(f"+ $({cmd})") result = run(cmd, shell=True, stdout=PIPE, stderr=stderr, encoding="utf8") if result.returncode != 0 and check: @@ -68,47 +73,87 @@ def load_mesh(mesh_file): return scene -def get_mesh_extent(scene, mesh_file): - # Return geometric center and size. +def get_transformed_vertices(node, v_list): + for child in node.children: + get_transformed_vertices(child, v_list) + + # add current node meshes to the list + for mesh in child.meshes: + for j in range(mesh.vertices.shape[0]): + v_list.append( + child.transformation.dot(np.append(mesh.vertices[j], 1))[0:3] + ) - # def check_identity(node): - # np.testing.assert_equal( - # node.transformation, - # np.eye(4), - # err_msg=mesh_file, - # ) - # for child in node.children: - # check_identity(child) + # apply current transformation to vertices + for i in range(len(v_list)): + v_list[i] = node.transformation.dot(np.append(v_list[i], 1)).A[0, 0:3] - # assert len(scene.meshes) > 0, mesh_file - # # Meshes should not have transforms. - # check_identity(scene.rootnode) +def get_mesh_extent(scene, mesh_file, filetype="obj"): + # Return geometric center and size. v_list = [] - for mesh in scene.meshes: - v_list.append(mesh.vertices) - v = np.vstack(v_list) - lb = np.min(v, axis=0) - ub = np.max(v, axis=0) + + if filetype == ".dae": + rotation = np.matrix([[1, 0, 0, 0], [0, 0, -1, 0], [0, 1, 0, 0], [0, 0, 0, 1]]) + else: + rotation = np.matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]) + + scene.rootnode.transformation = rotation.dot(scene.rootnode.transformation) + get_transformed_vertices(scene.rootnode, v_list) + + lb = np.min(v_list, axis=0) + ub = np.max(v_list, axis=0) size = ub - lb center = (ub + lb) / 2 return np.array([center, size]) -def convert_file_to_obj(mesh_file, suffix): +# Aplies a rotation to the root node +def rotate_root_node(scene, rotation): + transformed = rotation.dot(scene.rootnode.transformation) + scene.mRootNode.contents.mTransformation.a1 = transformed.item(0) + scene.mRootNode.contents.mTransformation.a2 = transformed.item(1) + scene.mRootNode.contents.mTransformation.a3 = transformed.item(2) + scene.mRootNode.contents.mTransformation.a4 = transformed.item(3) + scene.mRootNode.contents.mTransformation.b1 = transformed.item(4) + scene.mRootNode.contents.mTransformation.b2 = transformed.item(5) + scene.mRootNode.contents.mTransformation.b3 = transformed.item(6) + scene.mRootNode.contents.mTransformation.b4 = transformed.item(7) + scene.mRootNode.contents.mTransformation.c1 = transformed.item(8) + scene.mRootNode.contents.mTransformation.c2 = transformed.item(9) + scene.mRootNode.contents.mTransformation.c3 = transformed.item(10) + scene.mRootNode.contents.mTransformation.c4 = transformed.item(11) + scene.mRootNode.contents.mTransformation.d1 = transformed.item(12) + scene.mRootNode.contents.mTransformation.d2 = transformed.item(13) + scene.mRootNode.contents.mTransformation.d3 = transformed.item(14) + scene.mRootNode.contents.mTransformation.d4 = transformed.item(15) + + +def convert_file_to_obj(mesh_file, suffix, scale=1): assert mesh_file.endswith(suffix), mesh_file - obj_file = mesh_file[:-len(suffix)] + ".obj" + obj_file = mesh_file[: -len(suffix)] + ".obj" print(f"Convert Mesh: {mesh_file} -> {obj_file}") if isfile(obj_file): return scene = load_mesh(mesh_file) - extent = get_mesh_extent(scene, mesh_file) + + # Workaround for issue https://github.com/assimp/assimp/issues/849. + if suffix == ".dae": + ROT_X_90 = np.matrix([[1, 0, 0, 0], [0, 0, -1, 0], [0, 1, 0, 0], [0, 0, 0, 1]]) + rotate_root_node(scene, ROT_X_90) + pyassimp.export(scene, obj_file, file_type="obj") - # Sanity check. + + # TODO(marcoag) skip sanity check for now + # find a way to do one + extent = get_mesh_extent(scene, mesh_file, suffix) scene_obj = load_mesh(obj_file) extent_obj = get_mesh_extent(scene_obj, mesh_file) - np.testing.assert_equal( - extent, extent_obj, + np.testing.assert_allclose( + extent, + extent_obj, + rtol=1e-05, + atol=1e-07, err_msg=repr((mesh_file, obj_file)), ) @@ -119,11 +164,61 @@ def replace_text_to_obj(content, suffix): def find_mesh_files(d, suffix): - files = subshell(f"find meshes -name '*{suffix}'").strip().split() + files = subshell(f"find . -name '*{suffix}'").strip().split() files.sort() return files +# Workaround for https: // github.com/assimp/assimp/issues/3367 +# remove this once all consumers have an assimp release +# incorporating the fix available on their distribution +def remove_empty_tags(dae_file, root): + + for element in root.xpath(".//*[not(node())]"): + if len(element.attrib) == 0: + element.getparent().remove(element) + + data = etree.tostring(root, pretty_print=True).decode("utf-8") + text_file = open(dae_file, "w") + text_file.write(data) + text_file.close() + + +def obtain_scale(root): + return float(root.xpath("//*[local-name() = 'unit']")[0].get("meter")) + + +# Some models contain materials that use gazebo specifics scripts +# remove them so they don't fail +def remove_gazebo_specific_scripts(description_file): + root = etree.parse(description_file) + + for material_element in root.findall(".//material"): + script_element = material_element.find("script") + if script_element is not None: + print(script_element.find("name").text) + if script_element.find("name").text.startswith("Gazebo"): + material_element.remove(script_element) + + data = etree.tostring(root, pretty_print=True).decode("utf-8") + with open(description_file, "w") as text_file: + text_file.write(data) + + +# Some models use pacakge based uri but don't contain a +# pacakge.xml so we create one to make sure they can be +# resolved +def create_pacakge_xml(description_file): + if not os.path.isfile("package.xml"): + root = etree.parse(description_file) + model_element = root.find(".//model") + package_name = model_element.attrib["name"] + with open("package.xml", "w") as f: + f.write( + """\n {package_name}\n""" + ) + + FLAVORS = [ "ur3", "ur3e", @@ -132,65 +227,112 @@ def find_mesh_files(d, suffix): ] -def main(): +def preprocess_sdf_and_materials(model_directory, description_file): + description_file_path = os.path.join(model_directory, description_file) + for line in fileinput.input(description_file_path, inplace=True): + # Some sdfs have a comment before the xml tag + # this makes the parser fail, since the tag is optional + # we'll remove it as safety workaround + if not re.search(r"^\<\?xml.*", line): + # Change the reference of the mesh file + line = re.sub(r"\.stl|\.dae", ".obj", line) + print(line, end="") + + for root, subdirs, files in os.walk(model_directory): + for filename in files: + # Convert jpg/jpeg files to png + if filename.endswith(".jpg") or filename.endswith(".jpeg"): + im = Image.open(os.path.join(root, filename)) + filename = re.sub(r"\.jpg|\.jpeg", ".png", filename) + rgb_im = im.convert("RGB") + rgb_im.save(os.path.join(root, filename)) + print("Convert jpg/jpeg: ", os.path.join(root, filename)) + # Change jpg/jpeg renferences on mtl files to png + if filename.endswith(".mtl"): + for line in fileinput.input(os.path.join(root, filename), inplace=True): + line = re.sub(r"\.jpg|\.jpeg", ".png", line) + print(line, end="") + + +def main(model_directory, description_file): + + preprocess_sdf_and_materials(model_directory, description_file) source_tree = parent_dir(abspath(__file__), count=1) cd(source_tree) print(pyassimp.__file__) print(pyassimp.core._assimp_lib.dll) - if "ROS_DISTRO" not in os.environ: - raise UserError("Please run under `./ros_setup.bash`, or whatevs") - - cd("repos/universal_robot") - # Use URI that is unlikely to be used. - os.environ["ROS_MASTER_URI"] = "http://localhost:11321" - os.environ[ - "ROS_PACKAGE_PATH" - ] = f"{os.getcwd()}:{os.environ['ROS_PACKAGE_PATH']}" - - cd("ur_description") - - print() + cd(model_directory) print(f"[ Convert Meshes for Drake :( ]") - for dae_file in find_mesh_files("meshes", ".dae"): - convert_file_to_obj(dae_file, ".dae") - for stl_file in find_mesh_files("meshes", ".stl"): + for dae_file in find_mesh_files(".", ".dae"): + root = etree.parse(dae_file) + remove_empty_tags(dae_file, root) + scale = obtain_scale(root) + convert_file_to_obj(dae_file, ".dae", scale) + for stl_file in find_mesh_files(".", ".stl"): convert_file_to_obj(stl_file, ".stl") - urdf_files = [] - # Start a roscore, 'cause blech. - roscore = CapturedProcess( - ["roscore", "-p", "11321"], - on_new_text=bind_print_prefixed("[roscore] "), - ) - with closing(roscore): - # Blech. - while "started core service" not in roscore.output.get_text(): - assert roscore.poll() is None - - for flavor in FLAVORS: - shell(f"roslaunch ur_description load_{flavor}.launch") - urdf_file = f"urdf/{flavor}.urdf" - output = subshell(f"rosparam get /robot_description") - # Blech :( - content = yaml.load(output) - content = replace_text_to_obj(content, ".stl") - content = replace_text_to_obj(content, ".dae") - with open(urdf_file, "w") as f: - f.write(content) - urdf_files.append(urdf_file) - - print("\n\n") - print("Generated URDF files:") - print(indent("\n".join(urdf_files), " ")) + if description_file.endswith(".sdf"): + print( + "Found SDF as description file, making arrangements to ensure compatibility" + ) + remove_gazebo_specific_scripts(description_file) + create_pacakge_xml(description_file) + else: + print("Found URDF as description file, translating through ros launch") + cd(source_tree) + cd("repos/universal_robot") + if "ROS_DISTRO" not in os.environ: + raise UserError("Please run under `./ros_setup.bash`, or whatevs") + + # Use URI that is unlikely to be used. + os.environ["ROS_MASTER_URI"] = "http://localhost:11321" + os.environ[ + "ROS_PACKAGE_PATH" + ] = f"{os.getcwd()}:{os.environ['ROS_PACKAGE_PATH']}" + + cd("ur_description") + + print() + + urdf_files = [] + # Start a roscore, 'cause blech. + roscore = CapturedProcess( + ["roscore", "-p", "11321"], + on_new_text=bind_print_prefixed("[roscore] "), + ) + with closing(roscore): + # Blech. + while "started core service" not in roscore.output.get_text(): + assert roscore.poll() is None + + for flavor in FLAVORS: + shell(f"roslaunch ur_description load_{flavor}.launch") + urdf_file = f"urdf/{flavor}.urdf" + output = subshell(f"rosparam get /robot_description") + # Blech : ( + content = yaml.load(output) + content = replace_text_to_obj(content, ".stl") + content = replace_text_to_obj(content, ".dae") + with open(urdf_file, "w") as f: + f.write(content) + urdf_files.append(urdf_file) + + print("\n\n") + print("Generated URDF files:") + print(indent("\n".join(urdf_files), " ")) if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("model_directory", help="Directory location of the model files") + parser.add_argument("description_file", help="Model description file name") + args = parser.parse_args() try: - main() - print() - print("[ Done ]") + main(args.model_directory, args.description_file) except UserError as e: eprint(e) sys.exit(1) + print() + print("[ Done ]") diff --git a/drake_stuff/mbp_robot_arm_joint_limit_stuff/requirements.freeze.txt b/drake_stuff/mbp_robot_arm_joint_limit_stuff/requirements.freeze.txt index 3c20446c..e5fddf2a 100644 --- a/drake_stuff/mbp_robot_arm_joint_limit_stuff/requirements.freeze.txt +++ b/drake_stuff/mbp_robot_arm_joint_limit_stuff/requirements.freeze.txt @@ -1,27 +1,35 @@ -alabaster==0.7.8 -anyio==2.2.0 -apturl==0.5.2 -argcomplete==1.8.1 -argon2-cffi==20.1.0 -asn1crypto==0.24.0 -async-generator==1.10 -attrs==20.3.0 -Automat==0.6.0 -awscli==1.18.69 -Babel==2.9.0 -backcall==0.2.0 -beautifulsoup4==4.6.0 -bleach==3.3.0 -boto3==1.4.2 -botocore==1.16.19 -Brlapi==0.6.6 -cachetools==2.0.0 -catkin-pkg-modules==0.4.23 -certifi==2020.12.5 -cffi==1.14.5 -chardet==4.0.0 -chrome-gnome-shell==0.0.0 -click==6.7 +alabaster==0.7.12 +anyio==3.4.0 +argcomplete==1.12.0 +argon2-cffi==21.3.0 +argon2-cffi-bindings==21.2.0 +asgiref==3.4.1 +atomicwrites==1.1.5 +attrs==19.3.0 +autobahn==17.10.1 +Automat==0.8.0 +Babel==2.9.1 +backcall==0.1.0 +backports.weakref==1.0 +bcrypt==3.1.7 +beautifulsoup4==4.8.2 +bidict==0.21.2 +black==22.1.1.dev41+gf239d22 +bleach==3.1.1 +blinker==1.4 +bloom==0.10.7 +breezy==3.0.2 +cached-property==1.5.1 +catkin-pkg==0.4.24 +catkin-pkg-modules==0.4.24 +catkin-tools==0.7.1 +cbor==1.0.0 +certifi==2019.11.28 +cffi==1.15.0 +chardet==3.0.4 +click==8.0.4 +click-plugins==1.1.1 +cligj==0.5.0 colcon-argcomplete==0.3.3 colcon-bash==0.4.2 colcon-cd==0.1.1 @@ -44,192 +52,247 @@ colcon-recursive-crawl==0.2.1 colcon-ros==0.3.21 colcon-test-result==0.3.8 colcon-zsh==0.4.0 -colorama==0.3.7 -command-not-found==0.3 +colorama==0.4.3 configobj==5.0.6 constantly==15.1.0 -contextvars==2.4 cov-core==1.15.0 -coverage==4.5 -cryptography==2.1.4 -cupshelpers==1.0 +coverage==4.5.2 +cryptography==2.8 cycler==0.10.0 -dataclasses==0.8 +Cython==0.29.14 +dataclasses==0.6 +dbus-python==1.2.16 decorator==4.4.2 -defer==1.0.6 -defusedxml==0.7.1 -dill==0.2.7.1 -distlib==0.2.6 -distro-info===0.18ubuntu0.18.04.1 -docutils==0.14 +defusedxml==0.6.0 +Deprecated==1.2.7 +devscripts===2.20.2ubuntu2 +distlib==0.3.0 +distro==1.4.0 +docker==4.1.0 +docker-compose==1.25.0 +dockerpty==0.4.1 +docopt==0.6.2 +docutils==0.16 +drake==1.1.0 +dulwich==0.19.15 empy==3.3.2 entrypoints==0.3 -flake8==3.5.0 -h5py==2.7.1 -html5lib==0.999999999 -httplib2==0.9.2 -hyperlink==17.3.1 -idna==2.10 +et-xmlfile==1.0.1 +fastapi==0.70.1 +fastimport==0.9.8 +fastjsonschema==2.15.3 +Fiona==1.8.13 +flake8==3.7.9 +flake8-blind-except==0.1.1 +flake8-builtins==1.5.3 +flake8-class-newline==1.6.0 +flake8-comprehensions==3.2.3 +flake8-deprecated==1.3 +flake8-docstrings==1.5.0 +flake8-import-order==0.18.1 +flake8-quotes==3.2.0 +Flask==1.1.1 +Flask-Cors==3.0.8 +Flask-SocketIO==5.0.1 +gpg===1.13.1-unknown +h11==0.12.0 +html5lib==1.0.1 +httplib2==0.14.0 +hyperlink==19.0.0 +idna==2.8 ifcfg==0.18 -imagesize==0.7.1 -immutables==0.15 -importlib-metadata==3.7.2 +imagesize==1.3.0 +importlib-metadata==1.5.0 incremental==16.10.1 +iniconfig==1.0.1 ipykernel==5.4.3 -ipython==7.16.1 -ipython-genutils==0.2.0 +ipython==7.13.0 +ipython_genutils==0.2.0 ipywidgets==7.6.3 +itsdangerous==1.1.0 +jdcal==1.0 jedi==0.17.2 -Jinja2==2.11.3 -jmespath==0.9.3 -json5==0.9.5 +jenkinsapi==0.3.11 +Jinja2==3.1.1 +json5==0.9.6 jsonschema==3.2.0 jupyter==1.0.0 -jupyter-client==6.1.11 -jupyter-console==6.2.0 -jupyter-core==4.7.1 -jupyter-server==1.4.1 +jupyter-client==7.2.2 +jupyter-console==6.4.3 +jupyter-core==4.9.2 +jupyter-server==1.16.0 jupyterlab==3.0.3 -jupyterlab-pygments==0.1.2 -jupyterlab-server==2.3.0 -jupyterlab-widgets==1.0.0 -keyring==10.6.0 -keyrings.alt==3.0 -language-selector==0.1 -lark-parser==0.7.2 -launchpadlib==1.10.6 -lazr.restfulclient==0.13.5 +jupyterlab-pygments==0.2.0 +jupyterlab-server==2.12.0 +jupyterlab-widgets==1.1.0 +keyring==18.0.1 +kiwisolver==1.0.1 +lark-parser==0.8.1 +launchpadlib==1.10.13 +lazr.restfulclient==0.14.2 lazr.uri==1.0.3 -louis==3.5.0 -lxml==4.2.1 -macaroonbakery==1.1.3 -Mako==1.0.7 -MarkupSafe==1.1.1 -matplotlib==2.1.1 +lxml==4.5.0 +lz4==3.0.2+dfsg +MarkupSafe==2.1.1 +matplotlib==3.1.2 mccabe==0.6.1 -meld==3.18.0 +meshcat==0.3.2 mistune==0.8.4 -nbclassic==0.2.6 -nbclient==0.5.3 -nbconvert==6.0.7 -nbformat==5.1.2 -nest-asyncio==1.5.1 +mock==3.0.5 +more-itertools==4.2.0 +mpi4py==3.0.3 +msgpack==0.6.2 +munch==2.3.2 +mypy-extensions==0.4.3 +nbclassic==0.3.7 +nbclient==0.5.13 +nbconvert==6.4.5 +nbformat==5.3.0 +nest-asyncio==1.5.5 netifaces==0.10.4 -networkx==1.11 -nine==1.0.0 nose==1.3.7 -nose2==0.7.4 +nose2==0.9.1 notebook==6.1.6 +notebook-shim==0.1.0 notify2==0.3 -numexpr==2.6.4 -numpy==1.13.3 -numpy-stl==2.3.2 -oauth==1.0.1 -olefile==0.45.1 -openshot-qt==2.4.1 -packaging==20.9 -PAM==0.4.2 -pandas==0.22.0 -pandocfilters==1.4.3 +nudged==0.3.1 +numexpr==2.7.1 +numpy==1.17.4 +oauthlib==3.1.0 +olefile==0.46 +openpyxl==3.0.3 +osrf-pycommon==1.0.0 +packaging==20.3 +pandas==0.25.3 +pandocfilters==1.4.2 +paramiko==2.6.0 parso==0.7.1 -patsy==0.4.1+dev -pexpect==4.8.0 +pathspec==0.9.0 +pbr==5.4.5 +pexpect==4.6.0 pickleshare==0.7.5 -Pillow==5.1.0 -pkg-resources==0.0.0 -pluggy==0.6.0 -prometheus-client==0.9.0 -prompt-toolkit==3.0.17 -protobuf==3.0.0 -psycopg2==2.7.4 +Pillow==7.0.0 +pkg_resources==0.0.0 +pkgconfig==1.5.1 +platformdirs==2.5.1 +pluggy==0.13.0 +prometheus-client==0.7.1 +prompt-toolkit==2.0.10 +psutil==5.5.1 ptyprocess==0.7.0 -py==1.5.2 +py==1.9.0 +py-ubjson==0.14.0 pyasn1==0.4.2 pyasn1-modules==0.2.1 -pyassimp==3.3 -pycairo==1.16.2 -pycodestyle==2.3.1 -pycparser==2.20 -pycrypto==2.6.1 -pycups==1.9.73 -pycurl==7.43.0.1 -pydocstyle==2.0.0 -pydot==1.2.3 -pyflakes==1.6.0 -Pygments==2.8.1 -pygobject==3.26.1 -pymacaroons==0.13.0 -PyNaCl==1.1.2 +pyassimp==4.1.4 +pybind11==2.4.3 +pycodestyle==2.5.0 +pycparser==2.21 +pycryptodomex==3.6.1 +pydantic==1.9.0 +pydocstyle==5.1.1 +pydot==1.4.1 +pyflakes==2.1.1 +pygame==1.9.6 +PyGithub==1.43.7 +Pygments==2.11.2 +PyGObject==3.36.0 +PyHamcrest==1.9.0 +pyinotify==0.9.6 +PyJWT==1.7.1 +PyNaCl==1.3.0 +pyngrok==5.1.0 PyOpenGL==3.1.0 -pyOpenSSL==17.5.0 -pyparsing==2.4.7 -pypng==0.0.18 -pyRFC3339==1.0 -pyrsistent==0.17.3 -pyserial==3.4 -pytest==3.3.2 -pytest-cov==2.5.1 -python-apt==1.6.5+ubuntu0.5 -python-dateutil==2.8.1 -python-debian==0.1.32 -python-gnupg==0.4.1 -python-utils==2.2.0 -pytz==2021.1 -PyWavelets==0.5.1 -pyxdg==0.25 -PyYAML==3.12 -pyzmq==22.0.3 -qtconsole==5.0.2 -QtPy==1.9.0 -reportlab==3.4.0 -requests==2.25.1 -requests-unixsocket==0.1.5 +pyOpenSSL==19.0.0 +pyparsing==2.4.6 +pypng==0.0.20 +pyproj==2.5.0 +PyQRCode==1.2.1 +PyQt5==5.14.1 +pyrsistent==0.15.5 +pytest==6.0.1 +pytest-cov==2.8.1 +pytest-repeat==0.8.0 +pytest-rerunfailures==9.1 +python-apt==2.0.0+ubuntu0.20.4.6 +python-dateutil==2.8.2 +python-debian===0.1.36ubuntu1 +python-engineio==4.0.0 +python-gitlab==2.0.1 +python-gnupg==0.4.5 +python-magic==0.4.16 +python-snappy==0.5.3 +python-socketio==5.0.4 +PyTrie==0.2 +pytz==2020.1 +pyxdg==0.26 +PyYAML==5.3.1 +pyzmq==22.3.0 +qtconsole==5.3.0 +QtPy==2.0.1 +requests==2.22.0 roman==2.0.0 +ros-buildfarm===3.0.1-master +rosdep==0.21.0 +rosdep-modules==0.21.0 +rosdistro==0.8.3 rosdistro-modules==0.8.3 -rospkg-modules==1.2.10 -rsa==3.4.2 -Rtree==0.8.3 -ruamel.yaml==0.15.34 -s3transfer==0.3.3 -scikit-image==0.13.1 -scipy==0.19.1 -scour==0.36 -screen-resolution-extra==0.0.0 -seaborn==0.8.0 +rosinstall-generator==0.1.22 +rospkg==1.3.0 +rospkg-modules==1.3.0 +Rtree==0.9.4 +scipy==1.3.3 SecretStorage==2.3.1 +semantic-version==2.8.2 Send2Trash==1.5.0 -service-identity==16.0.0 -simplegeneric==0.8.1 -simplejson==3.13.2 -six==1.15.0 +service-identity==18.1.0 +Shapely==1.7.0 +simplejson==3.16.0 +sip==4.19.21 +six==1.14.0 sniffio==1.2.0 -snowballstemmer==1.2.1 -Sphinx==1.6.7 -sphinx-rtd-theme==0.2.4 -ssh-import-id==5.7 -system-service==0.3 -systemd-python==234 -tables==3.4.2 -terminado==0.9.2 +snowballstemmer==2.0.0 +soupsieve==1.9.5 +Sphinx==4.3.0 +sphinx-copybutton==0.4.0 +sphinx-multiversion==0.2.4 +sphinx-rtd-theme==1.0.0 +sphinx-tabs==3.2.0 +sphinxcontrib-applehelp==1.0.2 +sphinxcontrib-devhelp==1.0.2 +sphinxcontrib-htmlhelp==2.0.0 +sphinxcontrib-jsmath==1.0.1 +sphinxcontrib-qthelp==1.0.3 +sphinxcontrib-serializinghtml==1.1.5 +starlette==0.16.0 +tables==3.6.1 +terminado==0.13.3 testpath==0.4.4 -toposort==1.5 +testresources==2.0.1 +texttable==1.6.2 +toml==0.10.1 +tomli==2.0.1 tornado==6.1 -traitlets==4.3.3 -Twisted==17.9.0 -typing-extensions==3.7.4.3 -u-msgpack-python==2.1 -ubuntu-drivers-common==0.0.0 -ufw==0.36 -unattended-upgrades==0.1 +traitlets==5.1.1 +Twisted==18.9.0 +txaio==2.10.0 +typing_extensions==4.0.1 +u-msgpack-python==2.7.1 +unidiff==0.5.5 uritemplate==0.6 -urllib3==1.26.3 -usb-creator==0.3.3 -vcstool==0.2.15 -virtualenv==15.1.0 -wadllib==1.3.2 -wcwidth==0.2.5 +urllib3==1.25.8 +uvicorn==0.16.0 +vcstool==0.2.14 +vcstools==0.1.42 +wadllib==1.3.3 +wcwidth==0.1.8 webencodings==0.5.1 +websocket-client==0.53.0 +Werkzeug==0.16.1 widgetsnbextension==3.5.1 -xkit==0.0.0 -zipp==3.4.1 -zope.interface==4.3.2 +wrapt==1.11.2 +wsaccel==0.6.2 +xlrd==1.1.0 +xlwt==1.3.0 +zipp==1.0.0 +zope.interface==4.7.1 diff --git a/drake_stuff/mbp_robot_arm_joint_limit_stuff/requirements.txt b/drake_stuff/mbp_robot_arm_joint_limit_stuff/requirements.txt index ca2a4291..b6656f90 100644 --- a/drake_stuff/mbp_robot_arm_joint_limit_stuff/requirements.txt +++ b/drake_stuff/mbp_robot_arm_joint_limit_stuff/requirements.txt @@ -1,4 +1,4 @@ -dataclasses == 0.8 +dataclasses # Following adapted from a portion of TRI Anzu code. # Jupyter, for interactive workflows. @@ -14,3 +14,4 @@ widgetsnbextension == 3.5.1 # TODO(eric, andres): Remove this once the following issue is resolved: # https://github.com/ipython/ipython/issues/12740 jedi == 0.17.2 +drake == 1.1.0 diff --git a/drake_stuff/mbp_robot_arm_joint_limit_stuff/ros_setup.bash b/drake_stuff/mbp_robot_arm_joint_limit_stuff/ros_setup.bash index 1d3d0bcd..3db62cdb 100755 --- a/drake_stuff/mbp_robot_arm_joint_limit_stuff/ros_setup.bash +++ b/drake_stuff/mbp_robot_arm_joint_limit_stuff/ros_setup.bash @@ -3,25 +3,25 @@ if [[ ${0} != ${BASH_SOURCE} ]]; then # Sourced in shell / script. # N.B.: Passing `-h` or `--help` in argv makes `setup.bash` choke. - source /opt/ros/melodic/setup.bash + source /opt/ros/noetic/setup.bash unset _is_executed else # Executed as binary. # Copied from minimal sourcing of `setup.bash`, but fixing all values, # and removing the reference(s) to /usr/local. export \ - CMAKE_PREFIX_PATH=/opt/ros/melodic \ - LD_LIBRARY_PATH=/opt/ros/melodic/lib \ - PATH=/opt/ros/melodic/bin:/usr/bin:/bin \ - PKG_CONFIG_PATH=/opt/ros/melodic/lib/pkgconfig \ - PYTHONPATH=/opt/ros/melodic/lib/python2.7/dist-packages \ + CMAKE_PREFIX_PATH=/opt/ros/noetic \ + LD_LIBRARY_PATH=/opt/ros/noetic/lib \ + PATH=/opt/ros/noetic/bin:/usr/bin:/bin \ + PKG_CONFIG_PATH=/opt/ros/noetic/lib/pkgconfig \ + PYTHONPATH=/opt/ros/noetic/lib/python3/dist-packages \ ROSLISP_PACKAGE_DIRECTORIES= \ - ROS_DISTRO=melodic \ - ROS_ETC_DIR=/opt/ros/melodic/etc/ros \ + ROS_DISTRO=noetic \ + ROS_ETC_DIR=/opt/ros/noetic/etc/ros \ ROS_MASTER_URI=http://localhost:11311 \ - ROS_PACKAGE_PATH=/opt/ros/melodic/share \ - ROS_PYTHON_VERSION=2 \ - ROS_ROOT=/opt/ros/melodic/share/ros \ + ROS_PACKAGE_PATH=/opt/ros/noetic/share \ + ROS_PYTHON_VERSION=3 \ + ROS_ROOT=/opt/ros/noetic/share/ros \ ROS_VERSION=1 exec "$@" fi diff --git a/drake_stuff/mbp_robot_arm_joint_limit_stuff/setup.sh b/drake_stuff/mbp_robot_arm_joint_limit_stuff/setup.sh old mode 100755 new mode 100644 index 5009c23b..948cade3 --- a/drake_stuff/mbp_robot_arm_joint_limit_stuff/setup.sh +++ b/drake_stuff/mbp_robot_arm_joint_limit_stuff/setup.sh @@ -1,14 +1,5 @@ #!/bin/bash -# Either source this, or use it as a prefix: -# -# source ./setup.sh -# ./my_program -# -# or -# -# ./setup.sh ./my_program - _cur_dir=$(cd $(dirname ${BASH_SOURCE}) && pwd) _venv_dir=${_cur_dir}/venv @@ -17,7 +8,7 @@ _download_drake() { ( # Download and echo path to stdout for capture. set -eux - base=drake-20210312-bionic.tar.gz + base=drake-20211111-focal.tar.gz dir=~/Downloads uri=https://drake-packages.csail.mit.edu/drake/nightly if [[ ! -f ${dir}/${base} ]]; then @@ -26,34 +17,6 @@ _download_drake() { ( echo ${dir}/${base} ) } -_provision_repos() { ( - set -eu - cd ${_cur_dir} - - repo_dir=${PWD}/repos - completion_token=2021-03-12.1 - completion_file=${repo_dir}/.completion-token - - if [[ -f ${completion_file} && "$(cat ${completion_file})" == "${completion_token}" ]]; then - return 0 - fi - - set -x - rm -rf ${repo_dir} - - mkdir ${repo_dir} && cd ${repo_dir} - - git clone https://github.com/ros-industrial/universal_robot - cd universal_robot/ - git checkout e8234318cc94 # From melodic-devel-staging - - # Er... dunno what to do about this, so hackzzz - cd ${_cur_dir} - ./ros_setup.bash ./render_ur_urdfs.py - - echo "${completion_token}" > ${completion_file} -) } - _setup_venv() { ( set -eu cd ${_cur_dir} @@ -68,25 +31,14 @@ _setup_venv() { ( rm -rf ${_venv_dir} mkdir -p ${_venv_dir} - tar -xzf $(_download_drake) -C ${_venv_dir} --strip-components=1 - - # See: https://drake.mit.edu/python_bindings.html#inside-virtualenv python3 -m venv ${_venv_dir} --system-site-packages cd ${_venv_dir} - ./bin/pip install -I pip wheel - ./bin/pip install -I -r ${_cur_dir}/requirements.txt + ./bin/pip install -U pip wheel + ./bin/pip install -r ${_cur_dir}/requirements.txt ./bin/pip freeze > ${_cur_dir}/requirements.freeze.txt echo "${completion_token}" > ${completion_file} ) } -_setup_venv && source ${_venv_dir}/bin/activate - -_provision_repos - -if [[ ${0} == ${BASH_SOURCE} ]]; then - # This was executed, *not* sourced. Run arguments directly. - set -eux - env - exec "$@" -fi +_setup_venv +source ${_venv_dir}/bin/activate diff --git a/drake_stuff/mbp_robot_arm_joint_limit_stuff/setup_transform_test.sh b/drake_stuff/mbp_robot_arm_joint_limit_stuff/setup_transform_test.sh new file mode 100755 index 00000000..93c8e525 --- /dev/null +++ b/drake_stuff/mbp_robot_arm_joint_limit_stuff/setup_transform_test.sh @@ -0,0 +1,16 @@ +#!/bin/bash + +if [[ $# -lt 1 || $# -gt 2 ]]; then + echo "Please provide path to model directory and model file name." + echo " Usage:" + echo " bash model_transform.sh " + echo " or to tranform the universal_robot provide a valid empty path:" + echo " bash model_transform.sh " + return 1 +fi + +source setup.sh + +bash format_model_and_generate_manifest.sh "$1" "$2" + +bash compare_model_via_drake_and_ingition_images.sh "$1" "$2" diff --git a/drake_stuff/mbp_robot_arm_joint_limit_stuff/test_models.py b/drake_stuff/mbp_robot_arm_joint_limit_stuff/test_models.py new file mode 100755 index 00000000..4e23962c --- /dev/null +++ b/drake_stuff/mbp_robot_arm_joint_limit_stuff/test_models.py @@ -0,0 +1,421 @@ +#!/usr/bin/env python3 + +import numpy as np +import sys +import os +import argparse +from PIL import Image +import shutil +from lxml import etree + +from pydrake.all import ( + FindResourceOrThrow, + Parser, + AddMultibodyPlantSceneGraph, + ConnectMeshcatVisualizer, + DiagramBuilder, + JacobianWrtVariable, + Simulator, +) +from pydrake.geometry.render import ( + ClippingRange, + DepthRange, + DepthRenderCamera, + RenderCameraCore, + RenderLabel, + MakeRenderEngineVtk, + RenderEngineVtkParams, +) +from pydrake.geometry import ( + DrakeVisualizer, + HalfSpace, + FrameId, + GeometrySet, + CollisionFilterDeclaration, +) +from pydrake.systems.sensors import ( + CameraInfo, + RgbdSensor, +) +from pydrake.math import RigidTransform, RollPitchYaw +import pydrake.multibody as mb +import multibody_extras as me + + +def xyz_rpy_deg(xyz, rpy_deg): + # Shorthand for defining a pose. + rpy_deg = np.asarray(rpy_deg) + return RigidTransform(RollPitchYaw(rpy_deg * np.pi / 180), xyz) + + +def make_parser(plant): + parser = Parser(plant) + parser.package_map().PopulateFromFolder("./repos/") + return parser + + +def create_camera(builder, world_id, X_WB, depth_camera, scene_graph): + sensor = RgbdSensor(world_id, X_PB=X_WB, depth_camera=depth_camera) + builder.AddSystem(sensor) + builder.Connect( + scene_graph.get_query_output_port(), sensor.query_object_input_port() + ) + return sensor + + +def infer_mask(image, bg_pixel=[255, 255, 255]): + image_array = np.array(image) + mask_bg1 = np.all(image_array == np.full(image_array.shape, bg_pixel), axis=2) + return ~mask_bg1 + + +def intersection_over_union(mask_a, mask_b): + intersection = np.logical_and(mask_a, mask_b).sum() + union = np.logical_or(mask_a, mask_b).sum() + print(intersection / union) + + +def generate_images_and_iou(simulator, sensor, temp_directory, poses_dir, num_image): + + context = simulator.get_context() + sensor_context = sensor.GetMyMutableContextFromRoot(context) + + color = sensor.color_image_output_port().Eval(sensor_context).data + image_drake = Image.fromarray(color, "RGBA") + + image_drake.save( + temp_directory + "/pics/" + poses_dir + "/" + str(num_image) + "_drake.png" + ) + with Image.open( + temp_directory + "/pics/" + poses_dir + "/" + str(num_image) + ".png" + ) as image_ignition: + mask_a = infer_mask(image_drake, image_drake.getpixel((0, 0))) + mask_b = infer_mask(image_ignition, image_ignition.getpixel((0, 0))) + intersection_over_union(mask_a, mask_b) + + +def remove_tag(tag, current): + for element in current.findall(tag): + current.remove(element) + for element in list(current): + remove_tag(tag, element) + + +def generate_sdf(model, poses_file, random, file_name): + sdf_text = f""" + + + + + ogre2 + 0, 1, 0 + + + + + + + {model} + + {poses_file} + {random} + + + + 2.2 0 0 0 0 -3.14 + + 0 0 0 0 0 0 + + + 1.047 + + 960 + 540 + + + 0.1 + 100 + + + 1 + 30 + true + camera + + + true + + +""" + with open(file_name, "w") as f: + f.write(sdf_text) + + +def perform_iou_testing(model_file, test_specific_temp_directory, pose_directory): + + random_poses = {} + # Read camera translation calculated and applied on gazebo + # we read the random positions file as it contains everything: + with open( + test_specific_temp_directory + "/pics/" + pose_directory + "/poses.txt", "r" + ) as datafile: + for line in datafile: + if line.startswith("Translation:"): + line_split = line.split(" ") + # we make the value negative since gazebo moved the robot + # and in drakewe move the camera + trans_x = float(line_split[1]) + trans_y = float(line_split[2]) + trans_z = float(line_split[3]) + elif line.startswith("Scaling:"): + line_split = line.split(" ") + scaling = float(line_split[1]) + else: + line_split = line.split(" ") + if line_split[1] == "nan": + random_poses[line_split[0][:-1]] = 0 + else: + random_poses[line_split[0][:-1]] = float(line_split[1]) + + builder = DiagramBuilder() + plant, scene_graph = AddMultibodyPlantSceneGraph(builder, 0.0) + + parser = Parser(plant) + model = make_parser(plant).AddModelFromFile(model_file) + + model_bodies = me.get_bodies(plant, {model}) + frame_W = plant.world_frame() + frame_B = model_bodies[0].body_frame() + if len(plant.GetBodiesWeldedTo(plant.world_body())) < 2: + plant.WeldFrames( + frame_W, frame_B, X_PC=plant.GetDefaultFreeBodyPose(frame_B.body()) + ) + + # Creating cameras: + renderer_name = "renderer" + scene_graph.AddRenderer(renderer_name, MakeRenderEngineVtk(RenderEngineVtkParams())) + + # N.B. These properties are chosen arbitrarily. + depth_camera = DepthRenderCamera( + RenderCameraCore( + renderer_name, + CameraInfo( + width=960, + height=540, + focal_x=831.382036787, + focal_y=831.382036787, + center_x=480, + center_y=270, + ), + ClippingRange(0.01, 10.0), + RigidTransform(), + ), + DepthRange(0.01, 10.0), + ) + + world_id = plant.GetBodyFrameIdOrThrow(plant.world_body().index()) + + # Creating perspective cam + X_WB = xyz_rpy_deg( + [1.6 / scaling + trans_x, -1.6 / scaling + trans_y, 1.2 / scaling + trans_z], + [-120, 0, 45], + ) + sensor_perspective = create_camera( + builder, world_id, X_WB, depth_camera, scene_graph + ) + # Creating top cam + X_WB = xyz_rpy_deg( + [0 + trans_x, 0 + trans_y, 2.2 / scaling + trans_z], [-180, 0, -90] + ) + sensor_top = create_camera(builder, world_id, X_WB, depth_camera, scene_graph) + # Creating front cam + X_WB = xyz_rpy_deg( + [2.2 / scaling + trans_x, 0 + trans_y, 0 + trans_z], [-90, 0, 90] + ) + sensor_front = create_camera(builder, world_id, X_WB, depth_camera, scene_graph) + # Creating side cam + X_WB = xyz_rpy_deg( + [0 + trans_x, 2.2 / scaling + trans_y, 0 + trans_z], [-90, 0, 180] + ) + sensor_side = create_camera(builder, world_id, X_WB, depth_camera, scene_graph) + # Creating back cam + X_WB = xyz_rpy_deg( + [-2.2 / scaling + trans_x, 0 + trans_y, 0 + trans_z], [-90, 0, -90] + ) + sensor_back = create_camera(builder, world_id, X_WB, depth_camera, scene_graph) + + DrakeVisualizer.AddToBuilder(builder, scene_graph) + + # Remove gravity to avoid extra movements of the model when running the simulation + plant.gravity_field().set_gravity_vector(np.array([0, 0, 0], dtype=np.float64)) + + # Switch off collisions to avoid problems with random positions + collision_filter_manager = scene_graph.collision_filter_manager() + model_inspector = scene_graph.model_inspector() + geometry_ids = GeometrySet(model_inspector.GetAllGeometryIds()) + collision_filter_manager.Apply( + CollisionFilterDeclaration().ExcludeWithin(geometry_ids) + ) + + plant.Finalize() + diagram = builder.Build() + + simulator = Simulator(diagram) + simulator.Initialize() + + dofs = plant.num_actuated_dofs() + if dofs != plant.num_positions(): + raise ValueError( + "Error on converted model: Num positions is not equal to num actuated dofs." + ) + + if pose_directory == "random_pose": + joint_positions = [0] * dofs + for joint_name, pose in random_poses.items(): + # check if NaN + if pose != pose: + pose = 0 + # drake will add '_joint' when there's a name collision + if plant.HasJointNamed(joint_name): + joint = plant.GetJointByName(joint_name) + else: + joint = plant.GetJointByName(joint_name + "_joint") + joint_positions[joint.position_start()] = pose + sim_plant_context = plant.GetMyContextFromRoot(simulator.get_mutable_context()) + plant.get_actuation_input_port(model).FixValue( + sim_plant_context, np.zeros((dofs, 1)) + ) + plant.SetPositions(sim_plant_context, model, joint_positions) + + simulator.AdvanceTo(1) + + generate_images_and_iou( + simulator, sensor_perspective, test_specific_temp_directory, pose_directory, 1 + ) + generate_images_and_iou( + simulator, sensor_top, test_specific_temp_directory, pose_directory, 2 + ) + generate_images_and_iou( + simulator, sensor_front, test_specific_temp_directory, pose_directory, 3 + ) + generate_images_and_iou( + simulator, sensor_side, test_specific_temp_directory, pose_directory, 4 + ) + generate_images_and_iou( + simulator, sensor_back, test_specific_temp_directory, pose_directory, 5 + ) + + +def setup_temporal_model_description_file( + model_directory, description_file, temp_directory, mesh_type +): + # Setup model temporal files + temp_test_model_path = temp_directory + "/" + mesh_type + "/model/" + model_file_path = temp_test_model_path + "/" + description_file + shutil.copytree(model_directory, temp_test_model_path) + root = etree.parse(model_file_path) + model_name = root.find("model").attrib["name"] + for uri in root.findall(".//uri"): + uri.text = uri.text.replace("model://" + model_name + "/", "") + + if mesh_type == "collision": + # Create ignore namespace so lxml don't complain + # os.system("sed -i 's/visual/ignore:collision/g' " + model_file_path) + my_namespaces = {"ignore": "http://ignore"} + namespace = etree.Element("namespace", nsmap=my_namespaces) + namespace.append(root.getroot()) + collision_tags = root.findall(".//collision") + visual_tags = root.findall(".//visual") + for collision_tag in collision_tags: + collision_tag.tag = "visual" + for visual_tag in visual_tags: + visual_tag.tag = "{%s}visual" % my_namespaces["ignore"] + + data = etree.tostring(root, pretty_print=True).decode("utf-8") + text_file = open(model_file_path, "w") + text_file.write(data) + text_file.close() + + return model_file_path + + +def run_test( + model_file_path, + temp_directory, + mesh_type, + type_joint_positions, + poses_filename="poses.txt", +): + # Setup temporal pics and metadata directory + temp_default_pics_path = ( + temp_directory + "/" + mesh_type + "/pics/" + type_joint_positions + "/" + ) + os.makedirs(temp_default_pics_path) + os.chdir(temp_default_pics_path) + plugin_config_path = temp_default_pics_path + "plugin_config.sdf" + if type_joint_positions == "default_pose": + generate_sdf( + model_file_path, + temp_default_pics_path + poses_filename, + "false", + plugin_config_path, + ) + else: + generate_sdf( + model_file_path, + temp_default_pics_path + poses_filename, + "true", + plugin_config_path, + ) + + os.system("ign gazebo -s -r " + plugin_config_path + " --iterations 50") + perform_iou_testing( + model_file_path, temp_directory + "/" + mesh_type, type_joint_positions + ) + + +def main(original_model_directory, description_file, temp_directory): + + mesh_type = "visual" + tmp_model_file_path = setup_temporal_model_description_file( + original_model_directory, description_file, temp_directory, mesh_type + ) + run_test(tmp_model_file_path, temp_directory, mesh_type, "default_pose") + run_test(tmp_model_file_path, temp_directory, mesh_type, "random_pose") + + mesh_type = "collision" + tmp_model_file_path = setup_temporal_model_description_file( + original_model_directory, description_file, temp_directory, mesh_type + ) + run_test(tmp_model_file_path, temp_directory, mesh_type, "default_pose") + run_test(tmp_model_file_path, temp_directory, mesh_type, "random_pose") + + +if __name__ == "__main__": + try: + parser = argparse.ArgumentParser() + parser.add_argument( + "model_directory", help="Directory location of the model files" + ) + parser.add_argument("description_file", help="Model description file name") + parser.add_argument( + "temp_directory", + help="Temporal directory file where temporal objects will be written", + ) + args = parser.parse_args() + main(args.model_directory, args.description_file, args.temp_directory) + print() + print("[ Done ]") + except UserError as e: + eprint(e) + sys.exit(1)