data_Feature_extraction.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "Textural Parameter calculations"
      ],
      "metadata": {
        "id": "jWh21L7IbCJF"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8XeUdNlEuOsR"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import scipy.stats\n",
        "from skimage.feature import greycomatrix\n",
        "from scipy.spatial.distance import pdist, squareform\n",
        "from scipy.ndimage import label\n",
        "\n",
        "\n",
        "# Define a threshold for binary conversion (if needed)\n",
        "some_threshold = 0.5\n",
        "\n",
        "\n",
        "def calculate_fractal_dimension(image, scale_factor):\n",
        "\n",
        "    binary_image = (image > some_threshold).astype(int)\n",
        "    labeled_image, num_features = label(binary_image)\n",
        "    fractal_dimension = np.log(num_features) / np.log(1.0 / scale_factor)\n",
        "    return fractal_dimension\n",
        "\n",
        "# Entropy Calculation\n",
        "def calculate_entropy(image):\n",
        "    entropy = scipy.stats.entropy(image)\n",
        "    return entropy\n",
        "\n",
        "# Lacunarity Calculation\n",
        "def calculate_lacunarity(image):\n",
        "    mean = np.mean(image)\n",
        "    variance = np.var(image)\n",
        "    lacunarity = variance / (mean**2)\n",
        "    return lacunarity\n",
        "\n",
        "# Semivariogram Calculation\n",
        "def calculate_semivariogram(image):\n",
        "    image = img_as_ubyte(image)\n",
        "    glcm = greycomatrix(image, [1], [0], symmetric=True, normed=True)\n",
        "    distances = squareform(pdist(np.argwhere(image > some_threshold)))\n",
        "    semivariogram = np.var(glcm) * np.mean((distances - np.mean(distances))**2)\n",
        "    return semivariogram"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1kdf6SmCuVFI",
        "outputId": "b8002a37-f3d5-4375-d90a-6d88383a8600"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "import zipfile\n",
        "\n",
        "# Mount Google Drive\n",
        "drive.mount('/content/drive')\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Calculating the values for each image from the dataset"
      ],
      "metadata": {
        "id": "8xF_pqqgbPnu"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rTrXsAmCWGnG",
        "outputId": "7e0c9d5d-fe48-4b8f-92e8-fe97575be8c4"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/skimage/feature/__init__.py:35: skimage_deprecation: Function ``greycomatrix`` is deprecated and will be removed in version 1.0. Use ``skimage.feature.graycomatrix`` instead.\n",
            "  removed_version='1.0')\n"
          ]
        }
      ],
      "source": [
        "import os\n",
        "import numpy as np\n",
        "from skimage import io, img_as_ubyte, feature\n",
        "import pandas as pd\n",
        "from zipfile import ZipFile\n",
        "from google.colab import drive\n",
        "\n",
        "\n",
        "# Specify the path to the zip file containing your dataset in Google Drive\n",
        "zip_file_path = '/content/drive/MyDrive/data/gtos-mobile.zip'\n",
        "\n",
        "folders_to_process = ['brick', 'cement', 'grass', 'moss', 'pebble', 'sand', 'small_limestone', 'soil' ,'stone_asphalt', 'stone_brick', 'stone_cement']\n",
        "\n",
        "# Initialize lists to store results\n",
        "file_names = []\n",
        "fractal_dimensions = []\n",
        "lacunarity_values = []\n",
        "semivariogram_values = []\n",
        "entropy_values = []  # New list for entropy\n",
        "material_labels = []\n",
        "\n",
        "# Open the zip file and loop through its contents\n",
        "with ZipFile(zip_file_path, 'r') as zip_file:\n",
        "    for folder_name in folders_to_process:\n",
        "        folder_prefix = 'gtos-mobile/train/'+ folder_name + '/'  # Adjust this based on your folder structure\n",
        "        for entry in zip_file.infolist():\n",
        "            if entry.filename.startswith(folder_prefix) and (entry.filename.endswith('.jpg') or entry.filename.endswith('.png')):\n",
        "                # Read the image directly from the zip file\n",
        "                with zip_file.open(entry.filename) as file:\n",
        "                    image = io.imread(file, as_gray=True)\n",
        "                    image = img_as_ubyte(image)\n",
        "                    smaller_image = (image - np.min(image)) / (np.max(image) - np.min(image))\n",
        "\n",
        "                    fractal_dim = calculate_fractal_dimension(smaller_image, scale_factor=2)  # Replace with your fractal dimension calculation function\n",
        "                    lacunarity = calculate_lacunarity(smaller_image)  # Replace with your lacunarity calculation function\n",
        "                    semivariogram = calculate_semivariogram(image)  # Replace with your semivariogram calculation function\n",
        "                    # entropy = calculate_entropy(smaller_image)  # Replace with your entropy calculation function\n",
        "\n",
        "                    # Append results to lists\n",
        "                    file_names.append(entry.filename)\n",
        "                    fractal_dimensions.append(fractal_dim)\n",
        "                    lacunarity_values.append(lacunarity)\n",
        "                    semivariogram_values.append(semivariogram)\n",
        "                    # entropy_values.append(entropy)  # Add entropy value\n",
        "\n",
        "                    # Extract material label from the filename or directory structure\n",
        "                    material_label = folder_name  # Assuming folder name is the material label\n",
        "                    material_labels.append(material_label)\n",
        "\n",
        "# Create a DataFrame\n",
        "data = {\n",
        "    'filename': file_names,\n",
        "    'Fractal_dimension': fractal_dimensions,\n",
        "    'Lacunarity': lacunarity_values,\n",
        "    'Semivariogram': semivariogram_values,\n",
        "    # 'Entropy': entropy_values,  # Include entropy in the DataFrame\n",
        "    'Material_Label': material_labels\n",
        "}\n",
        "\n",
        "df = pd.DataFrame(data)\n",
        "\n",
        "# Save the DataFrame to a CSV file\n",
        "csv_file_path = '/content/drive/MyDrive/data/texture_features_tree.csv'\n",
        "df.to_csv(csv_file_path, index=False)\n",
        "\n",
        "print(\"Texture features saved to texture_features.csv\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "uUTI9ZTcWWuq",
        "outputId": "f3ebcea3-8412-4cb1-f9aa-61163e2f8892"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "\n",
              "  <div id=\"df-aba29f21-f328-414b-95a6-adaf8d512d94\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Fractal_dimension</th>\n",
              "      <th>Lacunarity</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>count</th>\n",
              "      <td>38646.000000</td>\n",
              "      <td>38646.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>mean</th>\n",
              "      <td>-7.920970</td>\n",
              "      <td>0.121026</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>std</th>\n",
              "      <td>2.088876</td>\n",
              "      <td>0.099649</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>min</th>\n",
              "      <td>-12.136671</td>\n",
              "      <td>0.000511</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>25%</th>\n",
              "      <td>-9.379378</td>\n",
              "      <td>0.046942</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>50%</th>\n",
              "      <td>-8.179909</td>\n",
              "      <td>0.093242</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>75%</th>\n",
              "      <td>-6.820179</td>\n",
              "      <td>0.165296</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>max</th>\n",
              "      <td>-0.000000</td>\n",
              "      <td>1.204755</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-aba29f21-f328-414b-95a6-adaf8d512d94')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-aba29f21-f328-414b-95a6-adaf8d512d94 button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-aba29f21-f328-414b-95a6-adaf8d512d94');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-d41ffd28-3c5f-4ed3-835b-d49073b9abd0\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-d41ffd28-3c5f-4ed3-835b-d49073b9abd0')\"\n",
              "            title=\"Suggest charts.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-d41ffd28-3c5f-4ed3-835b-d49073b9abd0 button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "    </div>\n",
              "  </div>\n"
            ],
            "text/plain": [
              "       Fractal_dimension    Lacunarity\n",
              "count       38646.000000  38646.000000\n",
              "mean           -7.920970      0.121026\n",
              "std             2.088876      0.099649\n",
              "min           -12.136671      0.000511\n",
              "25%            -9.379378      0.046942\n",
              "50%            -8.179909      0.093242\n",
              "75%            -6.820179      0.165296\n",
              "max            -0.000000      1.204755"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import pandas as pd\n",
        "\n",
        "d = pd.read_csv(\"/content/drive/MyDrive/data/terrain_roughness_classification.csv\")\n",
        "\n",
        "d.describe()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Adding the labels for Roughness estimation based on the Statistics of the calculated parameters"
      ],
      "metadata": {
        "id": "jWYmcoiNbWR3"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HOnBp22KV6_r"
      },
      "outputs": [],
      "source": [
        "df = pd.DataFrame(d)\n",
        "\n",
        "# Calculate the 25th and 75th percentiles (Q1 and Q3) for both fractal dimension and lacunarity\n",
        "Q1_fractal = np.percentile(df['Fractal_dimension'], 25)\n",
        "Q3_fractal = np.percentile(df['Fractal_dimension'], 75)\n",
        "Q1_lacunarity = np.percentile(df['Lacunarity'], 25)\n",
        "Q3_lacunarity = np.percentile(df['Lacunarity'], 75)\n",
        "\n",
        "# Define thresholds for terrain roughness based on percentiles\n",
        "threshold_smooth_fractal = Q1_fractal\n",
        "threshold_rough_fractal = Q3_fractal\n",
        "threshold_smooth_lacunarity = Q1_lacunarity\n",
        "threshold_rough_lacunarity = Q3_lacunarity\n",
        "\n",
        "# Classify terrain roughness based on thresholds\n",
        "def classify_terrain_roughness(row):\n",
        "    if (\n",
        "        row['Fractal_dimension'] <= threshold_smooth_fractal\n",
        "        and row['Lacunarity'] <= threshold_smooth_lacunarity\n",
        "    ):\n",
        "        return \"Relatively Smooth Terrain\"\n",
        "    elif (\n",
        "        row['Fractal_dimension'] >= threshold_rough_fractal\n",
        "        or row['Lacunarity'] >= threshold_rough_lacunarity\n",
        "    ):\n",
        "        return \"Rough Terrain\"\n",
        "    else:\n",
        "        return \"Moderate rough\"\n",
        "\n",
        "# Apply the classification function and add a new column to the DataFrame\n",
        "df['Terrain_Roughness'] = df.apply(classify_terrain_roughness, axis=1)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Training the machine learning model"
      ],
      "metadata": {
        "id": "TLGeTUdDbqQd"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DL2oabSUgasx"
      },
      "outputs": [],
      "source": [
        "file_path = 'terrain_roughness_classification.csv'\n",
        "\n",
        "# Save the DataFrame to a CSV file\n",
        "df.to_csv(file_path, index=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tYO9k57Rgq1X"
      },
      "outputs": [],
      "source": [
        "data = pd.read_csv(\"/content/drive/MyDrive/data/terrain_roughness_classification.csv\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 293
        },
        "id": "0m0rJ97Rxdp9",
        "outputId": "c2e7ba2e-ad00-4b7f-ad18-696ce8ef28f7"
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "\n",
              "  <div id=\"df-c43751f4-57fc-484a-b18f-41c45bbb577a\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>filename</th>\n",
              "      <th>Fractal_dimension</th>\n",
              "      <th>Lacunarity</th>\n",
              "      <th>Material_Label</th>\n",
              "      <th>Terrain_Roughness</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>gtos-mobile/train/brick/512_sample154_04_i13h.jpg</td>\n",
              "      <td>-6.918863</td>\n",
              "      <td>0.086210</td>\n",
              "      <td>brick</td>\n",
              "      <td>Moderate Terrain Roughness</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>gtos-mobile/train/brick/512_sample154_04_i09l.jpg</td>\n",
              "      <td>-7.330917</td>\n",
              "      <td>0.035026</td>\n",
              "      <td>brick</td>\n",
              "      <td>Moderate Terrain Roughness</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>gtos-mobile/train/brick/512_sample154_04_i11l.jpg</td>\n",
              "      <td>-7.357552</td>\n",
              "      <td>0.071256</td>\n",
              "      <td>brick</td>\n",
              "      <td>Moderate Terrain Roughness</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>gtos-mobile/train/brick/384_sample154_04_i12l.jpg</td>\n",
              "      <td>-9.967226</td>\n",
              "      <td>0.059995</td>\n",
              "      <td>brick</td>\n",
              "      <td>Moderate Terrain Roughness</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>gtos-mobile/train/brick/512_sample154_04_i14h.jpg</td>\n",
              "      <td>-5.584963</td>\n",
              "      <td>0.065416</td>\n",
              "      <td>brick</td>\n",
              "      <td>Rough Terrain</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-c43751f4-57fc-484a-b18f-41c45bbb577a')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-c43751f4-57fc-484a-b18f-41c45bbb577a button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-c43751f4-57fc-484a-b18f-41c45bbb577a');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-343227f3-5aca-4b22-97de-e9825b115cce\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-343227f3-5aca-4b22-97de-e9825b115cce')\"\n",
              "            title=\"Suggest charts.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-343227f3-5aca-4b22-97de-e9825b115cce button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "    </div>\n",
              "  </div>\n"
            ],
            "text/plain": [
              "                                            filename  Fractal_dimension  \\\n",
              "0  gtos-mobile/train/brick/512_sample154_04_i13h.jpg          -6.918863   \n",
              "1  gtos-mobile/train/brick/512_sample154_04_i09l.jpg          -7.330917   \n",
              "2  gtos-mobile/train/brick/512_sample154_04_i11l.jpg          -7.357552   \n",
              "3  gtos-mobile/train/brick/384_sample154_04_i12l.jpg          -9.967226   \n",
              "4  gtos-mobile/train/brick/512_sample154_04_i14h.jpg          -5.584963   \n",
              "\n",
              "   Lacunarity Material_Label           Terrain_Roughness  \n",
              "0    0.086210          brick  Moderate Terrain Roughness  \n",
              "1    0.035026          brick  Moderate Terrain Roughness  \n",
              "2    0.071256          brick  Moderate Terrain Roughness  \n",
              "3    0.059995          brick  Moderate Terrain Roughness  \n",
              "4    0.065416          brick               Rough Terrain  "
            ]
          },
          "execution_count": 5,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "data.head()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HX2KgkKPxrYu"
      },
      "outputs": [],
      "source": [
        "df_1  = pd.DataFrame(data)\n",
        "shuffled_df = df_1.sample(frac=1, random_state=42)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kNz_s5cNyJp0"
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.metrics import accuracy_score, classification_report\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "\n",
        "# Split the data into features (X) and labels (y) for terrain roughness and material label\n",
        "X = shuffled_df[['Fractal_dimension', 'Lacunarity']]\n",
        "y_terrain_roughness = shuffled_df['Terrain_Roughness']\n",
        "y_material_label = shuffled_df['Material_Label']\n",
        "\n",
        "# Split the data into training and testing sets (you can adjust the test_size as needed)\n",
        "X_train, X_test, y_train_terrain, y_test_terrain, y_train_material, y_test_material = train_test_split(\n",
        "    X, y_terrain_roughness, y_material_label, test_size=0.2, random_state=42\n",
        ")\n",
        "\n",
        "# Initialize the StandardScaler\n",
        "scaler = StandardScaler()\n",
        "\n",
        "# Fit the scaler to the training data and transform both the training and testing data\n",
        "X_train_scaled = scaler.fit_transform(X_train)\n",
        "X_test_scaled = scaler.transform(X_test)\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jyy6ZaG45fBS",
        "outputId": "bdfbe5da-1e40-4e93-f5ad-c1e213b80677"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['terrain_model.joblib']"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import joblib\n",
        "# Initialize and train a Random Forest Classifier for terrain roughness\n",
        "clf_terrain = RandomForestClassifier(n_estimators=100, random_state=42)\n",
        "clf_terrain.fit(X_train_scaled, y_train_terrain)\n",
        "\n",
        "\n",
        "\n",
        "# Assuming 'clf_terrain' is your trained Random Forest Classifier\n",
        "joblib.dump(clf_terrain, 'terrain_model.joblib')\n",
        "#"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3Cft_Ehi5rMI"
      },
      "outputs": [],
      "source": [
        "#Make predictions on terrain roughness for the test set\n",
        "y_pred_terrain = clf_terrain.predict(X_test_scaled)\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Qvb61tY-5yf8",
        "outputId": "69de4d37-0f43-499b-d501-c2ef634b8d38"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Terrain Roughness Classifier Accuracy: 1.0\n",
            "\n",
            "Classification Report for Terrain Roughness:\n",
            "                             precision    recall  f1-score   support\n",
            "\n",
            "Moderate Terrain Roughness       1.00      1.00      1.00      3762\n",
            " Relatively Smooth Terrain       1.00      1.00      1.00       577\n",
            "             Rough Terrain       1.00      1.00      1.00      3391\n",
            "\n",
            "                  accuracy                           1.00      7730\n",
            "                 macro avg       1.00      1.00      1.00      7730\n",
            "              weighted avg       1.00      1.00      1.00      7730\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# Evaluate the terrain roughness classifier\n",
        "terrain_accuracy = accuracy_score(y_test_terrain, y_pred_terrain)\n",
        "print(\"Terrain Roughness Classifier Accuracy:\", terrain_accuracy)\n",
        "print(\"\\nClassification Report for Terrain Roughness:\\n\", classification_report(y_test_terrain, y_pred_terrain))\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e_wY22hE53SB",
        "outputId": "9e84ab43-1768-41ce-a77c-0e15a5c0bea2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Material Label Classifier Accuracy: 0.291849935316947\n",
            "\n",
            "Classification Report for Material Label:\n",
            "                  precision    recall  f1-score   support\n",
            "\n",
            "          brick       0.30      0.29      0.29       966\n",
            "         cement       0.46      0.50      0.48      1535\n",
            "          grass       0.24      0.27      0.26       597\n",
            "           moss       0.20      0.20      0.20       521\n",
            "         pebble       0.31      0.35      0.33       645\n",
            "           sand       0.21      0.17      0.19       488\n",
            "small_limestone       0.29      0.31      0.30       791\n",
            "           soil       0.22      0.21      0.21       858\n",
            "  stone_asphalt       0.11      0.08      0.09       413\n",
            "    stone_brick       0.28      0.28      0.28       414\n",
            "   stone_cement       0.14      0.12      0.13       502\n",
            "\n",
            "       accuracy                           0.29      7730\n",
            "      macro avg       0.25      0.25      0.25      7730\n",
            "   weighted avg       0.28      0.29      0.29      7730\n",
            "\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "['material_model.joblib']"
            ]
          },
          "execution_count": 23,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Initialize and train a Random Forest Classifier for material label\n",
        "clf_material = RandomForestClassifier(n_estimators=100, random_state=42)\n",
        "clf_material.fit(X_train_scaled, y_train_material)\n",
        "\n",
        "# Make predictions on material label for the test set\n",
        "y_pred_material = clf_material.predict(X_test_scaled)\n",
        "\n",
        "# Evaluate the material label classifier\n",
        "material_accuracy = accuracy_score(y_test_material, y_pred_material)\n",
        "print(\"Material Label Classifier Accuracy:\", material_accuracy)\n",
        "print(\"\\nClassification Report for Material Label:\\n\", classification_report(y_test_material, y_pred_material))\n",
        "\n",
        "joblib.dump(clf_material, 'material_model.joblib')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jQwee4hp8kHk"
      },
      "source": [
        "Testing on random images"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "JTDTlRGV57vc",
        "outputId": "ef46451b-88d7-48e2-b669-5797eac23c8d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Predicted Terrain Roughness: ['Moderate Terrain Roughness']\n",
            "Predicted Terrain type: ['small_limestone']\n"
          ]
        }
      ],
      "source": [
        "import cv2\n",
        "from skimage import io, img_as_ubyte, feature\n",
        "\n",
        "# Load and preprocess the single image (replace 'image_path.jpg' with the actual image path)\n",
        "image_path = '/content/photo1695488130.jpeg'\n",
        "features = []\n",
        "\n",
        "\n",
        "\n",
        "# Extract relevant features (fractal dimension and lacunarity) from the image\n",
        "image = io.imread(image_path, as_gray=True)\n",
        "image = img_as_ubyte(image)\n",
        "smaller_image = (image - np.min(image)) / (np.max(image) - np.min(image))\n",
        "\n",
        "def extract_features(image):\n",
        "    # Implement your feature extraction method here\n",
        "    # Example: Calculate fractal dimension and lacunarity from the image\n",
        "    fractal_dimension = calculate_fractal_dimension(image, scale_factor = 2)\n",
        "    lacunarity = calculate_lacunarity(image)\n",
        "\n",
        "    # Return the features as a dictionary\n",
        "    features = {\n",
        "        'Fractal_dimension': fractal_dimension,\n",
        "        'Lacunarity': lacunarity\n",
        "    }\n",
        "\n",
        "    return features\n",
        "\n",
        "# Extract features from the image\n",
        "image_features = extract_features(smaller_image)\n",
        "\n",
        "# Create a DataFrame from the extracted features\n",
        "df_in = pd.DataFrame([image_features])\n",
        "\n",
        "# Scale the features using the same scaler used during model training\n",
        "# Initialize the StandardScaler\n",
        "scaler = StandardScaler()\n",
        "scaler.fit(X_train)\n",
        "\n",
        "# Use the scaler to transform the extracted features\n",
        "scaled_features = scaler.transform(df_in)  # Replace 'features' with the extracted features\n",
        "\n",
        "# Initialize the trained Random Forest Classifier for terrain roughness\n",
        "# clf_terrain = RandomForestClassifier(n_estimators=100, random_state=42)\n",
        "\n",
        "# Load the trained model weights (replace 'model_weights.pkl' with your trained model's file)\n",
        "loaded_model = joblib.load('terrain_model.joblib')\n",
        "loaded_model_1 = joblib.load('material_model.joblib')\n",
        "\n",
        "\n",
        "# Make predictions on the single image\n",
        "predicted_terrain = loaded_model.predict(scaled_features)\n",
        "predicted_label = loaded_model_1.predict(scaled_features)\n",
        "\n",
        "# Print the predicted terrain roughness\n",
        "print(\"Predicted Terrain Roughness:\", predicted_terrain)\n",
        "print(\"Predicted Terrain type:\", predicted_label)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4r9CT9-X_U48"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}