bin_packer_3d 1.0.0

Three dimensional fitting algorithm to fit smaller boxes inside of a larger box
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use crate::bin::Bin;
use crate::block::{Block, Dimension};
use crate::error::Result;
use crate::item::Item;

mod block {
    use super::*;

    #[test]
    fn test_block_creation() -> Result<()> {
        Block::new(1, 2, 3);
        Ok(())
    }

    #[test]
    fn test_item_creation() -> Result<()> {
        Item::new("asdf", [1, 2, 3]);
        Ok(())
    }

    #[test]
    fn test_bin_creation() -> Result<()> {
        Bin::new([1 as Dimension, 2 as Dimension, 3 as Dimension]);
        Ok(())
    }

    #[test]
    fn test_block_volume() -> Result<()> {
        let b = Block::new(3 as Dimension, 4 as Dimension, 5 as Dimension);
        assert_eq!(b.volume(), 60 as Dimension);
        Ok(())
    }

    #[test]
    fn test_block_volume_large_values() -> Result<()> {
        let b = Block::new(200 as Dimension, 100 as Dimension, 200 as Dimension);
        assert_eq!(b.volume(), 4_000_000 as Dimension);
        Ok(())
    }

    #[test]
    fn test_block_does_it_fit() -> Result<()> {
        // test that when an item fits, it returns true
        let item = Block::new(3.5, 14.0, 12.7);
        let container = Block::new(4 as Dimension, 22 as Dimension, 14 as Dimension);
        assert!(container.does_it_fit(&item));
        Ok(())
    }

    #[test]
    fn test_block_does_it_fit_false() -> Result<()> {
        // test that when a item does not fit, it returns false
        let item = Block::new(4 as Dimension, 12 as Dimension, 14 as Dimension);
        let container = Block::new(3 as Dimension, 14 as Dimension, 14 as Dimension);
        assert!(!container.does_it_fit(&item));
        Ok(())
    }

    #[test]
    fn test_best_fit_nil() -> Result<()> {
        // assert that if a item does not fit in the container,
        // we get None returned
        let item = Block::new(4 as Dimension, 12 as Dimension, 14 as Dimension);
        let container = Block::new(3 as Dimension, 14 as Dimension, 14 as Dimension);
        assert_eq!(container.best_fit(&item), None);
        Ok(())
    }

    #[test]
    fn test_best_fit_exact_size() -> Result<()> {
        // assert that if a item is the same size as the container, the remaining_dimensions comes back
        // empty

        let item = Block::new(13 as Dimension, 13 as Dimension, 31 as Dimension);
        let container = Block::new(13 as Dimension, 13 as Dimension, 31 as Dimension);
        assert_eq!(container.best_fit(&item), Some(vec![]));
        Ok(())
    }

    #[test]
    fn test_best_fit_half_size() -> Result<()> {
        // Assert that if a item is smaller than the container, but has two dimensions the same, it will
        // return the empty space

        let item = Block::new(13 as Dimension, 13 as Dimension, 31 as Dimension);
        let container = Block::new(13 as Dimension, 26 as Dimension, 31 as Dimension);
        assert_eq!(
            container.best_fit(&item),
            Some(vec![Block::new(
                13 as Dimension,
                13 as Dimension,
                31 as Dimension
            )])
        );
        Ok(())
    }

    #[test]
    fn test_best_fit_first_fit_greater_than() -> Result<()> {
        // test that the "greater than" match clause of the first fit returns the
        // correct remaining space.
        let item = Block::new(1.25, 7.0, 10.0);
        let container = Block::new(3.5, 9.5, 12.5);
        assert_eq!(
            container.best_fit(&item),
            Some(vec![
                Block::new(1.25, 2.5, 7.0),
                Block::new(2.5, 3.5, 12.5),
                Block::new(2.25, 7.0, 12.5)
            ])
        );
        Ok(())
    }

    #[test]
    fn test_best_fit_multiple_spaces_1_2_2() -> Result<()> {
        // test to ensure that our 2x theorum is working
        let item = Block::new(1 as Dimension, 1 as Dimension, 1 as Dimension);
        let container = Block::new(1 as Dimension, 2 as Dimension, 2 as Dimension);
        assert_eq!(
            container.best_fit(&item),
            Some(vec![
                Block::new(1 as Dimension, 1 as Dimension, 1 as Dimension),
                Block::new(1 as Dimension, 1 as Dimension, 2 as Dimension)
            ])
        );
        Ok(())
    }

    #[test]
    fn test_best_fit_multiple_spaces() -> Result<()> {
        // assert that if a item is smaller than the container, but has two dimensions
        // the same, it will return the empty space
        let item = Block::new(13 as Dimension, 13 as Dimension, 31 as Dimension);
        let (x, y, z) = (20 as Dimension, 20 as Dimension, 31 as Dimension);
        let container = Block::new(x, y, z);
        assert_eq!(
            container.best_fit(&item),
            Some(vec![
                Block::new(7 as Dimension, 13 as Dimension, 31 as Dimension),
                Block::new(7 as Dimension, 20 as Dimension, 31 as Dimension)
            ])
        );
        Ok(())
    }
}