Merge pull request #9 from Unimakers/dev

add: ML Pipeline - Robovision

.gitignore

@@ -5,4 +5,6 @@
 .vscode/ipch
 .vscode
 .cache
-docs/site
+docs/site
+
+__pycache__

ml/training.py

@@ -1,13 +1,17 @@
+import time
+import cv2
 from sklearn import svm
 import os
 from PIL import Image
 from skimage.feature import hog
-from skimage import exposure
-import pickle
 
 x: list[int | float] = []
 y: list[str] = []
 
+cell_per_block = (1, 1)
+pixels_per_cell = (8, 8)
+window_size = 8
+
 
 def read_blobs():
     plants = []
@@ -24,76 +28,148 @@ def read_blobs():
 def get_data():
     plants = []
     pots = []
+    random = []
     for filename in os.listdir("data/plant"):
         file_path = os.path.join("data/plant", filename)
         plants.append(file_path)
     for filename in os.listdir("data/pot"):
         file_path = os.path.join("data/pot", filename)
         pots.append(file_path)
-    return (plants, pots)
+    for filename in os.listdir("data/random"):
+        file_path = os.path.join("data/random", filename)
+        random.append(file_path)
+    return (plants, pots, random)
 
 
 def normalize_data():
-    plants, pots = read_blobs()
+    plants, pots, random = get_data()
     for index, url in enumerate(plants):
         img = Image.open(url)
-        img = img.resize((64, 64))
+        if img.height == 32:
+            img.close()
+            continue
+        img = img.resize((32, 32))
         img.save(f"data/plant/{index}.jpg")
     for index, url in enumerate(pots):
         img = Image.open(url)
-        img = img.resize((64, 64))
+        if img.height == 32:
+            img.close()
+            continue
+        img = img.resize((32, 32))
         img.save(f"data/pot/{index}.jpg")
+    for index, url in enumerate(random):
+        img = Image.open(url)
+        if img.height == 32:
+            img.close()
+            continue
+        img = img.resize((32, 32))
+        img = img.convert("RGB")
+        img.save(f"data/random/{index}.jpg")
 
 
 def create_dataframe():
     global x, y
-    plants, pots = get_data()
-    for index, url in enumerate(plants):
+    plants, pots, random = get_data()
+    for url in plants:
         img = Image.open(url)
         fd = hog(
             img,
             orientations=8,
-            pixels_per_cell=(16, 16),
-            cells_per_block=(1, 1),
+            pixels_per_cell=pixels_per_cell,
+            cells_per_block=cell_per_block,
             visualize=True,
             channel_axis=-1,
         )
         x.append(fd[0])
         y.append("plant")
-    for index, url in enumerate(pots):
+    for url in pots:
         img = Image.open(url)
         fd = hog(
             img,
             orientations=8,
-            pixels_per_cell=(16, 16),
-            cells_per_block=(1, 1),
+            pixels_per_cell=pixels_per_cell,
+            cells_per_block=cell_per_block,
             visualize=True,
             channel_axis=-1,
         )
         x.append(fd[0])
         y.append("pot")
+    for url in random:
+        img = Image.open(url)
+        fd = hog(
+            img,
+            orientations=8,
+            pixels_per_cell=pixels_per_cell,
+            cells_per_block=cell_per_block,
+            visualize=True,
+            channel_axis=-1,
+        )
+        x.append(fd[0])
+        y.append("object")
 
 
+normalize_data()
 create_dataframe()
-clf = svm.SVC()
-clf.fit(x, y)
-
-img = Image.open("../dataset/blobs/pots/50.pot.jpg")
-img = img.resize((64, 64))
-fd = hog(
-    img,
-    orientations=8,
-    pixels_per_cell=(16, 16),
-    cells_per_block=(1, 1),
-    visualize=True,
-    channel_axis=-1,
-)
-
-
-res = clf.predict([fd[0]])
-print(res)
-
-
-# save model
-with open("model.pkl", "wb") as f:
-    pickle.dump(clf, f)
+clf = svm.SVC(decision_function_shape="ovo", kernel="rbf", C=200, probability=True)
+clf.fit(x, y)  # type:ignore
+# with open("model.pkl", "rb") as f:
+#     clf: svm.SVC = pickle.load(f)
+img = Image.open("test/4.jpg")
+imgcv = cv2.imread("test/4.jpg")
+
+now = time.time()
+
+xa = 0
+ya = 0
+
+
+def get_value(x: list):
+    plant = x[0][0]
+    pot = x[0][1]
+    obj = x[0][2]
+    if plant > pot and plant > obj:
+        if plant > 85.0:
+            return "plant"
+    if pot > plant and pot > obj:
+        if pot > 85.0:
+            return "pot"
+    if obj > plant and obj > pot:
+        if obj > 85.0:
+            return "object"
+    return None
+
+
+while xa < 64:
+    while ya < 64:
+        window = img.crop((xa, ya, xa + window_size, ya + window_size))
+        window = window.resize((32, 32))
+        fd = hog(
+            window,
+            orientations=8,
+            pixels_per_cell=pixels_per_cell,
+            cells_per_block=cell_per_block,
+            visualize=True,
+            channel_axis=-1,
+        )
+        res = clf.predict_proba([fd[0]])  # type:ignore
+        if get_value(res) == "plant":  # type:ignore
+            print(res)
+            cv2.rectangle(
+                imgcv, (xa, ya), (xa + window_size, ya + window_size), (255, 0, 0), 1
+            )
+            ya += window_size
+            xa += window_size
+            continue
+            # print(f"{xa}:{ya} = {res[0]}")
+        ya += 1
+    xa += 1
+    ya = 0
+print(f"time elapsed : { (time.time() - now) *1000 } ms")
+
+cv2.imshow("image", imgcv)
+cv2.waitKey(0)
+
+
+# # save model
+# with open("model.pkl", "wb") as f:
+#     pickle.dump(clf, f)

tools/eql.py

@@ -70,7 +70,7 @@ def tokenize_text():
         if keywords.count(tokens[0]) == 0:
             print_parse_error(tokens[0])
         type = get_token_type(tokens[0])
-        token = assemble_command(type, tokens)
+        token = assemble_command(type, tokens)  # type: ignore
 
 
 def get_token_type(token: str):

tools/robovision/components/leftpane.py

@@ -0,0 +1,37 @@
+import dearpygui.dearpygui as dpg
+
+
+class LeftPane:
+    height: int | None
+    width: int
+
+    def __init__(self):
+        self.height = dpg.get_item_height("table")
+        if self.height is None:
+            self.height = 720
+
+    def register(self):
+        with dpg.texture_registry(show=False):
+            width, height, _, data = dpg.load_image("assets/logo.png")
+            dpg.add_static_texture(
+                width=width,
+                height=height,
+                default_value=data,
+                tag="logo_texture",
+            )
+        with dpg.window(
+            label="RoboVision 0.0.1",
+            no_close=True,
+            pos=[0, 0],
+            width=200,
+            height=self.height,
+            no_collapse=True,
+            no_move=True,
+        ):
+            dpg.add_image(
+                "logo_texture",
+                width=185,
+                height=32,
+                tag="logo_img",
+            )
+            dpg.add_text(source="mouse_pos")

tools/robovision/components/table.py

@@ -0,0 +1,39 @@
+import dearpygui.dearpygui as dpg
+
+TABLE_WIDTH = 3000
+TABLE_HEIGHT = 2000
+TABLE_RATIO = 0.3
+TABLE_VIEW_WIDTH = (int)(TABLE_WIDTH * TABLE_RATIO)
+TABLE_VIEW_HEIGHT = (int)(TABLE_HEIGHT * TABLE_RATIO)
+TABLE_REAL_RATIO = TABLE_WIDTH / TABLE_VIEW_WIDTH
+MARGIN_OFFSET = 30
+robot_pos = [0, 0]
+robot_size = [450 * TABLE_RATIO, 450 * TABLE_RATIO]
+
+
+class Table2D:
+    def register(self):
+        width, height, _, data = dpg.load_image("assets/table.png")
+        with dpg.texture_registry(show=False):
+            dpg.add_static_texture(
+                width=width,
+                height=height,
+                default_value=data,
+                tag="table_texture",
+            )
+        with dpg.window(
+            label="Table 2D",
+            tag="table",
+            pos=[205, 0],
+            height=640,
+            no_close=True,
+            no_move=True,
+            no_resize=True,
+            no_collapse=True,
+        ):
+            dpg.add_image(
+                "table_texture",
+                width=TABLE_VIEW_WIDTH,
+                height=TABLE_VIEW_HEIGHT,
+                tag="table_img",
+            )

tools/robovision/main.py

@@ -0,0 +1,57 @@
+from math import floor
+import dearpygui.dearpygui as dpg
+from components.table import Table2D
+from components.leftpane import LeftPane
+
+
+TABLE_WIDTH = 3000
+TABLE_HEIGHT = 2000
+TABLE_RATIO = 0.3
+TABLE_VIEW_WIDTH = (int)(TABLE_WIDTH * TABLE_RATIO)
+TABLE_VIEW_HEIGHT = (int)(TABLE_HEIGHT * TABLE_RATIO)
+TABLE_REAL_RATIO = TABLE_WIDTH / TABLE_VIEW_WIDTH
+MARGIN_OFFSET = 30
+robot_pos = [0, 0]
+robot_size = [450 * TABLE_RATIO, 450 * TABLE_RATIO]
+
+
+def main():
+    dpg.create_context()
+    dpg.create_viewport(title="RoboVision")
+    dpg.setup_dearpygui()
+    dpg.set_viewport_vsync(True)
+    dpg.toggle_viewport_fullscreen()
+    register_values()
+    register_handlers()
+
+    table = Table2D()
+    table.register()
+    leftpane = LeftPane()
+    leftpane.register()
+
+    dpg.show_viewport()
+
+    dpg.start_dearpygui()
+    dpg.destroy_context()
+
+
+def handle_mouse_click(sender, data):
+    if dpg.is_item_hovered("table") and dpg.is_item_focused("table"):
+        pos = dpg.get_mouse_pos()
+        x = floor(pos[0] * TABLE_REAL_RATIO) - MARGIN_OFFSET
+        y = floor(pos[1] * TABLE_REAL_RATIO) - MARGIN_OFFSET
+        dpg.set_value("mouse_pos", f"MOUSE:{pos}")
+
+
+def register_handlers():
+    with dpg.handler_registry():
+        dpg.add_mouse_move_handler(callback=handle_mouse_click)
+
+
+def register_values():
+    with dpg.value_registry():
+        dpg.add_string_value(tag="mouse_pos", default_value="MOUSE:[0.0,0.0]")
+
+
+if __name__ == "__main__":
+    main()