frontier.ipynb

{
 "cells": [
  {
   "cell_type": "code",
<<<<<<< HEAD
   "execution_count": 6,
=======
   "execution_count": 3,
>>>>>>> 8f7471d28040d8374eac59aa5b4b4ab9828e3306
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import skimage.io as skio\n",
    "import skimage as sk\n",
    "import skimage.transform as transform\n",
    "from skimage.measure import find_contours\n",
    "import numpy as np\n",
    "ros_path = '/opt/ros/kinetic/lib/python2.7/dist-packages'\n",
    "if ros_path in sys.path:\n",
    "    sys.path.remove(ros_path)\n",
    "import cv2\n",
    "sys.path.append('/opt/ros/kinetic/lib/python2.7/dist-packages')\n",
<<<<<<< HEAD
    "import matplotlib.pyplot as plt\n",
    "from lib.frontier import *\n",
    "from lib.pathplanner import lee_planning_path\n",
    "from lib.frontier import frontier_cluster\n",
    "from lib.pathplanner import find_waypoints\n",
    "\n",
=======
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1080x1080 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a = skio.imread(\"a.jpg\")\n",
    "a = a[::-1]\n",
    "size = a.shape\n",
    "plt.figure(figsize = (15,15))\n",
    "a = sk.measure.block_reduce(a, (2,2), np.min)\n",
    "a = transform.resize(a, size, preserve_range=True)\n",
    "# skio.imshow(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1080x1080 with 0 Axes>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1080x1080 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def obstacle_map(gridmap):\n",
    "    copy = np.copy(gridmap)\n",
    "    copy[copy == 127] = 255\n",
    "    return copy < 105\n",
    "\n",
    "def obstacle_indeices(obstacle_map):\n",
    "    return np.nonzero(obstacle_map)\n",
    "\n",
    "def show_obstacle(gridmap):\n",
    "    black = np.zeros(gridmap.shape)\n",
    "    black[obstacle_map(gridmap)] = 255\n",
    "    return black\n",
    "plt.figure(figsize = (15,15))\n",
    "# skio.imshow(obstacle_map(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# np.unique(a.reshape((40000, 1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1080x1080 with 0 Axes>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1080x1080 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def grow_obstacle(gridmap):\n",
    "    ob_map = obstacle_map(gridmap)\n",
    "    copy = np.copy(gridmap)\n",
    "    mask = np.copy(ob_map)\n",
    "    step = 5\n",
    "    for dx in range(-step, step+1):\n",
    "        for dy in range(-step, step+1):\n",
    "            roll = np.roll(np.roll(ob_map, dx, axis = 0), dy, axis = 1)\n",
    "            mask = np.logical_or(roll, mask)\n",
    "    copy[mask] = 0\n",
    "            \n",
    "    return copy\n",
    "plt.figure(figsize=(15,15))\n",
    "# skio.imshow(grow_obstacle(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1080x1080 with 0 Axes>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1080x1080 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def frontier(gridmap):\n",
    "    growed = grow_obstacle(gridmap)\n",
    "    gray = growed == 127\n",
    "    black = growed ==0\n",
    "    white = np.logical_not(np.logical_or(gray, black))\n",
    "    level_map = white*255+gray*127\n",
    "    canny = cv2.Canny(level_map.astype(np.uint8), 1, 1)\n",
    "    \n",
    "    xs, ys = np.nonzero(canny)\n",
    "    trued = np.copy(canny)\n",
    "    for i in range(len(xs)):\n",
    "        x, y = xs[i], ys[i]\n",
    "        if x > 0 and x< gridmap.shape[0]:\n",
    "            if y > 0 and y< gridmap.shape[1]:\n",
    "                blackarea = black[x-4:x+5,y-4:y+5]\n",
    "                blackave = np.mean(blackarea)\n",
    "                \n",
    "                whitearea = white[x-2:x+3,y-2:y+3]\n",
    "                whiteave = np.mean(whitearea)\n",
    "                if not blackave <0.1:\n",
    "                    trued[x][y] = 0\n",
    "                if not whiteave > 0.3:\n",
    "                    trued[x][y] = 0\n",
    "                \n",
    "    return trued\n",
    "plt.figure(figsize=(15, 15))\n",
    "# skio.imshow(frontier(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "import scipy.cluster.hierarchy as hcluster\n",
    "fro = frontier(a)\n",
    "cordinates = np.array(np.nonzero(fro))\n",
    "\n",
    "cordinates = np.transpose(cordinates)\n",
    "clusters = hcluster.fclusterdata(cordinates, 10, criterion=\"distance\")\n",
    "\n",
    "group_id, group_count = np.unique(clusters, return_counts=True)\n",
    "for i in group_id:\n",
    "    if group_count[i - 1] < 5:\n",
    "        clusters[clusters == i] = -5\n",
    "\n",
    "filter_lst = []\n",
    "for i in range(len(clusters)):\n",
    "    if clusters[i] == -5:\n",
    "        filter_lst.append(i)\n",
    "\n",
    "clusters = np.delete(clusters, filter_lst)\n",
    "cordinates = np.delete(cordinates, filter_lst, axis=0)\n",
    "cx, cy = np.transpose(cordinates)\n",
    "print(filter_lst)\n",
    "\n",
    "# plt.figure(figsize=(12, 12))\n",
    "# plt.scatter(*np.transpose(cordinates), c=clusters)\n",
    "# plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "False\n",
      "544.0\n"
     ]
    }
   ],
   "source": [
    "ccopy = np.copy(clusters)\n",
    "ccopy[ccopy != 2] = 0\n",
    "ones = np.nonzero(ccopy)\n",
    "print(ones[0].size)\n",
    "print(np.mean(cx[ones]) == np.nan)\n",
    "print(np.mean(cy[ones]))\n",
    "# plt.scatter(*np.transpose(cordinates), c=ccopy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "sys.path.append('/home/daly/vrep_ws/MultiRobotSLAM')\n",
    "from lib.frontier import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1080x1080 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "b = skio.imread(\"a.jpg\")\n",
    "b = b[::-1]\n",
    "#testx, testy, cl = frontier_cluster(b)\n",
    "plt.figure(figsize=(15, 15))\n",
    "#b = sk.measure.block_reduce(a, (2,2), np.min)\n",
    "#b = transform.resize(a, size, preserve_range=True)\n",
    "b = preprocess_grid(b)\n",
    "# skio.imshow(frontier(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 10  20  30   0 100]\n",
      " [  0  10  40  50  10]\n",
      " [  0  20  50   0 100]\n",
      " [ 10  50  60  70  80]]\n",
      "[[ 1.  2.  3. -1.  7.]\n",
      " [-1.  3.  4.  5.  6.]\n",
      " [-1.  4.  5. -1.  7.]\n",
      " [ 6.  5.  6.  7.  8.]]\n"
     ]
    }
   ],
   "source": [
    "from lib.pathplanner import lee_planning_path\n",
    "from lib.frontier import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " ...\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]]\n",
      "[(400, 381), (400, 400)]\n",
      "0.26377224922180176\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7ff16b8d86a0>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
>>>>>>> 8f7471d28040d8374eac59aa5b4b4ab9828e3306
    "def color_wp(grid, wp, c):\n",
    "    for i in range(wp[0]-5, wp[0]+5):\n",
    "        grid[i][wp[1]] = c\n",
    "    for i in range(wp[1]-5, wp[1]+5):\n",
    "        grid[wp[0]][i] = c\n",
<<<<<<< HEAD
    "    return grid"
=======
    "    return grid\n",
    "\n",
    "a = skio.imread(\"a.jpg\")\n",
    "#a = a[::-1]\n",
    "b = a.copy()\n",
    "b = preprocess_grid(b)\n",
    "#size = b.shape\n",
    "#b = sk.measure.block_reduce(a, (2,2), np.min)\n",
    "#b = transform.resize(b, size, preserve_range=True)\n",
    "obst_b = grow_obstacle(b)\n",
    "double_obst_b = grow_obstacle(obst_b)\n",
    "import time\n",
    "tstart = time.time()\n",
    "wps = lee_planning_path(obst_b, (400, 400), (416, 381))\n",
    "print(wps)\n",
    "tend = time.time()\n",
    "print(tend - tstart)\n",
    "obst_b = color_wp(obst_b, (400, 400), 0.6)\n",
    "obst_b = color_wp(obst_b, (416, 381), 0.8)\n",
    "for wp in wps:\n",
    "    obst_b = color_wp(obst_b, wp, 0.8)\n",
    "plt.figure(figsize=(15, 15))\n",
    "skio.imshow(obst_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[10, 20, 30, 0, 100],\n",
    "              [0, 10, 40, 50, 10],\n",
    "              [0, 20, 50, 0, 100],\n",
    "              [10, 50, 60, 70, 80]])\n",
    "status = np.zeros((len(a), len(a[0])))\n",
    "can_visit = np.ones((len(a), len(a[0])))\n",
    "start, end = (0, 0), (3, 4)"
>>>>>>> 8f7471d28040d8374eac59aa5b4b4ab9828e3306
   ]
  },
  {
   "cell_type": "code",
<<<<<<< HEAD
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lee2(grid, start, end):\n",
=======
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lee(grid, start, end):\n",
>>>>>>> 8f7471d28040d8374eac59aa5b4b4ab9828e3306
    "    status = np.zeros((len(grid), len(grid[0])))\n",
    "    can_visit = np.ones((len(grid), len(grid[0])))\n",
    "    visited = np.zeros((len(grid), len(grid[0])))\n",
    "\n",
    "    reached = False\n",
    "    status[grid < 10] = -1 #set obstacles to -1\n",
    "    can_visit[grid < 10] = 0\n",
    "    status[start] = 1\n",
    "    can_visit[start] = 0\n",
    "    current_step = 1\n",
    "    visited[start] = 1\n",
    "    loop_limit = 1000\n",
    "    loop_count = 0\n",
    "    while not reached:\n",
    "        loop_count += 1\n",
    "        current_step_map = status == current_step\n",
    "        rollup = np.roll(current_step_map, -1, axis = 0)\n",
    "        rollup[-1] = False\n",
    "        rollup = np.logical_and(rollup, can_visit)\n",
    "\n",
    "        rolldown = np.roll(current_step_map, 1, axis = 0)\n",
    "        rolldown[0] = False\n",
    "        rolldown = np.logical_and(rolldown, can_visit)\n",
    "\n",
    "        rollright = np.roll(current_step_map, 1, axis = 1)\n",
    "        rollright[:, 0] = False\n",
    "        rollright = np.logical_and(rollright, can_visit)\n",
    "\n",
    "        rollleft = np.roll(current_step_map, -1, axis = 1)\n",
    "        rollleft[:, -1] = False\n",
    "\n",
    "        rollleft = np.logical_and(rollleft, can_visit)\n",
    "\n",
    "        this_step = np.logical_or(np.logical_or(rollup, rolldown), np.logical_or(rollright, rollleft))\n",
    "        assert(not np.sum(np.logical_and(this_step, np.logical_not(can_visit))))\n",
    "\n",
    "        can_visit = np.logical_and(np.logical_not(this_step), can_visit)\n",
    "        visited = np.logical_or(this_step, visited)\n",
    "\n",
    "        status[this_step] = current_step+1\n",
    "        current_step+=1\n",
    "\n",
    "        coordinates = np.transpose(np.nonzero(this_step))\n",
    "        reached = list(end) in coordinates.tolist()\n",
    "        if loop_count >= loop_limit:\n",
    "            print(\"cant be reach in\", loop_count, \"steps\")\n",
    "            return []\n",
    "    \n",
    "    if status[end[0]][end[1]] == 0:\n",
    "        print(\"not accessible\")\n",
    "        return [] #end is not accessible\n",
    "    paths = []\n",
    "    paths.append([end])\n",
    "    backtostart = False\n",
    "    while not backtostart:\n",
    "        new_paths = []\n",
    "        while paths:\n",
    "            path = paths.pop()\n",
    "            i, j = path[-1]\n",
    "            if status[i][j] == 1:\n",
    "                backtostart = True\n",
    "                paths.append(path)\n",
    "                break\n",
    "            if len(path) == 1:\n",
    "                i, j = path[-1]\n",
    "                currentstatus = status[i][j]\n",
    "                left = (i-1) >= 0 and status[i-1][j] != -1 and visited[i-1][j] == 1\n",
    "                right = (i+1) < len(grid) and status[i+1][j] != -1 and visited[i+1][j] == 1\n",
    "                top  = (j-1) >= 0 and status[i][j-1] != -1 and visited[i][j-1] == 1\n",
    "                bottom = (j+1) < len(grid[0]) and status[i][j+1] != -1 and visited[i][j+1] == 1\n",
    "                if left:\n",
    "                    if status[i-1][j] < currentstatus:\n",
    "                        copy = path[:]\n",
    "                        copy.append((i-1, j))\n",
    "                        new_paths.append(copy)\n",
    "                if right:\n",
    "                    if status[i+1][j] < currentstatus:\n",
    "                        copy = path[:]\n",
    "                        copy.append((i+1, j))\n",
    "                        new_paths.append(copy)\n",
    "                if top:\n",
    "                    if status[i][j-1] < currentstatus:\n",
    "                        copy = path[:]\n",
    "                        copy.append((i, j-1))\n",
    "                        new_paths.append(copy)\n",
    "                if bottom:\n",
    "                    if status[i][j+1] < currentstatus:\n",
    "                        copy = path[:]\n",
    "                        copy.append((i, j+1))\n",
    "                        new_paths.append(copy)\n",
    "            else:\n",
    "                currentstatus = status[i][j]\n",
    "                this_i, this_j = path[-1]\n",
    "                last_i, last_j = path[-2]\n",
    "                continue_i = this_i + (this_i - last_i)\n",
    "                continue_j = this_j + (this_j - last_j)\n",
    "                if continue_i>=0 and continue_i<len(grid) and continue_j>=0 and continue_j<len(grid[0]) and status[continue_i][continue_j] < currentstatus and visited[continue_i][continue_j]:\n",
    "                    copy = path[:]\n",
    "                    copy.append((continue_i, continue_j))\n",
    "                    new_paths.append(copy)\n",
    "                else:\n",
    "                    left = (i-1) >= 0 and status[i-1][j] != -1 and visited[i-1][j] == 1\n",
    "                    right = (i+1) < len(grid) and status[i+1][j] != -1 and visited[i+1][j] == 1\n",
    "                    top  = (j-1) >= 0 and status[i][j-1] != -1 and visited[i][j-1] == 1\n",
    "                    bottom = (j+1) < len(grid[0]) and status[i][j+1] != -1 and visited[i][j+1] == 1\n",
    "                    if left:\n",
    "                        if status[i-1][j] < currentstatus:\n",
    "                            copy = path[:]\n",
    "                            copy.append((i-1, j))\n",
    "                            new_paths.append(copy)\n",
    "                    if right:\n",
    "                        if status[i+1][j] < currentstatus:\n",
    "                            copy = path[:]\n",
    "                            copy.append((i+1, j))\n",
    "                            new_paths.append(copy)\n",
    "                    if top:\n",
    "                        if status[i][j-1] < currentstatus:\n",
    "                            copy = path[:]\n",
    "                            copy.append((i, j-1))\n",
    "                            new_paths.append(copy)\n",
    "                    if bottom:\n",
    "                        if status[i][j+1] < currentstatus:\n",
    "                            copy = path[:]\n",
    "                            copy.append((i, j+1))\n",
    "                            new_paths.append(copy)\n",
    "        if not backtostart:\n",
    "            paths = new_paths\n",
    "\n",
    "    \"\"\"Calculate number of steps in unkonwn area for a given path.\"\"\" \n",
    "    def calculate_unknown(path):\n",
    "        total = 0\n",
    "        for position in path:\n",
    "            width = 3\n",
    "            px, py = position[0], position[1]\n",
    "            area = grid[px-width:px+width+1, py-width:py+width+1]\n",
    "            unknown = np.sum(area<127)/(2*width+1)**2\n",
    "            if unknown > 0.5:\n",
    "                total += 1                \n",
    "        return total\n",
    "    \n",
    "    \n",
    "    numStepsInUnknown = [calculate_unknown(p) for p in paths]\n",
    "    \n",
    "    waypoints = [find_waypoints(p) for p in paths]\n",
    "    pointsnums = np.array([len(p) for p in waypoints])\n",
<<<<<<< HEAD
    "    \n",
    "    minunknown = np.min(numStepsInUnknown)\n",
    "    minunknownindex = np.nonzero(numStepsInUnknown == minunknown)\n",
    "    \n",
    "    if len(minunknownindex[0]) == 1:\n",
    "        \"\"\"if exist one path with minimum unknown steps, take the path\"\"\"\n",
    "        return waypoints[minunknownindex[0][0]]\n",
    "    else:\n",
    "        \"\"\"otherwise choose a path with least turns among the paths with least unknown\"\"\"\n",
    "        left_waypoints = [waypoints[i] for i in minunknownindex[0]]\n",
    "        left_pointsnums = np.array([len(p) for p in left_waypoints])\n",
    "        min_points = np.min(left_pointsnums)\n",
    "        min_points_index = np.nonzero(left_pointsnums == min_points)\n",
    "        return waypoints[min_points_index[0][0]]"
=======
    "    minpointsnum = np.min(pointsnums)\n",
    "    minindex = np.nonzero(pointsnums == minpointsnum)\n",
    "    return waypoints[minindex[0][0]]\n",
    "        \n",
    "def find_waypoints(path):\n",
    "    waypoints = []\n",
    "    for idx, pt in enumerate(path):\n",
    "        if idx == 0:\n",
    "            continue\n",
    "        if idx == len(path) - 1:\n",
    "            waypoints.append(pt)\n",
    "            break\n",
    "        diff = np.array(path[idx + 1]) - np.array(path[idx - 1])\n",
    "        if (np.abs(diff) == np.array([1, 1])).all():\n",
    "            waypoints.append(pt)\n",
    "    return waypoints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lee(a, (0, 0), (3, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = []\n",
    "a.append([3, 4])"
>>>>>>> 8f7471d28040d8374eac59aa5b4b4ab9828e3306
   ]
  },
  {
   "cell_type": "code",
<<<<<<< HEAD
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(400, 387)]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
=======
   "execution_count": null,
   "metadata": {},
   "outputs": [],
>>>>>>> 8f7471d28040d8374eac59aa5b4b4ab9828e3306
   "source": [
    "leetest = skio.imread(\"lee.jpg\")\n",
    "start = [400, 400]\n",
    "end = [386, 387]\n",
    "lee2(leetest, start, end)"
   ]
  },
  {
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}