PackedLayer - Code Metrics - dvdoug/BoxPacker - Measure and Improve Code Quality continuously with Scrutinizer

PackedLayer A
last analyzed 2025-07-15 19:49 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	181
Duplicated Lines	0 %

Test Coverage

Coverage

90.36%

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	70
c	1
b	0
f	0
dl	0
loc	181
ccs	75
cts	83
cp	0.9036
rs	9.68
wmc	34

14 Methods

Rating	Name	Size	Complexity
A	getWeight()	8	2
A	getLength()	14	3
A	getFootprint()	3	1
A	getItems()	3	1
A	getStartZ()	12	3
A	getWidth()	14	3
A	getStartX()	12	3
A	getEndX()	12	3
A	insert()	3	1
A	getStartY()	12	3
A	merge()	4	2
A	getDepth()	14	3
A	getEndY()	12	3
A	getEndZ()	12	3

<?php

/**
 * Box packing (3D bin packing, knapsack problem).
 *
 * @author Doug Wright
 */
declare(strict_types=1);

namespace DVDoug\BoxPacker;

use function max;
use function min;

/**
 * A packed layer.
 * @internal
 */
class PackedLayer
{
    /**
     * @var PackedItem[]
     */
    protected array $items = [];

    /**
     * Add a packed item to this layer.
     */
    public function insert(PackedItem $packedItem): void
    {
        $this->items[] = $packedItem;
    }

    /**
     * Get the packed items.
     *
     * @return PackedItem[]
     */
    public function getItems(): array
    {
        return $this->items;
    }

    /**
     * Calculate footprint area of this layer.
     *
     * @return int mm^2
     */
    public function getFootprint(): int
    {
        return $this->getWidth() * $this->getLength();
    }

    public function getStartX(): int
    {
        if (!$this->items) {

            return 0;
        }

        $values = [];
        foreach ($this->items as $item) {
            $values[] = $item->x;
        }

        return min($values);
    }

    public function getEndX(): int
    {
        if (!$this->items) {

            return 0;
        }

        $values = [];
        foreach ($this->items as $item) {
            $values[] = $item->x + $item->width;
        }

        return max($values);
    }

    public function getWidth(): int
    {
        if (!$this->items) {

            return 0;
        }

        $start = [];
        $end = [];
        foreach ($this->items as $item) {
            $start[] = $item->x;
            $end[] = $item->x + $item->width;
        }

        return max($end) - min($start);
    }

    public function getStartY(): int
    {
        if (!$this->items) {

            return 0;
        }

        $values = [];
        foreach ($this->items as $item) {
            $values[] = $item->y;
        }

        return min($values);
    }

    public function getEndY(): int
    {
        if (!$this->items) {

            return 0;
        }

        $values = [];
        foreach ($this->items as $item) {
            $values[] = $item->y + $item->length;
        }

        return max($values);
    }

    public function getLength(): int
    {
        if (!$this->items) {

            return 0;
        }

        $start = [];
        $end = [];
        foreach ($this->items as $item) {
            $start[] = $item->y;
            $end[] = $item->y + $item->length;
        }

        return max($end) - min($start);
    }

    public function getStartZ(): int
    {
        if (!$this->items) {

            return 0;
        }

        $values = [];
        foreach ($this->items as $item) {
            $values[] = $item->z;
        }

        return min($values);
    }

    public function getEndZ(): int
    {
        if (!$this->items) {

            return 0;
        }

        $values = [];
        foreach ($this->items as $item) {
            $values[] = $item->z + $item->depth;
        }

        return max($values);
    }

    public function getDepth(): int
    {
        if (!$this->items) {

            return 0;
        }

        $start = [];
        $end = [];
        foreach ($this->items as $item) {
            $start[] = $item->z;
            $end[] = $item->z + $item->depth;
        }

        return max($end) - min($start);
    }

    public function getWeight(): int
    {
        $weight = 0;
        foreach ($this->items as $item) {
            $weight += $item->item->getWeight();
        }

        return $weight;
    }

    public function merge(self $otherLayer): void
    {
        foreach ($otherLayer->items as $packedItem) {
            $this->items[] = $packedItem;
        }
    }
}


1		<?php
2
3		/**
4		* Box packing (3D bin packing, knapsack problem).
5		*
6		* @author Doug Wright
7		*/
8		declare(strict_types=1);
9
10		namespace DVDoug\BoxPacker;
11
12		use function max;
13		use function min;
14
15		/**
16		* A packed layer.
17		* @internal
18		*/
19		class PackedLayer
20		{
21		/**
22		* @var PackedItem[]
23		*/
24		protected array $items = [];
25
26		/**
27		* Add a packed item to this layer.
28	99	*/
29		public function insert(PackedItem $packedItem): void
30	99	{
31		$this->items[] = $packedItem;
32		}
33
34		/**
35		* Get the packed items.
36		*
37		* @return PackedItem[]
38	101	*/
39		public function getItems(): array
40	101	{
41		return $this->items;
42		}
43
44		/**
45		* Calculate footprint area of this layer.
46		*
47		* @return int mm^2
48	51	*/
49		public function getFootprint(): int
50	51	{
51		return $this->getWidth() * $this->getLength();
52		}
53	1
54		public function getStartX(): int
55	1	{
56		if (!$this->items) {
		0 ignored issues – show Bug Best Practice introduced 2023-07-26 12:23 UTC by Report Bug Copy Issue Report The expression `$this->items` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
57		return 0;
58		}
59	1
60	1	$values = [];
61	1	foreach ($this->items as $item) {
62		$values[] = $item->x;
63		}
64	1
65		return min($values);
66		}
67	99
68		public function getEndX(): int
69	99	{
70		if (!$this->items) {
		0 ignored issues – show Bug Best Practice introduced 2023-07-26 12:23 UTC by Report Bug Copy Issue Report The expression `$this->items` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
71		return 0;
72		}
73	99
74	99	$values = [];
75	99	foreach ($this->items as $item) {
76		$values[] = $item->x + $item->width;
77		}
78	99
79		return max($values);
80		}
81	51
82		public function getWidth(): int
83	51	{
84		if (!$this->items) {
		0 ignored issues – show Bug Best Practice introduced 2023-07-26 12:23 UTC by Report Bug Copy Issue Report The expression `$this->items` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
85		return 0;
86		}
87	51
88	51	$start = [];
89	51	$end = [];
90	51	foreach ($this->items as $item) {
91	51	$start[] = $item->x;
92		$end[] = $item->x + $item->width;
93		}
94	51
95		return max($end) - min($start);
96		}
97	1
98		public function getStartY(): int
99	1	{
100		if (!$this->items) {
		0 ignored issues – show Bug Best Practice introduced 2023-07-26 12:23 UTC by Report Bug Copy Issue Report The expression `$this->items` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
101		return 0;
102		}
103	1
104	1	$values = [];
105	1	foreach ($this->items as $item) {
106		$values[] = $item->y;
107		}
108	1
109		return min($values);
110		}
111	99
112		public function getEndY(): int
113	99	{
114	97	if (!$this->items) {
		0 ignored issues – show Bug Best Practice introduced 2023-07-26 12:23 UTC by Report Bug Copy Issue Report The expression `$this->items` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
115		return 0;
116		}
117	99
118	99	$values = [];
119	99	foreach ($this->items as $item) {
120		$values[] = $item->y + $item->length;
121		}
122	99
123		return max($values);
124		}
125	51
126		public function getLength(): int
127	51	{
128		if (!$this->items) {
		0 ignored issues – show Bug Best Practice introduced 2023-07-26 12:23 UTC by Report Bug Copy Issue Report The expression `$this->items` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
129		return 0;
130		}
131	51
132	51	$start = [];
133	51	$end = [];
134	51	foreach ($this->items as $item) {
135	51	$start[] = $item->y;
136		$end[] = $item->y + $item->length;
137		}
138	51
139		return max($end) - min($start);
140		}
141	98
142		public function getStartZ(): int
143	98	{
144		if (!$this->items) {
		0 ignored issues – show Bug Best Practice introduced 2023-07-26 12:23 UTC by Report Bug Copy Issue Report The expression `$this->items` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
145		return 0;
146		}
147	98
148	98	$values = [];
149	98	foreach ($this->items as $item) {
150		$values[] = $item->z;
151		}
152	98
153		return min($values);
154		}
155	1
156		public function getEndZ(): int
157	1	{
158		if (!$this->items) {
		0 ignored issues – show Bug Best Practice introduced 2023-07-26 12:23 UTC by Report Bug Copy Issue Report The expression `$this->items` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
159		return 0;
160		}
161	1
162	1	$values = [];
163	1	foreach ($this->items as $item) {
164		$values[] = $item->z + $item->depth;
165		}
166	1
167		return max($values);
168		}
169	99
170		public function getDepth(): int
171	99	{
172		if (!$this->items) {
		0 ignored issues – show Bug Best Practice introduced 2023-07-26 12:23 UTC by Report Bug Copy Issue Report The expression `$this->items` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
173		return 0;
174		}
175	99
176	99	$start = [];
177	99	$end = [];
178	99	foreach ($this->items as $item) {
179	99	$start[] = $item->z;
180		$end[] = $item->z + $item->depth;
181		}
182	99
183		return max($end) - min($start);
184		}
185	1
186		public function getWeight(): int
187	1	{
188	1	$weight = 0;
189	1	foreach ($this->items as $item) {
190		$weight += $item->item->getWeight();
191		}
192	1
193		return $weight;
194		}
195	98
196		public function merge(self $otherLayer): void
197	98	{
198	25	foreach ($otherLayer->items as $packedItem) {
199		$this->items[] = $packedItem;
200		}
201		}
202		}
203

dvdoug / BoxPacker

PackedLayer A last analyzed 2025-07-15 19:49 UTC

Complexity

Size/Duplication

Test Coverage

Importance

14 Methods

Duplication Side-by-Side

Filter issues like

PackedLayer A
last analyzed 2025-07-15 19:49 UTC