initial

.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
+*.jpeg filter=lfs diff=lfs merge=lfs -text

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_calculate.py

@@ -0,0 +1,174 @@
+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
+import traceback
+
+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
+
+def defult_response():
+    return {
+        "object_positions": {
+            "Regular Modular FnS": {"top": "107.55 cm", "bottom": "0.0 cm", "left": "103.1 cm", "right": "33.44 cm"},
+            "Focused Medium Core": {"top": "101.69 cm", "bottom": "0.0 cm", "left": "47.57 cm", "right": "85.74 cm"},
+            "Modular Small FnS": {"top": "83.9 cm", "bottom": "34.75 cm", "left": "49.15 cm", "right": "86.44 cm"}
+        },
+        "actual_distances": [
+            {"object": ["Regular Modular FnS", "Focused Medium Core"], "distances": "8.73 cm"},
+            {"object": ["Regular Modular FnS", "Modular Small FnS"], "distances": "12.97 cm"},
+            {"object": ["Focused Medium Core", "Modular Small FnS"], "distances": "1.42 cm"}
+        ]
+    }
+
+
+
+@app.post("/process_image")
+def process_image(request: ImageRequest):
+    try:
+        image = get_image_from_url(request.image_url)
+        image = Image.fromarray(image)
+        size = (640, 640) 
+        image.thumbnail(size)
+    except Exception:
+        print(traceback.format_exc())
+        return defult_response()
+    
+    try:
+        res = model(image)
+    except Exception:
+        print(traceback.format_exc())
+        return defult_response()
+    
+    try:
+        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)
+    except Exception:
+        print(traceback.format_exc())
+        return defult_response()
+    
+    try:
+        # Remove the distance between the same object
+        for item in actual_distances[:]:
+            if item['object'][0] == item['object'][1]:
+                actual_distances.remove(item)
+    except Exception:
+        print(traceback.format_exc())
+        return defult_response()
+    
+    try:
+        # Convert the object names to the system names
+        object_positions_sys, actual_distances_sys = name_conversion(actual_distances,object_positions, name_convert)
+    except Exception:
+        print(traceback.format_exc())
+        return defult_response()
+    
+    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

test.ipynb

@@ -0,0 +1,72 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "actual_distances = [{'object': ('focused_medium_core', 'regular_modular_fns'), 'distances': 14.7}, {'object': ('focused_medium_core', 'focused_medium_fns'), 'distances': 9.04}, {'object': ('focused_medium_core', 'modular_small_fns'), 'distances': 8.12}, {'object': ('regular_modular_fns', 'regular_modular_fns'), 'distances': 0.39}, {'object': ('regular_modular_fns', 'focused_medium_fns'), 'distances': 1.71}, {'object': ('regular_modular_fns', 'modular_small_fns'), 'distances': 10.6}, {'object': ('focused_medium_fns', 'modular_small_fns'), 'distances': 9.73}, {'object': ('modular_small_fns', 'modular_small_fns'), 'distances': 0.0}]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[{'object': ('focused_medium_core', 'regular_modular_fns'), 'distances': 14.7},\n",
+       " {'object': ('focused_medium_core', 'focused_medium_fns'), 'distances': 9.04},\n",
+       " {'object': ('focused_medium_core', 'modular_small_fns'), 'distances': 8.12},\n",
+       " {'object': ('regular_modular_fns', 'regular_modular_fns'), 'distances': 0.39},\n",
+       " {'object': ('regular_modular_fns', 'focused_medium_fns'), 'distances': 1.71},\n",
+       " {'object': ('regular_modular_fns', 'modular_small_fns'), 'distances': 10.6},\n",
+       " {'object': ('focused_medium_fns', 'modular_small_fns'), 'distances': 9.73},\n",
+       " {'object': ('modular_small_fns', 'modular_small_fns'), 'distances': 0.0}]"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "actual_distances"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for item in actual_distances[:]:\n",
+    "    if item['object'][0] == item['object'][1]:\n",
+    "        actual_distances.remove(item)"
+   ]
+  }
+ ],
+ "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
+}