eval_2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_coverage = 'tme_data/sets/v2_maze/coverage/2'\n",
    "os.chdir(path_coverage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_text_file(file_path):\n",
    "    with open(file_path, 'r') as f:\n",
    "        return f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def neg_size_check(matrix, size):\n",
    "    \"\"\"\n",
    "    Check if matrix == size and return False if that is the case\n",
    "    \"\"\"\n",
    "    result = True\n",
    "    if(matrix.shape[0] == size):\n",
    "        result = False\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def matrix_build(matrix, limit):\n",
    "    \"\"\"\n",
    "    Stretch matrix to size: limit\n",
    "    \"\"\"\n",
    "    result = matrix\n",
    "    if (neg_size_check(matrix, limit)):\n",
    "        number = limit-matrix.shape[0]\n",
    "        if number < 0:\n",
    "            result = matrix[:limit]\n",
    "        else:\n",
    "            temp_2 = np.full(number, matrix[-1])\n",
    "            result = np.insert(result, -1, temp_2)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def min_mean_max_std_extraction(matrix):\n",
    "    \"\"\"\n",
    "    Extract min_mean_max from matrix with return [min, mean, max]\n",
    "    \"\"\"\n",
    "    result = np.empty(4)\n",
    "    result[0] = np.min(matrix)\n",
    "    result[1] = np.mean(matrix)\n",
    "    result[2] = np.max(matrix)\n",
    "    result[3] = np.std(matrix)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def min_median_max_extraction(matrix):\n",
    "    \"\"\"\n",
    "    Extract min_median_max from matrix with return [min, median, max]\n",
    "    \"\"\"\n",
    "    result = np.empty(3)\n",
    "    result[0] = np.min(matrix)\n",
    "    result[1] = np.median(matrix)\n",
    "    result[2] = np.max(matrix)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def matrix_splice(matrix, length):\n",
    "    \"\"\"\n",
    "    Return matrices spliced together with length being the number of robots for experiment to be evaluated\n",
    "    \"\"\"\n",
    "    result_distance = matrix[:, 0]\n",
    "    result_count = matrix[:, 0]\n",
    "    result_distance_sum = matrix[:, 0]\n",
    "    result_count_sum = matrix[:, 0]\n",
    "\n",
    "    temp = matrix[:, 1:]\n",
    "    loop = temp.shape[1]\n",
    "    loop = loop/length\n",
    "    loop = int(loop)\n",
    "\n",
    "    for i in range(loop):\n",
    "        num_1 = length\n",
    "        num_2 = length*2\n",
    "        temp_distance = temp[:, 0:num_1]\n",
    "        temp_count = temp[:, num_1:num_2]\n",
    "        temp_distance_sum = np.sum(temp_distance, axis=1)\n",
    "        temp_count_sum = np.sum(temp_count, axis=1)\n",
    "        result_distance=np.c_[result_distance, temp_distance]\n",
    "        result_count=np.c_[result_count, temp_count]\n",
    "        result_distance_sum = np.c_[result_distance_sum, temp_distance_sum]\n",
    "        result_count_sum = np.c_[result_count_sum, temp_count_sum]\n",
    "        temp = temp[:, num_2:]\n",
    "        \n",
    "    return result_distance, result_count, result_distance_sum, result_count_sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def matrix_builder(matrix, distance_matrix, limit, map_name):\n",
    "    \"\"\"\n",
    "    Returns coverage, travel distance and index of time if the requirements are met in terms of travel_distance and minimum coverage by robot\n",
    "    \"\"\"\n",
    "    temp = []\n",
    "    for i in range(limit):\n",
    "        temp.append(i*5)\n",
    "    temp = np.array(temp)\n",
    "    result = copy.deepcopy(temp)\n",
    "    result_2 = np.array(temp)\n",
    "    result_2 = copy.deepcopy(temp)\n",
    "    index_array = []\n",
    "    for i in range(len(matrix)):\n",
    "        temp = matrix[i][:, 1]\n",
    "        temp = matrix_build(temp, limit)\n",
    "        if(i < distance_matrix.shape[0]):\n",
    "            temp_2 = distance_matrix[i][:,1:]\n",
    "            temp_2 = eighty_build_distance(temp_2, limit)\n",
    "            if (temp[-1] > 0.88 and np.all(temp_2[-1] > 10)):\n",
    "                test_passed = False\n",
    "                start_value = -1\n",
    "                index = 0\n",
    "                count = 0\n",
    "                for j in range(limit - 1):\n",
    "                    if map_name == 'marty':\n",
    "                        if (temp[j+1] > 0.88 and index == 0):\n",
    "                            index = j+1\n",
    "                    else:\n",
    "                        if (temp[j+1] > 0.88 and index == 0):\n",
    "                            index = j+1\n",
    "                    for x in range(len(temp_2[0])):\n",
    "                        if (np.abs(temp_2[j][x] - temp_2[j+1][x]) > 5):\n",
    "                            test_passed = True\n",
    "                if(not test_passed and index != 0):\n",
    "                    result = np.c_[result, temp]\n",
    "                    result_2 = np.c_[result_2, temp_2]\n",
    "                    index_array.append(index)\n",
    "    index_array = np.array(index_array)\n",
    "    return result, result_2, index_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eighty_build_distance(matrix, limit):\n",
    "    \"\"\"\n",
    "    Return distance matrix sized to limit by appending last value until limit is reached\n",
    "    \"\"\"\n",
    "    result = matrix\n",
    "    if (neg_size_check(matrix, limit)):\n",
    "        number = limit-matrix.shape[0]\n",
    "        if number < 0:\n",
    "            result = matrix[:limit]\n",
    "            number = 0\n",
    "        #temp_2 = np.full((number, 4), matrix[-1][:])\n",
    "        #temp_2 = np.repeat(matrix[-1], number, axis=0)\n",
    "        temp_2 = np.tile(matrix[-1], (number, 1))\n",
    "        result = np.append(result, temp_2)\n",
    "        result = result.reshape((limit, -1))\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_from_file(eval_method):\n",
    "    result = []\n",
    "    output = 0\n",
    "    \n",
    "    for file in sorted(os.listdir()):\n",
    "        if file.endswith('.txt'):\n",
    "            file_path =  f\"{file}\"\n",
    "            if(eval_method in file_path):\n",
    "                check = np.loadtxt(file_path)\n",
    "                if check.any() and check.ndim == 2:\n",
    "                    output += 1\n",
    "                    #print(file)\n",
    "                    #print(check.shape)\n",
    "                    result.append(check)\n",
    "    result = np.asarray(result)\n",
    "    #if result.ndim > 1:\n",
    "    #    print(result)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extraction(map_name, robot_num, eval_methods, limit=100, eval_lower=0, eval_upper=-1):\n",
    "    try: \n",
    "        os.chdir(f'../../{map_name}/coverage/{robot_num}')\n",
    "    except:\n",
    "        os.chdir(f'../../../{map_name}/coverage/{robot_num}')\n",
    "\n",
    "    matrix_coverage = []\n",
    "    len_eval = len(eval_methods)\n",
    "\n",
    "    for i in range(len_eval):\n",
    "        testing = extract_from_file(eval_methods[i])\n",
    "        matrix_coverage.append(testing)\n",
    "\n",
    "    matrix_coverage = np.array(matrix_coverage)\n",
    "\n",
    "    os.chdir(f'../../../{map_name}/distances/{robot_num}')\n",
    "\n",
    "    matrix_distance = []\n",
    "    for i in range(len_eval):\n",
    "        matrix_distance.append(extract_from_file(eval_methods[i]))\n",
    "\n",
    "    matrix_distance = np.array(matrix_distance)\n",
    "        \n",
    "    c_mean = np.empty((len_eval, limit))\n",
    "    time = np.empty((len_eval, 4))\n",
    "    c_sum = []\n",
    "    d_sum = []\n",
    "\n",
    "    for i in range(len(eval_methods)):\n",
    "        print(f'robot:{robot_num} with {eval_methods[i]} on {map_name}')\n",
    "        nearest_c_plot, nearest_d_plot, nearest_time_taken = matrix_builder(matrix_coverage[i], matrix_distance[i], 100, map_name)\n",
    "\n",
    "        time_values_nearest = min_mean_max_std_extraction(nearest_time_taken[eval_lower:eval_upper])\n",
    "    \n",
    "        nearest_mean = np.mean(nearest_c_plot[:, eval_lower:eval_upper], axis=1)\n",
    "        \n",
    "        nearest_d, nearest_c, nearest_c_sum, nearest_d_sum = matrix_splice(nearest_d_plot, robot_num)\n",
    "\n",
    "        nearest_c_sum_mean = np.mean(nearest_c_sum[:, 1:-1], axis=1)\n",
    "        \n",
    "        nearest_d_sum_mean = np.mean(nearest_d_sum[:, 1:-1], axis=1)\n",
    "        \n",
    "        c_mean[i] = nearest_mean\n",
    "        time[i] = time_values_nearest\n",
    "        c_sum.append(nearest_c_sum_mean)\n",
    "        d_sum.append(nearest_d_sum_mean)\n",
    "\n",
    "    c_sum = np.array(c_sum)\n",
    "    d_sum = np.array(d_sum)\n",
    "\n",
    "    return c_mean, time, c_sum, d_sum\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "evals = ['nearest', 'minPos', 'nextFrontier', 'coExplore', 'co122']  # ['nearest', 'minPos', 'nextFrontier', 'coExplore', 'co122']\n",
    "eval_length = len(evals)\n",
    "\n",
    "map_2_a, map_2_b, map_2_c, map_2_d = extraction('map_3', 2, evals)\n",
    "map_3_a, map_3_b, map_3_c, map_3_d = extraction('map_3', 3, evals)\n",
    "map_4_a, map_4_b, map_4_c, map_4_d = extraction('map_3', 4, evals)\n",
    "map_5_a, map_5_b, map_5_c, map_5_d = extraction('map_3', 5, evals)\n",
    "\n",
    "maze_2_a, maze_2_b, maze_2_c, maze_2_d = extraction('v2_maze', 2, evals)\n",
    "maze_3_a, maze_3_b, maze_3_c, maze_3_d = extraction('v2_maze', 3, evals)\n",
    "maze_4_a, maze_4_b, maze_4_c, maze_4_d = extraction('v2_maze', 4, evals)\n",
    "maze_5_a, maze_5_b, maze_5_c, maze_5_d = extraction('v2_maze', 5, evals)\n",
    "\n",
    "marty_2_a, marty_2_b, marty_2_c, marty_2_d = extraction('marty', 2, evals)\n",
    "marty_3_a, marty_3_b, marty_3_c, marty_3_d = extraction('marty', 3, evals)\n",
    "marty_4_a, marty_4_b, marty_4_c, marty_4_d = extraction('marty', 4, evals)\n",
    "marty_5_a, marty_5_b, marty_5_c, marty_5_d = extraction('marty', 5, evals) \n",
    "save = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir('../../../../..')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "map = np.empty((4, eval_length))\n",
    "xdata = [2,3,4,5]\n",
    "map[0] = map_2_b[:, 1]\n",
    "map[1] = map_3_b[:, 1]\n",
    "map[2] = map_4_b[:, 1]\n",
    "map[3] = map_5_b[:, 1]\n",
    "map = map * 5\n",
    "fig = plt.figure()\n",
    "plt.plot(xdata, map[:,0], label='nearest')\n",
    "plt.plot(xdata, map[:,1], label='minPos')\n",
    "plt.plot(xdata, map[:,2], label='nextFrontier')\n",
    "plt.plot(xdata, map[:,3], label='coExplore')\n",
    "plt.plot(xdata, map[:,4], label='co122')\n",
    "plt.xlabel('Number of robots for experiment')\n",
    "plt.ylabel('Mean exploration time in seconds')\n",
    "plt.xticks(xdata)\n",
    "plt.legend()\n",
    "#plt.savefig(\"map_3_results.svg\", transparent=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maze = np.empty((4, eval_length))\n",
    "maze[0] = maze_2_b[:, 1]\n",
    "maze[1] = maze_3_b[:, 1]\n",
    "maze[2] = maze_4_b[:, 1]\n",
    "maze[3] = maze_5_b[:, 1]\n",
    "maze = maze * 5\n",
    "plt.plot(xdata, maze[:,0], label='nearest')\n",
    "plt.plot(xdata, maze[:,1], label='minPos')\n",
    "plt.plot(xdata, maze[:,2], label='nextFrontier')\n",
    "plt.plot(xdata, maze[:,3], label='coExplore')\n",
    "plt.plot(xdata, maze[:,4], label='co122')\n",
    "plt.xticks(xdata)\n",
    "plt.xlabel('Number of robots for experiment')\n",
    "plt.ylabel('Mean exploration time in seconds')\n",
    "plt.legend()\n",
    "#plt.savefig(\"maze_results.svg\", transparent=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "marty = np.empty((4, eval_length))\n",
    "marty[0] = marty_2_b[:, 1]\n",
    "marty[1] = marty_3_b[:, 1]\n",
    "marty[2] = marty_4_b[:, 1]\n",
    "marty[3] = marty_5_b[:, 1]\n",
    "marty = marty * 5\n",
    "plt.plot(xdata, marty[:,0], label='nearest')\n",
    "plt.plot(xdata, marty[:,1], label='minPos')\n",
    "plt.plot(xdata, marty[:,2], label='nextFrontier')\n",
    "plt.plot(xdata, marty[:,3], label='coExplore')\n",
    "plt.plot(xdata, marty[:,4], label='co122')\n",
    "plt.xlabel('Number of robots for experiment')\n",
    "plt.ylabel('Mean exploration time in seconds')\n",
    "plt.xticks(xdata)\n",
    "plt.legend()\n",
    "#plt.savefig('marty_results.svg', transparent=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "marty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maze"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dist = np.loadtxt('tme_data/distances/5/v2_maze_coExplore_2022-03-04|07:33:48.txt')\n",
    "cov = np.loadtxt('tme_data/coverage/measurements/5/v2_maze_coExplore_2022-03-04-07:33:48.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xdata = cov[:, 0]\n",
    "print(xdata)\n",
    "fig = plt.figure()\n",
    "plt.plot(xdata, cov[:,1])\n",
    "plt.ylabel('Exploration in %')\n",
    "plt.xlabel('Exploration time in seconds')\n",
    "plt.xticks(xdata[::2])\n",
    "if save:\n",
    "    plt.savefig(\"maze_video.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xdata = cov[:, 0]\n",
    "print(xdata)\n",
    "fig = plt.figure()\n",
    "plt.plot(xdata, cov[:,1], 'w')\n",
    "plt.ylabel('Exploration in %')\n",
    "plt.xlabel('Exploration time in seconds')\n",
    "plt.xticks(xdata[::2])\n",
    "if save:\n",
    "    plt.savefig(\"maze_empty.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dist_sum = np.sum(dist[:, 1:], axis=1)\n",
    "dist_sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xdata = dist[:, 0]\n",
    "fig = plt.figure()\n",
    "plt.plot(xdata, dist_sum)\n",
    "plt.ylabel('Exploration distance in meters')\n",
    "plt.xlabel('Exploration time in seconds')\n",
    "plt.xticks(xdata[::2])\n",
    "if save:\n",
    "    plt.savefig(\"maze_video_dist.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xdata = dist[:, 0]\n",
    "fig = plt.figure()\n",
    "plt.plot(xdata, dist_sum, 'w')\n",
    "plt.ylabel('Exploration distance in meters')\n",
    "plt.xlabel('Exploration time in seconds')\n",
    "plt.xticks(xdata[::2])\n",
    "if save:\n",
    "    plt.savefig(\"maze_video_dist_empty.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xdata = [2,3,4,5]\n",
    "maze = np.empty((4, eval_length))\n",
    "maze[0] = maze_2_b[:, 1]\n",
    "maze[1] = maze_3_b[:, 1]\n",
    "maze[2] = maze_4_b[:, 1]\n",
    "maze[3] = maze_5_b[:, 1]\n",
    "maze2 = np.empty((4, eval_length))\n",
    "maze2[0] = maze_2_b[:, 3]\n",
    "maze2[1] = maze_3_b[:, 3]\n",
    "maze2[2] = maze_4_b[:, 3]\n",
    "maze2[3] = maze_5_b[:, 3]\n",
    "maze = maze * 5\n",
    "plt.errorbar(np.array(xdata)+0.2, maze[:,0], maze2[:,0], label='nearest', ls='None', marker='o')\n",
    "plt.errorbar(np.array(xdata)+0.1, maze[:,1], maze2[:,1], label='minPos', ls='None', marker='o')\n",
    "plt.errorbar(np.array(xdata), maze[:,2], maze2[:,2], label='nextFrontier', ls='None', marker='o')\n",
    "plt.errorbar(np.array(xdata)-0.1, maze[:,3], maze2[:,3], label='coExplore', ls='None', marker='o')\n",
    "plt.errorbar(np.array(xdata)-0.2, maze[:,4], maze2[:,4], label='co122', ls='None', marker='o')\n",
    "plt.xticks(xdata)\n",
    "plt.xlabel('Number of robots for experiment')\n",
    "plt.ylabel('Mean exploration time in seconds')\n",
    "plt.legend()\n",
    "plt.axvline(x=2.5, color='black', linewidth=1)\n",
    "plt.axvline(x=3.5, color='black', linewidth=1)\n",
    "plt.axvline(x=4.5, color='black', linewidth=1)\n",
    "if save:\n",
    "    plt.savefig(\"maze_results.svg\", transparent=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xdata = [2,3,4,5]\n",
    "marty = np.empty((4, eval_length))\n",
    "marty[0] = marty_2_b[:, 1]\n",
    "marty[1] = marty_3_b[:, 1]\n",
    "marty[2] = marty_4_b[:, 1]\n",
    "marty[3] = marty_5_b[:, 1]\n",
    "marty2 = np.empty((4, eval_length))\n",
    "marty2[0] = marty_2_b[:, 3]\n",
    "marty2[1] = marty_3_b[:, 3]\n",
    "marty2[2] = marty_4_b[:, 3]\n",
    "marty2[3] = marty_5_b[:, 3]\n",
    "marty = marty * 5\n",
    "plt.errorbar(np.array(xdata)+0.2, marty[:,0], marty2[:,0], label='nearest')\n",
    "plt.errorbar(np.array(xdata)+0.1, marty[:,1], marty2[:,1], label='minPos')\n",
    "plt.errorbar(np.array(xdata), marty[:,2], marty2[:,2], label='nextFrontier')\n",
    "plt.errorbar(np.array(xdata)-0.1, marty[:,3], marty2[:,3], label='coExplore')\n",
    "plt.errorbar(np.array(xdata)-0.2, marty[:,4], marty2[:,4], label='co122')\n",
    "plt.xticks(xdata)\n",
    "plt.xlabel('Number of robots for experiment')\n",
    "plt.ylabel('Mean exploration time in seconds')\n",
    "plt.legend()\n",
    "plt.fill_between(np.array(xdata)+0.2, marty[:,0]+marty2[:,0], marty[:,0]-marty2[:,0], alpha=0.25)\n",
    "plt.fill_between(np.array(xdata)+0.1, marty[:,1]+marty2[:,1], marty[:,1]-marty2[:,1], alpha=0.25)\n",
    "plt.fill_between(np.array(xdata), marty[:,2]+marty2[:,2], marty[:,2]-marty2[:,2], alpha=0.25)\n",
    "plt.fill_between(np.array(xdata)-0.1, marty[:,3]+marty2[:,3], marty[:,3]-marty2[:,3], alpha=0.25)\n",
    "plt.fill_between(np.array(xdata)-0.2, marty[:,4]+marty2[:,4], marty[:,4]-marty2[:,4], alpha=0.25)\n",
    "if save:\n",
    "    plt.savefig(\"marty_results.svg\", transparent=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xdata = [2,3,4,5]\n",
    "marty = np.empty((4, eval_length))\n",
    "marty[0] = marty_2_b[:, 1]\n",
    "marty[1] = marty_3_b[:, 1]\n",
    "marty[2] = marty_4_b[:, 1]\n",
    "marty[3] = marty_5_b[:, 1]\n",
    "marty2 = np.empty((4, eval_length))\n",
    "marty2[0] = marty_2_b[:, 3]\n",
    "marty2[1] = marty_3_b[:, 3]\n",
    "marty2[2] = marty_4_b[:, 3]\n",
    "marty2[3] = marty_5_b[:, 3]\n",
    "marty = marty * 5\n",
    "plt.errorbar(np.array(xdata)-0.2, marty[:,0], marty2[:,0], label='nearest', ls='None', marker='o')\n",
    "plt.errorbar(np.array(xdata)-0.1, marty[:,1], marty2[:,1], label='minPos', ls='None', marker='o')\n",
    "plt.errorbar(np.array(xdata), marty[:,2], marty2[:,2], label='nextFrontier', ls='None', marker='o')\n",
    "plt.errorbar(np.array(xdata)+0.1, marty[:,3], marty2[:,3], label='coExplore', ls='None', marker='o')\n",
    "plt.errorbar(np.array(xdata)+0.2, marty[:,4], marty2[:,4], label='co122', ls='None', marker='o')\n",
    "plt.xticks(xdata)\n",
    "plt.xlabel('Number of robots for experiment')\n",
    "plt.ylabel('Mean exploration time in seconds')\n",
    "plt.legend()\n",
    "plt.axvline(x=2.5, color='black', linewidth=1)\n",
    "plt.axvline(x=3.5, color='black', linewidth=1)\n",
    "plt.axvline(x=4.5, color='black', linewidth=1)\n",
    "if save:\n",
    "    plt.savefig(\"marty_results.svg\", transparent=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xdata = [2,3,4,5]\n",
    "map = np.empty((4, eval_length))\n",
    "map[0] = map_2_b[:, 1]\n",
    "map[1] = map_3_b[:, 1]\n",
    "map[2] = map_4_b[:, 1]\n",
    "map[3] = map_5_b[:, 1]\n",
    "map2 = np.empty((4, eval_length))\n",
    "map2[0] = map_2_b[:, 3]\n",
    "map2[1] = map_3_b[:, 3]\n",
    "map2[2] = map_4_b[:, 3]\n",
    "map2[3] = map_5_b[:, 3]\n",
    "map = map * 5\n",
    "plt.errorbar(np.array(xdata)+0.2, map[:,0], map2[:,0], label='nearest', ls='None', marker='o')\n",
    "plt.errorbar(np.array(xdata)+0.1, map[:,1], map2[:,1], label='minPos', ls='None', marker='o')\n",
    "plt.errorbar(np.array(xdata), map[:,2], map2[:,2], label='nextFrontier', ls='None', marker='o')\n",
    "plt.errorbar(np.array(xdata)-0.1, map[:,3], map2[:,3], label='coExplore', ls='None', marker='o')\n",
    "plt.errorbar(np.array(xdata)-0.2, map[:,4], map2[:,4], label='co122', ls='None', marker='o')\n",
    "plt.xticks(xdata)\n",
    "plt.xlabel('Number of robots for experiment')\n",
    "plt.ylabel('Mean exploration time in seconds')\n",
    "plt.legend()\n",
    "plt.axvline(x=2.5, color='black', linewidth=1)\n",
    "plt.axvline(x=3.5, color='black', linewidth=1)\n",
    "plt.axvline(x=4.5, color='black', linewidth=1)\n",
    "if save:\n",
    "    plt.savefig(\"map_results.svg\", transparent=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.13 ('tme')",
   "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.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "3501abf558e85a96693b4fd2db39b3fc2c67c2cbd3ebb5388c5e3bcef9914af6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}