dvdoug / BoxPacker

BoxList.php

Indentation +14 added lines, -14 removed lines

@@ -4,29 +4,29 @@
  * @package BoxPacker
  * @author Doug Wright
  */
-  namespace DVDoug\BoxPacker;
+    namespace DVDoug\BoxPacker;
 
-  /**
-   * List of boxes available to put items into, ordered by volume
-   * @author Doug Wright
-   * @package BoxPacker
-   */
-  class BoxList extends \SplMinHeap {
+    /**
+     * List of boxes available to put items into, ordered by volume
+     * @author Doug Wright
+     * @package BoxPacker
+     */
+    class BoxList extends \SplMinHeap {
 
     /**
      * Compare elements in order to place them correctly in the heap while sifting up.
      * @see \SplMinHeap::compare()
      */
     public function compare($aBoxA, $aBoxB) {
-      if ($aBoxB->getInnerVolume() > $aBoxA->getInnerVolume()) {
+        if ($aBoxB->getInnerVolume() > $aBoxA->getInnerVolume()) {
         return 1;
-      }
-      else if ($aBoxB->getInnerVolume() < $aBoxA->getInnerVolume()) {
+        }
+        else if ($aBoxB->getInnerVolume() < $aBoxA->getInnerVolume()) {
         return -1;
-      }
-      else {
+        }
+        else {
         return 0;
-      }
+        }
     }
 
-  }
+    }

Braces +2 added lines, -4 removed lines

@@ -20,11 +20,9 @@
     public function compare($aBoxA, $aBoxB) {
       if ($aBoxB->getInnerVolume() > $aBoxA->getInnerVolume()) {
         return 1;
-      }
-      else if ($aBoxB->getInnerVolume() < $aBoxA->getInnerVolume()) {
+      } else if ($aBoxB->getInnerVolume() < $aBoxA->getInnerVolume()) {
         return -1;
-      }
-      else {
+      } else {
         return 0;
       }
     }

PackedBoxList.php

Indentation +45 added lines, -45 removed lines

@@ -1,17 +1,17 @@ 
 <?php
 /**
- * Box packing (3D bin packing, knapsack problem)
- * @package BoxPacker
- * @author Doug Wright
- */
-  namespace DVDoug\BoxPacker;
-
-  /**
-   * List of possible packed box choices, ordered by utilisation (item count, volume)
-   * @author Doug Wright
-   * @package BoxPacker
-   */
-  class PackedBoxList extends \SplMinHeap {
+     * Box packing (3D bin packing, knapsack problem)
+     * @package BoxPacker
+     * @author Doug Wright
+     */
+    namespace DVDoug\BoxPacker;
+
+    /**
+     * List of possible packed box choices, ordered by utilisation (item count, volume)
+     * @author Doug Wright
+     * @package BoxPacker
+     */
+    class PackedBoxList extends \SplMinHeap {
 
     /**
      * Average (mean) weight of boxes
@@ -30,14 +30,14 @@ 
      * @see \SplMinHeap::compare()
      */
     public function compare($aBoxA, $aBoxB) {
-      $choice = $aBoxA->getItems()->count() - $aBoxB->getItems()->count();
-      if ($choice === 0) {
+        $choice = $aBoxA->getItems()->count() - $aBoxB->getItems()->count();
+        if ($choice === 0) {
         $choice = $aBoxB->getBox()->getInnerVolume() - $aBoxA->getBox()->getInnerVolume();
-      }
-      if ($choice === 0) {
+        }
+        if ($choice === 0) {
         $choice = $aBoxA->getWeight() - $aBoxB->getWeight();
-      }
-      return $choice;
+        }
+        return $choice;
     }
 
     /**
@@ -45,14 +45,14 @@ 
      * @return int
      */
     public function reverseCompare($aBoxA, $aBoxB) {
-      $choice = $aBoxB->getItems()->count() - $aBoxA->getItems()->count();
-      if ($choice === 0) {
+        $choice = $aBoxB->getItems()->count() - $aBoxA->getItems()->count();
+        if ($choice === 0) {
         $choice = $aBoxA->getBox()->getInnerVolume() - $aBoxB->getBox()->getInnerVolume();
-      }
-      if ($choice === 0) {
+        }
+        if ($choice === 0) {
         $choice = $aBoxB->getWeight() - $aBoxA->getWeight();
-      }
-      return $choice;
+        }
+        return $choice;
     }
 
     /**
@@ -61,15 +61,15 @@ 
      */
     public function getMeanWeight() {
 
-      if (!is_null($this->meanWeight)) {
+        if (!is_null($this->meanWeight)) {
         return $this->meanWeight;
-      }
+        }
 
-      foreach (clone $this as $box) {
+        foreach (clone $this as $box) {
         $this->meanWeight += $box->getWeight();
-      }
+        }
 
-      return $this->meanWeight /= $this->count();
+        return $this->meanWeight /= $this->count();
 
     }
 
@@ -79,17 +79,17 @@ 
      */
     public function getWeightVariance() {
 
-      if (!is_null($this->weightVariance)) {
+        if (!is_null($this->weightVariance)) {
         return $this->weightVariance;
-      }
+        }
 
-      $mean = $this->getMeanWeight();
+        $mean = $this->getMeanWeight();
 
-      foreach (clone $this as $box) {
+        foreach (clone $this as $box) {
         $this->weightVariance += pow($box->getWeight() - $mean, 2);
-      }
+        }
 
-      return $this->weightVariance /= $this->count();
+        return $this->weightVariance /= $this->count();
 
     }
 
@@ -98,20 +98,20 @@ 
      * @return float
      */
     public function getVolumeUtilisation() {
-      $itemVolume = 0;
-      $boxVolume = 0;
+        $itemVolume = 0;
+        $boxVolume = 0;
 
-      /** @var PackedBox $box */
-      foreach (clone $this as $box) {
+        /** @var PackedBox $box */
+        foreach (clone $this as $box) {
         $boxVolume += $box->getBox()->getInnerVolume();
 
         /** @var Item $item */
         foreach (clone $box->getItems() as $item ) {
-          $itemVolume += $item->getVolume();
+            $itemVolume += $item->getVolume();
+        }
         }
-      }
 
-      return round($itemVolume / $boxVolume * 100, 1);
+        return round($itemVolume / $boxVolume * 100, 1);
     }
 
     /**
@@ -119,9 +119,9 @@ 
      * @param array $aBoxes
      */
     public function insertFromArray(array $aBoxes) {
-      foreach ($aBoxes as $box) {
+        foreach ($aBoxes as $box) {
         $this->insert($box);
-      }
+        }
     }
 
-  }
+    }

Spacing +1 added lines, -1 removed lines

@@ -106,7 +106,7 @@
         $boxVolume += $box->getBox()->getInnerVolume();
 
         /** @var Item $item */
-        foreach (clone $box->getItems() as $item ) {
+        foreach (clone $box->getItems() as $item) {
           $itemVolume += $item->getVolume();
         }
       }

Box.php

Indentation +12 added lines, -12 removed lines

@@ -1,17 +1,17 @@ 
 <?php
 /**
- * Box packing (3D bin packing, knapsack problem)
- * @package BoxPacker
- * @author Doug Wright
- */
-  namespace DVDoug\BoxPacker;
+     * Box packing (3D bin packing, knapsack problem)
+     * @package BoxPacker
+     * @author Doug Wright
+     */
+    namespace DVDoug\BoxPacker;
 
-  /**
-   * A "box" (or envelope?) to pack items into
-   * @author Doug Wright
-   * @package BoxPacker
-   */
-  interface Box {
+    /**
+     * A "box" (or envelope?) to pack items into
+     * @author Doug Wright
+     * @package BoxPacker
+     */
+    interface Box {
 
     /**
      * Reference for box type (e.g. SKU or description)
@@ -73,4 +73,4 @@ 
      */
     public function getMaxWeight();
 
-  }
+    }

Item.php

Indentation +12 added lines, -12 removed lines

@@ -1,17 +1,17 @@ 
 <?php
 /**
- * Box packing (3D bin packing, knapsack problem)
- * @package BoxPacker
- * @author Doug Wright
- */
-  namespace DVDoug\BoxPacker;
+     * Box packing (3D bin packing, knapsack problem)
+     * @package BoxPacker
+     * @author Doug Wright
+     */
+    namespace DVDoug\BoxPacker;
 
-  /**
-   * An item to be packed
-   * @author Doug Wright
-   * @package BoxPacker
-   */
-  interface Item {
+    /**
+     * An item to be packed
+     * @author Doug Wright
+     * @package BoxPacker
+     */
+    interface Item {
 
     /**
      * Item SKU etc
@@ -49,4 +49,4 @@ 
      */
     public function getVolume();
 
-  }
+    }

Packer.php

Indentation +128 added lines, -128 removed lines

@@ -1,22 +1,22 @@ 
 <?php
 /**
- * Box packing (3D bin packing, knapsack problem)
- * @package BoxPacker
- * @author Doug Wright
- */
-  namespace DVDoug\BoxPacker;
-
-  use Psr\Log\LoggerAwareInterface;
-  use Psr\Log\LoggerAwareTrait;
-  use Psr\Log\LogLevel;
-  use Psr\Log\NullLogger;
-
-  /**
-   * Actual packer
-   * @author Doug Wright
-   * @package BoxPacker
-   */
-  class Packer implements LoggerAwareInterface {
+     * Box packing (3D bin packing, knapsack problem)
+     * @package BoxPacker
+     * @author Doug Wright
+     */
+    namespace DVDoug\BoxPacker;
+
+    use Psr\Log\LoggerAwareInterface;
+    use Psr\Log\LoggerAwareTrait;
+    use Psr\Log\LogLevel;
+    use Psr\Log\NullLogger;
+
+    /**
+     * Actual packer
+     * @author Doug Wright
+     * @package BoxPacker
+     */
+    class Packer implements LoggerAwareInterface {
     use LoggerAwareTrait;
 
     /**
@@ -35,10 +35,10 @@ 
      * Constructor
      */
     public function __construct() {
-      $this->items = new ItemList();
-      $this->boxes = new BoxList();
+        $this->items = new ItemList();
+        $this->boxes = new BoxList();
 
-      $this->logger = new NullLogger();
+        $this->logger = new NullLogger();
     }
 
     /**
@@ -47,10 +47,10 @@ 
      * @param int  $aQty
      */
     public function addItem(Item $aItem, $aQty = 1) {
-      for ($i = 0; $i < $aQty; $i++) {
+        for ($i = 0; $i < $aQty; $i++) {
         $this->items->insert($aItem);
-      }
-      $this->logger->log(LogLevel::INFO, "added {$aQty} x {$aItem->getDescription()}");
+        }
+        $this->logger->log(LogLevel::INFO, "added {$aQty} x {$aItem->getDescription()}");
     }
 
     /**
@@ -58,18 +58,18 @@ 
      * @param \Traversable $aItems
      */
     public function setItems($aItems) {
-      if ($aItems instanceof ItemList) {
+        if ($aItems instanceof ItemList) {
         $this->items = clone $aItems;
-      }
-      else if (is_array($aItems)) {
+        }
+        else if (is_array($aItems)) {
         $this->items = new ItemList();
         foreach ($aItems as $item) {
-          $this->items->insert($item);
+            $this->items->insert($item);
         }
-      }
-      else {
+        }
+        else {
         throw new \RuntimeException('Not a valid list of items');
-      }
+        }
     }
 
     /**
@@ -77,8 +77,8 @@ 
      * @param Box $aBox
      */
     public function addBox(Box $aBox) {
-      $this->boxes->insert($aBox);
-      $this->logger->log(LogLevel::INFO, "added box {$aBox->getReference()}");
+        $this->boxes->insert($aBox);
+        $this->logger->log(LogLevel::INFO, "added box {$aBox->getReference()}");
     }
 
     /**
@@ -86,7 +86,7 @@ 
      * @param BoxList $aBoxList
      */
     public function setBoxes(BoxList $aBoxList) {
-      $this->boxes = clone $aBoxList;
+        $this->boxes = clone $aBoxList;
     }
 
     /**
@@ -96,15 +96,15 @@ 
      * @return PackedBoxList
      */
     public function pack() {
-      $packedBoxes = $this->doVolumePacking();
+        $packedBoxes = $this->doVolumePacking();
 
-      //If we have multiple boxes, try and optimise/even-out weight distribution
-      if ($packedBoxes->count() > 1) {
+        //If we have multiple boxes, try and optimise/even-out weight distribution
+        if ($packedBoxes->count() > 1) {
         $packedBoxes = $this->redistributeWeight($packedBoxes);
-      }
+        }
 
-      $this->logger->log(LogLevel::INFO, "packing completed, {$packedBoxes->count()} boxes");
-      return $packedBoxes;
+        $this->logger->log(LogLevel::INFO, "packing completed, {$packedBoxes->count()} boxes");
+        return $packedBoxes;
     }
 
     /**
@@ -115,53 +115,53 @@ 
      */
     public function doVolumePacking() {
 
-      $packedBoxes = new PackedBoxList;
+        $packedBoxes = new PackedBoxList;
 
-      //Keep going until everything packed
-      while ($this->items->count()) {
+        //Keep going until everything packed
+        while ($this->items->count()) {
         $boxesToEvaluate = clone $this->boxes;
         $packedBoxesIteration = new PackedBoxList;
 
         //Loop through boxes starting with smallest, see what happens
         while (!$boxesToEvaluate->isEmpty()) {
-          $box = $boxesToEvaluate->extract();
-          $packedBox = $this->packIntoBox($box, clone $this->items);
-          if ($packedBox->getItems()->count()) {
+            $box = $boxesToEvaluate->extract();
+            $packedBox = $this->packIntoBox($box, clone $this->items);
+            if ($packedBox->getItems()->count()) {
             $packedBoxesIteration->insert($packedBox);
 
             //Have we found a single box that contains everything?
             if ($packedBox->getItems()->count() === $this->items->count()) {
-              break;
+                break;
+            }
             }
-          }
         }
 
         //Check iteration was productive
         if ($packedBoxesIteration->isEmpty()) {
-          throw new \RuntimeException('Item ' . $this->items->top()->getDescription() . ' is too large to fit into any box');
+            throw new \RuntimeException('Item ' . $this->items->top()->getDescription() . ' is too large to fit into any box');
         }
 
         //Find best box of iteration, and remove packed items from unpacked list
         $bestBox = $packedBoxesIteration->top();
         $unPackedItems = $this->items->asArray();
         foreach(clone $bestBox->getItems() as $packedItem) {
-          foreach ($unPackedItems as $unpackedKey => $unpackedItem) {
+            foreach ($unPackedItems as $unpackedKey => $unpackedItem) {
             if ($packedItem === $unpackedItem) {
-              unset($unPackedItems[$unpackedKey]);
-              break;
+                unset($unPackedItems[$unpackedKey]);
+                break;
+            }
             }
-          }
         }
         $unpackedItemList = new ItemList();
         foreach ($unPackedItems as $unpackedItem) {
-          $unpackedItemList->insert($unpackedItem);
+            $unpackedItemList->insert($unpackedItem);
         }
         $this->items = $unpackedItemList;
         $packedBoxes->insert($bestBox);
 
-      }
+        }
 
-      return $packedBoxes;
+        return $packedBoxes;
     }
 
     /**
@@ -172,54 +172,54 @@ 
      */
     public function redistributeWeight(PackedBoxList $aPackedBoxes) {
 
-      $targetWeight = $aPackedBoxes->getMeanWeight();
-      $this->logger->log(LogLevel::DEBUG,  "repacking for weight distribution, weight variance {$aPackedBoxes->getWeightVariance()}, target weight {$targetWeight}");
+        $targetWeight = $aPackedBoxes->getMeanWeight();
+        $this->logger->log(LogLevel::DEBUG,  "repacking for weight distribution, weight variance {$aPackedBoxes->getWeightVariance()}, target weight {$targetWeight}");
 
-      $packedBoxes = new PackedBoxList;
+        $packedBoxes = new PackedBoxList;
 
-      $overWeightBoxes = [];
-      $underWeightBoxes = [];
-      foreach (clone $aPackedBoxes as $packedBox) {
+        $overWeightBoxes = [];
+        $underWeightBoxes = [];
+        foreach (clone $aPackedBoxes as $packedBox) {
         $boxWeight = $packedBox->getWeight();
         if ($boxWeight > $targetWeight) {
-          $overWeightBoxes[] = $packedBox;
+            $overWeightBoxes[] = $packedBox;
         }
         else if ($boxWeight < $targetWeight) {
-          $underWeightBoxes[] = $packedBox;
+            $underWeightBoxes[] = $packedBox;
         }
         else {
-          $packedBoxes->insert($packedBox); //target weight, so we'll keep these
+            $packedBoxes->insert($packedBox); //target weight, so we'll keep these
+        }
         }
-      }
 
-      do { //Keep moving items from most overweight box to most underweight box
+        do { //Keep moving items from most overweight box to most underweight box
         $tryRepack = false;
         $this->logger->log(LogLevel::DEBUG,  'boxes under/over target: ' . count($underWeightBoxes) . '/' . count($overWeightBoxes));
 
         foreach ($underWeightBoxes as $u => $underWeightBox) {
-          $this->logger->log(LogLevel::DEBUG,  'Underweight Box ' . $u);
-          foreach ($overWeightBoxes as $o => $overWeightBox) {
+            $this->logger->log(LogLevel::DEBUG,  'Underweight Box ' . $u);
+            foreach ($overWeightBoxes as $o => $overWeightBox) {
             $this->logger->log(LogLevel::DEBUG,  'Overweight Box ' . $o);
             $overWeightBoxItems = $overWeightBox->getItems()->asArray();
 
             //For each item in the heavier box, try and move it to the lighter one
             foreach ($overWeightBoxItems as $oi => $overWeightBoxItem) {
-              $this->logger->log(LogLevel::DEBUG,  'Overweight Item ' . $oi);
-              if ($underWeightBox->getWeight() + $overWeightBoxItem->getWeight() > $targetWeight) {
+                $this->logger->log(LogLevel::DEBUG,  'Overweight Item ' . $oi);
+                if ($underWeightBox->getWeight() + $overWeightBoxItem->getWeight() > $targetWeight) {
                 $this->logger->log(LogLevel::DEBUG,  'Skipping item for hindering weight distribution');
                 continue; //skip if moving this item would hinder rather than help weight distribution
-              }
+                }
 
-              $newItemsForLighterBox = clone $underWeightBox->getItems();
-              $newItemsForLighterBox->insert($overWeightBoxItem);
+                $newItemsForLighterBox = clone $underWeightBox->getItems();
+                $newItemsForLighterBox->insert($overWeightBoxItem);
 
-              $newLighterBoxPacker = new Packer(); //we may need a bigger box
-              $newLighterBoxPacker->setBoxes($this->boxes);
-              $newLighterBoxPacker->setItems($newItemsForLighterBox);
-              $this->logger->log(LogLevel::INFO,  "[ATTEMPTING TO PACK LIGHTER BOX]");
-              $newLighterBox = $newLighterBoxPacker->doVolumePacking()->extract();
+                $newLighterBoxPacker = new Packer(); //we may need a bigger box
+                $newLighterBoxPacker->setBoxes($this->boxes);
+                $newLighterBoxPacker->setItems($newItemsForLighterBox);
+                $this->logger->log(LogLevel::INFO,  "[ATTEMPTING TO PACK LIGHTER BOX]");
+                $newLighterBox = $newLighterBoxPacker->doVolumePacking()->extract();
 
-              if ($newLighterBox->getItems()->count() === $newItemsForLighterBox->count()) { //new item fits
+                if ($newLighterBox->getItems()->count() === $newItemsForLighterBox->count()) { //new item fits
                 $this->logger->log(LogLevel::DEBUG,  'New item fits');
                 unset($overWeightBoxItems[$oi]); //now packed in different box
 
@@ -230,8 +230,8 @@ 
                 $this->logger->log(LogLevel::INFO,  "[ATTEMPTING TO PACK HEAVIER BOX]");
                 $newHeavierBoxes = $newHeavierBoxPacker->doVolumePacking();
                 if (count($newHeavierBoxes) > 1) { //found an edge case in packing algorithm that *increased* box count
-                  $this->logger->log(LogLevel::INFO,  "[REDISTRIBUTING WEIGHT] Abandoning redistribution, because new packing is less efficient than original");
-                  return $aPackedBoxes;
+                    $this->logger->log(LogLevel::INFO,  "[REDISTRIBUTING WEIGHT] Abandoning redistribution, because new packing is less efficient than original");
+                    return $aPackedBoxes;
                 }
 
                 $overWeightBoxes[$o] = $newHeavierBoxes->extract();
@@ -241,17 +241,17 @@ 
                 usort($overWeightBoxes, [$packedBoxes, 'reverseCompare']);
                 usort($underWeightBoxes, [$packedBoxes, 'reverseCompare']);
                 break 3;
-              }
+                }
+            }
             }
-          }
         }
-      } while ($tryRepack);
+        } while ($tryRepack);
 
-      //Combine back into a single list
-      $packedBoxes->insertFromArray($overWeightBoxes);
-      $packedBoxes->insertFromArray($underWeightBoxes);
+        //Combine back into a single list
+        $packedBoxes->insertFromArray($overWeightBoxes);
+        $packedBoxes->insertFromArray($underWeightBoxes);
 
-      return $packedBoxes;
+        return $packedBoxes;
     }
 
 
@@ -262,22 +262,22 @@ 
      * @return PackedBox packed box
      */
     public function packIntoBox(Box $aBox, ItemList $aItems) {
-      $this->logger->log(LogLevel::DEBUG,  "[EVALUATING BOX] {$aBox->getReference()}");
+        $this->logger->log(LogLevel::DEBUG,  "[EVALUATING BOX] {$aBox->getReference()}");
 
-      $packedItems = new ItemList;
-      $remainingDepth = $aBox->getInnerDepth();
-      $remainingWeight = $aBox->getMaxWeight() - $aBox->getEmptyWeight();
-      $remainingWidth = $aBox->getInnerWidth();
-      $remainingLength = $aBox->getInnerLength();
+        $packedItems = new ItemList;
+        $remainingDepth = $aBox->getInnerDepth();
+        $remainingWeight = $aBox->getMaxWeight() - $aBox->getEmptyWeight();
+        $remainingWidth = $aBox->getInnerWidth();
+        $remainingLength = $aBox->getInnerLength();
 
-      $layerWidth = $layerLength = $layerDepth = 0;
-      while(!$aItems->isEmpty()) {
+        $layerWidth = $layerLength = $layerDepth = 0;
+        while(!$aItems->isEmpty()) {
 
         $itemToPack = $aItems->top();
 
         if ($itemToPack->getDepth() > $remainingDepth || $itemToPack->getWeight() > $remainingWeight) {
-          $aItems->extract();
-          continue;
+            $aItems->extract();
+            continue;
         }
 
         $this->logger->log(LogLevel::DEBUG,  "evaluating item {$itemToPack->getDescription()}");
@@ -292,67 +292,67 @@ 
 
         if ($fitsSameGap >= 0 || $fitsRotatedGap >= 0) {
 
-          $packedItems->insert($aItems->extract());
-          $remainingWeight -= $itemToPack->getWeight();
+            $packedItems->insert($aItems->extract());
+            $remainingWeight -= $itemToPack->getWeight();
 
-          if ($fitsRotatedGap < 0 ||
+            if ($fitsRotatedGap < 0 ||
               ($fitsSameGap >= 0 && $fitsSameGap <= $fitsRotatedGap) ||
               ($itemWidth <= $remainingWidth && !$aItems->isEmpty() && $aItems->top() == $itemToPack && $remainingLength >= 2 * $itemLength)) {
             $this->logger->log(LogLevel::DEBUG,  "fits (better) unrotated");
             $remainingLength -= $itemLength;
             $layerLength += $itemLength;
             $layerWidth = max($itemWidth, $layerWidth);
-          }
-          else {
+            }
+            else {
             $this->logger->log(LogLevel::DEBUG,  "fits (better) rotated");
             $remainingLength -= $itemWidth;
             $layerLength += $itemWidth;
             $layerWidth = max($itemLength, $layerWidth);
-          }
-          $layerDepth = max($layerDepth, $itemToPack->getDepth()); //greater than 0, items will always be less deep
+            }
+            $layerDepth = max($layerDepth, $itemToPack->getDepth()); //greater than 0, items will always be less deep
 
-          //allow items to be stacked in place within the same footprint up to current layerdepth
-          $maxStackDepth = $layerDepth - $itemToPack->getDepth();
-          while(!$aItems->isEmpty()) {
+            //allow items to be stacked in place within the same footprint up to current layerdepth
+            $maxStackDepth = $layerDepth - $itemToPack->getDepth();
+            while(!$aItems->isEmpty()) {
             $potentialStackItem = $aItems->top();
             if ($potentialStackItem->getDepth() <= $maxStackDepth &&
                 $potentialStackItem->getWeight() <= $remainingWeight &&
                 $potentialStackItem->getWidth() <= $itemToPack->getWidth() &&
                 $potentialStackItem->getLength() <= $itemToPack->getLength()) {
-              $remainingWeight -= $potentialStackItem->getWeight();
-              $maxStackDepth -= $potentialStackItem->getDepth();
-              $packedItems->insert($aItems->extract());
+                $remainingWeight -= $potentialStackItem->getWeight();
+                $maxStackDepth -= $potentialStackItem->getDepth();
+                $packedItems->insert($aItems->extract());
             }
             else {
-              break;
+                break;
+            }
             }
-          }
         }
         else {
-          if ($remainingWidth >= min($itemWidth, $itemLength) && $layerDepth > 0 && $layerWidth > 0 && $layerLength > 0) {
+            if ($remainingWidth >= min($itemWidth, $itemLength) && $layerDepth > 0 && $layerWidth > 0 && $layerLength > 0) {
             $this->logger->log(LogLevel::DEBUG,  "No more fit in lengthwise, resetting for new row");
             $remainingLength += $layerLength;
             $remainingWidth -= $layerWidth;
             $layerWidth = $layerLength = 0;
             continue;
-          }
+            }
 
-          if ($remainingLength < min($itemWidth, $itemLength) || $layerDepth == 0) {
+            if ($remainingLength < min($itemWidth, $itemLength) || $layerDepth == 0) {
             $this->logger->log(LogLevel::DEBUG,  "doesn't fit on layer even when empty");
             $aItems->extract();
             continue;
-          }
+            }
 
-          $remainingWidth = $layerWidth ? min(floor($layerWidth * 1.1), $aBox->getInnerWidth()) : $aBox->getInnerWidth();
-          $remainingLength = $layerLength ? min(floor($layerLength * 1.1), $aBox->getInnerLength()) : $aBox->getInnerLength();
-          $remainingDepth -= $layerDepth;
+            $remainingWidth = $layerWidth ? min(floor($layerWidth * 1.1), $aBox->getInnerWidth()) : $aBox->getInnerWidth();
+            $remainingLength = $layerLength ? min(floor($layerLength * 1.1), $aBox->getInnerLength()) : $aBox->getInnerLength();
+            $remainingDepth -= $layerDepth;
 
-          $layerWidth = $layerLength = $layerDepth = 0;
-          $this->logger->log(LogLevel::DEBUG,  "doesn't fit, so starting next vertical layer");
+            $layerWidth = $layerLength = $layerDepth = 0;
+            $this->logger->log(LogLevel::DEBUG,  "doesn't fit, so starting next vertical layer");
+        }
         }
-      }
-      $this->logger->log(LogLevel::DEBUG,  "done with this box");
-      return new PackedBox($aBox, $packedItems, $remainingWidth, $remainingLength, $remainingDepth, $remainingWeight);
+        $this->logger->log(LogLevel::DEBUG,  "done with this box");
+        return new PackedBox($aBox, $packedItems, $remainingWidth, $remainingLength, $remainingDepth, $remainingWeight);
     }
 
     /**
@@ -363,7 +363,7 @@ 
      * @return ItemList items packed into box
      */
     public function packBox(Box $aBox, ItemList $aItems) {
-      $packedBox = $this->packIntoBox($aBox, $aItems);
-      return $packedBox->getItems();
+        $packedBox = $this->packIntoBox($aBox, $aItems);
+        return $packedBox->getItems();
+    }
     }
-  }

Spacing +23 added lines, -23 removed lines

@@ -144,7 +144,7 @@ 
         //Find best box of iteration, and remove packed items from unpacked list
         $bestBox = $packedBoxesIteration->top();
         $unPackedItems = $this->items->asArray();
-        foreach(clone $bestBox->getItems() as $packedItem) {
+        foreach (clone $bestBox->getItems() as $packedItem) {
           foreach ($unPackedItems as $unpackedKey => $unpackedItem) {
             if ($packedItem === $unpackedItem) {
               unset($unPackedItems[$unpackedKey]);
@@ -173,7 +173,7 @@ 
     public function redistributeWeight(PackedBoxList $aPackedBoxes) {
 
       $targetWeight = $aPackedBoxes->getMeanWeight();
-      $this->logger->log(LogLevel::DEBUG,  "repacking for weight distribution, weight variance {$aPackedBoxes->getWeightVariance()}, target weight {$targetWeight}");
+      $this->logger->log(LogLevel::DEBUG, "repacking for weight distribution, weight variance {$aPackedBoxes->getWeightVariance()}, target weight {$targetWeight}");
 
       $packedBoxes = new PackedBoxList;
 
@@ -194,19 +194,19 @@ 
 
       do { //Keep moving items from most overweight box to most underweight box
         $tryRepack = false;
-        $this->logger->log(LogLevel::DEBUG,  'boxes under/over target: ' . count($underWeightBoxes) . '/' . count($overWeightBoxes));
+        $this->logger->log(LogLevel::DEBUG, 'boxes under/over target: ' . count($underWeightBoxes) . '/' . count($overWeightBoxes));
 
         foreach ($underWeightBoxes as $u => $underWeightBox) {
-          $this->logger->log(LogLevel::DEBUG,  'Underweight Box ' . $u);
+          $this->logger->log(LogLevel::DEBUG, 'Underweight Box ' . $u);
           foreach ($overWeightBoxes as $o => $overWeightBox) {
-            $this->logger->log(LogLevel::DEBUG,  'Overweight Box ' . $o);
+            $this->logger->log(LogLevel::DEBUG, 'Overweight Box ' . $o);
             $overWeightBoxItems = $overWeightBox->getItems()->asArray();
 
             //For each item in the heavier box, try and move it to the lighter one
             foreach ($overWeightBoxItems as $oi => $overWeightBoxItem) {
-              $this->logger->log(LogLevel::DEBUG,  'Overweight Item ' . $oi);
+              $this->logger->log(LogLevel::DEBUG, 'Overweight Item ' . $oi);
               if ($underWeightBox->getWeight() + $overWeightBoxItem->getWeight() > $targetWeight) {
-                $this->logger->log(LogLevel::DEBUG,  'Skipping item for hindering weight distribution');
+                $this->logger->log(LogLevel::DEBUG, 'Skipping item for hindering weight distribution');
                 continue; //skip if moving this item would hinder rather than help weight distribution
               }
 
@@ -216,21 +216,21 @@ 
               $newLighterBoxPacker = new Packer(); //we may need a bigger box
               $newLighterBoxPacker->setBoxes($this->boxes);
               $newLighterBoxPacker->setItems($newItemsForLighterBox);
-              $this->logger->log(LogLevel::INFO,  "[ATTEMPTING TO PACK LIGHTER BOX]");
+              $this->logger->log(LogLevel::INFO, "[ATTEMPTING TO PACK LIGHTER BOX]");
               $newLighterBox = $newLighterBoxPacker->doVolumePacking()->extract();
 
               if ($newLighterBox->getItems()->count() === $newItemsForLighterBox->count()) { //new item fits
-                $this->logger->log(LogLevel::DEBUG,  'New item fits');
+                $this->logger->log(LogLevel::DEBUG, 'New item fits');
                 unset($overWeightBoxItems[$oi]); //now packed in different box
 
                 $newHeavierBoxPacker = new Packer(); //we may be able to use a smaller box
                 $newHeavierBoxPacker->setBoxes($this->boxes);
                 $newHeavierBoxPacker->setItems($overWeightBoxItems);
 
-                $this->logger->log(LogLevel::INFO,  "[ATTEMPTING TO PACK HEAVIER BOX]");
+                $this->logger->log(LogLevel::INFO, "[ATTEMPTING TO PACK HEAVIER BOX]");
                 $newHeavierBoxes = $newHeavierBoxPacker->doVolumePacking();
                 if (count($newHeavierBoxes) > 1) { //found an edge case in packing algorithm that *increased* box count
-                  $this->logger->log(LogLevel::INFO,  "[REDISTRIBUTING WEIGHT] Abandoning redistribution, because new packing is less efficient than original");
+                  $this->logger->log(LogLevel::INFO, "[REDISTRIBUTING WEIGHT] Abandoning redistribution, because new packing is less efficient than original");
                   return $aPackedBoxes;
                 }
 
@@ -262,7 +262,7 @@ 
      * @return PackedBox packed box
      */
     public function packIntoBox(Box $aBox, ItemList $aItems) {
-      $this->logger->log(LogLevel::DEBUG,  "[EVALUATING BOX] {$aBox->getReference()}");
+      $this->logger->log(LogLevel::DEBUG, "[EVALUATING BOX] {$aBox->getReference()}");
 
       $packedItems = new ItemList;
       $remainingDepth = $aBox->getInnerDepth();
@@ -271,7 +271,7 @@ 
       $remainingLength = $aBox->getInnerLength();
 
       $layerWidth = $layerLength = $layerDepth = 0;
-      while(!$aItems->isEmpty()) {
+      while (!$aItems->isEmpty()) {
 
         $itemToPack = $aItems->top();
 
@@ -280,9 +280,9 @@ 
           continue;
         }
 
-        $this->logger->log(LogLevel::DEBUG,  "evaluating item {$itemToPack->getDescription()}");
-        $this->logger->log(LogLevel::DEBUG,  "remaining width: {$remainingWidth}, length: {$remainingLength}, depth: {$remainingDepth}");
-        $this->logger->log(LogLevel::DEBUG,  "layerWidth: {$layerWidth}, layerLength: {$layerLength}, layerDepth: {$layerDepth}");
+        $this->logger->log(LogLevel::DEBUG, "evaluating item {$itemToPack->getDescription()}");
+        $this->logger->log(LogLevel::DEBUG, "remaining width: {$remainingWidth}, length: {$remainingLength}, depth: {$remainingDepth}");
+        $this->logger->log(LogLevel::DEBUG, "layerWidth: {$layerWidth}, layerLength: {$layerLength}, layerDepth: {$layerDepth}");
 
         $itemWidth = $itemToPack->getWidth();
         $itemLength = $itemToPack->getLength();
@@ -298,13 +298,13 @@ 
           if ($fitsRotatedGap < 0 ||
               ($fitsSameGap >= 0 && $fitsSameGap <= $fitsRotatedGap) ||
               ($itemWidth <= $remainingWidth && !$aItems->isEmpty() && $aItems->top() == $itemToPack && $remainingLength >= 2 * $itemLength)) {
-            $this->logger->log(LogLevel::DEBUG,  "fits (better) unrotated");
+            $this->logger->log(LogLevel::DEBUG, "fits (better) unrotated");
             $remainingLength -= $itemLength;
             $layerLength += $itemLength;
             $layerWidth = max($itemWidth, $layerWidth);
           }
           else {
-            $this->logger->log(LogLevel::DEBUG,  "fits (better) rotated");
+            $this->logger->log(LogLevel::DEBUG, "fits (better) rotated");
             $remainingLength -= $itemWidth;
             $layerLength += $itemWidth;
             $layerWidth = max($itemLength, $layerWidth);
@@ -313,7 +313,7 @@ 
 
           //allow items to be stacked in place within the same footprint up to current layerdepth
           $maxStackDepth = $layerDepth - $itemToPack->getDepth();
-          while(!$aItems->isEmpty()) {
+          while (!$aItems->isEmpty()) {
             $potentialStackItem = $aItems->top();
             if ($potentialStackItem->getDepth() <= $maxStackDepth &&
                 $potentialStackItem->getWeight() <= $remainingWeight &&
@@ -330,7 +330,7 @@ 
         }
         else {
           if ($remainingWidth >= min($itemWidth, $itemLength) && $layerDepth > 0 && $layerWidth > 0 && $layerLength > 0) {
-            $this->logger->log(LogLevel::DEBUG,  "No more fit in lengthwise, resetting for new row");
+            $this->logger->log(LogLevel::DEBUG, "No more fit in lengthwise, resetting for new row");
             $remainingLength += $layerLength;
             $remainingWidth -= $layerWidth;
             $layerWidth = $layerLength = 0;
@@ -338,7 +338,7 @@ 
           }
 
           if ($remainingLength < min($itemWidth, $itemLength) || $layerDepth == 0) {
-            $this->logger->log(LogLevel::DEBUG,  "doesn't fit on layer even when empty");
+            $this->logger->log(LogLevel::DEBUG, "doesn't fit on layer even when empty");
             $aItems->extract();
             continue;
           }
@@ -348,10 +348,10 @@ 
           $remainingDepth -= $layerDepth;
 
           $layerWidth = $layerLength = $layerDepth = 0;
-          $this->logger->log(LogLevel::DEBUG,  "doesn't fit, so starting next vertical layer");
+          $this->logger->log(LogLevel::DEBUG, "doesn't fit, so starting next vertical layer");
         }
       }
-      $this->logger->log(LogLevel::DEBUG,  "done with this box");
+      $this->logger->log(LogLevel::DEBUG, "done with this box");
       return new PackedBox($aBox, $packedItems, $remainingWidth, $remainingLength, $remainingDepth, $remainingWeight);
     }
 

Braces +7 added lines, -14 removed lines

@@ -60,14 +60,12 @@ 
     public function setItems($aItems) {
       if ($aItems instanceof ItemList) {
         $this->items = clone $aItems;
-      }
-      else if (is_array($aItems)) {
+      } else if (is_array($aItems)) {
         $this->items = new ItemList();
         foreach ($aItems as $item) {
           $this->items->insert($item);
         }
-      }
-      else {
+      } else {
         throw new \RuntimeException('Not a valid list of items');
       }
     }
@@ -183,11 +181,9 @@ 
         $boxWeight = $packedBox->getWeight();
         if ($boxWeight > $targetWeight) {
           $overWeightBoxes[] = $packedBox;
-        }
-        else if ($boxWeight < $targetWeight) {
+        } else if ($boxWeight < $targetWeight) {
           $underWeightBoxes[] = $packedBox;
-        }
-        else {
+        } else {
           $packedBoxes->insert($packedBox); //target weight, so we'll keep these
         }
       }
@@ -302,8 +298,7 @@ 
             $remainingLength -= $itemLength;
             $layerLength += $itemLength;
             $layerWidth = max($itemWidth, $layerWidth);
-          }
-          else {
+          } else {
             $this->logger->log(LogLevel::DEBUG,  "fits (better) rotated");
             $remainingLength -= $itemWidth;
             $layerLength += $itemWidth;
@@ -322,13 +317,11 @@ 
               $remainingWeight -= $potentialStackItem->getWeight();
               $maxStackDepth -= $potentialStackItem->getDepth();
               $packedItems->insert($aItems->extract());
-            }
-            else {
+            } else {
               break;
             }
           }
-        }
-        else {
+        } else {
           if ($remainingWidth >= min($itemWidth, $itemLength) && $layerDepth > 0 && $layerWidth > 0 && $layerLength > 0) {
             $this->logger->log(LogLevel::DEBUG,  "No more fit in lengthwise, resetting for new row");
             $remainingLength += $layerLength;

ItemList.php

Indentation +22 added lines, -22 removed lines

@@ -1,32 +1,32 @@ 
 <?php
 /**
- * Box packing (3D bin packing, knapsack problem)
- * @package BoxPacker
- * @author Doug Wright
- */
-  namespace DVDoug\BoxPacker;
+     * Box packing (3D bin packing, knapsack problem)
+     * @package BoxPacker
+     * @author Doug Wright
+     */
+    namespace DVDoug\BoxPacker;
 
-  /**
-   * List of items to be packed, ordered by volume
-   * @author Doug Wright
-   * @package BoxPacker
-   */
-  class ItemList extends \SplMaxHeap {
+    /**
+     * List of items to be packed, ordered by volume
+     * @author Doug Wright
+     * @package BoxPacker
+     */
+    class ItemList extends \SplMaxHeap {
 
     /**
      * Compare elements in order to place them correctly in the heap while sifting up.
      * @see \SplMaxHeap::compare()
      */
     public function compare($aItemA, $aItemB) {
-      if ($aItemA->getVolume() > $aItemB->getVolume()) {
+        if ($aItemA->getVolume() > $aItemB->getVolume()) {
         return 1;
-      }
-      else if ($aItemA->getVolume() < $aItemB->getVolume()) {
+        }
+        else if ($aItemA->getVolume() < $aItemB->getVolume()) {
         return -1;
-      }
-      else {
+        }
+        else {
         return 0;
-      }
+        }
     }
 
     /**
@@ -34,11 +34,11 @@ 
      * @return array
      */
     public function asArray() {
-      $return = [];
-      foreach (clone $this as $item) {
+        $return = [];
+        foreach (clone $this as $item) {
         $return[] = $item;
-      }
-      return $return;
+        }
+        return $return;
     }
 
-  }
+    }

Braces +2 added lines, -4 removed lines

@@ -20,11 +20,9 @@
     public function compare($aItemA, $aItemB) {
       if ($aItemA->getVolume() > $aItemB->getVolume()) {
         return 1;
-      }
-      else if ($aItemA->getVolume() < $aItemB->getVolume()) {
+      } else if ($aItemA->getVolume() < $aItemB->getVolume()) {
         return -1;
-      }
-      else {
+      } else {
         return 0;
       }
     }

PackedBox.php

Indentation +36 added lines, -36 removed lines

@@ -1,17 +1,17 @@ 
 <?php
 /**
- * Box packing (3D bin packing, knapsack problem)
- * @package BoxPacker
- * @author Doug Wright
- */
-  namespace DVDoug\BoxPacker;
+     * Box packing (3D bin packing, knapsack problem)
+     * @package BoxPacker
+     * @author Doug Wright
+     */
+    namespace DVDoug\BoxPacker;
 
-  /**
-   * A "box" with items
-   * @author Doug Wright
-   * @package BoxPacker
-   */
-  class PackedBox {
+    /**
+     * A "box" with items
+     * @author Doug Wright
+     * @package BoxPacker
+     */
+    class PackedBox {
 
     /**
      * Box used
@@ -60,7 +60,7 @@ 
      * @return Box
      */
     public function getBox() {
-      return $this->box;
+        return $this->box;
     }
 
     /**
@@ -68,7 +68,7 @@ 
      * @return ItemList
      */
     public function getItems() {
-      return $this->items;
+        return $this->items;
     }
 
     /**
@@ -77,16 +77,16 @@ 
      */
     public function getWeight() {
 
-      if (!is_null($this->weight)) {
+        if (!is_null($this->weight)) {
         return $this->weight;
-      }
+        }
 
-      $this->weight = $this->box->getEmptyWeight();
-      $items = clone $this->items;
-      foreach ($items as $item) {
+        $this->weight = $this->box->getEmptyWeight();
+        $items = clone $this->items;
+        foreach ($items as $item) {
         $this->weight += $item->getWeight();
-      }
-      return $this->weight;
+        }
+        return $this->weight;
     }
 
     /**
@@ -94,7 +94,7 @@ 
      * @return int
      */
     public function getRemainingWidth() {
-      return $this->remainingWidth;
+        return $this->remainingWidth;
     }
 
     /**
@@ -102,7 +102,7 @@ 
      * @return int
      */
     public function getRemainingLength() {
-      return $this->remainingLength;
+        return $this->remainingLength;
     }
 
     /**
@@ -110,7 +110,7 @@ 
      * @return int
      */
     public function getRemainingDepth() {
-      return $this->remainingDepth;
+        return $this->remainingDepth;
     }
 
     /**
@@ -118,7 +118,7 @@ 
      * @return int
      */
     public function getRemainingWeight() {
-      return $this->remainingWeight;
+        return $this->remainingWeight;
     }
 
     /**
@@ -126,14 +126,14 @@ 
      * @return float
      */
     public function getVolumeUtilisation() {
-      $itemVolume = 0;
+        $itemVolume = 0;
 
-      /** @var Item $item */
-      foreach (clone $this->items as $item) {
+        /** @var Item $item */
+        foreach (clone $this->items as $item) {
         $itemVolume += $item->getVolume();
-      }
+        }
 
-      return round($itemVolume / $this->box->getInnerVolume() * 100, 1);
+        return round($itemVolume / $this->box->getInnerVolume() * 100, 1);
     }
 
 
@@ -148,12 +148,12 @@ 
      * @param int      $aRemainingWeight
      */
     public function __construct(Box $aBox, ItemList $aItemList, $aRemainingWidth, $aRemainingLength, $aRemainingDepth, $aRemainingWeight) {
-      $this->box = $aBox;
-      $this->items = $aItemList;
-      $this->remainingWidth = $aRemainingWidth;
-      $this->remainingLength = $aRemainingLength;
-      $this->remainingDepth = $aRemainingDepth;
-      $this->remainingWeight = $aRemainingWeight;
+        $this->box = $aBox;
+        $this->items = $aItemList;
+        $this->remainingWidth = $aRemainingWidth;
+        $this->remainingLength = $aRemainingLength;
+        $this->remainingDepth = $aRemainingDepth;
+        $this->remainingWeight = $aRemainingWeight;
     }
 
-  }
+    }