feat: improve visualization

Author: aPere3

zhc_ir/src/visualization/composition/model.rs

@@ -83,14 +83,14 @@ pub use D7::E7 as NodeGroupOutputPortVar;
 /// Horizontal row of nodes forming a diagram layer.
 pub type Layer = HStack<Node, LayerClass>;
 
-pub type LayerSeparator = Spacer<LayerClass>;
+pub type LayerSeparator = Spacer<LayerSpacerClass>;
 
 pub type LayerMember = D2<Layer, LayerSeparator>;
 pub use D2::E1 as LayerMemberLayer;
 pub use D2::E2 as LayerMemberSeparator;
 
 /// All the diagram layers
-pub type Layers = VStack<LayerMember, VerticesClass>;
+pub type Layers = VStack<LayerMember, LayersClass>;
 
 /// Content inside a group element (uses smaller padding/spacing than top-level Vertices).
 pub type GroupContent = Layers;

zhc_ir/src/visualization/composition/solver.rs

@@ -1,8 +1,7 @@
+use std::cmp::{max_by, min_by};
+
 use zhc_utils::{
-    FastMap,
-    graphics::{Frame, Height, Position},
-    iter::CollectInSmallVec,
-    svec,
+    FastMap, graphics::{Frame, Height, Position}, iter::{CollectInSmallVec, Interleave, Slide, SliderExt}, svec
 };
 
 use crate::{
@@ -48,17 +47,49 @@ fn gen_layers<'ir, 'ann>(
         order.sort_unstable_by_key(|(place, _)| *place);
         let (variable, assocs) = gen_layer(ir.walk_ops_with(order.into_iter().map(|(_, id)| id)));
         variables.push(LayerMemberLayer(variable));
-        let links_out = ir
-            .walk_ops_with(layer.walker())
-            .flat_map(|op| op.get_returns_iter().flat_map(|v| v.get_uses_iter()))
-            .count();
-        let sep_height = Height::new(10. * links_out as f64);
-        variables.push(LayerMemberSeparator(LayerSeparator::vertical(sep_height)));
         assocs.into_iter().for_each(|(k, v)| {
             opmap.insert(k, v);
         });
     }
-    variables.pop();
+    let variables = variables
+        .into_iter()
+        .interleave_with(
+            layers_map
+                .iter_layers()
+                .slide::<2>()
+                .skip_noncompletes()
+                .map(|layers| {
+                    let [layer_before, layer_after] = layers.unwrap_complete().into_array();
+                    let is_group_input_sep = ir.walk_ops_with(layer_before.walker()).all(|op| {
+                        matches!(
+                            op.get_instruction(),
+                            LayoutInstructionSet::GroupInput { .. }
+                        )
+                    });
+                    let is_group_output_sep = ir.walk_ops_with(layer_after.walker()).all(|op| {
+                        matches!(
+                            op.get_instruction(),
+                            LayoutInstructionSet::GroupOutput { .. }
+                        )
+                    });
+                    let width_before = layer_before.walker().count() as f64;
+                    let width_after = layer_after.walker().count() as f64;
+                    let traffic = ir
+                        .walk_ops_with(layer_after.walker())
+                        .map(|op| op.get_args_arity())
+                        .sum::<usize>() as f64;
+                    let width_min = min_by(width_before, width_after, |a, b| a.partial_cmp(b).unwrap());
+                    let width_max = max_by(width_before, width_after, |a, b| a.partial_cmp(b).unwrap());
+                    let spread = (width_max/width_min.max(1.)).max(1.).sqrt();
+                    let sep_height = if is_group_input_sep | is_group_output_sep {
+                        Height::new(0.)
+                    } else {
+                        Height::new(20.0 + 10.0 * traffic * spread )
+                    };
+                    LayerMemberSeparator(LayerSeparator::vertical(sep_height))
+                }),
+        )
+        .collect();
     (
         Layers::new(variables),
         AnnIR::new(ir.ir, opmap, ir.filled_valmap(())),
@@ -222,10 +253,16 @@ fn gen_group_node<'ir, 'ann>(
 
     for op in ir.walk_ops_linear() {
         match (op.get_instruction(), op.get_annotation()) {
-            (LayoutInstructionSet::GroupInput { .. }, PlacementSolution::NonGroup { op: lp }) => {
+            (
+                LayoutInstructionSet::GroupInput { .. },
+                PlacementSolution::NonGroup { op: lp, .. },
+            ) => {
                 group_inputs.push((*lp, op.get_id()));
             }
-            (LayoutInstructionSet::GroupOutput { .. }, PlacementSolution::NonGroup { op: lp }) => {
+            (
+                LayoutInstructionSet::GroupOutput { .. },
+                PlacementSolution::NonGroup { op: lp, .. },
+            ) => {
                 group_outputs.push((*lp, op.get_id()));
             }
             _ => {}

zhc_ir/src/visualization/composition/stylesheet.rs

@@ -139,11 +139,13 @@ impl StyleSheet {
         });
         output.insert::<LayerSpacerClass>(Style {
             hjustify: Justify::Space,
+            padding: Thickness::new(0.),
+            spacing: Thickness::new(0.),
             ..Default::default()
         });
-        output.insert::<VerticesClass>(Style {
+        output.insert::<LayersClass>(Style {
             padding: Thickness::new(10.),
-            spacing: Thickness::new(10.),
+            spacing: Thickness::new(0.),
             ..Default::default()
         });
         output.insert::<LinkClass>(Style {
@@ -255,8 +257,8 @@ impl Class for LayerClass {}
 pub struct LayerSpacerClass;
 impl Class for LayerSpacerClass {}
 
-pub struct VerticesClass;
-impl Class for VerticesClass {}
+pub struct LayersClass;
+impl Class for LayersClass {}
 
 pub struct LinkClass;
 impl Class for LinkClass {}

zhc_ir/src/visualization/layoutlang/generate.rs

@@ -160,7 +160,7 @@ impl StackFrame {
         let (opid, rets) = self.ir.add_op(
             LayoutInstructionSet::Operation {
                 opid: op.id,
-                op: OpContent::from_op(op, &FormatContext::new()),
+                op: OpContent::from_op(op, &FormatContext::new().show_types(true)),
                 args: op.get_arg_valids().iter().cloned().collect(),
                 returns: op.get_return_valids().iter().cloned().collect(),
             },

zhc_ir/src/visualization/layoutlang/instruction_set.rs

@@ -26,8 +26,8 @@ impl OpContent {
                 .get_returns_iter()
                 .map(|a| a.fmt_to_string(ctx))
                 .collect(),
-            call: opref.fmt_to_string(ctx),
-            comment: opref.comment.clone(),
+            call: opref.fmt_to_string(&ctx.clone().show_comments(false).show_types(false)),
+            comment: None,
         }
     }
 }

zhc_ir/src/visualization/placement/annotation.rs

@@ -194,7 +194,7 @@ pub enum PlacementSolution {
 impl PlacementSolution {
     pub fn get_place(&self) -> Place {
         match self {
-            PlacementSolution::NonGroup { op } | PlacementSolution::Group { op, .. } => *op,
+            PlacementSolution::NonGroup { op, .. } | PlacementSolution::Group { op, .. } => *op,
         }
     }
 }
@@ -212,7 +212,9 @@ fn positions_to_ranks(positions: SmallVec<Place>) -> SmallVec<Place> {
 
 fn resolve(input: OpMap<PlacementVariable>) -> OpMap<PlacementSolution> {
     input.map(|v| match v {
-        PlacementVariable::NonGroup { op, .. } => PlacementSolution::NonGroup { op: op.get_val() },
+        PlacementVariable::NonGroup { op, .. } => PlacementSolution::NonGroup {
+            op: op.get_val(),
+        },
         PlacementVariable::Group {
             op,
             maps,

zhc_utils/src/dump.rs

@@ -188,6 +188,12 @@ impl<A: Dumpable, B: Dumpable> Dumpable for (A, B) {
     }
 }
 
+impl<A: Dumpable, B: Dumpable, C: Dumpable> Dumpable for (A, B, C) {
+    fn dump_to_string(&self) -> String {
+        format!("({}, {}, {})", self.0.dump_to_string(), self.1.dump_to_string(), self.2.dump_to_string())
+    }
+}
+
 macro_rules! impl_dumpable_via_display {
     ($($t:ty),* $(,)?) => {
         $(