refactor

.gitignore

@@ -0,0 +1,2 @@
+.venv/*
+.env/*

app.py

@@ -1,10 +1,10 @@
-import asyncio
 import os
 import platform
-import random
+import re
 import subprocess  # used to connect to FreeCAD via terminal sub process
-import sys
 import tempfile
+import xml.etree.ElementTree as ET
+import zipfile
 from typing import Any, Dict, List, Tuple
 
 import gradio as gr  # demo with gradio
@@ -52,6 +52,8 @@ def convert_step_to_obj_with_freecad(step_path, obj_path):
         freecad_executable = "/usr/bin/freecadcmd"  # freecadcmd
     elif os_name == "Darwin":
         freecad_executable = "/Applications/FreeCAD.app/Contents/MacOS/FreeCAD"
+    else:
+        raise Exception("Unsupported OS for FreeCAD execution: " + os_name)
     # Python script to be executed by FreeCAD
     _, ext = os.path.splitext(step_path)
     ext = ext.lower()
@@ -229,10 +231,6 @@ def query_3D_object(query: str, embedding_dict: dict, top_k: int = 4):
 # Metadata Extraction
 ####################################################################################################################
 
-import os
-import xml.etree.ElementTree as ET
-import zipfile
-
 
 def extract_header_from_3dxml(file_path):
     header_info = {}
@@ -267,8 +265,6 @@ def extract_header_from_3dxml(file_path):
 
 #######################################################################################################################
 
-import re
-
 
 def extract_step_metadata(file_path):
     metadata = {}
@@ -313,16 +309,10 @@ def extract_step_metadata(file_path):
     return metadata
 
 
-#######################################################################################################################
-
-
 def dict_to_markdown(metadata: dict) -> str:
     return "\n".join(f"{key}: {value}" for key, value in metadata.items())
 
 
-#######################################################################################################################
-
-
 # Dummy parser - Replace with real parser
 def parse_3d_file(original_filepath: str):
     if original_filepath is None:

llm_service.py

@@ -1,16 +1,12 @@
 # %%writefile llm_service.py
 import asyncio
-import base64
-import io
 import os
-from enum import Enum
-from typing import List, Tuple, Union, cast
+from typing import Union
 
-import cv2
 import numpy as np
+from loguru import logger
 from openai import AsyncOpenAI
 from PIL import Image
-from loguru import logger
 
 from encode_image import encode_image
 from string_utils import StringUtils

mv_utils_zs.py

@@ -71,7 +71,7 @@ class Grid2Image(nn.Module):
             zsigma=params["convsigmaz"],
         )
         self.conv.weight.data = torch.Tensor(kn3d).repeat(1, 1, 1, 1, 1)
-        self.conv.bias.data.fill_(0)
+        self.conv.bias.data.fill_(0)  # type: ignore
 
     def forward(self, x):
         x = self.maxpool(x.unsqueeze(1))
@@ -138,50 +138,48 @@ def points_to_2d_grid(
     points, grid_h=params["grid_height"], grid_w=params["grid_width"]
 ):
     """
-    Chuyển đổi point cloud thành lưới 2D dựa trên tọa độ X, Y.
-    Các điểm được chiếu lên một mặt phẳng và được lượng tử hóa vào các ô lưới.
+    Converts a point cloud into a 2D grid based on X, Y coordinates.
+    Points are projected onto a plane and quantized into grid cells.
 
     Args:
-        points (torch.tensor): Tensor chứa các điểm, kích thước [B, P, 3]
-                               (B: batch size, P: số lượng điểm, 3: tọa độ x, y, z)
-        grid_h (int): Chiều cao của lưới 2D đầu ra.
-        grid_w (int): Chiều rộng của lưới 2D đầu ra.
+        points (torch.tensor): Tensor containing points, shape [B, P, 3]
+                               (B: batch size, P: number of points, 3: x, y, z coordinates)
+        grid_h (int): Height of the output 2D grid.
+        grid_w (int): Width of the output 2D grid.
 
     Returns:
-        grid (torch.tensor): Lưới 2D biểu diễn sự chiếm dụng của các điểm,
-                             kích thước [B, grid_h, grid_w].
-                             Giá trị 1.0 tại ô (y, x) nếu có ít nhất một điểm rơi vào đó,
-                             ngược lại là giá trị nền (params["bg_clr"]).
+        grid (torch.tensor): 2D grid representing the occupancy of points,
+                             shape [B, grid_h, grid_w].
+                             Value 1.0 at cell (y, x) if at least one point falls into it,
+                             otherwise the background value (params["bg_clr"]).
     """
     batch, pnum, _ = points.shape
     device = points.device
 
-    # --- Bước 1: Chuẩn hóa tọa độ điểm ---
-    # Tìm min/max cho từng point cloud trong batch (chỉ xét X, Y để chuẩn hóa 2D tốt hơn)
+    # --- Step 1: Normalize point coordinates ---
+    # Find min/max for each point cloud in the batch (considering only X, Y for better 2D normalization)
     pmax_xy = points[:, :, :2].max(dim=1)[0]
     pmin_xy = points[:, :, :2].min(dim=1)[0]
 
-    # Tính tâm và phạm vi dựa trên X, Y
+    # Compute the center and range based on X, Y
     pcent_xy = (pmax_xy + pmin_xy) / 2
-    pcent_xy = pcent_xy[:, None, :]  # Thêm chiều P để broadcast [B, 1, 2]
+    pcent_xy = pcent_xy[:, None, :]  # Add P dimension for broadcasting [B, 1, 2]
 
-    # Sử dụng phạm vi lớn nhất giữa X và Y để giữ tỷ lệ aspect ratio
+    # Use the larger range between X and Y to maintain aspect ratio
     prange_xy = (pmax_xy - pmin_xy).max(dim=-1)[0][:, None, None]  # [B, 1, 1]
 
-    # Thêm một epsilon nhỏ để tránh chia cho 0 nếu tất cả các điểm trùng nhau
+    # Add a small epsilon to avoid division by zero if all points overlap
     epsilon = 1e-8
-    # Chỉ chuẩn hóa X, Y vào khoảng [-1, 1] dựa trên phạm vi X, Y
-    # (points[:, :, :2] - pcent_xy) -> [B, P, 2]
-    # prange_xy -> [B, 1, 1]
+    # Normalize X, Y into the range [-1, 1] based on the X, Y range
     points_normalized_xy = (points[:, :, :2] - pcent_xy) / (prange_xy + epsilon) * 2.0
 
-    # Điều chỉnh tỷ lệ theo obj_ratio (nếu cần)
+    # Adjust the scale according to obj_ratio (if needed)
     points_normalized_xy = points_normalized_xy * params["obj_ratio"]
 
-    # --- Bước 2: Ánh xạ tọa độ chuẩn hóa vào chỉ số lưới 2D ---
-    # Ánh xạ X từ khoảng [-obj_ratio, obj_ratio] -> [0, grid_w]
-    # Ánh xạ Y từ khoảng [-obj_ratio, obj_ratio] -> [0, grid_h]
-    # Công thức chung: (normalized_coord + scale) / (2 * scale) * grid_dim
+    # --- Step 2: Map normalized coordinates to 2D grid indices ---
+    # Map X from the range [-obj_ratio, obj_ratio] -> [0, grid_w]
+    # Map Y from the range [-obj_ratio, obj_ratio] -> [0, grid_h]
+    # General formula: (normalized_coord + scale) / (2 * scale) * grid_dim
     _x = (
         (points_normalized_xy[:, :, 0] + params["obj_ratio"])
         / (2 * params["obj_ratio"])
@@ -193,32 +191,32 @@ def points_to_2d_grid(
         * grid_h
     )
 
-    # Làm tròn xuống để xác định chỉ số ô lưới (index)
+    # Round down to determine the grid cell indices
     _x = torch.floor(_x).long()
     _y = torch.floor(_y).long()
 
-    # --- Bước 3: Giới hạn chỉ số vào phạm vi hợp lệ của lưới ---
-    # Clip _x vào [0, grid_w - 1]
-    # Clip _y vào [0, grid_h - 1]
+    # --- Step 3: Clamp indices to valid grid range ---
+    # Clip _x to [0, grid_w - 1]
+    # Clip _y to [0, grid_h - 1]
     _x = torch.clip(_x, 0, grid_w - 1)
     _y = torch.clip(_y, 0, grid_h - 1)
 
-    # --- Bước 4: Tạo lưới 2D và đánh dấu các ô bị chiếm dụng ---
-    # Khởi tạo lưới 2D với giá trị nền
+    # --- Step 4: Create a 2D grid and mark occupied cells ---
+    # Initialize the 2D grid with the background value
     grid = torch.full(
         (batch, grid_h, grid_w), params["bg_clr"], dtype=torch.float32, device=device
     )
 
-    # Tạo chỉ số batch tương ứng với mỗi điểm
+    # Create batch indices corresponding to each point
     batch_indices = torch.arange(batch, device=device).view(-1, 1).repeat(1, pnum)
 
-    # Flatten các chỉ số để dễ dàng gán giá trị
+    # Flatten indices for easier assignment
     batch_idx_flat = batch_indices.view(-1)
     y_idx_flat = _y.view(-1)
     x_idx_flat = _x.view(-1)
 
-    # Gán giá trị 1.0 vào các ô lưới (y, x) tương ứng với vị trí các điểm
-    # Nếu nhiều điểm rơi vào cùng một ô, ô đó vẫn chỉ có giá trị 1.0
+    # Assign a value of 1.0 to grid cells (y, x) corresponding to point positions
+    # If multiple points fall into the same cell, the cell still has a value of 1.0
     grid[batch_idx_flat, y_idx_flat, x_idx_flat] = 1.0
 
     return grid
@@ -262,55 +260,27 @@ def points2grid(points, resolution=params["resolution"], depth=params["depth"]):
         * params["bg_clr"]
     )
 
-    # # *** THAY ĐỔI CHÍNH Ở ĐÂY ***
-    # # Tạo tensor nguồn (src) chứa giá trị 1.0 cho mỗi điểm
-    # # Kích thước phải phù hợp với coordinates khi flatten: [B * pnum]
-    # values_to_scatter = torch.ones(batch * pnum, dtype=torch.float32, device=points.device)
-
-    # # Scatter giá trị 1.0 vào grid tại các vị trí `coordinates`
-    # # Sử dụng reduce="max". Nếu ô có ít nhất một điểm, max(1.0, bg_clr) sẽ là 1.0 (nếu bg_clr <= 1)
-    # # Nếu muốn chắc chắn là 1 bất kể bg_clr, có thể dùng reduce khác hoặc xử lý sau scatter.
-    # # Lựa chọn an toàn hơn nếu bg_clr có thể > 1 là khởi tạo grid bằng 0 và dùng reduce='max'/'mean'
-    # # Hoặc khởi tạo bằng bg_clr và xử lý sau scatter.
-    # # Giả định bg_clr = 0.0 là phổ biến nhất cho occupancy grid.
-
-    # grid = scatter(
-    #     values_to_scatter,
-    #     coordinates.view(-1).long(),  # Flatten coordinates thành [B*pnum]
-    #     dim=0,  # Scatter trên chiều 0 của grid đã flatten [B*D*R*R]
-    #     # Cần chỉ số batch tương ứng nếu grid chưa flatten theo batch
-    #     out=grid.view(-1),  # Flatten grid thành [B*D*R*R] để scatter trên dim 0
-    #     reduce="max",
-    # )  # Nếu có điểm -> giá trị ô là 1, nếu không là bg_clr
-    # # **********************************
-
     grid = scatter(_z, coordinates.long(), dim=1, out=grid, reduce="max")
     grid = grid.reshape((batch, depth, resolution, resolution)).permute((0, 1, 3, 2))
 
     return grid
 
 
-# Giả sử bạn có thư viện scatter, ví dụ: from torch_scatter import scatter
-# Hoặc hàm scatter tương đương
-# import torch # Đảm bảo đã import torch
-# from torch_scatter import scatter # Ví dụ
-
-
 def points_to_occupancy_grid(
     points, resolution=params["resolution"], depth=params["depth"]
 ):
-    """Quantize each point cloud to a 3D occupancy grid."""
+    """Quantize each point cloud into a 3D occupancy grid."""
 
     batch, pnum, _ = points.shape
-    device = points.device  # Lấy device để tạo tensor mới
+    device = points.device  # Get device to create new tensors
 
-    # --- Phần chuẩn hóa và ánh xạ tọa độ giữ nguyên ---
+    # --- Normalization and coordinate mapping remain unchanged ---
     pmax, pmin = points.max(dim=1)[0], points.min(dim=1)[0]
     pcent = (pmax + pmin) / 2
     pcent = pcent[:, None, :]
     prange = (pmax - pmin).max(dim=-1)[0][
         :, None, None
-    ] + 1e-8  # Thêm epsilon tránh chia 0
+    ] + 1e-8  # Add epsilon to avoid division by zero
     points_norm = (points - pcent) / prange * 2.0
     points_norm[:, :, :2] = points_norm[:, :, :2] * params["obj_ratio"]
 
@@ -325,35 +295,33 @@ def points_to_occupancy_grid(
 
     _x = torch.clip(_x, 1, resolution - 2)
     _y = torch.clip(_y, 1, resolution - 2)
-    # z_int cũng nên được clip nếu dùng làm chỉ số tọa độ
+    # z_int should also be clipped if used as coordinate indices
     z_int = torch.clip(z_int, 1, depth - 2)
 
-    # --- Tính toán flattened coordinates giữ nguyên ---
+    # --- Compute flattened coordinates ---
     coordinates = z_int * resolution * resolution + _y * resolution + _x
-    coordinates = coordinates.long()  # Chuyển sang Long
+    coordinates = coordinates.long()  # Convert to Long
 
-    # --- Tạo Grid và Scatter ---
-    # Khởi tạo grid với giá trị nền (ví dụ: 0)
-    # Sử dụng torch.zeros thay vì torch.ones và nhân bg_clr
-    bg_clr_value = params.get("bg_clr", 0.0)  # Lấy bg_clr, mặc định là 0
+    # --- Create Grid and Scatter ---
+    # Initialize the grid with the background value (e.g., 0)
+    # Use torch.zeros instead of torch.ones and multiply by bg_clr
+    bg_clr_value = params.get("bg_clr", 0.0)  # Get bg_clr, default is 0
     grid = torch.full(
         (batch, depth * resolution * resolution),
         bg_clr_value,
-        dtype=torch.float32,  # Hoặc dtype phù hợp
+        dtype=torch.float32,  # Or appropriate dtype
         device=device,
     )
 
-    # *** THAY ĐỔI CHÍNH Ở ĐÂY ***
-    # Tạo tensor nguồn (src) chứa giá trị 1.0 cho mỗi điểm
-    # Kích thước phải phù hợp với coordinates khi flatten: [B * pnum]
+    # Create a source tensor (src) containing a value of 1.0 for each point
+    # The size must match the flattened coordinates: [B * pnum]
     values_to_scatter = torch.ones(batch * pnum, dtype=torch.float32, device=device)
 
-    # Scatter giá trị 1.0 vào grid tại các vị trí `coordinates`
-    # Sử dụng reduce="max". Nếu ô có ít nhất một điểm, max(1.0, bg_clr) sẽ là 1.0 (nếu bg_clr <= 1)
-    # Nếu muốn chắc chắn là 1 bất kể bg_clr, có thể dùng reduce khác hoặc xử lý sau scatter.
-    # Lựa chọn an toàn hơn nếu bg_clr có thể > 1 là khởi tạo grid bằng 0 và dùng reduce='max'/'mean'
-    # Hoặc khởi tạo bằng bg_clr và xử lý sau scatter.
-    # Giả định bg_clr = 0.0 là phổ biến nhất cho occupancy grid.
+    # Scatter the value 1.0 into the grid at the positions `coordinates`
+    # Use reduce="max". If a cell has at least one point, max(1.0, bg_clr) will be 1.0 (if bg_clr <= 1)
+    # To ensure the value is always 1 regardless of bg_clr, use a different reduce or post-process after scatter.
+    # A safer choice if bg_clr can be > 1 is to initialize the grid with 0 and use reduce='max'/'mean'
+    # Or initialize with bg_clr and process after scatter.
     if bg_clr_value != 0.0:
         print(
             "Warning: bg_clr is not 0.0, occupancy grid might not be strictly binary 0/1 with reduce='max'. Consider initializing grid with 0."
@@ -361,17 +329,16 @@ def points_to_occupancy_grid(
 
     grid = scatter(
         values_to_scatter,
-        coordinates.view(-1),  # Flatten coordinates thành [B*pnum]
-        dim=0,  # Scatter trên chiều 0 của grid đã flatten [B*D*R*R]
-        # Cần chỉ số batch tương ứng nếu grid chưa flatten theo batch
-        out=grid.view(-1),  # Flatten grid thành [B*D*R*R] để scatter trên dim 0
+        coordinates.view(-1),  # Flatten coordinates to [B*pnum]
+        dim=0,  # Scatter along dimension 0 of the flattened grid [B*D*R*R]
+        out=grid.view(-1),  # Flatten grid to [B*D*R*R] for scatter along dim 0
         reduce="max",
-    )  # Nếu có điểm -> giá trị ô là 1, nếu không là bg_clr
+    )  # If a point exists -> cell value is 1, otherwise bg_clr
 
-    # --- Reshape và Permute giữ nguyên ---
-    # Reshape lại grid về đúng kích thước 3D + batch
-    # Lưu ý: scatter vào grid đã flatten cần reshape cẩn thận
-    grid = grid.view(batch, depth, resolution, resolution)  # Reshape lại
+    # --- Reshape and Permute remain unchanged ---
+    # Reshape the grid back to the correct 3D + batch size
+    # Note: scatter into a flattened grid requires careful reshaping
+    grid = grid.view(batch, depth, resolution, resolution)  # Reshape back
     grid = grid.permute((0, 1, 3, 2))
 
     return grid

test.py

@@ -0,0 +1,73 @@
+import asyncio
+import os
+
+from loguru import logger
+
+from app import convert_to_obj, embedding_3d_object, parse_3d_file
+
+
+class ModuleTest:
+    @staticmethod
+    async def test_process_file(file_path: str, debug_mode: bool = False) -> dict:
+        report = {}
+        try:
+            obj_path = convert_to_obj(file_path)
+            report["CONV_TO_OBJ"] = "PASSED"
+            if debug_mode:
+                logger.info(f"Obj path: {obj_path}")
+        except Exception:
+            report["CONV_TO_OBJ"] = "FAILED"
+
+        if report["CONV_TO_OBJ"] == "PASSED":
+            obj_path = locals().get("obj_path", None)
+            assert obj_path is not None, "Conversion to OBJ failed"
+            assert os.path.exists(obj_path), "Converted OBJ file does not exist"
+
+            try:
+                embeddings = await embedding_3d_object(obj_path)
+                report["EMBEDDING_3D_OBJ"] = "PASSED"
+                if debug_mode:
+                    logger.info(f"Description: {embeddings['description']}")
+            except Exception:
+                report["EMBEDDING_3D_OBJ"] = "FAILED"
+        else:
+            report["EMBEDDING_3D_OBJ"] = "FAILED"
+
+        try:
+            metadata = parse_3d_file(file_path)
+            report["PARSE_METADATA"] = "PASSED"
+            if debug_mode:
+                logger.info(f"Parsed metadata: {metadata}")
+        except Exception:
+            report["PARSE_METADATA"] = "FAILED"
+        return report
+
+    async def test(self, file_paths: list[str], debug_mode: bool = False) -> None:
+        for file_path in file_paths:
+            basename = os.path.basename(file_path)
+            response = await self.test_process_file(
+                file_path=file_path, debug_mode=debug_mode
+            )
+            for key, value in response.items():
+                if value == "FAILED":
+                    logger.error(f"Processed file `{basename}` failed {key}")
+                else:
+                    logger.info(f"Processed file `{basename}` successfully {key}!")
+
+
+if __name__ == "__main__":
+    asyncio.run(
+        ModuleTest().test(
+            file_paths=[
+                # "/Users/tridoan/Spartan/Datum/service-ai/poc/resources/notebooks/3d_files/c5-corvette-knuckle-1.snapshot.1/C5 Knuckle Mesh.stl", # ok
+                # "/Users/tridoan/Spartan/Datum/service-ai/poc/resources/notebooks/3d_files/c5-corvette-knuckle-1.snapshot.1/C5 Knuckle 3mf.3mf", # ok
+                # "/Users/tridoan/Spartan/Datum/service-ai/poc/resources/notebooks/3d_files/nema-17-stepper-motors-coaxial-60-48-39-23mm-1.snapshot.3/NEMA 17 Stepper Motor 23mm-NEMA 17 Stepper Motor 23mm.obj", # ok
+                # "/Users/tridoan/Spartan/Datum/service-ai/poc/resources/notebooks/3d_files/nema-17-stepper-motors-coaxial-60-48-39-23mm-1.snapshot.3/NEMA 17 Stepper Motor 48mm-NEMA 17 Stepper Motor 48mm.step", # ok
+                # "/Users/tridoan/Spartan/Datum/service-ai/poc/resources/notebooks/3d_files/engrenagens-5.snapshot.6/Engre_con_Z16_mod_1_5.FCStd", # ok
+                # "/Users/tridoan/Spartan/Datum/service-ai/poc/resources/notebooks/3d_files/radial engine.3dxml",
+                # "/Users/tridoan/Spartan/Datum/service-ai/poc/resources/notebooks/3d_files/ARBOR GEAR.dwg",
+                # "/Users/tridoan/Spartan/Datum/service-ai/poc/resources/notebooks/3d_files/electrical-switch-1.snapshot.3/Electrical switch.IGS"
+            ],
+            debug_mode=True,
+        )
+    )