final_part1_part2_part3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "173\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from PIL import Image\n",
    "import hashlib\n",
    "\n",
    "def image_to_byte_array(image):\n",
    "    img_byte_array = bytearray()\n",
    "    img_byte_array.extend(image.tobytes())\n",
    "    return bytes(img_byte_array)\n",
    "\n",
    "def remove_duplicates(source_folder, destination_folder):\n",
    "    # Create the destination folder if it doesn't exist\n",
    "    if not os.path.exists(destination_folder):\n",
    "        os.makedirs(destination_folder)\n",
    "    \n",
    "    # Dictionary to store the hash values of images\n",
    "    hash_dict = {}\n",
    "\n",
    "    # Iterate through each image file in the source folder\n",
    "    for filename in os.listdir(source_folder):\n",
    "        filepath = os.path.join(source_folder, filename)\n",
    "        if os.path.isfile(filepath):\n",
    "            # Open the image file and convert it to bytes\n",
    "            img = Image.open(filepath)\n",
    "            img_bytes = image_to_byte_array(img)\n",
    "\n",
    "            # Calculate the MD5 hash value of the image bytes\n",
    "            img_hash = hashlib.md5(img_bytes).hexdigest()\n",
    "\n",
    "            # Check if the hash value already exists in the dictionary\n",
    "            if img_hash not in hash_dict:\n",
    "                # If not, copy the image to the destination folder\n",
    "                img.save(os.path.join(destination_folder, filename))\n",
    "                \n",
    "                # Store the hash value in the dictionary\n",
    "                hash_dict[img_hash] = filename\n",
    "            \n",
    "# Specify the source folder containing the images\n",
    "source_folder = 'E7-images'\n",
    "\n",
    "# Specify the destination folder for storing cleaned images\n",
    "destination_folder = 'E7-unique-images'\n",
    "\n",
    "# Call the function to remove duplicates\n",
    "remove_duplicates(source_folder, destination_folder)\n",
    "number_of_images = len(os.listdir(destination_folder))\n",
    "print(number_of_images)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_features(contours):\n",
    "    features = []\n",
    "    for contour in contours:\n",
    "        # Minimum area rectangle\n",
    "        rect = cv2.minAreaRect(contour) #tight-fitting box\n",
    "            \n",
    "        # Box coordinates\n",
    "        box = cv2.boxPoints(rect)\n",
    "        box = np.int0(box)\n",
    "        tight_fitting_boxes.append(box)\n",
    "            \n",
    "        # Calculate dimensions\n",
    "        dim1 = np.linalg.norm(box[0] - box[1])\n",
    "        dim2 = np.linalg.norm(box[1] - box[2])\n",
    "            \n",
    "        dim_1.append(dim1)\n",
    "        dim_2.append(dim2)\n",
    "        # Calculate contour area\n",
    "        contour_area = cv2.contourArea(contour)\n",
    "        contour_areas.append(contour_area)\n",
    "            \n",
    "        # Calculate layout area\n",
    "        tight_fit_box_area = dim1 * dim2\n",
    "        tight_fit_box_areas.append(tight_fit_box_area)\n",
    "            \n",
    "        # Draw tight-fitting box and contours on the image (for visualization)\n",
    "        cv2.drawContours(original_image, [box], 0, (0, 255, 0), 2)  # Tight-fitting box\n",
    "        cv2.drawContours(original_image, [contour], 0, (255, 0, 0), 2)  # Contour\n",
    "        \n",
    "        \n",
    "        # Number of vertices\n",
    "        num_vertices = len(contour)\n",
    "        \n",
    "        # Perimeter\n",
    "        perimeter = cv2.arcLength(contour, True)\n",
    "        \n",
    "        p_a = perimeter / contour_area\n",
    "\n",
    "        circularity = (4 * np.pi * contour_area) / (perimeter ** 2)\n",
    "        \n",
    "        # Angle changes\n",
    "        angles = []\n",
    "        for i in range(num_vertices):\n",
    "            p1 = contour[i][0]\n",
    "            p2 = contour[(i + 1) % num_vertices][0]\n",
    "            p3 = contour[(i + 2) % num_vertices][0]\n",
    "            v1 = np.array(p1) - np.array(p2)\n",
    "            v2 = np.array(p3) - np.array(p2)\n",
    "            angle = np.arccos(np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2)))\n",
    "            angles.append(np.degrees(angle))\n",
    "        \n",
    "        # Minimum, maximum, and mean angle changes\n",
    "        min_angle_change = np.min(angles)\n",
    "        max_angle_change = np.max(angles)\n",
    "        mean_angle_change = np.mean(angles)\n",
    "        \n",
    "        # Ratio of area of contour to tight bounding rectangle\n",
    "        x, y, w, h = cv2.boundingRect(contour)\n",
    "        bounding_rect_area = w * h\n",
    "        ratio_area_to_bounding_rect = contour_area / bounding_rect_area\n",
    "\n",
    "        M = cv2.moments(contour)\n",
    "        cx = int(M['m10'] / M['m00'])  # Centroid x\n",
    "        cy = int(M['m01'] / M['m00'])  # Centroid y\n",
    "        distances = [np.sqrt((point[0][0] - cx) ** 2 + (point[0][1] - cy) ** 2) for point in contour]\n",
    "        avg_distance_from_centroid = np.mean(distances)\n",
    "        symmetry = perimeter / avg_distance_from_centroid\n",
    "\n",
    "        laplacian = cv2.Laplacian(image, cv2.CV_64F)\n",
    "        gradient_magnitude = np.mean(np.abs(laplacian))\n",
    "        \n",
    "        features.append([num_vertices, perimeter, contour_area, p_a, circularity, min_angle_change,max_angle_change, mean_angle_change , dim1, dim2, ratio_area_to_bounding_rect, symmetry, gradient_magnitude])\n",
    "    \n",
    "    return features\n",
    "\n",
    "\n",
    "   \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\bpadm\\AppData\\Local\\Temp\\ipykernel_8384\\942949031.py:9: DeprecationWarning: `np.int0` is a deprecated alias for `np.intp`.  (Deprecated NumPy 1.24)\n",
      "  box = np.int0(box)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Results saved to: features.csv\n"
     ]
    }
   ],
   "source": [
    "import cv2 #cv2 stands for opencv : opensource computer vision and ml library\n",
    "import numpy as np\n",
    "import os #interacting with operating system- to do things like we use command line for accessing and manipulating files\n",
    "import csv\n",
    "import pandas as pd\n",
    "from sklearn.cluster import KMeans\n",
    "from shutil import copyfile\n",
    "\n",
    "# Path to the folder containing your images\n",
    "folder_path = \"E7-unique-images\"\n",
    "\n",
    "tfimage_folder = \"E7-tfimages\"\n",
    "os.makedirs(tfimage_folder, exist_ok=True)\n",
    "\n",
    "# Initialize lists to store results\n",
    "images =[]\n",
    "tight_fitting_boxes = []\n",
    "contour_areas = []\n",
    "tight_fit_box_areas = []\n",
    "dim_1=[]\n",
    "dim_2=[]\n",
    "features_list=[]\n",
    "\n",
    "processed_images=0\n",
    "\n",
    "# Iterate over all files in the folder\n",
    "for filename in os.listdir(folder_path):\n",
    "    # Check if the file is an image (JPG OR JPEG or PNG)\n",
    "    if filename.endswith(\".jpg\") or filename.endswith(\".jpeg\") or filename.endswith(\".png\"): #so that we don't run into a situation where we are doing imge kund operations on some non-image files\n",
    "        # Construct the full path to the image file\n",
    "        img_path = os.path.join(folder_path, filename)\n",
    "        \n",
    "        # Load image\n",
    "        image = cv2.imread(img_path) #reading specific image file\n",
    "        images.append(image)\n",
    "        original_image = image.copy()  # Save a copy for visualization\n",
    "        \n",
    "        # Convert image to grayscale\n",
    "        gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) #conversion flag- cv2.COLOR_BGR2GRAY\n",
    "        \n",
    "        # Threshold the image to create a mask of colored areas \n",
    "        #threshhold fn gives threshold value and thresholded image as output.\n",
    "        _, masked_image = cv2.threshold(gray_image, 200, 255, cv2.THRESH_BINARY_INV) \n",
    "        # 200 is our threshold value. pixels above 200 get conv into 255(W) and rest into 0(B): then through binary inversion fn they are inverted -- swaped.\n",
    "\n",
    "        # Find contours \n",
    "        #findContours function gives contours and their heirarchies\n",
    "        contours, _ = cv2.findContours(masked_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) \n",
    "        #cv2.RETR_EXTERNAL ignores any internal contours that exist. \n",
    "        #cv2.CHAIN_APPROX_SIMPLE is contour approximation method- compresses horizontal, vertical, and diagonal segments and leaves only their end points.\n",
    "        \n",
    "        extractedfeatures=extract_features(contours)\n",
    "        for features in extractedfeatures:\n",
    "            features.insert(0, filename)\n",
    "        # Write processed image to output folder\n",
    "        output_img_path = os.path.join(tfimage_folder, filename)\n",
    "        cv2.imwrite(output_img_path, original_image)\n",
    "        \n",
    "        # Increment the counter\n",
    "        processed_images += 1\n",
    "\n",
    "        features_list.extend(extractedfeatures)\n",
    "        \n",
    "# Save features to CSV\n",
    "csv_file = \"features.csv\"\n",
    "with open(csv_file, mode='w', newline='') as file:\n",
    "    writer = csv.writer(file) \n",
    "    writer.writerow([\"Image Number\",\"Num_Vertices\", \"Perimeter\", \"Contour Area\",\"ratio of perimeter and area\", \"Circularity\", \"Min_Angle_Change\", \"Max_Angle_Change\", \"Mean_Angle_Change\", \"dim1 of tfb\", \"dim2 of tfb\",\"Ratio_Area_to_Bounding_Rect\", \"Symmetry\",\"gradient_magnitude\"])\n",
    "    writer.writerows(features_list)\n",
    "\n",
    "print(\"Results saved to:\", csv_file)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Images moved to respective cluster folders.\n",
      "Centroids of Clusters:\n",
      "Cluster 0 Centroid: [-0.94319453 -0.28930402 -0.20666909 -0.39288937 -0.4522806  -0.01540116]\n",
      "Cluster 1 Centroid: [ 2.64508546 -1.63155924  0.50412281  0.39741403  0.18662726  0.01804356]\n",
      "Cluster 2 Centroid: [-3.01506008  0.24535758  0.26869973  0.41264837  0.38532818  0.01698229]\n",
      "Cluster 3 Centroid: [ 2.33736338  1.50107844 -0.3568276  -0.1314233   0.15509792 -0.00793038]\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.cluster import KMeans\n",
    "from shutil import copyfile\n",
    "\n",
    "# Read the CSV file\n",
    "df = pd.read_csv(csv_file)\n",
    "\n",
    "# Extract features\n",
    "\n",
    "features = df.iloc[:, 1:].values\n",
    "\n",
    "# Scale the features\n",
    "scaler = StandardScaler()\n",
    "features_scaled = scaler.fit_transform(features)\n",
    "\n",
    "# Perform PCA\n",
    "pca = PCA(n_components=0.95)  # Retain 95% of variance\n",
    "features_pca = pca.fit_transform(features_scaled)\n",
    "\n",
    "pca_df = pd.DataFrame(features_pca, columns=[f\"PC{i+1}\" for i in range(features_pca.shape[1])])\n",
    "pca_df.to_csv(\"pca_transformed_features.csv\", index=False)\n",
    "\n",
    "# Perform k-means clustering\n",
    "kmeans = KMeans(n_clusters=4, random_state=42)\n",
    "clusters = kmeans.fit_predict(features_pca)\n",
    "\n",
    "# Create folder for clusters\n",
    "clusters_folder = \"4clusterspca\"\n",
    "os.makedirs(clusters_folder, exist_ok=True)\n",
    "\n",
    "# Create folders for each cluster inside the 'clusters' directory\n",
    "for cluster_id in range(4):\n",
    "    cluster_folder = os.path.join(clusters_folder, f\"Cluster_{cluster_id}\")\n",
    "    os.makedirs(cluster_folder, exist_ok=True)\n",
    "\n",
    "# Move images to respective cluster folders\n",
    "for filename, cluster_id in zip(df['Image Number'], clusters):\n",
    "    source_path = os.path.join(tfimage_folder, str(filename))  # Convert filename to string\n",
    "    dest_folder = os.path.join(clusters_folder, f\"Cluster_{cluster_id}\")\n",
    "    dest_path = os.path.join(dest_folder, str(filename))  # Convert filename to string\n",
    "    \n",
    "    # Check if source file exists before copying\n",
    "    if os.path.isfile(source_path):\n",
    "        copyfile(source_path, dest_path)\n",
    "    \n",
    "\n",
    "print(\"Images moved to respective cluster folders.\")\n",
    "\n",
    "# # Move images to respective cluster folders\n",
    "# for filename, cluster_id in zip(df['Image Number'], clusters):\n",
    "#     source_path = os.path.join(tfimage_folder, filename)\n",
    "#     dest_folder = os.path.join(clusters_folder, f\"Cluster_{cluster_id}\")\n",
    "#     dest_path = os.path.join(dest_folder, filename)\n",
    "    \n",
    "#     # Check if source file exists before copying\n",
    "#     if os.path.isfile(source_path):\n",
    "#         copyfile(source_path, dest_path)\n",
    "#     else:\n",
    "#         print(f\"Source file '{source_path}' does not exist.\")\n",
    "\n",
    "# print(\"Images moved to respective cluster folders.\")\n",
    "\n",
    "# Access centroids of clusters\n",
    "centroids = kmeans.cluster_centers_\n",
    "\n",
    "# Print centroids\n",
    "print(\"Centroids of Clusters:\")\n",
    "for i, centroid in enumerate(centroids):\n",
    "    print(f\"Cluster {i} Centroid:\", centroid)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Images grouped based on complexity.\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.cluster import KMeans\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.decomposition import PCA\n",
    "import os\n",
    "import shutil\n",
    "from shutil import copyfile\n",
    "\n",
    "# Step 1: Read the features from the CSV file\n",
    "features_df = pd.read_csv('features.csv')\n",
    "\n",
    "# Step 2: Extract the features you mentioned\n",
    "selected_features = ['ratio of perimeter and area', 'Circularity', 'Min_Angle_Change',\n",
    "                     'Max_Angle_Change', 'Mean_Angle_Change', 'Ratio_Area_to_Bounding_Rect', 'Symmetry','gradient_magnitude']\n",
    "X = features_df[selected_features]\n",
    "\n",
    "# Scale the features\n",
    "scaler = StandardScaler()\n",
    "features_scaled = scaler.fit_transform(X)\n",
    "\n",
    "# Perform PCA\n",
    "pca = PCA(n_components=3)  # Retain 3 components\n",
    "features_pca = pca.fit_transform(features_scaled)\n",
    "\n",
    "# Perform k-means clustering\n",
    "kmeans = KMeans(n_clusters=3, random_state=42)\n",
    "labels = kmeans.fit_predict(features_pca)\n",
    "\n",
    "# Step 4: Calculate complexity measure (e.g., average Circularities) for each cluster\n",
    "cluster_complexity = {}\n",
    "for cluster_label in range(3):\n",
    "    cluster_indices = (labels == cluster_label)\n",
    "    cluster_complexity[cluster_label] = X[cluster_indices]['Circularity'].mean()\n",
    "\n",
    "# Step 5: Define thresholds based on the complexity measure\n",
    "low_threshold = min(cluster_complexity.values())\n",
    "high_threshold = max(cluster_complexity.values())\n",
    "medium_threshold = (low_threshold + high_threshold) / 2\n",
    "\n",
    "# Step 6: Assign labels based on thresholds\n",
    "for cluster_label, complexity_measure in cluster_complexity.items():\n",
    "    if complexity_measure < medium_threshold:\n",
    "        complexity_label = 'Low'\n",
    "    elif complexity_measure < high_threshold:\n",
    "        complexity_label = 'Medium'\n",
    "    else:\n",
    "        complexity_label = 'High'\n",
    "    #print(f\"Cluster {cluster_label}: {complexity_label} complexity\")\n",
    "\n",
    "# Step 7: Add the complexity labels to the CSV file\n",
    "features_df['Complexity'] = labels\n",
    "features_df.to_csv('features_with_labels.csv', index=False)\n",
    "\n",
    "# Load the CSV file\n",
    "csv_file = \"features_with_labels.csv\"\n",
    "data = pd.read_csv(csv_file)\n",
    "\n",
    "# Folder containing the images\n",
    "image_folder = \"E7-unique-images\"\n",
    "\n",
    "# Folder to store the grouped images\n",
    "out_folder = \"labelledcomplexities\"\n",
    "\n",
    "# Create the output folder if it doesn't exist\n",
    "os.makedirs(out_folder, exist_ok=True)\n",
    "\n",
    "# Group images based on Complexity column\n",
    "for index, row in data.iterrows():\n",
    "    image_number = row[\"Image Number\"]\n",
    "    complexity = row[\"Complexity\"]\n",
    "    \n",
    "    # Define destination folder based on complexity\n",
    "    destination_folder = os.path.join(out_folder, f\"complexity_{complexity}\")\n",
    "    os.makedirs(destination_folder, exist_ok=True)\n",
    "    \n",
    "    # Source path\n",
    "    source_path = os.path.join(image_folder, image_number)\n",
    "    \n",
    "    # Destination path\n",
    "    destination_path = os.path.join(destination_folder, image_number)\n",
    "    \n",
    "    if os.path.isfile(source_path):\n",
    "        copyfile(source_path, destination_path)\n",
    "\n",
    "print(\"Images grouped based on complexity.\")\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "import os\n",
    "import pandas as pd\n",
    "\n",
    "# Define the paths to the complexity level folders and corresponding complexity values\n",
    "complexity_folders = [\"Complexity_0\", \"Complexity_1\", \"Complexity_2\"]\n",
    "complexity_values = [1, 0, 2]  # Example complexity values for each folder\n",
    "\n",
    "# Read the CSV file\n",
    "csv_file = \"features_with_labels.csv\"\n",
    "features_df = pd.read_csv(csv_file)\n",
    "\n",
    "# Iterate over each complexity level folder and its corresponding complexity value\n",
    "for complexity_folder, complexity_value in zip(complexity_folders, complexity_values):\n",
    "    # Get the list of image names in the current complexity level folder\n",
    "    image_names_in_folder = os.listdir(os.path.join(\"labelledcomplexities\", complexity_folder))\n",
    "    \n",
    "    # Update the complexity values for images in the current complexity level folder\n",
    "    features_df.loc[features_df['Image Number'].isin(image_names_in_folder), 'Complexity'] = complexity_value\n",
    "\n",
    "# Save the updated DataFrame back to the CSV file\n",
    "features_df.to_csv(csv_file, index=False)\n",
    "\n",
    "\n",
    "\n",
    "current_folder_names = [\"Complexity_0\", \"Complexity_1\", \"Complexity_2\"]\n",
    "new_folder_names = [\"ComplexityMedium\", \"ComplexityLow\", \"ComplexityHigh\"]\n",
    "\n",
    "# Iterate over each pair of current and new folder names\n",
    "for current_name, new_name in zip(current_folder_names, new_folder_names):\n",
    "    # Construct the full paths of the folders\n",
    "    current_path = os.path.join(\"labelledcomplexities\", current_name)\n",
    "    new_path = os.path.join(\"labelledcomplexities\", new_name)\n",
    "    \n",
    "    # Check if the new folder already exists\n",
    "    if os.path.exists(new_path):\n",
    "        # If it exists, delete it and its contents\n",
    "        shutil.rmtree(new_path)\n",
    "        \n",
    "    \n",
    "    # Rename the folder\n",
    "    os.rename(current_path, new_path)\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Relevant Layouts for dim1/dim2 ratio:\n",
      "    Image Number  Num_Vertices    Perimeter  Contour Area  \\\n",
      "7       0008.jpg           413  1476.541192      103871.5   \n",
      "57      0068.jpg           453  1433.352374       96279.0   \n",
      "118     0239.jpg           419  1354.413338       95234.5   \n",
      "149     0503.jpg           431  1372.974739       97078.0   \n",
      "172     1083.jpg           449  1431.109733       98164.5   \n",
      "103     0197.jpg           472  1433.009228       98533.0   \n",
      "85      0122.jpg           390  1385.862043       97375.0   \n",
      "159     0619.jpg           507  1394.472212      102559.5   \n",
      "158     0607.jpg           377  1346.129066      101541.5   \n",
      "\n",
      "     ratio of perimeter and area  Circularity  Min_Angle_Change  \\\n",
      "7                       0.014215     0.598708              90.0   \n",
      "57                      0.014887     0.588892              90.0   \n",
      "118                     0.014222     0.652382              90.0   \n",
      "149                     0.014143     0.647151              90.0   \n",
      "172                     0.014579     0.602308              90.0   \n",
      "103                     0.014543     0.602967              90.0   \n",
      "85                      0.014232     0.637114              90.0   \n",
      "159                     0.013597     0.662775              90.0   \n",
      "158                     0.013257     0.704174              90.0   \n",
      "\n",
      "     Max_Angle_Change  Mean_Angle_Change  dim1 of tfb  dim2 of tfb  \\\n",
      "7               135.0         132.711864   307.936682   471.454134   \n",
      "57              135.0         133.708609   334.037423   451.039910   \n",
      "118             135.0         131.670644   335.005970   450.004444   \n",
      "149             135.0         133.225058   334.095795   450.111097   \n",
      "172             135.0         134.097996   333.541602   450.750485   \n",
      "103             135.0         133.665254   334.293284   451.443241   \n",
      "85              135.0         132.230769   335.053727   449.071264   \n",
      "159             135.0         132.426036   332.398857   451.624844   \n",
      "158             135.0         132.732095   334.005988   450.004444   \n",
      "\n",
      "     Ratio_Area_to_Bounding_Rect  Symmetry  gradient_magnitude  Complexity  \\\n",
      "7                       0.686981  7.407456            0.684993           1   \n",
      "57                      0.633948  7.882924            0.654883           1   \n",
      "118                     0.628461  7.298813            0.643581           1   \n",
      "149                     0.640627  7.445316            0.645445           1   \n",
      "172                     0.646363  7.779802            0.658077           1   \n",
      "103                     0.648790  7.730178            0.661862           1   \n",
      "85                      0.642587  7.319485            0.638166           1   \n",
      "159                     0.676800  7.671832            0.639763           1   \n",
      "158                     0.670082  7.217747            0.633071           1   \n",
      "\n",
      "     dim1_dim2_ratio  \n",
      "7           0.653164  \n",
      "57          0.740594  \n",
      "118         0.744450  \n",
      "149         0.742252  \n",
      "172         0.739969  \n",
      "103         0.740499  \n",
      "85          0.746104  \n",
      "159         0.736007  \n",
      "158         0.742228  \n",
      "\n",
      "Relevant Layouts for dim2/dim1 ratio:\n",
      "    Image Number  Num_Vertices    Perimeter  Contour Area  \\\n",
      "40      0044.jpg           642  1389.803165      102915.0   \n",
      "3       0004.jpg           405  1458.523947       99592.0   \n",
      "148     0500.jpg           600  1381.033613       95669.0   \n",
      "33      0036.jpg           425  1395.234625       99196.0   \n",
      "2       0003.jpg           511  1408.489458      106259.0   \n",
      "54      0065.jpg           530  1410.246817      106769.5   \n",
      "89      0134.jpg           267  1521.747255      106031.5   \n",
      "42      0046.jpg           459  1581.168608      113966.5   \n",
      "58      0069.jpg           276  1525.646749      106651.0   \n",
      "\n",
      "     ratio of perimeter and area  Circularity  Min_Angle_Change  \\\n",
      "40                      0.013504     0.669548              90.0   \n",
      "3                       0.014645     0.588311              90.0   \n",
      "148                     0.014436     0.630337              90.0   \n",
      "33                      0.014065     0.640338              90.0   \n",
      "2                       0.013255     0.673083              45.0   \n",
      "54                      0.013208     0.674632              90.0   \n",
      "89                      0.014352     0.575387              90.0   \n",
      "42                      0.013874     0.572837              90.0   \n",
      "58                      0.014305     0.575794              90.0   \n",
      "\n",
      "     Max_Angle_Change  Mean_Angle_Change  dim1 of tfb  dim2 of tfb  \\\n",
      "40              135.0         134.299065   462.640249   308.520664   \n",
      "3               135.0         133.777778   461.433636   317.266450   \n",
      "148             135.0         134.700000   489.866308   298.872883   \n",
      "33              135.0         133.411765   456.530393   326.392402   \n",
      "2               135.0         133.150685   452.518508   320.515210   \n",
      "54              135.0         133.811321   453.282473   320.090612   \n",
      "89              135.0         132.471910   448.763858   320.761594   \n",
      "42              135.0         132.549020   482.029045   303.815734   \n",
      "58              135.0         132.717391   448.906449   323.125363   \n",
      "\n",
      "     Ratio_Area_to_Bounding_Rect  Symmetry  gradient_magnitude  Complexity  \\\n",
      "40                      0.679146  7.355072            0.654859           1   \n",
      "3                       0.653817  7.853922            0.655640           1   \n",
      "148                     0.631329  7.601801            0.635102           1   \n",
      "33                      0.654604  7.621622            0.651135           1   \n",
      "2                       0.699132  7.528179            0.654069           1   \n",
      "54                      0.704582  7.522646            0.660226           1   \n",
      "89                      0.696092  7.428043            0.683353           1   \n",
      "42                      0.750412  8.236562            0.724065           1   \n",
      "58                      0.700159  7.301081            0.686664           1   \n",
      "\n",
      "     dim1_dim2_ratio  \n",
      "40          1.499544  \n",
      "3           1.454404  \n",
      "148         1.639046  \n",
      "33          1.398716  \n",
      "2           1.411847  \n",
      "54          1.416107  \n",
      "89          1.399057  \n",
      "42          1.586584  \n",
      "58          1.389264  \n",
      "\n",
      "Displaying images of relevant layouts for dim1/dim2 ratio:\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x500 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Displaying images of relevant layouts for dim2/dim1 ratio:\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x500 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.neighbors import NearestNeighbors\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.image as mpimg\n",
    "import os\n",
    "\n",
    "# Load data from CSV file\n",
    "data = pd.read_csv(\"features_with_labels.csv\")\n",
    "\n",
    "# Placeholder function to preprocess data (replace with your actual preprocessing logic)\n",
    "def preprocess_data(data):\n",
    "    # Placeholder preprocessing steps (you may need to adapt this based on your actual data)\n",
    "    data['dim1_dim2_ratio'] = data['dim1 of tfb'] / data['dim2 of tfb']\n",
    "    X = data[['dim1_dim2_ratio', 'Complexity', 'Ratio_Area_to_Bounding_Rect']].values\n",
    "    return X\n",
    "\n",
    "# Preprocess data\n",
    "X = preprocess_data(data)\n",
    "\n",
    "# Function to predict relevant layout designs based on parameters\n",
    "def predict_layouts(dim1_dim2_ratio, complexity, ratio_area_to_bounding_rect, num_neighbors=9):\n",
    "    input_params = np.array([[dim1_dim2_ratio, complexity, ratio_area_to_bounding_rect]])\n",
    "    \n",
    "    # Initialize and fit nearest neighbors model\n",
    "    nn_model = NearestNeighbors(n_neighbors=num_neighbors)\n",
    "    nn_model.fit(X)\n",
    "    \n",
    "    # Find nearest neighbors based on input parameters\n",
    "    distances, indices = nn_model.kneighbors(input_params)\n",
    "    \n",
    "    # Retrieve and return relevant layouts\n",
    "    relevant_layouts = data.iloc[indices[0]]\n",
    "    relevant_layouts = relevant_layouts[relevant_layouts['Complexity'] == complexity]\n",
    "    \n",
    "    return relevant_layouts\n",
    "\n",
    "# Function to display images of relevant layouts\n",
    "def display_layout_images(relevant_layouts, image_folder, nrows=3, ncols=3):\n",
    "    \"\"\"\n",
    "    Display images of relevant layouts in a grid.\n",
    "\n",
    "    Args:\n",
    "        relevant_layouts (pd.DataFrame): DataFrame containing relevant layouts.\n",
    "        image_folder (str): Folder containing the images.\n",
    "        nrows (int): Number of rows in the grid.\n",
    "        ncols (int): Number of columns in the grid.\n",
    "\n",
    "    Returns:\n",
    "        None: This function does not return any value. It only displays the images.\n",
    "    \"\"\"\n",
    "    plt.figure(figsize=(15, 5))\n",
    "    for i, filename in enumerate(relevant_layouts['Image Number']):\n",
    "        img_path = os.path.join(image_folder, filename)\n",
    "        img = mpimg.imread(img_path)\n",
    "        plt.subplot(nrows, ncols, i + 1)\n",
    "        plt.imshow(img)\n",
    "        plt.title(filename)\n",
    "        plt.axis('off')\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "dim1 = float(input(\"Enter the dim1 of tfb: \"))  # Example dim1\n",
    "dim2 = float(input(\"Enter the dim2 of tfb: \"))  # Example dim2\n",
    "complexity = int(input(\"Enter the complexity: \"))  # Example complexity\n",
    "cont_area = float(input(\"Enter the Cont_Area: \"))  # Example cont_area\n",
    "\n",
    "# Calculate both ratios\n",
    "dim1_dim2_ratio = dim1 / dim2\n",
    "dim2_dim1_ratio = dim2 / dim1\n",
    "\n",
    "# Calculate ratio_area_to_bounding_rect\n",
    "ratio_area_to_bounding_rect = cont_area / (dim1 * dim2)  # Example ratio_area_to_bounding_rect\n",
    "\n",
    "# Example usage for dim1/dim2 ratio\n",
    "relevant_layouts_dim1_dim2 = predict_layouts(dim1_dim2_ratio, complexity, ratio_area_to_bounding_rect)\n",
    "\n",
    "# Example usage for dim2/dim1 ratio\n",
    "relevant_layouts_dim2_dim1 = predict_layouts(dim2_dim1_ratio, complexity, ratio_area_to_bounding_rect)\n",
    "\n",
    "# Print results for both ratios\n",
    "print(\"Relevant Layouts for dim1/dim2 ratio:\")\n",
    "print(relevant_layouts_dim1_dim2)\n",
    "\n",
    "print(\"\\nRelevant Layouts for dim2/dim1 ratio:\")\n",
    "print(relevant_layouts_dim2_dim1)\n",
    "\n",
    "# Display images of relevant layouts for dim1/dim2 ratio\n",
    "image_folder = \"E7-unique-images\"\n",
    "print(\"\\nDisplaying images of relevant layouts for dim1/dim2 ratio:\")\n",
    "display_layout_images(relevant_layouts_dim1_dim2, image_folder)\n",
    "\n",
    "# Display images of relevant layouts for dim2/dim1 ratio\n",
    "print(\"\\nDisplaying images of relevant layouts for dim2/dim1 ratio:\")\n",
    "display_layout_images(relevant_layouts_dim2_dim1, image_folder)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}