HMWK3

hmwk3.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "HMWK3",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/gist/tuffacton/0a51c958936b91989fe619bc3250663d/hmwk3.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4ru12l9x2w83",
        "colab_type": "text"
      },
      "source": [
        "Write and test a program that will:\n",
        "1. Extract the contour of the object using the Pavlidis algorithm. This should return a 2D numpy array of the XY points that make up the contour.\n",
        "2. Compute the estimated area of the contour using the Gauss formula presented in the lecture.\n",
        "3. Write a function that implements one pass of the Discrete Contour Evolution algorithm.\n",
        "4. Use the starter code provided to test the code. This starter code does eight steps of successive contour evolution, each time reducing the number of points in the contour by half.\n",
        "\n",
        "**Do not use any OpenCV, Numpy, or other functions that perform contour extraction or similar.**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Uaey3TqklNeH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "import cv2\n",
        "import math\n",
        "import matplotlib.pyplot as plt\n",
        "from google.colab.patches import cv2_imshow\n",
        "\n",
        "pathName = \"/content/\"\n",
        "MAXCONTOUR = 50000\n",
        "\n",
        "def showImage(img,name):\n",
        "  cv2_imshow(img)\n",
        "  return\n",
        "\n",
        "######################################################\n",
        "\n",
        "def saveImage(img, name):\n",
        "  cv2.imwrite(pathName + name + \".png\", img)\n",
        "  return\n",
        "\n",
        "######################################################\n",
        "\n",
        "def outOfBounds(point,image):\n",
        "  if ( (point[0] < 0) or (point[0] >= image.shape[1]) ):\n",
        "    return True\n",
        "  if ( (point[1] < 0) or (point[1] >= image.shape[0]) ):\n",
        "    return True\n",
        "  return False\n",
        "\n",
        "######################################################\n",
        "\n",
        "def GaussArea(pts):\n",
        "  area = float(0)\n",
        "  for p in range(0, len(pts)-1):\n",
        "    # Come back around full cirlce\n",
        "    if p == len(pts):\n",
        "      area = area + pts[p][0]*pts[0][1] - pts[0][0]*pts[p][1]\n",
        "    else:\n",
        "      area = area + pts[p][0]*pts[p+1][1] - pts[p+1][0]*pts[p][1]\n",
        "  return abs(area)/2.0\n",
        "\n",
        "######################################################\n",
        "'''\n",
        "Derived using the slides 49-51 from Lecture 6a\n",
        "'''\n",
        "def theta(i, ctr):\n",
        "  '''\n",
        "  Given a point i return the relative theta measure between\n",
        "  i and its surrounding points\n",
        "  '''\n",
        "  index = ctr.shape[0]\n",
        "\n",
        "  y_i = ctr[i][0]\n",
        "  x_i = ctr[i][1]\n",
        "\n",
        "  y_imin1 = ctr[i-1][0]\n",
        "  x_imin1 = ctr[i-1][1]\n",
        "\n",
        "  y_0 = ctr[0][0]\n",
        "  x_0 = ctr[0][1]\n",
        "  if i == index:\n",
        "    # return math.atan((y_i-y_imin1)/(x_i-x_imin1))\\\n",
        "    #     - math.atan((y_0-y_i)/(x_0-x_i))\n",
        "    y_iplus1 = ctr[0][0]\n",
        "    x_iplus1 = ctr[0][1]\n",
        "  \n",
        "  else:\n",
        "    y_iplus1 = ctr[i+1][0]\n",
        "    x_iplus1 = ctr[i+1][1]\n",
        "\n",
        "  return math.atan((y_i-y_imin1)/(x_i-x_imin1))\\\n",
        "      - math.atan((y_iplus1-y_i)/(x_iplus1-x_i)) \n",
        "\n",
        "  # return (y_i-y_imin1)/x_i-x_imin1)\n",
        "  #     - math.atan((y_iplus1-y_i)/(x_iplus1-x_i)) \n",
        "\n",
        "def length(i, ctr):\n",
        "  '''\n",
        "  Given a point, find the length from the previous connected point\n",
        "  '''\n",
        "  return math.sqrt((ctr[i][0] - ctr[i-1][0])**2\\\n",
        "                   + (ctr[i][1] - ctr[i-1][1])**2)\n",
        "\n",
        "\n",
        "def onePassDCE(ctr):\n",
        "  index = ctr.shape[0]\n",
        "\n",
        "  K = []\n",
        "  ref = []\n",
        "\n",
        "  for i in range(index-1):\n",
        "    k = abs(theta(i, ctr))*length(i, ctr)*length(i+1, ctr)/\\\n",
        "    (length(i, ctr) + length(i+1, ctr))\n",
        "    K.append(k)\n",
        "    ref.append([int(ctr[i][0]), int(ctr[i][1]), k])\n",
        "\n",
        "  # Playing with various thresholds for K\n",
        "  # k_thresh = np.min(K)\n",
        "  #k_thresh = 1.1\n",
        "  k_thresh = np.percentile(np.unique(K), 50)\n",
        "\n",
        "  new_ref = []\n",
        "  for i in ref:\n",
        "    if i[2] > k_thresh:\n",
        "      new_ref = np.append(new_ref, np.asarray([int(i[0]), int(i[1])]))\n",
        "  new_contours = np.reshape(new_ref, (-1,2))\n",
        "  new_contours = new_contours.astype(int)\n",
        "  \n",
        "  # Return the contour AND return the unique values of\n",
        "  # K for exploration and threshold tuning\n",
        "  return new_contours, np.unique(K)\n",
        "\n",
        "######################################################\n",
        "\n",
        "def showContour(ctr, img):\n",
        "  length = ctr.shape[0]\n",
        "  contourImage = np.zeros(binary.shape)\n",
        "  for i in range(length):\n",
        "    if i == length-1:\n",
        "        cv2.line(contourImage, (ctr[i,1], ctr[i,0]),\\\n",
        "            (ctr[0,1], ctr[0,0]), 255,1)\n",
        "    else:\n",
        "      cv2.line(contourImage, (ctr[i,1], ctr[i,0]),\\\n",
        "                (ctr[i+1%length,1], ctr[i+1%length,0]), 255,1)\n",
        "  cv2_imshow(contourImage)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kDRAkwVxp4zL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "'''\n",
        "Derived with the immense help of this demonstration:\n",
        "http://www.imageprocessingplace.com/downloads_V3/root_downloads/tutorials/contour_tracing_Abeer_George_Ghuneim/theo.html\n",
        "'''\n",
        "\n",
        "def pathCheck(point, img, direction):\n",
        "  point_y = point[0]\n",
        "  point_x = point[1]\n",
        "\n",
        "  # Define surrounding points\n",
        "  # by compass configuration\n",
        "  w = (point[0], point[1]-1)\n",
        "  nw = (point[0]-1, point[1]-1)\n",
        "  n = (point[0]-1, point[1])\n",
        "  ne = (point[0]-1, point[1]+1)\n",
        "  e = (point[0], point[1]+1)\n",
        "  se = (point[0]+1, point[1]+1)\n",
        "  s = (point[0]+1, point[1])\n",
        "  sw = (point[0]+1, point[1]-1)\n",
        "\n",
        " # Check North\n",
        "  if direction == 'north':\n",
        "    # P1 check\n",
        "    if img[nw] > 2:\n",
        "      new_point = nw\n",
        "      direction = 'west'\n",
        "    # P2 check\n",
        "    elif img[n] > 0:\n",
        "      new_point = n\n",
        "      direction = direction\n",
        "    # P3 Check\n",
        "    elif img[ne] > 0:\n",
        "      new_point = ne\n",
        "      direction = direction\n",
        "    # No P1, P2, P3\n",
        "    # Rotate 90 deg\n",
        "    else:\n",
        "      new_point = point\n",
        "      direction = 'east'\n",
        "\n",
        "  # Check East\n",
        "  elif direction == 'east':\n",
        "    # P1 check\n",
        "    if img[ne] > 0:\n",
        "      new_point = ne\n",
        "      direction = 'north'\n",
        "    # P2 check\n",
        "    elif img[e] > 0:\n",
        "      new_point = e\n",
        "      direction = direction\n",
        "    # P3 check\n",
        "    elif img[se] > 0:\n",
        "      new_point = se\n",
        "      direction = direction\n",
        "    # No P1, P2, P3\n",
        "    # Rotate 90 deg\n",
        "    else:\n",
        "      new_point = point\n",
        "      direction = 'south'\n",
        "\n",
        "\n",
        "  # Check South\n",
        "  elif direction == 'south':\n",
        "    # P1 check\n",
        "    if img[se] > 0:\n",
        "      new_point = se\n",
        "      direction = 'east'\n",
        "    # P2 check\n",
        "    elif img[s] > 0:\n",
        "      new_point = s\n",
        "      direction = direction\n",
        "    # P3 check\n",
        "    elif img[sw] > 0:\n",
        "      new_point = sw\n",
        "      direction = direction\n",
        "    # No P1, P2, P3\n",
        "    # Rotate 90 deg\n",
        "    else:\n",
        "      new_point = point\n",
        "      direction = 'west'\n",
        "\n",
        "  # Check West\n",
        "  elif direction == 'west':\n",
        "    # P1 check\n",
        "    if img[sw] > 0:\n",
        "      new_point = sw\n",
        "      direction = 'south'\n",
        "    # P2 check\n",
        "    elif img[w] > 0:\n",
        "      new_point = w\n",
        "      direction = direction\n",
        "    # P3 check\n",
        "    elif img[nw] > 0:\n",
        "      new_point = nw\n",
        "      direction = direction\n",
        "    # No P1, P2, P3\n",
        "    # Rotate 90 deg\n",
        "    else:\n",
        "      new_point = point\n",
        "      direction = 'north'\n",
        "\n",
        "  return new_point, direction\n",
        "\n",
        "def Pavlidis(img):\n",
        "  # Find a start point\n",
        "  ## Since this image is a continuous binary image,\n",
        "  ## this start point can be probably one of the first\n",
        "  ## points with a 255 intensity.\n",
        "  start = (ystt, xstt)\n",
        "  first_direction = 'north'\n",
        "\n",
        "  first_direction = 'north'\n",
        "  first_start_point = ([start_y, start_x], first_direction)\n",
        "\n",
        "\n",
        "  # Initialize Points\n",
        "  points = []\n",
        "  points.append(first_start_point[0])\n",
        "\n",
        "  start_point = first_start_point\n",
        "  next_point = pathCheck(start_point[0], img, start_point[1])\n",
        "\n",
        "  # Travel along the points, collecting contours as you go\n",
        "  # 5000 is our max contours\n",
        "  i = 0\n",
        "  while i < 5000:\n",
        "    next_point = pathCheck(start_point[0], img, start_point[1])\n",
        "    points.append(next_point[0])\n",
        "    start_point = next_point\n",
        "    i = i + 1\n",
        "\n",
        "  # We actually don't need any contour lines that are already considered\n",
        "  # So we can pull only our unique ones and retain order\n",
        "  points_array = np.array(points)\n",
        "  u, ind = np.unique(points_array, axis=0, return_index=True)\n",
        "  points_array = u[np.argsort(ind)]\n",
        "  return points_array"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-uk79H6t8p5T",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "####### Testing Area #########\n",
        "%%capture\n",
        "!wget https://github.com/tuffacton/ece5554/raw/master/hmwk3/USAsmall.png -O usa.png\n",
        "\n",
        "inputImage = cv2.imread(pathName+'usa.png')\n",
        "grayImage = cv2.cvtColor(inputImage, cv2.COLOR_BGR2GRAY)\n",
        "thresh = 70\n",
        "binary = cv2.threshold(grayImage, thresh, 255, cv2.THRESH_BINARY)[1]\n",
        "(height, width) = binary.shape\n",
        "\n",
        "# Initialize starts and base images\n",
        "ystt = np.uint8(height/2)\n",
        "for xstt in range(width):\n",
        "  if (binary[ystt, xstt] > 0):\n",
        "    break\n",
        "\n",
        "img = binary.copy()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4jrvVRnMzyA_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "032035a9-7b7c-424a-c13f-d5aec8a2d2dd"
      },
      "source": [
        "Steps = 9\n",
        "for s in range(Steps):\n",
        "  if s == 0:\n",
        "    ctr = Pavlidis(img)\n",
        "  else:\n",
        "    ctr = onePassDCE(ctr)[0]\n",
        "  print(\"Gaussian Area for Step %d is: %d\" % (s, GaussArea(ctr)))\n",
        "  # Print the K for threshold exploration and tuning\n",
        "  print(onePassDCE(ctr)[1])\n",
        "  showContour(ctr,img)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Gaussian Area for Step 0 is: 198224\n",
            "[0.         0.14183169 0.15642817 0.27873592 0.32034502 0.32037262\n",
            " 0.37891879 0.46007559 0.46185949 0.65064514 0.78539816 1.11072073\n",
            " 1.38022678 1.40576619 1.85041452 2.08174295 2.0943951  2.51409215]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<PIL.Image.Image image mode=L size=743x468 at 0x7FE31EE9EE10>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Gaussian Area for Step 1 is: 201288\n",
            "[ 0.22306549  0.24924424  0.2779284   0.28889335  0.329189    0.34570308\n",
            "  0.46942141  0.48165652  0.6004951   0.63565973  0.6401409   0.65209272\n",
            "  0.66330625  0.66971557  0.70225267  0.70634181  0.86582768  0.86848826\n",
            "  0.87098951  0.90344     0.9212794   0.93310719  1.04186843  1.05125289\n",
            "  1.08206162  1.09830911  1.109907    1.11072073  1.14950276  1.16049824\n",
            "  1.20446699  1.21231895  1.30070896  1.30526649  1.30899694  1.34203025\n",
            "  1.35725623  1.36692998  1.38022678  1.40576619  1.41644842  1.44549939\n",
            "  1.46134642  1.47827776  1.48096098  1.48595386  1.50581519  1.52352293\n",
            "  1.57200631  1.6047998   1.62577818  1.63953346  1.63953346  1.64570328\n",
            "  1.65450862  1.66266152  1.6660811   1.6835728   1.69006049  1.69138424\n",
            "  1.70722063  1.74074736  1.74637751  1.77715318  1.78552122  1.7869888\n",
            "  1.80206302  1.8021497   1.83036892  1.84475113  1.84524786  1.85120122\n",
            "  1.87579884  1.89441507  1.90676554  1.91713872  1.92995673  1.9337665\n",
            "  1.93813713  1.94221435  1.95193543  1.96843739  1.98020588  1.98805361\n",
            "  2.00224435  2.00775007  2.01197374  2.01649835  2.03343641  2.04534368\n",
            "  2.05637718  2.06426354  2.10778916  2.15967009  2.16412323  2.17378931\n",
            "  2.17529714  2.1845593   2.20608879  2.21027147  2.21027147  2.21290706\n",
            "  2.22316928  2.26461327  2.26461327  2.32737589  2.36560252  2.39010646\n",
            "  2.39010646  2.42362293  2.4429      2.44537087  2.45446486  2.46178852\n",
            "  2.50073194  2.50388158  2.51409215  2.51409215  2.55522831  2.59369439\n",
            "  2.59748305  2.60957455  2.61112026  2.62837566  2.62837566  2.64092655\n",
            "  2.66572976  2.67332465  2.68527014  2.69657369  2.69657369  2.71858181\n",
            "  2.76045355  2.77211117  2.79754087  2.81153237  2.83241713  2.84028813\n",
            "  2.85153182  2.86455037  2.8796663   2.90179355  2.96440846  2.99993766\n",
            "  3.0242672   3.0734351   3.13514752  3.15310448  3.17348781  3.2026468\n",
            "  3.24477884  3.35918511  3.36445494  3.39204759  3.42216864  3.4302519\n",
            "  3.43085719  3.46262716  3.48149472  3.5218188   3.54209214  3.6633012\n",
            "  3.75455329  3.77616708  3.85834756  3.90387085  4.08439008  4.09367314\n",
            "  4.25649003  4.2584514   4.44633857  4.47355638  4.49510196  4.52226256\n",
            "  4.52922654  4.52922654  4.61899268  4.63577069  4.65191306  4.74646352\n",
            "  4.78021293  4.78021293  4.80041576  4.84678139  4.85110876  4.91446976\n",
            "  4.92066097  5.10153124  5.2534329   5.45059461  5.47622839  5.55496425\n",
            "  5.68297138  5.84584616  5.96332554  6.03420692  6.42204566  6.47596319\n",
            "  6.49843308  6.54498469  6.70050821  6.70859089  6.90113388  6.93810212\n",
            "  7.06546764  7.06969395  7.30673211  8.55398277  8.60714718 10.18914784\n",
            " 10.63844004 10.85805061 11.98882127 12.22675663 12.249542   12.80516567\n",
            " 15.69428594 17.30793898]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAucAAAHUCAAAAAC8atmKAAARP0lEQVR4nO3d25qjKhCGYVzP3P8tsw6SNu5lV1RBfe/B7LqjBv6uQVQSAgAAAIAOovYBAOJiJOiYXlx/ASb0CXj8/RmYUAybfL8HfZE8FkBKDNvwRnKMGR3PPt8q+n9yhwIIUqjgMXImgK5OgXtJ4L8me10OwyWgs+V5iN4m55+Mk3XoeQ56k5x/d/GXdcKOOR0GR5EBO0Rdxks8c1c7IOuQcx2th8DljFuyJuMZxKC3hyF6es5jWGJmaJfP68g6+niZdEkTw3rjzPkLLy9lEIOW7tJ0m7LM+Zal7E4CBjHookFB//tROVfmjFJNYUcDDxmqjle8+FPRlsk6Kj3l5/pr6eOW338J2eejhw0FBjGwa/uDsqvIpdWZwo5C+QW9dNu3w5jMjZJ15HvMzNUXW93HVYpBDFq7mnSpz3n9TA6Xk2DH3SxLw2EHgxgkeUtJTYpuhuetgxkJO968BuT0Ddrj8xMGMah3GqLX5lxmQQGeTkKd8hsA4tVfhEcYDGJwKSEUpcG5ynmXDJJ1nKQkoj7oncr5ZodkHVtJaSiLzPkKaN/oMYjBKi0IRXE55VwjdGQdIT166/dVzLeorN3ITAwyrNMuRTlv8hheOe6JQaqSqP5GDLvFp/UwiPEqudv/vjGnnu8eDrWw4vRmECOddwPvFhWyxi3GYh5CWLMufTji/29Yac8hJKevKKbbCXTGC43Rohmyp1tKN06ntEfSkyW2VHXMIYKkp+pyORRiSHoiuftb6IEuSHoKwXpO0Dsh6a8kY07OuyHpj5Kap6INaf1uSPo94ZST865I+g3RMUv9i5GLpF+Rjzk5742kn6TFvLLdaPbeSPqe+Ng8eS9oi6RvlD/mn3M/l5l7FH35dhyNn7Ds/u23mFuPC0ffnovHf/AmqczefU9Gzinnqjb3/h/+7kO3+DFQtMRbb1QuZJHxObneCgjsqPtErMxdwQ5fvZH92HOHXaEHV93RIObMt8C49DFLg6G1q/oxAD/9kf5OW7SJn3Ydg5v+IOaueemQVjFnfD4kJ5O8HacTv/uDKT46JOddvnwv9RxWZfyn1abw+6geI/HQIxnvsVFzeGjVoaTchy1/FKKy7rtv82ZHb7LpvHfI8AvDZx0+5XxOrx0SR++z5jFPOA91Moc1jrcOybhQ/vnNXAe3jxzzLcN5jXnC02Vfm0eVDGVdYtb8PeeUc1te+uMTkutv+sv38Yu2PsRPJHDU88G8xfziy8fyfemTdQNJl6mrrzmnnJvy3B27oCbFe0+/r9V+1AY/cZ/Mc2/8Pvey6BMnDXS12ietGHjvWD32xgSrrel9oJCBN48/zzGX3HgfxBzhuTOqr3/q93ThW0h7FfMto4q7lYv0zyBryU54POecyRZDdp0RwxI3f67abghBf6pFOGrU82Esvyg0quU2Eh5CUK6o+mM2bH36Y50yjKFuXG7nnsaqd9Fg9/WbQEtxF4lYkY+iCXYpyh+aZach8LULZ03KGxxLM9qfJmSqMdCQpZ6t/JlLfPXDeSiTLVPZnHRa6tlOx8J8ixPfPFmq5CE0iPlSuwVrLYIqNrvTwFmkzYZBobfu1Dg1bbNP7dNYGGJxiQATj+mT86kkLBHQu6Y325ny9DsMScp556S32lejdS3gwHfWYgnRyA0v6WomXCjnc0ks598/9+p9/QE6OZ/L62zL4a+d+l876MR8Llnl/PMPHSLQbh/vG2J8jqsh7iL+jJKBZ6Ao55PJr+chCNf0ttuWfLQUoyi9FiqXg+Y/QiXbI+aTeenQ2y9LBUHiP4qCTZLzySSu4pX5umIym83eKjGfTPEqXiJJEBv1526XnE/mcX2j4leWETy3zdwyMZ/MU8EuHbkXkp2Vz9s4OZ9MxcCkcRako5WzfWI+Gys573CJ9X4PXA+dXcXtfC2fUTZw+XOLcj6bePrD+UtvL214FJIedkI990KzgvUp5hn//VDOZxPX37PrebPnfQzc5Xuo59WrYcAmvX7tNTB/3g/jFhdKYr5fb70wrDZSfso55Xwysc1Cc4UjDyspv3gB5hLD+iz/5dceX7j5s+EbX/PH/8R8PusJaF7O4+EvRdGw+vQdOZ9QUcx3X43v352wFRmJO/hP9iigr3qIXDO6X2SDHouOjXI+seLp8+PvWTuVvUExfevMK+LGUj1XIzvdUv1Be5hR/u0tm7mapG/P3n6Nqv8pyPm8Lvo25T6u4+lo+v5EV8Wo3DhBn9VVzyYU9MMsevruDD05JLEBGFVQzk/fkp4Oc0MWzkPxoOxMT/T8s2zj+5xzewvqSaaozY8Qw5ZpFY3PS14gOTIv3zbjFrQkOWRpt23q+bQuu7Z5QRedS6x58f7+FuG7ETC3srtNFBDzaV13bcuCbuZeloSNNdwWTLnp2twev//+cVJOzOfVaCn/2283fv2T+RYnlhDD1WWfrAUebic8jC229YJyPrt4LrsZnX5fzMuOpsGek1HPPVlCiIeqXr9izxDFfJPzUSaFUOMT9YbRHCM21HN/lnAu66WGKOY7jM6d+RusJ3f8xRNJfULTYC/Uc7e+I5jkgnweoIwxZNmjnDuVXJOP39drGdyLXdvYFGZ0CEjHlLcMJzHHo2PMNXduYkuY0n69xd5xqd7f9zx0xDMKKBlvLpH5FmQbuCYyasGLdZVFnay02Ss5x7OaxURb7r8U4xakG3FkvkU9x7MY1IYsvwOwsRHM67CiqNIRVPgXwtBn0Ohk9CFLCNo/qbBPdcjyPYSqV3MeineT/Iev/8MKPOM8FB5woQgeVCaUzw+FB+QcnjBwgWW1+aSewxPqOQzjwTl4QM7hQH04GZ/DA3IOVxi3wCqW44IDLW4K5r5c2PQLd8ubgqnnMEYkkuQc1khkkpzDHIFQknPY0y6VzJ/DE+o5DGoeS3IOi1rnkpzDpLbBJOawI97+pemWAU1RIOjMt8AYycW/qOcw4rw0b4twUs9hivBSjhR0WBA3vx7+sQr1HNa1LPHUc5gQ118O/9Zy+4Cyi4ELl4own3NBZ74Fk1oEqy4FHRacRi7cy4UJxd1vgZxjToegc38LUIKCDgs2Uy6xUSip5zAsLhL3u1DPYcCunIvtAFC23porFUiCDgP+Mt4wjozPYY7A1VByDocYuMCC2G5G8eNQzyXvnwHsIOgwILb5GIsV43NY1HpgQc7hEcMW2BAZt8CFlne2kHPY1Pb+LXIOlxigwwjRKJJzWMF9XEAVyjns4HMVgRrUcxjSLI7Uc7hEQYchreJIPYdPFHQYIhdHgg47JBeIJukwQzKMBB1WcJcLXCDo8ICBC1xgygUeiKWRmMMOyjkcIOZwgUXQ4YLQdUtyDmNEIknOYU11JrkvFx6Qc3jFwAXGcCYKD4QSSdBhSX0eGZ/DMQo67ODSPxyQfERUbtNAliZZZHwOD/5pHwDwJDb+AJfT5gF94jkk6DBAPoYEHepYFxpog4IObT0ySM6hrE8ECTp0dUogQYequP5Si/NQ2Nah2FLPoSuGSD3H/OLSpthyfwtMi6K3t/ztpMM+gDvtVuKinsMq4VsV97sCVPT9NDiCDg2tU858C0zqNmT5oJ5DQfPYcR4KczqegP52CfQlkTnG5wDlHN2JZI56DlDP0ZtM5Kjn8ICcA51vMgC0AkfS0ZNe3Eg6+hEKW8J1/yXE7rfVACoo6uhCPWckHeJMhMzEQWBeZgJm5kAwH0vhMnQomIqllAeCDhHGUh4IOtqzl/IQosWDwsh6BCr7+dAlcNkIXlDU0YrtKJF0tGE9SNaPD2OwniPrx4ch9IkRzxPBA3IOD2pyzsAFo6jJeaOPjgGMY3IRtcaI0BhHCbsGSdAghwmjOuWH+RYgBQUd5QZKz0CHClvGmscY6mBhx2jBGe14YcNwuRnugGHAeKkZ74ihbsTQjHjMUDVmZMY8aqgZNDCDHjaUjJqXUY8bKrrHhev+QDrqOdINnJaBDx2djZyVkY8dXQ0dlaEPHh2NnZSxjx7djB6U0Y8fXYwek9GPH10MH5Ph3wA6UEtJu4XMY9OtYUZRLSDZ6/zfWsL640rcYYxIJIk7ruiV84b1fOP7duL2L4Ai+RRS3PGhWM5l6vnOpriTdTjA1KNrqt3f9f5zgg4l8uOWn4VPHoUXYy01hmZ0+71nPQ8hUNShonvO+eR0KFDIeSDq6E0n54GowxPOSr1Q7mi1ev7BWSm6UM454xd0oZ7zQNThSWSsPjH6doOkz4uu3aKoT0q7Wy2MzzcYqsMPqvp8fM+fX6Oqww+K+lSc3ZebjmulcIOh+jRUO9JwPQ8hMFSHJ1T1GdCHCUj68OjBJBT10Sn2n/Xx+QZDdfhBVR+YXtcNVM8/qOrwg6I+JrotV874JfJzYcQEn0/U32H8ct+GS1xCHPqtTkNzDfSBbav6W62gpBtAJ5Rao07OR6DUC8PNt5wsgTEJnIgxvlcKCroFOr0wfj0PIfzNqgPgR8EGlV7o+vlE6gg6XOB6kT66oAdaWZ1GF/gat+AOP/6zoUfPUmZlW+6u477copGPPictHduFLuiBVj6Im1+zX1v0MrqgB1p5J/H2oLsXlzzgRQ90weziVjz8nv/a/Kh374BJrvvnWbgN+ud4Y3NOy3yb8XvXheU2tXxskgh6COHyUdt9qX1spsN9ojnP7fZuf7fdTdCTcvmQ+qu7oZOjTs57cR70okUTvql/XHMh8WEA583fkeeT0aoz8ZfHytM27bn1O/Pa1LVLPb29nKAb43F+scd6Zkm7cNj2epw1drdF+8wF3fvZgKfToZ6PiyfMxXtqen2OKnr3t9pkHI8m3DS2xsnI8y7dNL0JXlpb5X0SdDOcNLbS23zcrZOmt8FLY+u8Twq6GV4a22DQvTS9CW4a29wI3U3L2+CmuTXeKDk3w09zW5ta7Hc8rN/iCFcgXfNSz82NzzseksvnQ+eyZuW5Wvv+MARynsRASNZBx7EGrkf29CyygTdwZek1lCLnCY0dw6L94bwxLH/5vj2MJdxl3WjK0VfifXWKH7meteO4O9AYo+IpiJUP06Gev1qrvd4yJXn/u3/q+qa6eznRxouHIJxrePeyXrK/uK/qav8Tve+XH8KObhv7+gtdo162UqeR+JBzU25i8ZCWbkEaOwcJRz/2GxzNVW4NXLO2UpdLkXNzLkbiz98vdiR99yHKyoP/3N+yWjKL5yLfP9yQ0goNubNfjiHl+pHowYzfO78VGZ++afz3OaQYUy+uSJb04ccsPyxwYVfa3KFcF83U+W/vZab3OimhLhp9nmXHysV/lJPpork6notFE5Doosm6nZzPoHkfTTVmCUH9hB5NtO6i6brcyrUiVGncRfP1eNI7En7b3H9uywzXhjCnhqVovmIego2CjmrtemjWvmaEPoNWPTTdPMsPQZ9Bmx6aup/j+svzt8CwJj00eTfHECJBH1x9D008Zvn4hNzAE1ooV91DDrqYkcsEKnvITQer5ZzrRPq4NvTBY0X2VZQiN8U8hOc366ohRlXcSb56l5yPrqyXpp9nOSDnwyvpJndd+/TUrbvGGFNBaXbZs7ft5LI1RpTZUd7GLH8yF21tgnlFNUyjYVBZBclpNQ/379xvi4wmo6ccdyo5H15yV7nu05s3L9gmrJcLIFtiTXJdzm+mmpy3yWCUlx8dxUUz0ShjYfmpJKek0yiDYX3YNMekc50IM1r63XrPfAsULR0+5CmEQD0XsXBJP10M4fv5RZKtRs4V8GPw82kK8apOzmGA+A8+43N4QM4BlGE5Hmuo5/CAnAMoxMAFLrAwrC2MWwAUY+EpU6jnAMpR0C2hnoshzHDh/klRfgQwk7ukk3PM5SbpBB2TYakS+MBSJfCBpUrgwyHp5ByT2iedoPfFc9C9LCF2eN4X18h5P8t2sRJ0RZv3FwPtDgAAAAAAAAAA9P0PXqeSNVqkHqYAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<PIL.Image.Image image mode=L size=743x468 at 0x7FE31EE9EBE0>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Gaussian Area for Step 2 is: 203773\n",
            "[ 0.          0.0335204   0.39852577  0.74722533  0.76719871  0.8068194\n",
            "  0.85253251  0.89322627  0.9061506   1.00204112  1.30006856  1.4746641\n",
            "  1.58513369  1.64666691  1.65499816  1.72337415  1.76827572  2.21343002\n",
            "  2.23014668  2.42362293  2.4429      2.46178852  2.51409215  2.51409215\n",
            "  2.5338631   2.59369439  2.59748305  2.60957455  2.61112026  2.62837566\n",
            "  2.64092655  2.65461758  2.77211117  2.79754087  2.84028813  2.85153182\n",
            "  2.8796663   2.94246084  3.03334352  3.08347202  3.21866837  3.62065131\n",
            "  3.64424754  3.75455329  3.91161515  4.09367314  4.16560263  4.25649003\n",
            "  4.47355638  4.49510196  4.52226256  4.52922654  4.61899268  4.62156839\n",
            "  4.63864819  4.6637626   4.78021293  4.78021293  4.87312524  4.91446976\n",
            "  4.92066097  5.05688828  5.15291218  5.19479072  5.40678284  5.44878484\n",
            "  5.46239913  5.47622839  5.55131454  5.56508139  5.59080445  5.84584616\n",
            "  5.92474431  5.98826318  6.1288554   6.14231059  6.19852914  6.30674774\n",
            "  6.42204566  6.47596319  6.65798059  6.70859089  6.94368418  7.06713848\n",
            "  7.06969395  7.13740441  7.30673211  7.36620993  7.39180304  7.43412808\n",
            "  7.47555305  7.49931096  7.70574802  7.80241398  7.82246008  7.88082147\n",
            "  7.88871014  8.14502608  8.28618058  8.30276529  8.38732774  8.43025245\n",
            "  8.66754584  8.67879557  8.78569687  9.0116936   9.17893841  9.47642947\n",
            "  9.61585068  9.96726254 10.00489961 10.09997118 10.18914784 10.26650591\n",
            " 10.4149184  10.4510979  10.52032262 10.59082712 10.63844004 10.81723468\n",
            " 10.85805061 10.94100258 11.34970819 11.56227423 11.68391792 11.75117088\n",
            " 12.0264716  12.09980628 12.90037637 12.91947989 13.3767007  13.63126312\n",
            " 14.22419977 14.35457046 15.27901833 15.32489139 15.39882726 16.16121369\n",
            " 17.30793898 21.69165143 21.81313286 31.03400647]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<PIL.Image.Image image mode=L size=743x468 at 0x7FE31EE9EBE0>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Gaussian Area for Step 3 is: 207386\n",
            "[ 1.31187308  1.69565039  1.93711696  3.04775459  3.82802655  4.05624457\n",
            "  4.13771907  4.28710948  4.41362149  4.73877028  4.86998535  5.39113319\n",
            "  5.65974224  5.85500216  6.47596319  6.65798059  7.23693271  7.26837412\n",
            "  7.39180304  7.43412808  7.50041509  7.86998881  7.88082147  8.06280119\n",
            "  8.14502608  8.23198277  8.29606264  8.78569687  8.96939343  9.0116936\n",
            "  9.17893841  9.749966    9.96726254 10.00489961 10.09997118 10.19232159\n",
            " 10.26650591 10.4149184  10.63844004 10.99942339 11.27455235 11.34970819\n",
            " 11.56227423 11.75117088 11.86457628 12.0264716  12.91947989 12.96946907\n",
            " 14.34304446 15.06874478 15.27901833 15.42476241 15.92713761 16.62715833\n",
            " 16.82601556 17.30793898 17.4113438  19.52266905 20.19355315 21.17569908\n",
            " 21.69165143 21.81858186 22.53354295 22.95129688 26.22215396 30.4278365\n",
            " 30.76198877 31.03400647 33.96105846 34.90300626 40.84085278 45.2086072 ]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<PIL.Image.Image image mode=L size=743x468 at 0x7FE31EE9E240>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Gaussian Area for Step 4 is: 203419\n",
            "[  0.35894253   0.49844599   4.23598414   5.57995211   7.38238524\n",
            "   8.1934339   10.99942339  11.56227423  12.0264716   13.24941664\n",
            "  13.84233202  14.34304446  14.80406415  15.42476241  15.92713761\n",
            "  17.30793898  18.570455    19.54013429  21.41424202  21.81858186\n",
            "  22.53354295  23.04318564  26.93104909  27.92768334  29.97727337\n",
            "  30.4278365   31.03400647  31.72892296  35.46052899  36.29527326\n",
            "  52.27112191  67.60384081  67.99323679  72.69967315 101.01292079]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<PIL.Image.Image image mode=L size=743x468 at 0x7FE31EE9EE10>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Gaussian Area for Step 5 is: 173654\n",
            "[ 21.41424202  21.81858186  22.53354295  26.93104909  27.92768334\n",
            "  30.4278365   52.27112191  53.11429712  67.60384081  67.99323679\n",
            "  68.86815253  88.63359529 101.31523473 117.19918832 175.71548277\n",
            " 204.59624585]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<PIL.Image.Image image mode=L size=743x468 at 0x7FE31EE9E588>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Gaussian Area for Step 6 is: 147621\n",
            "[ 22.33698966  48.28922356  67.60384081  90.08383554 137.10348131\n",
            " 194.1940237  235.21995421]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<PIL.Image.Image image mode=L size=743x468 at 0x7FE31EE9E748>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Gaussian Area for Step 7 is: 5596\n",
            "[153.85635155 194.1940237 ]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<PIL.Image.Image image mode=L size=743x468 at 0x7FE31EE9E588>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Gaussian Area for Step 8 is: 0\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "IndexError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-732-9d423a0a5e5a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      7\u001b[0m   \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Gaussian Area for Step %d is: %d\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mGaussArea\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mctr\u001b[0m\u001b[0;34m)\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      8\u001b[0m   \u001b[0;31m# Print the K for threshold exploration and tuning\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m   \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0monePassDCE\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mctr\u001b[0m\u001b[0;34m)\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[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     10\u001b[0m   \u001b[0mshowContour\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mctr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-731-1ff748ce93fa>\u001b[0m in \u001b[0;36monePassDCE\u001b[0;34m(ctr)\u001b[0m\n\u001b[1;32m     94\u001b[0m   \u001b[0;31m# k_thresh = np.min(K)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     95\u001b[0m   \u001b[0;31m#k_thresh = 1.1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 96\u001b[0;31m   \u001b[0mk_thresh\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpercentile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munique\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mK\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m50\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     97\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     98\u001b[0m   \u001b[0mnew_ref\u001b[0m \u001b[0;34m=\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[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mpercentile\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/numpy/lib/function_base.py\u001b[0m in \u001b[0;36mpercentile\u001b[0;34m(a, q, axis, out, overwrite_input, interpolation, keepdims)\u001b[0m\n\u001b[1;32m   3704\u001b[0m         \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Percentiles must be in the range [0, 100]\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3705\u001b[0m     return _quantile_unchecked(\n\u001b[0;32m-> 3706\u001b[0;31m         a, q, axis, out, overwrite_input, interpolation, keepdims)\n\u001b[0m\u001b[1;32m   3707\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3708\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/numpy/lib/function_base.py\u001b[0m in \u001b[0;36m_quantile_unchecked\u001b[0;34m(a, q, axis, out, overwrite_input, interpolation, keepdims)\u001b[0m\n\u001b[1;32m   3824\u001b[0m     r, k = _ureduce(a, func=_quantile_ureduce_func, q=q, axis=axis, out=out,\n\u001b[1;32m   3825\u001b[0m                     \u001b[0moverwrite_input\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0moverwrite_input\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3826\u001b[0;31m                     interpolation=interpolation)\n\u001b[0m\u001b[1;32m   3827\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mkeepdims\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3828\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mq\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/numpy/lib/function_base.py\u001b[0m in \u001b[0;36m_ureduce\u001b[0;34m(a, func, **kwargs)\u001b[0m\n\u001b[1;32m   3401\u001b[0m         \u001b[0mkeepdim\u001b[0m \u001b[0;34m=\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[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3402\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3403\u001b[0;31m     \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\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   3404\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkeepdim\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3405\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/numpy/lib/function_base.py\u001b[0m in \u001b[0;36m_quantile_ureduce_func\u001b[0;34m(a, q, axis, out, overwrite_input, interpolation, keepdims)\u001b[0m\n\u001b[1;32m   3939\u001b[0m             \u001b[0mn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0misnan\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0map\u001b[0m\u001b[0;34m[\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[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   3940\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3941\u001b[0;31m         \u001b[0mx1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtake\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0map\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindices_below\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mweights_below\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3942\u001b[0m         \u001b[0mx2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtake\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0map\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindices_above\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mweights_above\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3943\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mtake\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/numpy/core/fromnumeric.py\u001b[0m in \u001b[0;36mtake\u001b[0;34m(a, indices, axis, out, mode)\u001b[0m\n\u001b[1;32m    192\u001b[0m            [5, 7]])\n\u001b[1;32m    193\u001b[0m     \"\"\"\n\u001b[0;32m--> 194\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0m_wrapfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'take'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindices\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmode\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    195\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    196\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/numpy/core/fromnumeric.py\u001b[0m in \u001b[0;36m_wrapfunc\u001b[0;34m(obj, method, *args, **kwds)\u001b[0m\n\u001b[1;32m     59\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     60\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 61\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mbound\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\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     62\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     63\u001b[0m         \u001b[0;31m# A TypeError occurs if the object does have such a method in its\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mIndexError\u001b[0m: cannot do a non-empty take from an empty axes."
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vmE4ySc33PyR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}