easy-box-packer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c160200ca99944f6560dca5948ce785bde238d87
+  data.tar.gz: 7d7cd114d8c6ebb74ad5fea4c5974210c2348143
+SHA512:
+  metadata.gz: 4351a0c2f6a572d90e803e2218bc25f9d9e1635ca6d94f1b699b86656bdb34f77ecce108e76b97eea4dbebba49ba03741c36d64a1da10e39dea9628a10a38e00
+  data.tar.gz: 66c2d2b3a04c2b8e0b1ac1347f8fde974051bf75d06b79f2fac54642a9f76845c8d0af56c7ea7137c22bc73834c3fd8ec0746cd8e09c8a99b24920a55b4a91a6

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2017 Aloha Chen
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,45 @@
+# EasyBoxPacker
+
+Ref from [box_packer](https://github.com/mushishi78/box_packer)
+
+and inspired by [A genetic algorithm for the three-dimensional bin packing problem with heterogeneous bins](https://www.researchgate.net/publication/273121476_A_genetic_algorithm_for_the_three-dimensional_bin_packing_problem_with_heterogeneous_bins) and [A New Heuristic Algorithm for the 3D Bin Packing Problem](https://www.researchgate.net/publication/226249396_A_New_Heuristic_Algorithm_for_the_3D_Bin_Packing_Problem)
+
+## Installation
+
+Add to gemfile:
+
+``` ruby
+gem  'easy-box-packer'
+```
+
+## Usage
+
+``` ruby
+require 'easy-box-packer'
+
+packings = BoxPacker.pack(
+  container: { dimensions: [15, 20, 13], weight_limit: 50 },
+  items: [
+    { dimensions: [2, 3, 5], weight: 47 },
+    { dimensions: [2, 3, 5], weight: 47 },
+    { dimensions: [3, 3, 1], weight: 24 },
+    { dimensions: [1, 1, 4], weight: 7 },
+  ]
+)
+
+packings.length # 3
+packings[0][:weight] # 47
+packings[0][:placements].length # 1
+packings[0][:placements][0][:dimensions] # [2, 3, 5]
+packings[0][:placements][0][:position] # [0, 0, 0]
+packings[1][:weight] # 47
+packings[1][:placements].length # 1
+packings[1][:placements][0][:dimensions] # [2, 3, 5]
+packings[1][:placements][0][:position] # [0, 0, 0]
+packings[2][:weight] # 31
+packings[2][:placements].length # 2
+packings[2][:placements][0][:dimensions] # [1, 3, 3]
+packings[2][:placements][0][:position] # [0, 0, 0]
+packings[2][:placements][1][:dimensions] # [4, 1, 1]
+packings[2][:placements][1][:position] # [3, 0, 0]
+```

data/easy-box-packer.rb

@@ -0,0 +1,143 @@
+module EasyBoxPacker
+  class << self
+    def pack(container:, items:)
+      packings = []
+      errors   = []
+      # pack from biggest to smallest
+      items.sort_by { |h| h[:dimensions].sort }.reverse.each do |item|
+        # If the item is just too big for the container lets give up on this
+        if item[:weight].to_f > container[:weight_limit].to_f
+          errors << "Item: #{item} is too heavy for container"
+          next
+        end
+
+        # Need a bool so we can break out nested loops once it's been packed
+        item_has_been_packed = false
+
+        packings.each do |packing|
+          # If this packings going to be too big with this
+          # item as well then skip on to the next packing
+          next if packing[:weight].to_f + item[:weight].to_f > container[:weight_limit].to_f
+
+          # try minimum space first
+          packing[:spaces].sort_by { |h| h[:dimensions].sort }.each do |space|
+            # Try placing the item in this space,
+            # if it doesn't fit skip on the next space
+            next unless placement = place(item, space)
+
+            # Add the item to the packing and
+            # break up the surrounding spaces
+            packing[:placements] += [placement]
+            packing[:weight] += item[:weight].to_f
+            packing[:spaces] -= [space]
+            packing[:spaces] += break_up_space(space, placement)
+            item_has_been_packed = true
+            break
+          end
+          break if item_has_been_packed
+        end
+        next if item_has_been_packed
+
+        # Can't fit in any of the spaces for the current packings
+        # so lets try a new space the size of the container
+        space = {
+          dimensions: container[:dimensions].sort.reverse,
+          position: [0, 0, 0]
+        }
+        placement = place(item, space)
+
+        # If it can't be placed in this space, then it's just
+        # too big for the container and we should abandon hope
+        unless placement
+          errors << "Item: #{item} cannot be placed in container"
+          next
+        end
+
+        # Otherwise lets put the item in a new packing
+        # and break up the remaing free space around it
+        packings += [{
+          placements: [placement],
+          weight: item[:weight].to_f,
+          spaces: break_up_space(space, placement)
+        }]
+      end
+
+      { packings: packings, errors: errors }
+    end
+
+    def place(item, space)
+      item_width, item_height, item_length = item[:dimensions].sort.reverse
+
+      permutations = [
+        [item_width, item_height, item_length],
+        [item_width, item_length, item_height],
+        [item_height, item_width, item_length],
+        [item_height, item_length, item_width],
+        [item_length, item_width, item_height],
+        [item_length, item_height, item_width]
+      ]
+
+      possible_rotations_and_margins = []
+
+      permutations.each do |perm|
+        # Skip if the item does not fit with this orientation
+        next unless perm[0] <= space[:dimensions][0] &&
+          perm[1] <= space[:dimensions][1] &&
+          perm[2] <= space[:dimensions][2]
+
+        possible_margin   = [space[:dimensions][0] - perm[0], space[:dimensions][1] - perm[1], space[:dimensions][2] - perm[2]]
+        possible_rotations_and_margins << { margin: possible_margin, rotation: perm }
+      end
+
+      # select rotation with smallest margin
+      final = possible_rotations_and_margins.sort_by { |a| a[:margin].sort }.first
+      return unless final
+      return {
+        dimensions: final[:rotation],
+        position: space[:position],
+        weight: item[:weight].to_f
+      }
+    end
+
+    def break_up_space(space, placement)
+      [
+        {
+          dimensions: [
+            space[:dimensions][0],
+            space[:dimensions][1],
+            space[:dimensions][2] - placement[:dimensions][2]
+          ],
+          position: [
+            space[:position][0],
+            space[:position][1],
+            space[:position][2] + placement[:dimensions][2]
+          ]
+        },
+        {
+          dimensions: [
+            space[:dimensions][0],
+            space[:dimensions][1] - placement[:dimensions][1],
+            placement[:dimensions][2]
+          ],
+          position: [
+            space[:position][0],
+            space[:position][1] + placement[:dimensions][1],
+            space[:position][2]
+          ]
+        },
+        {
+          dimensions: [
+            space[:dimensions][0] - placement[:dimensions][0],
+            placement[:dimensions][1],
+            placement[:dimensions][2]
+          ],
+          position: [
+            space[:position][0] + placement[:dimensions][0],
+            space[:position][1],
+            space[:position][2]
+          ]
+        }
+      ]
+    end
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: easy-box-packer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Aloha Chen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: y.alohac@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- easy-box-packer.rb
+homepage: https://github.com/alChaCC/easy-box-packer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- "."
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: 3D bin-packing with weight limit using first-fit decreasing algorithm and
+  empty maximal spaces
+test_files: []