bspa 0.1.1

Beam search packing algorithm
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

use beamsrch::Node;

use crate::{Area, BspaNode, types::*};

const SIDE: u32 = 8;
const PADD: u32 = 4;

#[test]
fn basic_beam_functions() {
    const RECT_0: Rect = Rect::new(SIDE, SIDE);
    const RECT_1: Rect = Rect::new(SIDE, PADD);
    const SPACES: [Placement<Rect>; 3] = [
        Placement {
            x: 0,
            y: SIDE,
            item: Rect::new(SIDE * 3, PADD),
        },
        Placement {
            x: SIDE,
            y: PADD,
            item: Rect::new(SIDE, PADD * 2),
        },
        Placement {
            x: SIDE * 3,
            y: 0,
            item: Rect::new(PADD, SIDE + PADD),
        },
    ];

    let tmp = BspaNode::new([RECT_0, RECT_1].repeat(5), SIDE * 3, 0, 1.0);
    let mut node = BspaNode {
        spaces: SPACES.to_vec(),
        blocks: vec![Placement {
            x: 0,
            y: 0,
            item: [
                Placement {
                    x: 0,
                    y: 0,
                    item: RECT_0,
                },
                Placement {
                    x: SIDE,
                    y: 0,
                    item: RECT_1,
                },
                Placement {
                    x: SIDE * 2,
                    y: 0,
                    item: RECT_0,
                },
            ]
            .into_iter()
            .collect(),
        }],
        avai_box: tmp.avai_box,
        avai_blk: tmp.avai_blk,
    };

    Node::<0>::inflate(&mut node);

    let xmax = node
        .spaces
        .iter()
        .map(|s| s.x + s.w())
        .max()
        .unwrap_or_else(|| node.w());
    assert_eq!(
        node.spaces,
        vec![
            Placement {
                x: SPACES[0].x,
                y: SPACES[0].y,
                item: Rect::new(SPACES[0].item.w(), 44 - SPACES[0].y)
            },
            Placement {
                x: SPACES[1].x,
                y: SPACES[1].y,
                item: Rect::new(SPACES[1].item.w(), 44 - SPACES[1].y)
            },
            Placement {
                x: SPACES[2].x,
                y: SPACES[2].y,
                item: Rect::new(SPACES[2].item.w(), 44 - SPACES[2].y),
            },
            Placement {
                x: 0,
                y: node.h(),
                item: Rect::new(xmax, 44 - node.h()),
            },
        ]
    );
}