Rigid_Pavement_Crack_Detector_sharedGIT.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/germancruzram/Rigid_Pavement_Crack_Detector/blob/main/Rigid_Pavement_Crack_Detector_sharedGIT.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4zV9QtfrneNw"
      },
      "source": [
        "# **HERRAMIENTA IA PARA DETECCION DE GRIETAS EN PAVIMENTO RIGIDO.**\n",
        "**German Cruz Ramírez. 🇳**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LA9VI44c_Dex"
      },
      "source": [
        "# **PASO 1. INSTALANDO PAQUETES**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IrOIVb4g-9LV"
      },
      "outputs": [],
      "source": [
        "%%capture\n",
        "!pip install super-gradients\n",
        "!pip install imutils\n",
        "!pip install gdown"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mufgwYJGRGaY"
      },
      "outputs": [],
      "source": [
        "# Reiniciar sesión en Google Colab\n",
        "import os\n",
        "os._exit(00)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "En caso que no se reinicie la sesión Colab, debe hacerlo manualmente en el menú \"Entorno de ejecución\" luego \"Reiniciar sesión\"."
      ],
      "metadata": {
        "id": "6EqwhjVxMJX9"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8vj6ZhW5_ZiD"
      },
      "source": [
        "# **PASO 2. IMPORTANDO LAS LIBRERIAS**\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gPnhQ5DQ_gTu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e5ea0945-ccbb-4852-c1f4-19a3434efc04"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "[2024-06-28 19:36:24] INFO - crash_tips_setup.py - Crash tips is enabled. You can set your environment variable to CRASH_HANDLER=FALSE to disable it\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The console stream is logged into /root/sg_logs/console.log\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "[2024-06-28 19:36:32] INFO - utils.py - NumExpr defaulting to 2 threads.\n"
          ]
        }
      ],
      "source": [
        "from super_gradients.training import Trainer\n",
        "from super_gradients.training import dataloaders\n",
        "from super_gradients.training.dataloaders.dataloaders import coco_detection_yolo_format_train, coco_detection_yolo_format_val\n",
        "from IPython.display import clear_output\n",
        "from super_gradients.training.losses import PPYoloELoss\n",
        "from super_gradients.training.metrics import DetectionMetrics_050\n",
        "from super_gradients.training.models.detection_models.pp_yolo_e import PPYoloEPostPredictionCallback\n",
        "from super_gradients.training import models\n",
        "import os\n",
        "import cv2\n",
        "import pandas as pd\n",
        "from PIL import Image, ExifTags\n",
        "import numpy as np\n",
        "import shutil\n",
        "import torch"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x4XPW8VuVp-c"
      },
      "source": [
        "# **PASO 3. IMPORTANDO EL MODELO ENTRENADO PARA DETECCION DE GRIETAS**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-1UcxrpIUm2G"
      },
      "outputs": [],
      "source": [
        "%%capture\n",
        "# ID del archivo en Google Drive\n",
        "file_id = '1NcEQrTL0KMlkq29-D-w80x57VRSEM2dP'\n",
        "\n",
        "# Construir la URL de descarga directa\n",
        "url = f'https://drive.google.com/uc?id={file_id}'\n",
        "\n",
        "# Ruta donde se guardará el archivo descargado\n",
        "output = '/content/crackCH_1906.pth'\n",
        "\n",
        "# Descargar el archivo usando gdown\n",
        "!gdown {url} -O {output}\n",
        "\n",
        "print(\"Archivo descargado y guardado en\", output)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ELYsCvoQANtB"
      },
      "source": [
        "# **PASO 4. DEFINICION DE LAS CLASES**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "l8caxCpbASNj"
      },
      "outputs": [],
      "source": [
        "dataset_params = {\n",
        "    'classes': ['grieta_lineal']\n",
        "\n",
        "}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VWrhOdu7Mxdi"
      },
      "source": [
        "# **PASO 5. CARGANDO LA IA ENTRENADA**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CJQBe5WdDYs-",
        "outputId": "25eddedc-fcf8-4485-8ccb-a517aa75e0b7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "[2024-06-28 19:36:39] INFO - checkpoint_utils.py - Successfully loaded model weights from /content/crackCH_1906.pth EMA checkpoint.\n"
          ]
        }
      ],
      "source": [
        "best_model = models.get('yolo_nas_s',\n",
        "                        num_classes=len(dataset_params['classes']),\n",
        "                        checkpoint_path=\"/content/crackCH_1906.pth\")\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v3Tif0nVqSCz"
      },
      "source": [
        "# **PASO 6. SUBIR LAS IMAGENES A PROCESAR EN LA CARPETA FOTOGRAFIA**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "E-z9LBeyk21J",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b126024c-7f93-4b50-b0a8-57763fe08b95"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Carpeta \"/content/Fotografias\" creada exitosamente\n",
            "Carpeta \"/content/Video\" creada exitosamente\n",
            "Carpeta \"/content/Detecciones\" creada exitosamente\n",
            "ANTES DE CONTINUAR, RECUERDE SUBIR LAS IMAGENES A PROCESAR EN LA CARPETA FOTOGRAFIA\n"
          ]
        }
      ],
      "source": [
        "import os\n",
        "from google.colab import files\n",
        "\n",
        "# Crear la carpeta \"Fotografias\"\n",
        "folder_name = '/content/Fotografias'\n",
        "os.makedirs(folder_name, exist_ok=True)\n",
        "print(f'Carpeta \"{folder_name}\" creada exitosamente')\n",
        "\n",
        "# Crear la carpeta \"Video\"\n",
        "folder_name = '/content/Video'\n",
        "os.makedirs(folder_name, exist_ok=True)\n",
        "print(f'Carpeta \"{folder_name}\" creada exitosamente')\n",
        "\n",
        "# Crear la carpeta \"Detecciones\" si no existe\n",
        "detections_folder = '/content/Detecciones'\n",
        "os.makedirs(detections_folder, exist_ok=True)\n",
        "print(f'Carpeta \"{detections_folder}\" creada exitosamente')\n",
        "print(\"ANTES DE CONTINUAR, RECUERDE SUBIR LAS IMAGENES A PROCESAR EN LA CARPETA FOTOGRAFIA\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tFtxr3jfNq-T"
      },
      "source": [
        "# **PASO 7. ANTES DE EJECUTAR EL PASO 7, SUBA LAS IMAGENES A PROCESAR**\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9BsRPmLy870v"
      },
      "outputs": [],
      "source": [
        "def get_lat_lon(exif):\n",
        "    lat = lon = None\n",
        "    if 'GPSInfo' in exif:\n",
        "        gps_info = exif['GPSInfo']\n",
        "        gps_latitude = gps_info.get(2)\n",
        "        gps_latitude_ref = gps_info.get(1)\n",
        "        gps_longitude = gps_info.get(4)\n",
        "        gps_longitude_ref = gps_info.get(3)\n",
        "        if gps_latitude and gps_latitude_ref and gps_longitude and gps_longitude_ref:\n",
        "            lat = convert_to_degrees(gps_latitude)\n",
        "            if gps_latitude_ref != 'N':\n",
        "                lat = -lat\n",
        "            lon = convert_to_degrees(gps_longitude)\n",
        "            if gps_longitude_ref != 'E':\n",
        "                lon = -lon\n",
        "    return lat, lon\n",
        "\n",
        "def convert_to_degrees(value):\n",
        "    d = float(value[0])\n",
        "    m = float(value[1])\n",
        "    s = float(value[2])\n",
        "    return d + (m / 60.0) + (s / 3600.0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6IkpVtr79D78",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8f1046ee-7b47-400c-e6fd-57c22d01df6f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "[2024-06-28 20:18:28] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n",
            "[2024-06-28 20:18:28] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Processed Imagen con grietas lineales.jpeg\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "[2024-06-28 20:18:29] INFO - pipelines.py - Fusing some of the model's layers. If this takes too much memory, you can deactivate it by setting `fuse_model=False`\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Processed Imagen sin deterioro (1).jpeg\n"
          ]
        }
      ],
      "source": [
        "# Inicialización de la lista para almacenar los datos del Excel\n",
        "data = []\n",
        "\n",
        "# Ruta de la carpeta de imágenes\n",
        "folder_path = '/content/Fotografias'\n",
        "detections_folder = '/content/Detecciones'\n",
        "os.makedirs(detections_folder, exist_ok=True)\n",
        "\n",
        "# Procesar cada imagen en la carpeta \"Fotografias\"\n",
        "for filename in os.listdir(folder_path):\n",
        "    if filename.lower().endswith((\".jpg\", \".png\",\".jpeg\")):\n",
        "        img_path = os.path.join(folder_path, filename)\n",
        "        with Image.open(img_path) as img_pil:\n",
        "            exif_data = img_pil.info.get('exif')\n",
        "            exif = img_pil._getexif()\n",
        "            if exif:\n",
        "                exif = {ExifTags.TAGS[k]: v for k, v in exif.items() if k in ExifTags.TAGS}\n",
        "                lat, lon = get_lat_lon(exif)\n",
        "            else:\n",
        "                lat, lon = None, None\n",
        "\n",
        "            img = cv2.cvtColor(np.array(img_pil), cv2.COLOR_RGB2BGR)\n",
        "            outputs = best_model.predict(img)\n",
        "            detections = [{'confidence': confidence, 'bbox': bbox, 'class_id': label}\n",
        "                          for bbox, confidence, label in zip(outputs.prediction.bboxes_xyxy, outputs.prediction.confidence, outputs.prediction.labels)\n",
        "                          if confidence > 0.3]\n",
        "            for det in detections:\n",
        "                x_min, y_min, x_max, y_max = map(int, det['bbox'])\n",
        "                cv2.rectangle(img, (x_min, y_min), (x_max, y_max), (255, 0, 255), 2)\n",
        "                label = f\"{dataset_params['classes'][det['class_id']]}: {det['confidence']:.2f}\"\n",
        "                (text_width, text_height), baseline = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 2)\n",
        "                cv2.rectangle(img, (x_min, y_min - text_height - 10), (x_min + text_width, y_min), (255, 0, 255), -1)\n",
        "                cv2.putText(img, label, (x_min, y_min - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2)\n",
        "            save_path = os.path.join(detections_folder, filename)\n",
        "            img_pil = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))\n",
        "            img_pil.save(save_path, exif=exif_data) if exif_data else img_pil.save(save_path)\n",
        "            data.append([filename, lat, lon, len(detections)])\n",
        "        print(f\"Processed {filename}\")\n",
        "\n",
        "# Crear el DataFrame y guardar en un archivo Excel\n",
        "df = pd.DataFrame(data, columns=['Filename', 'Latitude', 'Longitude', 'Detections'])\n",
        "excel_path = '/content/detections_info.xlsx'\n",
        "df.to_excel(excel_path, index=False)\n",
        "print(\"Proceso finalizado, las imágenes fueron procesadas y el archivo Excel ha sido creado.\")\n",
        "\n",
        "# Verificar si hay un archivo CSV en la carpeta \"Fotografias\"\n",
        "csv_file = None\n",
        "for file in os.listdir(folder_path):\n",
        "    if file.lower().endswith('.csv'):\n",
        "        csv_file = os.path.join(folder_path, file)\n",
        "        break\n",
        "\n",
        "# Si se encuentra un archivo CSV, agregar la información del punto kilométrico\n",
        "if csv_file:\n",
        "    csv_data = pd.read_csv(csv_file)\n",
        "    if 'Nombre_de_archivo_de_imagen' in csv_data.columns and 'Punto_kilométrico__km_' in csv_data.columns:\n",
        "        detections_info = pd.read_excel(excel_path)\n",
        "        merged_data = pd.merge(detections_info, csv_data[['Nombre_de_archivo_de_imagen', 'Punto_kilométrico__km_']],\n",
        "                               left_on='Filename', right_on='Nombre_de_archivo_de_imagen', how='left')\n",
        "        merged_data = merged_data.drop(columns=['Nombre_de_archivo_de_imagen'])\n",
        "        merged_data = merged_data.rename(columns={'Punto_kilométrico__km_': 'PKM'})\n",
        "        merged_data.to_excel(excel_path, index=False)\n",
        "        print(f\"Información de punto kilométrico agregada al archivo Excel en {excel_path}\")\n",
        "\n",
        "print(\"Proceso completado.\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SKgcbpARdePI",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "outputId": "3ce4b5c2-f7c8-41be-d929-23b9f4482a67"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_3e18549c-f2bc-4ae8-b3d3-ef53e5cdda9f\", \"Detecciones.zip\", 642002)"
            ]
          },
          "metadata": {}
        }
      ],
      "source": [
        "import zipfile\n",
        "import os\n",
        "from google.colab import files\n",
        "\n",
        "# Ruta de la carpeta a comprimir\n",
        "folder_to_zip = '/content/Detecciones'\n",
        "# Ruta del archivo .zip resultante\n",
        "zip_filename = '/content/Detecciones.zip'\n",
        "\n",
        "# Función para comprimir la carpeta con nivel de compresión máximo\n",
        "def compress_folder(folder_path, output_path, compression_level=zipfile.ZIP_DEFLATED):\n",
        "    with zipfile.ZipFile(output_path, 'w', compression=compression_level) as zipf:\n",
        "        for root, dirs, files in os.walk(folder_path):\n",
        "            for file in files:\n",
        "                file_path = os.path.join(root, file)\n",
        "                arcname = os.path.relpath(file_path, start=folder_path)\n",
        "                zipf.write(file_path, arcname)\n",
        "    print(f'Carpeta \"{folder_path}\" comprimida exitosamente como \"{output_path}\"')\n",
        "\n",
        "# Comprimir la carpeta con nivel de compresión máximo\n",
        "compress_folder(folder_to_zip, zip_filename, compression_level=zipfile.ZIP_DEFLATED)\n",
        "\n",
        "# Descargar el archivo comprimido\n",
        "files.download(zip_filename)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oK8M-_OR4USS"
      },
      "source": [
        "# **PASO 8. BORRAR CONTENIDO DE LAS CARPETAS PARA REALIZAR OTRO PROCESO**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JVDUCTVn3CZt",
        "outputId": "4e411fdb-f15a-40df-81cd-a58dfebbe547"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "La carpeta \"/content/Detecciones\" no existe.\n",
            "La carpeta \"/content/Fotografias\" no existe.\n",
            "La carpeta \"/content/Video\" no existe.\n",
            "rm: cannot remove '/content/detections_info.xlsx': No such file or directory\n"
          ]
        }
      ],
      "source": [
        "import os\n",
        "import shutil\n",
        "\n",
        "# Función para eliminar todos los archivos en una carpeta\n",
        "def delete_files_in_folder(folder_path):\n",
        "    # Verificar si la carpeta existe\n",
        "    if os.path.exists(folder_path):\n",
        "        # Iterar sobre todos los archivos en la carpeta\n",
        "        for filename in os.listdir(folder_path):\n",
        "            file_path = os.path.join(folder_path, filename)\n",
        "            try:\n",
        "                # Eliminar archivos\n",
        "                if os.path.isfile(file_path) or os.path.islink(file_path):\n",
        "                    os.unlink(file_path)\n",
        "                # Eliminar directorios\n",
        "                elif os.path.isdir(file_path):\n",
        "                    shutil.rmtree(file_path)\n",
        "            except Exception as e:\n",
        "                print(f'No se pudo eliminar {file_path}. Razón: {e}')\n",
        "        print(f'Todos los archivos en la carpeta \"{folder_path}\" han sido eliminados.')\n",
        "    else:\n",
        "        print(f'La carpeta \"{folder_path}\" no existe.')\n",
        "\n",
        "# Rutas de las carpetas a limpiar\n",
        "detections_folder = '/content/Detecciones'\n",
        "fotografias_folder = '/content/Fotografias'\n",
        "Videofolder= '/content/Video'\n",
        "\n",
        "# Eliminar archivos en las carpetas especificadas\n",
        "delete_files_in_folder(detections_folder)\n",
        "delete_files_in_folder(fotografias_folder)\n",
        "delete_files_in_folder(Videofolder)\n",
        "!rm '/content/detections_info.xlsx'\n",
        "\n",
        "\n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [
        "LA9VI44c_Dex",
        "8vj6ZhW5_ZiD",
        "x4XPW8VuVp-c",
        "tFtxr3jfNq-T"
      ],
      "gpuType": "T4",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}