WIP-FIX legend display to smooth. fixed steps to correct number

Author: eleniv3d

src/gh/components/DF_vizualization/code.py

@@ -34,6 +34,7 @@ def RunScript(self,
         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]
         min_value = min(min(sublist) for sublist in i_results.distances)
         max_value = max(max(sublist) for sublist in i_results.distances)
 
@@ -42,13 +43,15 @@ def RunScript(self,
         o_target = [df_cvt_bindings.cvt_dfcloud_2_rhcloud(trg) for trg in i_results.target]
 
         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_target, o_legend
+        return o_source, o_target, o_legend, o_histogram
 
 
 if __name__ == "__main__":
     com = Vizualization()
-    o_source, o_target, o_legend,  = com.RunScript(
+    o_source, o_target, o_legend, o_histogram  = com.RunScript(
         i_results,
         i_viz_settings
         )

src/gh/diffCheck/diffCheck/df_vizualization.py

@@ -3,18 +3,17 @@
     This module contains the utility functions to vizualize differences
 """
 
-import numpy as np
-import open3d as o3d
-from diffCheck import diffcheck_bindings
 import Rhino.Geometry as rg
-import System.Drawing
+from System.Drawing import Color
+
 
 class DFVizSettings:
     """
     This class compiles the settings for the vizualization into one object
     """
 
-    def __init__(self, source_valueType, target_valueType, upper_threshold, lower_threshold, palette):
+    def __init__(self, source_valueType, target_valueType, upper_threshold,
+                 lower_threshold, palette):
 
         self.source_valueType = source_valueType
         self.target_valueType = target_valueType
@@ -30,20 +29,19 @@ def interpolate_color(color1, color2, t):
     r = int(color1.R + (color2.R - color1.R) * t)
     g = int(color1.G + (color2.G - color1.G) * t)
     b = int(color1.B + (color2.B - color1.B) * t)
-    return System.Drawing.Color.FromArgb(r, g, b)
+    return Color.FromArgb(r, g, b)
 
 
 def value_to_color(value, min_value, max_value):
     """Map a value to a color based on a spectral colormap."""
 
     # Define the spectral colormap (simplified)
     colormap = [
-        System.Drawing.Color.FromArgb(0, 0, 255),  # Blue
-        System.Drawing.Color.FromArgb(0, 255, 255),  # Cyan
-        System.Drawing.Color.FromArgb(0, 255, 0),  # Green
-        System.Drawing.Color.FromArgb(255, 255, 0),  # Yellow
-        System.Drawing.Color.FromArgb(255, 0, 0),  # Red
-        System.Drawing.Color.FromArgb(255, 0, 255)  # Magenta
+        Color.FromArgb(0, 0, 255),  # Blue
+        Color.FromArgb(0, 255, 255),  # Cyan
+        Color.FromArgb(0, 255, 0),  # Green
+        Color.FromArgb(255, 255, 0),  # Yellow
+        Color.FromArgb(255, 0, 0),  # Red
     ]
 
     # Normalize the value within the range
@@ -53,7 +51,7 @@ def value_to_color(value, min_value, max_value):
         t = (value - min_value) / (max_value - min_value)
 
     # Determine the segment in the colormap
-    n = len(colormap) - 1
+    n = len(colormap)-1
     idx = int(t * n)
     if idx >= n:
         idx = n - 1
@@ -74,10 +72,11 @@ def color_pcd(pcd, values, min_value, max_values):
     return pcd
 
 
-def create_legend(min_value, max_value, steps=10, base_point=rg.Point3d(0, 0, 0), width=0.5, height=1, spacing=0):
+def create_legend(min_value, max_value, steps=10, base_point=rg.Point3d(0, 0, 0),
+                  width=0.5, height=1, spacing=0):
     """
     Create a legend in Rhino with colored hatches and text labels.
-    
+
     Parameters:
     min_value (float): Minimum value for the legend.
     max_value (float): Maximum value for the legend.
@@ -88,38 +87,93 @@ def create_legend(min_value, max_value, steps=10, base_point=rg.Point3d(0, 0, 0)
     spacing (float): Spacing between rectangles.
     """
     x, y, z = base_point.X, base_point.Y, base_point.Z
-    
+
     legend_geometry = []
 
-    for i in range(steps + 1):
+    for i in range(steps+1):
+
         value = min_value + (max_value - min_value) * i / steps
         color = value_to_color(value, min_value, max_value)
-        
+
+        if i > 0:
+            mesh = rg.Mesh()
+            for pt in rect_pts:
+                mesh.Vertices.Add(pt)
+            # color mesh
+            mesh.Faces.AddFace(0, 1, 2, 3)
+            
+            mesh.VertexColors.Add(previous_color.R, previous_color.G, previous_color.B)
+            mesh.VertexColors.Add(previous_color.R, previous_color.G, previous_color.B)
+            mesh.VertexColors.Add(color.R, color.G, color.B)
+            mesh.VertexColors.Add(color.R, color.G, color.B)
+            mesh.VertexColors.Add(color.R, color.G, color.B)
+
+
+            polyline = rg.Polyline(rect_pts)
+
+            legend_geometry.append(mesh)
+            # legend_geometry.append(polyline.ToPolylineCurve())
+
+        text_pt = rg.Point3d(x + 1.25 * width + spacing, y + i * (height + spacing) + height / 10, z)
+        text_entity = rg.TextEntity()
+        text_entity.Plane = rg.Plane(text_pt, rg.Vector3d.ZAxis)
+        text_entity.Text = f"{value:.2f}"
+        text_entity.TextHeight = height / 5
+        legend_geometry.append(text_entity)
+
         rect_pts = [
             rg.Point3d(x, y + i * (height + spacing), z),
             rg.Point3d(x + width, y + i * (height + spacing), z),
             rg.Point3d(x + width, y + (i + 1) * height + i * spacing, z),
             rg.Point3d(x, y + (i + 1) * height + i * spacing, z),
-            rg.Point3d(x, y + i * (height + spacing), z)
         ]
-        
-        mesh = rg.Mesh()
-        for pt in rect_pts:
-            mesh.Vertices.Add(pt)
-        mesh.Faces.AddFace(0, 1, 2, 3)
-        mesh.VertexColors.CreateMonotoneMesh(color)
 
-        polyline = rg.Polyline(rect_pts)
-        
-        legend_geometry.append(mesh)
-        
-        legend_geometry.append(polyline.ToPolylineCurve())
+        previous_color = color
+
+    return legend_geometry
+
+
+def create_histogram(values, min_value, max_value, steps=10, base_point=rg.Point3d(0,0,0), height=0.1, spacing=0.1):
+    """
+    Create a histogram in Rhino with a polyline representing value frequencies.
+
+    Parameters:
+    values (list of float): List of values to calculate the histogram.
+    min_value (float): Minimum value for the histogram.
+    max_value (float): Maximum value for the histogram.
+    steps (int): Number of steps in the histogram.
+    base_point (rg.Point3d): The base point where the histogram starts.
+    height (float): Height of each bin in the histogram.
+    spacing (float): Spacing between bins.
+    """
+    histogram_geometry = []
+
+    # Calculate the size of each bin
+    bin_size = (max_value - min_value) / steps
+
+    # Initialize the frequency counts for each bin
+    frequencies = [0] * (steps + 1)
+
+    # Count the frequencies of values in each bin
+    for value in values:
+        if min_value <= value and value <= max_value:
+            bin_index = (value - min_value) // bin_size
+            bin_index = int(bin_index)
+            if bin_index == steps:
+                bin_index -= 1
+            frequencies[bin_index] += 1
+
+    x, y, z = base_point.X, base_point.Y, base_point.Z
+
+    # Create points for the polyline representing the histogram
+    points = [rg.Point3d(x, y, z)]
+    for i in range(int(steps)):
 
-        text_pt = rg.Point3d(x + width + spacing, y + i * (height + spacing) + height / 2, z)
-        text_entity = rg.TextEntity()
-        text_entity.Plane = rg.Plane(text_pt, rg.Vector3d.ZAxis)
-        text_entity.Text = f"{value:.2f}"
-        text_entity.TextHeight = height / 2
-        legend_geometry.append(text_entity)
-    
-    return legend_geometry
+        bar_height = frequencies[i] * height
+        points.append(rg.Point3d(x + bar_height, y + i * (spacing + height), z))
+        points.append(rg.Point3d(x, y + (i + 1) * (spacing + height), z))
+    # Create the polyline and add it to the histogram geometry
+    polyline = rg.Polyline(points)
+    histogram_geometry.append(points)
+
+    return histogram_geometry