stp_ply

text

@@ -0,0 +1,201 @@
+from OCC.Core.STEPControl import STEPControl_Reader
+from OCC.Core.IFSelect import IFSelect_RetDone
+from OCC.Core.BRepMesh import BRepMesh_IncrementalMesh
+from OCC.Core.TopExp import TopExp_Explorer
+from OCC.Core.TopAbs import TopAbs_SHELL, TopAbs_FACE
+from OCC.Core.TopoDS import topods
+from OCC.Core.BRep import BRep_Tool
+from OCC.Core.TopLoc import TopLoc_Location
+import open3d as o3d
+import math
+import os
+import sys
+import numpy as np
+import torch
+device = torch.device("cpu")
+print(f"Using device: {device}")
+def triangle_area(v1, v2, v3):
+    ax, ay, az = v2[0]-v1[0], v2[1]-v1[1], v2[2]-v1[2]
+    bx, by, bz = v3[0]-v1[0], v3[1]-v1[1], v3[2]-v1[2]
+    cross_x = ay*bz - az*by
+    cross_y = az*bx - ax*bz
+    cross_z = ax*by - ay*bx
+    cross_len = math.sqrt(cross_x**2 + cross_y**2 + cross_z**2)
+    return 0.5 * cross_len
+def sample_triangle_points(args):
+    v1, v2, v3, num_points_for_triangle = args
+    if num_points_for_triangle <= 0:
+        return []
+    v1_t = torch.tensor(v1, dtype=torch.float)
+    v2_t = torch.tensor(v2, dtype=torch.float)
+    v3_t = torch.tensor(v3, dtype=torch.float)
+    rand_vals = torch.rand((num_points_for_triangle, 2))
+    u = rand_vals[:,0]
+    w = rand_vals[:,1]
+    mask = (u + w) > 1.0
+    u[mask] = 1 - u[mask]
+    w[mask] = 1 - w[mask]
+    v2v1 = (v2_t - v1_t)
+    v3v1 = (v3_t - v1_t)
+    sampled_points = v1_t + u.unsqueeze(1)*v2v1 + w.unsqueeze(1)*v3v1
+    sampled_points_cpu = sampled_points.numpy().tolist()
+    return sampled_points_cpu
+def step_to_point_cloud(step_file_path, 
+                        mesh_linear_deflection=0.5, 
+                        mesh_angular_deflection=1.0, 
+                        target_point_density=5,
+                        max_total_points=50000000):
+    print(f"Reading STEP file: {step_file_path}")
+    step_reader = STEPControl_Reader()
+    status = step_reader.ReadFile(step_file_path)
+    if status != IFSelect_RetDone:
+        raise ValueError(f"Cannot read STEP file: {step_file_path}")
+    print("STEP file read successfully.")
+    step_reader.TransferRoots()
+    shape = step_reader.OneShape()
+    if shape.IsNull():
+        raise ValueError("No shape found in STEP file.")
+    print("Shape transfer completed.")
+    print("Starting tessellation...")
+    mesh = BRepMesh_IncrementalMesh(shape, mesh_linear_deflection, True, mesh_angular_deflection, True)
+    mesh.Perform()
+    if not mesh.IsDone():
+        raise RuntimeError("Mesh generation failed.")
+    print("Tessellation completed.")
+    triangles_info = []
+    total_area = 0.0
+    shell_exp = TopExp_Explorer(shape, TopAbs_SHELL)
+    while shell_exp.More():
+        shell = shell_exp.Current()
+        face_exp = TopExp_Explorer(shell, TopAbs_FACE)
+        while face_exp.More():
+            face = topods.Face(face_exp.Current())
+            loc = TopLoc_Location()
+            triangulation = BRep_Tool.Triangulation(face, loc)
+            if triangulation is None:
+                face_exp.Next()
+                continue
+            for i in range(1, triangulation.NbTriangles() + 1):
+                tri = triangulation.Triangle(i)
+                i1, i2, i3 = tri.Get()
+                p1 = triangulation.Node(i1)
+                p2 = triangulation.Node(i2)
+                p3 = triangulation.Node(i3)
+                v1 = (p1.X(), p1.Y(), p1.Z())
+                v2 = (p2.X(), p2.Y(), p2.Z())
+                v3 = (p3.X(), p3.Y(), p3.Z())
+                area = triangle_area(v1, v2, v3)
+                total_area += area
+                triangles_info.append((v1, v2, v3, area))
+            face_exp.Next()
+        shell_exp.Next()
+    if total_area == 0:
+        raise ValueError("Total area is zero. Check if the STEP file has visible geometry.")
+    desired_total_points = int(total_area * target_point_density)
+    if desired_total_points > max_total_points:
+        scale_factor = max_total_points / desired_total_points
+        target_point_density *= scale_factor
+        desired_total_points = max_total_points
+    print(f"Total area: {total_area:.4f}, Adjusted target density: {target_point_density:.4f}, "
+          f"Total points: {desired_total_points}")
+    args_list = []
+    for (v1, v2, v3, area) in triangles_info:
+        if total_area > 0:
+            num_points_for_triangle = int(area * target_point_density)
+        else:
+            num_points_for_triangle = 0
+        if num_points_for_triangle > 0:
+            args_list.append((v1, v2, v3, num_points_for_triangle))
+    points = []
+    # Process sequentially to reduce memory usage and we print progress every 10k triangles
+    for i, arg in enumerate(args_list, start=1):
+        pts = sample_triangle_points(arg)
+        points.extend(pts)
+        if i % 10000 == 0:
+            print(f"Processed {i}/{len(args_list)} triangles...")
+    if not points:
+        print("No points sampled.")
+        raise ValueError("No points were sampled. Check parameters and input file.")
+    print(f"Total sampled points: {len(points)}")
+    pcd = o3d.geometry.PointCloud()
+    pcd.points = o3d.utility.Vector3dVector(points)
+    
+    ## Normals added by navin
+    pcd.estimate_normals(search_param=o3d.geometry.KDTreeSearchParamKNN(knn=6))
+    # pcd.orient_normals_consistent_tangent_plane(k=6)
+    ##
+    
+    return pcd
+def remove_extension(fname):
+    lower = fname.lower()
+    if lower.endswith(".step"):
+        return fname[:-5]  # remove '.step'
+    elif lower.endswith(".stp"):
+        return fname[:-4]  # remove '.stp'
+    return fname
+class TeeOutput:
+    def __init__(self, *files):
+        self.files = files
+    def write(self, data):
+        for f in self.files:
+            f.write(data)
+            f.flush()
+    def flush(self):
+        for f in self.files:
+            f.flush()
+def process_step_directory(dir_path, processed_dir_path, mesh_linear_deflection=0.01, mesh_angular_deflection=0.5, density=20, max_points=5000000):
+    if not os.path.exists(processed_dir_path):
+        os.makedirs(processed_dir_path)
+    log_path = os.path.join(processed_dir_path, "output_log.txt")
+    log_file = open(log_path, "a", buffering=1)
+    original_stdout = sys.stdout
+    sys.stdout = TeeOutput(sys.stdout, log_file)
+    user_choice = input("Do you want to save processed point clouds (y/n)? ").strip().lower()
+    save_processed = (user_choice == 'y')
+    pc_list = []
+    files = os.listdir(dir_path)
+    files.sort()  # for consistent order
+    total_files = sum(1 for f in files if f.lower().endswith('.step') or f.lower().endswith('.stp'))
+    processed_count = 0
+    for fname in files:
+        fext = fname.lower().endswith
+        if fext(".step") or fext(".stp"):
+            fpath = os.path.join(dir_path, fname)
+            processed_name = remove_extension(fname) + ".ply"
+            processed_file = os.path.join(processed_dir_path, processed_name)
+            if os.path.exists(processed_file):
+                print(f"Already processed: {fname}, loading from {processed_file}")
+                try:
+                    pcd = o3d.io.read_point_cloud(processed_file)
+                    pc_list.append((fname, pcd))
+                except Exception as e:
+                    print(f"Failed to load processed file {processed_file}: {e}")
+            else:
+                print(f"Processing file: {fpath}")
+                try:
+                    pcd = step_to_point_cloud(
+                        fpath,
+                        mesh_linear_deflection=mesh_linear_deflection,
+                        mesh_angular_deflection=mesh_angular_deflection,
+                        target_point_density=density,
+                        max_total_points=max_points
+                    )
+                    if save_processed:
+                        print(f"Saving processed point cloud for {fname} as {processed_name}...")
+                        o3d.io.write_point_cloud(processed_file, pcd,write_ascii=True)
+                    pc_list.append((fname, pcd))
+                except Exception as e:
+                    print(f"Failed to process {fpath}: {e}")
+            processed_count += 1
+            # Print progress after each file processed
+            print(f"Processed {processed_count}/{total_files} files.")
+    sys.stdout = original_stdout
+    log_file.close()
+    return pc_list
+if __name__ == "__main__":
+    step_dir = r"C:\Users\machinelearning\Desktop\navin_testing\step_file"
+    processed_dir = os.path.join(step_dir, "processed_pointclouds")
+    pc_list = process_step_directory(step_dir, processed_dir, mesh_linear_deflection=0.05, mesh_angular_deflection=0.5, density=20, max_points=5_000_000)
+    for fname, pcd in pc_list:
+        print(f"{fname}: {len(np.asarray(pcd.points))} points")
+