Crack Width Estimation with Crack Detection v1.3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright (C) 2018 Pierluigi Ferrari\n",
    "\n",
    "Licensed under the Apache License, Version 2.0 (the \"License\");\n",
    "you may not use this file except in compliance with the License.\n",
    "You may obtain a copy of the License at\n",
    "    http://www.apache.org/licenses/LICENSE-2.0\n",
    " Unless required by applicable law or agreed to in writing, software\n",
    "distributed under the License is distributed on an \"AS IS\" BASIS,\n",
    "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
    "See the License for the specific language governing permissions and\n",
    "limitations under the License.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Copyright (C) 2011, the scikit-image team\n",
    "All rights reserved.\n",
    "\n",
    "Redistribution and use in source and binary forms, with or without\n",
    "modification, are permitted provided that the following conditions are\n",
    "met:\n",
    "\n",
    " 1. Redistributions of source code must retain the above copyright\n",
    "    notice, this list of conditions and the following disclaimer.\n",
    " 2. Redistributions in binary form must reproduce the above copyright\n",
    "    notice, this list of conditions and the following disclaimer in\n",
    "    the documentation and/or other materials provided with the\n",
    "    distribution.\n",
    " 3. Neither the name of skimage nor the names of its contributors may be\n",
    "    used to endorse or promote products derived from this software without\n",
    "    specific prior written permission.\n",
    "\n",
    "THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n",
    "IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n",
    "WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n",
    "DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,\n",
    "INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n",
    "(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n",
    "SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n",
    "HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,\n",
    "STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING\n",
    "IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n",
    "POSSIBILITY OF SUCH DAMAGE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. 사전에 학습시킨 균열 탐지 딥러닝 weight와 Single Shot Multibox Detector model을 불러옵니다. \n",
    "\n",
    "# 1. Upload the pre-trained deep learning weight and Single Shot Multibox Detector model for crack detection.\n",
    "\n",
    "from keras import backend as K\n",
    "from keras.models import load_model\n",
    "from keras.preprocessing import image\n",
    "from keras.optimizers import Adam\n",
    "from imageio import imread\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "import cv2\n",
    "\n",
    "from models.keras_ssd300 import ssd_300\n",
    "from keras_loss_function.keras_ssd_loss import SSDLoss\n",
    "from keras_layers.keras_layer_AnchorBoxes import AnchorBoxes\n",
    "from keras_layers.keras_layer_DecodeDetections import DecodeDetections\n",
    "from keras_layers.keras_layer_DecodeDetectionsFast import DecodeDetectionsFast\n",
    "from keras_layers.keras_layer_L2Normalization import L2Normalization\n",
    "\n",
    "from ssd_encoder_decoder.ssd_output_decoder import decode_detections, decode_detections_fast\n",
    "\n",
    "from data_generator.object_detection_2d_data_generator import DataGenerator\n",
    "from data_generator.object_detection_2d_photometric_ops import ConvertTo3Channels\n",
    "from data_generator.object_detection_2d_geometric_ops import Resize\n",
    "from data_generator.object_detection_2d_misc_utils import apply_inverse_transforms\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "img_height = 300\n",
    "img_width = 300\n",
    "\n",
    "K.clear_session() \n",
    "\n",
    "# 변수 값은 Single Shot Multibox Detector의 원래 수치를 변경하지 않고 사용하였습니다.\n",
    "# The original value of parameters of 'Single Shot Multibox Detector' was used without any changes.\n",
    "model = ssd_300(image_size=(img_height, img_width, 3),\n",
    "                n_classes=1,\n",
    "                mode='inference',\n",
    "                l2_regularization=0.0005,\n",
    "                scales=[0.1, 0.2, 0.37, 0.54, 0.71, 0.88, 1.05], \n",
    "                aspect_ratios_per_layer=[[1.0, 2.0, 0.5],\n",
    "                                         [1.0, 2.0, 0.5, 3.0, 1.0/3.0],\n",
    "                                         [1.0, 2.0, 0.5, 3.0, 1.0/3.0],\n",
    "                                         [1.0, 2.0, 0.5, 3.0, 1.0/3.0],\n",
    "                                         [1.0, 2.0, 0.5],\n",
    "                                         [1.0, 2.0, 0.5]],\n",
    "                two_boxes_for_ar1=True,\n",
    "                steps=[8, 16, 32, 64, 100, 300],\n",
    "                offsets=[0.5, 0.5, 0.5, 0.5, 0.5, 0.5],\n",
    "                clip_boxes=False,\n",
    "                variances=[0.1, 0.1, 0.2, 0.2],\n",
    "                normalize_coords=True,\n",
    "                subtract_mean=[123, 117, 104],\n",
    "                swap_channels=[2, 1, 0],\n",
    "                confidence_thresh=0.5,\n",
    "                iou_threshold=0.45,\n",
    "                top_k=200,\n",
    "                nms_max_output_size=400)\n",
    "\n",
    "# 학습된 weight를 불러오는 경로를 입력합니다.\n",
    "# Input your own path for pre-trained weight.\n",
    "weights_path = 'ssd300_pascal_07+12_epoch-04_loss-3.0387_val_loss-3.5244_weight.h5'\n",
    "\n",
    "model.load_weights(weights_path, by_name=True)\n",
    "\n",
    "adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)\n",
    "\n",
    "ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0)\n",
    "\n",
    "model.compile(optimizer=adam, loss=ssd_loss.compute_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "445\n",
      "Predicted boxes:\n",
      "\n",
      "   class   conf xmin   ymin   xmax   ymax\n",
      "frame : 0\n",
      "frame : 6\n",
      "frame : 12\n",
      "frame : 18\n",
      "frame : 24\n",
      "frame : 30\n",
      "frame : 36\n",
      "frame : 42\n",
      "frame : 48\n",
      "frame : 54\n",
      "frame : 60\n",
      "frame : 66\n",
      "frame : 72\n",
      "frame : 78\n",
      "frame : 84\n",
      "frame : 90\n",
      "frame : 96\n",
      "frame : 102\n",
      "frame : 108\n",
      "frame : 114\n",
      "frame : 120\n",
      "frame : 126\n",
      "frame : 132\n",
      "frame : 138\n",
      "frame : 144\n",
      "frame : 150\n",
      "frame : 156\n",
      "frame : 162\n",
      "frame : 168\n",
      "frame : 174\n",
      "frame : 180\n",
      "frame : 186\n",
      "frame : 192\n",
      "frame : 198\n",
      "frame : 204\n",
      "frame : 210\n",
      "frame : 216\n",
      "frame : 222\n",
      "frame : 228\n",
      "frame : 234\n",
      "frame : 240\n",
      "frame : 246\n",
      "frame : 252\n",
      "frame : 258\n",
      "xmin :  -3.0719831585884094   ymin :  312.63884674072267   xmax :  504.6997955322266   ymax :  435.86864379882815\n",
      "frame : 264\n",
      "frame : 270\n",
      "frame : 276\n",
      "frame : 282\n",
      "xmin :  3.229735493659973   ymin :  306.6112655639648   xmax :  504.5031707763672   ymax :  424.433473815918\n",
      "frame : 288\n",
      "frame : 294\n",
      "frame : 300\n",
      "frame : 306\n",
      "xmin :  1.8382197618484497   ymin :  211.1157989501953   xmax :  502.82091369628904   ymax :  328.9063958740234\n",
      "frame : 312\n",
      "frame : 318\n",
      "frame : 324\n",
      "frame : 330\n",
      "frame : 336\n",
      "xmin :  8.052163124084473   ymin :  109.60983596801758   xmax :  491.5266632080078   ymax :  226.92417327880858\n",
      "frame : 342\n",
      "frame : 348\n",
      "frame : 354\n",
      "xmin :  8.622269535064698   ymin :  101.70400871276856   xmax :  492.5082305908203   ymax :  214.17680389404296\n",
      "frame : 360\n",
      "frame : 366\n",
      "frame : 372\n",
      "frame : 378\n",
      "frame : 384\n",
      "frame : 390\n",
      "frame : 396\n",
      "frame : 402\n",
      "frame : 408\n",
      "frame : 414\n",
      "frame : 420\n",
      "frame : 426\n",
      "frame : 432\n",
      "frame : 438\n",
      "frame : 444\n",
      "--- 5.590044975280762 seconds ---\n"
     ]
    }
   ],
   "source": [
    "# 2. 드론이 촬영한 콘크리트 외벽 영상에서 프레임을 추출합니다(4fps).\n",
    "#    이 프레임 이미지들을 균열 탐지 딥러닝 엔진에 입력하여 inference를 합니다.\n",
    "#    Inference의 결과 값으로 균열의 위치를 bounding box의 형태로 report합니다.\n",
    "\n",
    "# 2. Extract frames out of the video which recorded the concrete surface shoot by drone(4fps).\n",
    "#    Input the frame images into the deep learning engine for inference.\n",
    "#    The positional information will be reported as a bounding box, as a result of the inference.\n",
    "\n",
    "\n",
    "# 드론으로 촬영한 영상의 경로를 입력합니다.\n",
    "# Input the path of the video shoot by drone.\n",
    "\n",
    "\n",
    "\n",
    "vidcap = cv2.VideoCapture('C:\\\\Users\\\\user\\Desktop\\\\video3.mp4')\n",
    "success,imagefile = vidcap.read()\n",
    "count = 0\n",
    "while success:\n",
    "    if(count%6==0):\n",
    "# 추출된 프레임 이미지들을 저장할 경로를 입력합니다.\n",
    "# Input the path to save the extracted frame images.\n",
    "        cv2.imwrite(\"C:\\\\Users\\\\user\\Desktop\\\\frames\\\\frame%d.jpg\" % count, imagefile)    \n",
    "    success,imagefile = vidcap.read()\n",
    "    count += 1\n",
    "\n",
    "orig_images = [] \n",
    "input_images = [] \n",
    "\n",
    "frames_count = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))\n",
    "print(frames_count)\n",
    "for i in range(0,frames_count):\n",
    "    if(i%6==0):\n",
    "# 저장한 프레임 이미지들을 다시 불러올 수 있도록 동일한 경로를 입력합니다.\n",
    "# Input the same path used before to load the saved frame images.\n",
    "        img_path = 'C:\\\\Users\\\\user\\Desktop\\\\frames\\\\frame%d.jpg'%i\n",
    "        orig_images.append(imread(img_path))\n",
    "        img = image.load_img(img_path, target_size=(img_height, img_width))\n",
    "        img = image.img_to_array(img)\n",
    "        img = np.array(img)\n",
    "        input_images.append(img)\n",
    "        \n",
    "input_images = np.array(input_images)\n",
    "orig_images = np.array(orig_images)\n",
    "\n",
    "# 한 번에 처리되는 프레임 이미지의 갯수를 입력합니다. 보유 GPU 성능에 따라 늘리거나 줄여야 할 수 있습니다. \n",
    "# Input the number of frame images to be batch-processed.\n",
    "# You may increase or decrease the number depending on the performance of your own gpu. \n",
    "num_of_frames = 16\n",
    "counting = 0\n",
    "saving_bounding_boxes = []\n",
    "isBreak = 0;\n",
    "\n",
    "print(\"Predicted boxes:\\n\")\n",
    "print('   class   conf xmin   ymin   xmax   ymax')\n",
    "\n",
    "for i in range(0, frames_count):\n",
    "    y_pred = model.predict(input_images[i*num_of_frames:i*num_of_frames + num_of_frames])\n",
    "    confidence_threshold = 0.4\n",
    "\n",
    "    y_pred_thresh = [y_pred[k][y_pred[k,:,1] > confidence_threshold] for k in range(y_pred.shape[0])]\n",
    "    np.set_printoptions(precision=2, suppress=True, linewidth=90)\n",
    "\n",
    "    for j in range(0, num_of_frames):\n",
    "        print('frame :',counting)\n",
    "        if(j>len(y_pred_thresh)): break;\n",
    "        for box in y_pred_thresh[j]:\n",
    "            xmin = box[2] * orig_images[0].shape[1] / img_width\n",
    "            ymin = box[3] * orig_images[0].shape[0] / img_height\n",
    "            xmax = box[4] * orig_images[0].shape[1] / img_width\n",
    "            ymax = box[5] * orig_images[0].shape[0] / img_height\n",
    "            print('xmin : ',xmin, '  ymin : ',ymin, '  xmax : ',xmax, '  ymax : ',ymax)\n",
    "            # 균열이 탐지된 프레임의 bounding box 위치정보를 saving_bounding_boxes 리스트에 저장합니다.\n",
    "            # Append the positional information of the bounding box of the detected frame at'saving_bounding_boxes' list.\n",
    "            saving_bounding_boxes.append([counting, xmin,ymin,xmax,ymax])\n",
    "        counting += 6\n",
    "        if(counting>frames_count): \n",
    "            isBreak = 1;\n",
    "            break;\n",
    "    if(isBreak == 1): break;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 509 495\n",
      "0 0 509 495\n",
      "0 0 508 495\n",
      "0 0 508 496\n",
      "0 0 508 496\n",
      "0 1 508 496\n",
      "0 1 508 496\n",
      "0 1 507 495\n",
      "0 0 508 496\n",
      "1 1 509 495\n",
      "1 1 509 495\n",
      "1 1 509 495\n",
      "0 1 509 495\n",
      "1 1 509 496\n",
      "2 2 509 497\n",
      "2 4 509 497\n",
      "2 5 509 496\n",
      "3 8 509 496\n",
      "5 23 508 496\n",
      "4 15 508 495\n",
      "2 33 507 491\n",
      "3 18 507 495\n",
      "4 21 507 495\n",
      "3 10 508 495\n",
      "2 6 508 495\n",
      "3 7 508 496\n",
      "3 2 509 496\n",
      "2 2 509 496\n",
      "2 1 509 495\n",
      "1 1 509 494\n",
      "2 1 509 493\n",
      "2 1 509 494\n",
      "1 1 509 495\n",
      "1 1 509 494\n",
      "1 1 509 495\n",
      "1 1 509 494\n",
      "1 1 509 493\n",
      "1 1 509 494\n",
      "1 1 509 495\n",
      "2 1 509 495\n",
      "2 0 515 422\n",
      "2 0 514 402\n",
      "3 0 514 407\n",
      "2 30 520 418\n",
      "1 79 521 399\n",
      "0 133 523 427\n",
      "0 125 512 421\n",
      "0 85 516 492\n",
      "4 63 514 501\n",
      "3 89 509 499\n",
      "1 0 508 495\n",
      "0 0 508 495\n",
      "1 0 508 496\n",
      "1 0 508 496\n",
      "0 0 508 496\n",
      "0 1 508 495\n",
      "0 1 509 496\n",
      "--- 0.33022570610046387 seconds ---\n"
     ]
    }
   ],
   "source": [
    "# 3. 균열탐지 딥러닝 엔진이 리포트 한 균열 위치에 맞게 프레임 이미지를 잘라냅니다.\n",
    "# 3. Crop the frame image using the positional information of the crack reported by crack detection deep learning engine.\n",
    "\n",
    "from skimage import io\n",
    "\n",
    "cropped_frames = []\n",
    "\n",
    "for i in range(0, len(saving_bounding_boxes)):\n",
    "    frame_count = saving_bounding_boxes[i][0]//6\n",
    "    frame = orig_images[frame_count]\n",
    "    if(saving_bounding_boxes[i][1] < 0):\n",
    "        saving_bounding_boxes[i][1] = 0\n",
    "    xmin = int(saving_bounding_boxes[i][1])\n",
    "    if(saving_bounding_boxes[i][2] < 0):\n",
    "        saving_bounding_boxes[i][2] = 0\n",
    "    ymin = int(saving_bounding_boxes[i][2])\n",
    "    xmax = int(saving_bounding_boxes[i][3])\n",
    "    ymax = int(saving_bounding_boxes[i][4])\n",
    "    print(xmin,ymin,xmax,ymax)\n",
    "    cropped_frame = orig_images[frame_count][ymin:ymax, xmin:xmax, :]\n",
    "    cropped_frame = cropped_frame.astype('uint8')\n",
    "# 잘라낸 프레임 이미지를 저장하는 리스트입니다.\n",
    "# The list which saves the cropped frame images.\n",
    "    cropped_frames.append(cropped_frame)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\user\\anaconda2\\envs\\tensorflow-gpu\\lib\\site-packages\\skimage\\util\\arraycrop.py:177: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  cropped = ar[slices]\n"
     ]
    }
   ],
   "source": [
    "# 4. 균열 탐지 딥러닝 엔진이 잘라낸 프레임 이미지에 전처리를 합니다.\n",
    "#    전처리는 총 3단계로 구성됩니다.\n",
    "#   1) Image Binarization : 균열인 부분과 균열이 아닌 부분을 분리합니다.\n",
    "#   2) Skeletonize : 균열의 뼈대를 추출합니다.\n",
    "#   3) Edge detection : 균열의 외곽선을 추출합니다.\n",
    "\n",
    "#   이 단계에서는 Image Binarization을 진행합니다.\n",
    "\n",
    "# 4. Preprocess the frame images cropped by crack detection deep learning engine.\n",
    "#    The preprocess consists of 3 stages.\n",
    "#   1) Image Binarization : seperate crack section and the noncrack section.\n",
    "#   2) Skeletonize : extract the central skeleton of the crack.\n",
    "#   3) Edge detection : extract the edge of the crack.\n",
    "\n",
    "#   At this stage, Image Binarization will be done.\n",
    "\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import cv2\n",
    "from skimage import io\n",
    "from skimage import data\n",
    "from skimage.color import rgb2gray\n",
    "from skimage.data import page\n",
    "from skimage.filters import (threshold_sauvola)\n",
    "from PIL import Image\n",
    "\n",
    "sauvola_frames_Pw_bw = []\n",
    "sauvola_frames_Pw = []\n",
    "\n",
    "for i in range(0,len(cropped_frames)):\n",
    "    img = cropped_frames[i]\n",
    "    img_gray = rgb2gray(img)\n",
    "\n",
    "    # window size와 k값은 'Concrete Crack Identification Using a UAV Incorporating Hybrid Image Processing' 논문이 제시한 값을\n",
    "    # 그대로 사용하였습니다.\n",
    "    \n",
    "    # window size and k value were used without any changes from the\n",
    "    # 'Concrete Crack Identification Using a UAV Incorporating Hybrid Image Processing' thesis.\n",
    "    window_size_Pw = 71\n",
    "    thresh_sauvola_Pw = threshold_sauvola(img_gray, window_size=window_size_Pw, k=0.42)\n",
    "\n",
    "    binary_sauvola_Pw = img_gray > thresh_sauvola_Pw\n",
    "    binary_sauvola_Pw_bw = img_gray > thresh_sauvola_Pw\n",
    "\n",
    "    binary_sauvola_Pw_bw.dtype = 'uint8'\n",
    "\n",
    "    binary_sauvola_Pw_bw *= 255\n",
    "    \n",
    "    # Image Binarization이 완료된 이미지를 저장하는 리스트입니다.\n",
    "    # The list which saves the images after image binarization.\n",
    "    \n",
    "    sauvola_frames_Pw_bw.append(binary_sauvola_Pw_bw)\n",
    "    sauvola_frames_Pw.append(binary_sauvola_Pw)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5. 균열의 뼈대를 추출합니다.\n",
    "# 5. Extract the skeleton of the crack.\n",
    "\n",
    "from skimage.morphology import skeletonize\n",
    "from skimage.util import invert\n",
    "\n",
    "skeleton_frames_Pw = []\n",
    "\n",
    "for i in range(0,len(cropped_frames)):\n",
    "    img_Pw = invert(sauvola_frames_Pw[i])\n",
    "\n",
    "    skeleton_Pw = skeletonize(img_Pw)\n",
    "\n",
    "    skeleton_Pw.dtype = 'uint8'\n",
    "\n",
    "    skeleton_Pw *= 255\n",
    "\n",
    "    # Skeletonize가 끝난 이미지를 저장하는 리스트입니다.\n",
    "    # The list which saves the images after the skeletonization.\n",
    "    skeleton_frames_Pw.append(skeleton_Pw)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6. 균열의 외곽선을 추출합니다.\n",
    "# 6. Detect the edges of the crack.\n",
    "\n",
    "import numpy as np\n",
    "from scipy import ndimage as ndi\n",
    "from skimage import feature\n",
    "\n",
    "edges_frames_Pw = []\n",
    "edges_frames_Pl = []\n",
    "\n",
    "for i in range(0,len(cropped_frames)):\n",
    "    edges_Pw = feature.canny(sauvola_frames_Pw[i], 0.09)\n",
    "\n",
    "    edges_Pw.dtype = 'uint8'\n",
    "\n",
    "    edges_Pw *= 255\n",
    "    \n",
    "    # Edge detection이 끝난 이미지를 저장하는 리스트입니다.\n",
    "    # The list which saves the images after edge detection.\n",
    "    edges_frames_Pw.append(edges_Pw)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------동영상 내 재생 시간 :  0.0 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  0.25 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  0.5 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  0.75 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  1.0 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  1.25 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  1.5 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  1.75 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  2.0 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  2.25 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  2.5 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  2.75 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  3.0 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  3.25 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  3.5 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  3.75 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  4.0 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  4.25 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  4.5 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  4.75 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  5.0 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  5.25 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  5.5 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  5.75 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  6.0 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  6.25 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  6.5 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  6.75 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  7.0 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  7.25 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  7.5 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  7.75 초 -----------------\n",
      "2\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  8.0 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  8.25 초 -----------------\n",
      "2\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  8.5 초 -----------------\n",
      "0\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  8.75 초 -----------------\n",
      "4\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  9.0 초 -----------------\n",
      "2\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  9.25 초 -----------------\n",
      "2\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  9.5 초 -----------------\n",
      "8\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  9.75 초 -----------------\n",
      "2\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  10.0 초 -----------------\n",
      "2\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  10.25 초 -----------------\n",
      "2\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  10.5 초 -----------------\n",
      "509\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  10.75 초 -----------------\n",
      "509\n",
      "균열 폭 :  3.68\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  12.0 초 -----------------\n",
      "515\n",
      "균열 폭 :  4.6\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  14.5 초 -----------------\n",
      "521\n",
      "균열 폭 :  5.52\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  15.0 초 -----------------\n",
      "520\n",
      "균열 폭 :  6.44\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  15.75 초 -----------------\n",
      "2\n",
      "균열 폭 :  2.6\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  16.25 초 -----------------\n",
      "2\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  16.5 초 -----------------\n",
      "6\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  17.0 초 -----------------\n",
      "7\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  17.25 초 -----------------\n",
      "9\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  17.5 초 -----------------\n",
      "11\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  17.75 초 -----------------\n",
      "4\n",
      "균열 폭 :  1.3\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  18.0 초 -----------------\n",
      "10\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  18.25 초 -----------------\n",
      "11\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--------------동영상 내 재생 시간 :  18.5 초 -----------------\n",
      "12\n",
      "균열 폭 :  1.84\n",
      "위험군 : 상\n",
      "\n",
      "--- 2973.917294025421 seconds ---\n"
     ]
    }
   ],
   "source": [
    "# 7. 균열의 폭을 계산합니다. \n",
    "# 1) BFS를 통해 skeleton을 찾습니다.\n",
    "# 2) 찾은 skeletion pixel에서 5 pixel의 거리만큼 떨어져있는 인접 skeletion pixel들을 기준으로 방향을 설정합니다.\n",
    "# 3) 균열의 진행 방향에 수직인 직선을 긋습니다.\n",
    "# 4) 균열의 폭은 이 수직선과 Edge가 만나는 거리상에 위치한 pixel 단위로 산출합니다.\n",
    "# 5) 이를 실제 mm 단위로 변환한 후, 위험군을 분류합니다.\n",
    "\n",
    "# 7. Calculate the width of the crack.\n",
    "# 1) Find skeleton using BFS\n",
    "# 2) Set the direction of the crack by searching skeletion pixels which are 5 pixels away from the skeleton pixel.\n",
    "# 3) Draw a perpendicular line of the direction\n",
    "# 4) The perpendicular line meets the edge. The distance is calulated by counting pixels on the line.\n",
    "# 5) Convert the number of pixels into real mm width, and classify the danger group.\n",
    "\n",
    "import queue\n",
    "import math\n",
    "\n",
    "dx_dir_right = [-5,-5,-5,-4,-3,-2,-1,0,1,2,3,4,5,5]\n",
    "dy_dir_right = [0,1,2,3,4,5,5,5,5,5,4,3,2,1]\n",
    "\n",
    "dx_dir_left = [5,5,5,4,3,2,1,0,-1,-2,-3,-4,-5,-5]\n",
    "dy_dir_left = [0,-1,-2,-3,-4,-5,-5,-5,-5,-5,-4,-3,-2,-1]\n",
    "\n",
    "dx_bfs = [-1,-1,0,1,1,1,0,-1]\n",
    "dy_bfs = [0,1,1,1,0,-1,-1,-1]\n",
    "\n",
    "save_result = []\n",
    "save_risk = []\n",
    "\n",
    "\n",
    "for k in range(0,len(skeleton_frames_Pw)):\n",
    "    print('--------------''동영상 내 재생 시간 : ',(saving_bounding_boxes[k][0]//6)*0.25,'초','-----------------')\n",
    "    # BFS를 통해 Skeleton을 찾습니다.\n",
    "    # Searching the skeleton through BFS.\n",
    "    start = [0,0]\n",
    "    next = []\n",
    "    q = queue.Queue()\n",
    "    q.put(start)\n",
    "\n",
    "    len_x = skeleton_frames_Pw[k].shape[0]\n",
    "    len_y = skeleton_frames_Pw[k].shape[1]\n",
    "\n",
    "    visit = np.zeros((len_x,len_y))\n",
    "    crack_width_list = []\n",
    "    \n",
    "    # Skeleton pixel로 부터 균열의 진행 방향을 찾아냅니다.\n",
    "    # Find out the direction of the crack from skeleton pixel.\n",
    "    while(q.empty() == 0):\n",
    "        next = q.get()\n",
    "        x = next[0]\n",
    "        y = next[1]\n",
    "        right_x = right_y = left_x = left_y = -1\n",
    "\n",
    "        if(skeleton_frames_Pw[k][x][y] == 255):\n",
    "            # Skeleton을 바탕으로 균열의 진행 방향을 구합니다.\n",
    "            # Estimating the direction of the crack from skeleton\n",
    "            for i in range(0, len(dx_dir_right)):\n",
    "                right_x = x + dx_dir_right[i]\n",
    "                right_y = y + dy_dir_right[i]\n",
    "                if(right_x<0 or right_y<0 or right_x>=len_x or right_y>=len_y): \n",
    "                    right_x = right_y = -1\n",
    "                    continue;\n",
    "                if(skeleton_frames_Pw[k][right_x][right_y] == 255): break;\n",
    "                if(i==13): right_x = right_y = -1\n",
    "\n",
    "            if(right_x == -1): \n",
    "                right_x = x\n",
    "                right_y = y\n",
    "\n",
    "            for i in range(0, len(dx_dir_left)):\n",
    "                left_x = x + dx_dir_left[i]\n",
    "                left_y = y + dy_dir_left[i]\n",
    "                if(left_x <0 or left_y<0 or left_x >=len_x or left_y>=len_y): \n",
    "                    left_x = left_y = -1\n",
    "                    continue;\n",
    "                if(skeleton_frames_Pw[k][left_x][left_y] == 255): break;\n",
    "                if(i==13): left_x = left_y = -1\n",
    "\n",
    "            if(left_x == -1): \n",
    "                left_x = x\n",
    "                left_y = y\n",
    "            \n",
    "            # acos 공식을 바탕으로 균열의 진행 방향을 각도(theta)로 나타냅니다.\n",
    "            # Set the direction of the crack as angle(theta) by using acos formula\n",
    "            base = right_y - left_y\n",
    "            height = right_x - left_x\n",
    "            hypotenuse = math.sqrt(base*base + height*height)\n",
    "\n",
    "            if(base==0 and height != 0): theta = 90.0\n",
    "            elif(base==0 and height == 0): continue\n",
    "            else: theta = math.degrees(math.acos((base * base + hypotenuse * hypotenuse - height * height)/(2.0 * base * hypotenuse)))\n",
    "\n",
    "            theta += 90\n",
    "            dist = 0\n",
    "            \n",
    "            # 균열 진행 방향의 수직선과 Edge가 만나면, 그 거리를 구합니다.\n",
    "            # Calculate the distance if the perpendicular line meets the edge of the crack.\n",
    "            for i in range(0,2):\n",
    "                \n",
    "                pix_x = x\n",
    "                pix_y = y\n",
    "                if(theta>360): theta -= 360\n",
    "                elif(theta<0): theta += 360    \n",
    "                \n",
    "                if(theta == 0.0 or theta == 360.0):\n",
    "                    while(1):\n",
    "                        pix_y+=1\n",
    "                        if(pix_y>=len_y):\n",
    "                            pix_x = x\n",
    "                            pix_y = y\n",
    "                            break;\n",
    "                        if(edges_frames_Pw[k][pix_x][pix_y]==255): break;\n",
    "\n",
    "                elif(theta == 90.0):\n",
    "                    while(1):\n",
    "                        pix_x-=1\n",
    "                        if(pix_x<0):\n",
    "                            pix_x = x\n",
    "                            pix_y = y\n",
    "                            break;\n",
    "                        if(edges_frames_Pw[k][pix_x][pix_y]==255): break;\n",
    "\n",
    "                elif(theta == 180.0):\n",
    "                    while(1):\n",
    "                        pix_y-=1\n",
    "                        if(pix_y<0):\n",
    "                            pix_x = x\n",
    "                            pix_y = y\n",
    "                            break;\n",
    "                        if(edges_frames_Pw[k][pix_x][pix_y]==255): break;\n",
    "\n",
    "                elif(theta == 270.0):\n",
    "                    while(1):\n",
    "                        pix_x+=1\n",
    "                        if(pix_x>=len_x):\n",
    "                            pix_x = x\n",
    "                            pix_y = y\n",
    "                            break;\n",
    "                        if(edges_frames_Pw[k][pix_x][pix_y]==255): break;\n",
    "                else:\n",
    "                    a = 1\n",
    "                    radian = math.radians(theta)\n",
    "                    while(1):        \n",
    "                        pix_x = x - round(a*math.sin(radian))\n",
    "                        pix_y = y + round(a*math.cos(radian))\n",
    "                        if(pix_x<0 or pix_y<0 or pix_x>=len_x or pix_y>=len_y): \n",
    "                            pix_x=x\n",
    "                            pix_y=y\n",
    "                            break;\n",
    "                        if(edges_frames_Pw[k][pix_x][pix_y]==255): break;\n",
    "\n",
    "                        if(theta>0 and theta<90):\n",
    "                            if(pix_y+1<len_y and edges_frames_Pw[k][pix_x][pix_y+1]==255): \n",
    "                                pix_y+=1\n",
    "                                break;\n",
    "                            if(pix_x-1>=0 and edges_frames_Pw[k][pix_x-1][pix_y]==255): \n",
    "                                pix_x-=1\n",
    "                                break;\n",
    "\n",
    "                        elif(theta>90 and theta<180):\n",
    "                            if(pix_y-1>=0 and edges_frames_Pw[k][pix_x][pix_y-1]==255): \n",
    "                                pix_y-=1\n",
    "                                break;\n",
    "                            if(pix_x-1>=0 and edges_frames_Pw[k][pix_x-1][pix_y]==255): \n",
    "                                pix_x-=1\n",
    "                                break;\n",
    "\n",
    "                        elif(theta>180 and theta<270):\n",
    "                            if(pix_y-1>=0 and edges_frames_Pw[k][pix_x][pix_y-1]==255): \n",
    "                                pix_y-=1\n",
    "                                break;\n",
    "                            if(pix_x+1<len_x and edges_frames_Pw[k][pix_x+1][pix_y]==255): \n",
    "                                pix_x+=1\n",
    "                                break;         \n",
    "\n",
    "                        elif(theta>270 and theta<360): \n",
    "                            if(pix_y+1<len_y and edges_frames_Pw[k][pix_x][pix_y+1]==255): \n",
    "                                pix_y+=1\n",
    "                                break;\n",
    "                            if(pix_x+1<len_x and edges_frames_Pw[k][pix_x+1][pix_y]==255): \n",
    "                                pix_x+=1\n",
    "                                break;\n",
    "                        a+=1\n",
    "        \n",
    "                dist += math.sqrt((y-pix_y)**2 + (x-pix_x)**2)\n",
    "                theta += 180        \n",
    "\n",
    "            # 균열의 폭을 저장하는 리스트입니다.\n",
    "            # The list which saves the width of the crack.\n",
    "            crack_width_list.append(dist)\n",
    "        \n",
    "        for i in range(0,8):\n",
    "            next_x = x + dx_bfs[i]\n",
    "            next_y = y + dy_bfs[i]\n",
    "\n",
    "            if(next_x<0 or next_y<0 or next_x>=len_x or next_y>=len_y): continue;\n",
    "            if(visit[next_x][next_y] == 0): \n",
    "                q.put([next_x,next_y])\n",
    "                visit[next_x][next_y] = 1\n",
    "                \n",
    "    crack_width_list.sort(reverse=True)\n",
    "   \n",
    "    # 실제의 길이로 변환합니다.\n",
    "    # Convert into real width.\n",
    "    print(len(crack_width_list))\n",
    "    if(len(crack_width_list)==0): \n",
    "        save_result.append(0)\n",
    "        real_width = 0\n",
    "    elif(len(crack_width_list)<10):\n",
    "        real_width = round(crack_width_list[len(crack_width_list)-1]*0.92, 2)\n",
    "        save_result.append(real_width)\n",
    "    else: \n",
    "        real_width = round(crack_width_list[9]*0.92, 2)\n",
    "        save_result.append(real_width)\n",
    "    \n",
    "    print('균열 폭 : ',real_width)\n",
    "   \n",
    "    # 위험군을 분류합니다.\n",
    "    # Classify the danger group.\n",
    "    if(real_width >= 0.3):\n",
    "        save_risk.append('상')\n",
    "        print('위험군 : 상\\n')\n",
    "    elif(real_width<0.3 and real_width>=0.2): \n",
    "        save_risk.append('중')\n",
    "        print('위험군 : 중\\n')\n",
    "    else: \n",
    "        save_risk.append('하')\n",
    "        print('위험군 : 하\\n')\n",
    "        \n",
    "# 해당 정보를 텍스트 파일에 저장합니다.\n",
    "# Save those information into text files.\n",
    "f1 = open(\"C:\\\\Users\\\\user\\\\Desktop\\\\width.txt\", 'w')\n",
    "f2 = open(\"C:\\\\Users\\\\user\\\\Desktop\\\\risk.txt\", 'w')\n",
    "\n",
    "for z in range(0, len(save_result)):\n",
    "    f1.write(str(save_result[z])+'mm'+'\\n')\n",
    "f1.close()\n",
    "\n",
    "for z in range(0, len(save_risk)):\n",
    "    f2.write(str(save_risk[z])+'\\n')\n",
    "f2.close()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}