eunoia 0.13.0

A library for creating area-proportional Euler and Venn diagrams
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

//! Integration tests for the plotting module.

#[cfg(feature = "plotting")]
use eunoia::geometry::shapes::Circle;
#[cfg(feature = "plotting")]
use eunoia::spec::{DiagramSpecBuilder, InputType};
#[cfg(feature = "plotting")]
use eunoia::Fitter;

#[test]
#[cfg(feature = "plotting")]
fn test_region_decomposition_two_sets() {
    let spec = DiagramSpecBuilder::new()
        .set("A", 10.0)
        .set("B", 8.0)
        .intersection(&["A", "B"], 2.0)
        .input_type(InputType::Exclusive)
        .build()
        .unwrap();

    let layout = Fitter::<Circle>::new(&spec).seed(42).fit().unwrap();

    // Get region polygons using the convenient method
    let regions = layout.region_polygons(&spec, 64);

    // Should have at least A-only, B-only, and A&B regions
    assert!(regions.len() >= 2);

    // Check that total polygon area is close to expected
    let total_area: f64 = regions.areas().values().sum();
    let expected_total: f64 = spec.exclusive_areas().values().sum();

    assert!(
        (total_area - expected_total).abs() < 1.0,
        "Total area {:.3} should be close to expected {:.3}",
        total_area,
        expected_total
    );
}

#[test]
#[cfg(feature = "plotting")]
fn test_region_decomposition_three_sets() {
    let spec = DiagramSpecBuilder::new()
        .set("A", 5.0)
        .set("B", 5.0)
        .set("C", 5.0)
        .intersection(&["A", "B"], 1.0)
        .intersection(&["B", "C"], 1.0)
        .intersection(&["A", "C"], 1.0)
        .intersection(&["A", "B", "C"], 0.5)
        .input_type(InputType::Exclusive)
        .build()
        .unwrap();

    let layout = Fitter::<Circle>::new(&spec).seed(123).fit().unwrap();
    let regions = layout.region_polygons(&spec, 128);

    // Should have multiple regions
    assert!(regions.len() >= 3);

    // Verify each region has pieces with non-degenerate outer rings.
    for (combo, pieces) in regions.iter() {
        assert!(!pieces.is_empty(), "Region {:?} should have pieces", combo);
        for piece in pieces {
            assert!(
                piece.outer.vertices().len() >= 3,
                "Outer ring should have at least 3 vertices"
            );
        }
    }
}

#[test]
#[cfg(feature = "plotting")]
fn test_region_polygons_with_ellipses() {
    use eunoia::geometry::shapes::Ellipse;

    let spec = DiagramSpecBuilder::new()
        .set("A", 8.0)
        .set("B", 6.0)
        .intersection(&["A", "B"], 2.0)
        .input_type(InputType::Exclusive)
        .build()
        .unwrap();

    let layout = Fitter::<Ellipse>::new(&spec).seed(42).fit().unwrap();
    let regions = layout.region_polygons(&spec, 96);

    assert!(regions.len() >= 2);

    // Check areas are reasonable
    let areas = regions.areas();
    for (_, &area) in areas.iter() {
        assert!(area > 0.0, "All regions should have positive area");
    }
}