WIP-FIX change inputs for cloud2cloud comparison to lists

Author: eleniv3d

src/gh/components/DF_cloud_to_cloud_distance/code.py

@@ -20,32 +20,33 @@
 
 class CloudToCloudDistance(component):
     def RunScript(self,
-        i_cloud_source: rg.PointCloud,
-        i_cloud_target: rg.PointCloud):
+        i_cloud_source:  typing.List[rg.PointCloud],
+        i_cloud_target: typing.List[rg.PointCloud]):
         """
             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.
 
-            :param i_cloud_source: source point cloud
-            :param i_cloud_target: target point cloud to align to
+            :param i_cloud_source: a list of source point cloud
+            :param i_cloud_target: a list of target point cloud to align to
 
             :return o_distances : list of calculated distances for each point
             :return o_mse: the average squared difference between corresponding points of source and target
             :return o_max_deviation: the max deviation between source and target (Hausdorff Distance)
             :return o_min_deviation: the min deviation between source and target
             :return o_std_deviation: the standard deviation between source and target
         """
+
         if i_cloud_source is None or i_cloud_target is None:
             ghenv.Component.AddRuntimeMessage(RML.Warning, "Please provide both objects of type point clouds to compare")
             return None
 
         # conversion
-        df_cloud_source = df_cvt_bindings.cvt_rhcloud_2_dfcloud(i_cloud_source)
-        df_cloud_target = df_cvt_bindings.cvt_rhcloud_2_dfcloud(i_cloud_target)
+        df_cloud_source_list = [df_cvt_bindings.cvt_rhcloud_2_dfcloud(i_cl_s) for i_cl_s in i_cloud_source]
+        df_cloud_target_list = [df_cvt_bindings.cvt_rhcloud_2_dfcloud(i_cl_t) for i_cl_t in i_cloud_target]
 
         # calculate distances
-        o_results = df_error_estimation.cloud_2_cloud_distance(df_cloud_source, df_cloud_target)
+        o_results = df_error_estimation.cloud_2_cloud_comparison(df_cloud_source_list, df_cloud_target_list)
 
-        return o_results.distances_to_target, o_results.distances_to_target_mse, o_results.distances_to_target_max_deviation, o_results.distances_to_target_min_deviation, o_results.distances_to_target_sd_deviation, o_results
+        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__":

src/gh/components/DF_vizualization/code.py

@@ -21,8 +21,6 @@
 class Vizualization(component):
     def RunScript(self,
         i_results,
-        i_target_flag,
-        i_source_flag,
         i_viz_settings):
         """
             sth sth
@@ -32,38 +30,25 @@ def RunScript(self,
             ghenv.Component.AddRuntimeMessage(RML.Warning, "Please provide both objects of type point clouds to compare")
             return None
 
-        if i_target_flag == False:
-            #if user doesn't want to vizualize results on the target return the original geo
-            #now only implemented for PCD
-            o_target = df_cvt_bindings.cvt_dfcloud_2_rhcloud(i_results.target)
-            o_target_legend = []
-        else:
-            #color the target pointcloud based on viz_settings
+        #temp
+        o_source = []
+        o_target = []
 
-            #make a legend
+        o_source = [df_cvt_bindings.cvt_dfcloud_2_rhcloud(src) for src in i_results.source]
+        o_target = [df_cvt_bindings.cvt_dfcloud_2_rhcloud(trg) for trg in i_results.target]
 
-            pass
+        o_legend = []
+    
+        #color the source pointcloud based on viz_settings
 
-        if i_source_flag == False:
-            #if user doesn't want to vizualize results on the target return the original geo
-            #now only implemented for PCD
-            o_source = df_cvt_bindings.cvt_dfcloud_2_rhcloud(i_results.source)
-            o_source_legend = []
-        else:
-            #color the source pointcloud based on viz_settings
+        #make a legend
 
-            #make a legend
-
-            pass
-
-        return o_source, o_target, o_source_legend, o_target_legend
+        return o_source, o_target, o_legend
 
 
 if __name__ == "__main__":
     com = Vizualization()
-    o_source, o_target, o_source_legend, o_target_legend = com.RunScript(
+    o_source, o_target, o_legend,  = com.RunScript(
         i_results,
-        i_target_flag,
-        i_source_flag,
         i_viz_settings
         )

src/gh/diffCheck/diffCheck/df_error_estimation.py

@@ -8,14 +8,31 @@
 from diffCheck import diffcheck_bindings
 import Rhino.Geometry as rg
 
-def cloud_2_cloud_distance(source, target, signed=False):
+
+def cloud_2_cloud_distance(source, target, invert=False):
     """
-        Compute the Euclidean distance for every point of a source pcd to its closest point on a target pointcloud
+        Compute the Euclidean distance for every point of a source pcd to its
+        closest point on a target pointcloud
     """
-    distances_to_target = np.asarray(source.compute_distance(target))
-    distances_to_source = np.asarray(target.compute_distance(source))
+    if invert:
+        distances = np.asarray(target.compute_distance(source))
+    else:
+        distances = np.asarray(source.compute_distance(target))
 
-    return DFVizResults(source, target, distances_to_target, distances_to_source)
+    return distances
+
+
+def cloud_2_cloud_comparison(source_list, target_list, invert=False):
+    """
+        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)
+
+    return results
 
 
 def cloud_2_mesh_distance(source, target, signed=False):
@@ -102,20 +119,24 @@ class DFVizResults:
     This class compiles the resluts of the error estimation into one object
     """
 
-    def __init__(self, source, target, distances_to_target, distances_to_source):
+    def __init__(self):
+
+        self.source = []
+        self.target = []
 
-        self.source = source
-        self.target = target
+        self.distances_mse = []
+        self.distances_max_deviation = []
+        self.distances_min_deviation = []
+        self.distances_sd_deviation = []
+        self.distances = []
 
-        self.distances_to_target_mse = np.sqrt(np.mean(distances_to_target ** 2))
-        self.distances_to_target_max_deviation = np.max(distances_to_target)
-        self.distances_to_target_min_deviation = np.min(distances_to_target)
-        self.distances_to_target_sd_deviation = np.std(distances_to_target)
-        self.distances_to_target = distances_to_target.tolist()
+    def add(self, source, target, distances):
 
-        self.distances_to_source_mse = np.sqrt(np.mean(distances_to_source ** 2))
-        self.distances_to_source_max_deviation = np.max(distances_to_source)
-        self.distances_to_source_min_deviation = np.min(distances_to_source)
-        self.distances_to_source_sd_deviation = np.std(distances_to_source)
-        self.distances_to_source = distances_to_source.tolist()
+        self.source.append(source)
+        self.target.append(target)
 
+        self.distances_mse.append(np.sqrt(np.mean(distances ** 2)))
+        self.distances_max_deviation.append(np.max(distances))
+        self.distances_min_deviation.append(np.min(distances))
+        self.distances_sd_deviation.append(np.std(distances))
+        self.distances.append(distances.tolist())