Delete text

text

@@ -1,201 +0,0 @@
-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")
-