Wear analysys of sugarcane harvester knives.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementações necessárias"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Processamento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1.jpeg', '10.jpeg', '11.jpeg', '12.jpeg', '13.jpeg', '14.jpeg', '15.jpeg', '16.jpeg', '2.jpeg', '3.jpeg', '4.jpeg', '5.jpeg', '6.jpeg', '7.jpeg', '8.jpeg', '9.jpeg', 'Fotos_Facas.rar']\n",
      "Inserir o indice de posicao da imagem a ser processada = 3\n",
      "12.jpeg\n"
     ]
    }
   ],
   "source": [
    "# Importar dados \n",
    "import pandas as pd\n",
    "from os import listdir\n",
    "import numpy as np\n",
    "import cv2\n",
    "\n",
    "imagens = listdir(\"C:/UFV/Fotos/\")\n",
    "print imagens\n",
    "\n",
    "imagem = input(\"Inserir o indice de posicao da imagem a ser processada = \")\n",
    "imagem = imagens[imagem]\n",
    "print imagem\n",
    "\n",
    "caminho = \"C:/UFV/Fotos/\"+imagem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Amostragem iterativa\n",
    "        \n",
    "def coordenadas(Im, Im_Limiarizada, f = 0):  \n",
    "    \n",
    "    I = Im.copy()\n",
    "    I[np.where(Im_Limiarizada == 0)] = 100\n",
    "    \n",
    "    # Coordenada [x,y] quando acionado o botão direito\n",
    "    XY = list() \n",
    "\n",
    "    #função armazenará uma coordenada toda vez que o botão direito for acionado\n",
    "    def direito_down(evento, x, y, flags, params):\n",
    "        \n",
    "    # evento igual a 2 quando acionado botão direito\n",
    "        if evento == 2:            \n",
    "            ID_class = input(\"Class ID = \")\n",
    "        \n",
    "            if f == 0:\n",
    "                XY.append([x, y, ID_class])\n",
    "            else:          \n",
    "                x = range(x-f, x+f+1)\n",
    "                y = range(y-f, y+f+1)\n",
    "                for i in range(0, len(x)):\n",
    "                    for j in range(0, len(y)):\n",
    "                        XY.append([x[i], y[j], ID_class]) \n",
    "                        \n",
    "            I[(y-3):(y+3), (x-3):(x+3), :] = 255\n",
    "    \n",
    "    # Chamada toda vez que uma tecla do mouse é acionada\n",
    "    cv2.namedWindow('True Color Image')    \n",
    "    cv2.setMouseCallback('True Color Image', direito_down)  \n",
    "    \n",
    "    while True: \n",
    "        cv2.imshow('True Color Image', I)\n",
    "        k = cv2.waitKey(10) & 0XFF\n",
    "        if k == cv2.EVENT_RBUTTONDOWN:\n",
    "            break \n",
    "        elif k == ord(\"q\"):\n",
    "            break\n",
    "            cv2.waitKey()\n",
    "            cv2.destroyAllWindows()\n",
    "            \n",
    "    cv2.destroyAllWindows()\n",
    "    \n",
    "    amostras = pd.DataFrame(XY, columns = [\"x\", \"y\", \"Class\"])    \n",
    "    \n",
    "    return amostras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Função Discriminante \n",
    "def FD (X,Mu,C,P):\n",
    "    X = np.matrix(X)\n",
    "    I = np.linalg.inv(C)# Inversa da matriz de covariância\n",
    "    D = np.linalg.det(C)# Determinante da matriz de covariância\n",
    "    A = X-Mu\n",
    "    FD = -0.5*A*I*A.transpose()-0.5*np.log(1+D)+np.log(1+P)\n",
    "    return FD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample = cv2.imread(caminho,1)\n",
    "\n",
    "sample_gray = cv2.cvtColor(sample, cv2.COLOR_BGR2GRAY)\n",
    "\n",
    "cv2.imshow(\"sample true color\", cv2.resize(sample,(0,0),fx=0.3,fy=0.3))\n",
    "cv2.imshow(\"sample\", cv2.resize(sample_gray,(0,0),fx=0.3,fy=0.3))\n",
    "cv2.waitKey()\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.figure.Figure at 0x84c8b30>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Limiar ótimo pelo Otsu =  130.0\n"
     ]
    }
   ],
   "source": [
    "# Limiarizar imagem\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "plt.hist(sample_gray.ravel(), 255, [0,256])\n",
    "plt.show()\n",
    "\n",
    "thresh, sample_limiarizada = cv2.threshold(sample_gray,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)\n",
    "\n",
    "print 'Limiar ótimo pelo Otsu = ', thresh\n",
    "\n",
    "cv2.imshow(\"sample limiarizada\", cv2.resize(sample_limiarizada,(0,0),fx=0.3,fy=0.3))\n",
    "cv2.imshow(\"sample gray\", cv2.resize(sample_gray,(0,0),fx=0.3,fy=0.3))\n",
    "cv2.waitKey()\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remover ruídos\n",
    "sample_blur = cv2.medianBlur(sample_limiarizada, 5)\n",
    "EE = cv2.getStructuringElement(cv2.MORPH_ELLIPSE , (11,11))\n",
    "\n",
    "sample_blur = cv2.morphologyEx(sample_blur, cv2.MORPH_OPEN, EE)\n",
    "sample_blur = cv2.morphologyEx(sample_blur, cv2.MORPH_CLOSE, EE)\n",
    "\n",
    "cv2.imshow(\"sample blur\", cv2.resize(sample_blur,(0,0),fx=0.3,fy=0.3))\n",
    "cv2.imshow(\"Imagem corrigida\", cv2.resize(sample_blur,(0,0),fx=0.3,fy=0.3))\n",
    "\n",
    "cv2.waitKey()\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Preenchendo a imagem\n",
    "sample_blur_inv = cv2.bitwise_not(sample_blur)\n",
    "EE = cv2.getStructuringElement(cv2.MORPH_ELLIPSE , (11,11))\n",
    "sample_blur_inv = cv2.morphologyEx(sample_blur_inv,cv2.MORPH_CLOSE,EE)\n",
    "\n",
    "K_floodfill = sample_blur_inv.copy()\n",
    "h,w = sample.shape[:2]\n",
    "mask = np.zeros((h+2,w+2),np.uint8)\n",
    "\n",
    "cv2.floodFill(K_floodfill,mask,(0,0),255);\n",
    "K_floodfill_inv = cv2.bitwise_not(K_floodfill)\n",
    "F = sample_blur_inv|K_floodfill_inv\n",
    "\n",
    "cv2.imshow('Imagem Final', cv2.resize(F,(0,0),fx=0.3,fy=0.3))\n",
    "\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Número de objetos identificados = 1\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0xc1f8130>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Quantificar objetos (registrar ID's) para a imagem inteira\n",
    "sample_contours = F.copy()\n",
    "objeto, H = cv2.findContours(sample_contours, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n",
    "sample_etiquetada = np.zeros((sample.shape[0], sample.shape[1]), np.uint8)\n",
    "\n",
    "cont = 1\n",
    "marker = np.zeros((sample.shape[0], sample.shape[1]),dtype = np.int32)\n",
    "\n",
    "for i in xrange(len(objeto)):\n",
    "    mask = np.zeros((sample.shape[0], sample.shape[1]), np.uint8)    \n",
    "    cv2.drawContours(mask, objeto, i, (255,255,255), -1)\n",
    "    \n",
    "    sample_etiquetada[np.where(mask != 0)] = cont    \n",
    "    cont = cont+1\n",
    "    \n",
    "    cv2.drawContours(marker,objeto,i,i+2, -1)\n",
    "\n",
    "marker = marker + 1\n",
    "marker[objeto==255] = 0\n",
    "    \n",
    "print \"Número de objetos identificados =\", len(np.unique(sample_etiquetada[np.where(sample_etiquetada!= 0)]))\n",
    "\n",
    "imgplt = plt.imshow(marker)\n",
    "plt.title('Objetos Individualizados')\n",
    "plt.colorbar()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A coordenada X do centro é:  451\n",
      "A coordenada Y do centro é:  772\n",
      "As dimensões da imagem são:  960 1280\n"
     ]
    }
   ],
   "source": [
    "# Computar as coordenadas do centro do objeto\n",
    "sample_cp = sample.copy()\n",
    "for c in objeto:\n",
    "    M = cv2.moments(c)\n",
    "    cX = int(M[\"m10\"] / M[\"m00\"])\n",
    "    cY = int(M[\"m01\"] / M[\"m00\"])\n",
    "# draw the contour and center of the shape on the image\n",
    "    cv2.drawContours(sample_cp, [c], -1, (0, 255, 0), 2)\n",
    "    cv2.circle(sample_cp, (cX, cY), 7, (255, 255, 255), -1)\n",
    "    cv2.putText(sample_cp, \"center\", (cX - 20, cY - 20),\n",
    "        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2)\n",
    "    cv2.imshow(\"Image\", cv2.resize(sample_cp,(0,0),fx=0.6,fy=0.6))\n",
    "Iy = sample_cp.shape[0] # Dimensões da imagem no eixo y\n",
    "Ix = sample_cp.shape[1] # Dimensões da imagem no eixo x\n",
    "\n",
    "print 'A coordenada X do centro é: ',cX\n",
    "print 'A coordenada Y do centro é: ',cY\n",
    "print 'As dimensões da imagem são: ',Ix, Iy\n",
    "\n",
    "cv2.waitKey()\n",
    "cv2.destroyAllWindows() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dividir o objeto em quatro quadrantes\n",
    "Q1 = F[0:cY,0:cX]  # Quadrante superior esquerdo\n",
    "Q2 = F[0:cY,cX:Ix]  # Quadrante superior direito\n",
    "Q3 = F[cY:Iy,0:cX]  # Quadrante inferior esquerdo\n",
    "Q4 = F[cY:Iy,cX:Ix]  # Quadrante inferior direito\n",
    "Qc1 = sample[0:cY,0:cX]  # Quadrante superior esquerdo\n",
    "Qc2 = sample[0:cY,cX:Ix]  # Quadrante superior direito\n",
    "Qc3 = sample[cY:Iy,0:cX]  # Quadrante inferior esquerdo\n",
    "Qc4 = sample[cY:Iy,cX:Ix]  # Quadrante inferior direito\n",
    "\n",
    "cv2.imshow('Quadrante superior esquerdo', cv2.resize(Q1,(0,0),fx=0.6,fy=0.6))\n",
    "cv2.imshow('Quadrante superior direito', cv2.resize(Q2,(0,0),fx=0.6,fy=0.6))\n",
    "cv2.imshow('Quadrante inferior esquerdo', cv2.resize(Q3,(0,0),fx=0.6,fy=0.6))\n",
    "cv2.imshow('Quadrante inferior direito', cv2.resize(Q4,(0,0),fx=0.6,fy=0.6))\n",
    "\n",
    "cv2.waitKey()\n",
    "cv2.destroyAllWindows() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Número de objetos identificados em Q1 = 1\n",
      "Número de objetos identificados em Q2 = 1\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0xc405670>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Número de objetos identificados em Q3 = 1\n",
      "Número de objetos identificados em Q4 = 1\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAADxCAYAAADRGSCbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzt3X+w3XV95/HniySQghKEICI/hBZ2V+tIbDNAm+4oYCFYFdul3VCG0g5upjvSwZVV1J3R0bo72nbEtkppRhjQUZHlR8swSEgFpNbyIwHkV0RTypQ0aMwPIOgKJHntH9/PgZObc+753nvPj++59/VwvnPP+X6/93zfsfW87+fX+yPbRERETLTPqAOIiIhmSoKIiIiOkiAiIqKjJIiIiOgoCSIiIjpKgoiIiI6SICIixoSkhZLulfQ9SY9K+mSHe/aT9A1JGyTdI+mYtmsfLecfl3RGr+clQUREjI8XgFNtnwAsAZZLOnnCPRcA220fB1wKfBZA0puAFcAvA8uByyTNm+xhSRAREWPClefL2wXlmLja+Szg6vL6OuA0SSrnr7H9gu1/BTYAJ072vPl9izwiIvZyxikHeOu2XbXuXffQC48CP287tcr2qvZ7yl/964DjgC/avmfCxxwBPAVge6ekZ4FDyvm72+7bWM51lQQRETFAW7ft4t7VR9e6d97hP/y57aWT3WN7F7BE0kHAjZLebPuRtlvU6dcmOd9VupgiIgbIwO6a/5nS59rPAHdSjSe02wgcBSBpPrAI2NZ+vjgS2DTZM5IgIiIGyJiXvKvW0YukQ0vLAUm/ALwD+P6E224Czi+vzwZud1WV9SZgRZnldCxwPHDvZM9LF1NExIBNtXUwicOBq8s4xD7AtbZvlvQpYK3tm4ArgK9I2kDVclgBYPtRSdcCjwE7gfeX7qqulHLfERGD89YT9vW3v/m6WvcuOuKpdb3GIIYpLYiIiAHbPflYcGMlQUREDJCBXUkQERHRSVoQERGxFwMvjelYb6a5NpikP5T0sKSfSfqRpMskLSrXVpSCW89K2izpakkHjjrmiNiTMbtqHk2TBNFQki6mKrL1IaqFLicDxwC3SVoA/BOwzPYi4BepWoOfHk20EdGVYVfNo2mSIBqotAQ+CfyJ7Vttv2T7SeD3gGOB37f9lO0tbb+2i6o2S0Q0SLWSut7RNEkQzfTrwELghvaTpYrjN4HTAST9RinEtQP4L8DnhxxnRPQkdtU8miaD1M20GNhie2eHa08DvwJg+zvAIklHAP8NeHJoEUZELdUgdfO+/OtIC6KZtgCLS6GtiQ4HftJ+wva/A7cC1wwhtoiYgmodxHi2IJIgmumfqXaO+p32k5IOAM4Evt3hd+YDvzT40CJiqnZbtY6mSYJoINvPUg1S/7Wk5ZIWlH1l/y9V6+Krks6VdLQqbwD+N/CtkQUdER2NcwsiYxANZfvPJG0F/oJqdtJ+VC2Hd9j+adlf9rPAa4DtwC3AR0cVb0R0ZsSuMf1bfDyjniNsX2H7zbYXUm1E/kuUpG77f9k+0vYB5edK21tHGnBEdDSuXUwDaUFIWg78JTAP+JLtzwziOXOJ7SslvUQ1BfbfRh1PRNRjxIueN+owpqXvCaJsZPFF4Deptri7T9JNth/r97PmGttfGXUMETE11UK58eysGUTUJwIbbD9h+0WqqZdnDeA5ERFjIYPUrzgCeKrt/UbgpMl+YV/t54UcMIBQYqb+w1t+NuoQZuzJp15iy7ZdzftfX8wJttjl8WxBDCJBdPof4l5lqCStBFYCLGR/TtJpAwglZmr16gdHHcKMnXjGU71vihig3X1qHUg6Cvgy8Dqq8k2rbP/lhHs+BJxb3s4H3ggcanubpCepSvPsAnb22t50EAliI3BU2/sjgU0Tb7K9ClgFcKAObmAdw4iImasGqfv2VbsTuNj2/ZJeDayTtKZ9jNf2nwN/DiDp3cD/sL2t7TNOmVDos6tBtHvuA46XdKykfYEVwE0DeE5EROO1BqnrHD0/y37a9v3l9Q5gPVW3fjfnAF+fbux9TxClwNyFwGqq4K+1/Wi/nxMRMS52WbWOqSjVFd4K3NPl+v7AcuD6ttOm2lNmXenmn9RA1kHYvoVqZW9ExJw2xZXUiyWtbXu/qnTH70HSq6i++D9g+7kun/Vu4J8mdC8ts71J0muBNZK+b/uubsGk1EZExIDtrj+LaUuvgeOyo+T1wFdt3zDJrSuY0L1ke1P5uVnSjVTLEromiPGcexURMSaqYn371Dp6kSTgCmC97c9Nct8i4G3A37edO6AMbLcqQ58OPDLZ89KCiIgYICNe6l+pjWXAecDDklpz0D8GHA1g+/Jy7reB22z/tO13DwNurHIM84Gv2b51soclQUREDJBN3xbKlV0ke45m274KuGrCuSeAE6byvCSIiIiBUt8Wyg1bEkRExACZ/rUghm08o46IkZP0h5IelvQzST+SdFkZHJ143+2S3GWP9TmhX4PUw9a8iCKi8SRdTLWj4YeARcDJwDFUi7AWtN13LnO8p8LU2yyoiRsGJUFExJRIOpBqz/Q/sX2r7ZdsPwn8HnAs8PvlvkXAJ4APjyrWJjDwkufXOpomCSIipurXgYXAHou0bD8PfJNqfj3A/wH+BvjRUKNrnHp7QTRxP4gkiIiYqsVUK353drj2NHCopKVUc/b/eqiRNZCpVlLXOZqmeW2aiGi6LVQ1g+Z3SBKHA1uBy4CLbO8sC7PmtCa2DupoXsqKiKb7Z+AF4HfaT5byDWcCDwBLgW9I+hHVFgAAGyX952EG2gS20oKIiLnB9rOSPgn8taTngG9R7UlwGVXr4otUu561HAXcC/wq8JMhhzty1SB130ptDFUSRERMme0/k7QV+AvgOGA/4NvAO0r9n5drAElaWF7+uMu4xSw3vntSj2fUETFytq+w/WbbC4ELgF+iwx+dtp+0rbmZHFqD1FkHETHrSVou6XFJGyR9ZNTxNIXtK6mqiv76qGNponFdSZ0upoiaJM2j6l//TWAjcJ+km9o3jJ/LbH9l1DE0UWsl9ThqXsqKaK4TgQ22n7D9InANcNaIY4oxsJt9ah1NkxZERH1HAE+1vd8InDTxprIZ/EqAA/bXr/6n4/YdTnQ9/OCh/Ucdwqz0c37Ki36haxPBhpd2N+/Lv44kiIj6On0JeK8T1SbzqwCWnrDQ964+atBx1XLG65eMOoRZ6R5/a9LrVRdTEkTEbLeRak5/y5HAphHFEmNkXFdSJ0FE1HcfcLykY4F/B1ZQKpdGdNOa5jqOxrPdEzECZR7/hcBqYD1wre1HRxtVNF//Sm1IOkrSHZLWS3pU0kUd7nm7pGclPViOj7ddm9I07bQgIqbA9i3ALaOOI8ZLH/ek3glcbPt+Sa8G1kla02Gq9T/aflf7ielM0+6ZsiRdKWmzpEfazh0saY2kH5afrynnJemvSnZ6SNKv1P5nR0TMQtUspnm1jt6f5adt319e76BqyR5RM5QpT9Ou08V0FbB8wrmPAN+yfTxVoa5WU+VM4PhyrKTaLCQiYs6a4pajiyWtbTtWdvtcSccAbwXu6XD51yR9T9I3Jf1yOddpmvakyaVnF5Ptu0og7c4C3l5eXw3cCVxSzn/ZtoG7JR0k6XDbT/d6TkTEbDWFLqYttpf2uknSq4DrgQ/Yfm7C5fuBN9h+XtI7gb+j+qO91jTtdtMdpD6s9aVffr62nK+doSStbGXJl3hhmmFERDRbv4v1SVpAlRy+avuGiddtP1e2f22NmS2QtJhpTNPu9yB17QzVvpjoQB08aRaLiBhn/Voop2p7viuA9bY/1+We11GVVrekE6kaAluBZ5jiNO3pJogft7qOJB0ObC7ns5AoIqKNLXb2byX1MuA84GFJD5ZzHwOOrp7ly4Gzgf8uaSfw/4AVpdt/p6TWNO15wJW9pmlPN0HcBJwPfKb8/Pu28xdKuoaqRs2zGX+IiLmuXwvlbH+Hzj017fd8AfhCl2tTmqbdM0FI+jrVgPRiSRuBT1AlhmslXQD8G/C75fZbgHcCG4CfAX9UN5CIiNlonFdS15nFdE6XS6d1uNfA+2caVETEbDJrE0REREzfOG8YlAQRETFgfSy1MVRJEBERA2TDzmwYFBERnaSLKWad1Zse7H1TREwqYxAREdGVxzRBjGfHWEQfpJR9DMtuVOtomiSImMuuIqXsY8Ds/hbrG6YkiJizbN8FbJtw+iyqEvaUn+9tO/9lV+4GDip1yCJ6ELt271PraJrmRRQxWn0tZf+TrbsGGmyMB1u1jqZJgoioZ0ql7G0vtb300EN6byMZs1u/94MYpiSIiD39uNV1lFL20ReuxiHqHE2TBBGxp1Ype9i7lP0flNlMJ5NS9jEF4zqLKesgYs5KKfsYBpdB6nGUBBFzVkrZx7A0sfuojiSIiIgBa+IMpTrGs90TETEmqgHo/kxzlXSUpDskrZf0qKSLOtxzblnt/5Ck70o6oe3ak5IelvSgpLW9npcWRETEgPVxCutO4GLb90t6NbBO0hrbj7Xd86/A22xvl3QmsAo4qe36Kba31HlYEkRExID1awyizJxrLeTcIWk91YLNx9ru+W7br9xNNSV7WpIgIiIGyIjd9WcxLZ7Q9bPK9qpON0o6BngrcM8kn3cB8M09woHbJBn4226f3ZIEERExYFNoQGyxvbTXTZJeBVwPfMD2c13uOYUqQfxG2+lltjdJei2wRtL3S02yjjJIHRExSH0cpAaQtIAqOXzV9g1d7nkL8CXgLNtbXw7F3lR+bgZuBE6c7FlJEBERg+aaRw+SBFwBrLf9uS73HA3cAJxn+wdt5w8oA9tIOgA4HXik02e0pIspImLA+rgOYhlwHvCwpNaewB8Djq6e48uBjwOHAJdV+YSdpdvqMODGcm4+8DXbt072sCSIiIgBMrB7d38ShO3v0LmycPs97wPe1+H8E8AJe/9Gdz27mLotzMjWjBERNRiw6h0NU2cMorUw443AycD7Jb2JbM0YEVHLrC33bftp2/eX1zuA1sKMbM0YEVFHnwaph21KYxATFmbssTVjmVcL3bdm3KN2vqSVVC0MFrL/NEKPiBgHzdxOtI7a01zrLMxo3drh3F65sX1bxgXsVzeMiIjxM6YtiFoJosvCjGzNGGMtEzBiKAzerVpH09SZxdRtYUa2ZoxxlwkYMSSqeTRLnTGIbgszsjVjjLVJKmOeRbUVKVQTMO4ELqFtAgZwt6SDJB2eP4CipwZ2H9XRM0H0WJiRrRljVhjUBIyjj8ha1GBsE0RqMcWcN8gJGIceMq9fYca4muUL5SJmrUzAiGGYtQvlImarTMCIodmtekfDpIM05rJMwIihUANbB3UkQcSclQkYMRQNXQRXRxJERMRANXMAuo4kiIiIQUsLIiIiOto96gCmJwkiImKQWusgxlCmuUZEDJhc7+j5OV0KTE64p2tRSUnnlyKUP5R0/sTfnSgtiIiIQevfGESrwOT9kl4NrJO0xvZjbfe0F5U8iaqo5EmSDgY+ASwtEa2TdJPt7d0elhZERMSYmGSHz3bddvU8A1hje1tJCmuA5ZM9Ly2IiIgBm8JCucWS1ra9X2V7VcfP3LPAZLtuRSW7ne8qCSIiYpDMVMpobLG9tNdNPQpMdisqWavYZLt0MUVEDFoftxztUmCyXbeiklMuNpkEERExYH2cxdStwGS7bkUlVwOnS3pN2Ub39HKuq3QxRUQMWv9mMXUrMHk0gO3L6VJU0vY2SX8K3Fd+71O2t032sCSIiIhB61OC6FFgsnVP16KStq8Erqz7vCSIiIgBqtt91ERJEBERg9bAzYDqyCB1zFmSFkq6V9L3StmCT5bzx0q6p5Qj+Iakfcv5/cr7DeX6MaOMP8ZHvwaphy0JIuayF4BTbZ8ALAGWl1kfnwUutX08sB24oNx/AbDd9nHApeW+sXDG65eMOoS5rY/TXIcpCSLmrFKK4PnydkE5DJwKXFfOXw28t7w+q7ynXD+tTDuM6K5m6yEtiIiGkTSvTBfcTFWb5l+AZ2zvLLe0lyN4uVRBuf4scEiHz1wpaa2ktT/ZumvQ/4QYB2lBxGyyetODvW+aBWzvsr2EalXpicAbO91WftYqVWB7le2ltpceesi8/gUbY0u76x1N0zNBZCAv5gLbzwB3AidTVb9szfBrL0fwcqmCcn0RMOlCo4hxVqcFMWcG8mJukXSopIPK618A3kFVPvkO4Oxy2/nA35fXN5X3lOu3l0VJEZObrV1MGciLWexw4A5JD1GVH1hj+2bgEuCDkjZQjTFcUe6/AjiknP8g8JERxBzjZowHqWstlJM0D1gHHAd8kSkM5ElqDeRtmfCZK4GVAAvZf2b/iohpsP0QVT39ieefoBqPmHj+58DvDiG0mG0a+OVfR61B6kEP5C1gv7rxRkSMn9naxdQuA3kR4yeL5EZLzO5ZTBnIi4iYrlk+BnE4cHUZh9gHuNb2zZIeA66R9GngAfYcyPtKGcjbBqwYQNwREeOjgV/+dfRMEBnIi4iYodmaICIiYmaa2H1URxJERMSgJUFERNNkBlMDuH8zlCRdCbwL2Gz7zR2ufwg4t7ydT7Uk4dCyH/WTwA5gF7DT9tJez0uxvoiIQevfOoirgOVdH2P/ue0lZd3aR4Fv225fZnBKud4zOUBaEBGzVloPzdGvMQjbd02hAOo5wNdn8ry0ICIiBq1+C2Jxay+RcqyczuMk7U/V0rh+QhS3SVpX93PTgoiIGKSpldHYUrf7p4d3A/80oXtpme1Nkl4LrJH0fdt3TfYhaUFERAyQGMlK6hVM6F6yvan83AzcSId1bBMlQUREDNgwE4SkRcDbeKX8EZIOkPTq1mvgdOCRXp+VLqaIiEHr35f/14G3U41VbAQ+QbVHD7YvL7f9NnCb7Z+2/ephwI1la575wNds39rreUkQMaeVGmNrgX+3/S5JxwLXAAcD9wPn2X5R0n7Al4FfBbYC/9X2kyMKO8ZN/2YxnVPjnquopsO2n3sCOGGqz0sXU8x1F1FVJ26ZFVvpZoprg4xxNdckiJizJB0J/BbwpfJeZCvdGIS5sGFQxCzzeeDDQKsQwiHU3EoXaG2luxdJK1vz2H+yddegYo8xMms3DIqYjSS16tmsaz/d4dYpbaULe26ne+gh82YY6dSle6l5xrWLKYPUMVctA94j6Z3AQuBAqhbFQZLml1ZCp610N2Yr3ZiShnYf1ZEWRMxJtj9q+0jbx1AtKrrd9rlkK90YhIxBRMwKlwAfLFvmHsKeW+keUs5/EPjIiOKbVLqXmmdEK6n7Il1MMefZvhO4s7we2610kxyaS7sb+O1fQxJExCyQ5NBgDe0+qiMJImKMJTGMhyZ2H9WRBBExBL2+yFdverCvnxcNkwQRERP94KH9a32Zt98zWbJIYhhPaUFERF8kCcxCY5ogak9zlTRP0gOSbi7vj5V0j6QfSvqGpH3L+f3K+w3l+jGDCT0iYgx4bpTamJVVLyMiBmmc10HUShCpehkRMQN2vaNh6rYgBlL1Mpor/eAR/TNrWxCDqnrZXhL5JV6oFWxExNipW4dpHBMEr1S9fJJqK8ZTaat6We7pVPWSyapetpdEXsB+M/pHxGCkFRHRH/0apJZ0paTNkh7pcv3tkp6V9GA5Pt52bbmkx8sEolq1xHomiFS9nNuSJCJmro+zmK4Clve45x9tLynHp+Dlvde/CJwJvAk4R9Kbej1sJtVcx7rqZdSXJBExA6Zvg9S272J6+5CcCGyw/YTtF6l6g87q9UtTWig3W6peRkQM0xQGoBdLWtv2fpXtVVN83K9J+h5Vt///tP0obZOHio3ASb0+KCupo5YzXr9kyvWCIqKonyC22F46gyfdD7zB9vNlt8S/A45nClvmtsuGQVHbbOxqkvSkpIfLgN7acu5gSWtKlYA1kl5TzkvSX5VBvock/cpoo49xMMyFcrafs/18eX0LsEDSYtomDxXtE4u6SoKIKTnj9UtmY6I4pQzotf5y+wjwrVIl4Fu8Mo52JtVfY8cDK4G/GXqkMX5stLveMVOSXtdamCzpRKrv+K3AfcDxpUTSvlQTjm7q9XlJEDEtszBJtGuvBjCxSsCXXbmbaqr34aMIMMZMn9ZBSPo68M/Af5S0UdIFkv5Y0h+XW84GHiljEH8FrCj//7oTuBBYTVUy6doyNjGpjEHEtM2ScQkDt0ky8LdlQPAw208D2H5a0mvLvZ0G+o4Anm7/QEkrqVoYLGT/AYcf46Bfq6Rtn9Pj+heAL3S5dgtwy1SelwQRM9JqSYxxolhme1NJAmskfX+Se2sN9JUkswrgQB2cNUBznYHsSR1zWd0Nb5rG9qbyc7OkG6mmbv9Y0uGl9XA4sLncPuWBvh1sf/4ffN3jAwh9WBYDW0YdxDQNK/Y39LxjPPNDEkT03zDHJ2aSjCQdAOxje0d5fTrwKV6pBvAZ9q4ScKGka6jmkD/b6oqaxOMznLY4UpLWjmv8TYq9iYX46kiCiLFWJxn9wFu7XToMuLFM+pgPfM32rZLuA66VdAHwb7yy8PMW4J3ABuBnwB/NKPiYM/oxQ2kUkiBizirVAE7ocH4rcFqH8wbeP4TQYjZpaKXWOpIgIgZrqmUSmmac429E7NVCufHMEEkQEQM0jTo6jTLO8Tcq9gbuN11HEkRExIClBREREXsb4zGIlNqIGIDp7N41bJKOknSHpPWSHpV0UTk/VsUKJc2T9ICkm8v7YyXdU+L/Rqk9hKT9yvsN5foxw4lweLWY+i0JIqLPprt71wjsBC62/UbgZOD9Jc5xK1Z4EVV9oZbPApeW+LcDF5TzFwDbbR8HXFruG44+bRg0bEkQEf03rd27hs3207bvL693UH3JHsEYFSuUdCTwW8CXynsBpwLXlVsmxt/6d10HnNaqfDpQ7uuWo0OVBBHRf92K+jVW6W55K3APE4oVAr2KFY7S54EP88o8oUOAZ0r1UtgzxpfjL9efLfcPXloQEVFMa/euUZH0KuB64AO2n5vs1g7nRvbvkvQuYLPtde2nO9zqGtcGq0/lvocts5gi+m9au3eNgqQFVMnhq7ZvKKf7VqxwwJYB7ylbay4EDqRqURwkaX5pJbTH2Ip/o6T5wCJg2zAC1e4G9h/VkBZERP9Na/euYSv971cA621/ru1Sq1gh7F2s8A/KbKaTqVescGBsf9T2kbaPofrv+Hbb5wJ3UG2cA3vH3/p3nV3uH/zf7abqAKtzNExaEBF9ZnunpNbuXfOAK+vs3jUCy4DzgIcltcrifoyqiu04Fyu8BLhG0qeBB6iSIOXnVyRtoGo5rBhGMMJZKBcRr5jO7l3DZvs7dO6XhzErVmj7TuDO8voJqplkE+/5Oa8ku+Ea0wSRLqaIiEHr0ywmSVdK2izpkS7Xzy2LGB+S9F1JJ7Rde1LSw5IelLS2TthJEBERg9TfMYirgOWTXP9X4G223wL8KXtXtD3F9pK6GynVShCdMs+4LcePiBgV7d5d6+jF9l1MMvPK9ndtby9v76aaxTVtU2lBTMw847YcPyJiBGp2L/V/nOIC4Jt7BsJtktZJWlnnA2YySH0W8Pby+mqqAaJLaFuOD9wt6aDWnOoZPCsiYjyZqXz5L54wPrBqOvtaSDqFKkH8RtvpZbY3SXotsEbS90uLpKu6CaKVeQz8bQl4j+X45aHQfTn+HgmiZLCVAAvZv2YYERFjqP4ahy11xwe6kfQWqtpUZ5btcwGwvan83CzpRqqZXn1JEHtlnsni63Bur/RZkswqgAN18HjOAYuIqGFY6yAkHQ3cAJxn+wdt5w8A9rG9o7w+HfhUr8+rlSC6ZJ5xWY4fETFafUoQkr5O1bW/WNJG4BPAguoRvhz4OFUBwstKodqdpUVyGHBjOTcf+JrtW3s9r2eCmCTztJatf4a9l7NfKOka4CRqLMffwfbn/8HXPd4rliFYDGwZdRA0I44mxAD9ieMN/QgkYlps2NWfOhq2z+lx/X3A+zqcfwI4Ye/fmFydFkTHzCPpPvq3HP/xmfa79YOktYmjOTE0KY6IGRnTldQ9E0S3zFMGP8ZqOX5ExEjM1gQREREzYKCB+03X0ZQEMeV5vgOSOF7RhBigOXFETJPBDazlXUMjEsR0FoIMQuJoVgzQnDgips30bZB62BqRICIiZrWMQUREREdjmiBGXu5b0nJJj5fqrx/p/RszetZetdSHXZVW0lGS7pC0XtKjki4aURwLJd0r6Xsljk+W88dKuqfE8Y2yZSaS9ivvN5Trx/QjjvLZ8yQ9IOnmUcUQMTgjK9Y3YyNNEJLmAV+kqgD7JuAcSW8a4COvYu9a6sOuSrsTuNj2G4GTgfeXf/Ow43gBONX2CcASYLmqfYY/C1xa4thOVfCL8nO77eOAS8t9/XIRsL7t/ShiiBgMA7t31zsaZtQtiBOBDbafsP0icA1VNdiB6FJL/SyqarSUn+9tO/9lV+4GDiolRWYaw9O27y+vd1B9MR4xgjhs+/nydkE5DJwKXNcljlZ81wGnqayenAlJRwK/RVVcjPKZQ40hYuDSgpiWbpVfh2mPqrRAr6q0fVO6SN4K3DOKOErXzoNUdbTWAP8CPGN7Z4dnvRxHuf4sVc2Xmfo88GFeqXd5yAhiiBigUmqjztEwo04QtSq/jshAY5P0KuB64AO2nxtFHLZ32V5CVVDxROCNkzyr73FIehew2fa69tPDjCFi4Az27lpH04w6QTSh8uuPW102w6pKK2kBVXL4qu0bRhVHi+1nqDZ8OpmqC6s1u639WS/HUa4vYpKtD2taBrxH0pNU3YunUrUohhlDxODtdr2jYUadIO4Dji+zVvYFVlBVgx2mVlVa2Lsq7R+UWUQnU6MqbR2lz/wKYL3tz40wjkMlHVRe/wLwDqrxkDuAs7vE0YrvbOD2Undr2mx/1PaRto+h+r/97bbPHWYMEUMxpmMQI10HYXunpAuB1cA84Erbjw7qeepcS/0z9K8qbR3LgPOAh0v/P8DHRhDH4cDVZSbZPsC1tm+W9BhwjaRPAw9QJTPKz69I2kD1V/uKPsXRySUNiCGiP+xGzlCqQ/kDLCJicBbNW+xfO+Ddte5dveOqdU0qb5+V1BERA2W8a9eog5iWJIiIiEFKue+IiOiqgVNmKVvTAAABF0lEQVRY6xj1LKaIiFnNgHe71tFLp3pyE653rd0m6fxS3+yHks7v9PsTJUFERAySy4ZBdY7ermLvenLtOtZuk3Qw1azNk6gWxX6iVRB0MkkQERED5l27ah09P6dzPbl23Wq3nQGssb3N9naq0jqTJRogYxAREQO1g+2r/8HXLa55+0JJa9ver5rirordardNq6ZbEkRExADZ7vmXeh91q1c2rTpm6WKKiJg9utVum1ZNtySIiIjZo1vtttXA6ZJeUwanTy/nJpUupoiIMdGlntwCANuX06V2m+1tkv6UqkAqwKds96yEnFpMERHRUbqYIiKioySIiIjoKAkiIiI6SoKIiIiOkiAiIqKjJIiIiOgoCSIiIjr6/+yuxJvqoSAAAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0xc54aab0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Quantificar objetos (registrar ID's) para os quadrantes\n",
    "# Quadrante superior esquerdo\n",
    "o1, H = cv2.findContours(Q1, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n",
    "etiqueta1 = np.zeros((Q1.shape[0], Q1.shape[1]), np.uint8)\n",
    "\n",
    "cont = 1\n",
    "marker1 = np.zeros((Q1.shape[0], Q1.shape[1]),dtype = np.int32)\n",
    "\n",
    "for i in xrange(len(o1)):\n",
    "    mask = np.zeros((Q1.shape[0], Q1.shape[1]), np.uint8)    \n",
    "    cv2.drawContours(mask, o1, i, (255,255,255), -1)\n",
    "    \n",
    "    etiqueta1[np.where(mask != 0)] = cont    \n",
    "    cont = cont+1\n",
    "    \n",
    "    cv2.drawContours(marker1,o1,i,i+2, -1)\n",
    "\n",
    "marker1 = marker1 + 1\n",
    "marker1[o1==255] = 0\n",
    "\n",
    "print \"Número de objetos identificados em Q1 =\", len(np.unique(etiqueta1[np.where(etiqueta1!= 0)]))\n",
    "\n",
    "# Quadrante superior direito\n",
    "o2, H = cv2.findContours(Q2, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n",
    "etiqueta2 = np.zeros((Q2.shape[0], Q2.shape[1]), np.uint8)\n",
    "\n",
    "cont = 1\n",
    "marker2 = np.zeros((Q2.shape[0], Q2.shape[1]),dtype = np.int32)\n",
    "\n",
    "for i in xrange(len(o2)):\n",
    "    mask = np.zeros((Q2.shape[0], Q2.shape[1]), np.uint8)    \n",
    "    cv2.drawContours(mask, o2, i, (255,255,255), -1)\n",
    "    \n",
    "    etiqueta2[np.where(mask != 0)] = cont    \n",
    "    cont = cont+1\n",
    "    \n",
    "    cv2.drawContours(marker2,o2,i,i+2, -1)\n",
    "\n",
    "marker2 = marker2 + 1\n",
    "marker2[o2==255] = 0\n",
    "    \n",
    "print \"Número de objetos identificados em Q2 =\", len(np.unique(etiqueta2[np.where(etiqueta2!= 0)]))\n",
    "\n",
    "plt.subplot(121), plt.imshow(marker1)\n",
    "plt.title('Q1')\n",
    "plt.subplot(122), plt.imshow(marker2)\n",
    "plt.title('Q2')\n",
    "plt.colorbar()\n",
    "plt.show()\n",
    "\n",
    "# Quadrante inferior esquerdo\n",
    "o3, H = cv2.findContours(Q3, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n",
    "etiqueta3 = np.zeros((Q3.shape[0], Q3.shape[1]), np.uint8)\n",
    "\n",
    "cont = 1\n",
    "marker3 = np.zeros((Q3.shape[0], Q3.shape[1]),dtype = np.int32)\n",
    "\n",
    "for i in xrange(len(o3)):\n",
    "    mask = np.zeros((Q3.shape[0], Q3.shape[1]), np.uint8)    \n",
    "    cv2.drawContours(mask, o3, i, (255,255,255), -1)\n",
    "    \n",
    "    etiqueta3[np.where(mask != 0)] = cont    \n",
    "    cont = cont+1\n",
    "    \n",
    "    cv2.drawContours(marker3,o3,i,i+2, -1)\n",
    "\n",
    "marker3 = marker3 + 1\n",
    "marker3[o3==255] = 0\n",
    "    \n",
    "print \"Número de objetos identificados em Q3 =\", len(np.unique(etiqueta3[np.where(etiqueta3!= 0)]))\n",
    "\n",
    "# Quadrante inferior direito\n",
    "o4, H = cv2.findContours(Q4, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n",
    "etiqueta4 = np.zeros((Q4.shape[0], Q4.shape[1]), np.uint8)\n",
    "\n",
    "cont = 1\n",
    "marker4 = np.zeros((Q4.shape[0], Q4.shape[1]),dtype = np.int32)\n",
    "\n",
    "for i in xrange(len(o4)):\n",
    "    mask = np.zeros((Q4.shape[0], Q4.shape[1]), np.uint8)    \n",
    "    cv2.drawContours(mask, o4, i, (255,255,255), -1)\n",
    "    \n",
    "    etiqueta4[np.where(mask != 0)] = cont    \n",
    "    cont = cont+1\n",
    "    \n",
    "    cv2.drawContours(marker4,o4,i,i+2, -1)\n",
    "\n",
    "marker4 = marker4 + 1\n",
    "marker4[o4==255] = 0\n",
    "    \n",
    "print \"Número de objetos identificados em Q4 =\", len(np.unique(etiqueta4[np.where(etiqueta4!= 0)]))\n",
    "\n",
    "plt.subplot(121), plt.imshow(marker3)\n",
    "plt.title('Q3')\n",
    "plt.subplot(122), plt.imshow(marker4)\n",
    "plt.title('Q4')\n",
    "plt.colorbar()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Criar dataframe para armazenar descritores de forma\n",
    "ID = range(0,4)\n",
    "\n",
    "Descritores_Forma = pd.DataFrame({\"ID\" : ID, \"Perimetro\" : 0, \"Comprimento\" : 0, \"Area\" : 0, \"Retangularidade\" : 0})\n",
    "\n",
    "Descritores_Forma = Descritores_Forma[[\"ID\", \"Perimetro\", \"Comprimento\", \"Area\", \"Retangularidade\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   ID    Perimetro  Comprimento     Area  Retangularidade\n",
      "0   0  1106.254833   143.999969  59688.0         0.959491\n",
      "1   1  1134.213203   152.999969  63705.5         0.972841\n",
      "2   2  1006.811182   150.999969  63798.5         0.966835\n",
      "3   3   997.580734   145.999969  60312.5         0.941001\n"
     ]
    }
   ],
   "source": [
    "# Calcular descritores de forma\n",
    "for i in (np.unique(Descritores_Forma.ID)):        \n",
    "    if i==0:\n",
    "        # Criar uma máscara colorida\n",
    "        m1 = np.zeros((Q1.shape[0], Q1.shape[1], 3), np.uint8)  \n",
    "        # Desenhar objeto\n",
    "        cv2.drawContours(m1, o1, (i), (255,255,255), -1)\n",
    "        #cv2.imshow(\"objeto %d\" %i, mask)\n",
    "        cv2.waitKey()\n",
    "        cv2.destroyAllWindows()\n",
    "    \n",
    "        # Calcular os inputs dos descritores:\n",
    "        # Área\n",
    "        Area1 = cv2.contourArea(o1[i], False)\n",
    "\n",
    "        # Perímetro\n",
    "        Perimetro1 = cv2.arcLength(o1[i], False)\n",
    "\n",
    "        # Mínimo Retângulo Envolvente\n",
    "        Retangulo_Envolvente1 = cv2.minAreaRect(o1[i])\n",
    "        E_maior1 = max(Retangulo_Envolvente1[1])\n",
    "        E_menor1 = min(Retangulo_Envolvente1[1])\n",
    "\n",
    "        Box1 = cv2.cv.BoxPoints(Retangulo_Envolvente1)\n",
    "        Box1 = np.int0(Box1)\n",
    "    \n",
    "        Mask_Retangulo_Envolvente1 = m1.copy()\n",
    "        cv2.drawContours(Mask_Retangulo_Envolvente1, [Box1], 0, (255,0,0), 2)  \n",
    "        \n",
    "        # Obter os descritores e registrar seus valores\n",
    "    \n",
    "        # 0 - Perímetro\n",
    "        Descritores_Forma.loc[Descritores_Forma[\"ID\"] == (i), \"Perimetro\"] = Perimetro1\n",
    "    \n",
    "        # 1 - Comprimento\n",
    "        Descritores_Forma.loc[Descritores_Forma[\"ID\"] == (i), \"Comprimento\"] = E_menor1\n",
    "    \n",
    "        # 2 - Área\n",
    "        Descritores_Forma.loc[Descritores_Forma[\"ID\"] == (i), \"Area\"] = Area1   \n",
    "    \n",
    "        # 3 - Retangularidade = Area/(L1*L2)\n",
    "        Retangularidade1 = Area1/(E_maior1*E_menor1)\n",
    "        Descritores_Forma.loc[Descritores_Forma[\"ID\"] == (i), \"Retangularidade\"] = Retangularidade1\n",
    "\n",
    "        cv2.waitKey()\n",
    "        cv2.destroyAllWindows()\n",
    "        \n",
    "    elif i==1:\n",
    "        # Criar uma máscara colorida\n",
    "        m2 = np.zeros((Q2.shape[0], Q2.shape[1], 3), np.uint8)  \n",
    "        # Desenhar objeto\n",
    "        cv2.drawContours(m2, o2, -1, (255,255,255), -1)\n",
    "        #cv2.imshow(\"objeto %d\" %i, mask)\n",
    "        cv2.waitKey()\n",
    "        cv2.destroyAllWindows()\n",
    "    \n",
    "        # Calcular os inputs dos descritores:\n",
    "        # Área\n",
    "        Area2 = cv2.contourArea(o2[0], False)\n",
    "\n",
    "        # Perímetro\n",
    "        Perimetro2 = cv2.arcLength(o2[0], False)\n",
    "\n",
    "        # Mínimo Retângulo Envolvente\n",
    "        Retangulo_Envolvente2 = cv2.minAreaRect(o2[0])\n",
    "        E_maior2 = max(Retangulo_Envolvente2[1])\n",
    "        E_menor2 = min(Retangulo_Envolvente2[1])\n",
    "\n",
    "        Box2 = cv2.cv.BoxPoints(Retangulo_Envolvente2)\n",
    "        Box2 = np.int0(Box2)\n",
    "    \n",
    "        Mask_Retangulo_Envolvente2 = m2.copy()\n",
    "        cv2.drawContours(Mask_Retangulo_Envolvente2, [Box2], 0, (255,0,0), 2)  \n",
    "        \n",
    "        # Obter os descritores e registrar seus valores\n",
    "    \n",
    "        # 0 - Perímetro\n",
    "        Descritores_Forma.loc[Descritores_Forma[\"ID\"] == (i), \"Perimetro\"] = Perimetro2\n",
    "    \n",
    "        # 1 - Comprimento\n",
    "        Descritores_Forma.loc[Descritores_Forma[\"ID\"] == (i), \"Comprimento\"] = E_menor2\n",
    "    \n",
    "        # 2 - Área\n",
    "        Descritores_Forma.loc[Descritores_Forma[\"ID\"] == (i), \"Area\"] = Area2   \n",
    "    \n",
    "        # 3 - Retangularidade = Area/(L1*L2)\n",
    "        Retangularidade2 = Area2/(E_maior2*E_menor2)\n",
    "        Descritores_Forma.loc[Descritores_Forma[\"ID\"] == (i), \"Retangularidade\"] = Retangularidade2\n",
    "\n",
    "        cv2.waitKey()\n",
    "        cv2.destroyAllWindows()\n",
    "        \n",
    "    elif i==2:\n",
    "        # Criar uma máscara colorida\n",
    "        m3 = np.zeros((Q3.shape[0], Q3.shape[1], 3), np.uint8)  \n",
    "        # Desenhar objeto\n",
    "        cv2.drawContours(m3, o3,-1, (255,255,255), -1)\n",
    "        #cv2.imshow(\"objeto %d\" %i, mask)\n",
    "        cv2.waitKey()\n",
    "        cv2.destroyAllWindows()\n",
    "    \n",
    "        # Calcular os inputs dos descritores:\n",
    "        # Área\n",
    "        Area3 = cv2.contourArea(o3[0], False)\n",
    "\n",
    "        # Perímetro\n",
    "        Perimetro3 = cv2.arcLength(o3[0], False)\n",
    "\n",
    "        # Mínimo Retângulo Envolvente\n",
    "        Retangulo_Envolvente3 = cv2.minAreaRect(o3[0])\n",
    "        E_maior3 = max(Retangulo_Envolvente3[1])\n",
    "        E_menor3 = min(Retangulo_Envolvente3[1])\n",
    "\n",
    "        Box3 = cv2.cv.BoxPoints(Retangulo_Envolvente3)\n",
    "        Box3 = np.int0(Box3)\n",
    "    \n",
    "        Mask_Retangulo_Envolvente3 = m3.copy()\n",
    "        cv2.drawContours(Mask_Retangulo_Envolvente3, [Box3], 0, (255,0,0), 2)  \n",
    "        \n",
    "        # Obter os descritores e registrar seus valores\n",
    "    \n",
    "        # 0 - Perímetro\n",
    "        Descritores_Forma.loc[Descritores_Forma[\"ID\"] == (i), \"Perimetro\"] = Perimetro3\n",
    "    \n",
    "        # 1 - Comprimento\n",
    "        Descritores_Forma.loc[Descritores_Forma[\"ID\"] == (i), \"Comprimento\"] = E_menor3\n",
    "    \n",
    "        # 2 - Área\n",
    "        Descritores_Forma.loc[Descritores_Forma[\"ID\"] == (i), \"Area\"] = Area3\n",
    "    \n",
    "        # 3 - Retangularidade = Area/(L1*L2)\n",
    "        Retangularidade3 = Area3/(E_maior3*E_menor3)\n",
    "        Descritores_Forma.loc[Descritores_Forma[\"ID\"] == (i), \"Retangularidade\"] = Retangularidade3\n",
    "\n",
    "        cv2.waitKey()\n",
    "        cv2.destroyAllWindows()\n",
    "        \n",
    "    elif i==3:\n",
    "        # Criar uma máscara colorida\n",
    "        m4 = np.zeros((Q4.shape[0], Q4.shape[1], 3), np.uint8)  \n",
    "        # Desenhar objeto\n",
    "        cv2.drawContours(m4, o4,-1, (255,255,255), -1)\n",
    "        #cv2.imshow(\"objeto %d\" %i, mask)\n",
    "        cv2.waitKey()\n",
    "        cv2.destroyAllWindows()\n",
    "    \n",
    "        # Calcular os inputs dos descritores:\n",
    "        # Área\n",
    "        Area4 = cv2.contourArea(o4[0], False)\n",
    "\n",
    "        # Perímetro\n",
    "        Perimetro4 = cv2.arcLength(o4[0], False)\n",
    "\n",
    "        # Mínimo Retângulo Envolvente\n",
    "        Retangulo_Envolvente4 = cv2.minAreaRect(o4[0])\n",
    "        E_maior4 = max(Retangulo_Envolvente4[1])\n",
    "        E_menor4 = min(Retangulo_Envolvente4[1])\n",
    "\n",
    "        Box4 = cv2.cv.BoxPoints(Retangulo_Envolvente4)\n",
    "        Box4 = np.int0(Box4)\n",
    "    \n",
    "        Mask_Retangulo_Envolvente4 = m4.copy()\n",
    "        cv2.drawContours(Mask_Retangulo_Envolvente4, [Box4], 0, (255,0,0), 2)  \n",
    "        \n",
    "        # Obter os descritores e registrar seus valores\n",
    "    \n",
    "        # 0 - Perímetro\n",
    "        Descritores_Forma.loc[Descritores_Forma[\"ID\"] == (i), \"Perimetro\"] = Perimetro4\n",
    "    \n",
    "        # 1 - Comprimento\n",
    "        Descritores_Forma.loc[Descritores_Forma[\"ID\"] == (i), \"Comprimento\"] = E_menor4\n",
    "    \n",
    "        # 2 - Área\n",
    "        Descritores_Forma.loc[Descritores_Forma[\"ID\"] == (i), \"Area\"] = Area4   \n",
    "    \n",
    "        # 3 - Retangularidade = Area/(L1*L2)\n",
    "        Retangularidade4 = Area4/(E_maior4*E_menor4)\n",
    "        Descritores_Forma.loc[Descritores_Forma[\"ID\"] == (i), \"Retangularidade\"] = Retangularidade4\n",
    "\n",
    "        cv2.waitKey()\n",
    "        cv2.destroyAllWindows()\n",
    "\n",
    "print Descritores_Forma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class ID = 2\n",
      "Class ID = 1\n",
      "Class ID = 1\n",
      "Class ID = 2\n",
      "     x    y  Class\n",
      "0  224  268      2\n",
      "    x    y  Class\n",
      "0  71  303      1\n",
      "     x    y  Class\n",
      "0  203  100      1\n",
      "    x    y  Class\n",
      "0  55  121      2\n"
     ]
    }
   ],
   "source": [
    "# Coletar amostras (buffer de amostragem = \"f\")\n",
    "# Classe 1 - Faca Boa; Classe 2 - Faca Ruim \n",
    "dados_aux1 = coordenadas(cv2.resize(Qc1,(0,0),fx=0.6,fy=0.6), cv2.resize(Q1,(0,0),fx=0.6,fy=0.6))\n",
    "dados_aux2 = coordenadas(cv2.resize(Qc2,(0,0),fx=0.6,fy=0.6), cv2.resize(Q2,(0,0),fx=0.6,fy=0.6))\n",
    "dados_aux3 = coordenadas(cv2.resize(Qc3,(0,0),fx=0.6,fy=0.6), cv2.resize(Q3,(0,0),fx=0.6,fy=0.6))\n",
    "dados_aux4 = coordenadas(cv2.resize(Qc4,(0,0),fx=0.6,fy=0.6), cv2.resize(Q4,(0,0),fx=0.6,fy=0.6))\n",
    "print dados_aux1\n",
    "print dados_aux2\n",
    "print dados_aux3\n",
    "print dados_aux4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ID's amostrados =  [0] \n",
      "\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "append() takes at most 3 arguments (4 given)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0mTraceback (most recent call last)",
      "\u001b[1;32m<ipython-input-23-b6e0d96b90d4>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     38\u001b[0m              \u001b[0mdados_aux2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     39\u001b[0m              \u001b[0mdados_aux3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 40\u001b[1;33m              dados_aux4)\n\u001b[0m\u001b[0;32m     41\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     42\u001b[0m \u001b[0mrep\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconcat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mdados_aux1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdados_aux2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdados_aux3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdados_aux4\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mloc\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m  \u001b[0mdados_aux4\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcolumns\u001b[0m \u001b[1;33m!=\u001b[0m \u001b[1;34m\"ID\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: append() takes at most 3 arguments (4 given)"
     ]
    }
   ],
   "source": [
    "# Integrar dados aos ID's\n",
    "amostragem1 = np.zeros((cv2.resize(Qc1,(0,0),fx=0.6,fy=0.6).shape[0], cv2.resize(Qc1,(0,0),fx=0.6,fy=0.6).shape[1]), np.uint8)\n",
    "amostragem1[dados_aux1.y, dados_aux1.x] = 255\n",
    "\n",
    "amostragem2 = np.zeros((cv2.resize(Qc2,(0,0),fx=0.6,fy=0.6).shape[0], cv2.resize(Qc2,(0,0),fx=0.6,fy=0.6).shape[1]), np.uint8)\n",
    "amostragem2[dados_aux2.y, dados_aux2.x] = 255\n",
    "\n",
    "amostragem3 = np.zeros((cv2.resize(Qc3,(0,0),fx=0.6,fy=0.6).shape[0], cv2.resize(Qc3,(0,0),fx=0.6,fy=0.6).shape[1]), np.uint8)\n",
    "amostragem3[dados_aux3.y, dados_aux3.x] = 255\n",
    "\n",
    "amostragem4 = np.zeros((cv2.resize(Qc4,(0,0),fx=0.6,fy=0.6).shape[0], cv2.resize(Qc4,(0,0),fx=0.6,fy=0.6).shape[1]), np.uint8)\n",
    "amostragem4[dados_aux4.y, dados_aux4.x] = 255\n",
    "\n",
    "cv2.waitKey()\n",
    "cv2.destroyAllWindows()\n",
    "print \"ID's amostrados = \", np.unique(sample_etiquetada[dados_aux.y, dados_aux.x]), \"\\n\"\n",
    "\n",
    "# Tornar compatível indices dos dados_aux e repositório\n",
    "dados_aux1[\"ID\"] = sample_etiquetada[dados_aux1.y, dados_aux1.x]\n",
    "dados_aux2[\"ID\"] = sample_etiquetada[dados_aux2.y, dados_aux2.x]\n",
    "dados_aux3[\"ID\"] = sample_etiquetada[dados_aux3.y, dados_aux3.x]\n",
    "dados_aux4[\"ID\"] = sample_etiquetada[dados_aux4.y, dados_aux4.x]\n",
    "indices_compativeis1 = dados_aux1.ID-1\n",
    "indices_compativeis2 = dados_aux2.ID-1\n",
    "indices_compativeis3 = dados_aux3.ID-1\n",
    "indices_compativeis4 = dados_aux4.ID-1\n",
    "dados_aux1 = dados_aux1.set_index(indices_compativeis1)\n",
    "dados_aux2 = dados_aux2.set_index(indices_compativeis2)\n",
    "dados_aux3 = dados_aux3.set_index(indices_compativeis3)\n",
    "dados_aux4 = dados_aux4.set_index(indices_compativeis4)\n",
    "\n",
    "del dados_aux1.index.name\n",
    "del dados_aux2.index.name\n",
    "del dados_aux3.index.name\n",
    "del dados_aux4.index.name\n",
    "\n",
    "p = np.append(dados_aux1,\n",
    "             dados_aux2,\n",
    "             dados_aux3,\n",
    "             dados_aux4)\n",
    "\n",
    "rep = pd.concat([dados_aux1, dados_aux2, dados_aux3, dados_aux4.loc[:,  dados_aux4.columns != \"ID\"]], axis = 1)\n",
    "\n",
    "print p "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exportar dados \n",
    "\n",
    "import re\n",
    "amostra = re.split(r'\\.(?!\\d)', imagem)[0]\n",
    "amostra = np.int(amostra)\n",
    "print amostra\n",
    "\n",
    "chave = input(\"Definir amostra como 0 (Faca de referencia) ou 1 (Faca para avaliacao):\")\n",
    "\n",
    "if chave == 0:\n",
    "    Descritores_Forma.to_excel(\"C:/UFV/Dados_faca/Ref/dados_%d.xlsx\" %amostra, index = False)\n",
    "else:\n",
    "    Descritores_Forma.to_excel(\"C:/UFV/Dados_faca/Ava/dados_%d.xlsx\" %amostra, index = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importar dados de avaliacao\n",
    "amostras = listdir(\"C:/UFV/Dados_faca/Ava/\")\n",
    "avaliacao = pd.DataFrame()\n",
    "\n",
    "for i in xrange(len(amostras)):\n",
    "    dados_i = pd.read_excel(\"C:/UFV/Dados_faca/Ava/\"+amostras[i])\n",
    "    \n",
    "    avaliacao = avaliacao.append(dados_i, ignore_index = True)\n",
    "\n",
    "Rang = range(0,56)\n",
    "Class = pd.DataFrame({\"Classe\" : 1}, index=Rang)\n",
    "Class = Class[[\"Classe\"]]\n",
    "repositorio_ava = pd.concat([Class, avaliacao.loc[:, avaliacao.columns]], axis = 1)\n",
    "\n",
    "print \"Dados de Avaliacao\\n\"\n",
    "print repositorio_ava"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importar dados de referencia \n",
    "amostras = listdir(\"C:/UFV/Dados_faca/Ref/\")\n",
    "referencia = pd.DataFrame()\n",
    "\n",
    "for i in xrange(len(amostras)):\n",
    "    dados_i = pd.read_excel(\"C:/UFV/Dados_faca/Ref/\"+amostras[i])\n",
    "    \n",
    "    referencia = referencia.append(dados_i, ignore_index = True)\n",
    "\n",
    "Class2 = pd.DataFrame({\"Classe\" : 0}, index = referencia.ID)\n",
    "Class2 = Class2[[\"Classe\"]]\n",
    "repositorio_ref = pd.concat([Class2, referencia.loc[:, referencia.columns]], axis = 1)\n",
    "\n",
    "print \"Dados de Referencia\\n\"\n",
    "print repositorio_ref"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%% Blade reconstitution (trigonometric approach)\n",
    "\n",
    "%Houghlines\n",
    "IH = edge(Igray,'canny',T);\n",
    "[HI,TI,RI] = hough(IH);\n",
    "PI = houghpeaks(HI,10,'threshold',10);\n",
    "lI = houghlines(Igray,TI,RI,PI);% ,'FillGap',20,'MinLength',20)\n",
    "\n",
    "%Store theta and rho values\n",
    "for i=1:length(lI)\n",
    "    tr(i,1) = lI(i).theta;\n",
    "    if tr(i,1) == 0\n",
    "        tr(i,1) = 0.0001;\n",
    "    end\n",
    "    tr(i,2) = lI(i).rho;\n",
    "end\n",
    "\n",
    "%Select only two vertical and two horizontal lines (most colinear points)\n",
    "cv = 0;\n",
    "ch = 0;\n",
    "for i=1:length(tr)\n",
    "    if tr(i,1) < 10 && tr(i,1) > -10 && cv<2 %criteria vert theta low\n",
    "        cv = cv+1;\n",
    "        trn(cv,1) = tr(i,1);\n",
    "        trn(cv,2) = tr(i,2);\n",
    "        trn(cv,3) = lI(i).point1(1);\n",
    "        trn(cv,4) = lI(i).point1(2);\n",
    "        trn(cv,5) = lI(i).point2(1);\n",
    "        trn(cv,6) = lI(i).point2(2);\n",
    "    end\n",
    "        if tr(i,1) < -70 && ch <2 %criteria hor theta high\n",
    "        ch = ch+1;\n",
    "        trn(2+ch,1) = tr(i,1);\n",
    "        trn(2+ch,2) = tr(i,2);\n",
    "        trn(2+ch,3) = lI(i).point1(1);\n",
    "        trn(2+ch,4) = lI(i).point1(2);\n",
    "        trn(2+ch,5) = lI(i).point2(1);\n",
    "        trn(2+ch,6) = lI(i).point2(2);\n",
    "    end\n",
    "end\n",
    "\n",
    "%Sorts vector\n",
    "if trn(1,3)>trn(2,3)\n",
    "        arm(1,:) = trn(1,:);\n",
    "        trn(1,:)=trn(2,:);\n",
    "        trn(2,:)=arm(1,:);\n",
    "end\n",
    "    \n",
    "figure, imshow(If), colormap gray;\n",
    "hold on\n",
    "\n",
    "%Plot selected lines over binary image\n",
    "for i=1:size(trn,1)\n",
    "    xy = [trn(i,3),trn(i,4); trn(i,5),trn(i,6)]; %store coordinates in xy vector\n",
    "    plot(xy(:,1),xy(:,2),'--','LineWidth',2,'Color','red'); %plot lines\n",
    "    hold on\n",
    "end\n",
    "\n",
    "% Find intersections between lines(x coordinates)\n",
    "drti3 = (trn(3,2)/sind(trn(3,1)))-(trn(1,2)/sind(trn(1,1)));\n",
    "tgi13 = 1/(1/tand(trn(3,1))-1/tand(trn(1,1)));\n",
    "i13 = drti3*tgi13;\n",
    "\n",
    "drti4 = (trn(4,2)/sind(trn(4,1)))-(trn(1,2)/sind(trn(1,1)));\n",
    "tgi14 = 1/(1/tand(trn(4,1))-1/tand(trn(1,1)));\n",
    "i14 = drti4*tgi14;\n",
    "\n",
    "drt23 = (trn(2,2)/sind(trn(2,1)))-(trn(3,2)/sind(trn(3,1)));\n",
    "tgi23 = 1/(1/tand(trn(2,1))-1/tand(trn(3,1)));\n",
    "i23 = drt23*tgi23;\n",
    "\n",
    "drt24 = (trn(2,2)/sind(trn(2,1)))-(trn(4,2)/sind(trn(4,1)));\n",
    "tgi24 = 1/(1/tand(trn(2,1))-1/tand(trn(4,1)));\n",
    "i24 = drt24*tgi24;\n",
    "\n",
    "% Find intersections between lines(y coordinates)\n",
    "y13 = (trn(1,2)-i13*cosd(trn(1,1)))/sind(trn(1,1));\n",
    "y14 = (trn(1,2)-i14*cosd(trn(1,1)))/sind(trn(1,1));\n",
    "y23 = (trn(2,2)-i23*cosd(trn(2,1)))/sind(trn(2,1));\n",
    "y24 = (trn(2,2)-i24*cosd(trn(2,1)))/sind(trn(2,1));\n",
    "\n",
    "%Stores intersection coordinates in vector\n",
    "g(1,1) = i13;\n",
    "g(1,2) = y13;\n",
    "g(2,1) = i23;\n",
    "g(2,2) = y23;\n",
    "g(3,1) = i24;\n",
    "g(3,2) = y24;\n",
    "g(4,1) = i14;\n",
    "g(4,2) = y14;\n",
    "g(5,1) = i13;\n",
    "g(5,2) = y13;\n",
    "\n",
    "vetint(1,1) = i13;\n",
    "vetint(1,2) = y13;\n",
    "vetint(2,1) = i23;\n",
    "vetint(2,2) = y23;\n",
    "vetint(3,1) = i24;\n",
    "vetint(3,2) = y24;\n",
    "vetint(4,1) = i14;\n",
    "vetint(4,2) = y14;\n",
    "vetint = sortrows(vetint);\n",
    "\n",
    "if vetint(1,2)<vetint(2,2)\n",
    "IE(1,1) = vetint(1,1);\n",
    "IE(1,2) = vetint(1,2);\n",
    "IE(2,1) = vetint(2,1);\n",
    "IE(2,2) = vetint(2,2);\n",
    "else\n",
    "IE(1,1) = vetint(2,1);\n",
    "IE(1,2) = vetint(2,2);\n",
    "IE(2,1) = vetint(1,1);\n",
    "IE(2,2) = vetint(1,2);\n",
    "end\n",
    "\n",
    "if vetint(3,2)<vetint(4,2)\n",
    "IE(3,1) = vetint(3,1);\n",
    "IE(3,2) = vetint(3,2);\n",
    "IE(4,1) = vetint(4,1);\n",
    "IE(4,2) = vetint(4,2);\n",
    "else\n",
    "IE(3,1) = vetint(4,1);\n",
    "IE(3,2) = vetint(4,2);\n",
    "IE(4,1) = vetint(3,1);\n",
    "IE(4,2) = vetint(3,2);\n",
    "end\n",
    "\n",
    "%Plot intersected lines\n",
    "imshow(If);\n",
    "hold on\n",
    "plot(g(:,1),g(:,2),'-','color','k')\n",
    "\n",
    "close Figure 2\n",
    "%Fill up the gaps (Blade reconstitution)\n",
    "x = [IE(1,1) IE(2,1) IE(4,1) IE(3,1)];\n",
    "y = [IE(1,2) IE(2,2) IE(4,2) IE(3,2)];\n",
    "patch(x,y,'black')\n",
    "%Saves reconstitude blade\n",
    "saveas(gcf,'HR.png')\n",
    "HR = imread('C:\\Users\\Guilherme\\Dropbox\\PRODUÇÕES\\ARTIGOS\\A publicar\\Image Processing\\Códigos\\HR.png');\n",
    "HR = im2bw(HR);\n",
    "imshow(HR);\n",
    "\n",
    "%% Distance between actual and reconstitude blade (crack detection)\n",
    "\n",
    "%x y left line equation\n",
    "a1 = (trn(1,3)-trn(1,5))/(trn(1,4)-trn(1,6));\n",
    "b1 = trn(1,3)-trn(1,4)*a1;\n",
    "\n",
    "%Measures distance between houghline and actual blade --> crack detection\n",
    "y = ceil(IE(1,2))+20;\n",
    "x = ceil(IE(1,1));\n",
    "c=1;\n",
    "for i=1:(IE(2,2)-y)\n",
    "    dfe(i) = 0;\n",
    "end\n",
    "\n",
    "while y < IE(2,2)-30\n",
    "    while If(y,x)~=0\n",
    "        dfe(c)=dfe(c)+1;\n",
    "        x=x+1;\n",
    "    end\n",
    "    c=c+1;\n",
    "    y=y+1;\n",
    "    x=ceil(a1*y+b1);\n",
    "end\n",
    "\n",
    "%x y right line equation\n",
    "a2 = (trn(2,3)-trn(2,5))/(trn(2,4)-trn(2,6));\n",
    "b2 = trn(2,3)-a2*trn(2,4);\n",
    "\n",
    "%Measures distance between houghline and actual blade --> crack detection\n",
    "y = ceil(IE(3,2))+20;\n",
    "x = ceil(IE(3,1));\n",
    "\n",
    "c=1;\n",
    "for i=1:(IE(4,2)-y)\n",
    "    dfd(i) = 0;\n",
    "end\n",
    "\n",
    "while y < IE(4,2)-20\n",
    "    while If(y,x)~=0\n",
    "        dfd(c)=dfd(c)+1;\n",
    "        x=x-1;\n",
    "    end\n",
    "    c=c+1;\n",
    "    y=y+1;\n",
    "    x=ceil(a2*y+b2);\n",
    "end\n",
    "\n",
    "%% BLADE GEOMETRIC PROPERTIES\n",
    "\n",
    "stats = regionprops(If,'Area','Centroid','Perimeter','MajorAxisLength','MinorAxisLength');\n",
    "for i=1:length(stats)\n",
    "    info(i,1) = stats(i).Centroid(1);\n",
    "    info(i,2) = stats(i).Centroid(2);\n",
    "    info(i,3) = stats(i).Area;\n",
    "    info(i,4) = stats(i).Perimeter;\n",
    "    info(i,5) = stats(i).MajorAxisLength;\n",
    "    info(i,6) = stats(i).MinorAxisLength;\n",
    "end\n",
    "\n",
    "If = imcomplement(If);\n",
    "stats = regionprops(If,'Area','Centroid','Perimeter','MajorAxisLength','MinorAxisLength');\n",
    "for i=1:length(stats)\n",
    "    info2(i,1) = stats(i).Centroid(1);\n",
    "    info2(i,2) = stats(i).Centroid(2);\n",
    "    info2(i,3) = stats(i).Area;\n",
    "    info2(i,4) = stats(i).Perimeter;\n",
    "    info2(i,5) = stats(i).MajorAxisLength;\n",
    "    info2(i,6) = stats(i).MinorAxisLength;\n",
    "end\n",
    "great = 0;\n",
    "for i=1:length(stats)\n",
    "    if info2(i,3)>great\n",
    "        great=info2(i,3)\n",
    "        pos = i\n",
    "    end\n",
    "end\n",
    "info(1,:) = info2(pos,:);\n",
    "imshow(If)\n",
    "hold on\n",
    "plot(info(:,1),info(:,2),'rx');\n",
    "\n",
    "%% Divide imagem\n",
    "close Figure 1\n",
    "%Superior left corner\n",
    "for i=1:ceil(info(1,2))\n",
    "    for j=1:ceil(info(1,1))\n",
    "        SUPLEFT(i,j) = If(i,j);\n",
    "    end\n",
    "end\n",
    "\n",
    "imshow(SUPLEFT)\n",
    "\n",
    "%Superior right corner\n",
    "for i=1:ceil(info(1,2))\n",
    "    for j=ceil(info(1,1)):size(If,2)\n",
    "        SUPRIGHT(i,j) = If(i,j);\n",
    "    end\n",
    "end\n",
    "%imshow(SUPRIGHT)\n",
    "\n",
    "%Inferior left corner\n",
    "for i=1:ceil(info(1,2))\n",
    "    for j=ceil(info(1,1)):size(If,1)-1\n",
    "        INFLEFT(i,j) = If(i,j);\n",
    "    end\n",
    "end\n",
    "imshow(INFLEFT)\n",
    "break\n",
    "for i=1:info(1,2)\n",
    "    for j=1:info(1,1)\n",
    "        SUPRIGTH(i,j) = If(i,j);\n",
    "    end\n",
    "end\n",
    "imshow(SUPRIGTH);\n",
    "\n",
    "%% Extra\n",
    "\n",
    "% [centers, radii] = imfindcircles(If,[23 32],'ObjectPolarity','bright','Sensitivity',0.93);\n",
    "% figure, imshow(If)\n",
    "% viscircles(centers, radii,'EdgeColor','r');\n",
    "% hold on\n",
    "% for i=1:size(centers,1)\n",
    "%     txt{i} = num2str(i);\n",
    "%     plot(centers(i,1),centers(i,2),'x');\n",
    "%     text(centers(i,1),centers(i,2),txt{i},'color','r');\n",
    "% end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calcular probabilidade de cada classe\n",
    "treinamento_length = treinamento.shape[0]\n",
    "Probabilidades = list()\n",
    "\n",
    "for i in np.unique(treinamento.Class):\n",
    "    class_i = treinamento.loc[treinamento[\"Class\"] == i,\"Class\"]\n",
    "    class_i = len(class_i)\n",
    "    \n",
    "    prob_i = class_i/float(treinamento_length)\n",
    "    \n",
    "    Probabilidades.insert(i, prob_i)\n",
    "    \n",
    "#Probabilidades = [0.33, 0.33, 0.33]\n",
    "print Probabilidades"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Separar conjunto de treinamento para cada defeito\n",
    "treinamento_classe = list()\n",
    "\n",
    "for i in np.unique(treinamento.Class):    \n",
    "    treinamento_classe_i = treinamento.loc[treinamento[\"Class\"] == i, :] \n",
    "    treinamento_classe_i = treinamento_classe_i.iloc[:,treinamento_classe_i.columns != \"ID\"]\n",
    "    \n",
    "    treinamento_classe.insert(i, treinamento_classe_i)    \n",
    "    \n",
    "print treinamento_classe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Gerar matrizes de covariancia e vetores medios com dados de treinamento\n",
    "# Classes: normais, quebrados, pretos + verdes, cascas\n",
    "Cov_Matrix = list()\n",
    "Vetor_Medio = list()\n",
    "\n",
    "for i in xrange(len(treinamento_classe)):\n",
    "    treinamento_classe_i = treinamento_classe[i]     \n",
    "    treinamento_classe_i = pd.DataFrame(treinamento_classe_i)\n",
    "    treinamento_classe_i = treinamento_classe_i.loc[:, treinamento_classe_i.columns != \"Class\"]\n",
    "    treinamento_classe_i = treinamento_classe_i.T\n",
    "    #print treinamento_classe_i, \"\\n\"  \n",
    "    \n",
    "    treinamento_classe_i = treinamento_classe_i.as_matrix()\n",
    "    #print treinamento_classe_i, \"\\n\"\n",
    "        \n",
    "    Cov_Matrix_i = np.cov(treinamento_classe_i)\n",
    "    #print Cov_Matrix_i, \"\\n\"\n",
    "    Cov_Matrix.insert(i, Cov_Matrix_i)\n",
    "    \n",
    "    Vetor_Medio_i = np.average(treinamento_classe_i,1)# Vetor médio\n",
    "    #print Vetor_Medio_i, \"\\n\"\n",
    "    \n",
    "    Vetor_Medio.insert(i, Vetor_Medio_i)\n",
    "\n",
    "#print Cov_Matrix[0], \"\\n\"\n",
    "#print Vetor_Medio[0], \"\\n\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importar dados de validacao\n",
    "amostras = listdir(\"C:/UFV/2 Semestre/ENG 639/Trabalho/Dados/Validacao/\")\n",
    "validacao = pd.DataFrame()\n",
    "\n",
    "for i in xrange(len(amostras)):\n",
    "    validacao_i = pd.read_excel(\"C:/UFV/2 Semestre/ENG 639/Trabalho/Dados/Validacao/\"+amostras[i])\n",
    "    \n",
    "    validacao = validacao.append(validacao_i, ignore_index = True)\n",
    "    \n",
    "print validacao"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Separar conjunto de validacao para cada defeito\n",
    "validacao_classe = list()\n",
    "ID = list()\n",
    "\n",
    "for i in np.unique(validacao.Class):    \n",
    "    validacao_classe_i = validacao.loc[validacao[\"Class\"] == i, :] \n",
    "    validacao_classe_i = validacao_classe_i.reset_index(drop=True)\n",
    "    #print validacao_classe_i\n",
    "    \n",
    "    ID_i = validacao_classe_i.loc[:,\"ID\"]\n",
    "    ID.insert(i, ID_i)\n",
    "    \n",
    "    validacao_classe_i = validacao_classe_i.iloc[:,validacao_classe_i.columns != \"ID\"]    \n",
    "    validacao_classe.insert(i, validacao_classe_i)\n",
    "       \n",
    "#print validacao_classe\n",
    "#print ID"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Processar matriz de validacao para adequar a FD\n",
    "Matrix_Validacao = list()\n",
    "\n",
    "for i in xrange(len(validacao_classe)):\n",
    "    validacao_classe_i = validacao_classe[i]     \n",
    "    validacao_classe_i = pd.DataFrame(validacao_classe_i)\n",
    "    validacao_classe_i = validacao_classe_i.loc[:, validacao_classe_i.columns != \"Class\"]\n",
    "    validacao_classe_i = validacao_classe_i.T\n",
    "    #print validacao_classe_i, \"\\n\"  \n",
    "    \n",
    "    validacao_classe_i = validacao_classe_i.as_matrix()\n",
    "    #print matrix_classe_i, \"\\n\"    \n",
    "    \n",
    "    Matrix_Validacao.insert(i, validacao_classe_i)\n",
    "    \n",
    "#print Matrix_Validacao"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Criar um repositório para resultado da classificacao\n",
    "Classificacao = pd.DataFrame({\"Class\" : validacao.Class, \"ID\" : validacao.ID})\n",
    "\n",
    "for i in np.unique(validacao.Class):\n",
    "    class_i = [0]*len(validacao.Class)\n",
    "    Classificacao_i = pd.DataFrame({\"%d\" %i : class_i})\n",
    "    \n",
    "    Classificacao = pd.concat([Classificacao, Classificacao_i], axis=1)\n",
    "\n",
    "print Classificacao"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Aplicar classificar nas imagens de validacao   \n",
    "for i in xrange(len(Matrix_Validacao)): # i define a matriz de validacao das classes\n",
    "    \n",
    "    Matrix_Validacao_i = Matrix_Validacao[i]\n",
    "    \n",
    "    for j in xrange(len(Vetor_Medio)): # j define as classes de defeitos\n",
    "        \n",
    "        Vetor_Medio_j = Vetor_Medio[j]        \n",
    "        Cov_Matrix_j = Cov_Matrix[j]\n",
    "        Probabilidades_j = Probabilidades[j]    \n",
    "        \n",
    "        for k in range(0,Matrix_Validacao_i.shape[1]): # k define o objeto que está sendo classificado na matriz i\n",
    "            FD_ij = FD(Matrix_Validacao_i[:,k], Vetor_Medio_j, Cov_Matrix_j, Probabilidades_j)  \n",
    "            \n",
    "            ID_i = ID[i][k]\n",
    "            \n",
    "            coluna = str(j+1)           \n",
    "            \n",
    "            Classificacao.loc[Classificacao[\"ID\"] == ID_i, Classificacao.columns == coluna] = FD_ij\n",
    "            \n",
    "            #if k == 0:\n",
    "                #print \"ID = \", ID_i \n",
    "                #print \"Matriz validacao = \", i+1\n",
    "                #print \"Classe = \", j+1\n",
    "                #print FD_ij\n",
    "            \n",
    "                #print Classificacao, \"\\n\"\n",
    "\n",
    "print Classificacao    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adicionar uma coluna no objeto classificacao com a classe final dos objetos\n",
    "for i in xrange(Classificacao.shape[0]):    \n",
    "    valores_i = Classificacao.iloc[i, 2:(len(Classificacao))].astype('float64')\n",
    "    Classificacao.loc[i, \"Classe\"] = valores_i.idxmax()\n",
    "    \n",
    "print Classificacao"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Criar a matriz de confusao\n",
    "Matriz_Confusao = pd.DataFrame({\"Classe\" : np.append(np.unique(Classificacao.Class), [\"Total\", \"Acuracia Classificador\", \"EO\"], axis=0)})\n",
    "\n",
    "for i in np.unique(Classificacao.Class):\n",
    "    Matriz_Confusao[str(i)] = 0   \n",
    "    \n",
    "Matriz_Confusao[\"Total\"] = 0\n",
    "Matriz_Confusao[\"Acuracia Usuario\"] = 0\n",
    "Matriz_Confusao[\"EC\"] = 0\n",
    "\n",
    "print Matriz_Confusao"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Computar a matriz de confusao\n",
    "\n",
    "for i in np.unique(Classificacao.Class):\n",
    "    amostras = len(Classificacao.Class[Classificacao.Class == i])\n",
    "    amostras_classificadas = len(Classificacao.Classe[Classificacao.Classe == str(i)])\n",
    "    \n",
    "    Matriz_Confusao.loc[Matriz_Confusao[\"Classe\"] == \"Total\", str(i)] = amostras\n",
    "    Matriz_Confusao.loc[Matriz_Confusao[\"Classe\"] == str(i), \"Total\"] = amostras_classificadas\n",
    "    \n",
    "    for j in np.unique(Classificacao.Classe):        \n",
    "        amostras_i = Classificacao.loc[Classificacao[\"Class\"] == i, \"Classe\"]\n",
    "        teste = amostras_i[amostras_i == str(j)]\n",
    "        amostras_ij = teste.count()\n",
    "        Matriz_Confusao.loc[Matriz_Confusao[\"Classe\"] == str(i), str(j)] = amostras_ij\n",
    "        #print i\n",
    "        #print j\n",
    "        #print amostras_ij\n",
    "        #print Matriz_Confusao\n",
    "        \n",
    "print Matriz_Confusao"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calcular exatidao global, acuracias, erros de omissao e comissao\n",
    "N = np.sum(Matriz_Confusao.Total)\n",
    "\n",
    "for i in np.unique(Classificacao.Class):    \n",
    "    amostras_ii = Matriz_Confusao.loc[Matriz_Confusao[\"Classe\"] == str(i), str(i)]     \n",
    "    contador_ii = amostras_ii.values\n",
    "    \n",
    "    # Acuracia do classificador para classe \"i\"\n",
    "    total_i = Matriz_Confusao.loc[Matriz_Confusao[\"Classe\"] == \"Total\", str(i)]\n",
    "    acuracia_classificador_i = contador_ii/total_i*100\n",
    "    acuracia_classificador_i = acuracia_classificador_i.values\n",
    "    \n",
    "    Matriz_Confusao.loc[Matriz_Confusao[\"Classe\"] == \"Acuracia Classificador\", str(i)] = acuracia_classificador_i\n",
    "    \n",
    "    # Acuracia do usuario para a classe \"i\"\n",
    "    total_j = Matriz_Confusao.loc[Matriz_Confusao[\"Classe\"] == str(i), \"Total\"]\n",
    "    acuracia_usuario_i = contador_ii/total_j*100\n",
    "    acuracia_usuario_i = acuracia_usuario_i.values\n",
    "    \n",
    "    Matriz_Confusao.loc[Matriz_Confusao[\"Classe\"] == str(i), \"Acuracia Usuario\"] = acuracia_usuario_i\n",
    "    \n",
    "    # Erros de omissao\n",
    "    EO = 100 - acuracia_classificador_i\n",
    "    Matriz_Confusao.loc[Matriz_Confusao[\"Classe\"] == \"EO\", str(i)] = EO\n",
    "    \n",
    "    # Erros de comissao\n",
    "    EC = 100 - acuracia_usuario_i\n",
    "    Matriz_Confusao.loc[Matriz_Confusao[\"Classe\"] == str(i), \"EC\"] = EC\n",
    "    \n",
    "    if i == 1:\n",
    "        contador = contador_ii\n",
    "    else:\n",
    "        contador = contador + contador_ii\n",
    "        \n",
    "\n",
    "#Matriz_Confusao.loc[Matriz_Confusao[\"Classe\"] == \"Total\", \"Total\"] = contador/N*100\n",
    "print Matriz_Confusao"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calcular kappa\n",
    "kappa_aux = Matriz_Confusao.iloc[0:3,1:4]\n",
    "kappa_aux = kappa_aux.as_matrix()\n",
    "vetor_amostras = kappa_aux[kappa_aux.shape[0]-1,:]\n",
    "vetor_classificadas = kappa_aux[:,kappa_aux.shape[1]-1]\n",
    "\n",
    "N_diagonal = np.sum(N*kappa_aux.diagonal())\n",
    "produto = np.sum(vetor_amostras*vetor_classificadas)\n",
    "\n",
    "kappa = (N_diagonal - produto)/((N**2) - produto)\n",
    "\n",
    "print kappa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mostrar amostras antes da classificacao\n",
    "r = [255,0,0]\n",
    "g = [0,255,0]\n",
    "b = [0,0,255]\n",
    "\n",
    "mask = np.zeros((sample.shape[0], sample.shape[1], 3), np.uint8)\n",
    "amostras_originais = mask.copy()\n",
    "\n",
    "for i in np.unique(Classificacao.Class):\n",
    "    ID_class_i = Classificacao.loc[Classificacao[\"Class\"] == i, \"ID\"]\n",
    "    ID_class_i = np.array(ID_class_i)\n",
    "    \n",
    "    for j in xrange(len(ID_class_i)):        \n",
    "        amostras_originais[np.where(sample_etiquetada == ID_class_i[j]-1)] = r[i], g[i], b[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mostrar amostras classificadas\n",
    "r = [255,0,0]\n",
    "g = [0,255,0]\n",
    "b = [0,0,255]\n",
    "\n",
    "mask = np.zeros((sample.shape[0], sample.shape[1], 3), np.uint8)\n",
    "amostras_classificadas = mask.copy()\n",
    "\n",
    "print Classificacao\n",
    "\n",
    "for i in np.unique(Classificacao.Classe):\n",
    "    ID_classe_i = Classificacao.loc[Classificacao[\"Classe\"] == str(i), \"ID\"]\n",
    "    ID_classe_i = np.array(ID_classe_i)\n",
    "    \n",
    "    for j in xrange(len(ID_classe_i)): \n",
    "        amostras_classificadas[np.where(sample_etiquetada == ID_classe_i[j]-1)] = r[int(i)], g[int(i)], b[int(i)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cv2.imshow(\"Amostras Originais\", amostras_originais)\n",
    "cv2.imshow(\"Amostras Classificadas\", amostras_classificadas)\n",
    "cv2.waitKey()\n",
    "cv2.destroyAllWindows()   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MC=np.array([[60,20,52,14],[4,11,12,8],[18,2,79,6],[0,8,0,14]])\n",
    "\n",
    "c=MC.shape[0]\n",
    "\n",
    "SC=np.sum(MC,0)\n",
    "SL=np.sum(MC,1)\n",
    "\n",
    "EG=np.float(np.sum(np.diagonal(MC,0)))/np.sum(MC)*100\n",
    "\n",
    "Kappa=np.float(np.sum(np.diagonal(MC,0)))*np.sum(MC)\n",
    "Kappa=Kappa-np.sum(SC*SL)\n",
    "Kappa=Kappa/(np.sum(MC)**2-np.sum(SC*SL))\n",
    "\n",
    "Theta1=np.float(np.sum(np.diagonal(MC,0)))/np.sum(MC)\n",
    "Theta2=np.float(np.sum(SC*SL))/np.sum(MC)**2\n",
    "Theta3=np.float(np.sum(np.diagonal(MC,0)*(SC+SL)))/np.sum(MC)**2\n",
    "Theta4=0.\n",
    "for i in range(0,c):\n",
    "    for j in range (0,c):\n",
    "        Theta4=Theta4+MC[i,j]*(SL[j]+SC[i])**2\n",
    "Theta4=Theta4/np.sum(MC)**3\n",
    "\n",
    "Apoio1=(Theta1*(1-Theta1)/(1-Theta2)**2)\n",
    "Apoio2=(2*(1-Theta1)*(2*Theta1*Theta2-Theta3))/(1-Theta2)**3\n",
    "Apoio3=(((1-Theta1)**2)*(Theta4-4*Theta2**2))/(1-Theta2)**4\n",
    "VarK=(Apoio1+Apoio2+Apoio3)/np.sum(MC)\n",
    "Zc=Kappa/np.sqrt(VarK)\n",
    "\n",
    "print MC\n",
    "\n",
    "print 'Exatidao Global =', EG\n",
    "print 'Coeficiente Kappa = ', Kappa\n",
    "print 'Zc = ', Zc\n"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}