WIP-ADD meshcloud comparison

Author: eleniv3d

src/gh/components/DF_cloud_to_mesh_distance/code.py

@@ -11,16 +11,17 @@
 from Grasshopper.Kernel import GH_RuntimeMessageLevel as RML
 
 import diffCheck
-from diffCheck import diffcheck_bindings
 from diffCheck import df_cvt_bindings
 from diffCheck import df_error_estimation
+from diffCheck.df_geometries import DFBeam
 
 
 class CloudToMeshDistance(component):
     def RunScript(self,
-        i_cloud_source: rg.PointCloud,
-        i_beam,
-        i_signed_flag: bool):
+        i_cloud_source: typing.List[rg.PointCloud],
+        i_beam: typing.List[DFBeam],
+        i_signed_flag: bool,
+        i_swap: bool):
         """
             The cloud-to-cloud component computes the distance between each point in the source point cloud and its nearest neighbour in thr target point cloud.
 
@@ -35,25 +36,23 @@ def RunScript(self,
         if i_cloud_source is None or i_beam is None:
             ghenv.Component.AddRuntimeMessage(RML.Warning, "Please provide an object of type point cloud and an object of type mesh to compare")
             return None
+        
 
         # conversion
-        df_cloud_source = df_cvt_bindings.cvt_rhcloud_2_dfcloud(i_cloud_source)
-        rhino_mesh_target = i_beam.to_mesh()
-        df_mesh_target = df_cvt_bindings.cvt_rhmesh_2_dfmesh(rhino_mesh_target)
+        df_cloud_source_list = [df_cvt_bindings.cvt_rhcloud_2_dfcloud(i_cl_s) for i_cl_s in i_cloud_source]
+        df_mesh_target_list = [beam.to_mesh() for beam in i_beam]
 
         # calculate distances
-        o_results = df_error_estimation.cloud_2_mesh_distance(df_cloud_source, df_mesh_target, i_signed_flag)
-
-        o_mesh = rhino_mesh_target
-
-        return o_distances.tolist(), o_mse, o_max_deviation, o_min_deviation, o_mesh
+        o_results = df_error_estimation.cloud_2_rhino_mesh_comparison(df_cloud_source_list, df_mesh_target_list, i_signed_flag, i_swap)
 
+        return o_results.distances, o_results.distances_mse, o_results.distances_max_deviation, o_results.distances_min_deviation, o_results.distances_sd_deviation, o_results
 
 
 if __name__ == "__main__":
     com = CloudToMeshDistance()
-    o_distances, o_mse, o_max_deviation, o_min_deviation, o_mesh = com.RunScript(
+    o_distances, o_mse, o_max_deviation, o_min_deviation, o_std_deviation, o_results = com.RunScript(
         i_cloud_source,
-        i_mesh_target,
-        i_signed_flag
+        i_beam,
+        i_signed_flag,
+        i_swap
         )

…nents/DF_cloud_to_mesh_distance2/code.py …_cloud_to_mesh_distance_archived/code.pysrc/gh/components/DF_cloud_to_mesh_distance2/code.py renamed to src/gh/components/DF_cloud_to_mesh_distance_archived/code.py src/gh/components/DF_cloud_to_mesh_distance2/code.py renamed to src/gh/components/DF_cloud_to_mesh_distance_archived/code.py

@@ -39,12 +39,10 @@ def RunScript(self,
         # conversion
         df_cloud_source = df_cvt_bindings.cvt_rhcloud_2_dfcloud(i_cloud_source)
         rhino_mesh_target = i_beam.to_mesh()
+        df_mesh_target = df_cvt_bindings.cvt_rhmesh_2_dfmesh(rhino_mesh_target)
 
         # calculate distances
-        o_distances = df_error_estimation.cloud_2_rhino_mesh_distance(df_cloud_source, rhino_mesh_target, i_signed_flag)
-        o_mse = df_error_estimation.compute_mse(o_distances)
-        o_max_deviation = df_error_estimation.compute_max_deviation(o_distances)
-        o_min_deviation = df_error_estimation.compute_min_deviation(o_distances)
+        o_results = df_error_estimation.cloud_2_mesh_distance(df_cloud_source, df_mesh_target, i_signed_flag)
 
         o_mesh = rhino_mesh_target
 

…ents/DF_cloud_to_mesh_distance2/icon.png …cloud_to_mesh_distance_archived/icon.pngsrc/gh/components/DF_cloud_to_mesh_distance2/icon.png renamed to src/gh/components/DF_cloud_to_mesh_distance_archived/icon.png src/gh/components/DF_cloud_to_mesh_distance2/icon.png renamed to src/gh/components/DF_cloud_to_mesh_distance_archived/icon.png

@@ -10,12 +10,9 @@
 import Grasshopper as gh
 from Grasshopper.Kernel import GH_RuntimeMessageLevel as RML
 
-import diffCheck
 from diffCheck import diffcheck_bindings
 from diffCheck import df_cvt_bindings
-from diffCheck import df_error_estimation, df_vizualization
-
-import diffCheck.df_util
+from diffCheck import df_vizualization
 
 
 class Vizualization(component):
@@ -26,14 +23,6 @@ def RunScript(self,
             sth sth
         """
 
-        if i_results.source is None or i_results.target is None:
-            ghenv.Component.AddRuntimeMessage(RML.Warning, "Please provide both objects of type point clouds to compare")
-            return None
-
-        # check if target is a pcl
-        o_source = [df_cvt_bindings.cvt_dfcloud_2_rhcloud(src) for src in i_results.source]
-
-        # by default we color the target
         distances_flattened = [item for sublist in i_results.distances for item in sublist]
 
         if i_viz_settings.lower_threshold is not None:
@@ -46,12 +35,24 @@ def RunScript(self,
         else:
             max_value = max(max(sublist) for sublist in i_results.distances)
 
-        # we always color the source
-        # check if source is a pcd
-        o_colored_geo = [df_vizualization.color_pcd(src, dist, min_value, max_value) for src, dist in zip(o_source, i_results.distances)]
+        # check if i_results.source is a list of pointclouds or a mesh
+        if type(i_results.source[0]) is diffcheck_bindings.dfb_geometry.DFPointCloud:
+
+            # convert to Rhino PCD
+            o_source = [df_cvt_bindings.cvt_dfcloud_2_rhcloud(src) for src in i_results.source]
+
+            # color geometry
+            o_colored_geo = [df_vizualization.color_pcd(src, dist, min_value, max_value) for src, dist in zip(o_source, i_results.distances)]
+
+        elif type(i_results.source[0]) is rg.Mesh:
+            # convert to Rhino Mesh
+            o_source = i_results.source
+
+            # color geometry
+            o_colored_geo = [df_vizualization.color_mesh(src, dist, min_value, max_value) for src, dist in zip(o_source, i_results.distances)]
 
         o_legend = df_vizualization.create_legend(min_value, max_value)
-        
+
         o_histogram = df_vizualization.create_histogram(distances_flattened, min_value, max_value)
 
         return o_source, o_colored_geo, o_legend, o_histogram

…DF_cloud_to_mesh_distance2/metadata.json …_to_mesh_distance_archived/metadata.jsonsrc/gh/components/DF_cloud_to_mesh_distance2/metadata.json renamed to src/gh/components/DF_cloud_to_mesh_distance_archived/metadata.json src/gh/components/DF_cloud_to_mesh_distance2/metadata.json renamed to src/gh/components/DF_cloud_to_mesh_distance_archived/metadata.json

@@ -4,49 +4,95 @@
 """
 
 import numpy as np
-import open3d as o3d
 from diffCheck import diffcheck_bindings
 import Rhino.Geometry as rg
 
 
-def cloud_2_cloud_distance(source, target, invert=False):
+def cloud_2_cloud_comparison(source_list, target_list):
     """
         Compute the Euclidean distance for every point of a source pcd to its
         closest point on a target pointcloud
     """
-    if invert:
-        distances = np.asarray(target.compute_distance(source))
-    else:
-        distances = np.asarray(source.compute_distance(target))
+    results = DFVizResults()
+    for source, target in zip(source_list, target_list):
+        distances = cloud_2_cloud_distance(source, target)
+        results.add(source, target, distances)
+
+    return results
+
 
-    return distances
+def cloud_2_cloud_distance(source, target):
+    """
+        Compute the Euclidean distance for every point of a source pcd to its
+        closest point on a target pointcloud
+    """
+
+    return np.asarray(source.compute_distance(target))
 
 
-def cloud_2_cloud_comparison(source_list, target_list, invert=False):
+def cloud_2_rhino_mesh_comparison(cloud_source_list, rhino_mesh_target_list, signed_flag, swap):
     """
         Compute the Euclidean distance for every point of a source pcd to its
         closest point on a target pointcloud
     """
     results = DFVizResults()
-    for source, target in zip(source_list, target_list):
-        distances = cloud_2_cloud_distance(source, target, invert)
-        results.add(source, target, distances)
+
+    for source, target in zip(cloud_source_list, rhino_mesh_target_list):
+        if swap:
+            # this mean we want to vizualize the result on the target mesh
+            distances = rhino_mesh_2_cloud_distance(target, source, signed_flag)
+        else:
+            # this means we want to vizualize the result on the source pcd
+            distances = cloud_2_rhino_mesh_distance(source, target, signed_flag)
+
+        if swap:
+            results.add(target, source, distances)
+        else:
+            results.add(source, target, distances)
 
     return results
 
 
-def cloud_2_mesh_distance(source, target, signed=False):
+# def cloud_2_mesh_distance(source, target, signed=False):
+#     """
+#         Calculate the distance between every point of a source pcd to its closest point on a target DFMesh
+#     """
+
+#     # for every point on the PCD compute the point_2_mesh_distance
+#     if signed:
+#         distances = np.asarray(target.compute_distance(source, is_abs=False))
+#     else:
+#         distances = np.asarray(target.compute_distance(source, is_abs=True))
+
+#     return distances
+
+def rhino_mesh_2_cloud_distance(source, target, signed=False):
     """
-        Calculate the distance between every point of a source pcd to its closest point on a target DFMesh
+        Calculate the distance between every vertex of a Rhino Mesh to its closest point on a PCD
     """
+    #make a Df point cloud containing all the vertices of the source rhino mesh
+    df_pcd_from_mesh_vertices = diffcheck_bindings.dfb_geometry.DFPointCloud()
+    df_pcd_from_mesh_vertices.points = [[pt.X, pt.Y, pt.Z] for pt in source.Vertices]
+    #calculate the distances
+    distances = np.asarray(df_pcd_from_mesh_vertices.compute_distance(target))
 
-    # for every point on the PCD compute the point_2_mesh_distance
     if signed:
-        distances = np.asarray(target.compute_distance(source, is_abs=False))
-    else:
-        distances = np.asarray(target.compute_distance(source, is_abs=True))
+        for p in target.points:
+
+            rhp = rg.Point3d(p[0], p[1], p[2])
+            closest_meshPoint = source.ClosestMeshPoint(rhp, 1000)
+            closest_point = closest_meshPoint.Point
+            distance = rhp.DistanceTo(closest_point)
+            # Calculate the direction from target to source
+            direction = rhp - closest_point
+            # Calculate the signed distance
+            normal = source.NormalAt(closest_meshPoint)
+            dot_product = direction * normal
+            if dot_product < 0:
+                distance = - distance
+
+    return np.asarray(distances)
 
-    return distances
 
 def cloud_2_rhino_mesh_distance(source, target, signed=False):
     """
@@ -61,7 +107,6 @@ def cloud_2_rhino_mesh_distance(source, target, signed=False):
         rhp = rg.Point3d(p[0], p[1], p[2])
         closest_meshPoint = target.ClosestMeshPoint(rhp, 1000)
         closest_point = closest_meshPoint.Point
-        face_Index = closest_meshPoint.FaceIndex
         distance = rhp.DistanceTo(closest_point)
 
         if signed:
@@ -78,42 +123,6 @@ def cloud_2_rhino_mesh_distance(source, target, signed=False):
     return np.asarray(distances)
 
 
-# def compute_mse(distances):
-#     """
-#         Calculate mean squared distance
-#     """
-#     mse = np.sqrt(np.mean(distances ** 2))
-
-#     return mse
-
-
-# def compute_max_deviation(distances):
-#     """
-#         Calculate max deviation of distances
-#     """
-#     max_deviation = np.max(distances)
-
-#     return max_deviation
-
-
-# def compute_min_deviation(distances):
-#     """
-#         Calculate min deviation of distances
-#     """
-
-#     min_deviation = np.min(distances)
-
-#     return min_deviation
-
-
-# def compute_standard_deviation(distances):
-#     """
-#         Calculate standard deviation of distances
-#     """
-#     standard_deviation = np.std(distances)
-
-#     return standard_deviation
-
 class DFVizResults:
     """
     This class compiles the resluts of the error estimation into one object

src/gh/components/DF_vizualization/code.py

@@ -251,7 +251,7 @@ def to_mesh(self):
 
             param = rg.MeshingParameters()
             scalef = diffCheck.df_util.get_doc_2_meters_unitf()
-            param.MaximumEdgeLength = 0.01 / scalef
+            param.MaximumEdgeLength = 0.1 / scalef
             mesh_part = rg.Mesh.CreateFromBrep(f, param)[0] #returns a list of meshes with one element
             mesh.Append(mesh_part)
 

src/gh/diffCheck/diffCheck/df_error_estimation.py

@@ -67,14 +67,24 @@ def value_to_color(value, min_value, max_value):
     return interpolate_color(color1, color2, t)
 
 
-def color_pcd(pcd, values, min_value, max_values):
+def color_pcd(pcd, values, min_value, max_value):
 
     for i, p in enumerate(pcd):
-        mapped_color = value_to_color(values[i], min_value, max_values)
+        mapped_color = value_to_color(values[i], min_value, max_value)
         p.Color = mapped_color
     return pcd
 
 
+def color_mesh(mesh, values, min_value, max_value):
+    mesh.VertexColors.Clear()
+    for i, vertex in enumerate(mesh.Vertices):
+
+        mapped_color = value_to_color(values[i], min_value, max_value)
+        mesh.VertexColors.Add(mapped_color.R, mapped_color.G, mapped_color.B)
+
+    return mesh
+
+
 def create_legend(min_value, max_value, steps=10, base_point=rg.Point3d(0, 0, 0),
                   width=0.5, height=1, spacing=0):
     """
@@ -172,7 +182,6 @@ def create_histogram(values, min_value, max_value, steps=100, base_point=rg.Poin
     for i in range(steps+1):
 
         bar_height = frequencies[i] * 0.01 * height
-        print(bar_height)
         points.append(rg.Point3d(x - bar_height - 0.15 , y + i * (spacing + height), z))
 
     # Create the polyline and add it to the histogram geometry