new

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+posmPJSTRIKE_v1.3.pt filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,27 @@
+# Use a minimal Python image
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install required system libraries
+RUN apt-get update && apt-get install -y libgl1-mesa-glx libglib2.0-0
+
+# Install PyTorch separately to avoid timeout
+RUN pip install --no-cache-dir torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
+
+# Copy dependencies
+COPY requirements.txt ./
+
+# Install remaining dependencies
+RUN pip install --no-cache-dir -r requirements.txt --timeout 100 --index-url https://pypi.tuna.tsinghua.edu.cn/simple
+
+# Copy application code
+COPY . .
+
+# Expose the FastAPI port
+EXPOSE 8000
+
+# Run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
+

base_width.json

@@ -0,0 +1,14 @@
+{
+    "Name": ["Width","hight"],
+    "focused_medium_core": [49.6,34.6],
+    "modular_small_core": [44.6,17.2],
+    "focused_modular_extra_small_core": [25.7,12.7],
+    "regular_modular_core": [42.9,25.5],
+    "reusable_pack_dispenser_core": [28.15,15.15],
+
+    "regular_modular_fns": [42.9,25.5],
+    "modular_small_fns": [44.8,17.1],
+    "focused_medium_fns": [49.6,34.6],
+    "reusable_pack_dispenser_fns": [28.15,15.15],
+    "focused_modular_extra_small_fns": [25.5,12.7]
+}

distance_calculate3.ipynb

@@ -0,0 +1,140 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "0: 384x512 1 focused_medium_core, 1 modular_small_core, 341.3ms\n",
+      "Speed: 1.5ms preprocess, 341.3ms inference, 1.5ms postprocess per image at shape (1, 3, 384, 512)\n"
+     ]
+    }
+   ],
+   "source": [
+    "import math\n",
+    "import cv2\n",
+    "import numpy as np\n",
+    "from ultralytics import YOLO\n",
+    "import json\n",
+    "\n",
+    "model = YOLO(\"posmPJSTRIKE_v1.3.pt\")\n",
+    "image = cv2.imread(\"1.jpeg\")\n",
+    "res = model(image)\n",
+    "\n",
+    "with open(\"base_width.json\", \"r\") as f:\n",
+    "    base_width = json.load(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def find_position(objects_names_points, par_pix_cm, image):\n",
+    "    object_positions = {}\n",
+    "    for obj in objects_names_points:\n",
+    "        name = list(obj.keys())[0]\n",
+    "        points = list(obj.values())[0]\n",
+    "\n",
+    "        top_distance = round((points[0][1] - 0) * par_pix_cm[name],2)\n",
+    "        bottom_distance = round((image.shape[0] - points[3][1]) * par_pix_cm[name],2)\n",
+    "        left_distance = round((points[0][0] - 0) * par_pix_cm[name],2)\n",
+    "        right_distance = round((image.shape[1] - points[3][0]) * par_pix_cm[name],2)\n",
+    "        \n",
+    "        object_positions.update({name: {\"top\": top_distance, \"bottom\": bottom_distance, \"left\": left_distance, \"right\": right_distance}})\n",
+    "    return object_positions\n",
+    "\n",
+    "def get_actual_distance(closest_points, par_pix_cm):\n",
+    "    actual_results_n_distance = {}\n",
+    "    for i in closest_points:\n",
+    "        avg_px_cm = ((par_pix_cm[i[0]] + par_pix_cm[i[1]])/2)\n",
+    "        actual_results_n_distance.update({i:round(closest_points[i]*avg_px_cm,2)})\n",
+    "    return actual_results_n_distance\n",
+    "\n",
+    "def pixel_per_cm(objects_names_width_pix):\n",
+    "    par_pix_cm = {}\n",
+    "    for i in objects_names_width_pix:\n",
+    "        par_pix_cm_width = base_width[i][0]/objects_names_width_pix[i][0]\n",
+    "        par_pix_cm_hight = base_width[i][1]/objects_names_width_pix[i][1]\n",
+    "        avg_par_pix_cm = (par_pix_cm_width + par_pix_cm_hight)/2\n",
+    "        par_pix_cm.update({i:avg_par_pix_cm})\n",
+    "    return par_pix_cm\n",
+    "\n",
+    "def get_points_n_names(results):\n",
+    "    objects_names_points = []\n",
+    "    objects_names_width_pix = {}\n",
+    "    for box, cls in zip(results[0].boxes.xyxy, results[0].boxes.cls):\n",
+    "        x1, y1, x2, y2 = map(int, box)\n",
+    "        class_name = results[0].names[int(cls)]\n",
+    "        width = x2 - x1\n",
+    "        hight = y2 - y1\n",
+    "        objects_names_points.append({class_name: [(x1, y1), (x2, y1), (x1, y2), (x2, y2)]})\n",
+    "        objects_names_width_pix.update({class_name: [width, hight]})\n",
+    "    \n",
+    "    return objects_names_points, objects_names_width_pix\n",
+    "\n",
+    "def euclidean_distance(point1, point2):\n",
+    "    dist_pixels = math.sqrt((point2[0] - point1[0])**2 + (point2[1] - point1[1])**2)\n",
+    "    return dist_pixels\n",
+    "\n",
+    "def find_closest_points(lst):\n",
+    "    closest_points = {}\n",
+    "    \n",
+    "    for i in range(len(lst)):\n",
+    "        for j in range(i + 1, len(lst)):\n",
+    "            list1 = lst[i]\n",
+    "            list2 = lst[j]\n",
+    "            min_distance = float('inf')\n",
+    "            closest_objects_pair = None\n",
+    "            \n",
+    "            for obj1 in list1.values():\n",
+    "                points1 = obj1\n",
+    "                for obj2 in list2.values():\n",
+    "                    points2 = obj2\n",
+    "                    \n",
+    "                    for point1 in points1:\n",
+    "                        for point2 in points2:\n",
+    "                            distance = euclidean_distance(point1, point2)\n",
+    "                            if distance < min_distance:\n",
+    "                                min_distance = distance\n",
+    "                                closest_objects_pair = (list1.keys(), list2.keys())\n",
+    "            \n",
+    "            closest_points.update({(list(closest_objects_pair[0])[0],list(closest_objects_pair[1])[0]):round(min_distance, 2)})\n",
+    "    return closest_points\n",
+    "\n",
+    "objects_names_points, objects_names_width_pix = get_points_n_names(res)\n",
+    "par_pix_cm = pixel_per_cm(objects_names_width_pix)\n",
+    "closest_points = find_closest_points(objects_names_points)\n",
+    "actual_distances = get_actual_distance(closest_points, par_pix_cm)\n",
+    "object_position = find_position(objects_names_points, par_pix_cm, image)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "bat",
+   "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.12.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

main.py

@@ -0,0 +1,137 @@
+import math
+import requests
+import numpy as np
+import json
+from io import BytesIO
+from fastapi import FastAPI
+from pydantic import BaseModel
+from ultralytics import YOLO
+from PIL import Image
+
+app = FastAPI()
+
+model = YOLO("posmPJSTRIKE_v1.3.pt")
+
+with open("base_width.json", "r") as f:
+    base_width = json.load(f)
+    
+with open("name_conversion.json", "r") as f:
+    name_convert = json.load(f)
+
+class ImageRequest(BaseModel):
+    image_url: str
+
+def get_image_from_url(image_url):
+    response = requests.get(image_url)
+    image = Image.open(BytesIO(response.content)).convert("RGB")
+    return np.array(image)
+
+def name_conversion(actual_distances,object_positions, name_convert):
+    actual_distances_sys = []
+    object_positions_sys = {}
+    for item in actual_distances:
+        actual_distances_sys.append({'object':(name_convert[list(item.values())[0][0]],name_convert[list(item.values())[0][1]]),'distances': str(list(item.values())[1]) + " cm"})
+
+    for item in object_positions:
+        object_positions_sys.update({name_convert[item]:{"top": str(object_positions[item]['top']) + " cm", "bottom": str(object_positions[item]['bottom']) + " cm", "left": str(object_positions[item]['left']) + " cm", "right": str(object_positions[item]['right']) + " cm"}})
+    return object_positions_sys, actual_distances_sys
+
+def find_position(objects_names_points, par_pix_cm, image):
+    object_positions = {}
+    for obj in objects_names_points:
+        name = list(obj.keys())[0]
+        points = list(obj.values())[0]
+
+        top_distance = round((points[0][1] - 0) * par_pix_cm[name], 2)
+        bottom_distance = round((image.size[1] - points[3][1]) * par_pix_cm[name], 2)
+        left_distance = round((points[0][0] - 0) * par_pix_cm[name], 2)
+        right_distance = round((image.size[0] - points[3][0]) * par_pix_cm[name], 2)
+        
+        object_positions.update({name: {"top": top_distance, "bottom": bottom_distance, "left": left_distance, "right": right_distance}})
+    return object_positions
+
+def get_actual_distance(closest_points, par_pix_cm):
+    actual_results_n_distance = []
+    for i in closest_points:
+        avg_px_cm = ((par_pix_cm[i[0]] + par_pix_cm[i[1]]) / 2)
+        actual_results_n_distance.append({'object': i, 'distances': round(closest_points[i] * avg_px_cm, 2)})
+    return actual_results_n_distance
+
+def pixel_per_cm(objects_names_width_pix):
+    par_pix_cm = {}
+    for i in objects_names_width_pix:
+        par_pix_cm_width = base_width[i][0] / objects_names_width_pix[i][0]
+        par_pix_cm_height = base_width[i][1] / objects_names_width_pix[i][1]
+        avg_par_pix_cm = (par_pix_cm_width + par_pix_cm_height) / 2
+        par_pix_cm.update({i: avg_par_pix_cm})
+    return par_pix_cm
+
+def get_points_n_names(results):
+    objects_names_points = []
+    objects_names_width_pix = {}
+    for box, cls in zip(results[0].boxes.xyxy, results[0].boxes.cls):
+        x1, y1, x2, y2 = map(int, box)
+        class_name = results[0].names[int(cls)]
+        width = x2 - x1
+        height = y2 - y1
+        objects_names_points.append({class_name: [(x1, y1), (x2, y1), (x1, y2), (x2, y2)]})
+        objects_names_width_pix.update({class_name: [width, height]})
+    
+    return objects_names_points, objects_names_width_pix
+
+def euclidean_distance(point1, point2):
+    dist_pixels = math.sqrt((point2[0] - point1[0])**2 + (point2[1] - point1[1])**2)
+    return dist_pixels
+
+def find_closest_points(lst):
+    closest_points = {}
+    
+    for i in range(len(lst)):
+        for j in range(i + 1, len(lst)):
+            list1 = lst[i]
+            list2 = lst[j]
+            min_distance = float('inf')
+            closest_objects_pair = None
+            
+            for obj1 in list1.values():
+                points1 = obj1
+                for obj2 in list2.values():
+                    points2 = obj2
+                    
+                    for point1 in points1:
+                        for point2 in points2:
+                            distance = euclidean_distance(point1, point2)
+                            if distance < min_distance:
+                                min_distance = distance
+                                closest_objects_pair = (list1.keys(), list2.keys())
+            
+            closest_points.update({(list(closest_objects_pair[0])[0], list(closest_objects_pair[1])[0]): round(min_distance, 2)})
+    return closest_points
+
+@app.post("/process_image")
+def process_image(request: ImageRequest):
+    image = get_image_from_url(request.image_url)
+    image = Image.fromarray(image)
+    size = (640, 640) 
+    image.thumbnail(size)
+    image.save("image.jpg")
+    res = model(image)
+    
+    objects_names_points, objects_names_width_pix = get_points_n_names(res)
+    par_pix_cm = pixel_per_cm(objects_names_width_pix)
+    closest_points = find_closest_points(objects_names_points)
+    actual_distances = get_actual_distance(closest_points, par_pix_cm)
+    object_positions = find_position(objects_names_points, par_pix_cm, image)
+    
+    # Remove the distance between the same object
+    for item in actual_distances[:]:
+        if item['object'][0] == item['object'][1]:
+            actual_distances.remove(item)
+    
+    # Convert the object names to the system names
+    object_positions_sys, actual_distances_sys = name_conversion(actual_distances,object_positions, name_convert)
+    
+    return {
+        "object_positions": object_positions_sys,
+        "actual_distances": actual_distances_sys
+    }

name_conversion.json

@@ -0,0 +1,18 @@
+{
+"pvc_base_surface_hanger_core":"PVC Base Surface Hanger Core",
+    "paper_base_surface_hanger_core":"Paper Base Surface Hanger Core",
+    "pvc_base_surface_hanger_fns":"PVC Base Surface Hanger FnS",
+    "paper_base_surface_hanger_fns":"Paper Base Surface Hanger FnS",
+    "focused_medium_core":"Focused Medium Core",
+    "focused_modular_extra_small_core":"Focused Modular-Extra Small Core",
+    "focused_modular_extra_small_fns":"Focused Modular-Extra Small FnS",
+    "focused_medium_fns":"Focused Medium FnS",
+    "modular_small_core":"Modular Small Core",
+    "modular_small_fns":"Modular Small FnS",
+    "regular_modular_core":"Regular Modular Core",
+    "regular_modular_fns":"Regular Modular FnS",
+    "reusable_pack_dispenser_core":"Reusable Pack Dispenser Core",
+    "reusable_pack_dispenser_fns":"Reusable Pack Dispenser FnS",
+    "street_kiosk_identifier_core":"Street Kiosk Identifier Core",
+    "street_kiosk_identifier_fns":"Street Kiosk Identifier FnS"
+}

posmPJSTRIKE_v1.3.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e318caeaf1d380b927894f517d142f4176a4ad20c8706f01fd14d089e7f18980
+size 144064701

requirements.txt

@@ -0,0 +1,10 @@
+ultralytics
+torch
+torchvision
+torchaudio
+fastapi
+uvicorn
+pillow
+numpy
+requests
+pydantic