jagua-rs 0.6.2

A fast and fearless Collision Detection Engine for 2D irregular Cutting and Packing problems
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

use crate::entities::Instance;
use crate::entities::{Container, Item};
use crate::probs::bpp::entities::bin::Bin;
use crate::probs::bpp::util::assertions::instance_item_bin_ids_correct;

#[derive(Debug, Clone)]
/// Instance of the Bin Packing Problem.
pub struct BPInstance {
    /// The items to be packed and their demands
    pub items: Vec<(Item, usize)>,
    /// Set of bins available to pack the items
    pub bins: Vec<Bin>,
}

impl BPInstance {
    pub fn new(items: Vec<(Item, usize)>, bins: Vec<Bin>) -> Self {
        assert!(instance_item_bin_ids_correct(&items, &bins));

        Self { items, bins }
    }

    pub fn item_area(&self) -> f32 {
        self.items
            .iter()
            .map(|(item, qty)| item.shape_orig.area() * *qty as f32)
            .sum()
    }

    pub fn item_qty(&self, id: usize) -> usize {
        self.items[id].1
    }

    pub fn bins(&self) -> impl Iterator<Item = &Bin> {
        self.bins.iter()
    }

    pub fn bin_qty(&self, id: usize) -> usize {
        self.bins[id].stock
    }

    pub fn total_item_qty(&self) -> usize {
        self.items.iter().map(|(_, qty)| *qty).sum()
    }
}

impl Instance for BPInstance {
    fn items(&self) -> impl Iterator<Item = &Item> {
        self.items.iter().map(|(item, _qty)| item)
    }

    fn containers(&self) -> impl Iterator<Item = &Container> {
        self.bins.iter().map(|bin| &bin.container)
    }

    fn item(&self, id: usize) -> &Item {
        &self.items.get(id).unwrap().0
    }

    fn container(&self, id: usize) -> &Container {
        &self.bins[id].container
    }
}