box_packer 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NzdjZDhlOTBiNmZmYjI3Zjc2ZDA2MTE2YWVlNWJiYWE0NmIwMjExMg==
+  data.tar.gz: !binary |-
+    N2E1MDhjOTY1ZmQ5YjQ4M2M0MjUzMmY4ZTE4NzI5ZTNlOWEyYTY0OA==
+SHA512:
+  metadata.gz: !binary |-
+    ODMxODdhNTE5OWQ4ZTNkNzFkZGJlYzY2ODJlYzU3OWMyNDQzNTBmNDAzYTlm
+    MjJkMWZhOGVmMjkyM2MxNzc3ZDJhZGQzODJkNjFmMTVlMDc0ZTVkNjI2YjE1
+    YzYwMjZhY2FkMGQ0YTZlZDU5Y2ZiYmU3MzVmOGYxNmU2OTRhZGQ=
+  data.tar.gz: !binary |-
+    NmZkNTgzYzA3ZWYyZTI2YjdjMGJjZjhkM2Y0YTYyMmRmYmNkZjI4ZGUwNGE1
+    YTFmMzhhYjcwZTZjNTBlZDVlMWZmNzliOThlNGM2OTlhN2ZiZjU5MjU4ZWE1
+    NmMxNTM3NmVhNjIwYzQ4NzkyOWM5ZDczZTBmZWJlZmNmNTBiMjc=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in box_packer.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Max White
+
+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,44 @@
+BoxPacker
+=========
+
+A Heuristic First-Fit 3D Bin Packing Algorithm with Weight Limit. 
+
+Installation
+------------
+
+Add this line to your application's Gemfile:
+
+    gem 'box_packer'
+
+And then execute:
+
+    $ bundle
+
+Usage
+-----
+
+```Ruby
+container = BoxPacker::Container.new("MyContainer", [6, 3, 7], 50)
+
+container.items << BoxPacker::Item.new("MyItem01", [1, 5, 3], 10)
+container.items << BoxPacker::Item.new("MyItem02", [2, 5, 2], 13)
+container.items << BoxPacker::Item.new("MyItem03", [5, 5, 3], 36)
+
+container.pack          #=> 2
+puts container
+```
+
+``` console
+*** MyContainer - [3, 6, 7] V:126 WL:50 PL:3 ***
+
+MyItem01 - [1, 3, 5] V:15 W:10
+MyItem02 - [2, 2, 5] V:20 W:13
+MyItem03 - [3, 5, 5] V:75 W:36
+
+Packing 0 RW:1 RV:31
+MyItem03 - [3, 5, 5] Pos:[0, 0, 0] V:75 W:36
+MyItem02 - [2, 5, 2] Pos:[0, 0, 5] V:20 W:13
+
+Packing 1 RW:40 RV:111
+MyItem01 - [1, 3, 5] Pos:[0, 0, 0] V:15 W:10
+```

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/box_packer.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'box_packer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "box_packer"
+  spec.version       = BoxPacker::VERSION
+  spec.authors       = ["Max White"]
+  spec.email         = ["mushishi78@gmail.com"]
+  spec.description   = %q{A Heuristic First-Fit 3D Bin Packing Algorithm with Weight Limit}
+  spec.summary       = %q{A Heuristic First-Fit 3D Bin Packing Algorithm with Weight Limit}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/box_packer/version.rb

@@ -0,0 +1,3 @@
+module BoxPacker
+  VERSION = "0.0.1"
+end

data/lib/box_packer.rb

@@ -0,0 +1,196 @@
+require_relative "box_packer/version"
+require "matrix"
+require "forwardable"
+
+module BoxPacker
+  
+	class Box 	
+		attr_reader :volume
+		attr_accessor :dimensions, :position
+
+		def initialize(dimensions, position=[0,0,0])
+			@dimensions, @position = Vector.elements(dimensions), Vector.elements(position)
+			@volume = @dimensions.reduce(:*)
+		end
+
+		def fit?(box)
+			(0..2).all?{ |i| box.dimensions[i] <= @dimensions[i] }
+		end
+
+		def fit_with_rotation?(box)
+			rotations = [0,0,1]
+			rotations = rotations.permutation.to_a.uniq.permutation.to_a.reverse
+			original_orientation = box.dimensions
+
+			rotations.each do |rotation|
+				box.dimensions = Matrix.rows(rotation) * box.dimensions
+				return true if fit?(box)
+			end
+
+			box.dimensions = original_orientation
+			return false
+		end
+
+		def break_up_remaining_space(box)				
+			x_offset = Vector[box.position[0], 0, 0]
+
+			sub_box_x = Box.new((Matrix.diagonal(1,1,1) * @dimensions) +(Matrix.diagonal(-1,0,0) * box.dimensions), 
+				                (Matrix.diagonal(0,1,1) * @position) +(Matrix.diagonal(1,0,0) * box.dimensions) + x_offset)
+
+			sub_box_y = Box.new((Matrix.diagonal(0,1,1) * @dimensions) +(Matrix.diagonal(1,-1,0) * box.dimensions), 
+				                (Matrix.diagonal(0,1,1) * @position) +(Matrix.diagonal(0,1,0) * box.dimensions) + x_offset)
+
+			sub_box_z = Box.new((Matrix.diagonal(0,0,1) * @dimensions) +(Matrix.diagonal(1,1,-1) * box.dimensions), 
+				                (Matrix.diagonal(0,1,1) * @position) +(Matrix.diagonal(0,0,1) * box.dimensions) + x_offset)
+
+			return [sub_box_x, sub_box_y, sub_box_z]
+		end
+
+		def to_s
+			"Box - #{@dimensions.to_a} Pos:#{@position.to_a} V:#{@volume}"
+		end
+	end
+
+	class Item < Box
+		attr_accessor :id, :weight
+
+		def initialize(id, dimensions, weight)
+			super(dimensions.sort)
+			@id, @weight = id, weight
+		end
+
+		def deep_copy
+    		cloned_item = self.clone
+    		cloned_item.dimensions = @dimensions.clone
+    		cloned_item.position = @position.clone
+    		return cloned_item
+		end
+
+		def to_s
+			"#{@id} - #{@dimensions.to_a} V:#{@volume} W:#{@weight}"
+		end
+	end
+
+	class Packing
+		extend Forwardable
+		attr_reader :remaining_weight, :remaining_volume, :items
+
+		def_delegators :@items, :include?, :each, :map, :count
+		
+		def initialize(weight_limit, container_volume)
+		    @items = []
+		    @remaining_weight, @remaining_volume = weight_limit, container_volume
+		end
+
+  		def <<(item)
+  			@items << item
+  			@remaining_volume -= item.volume
+  			@remaining_weight -= item.weight
+  		end
+
+  		def to_s
+			s = @items.map do |item|
+				"#{item.id} - #{item.dimensions.to_a} Pos:#{item.position.to_a} V:#{item.volume} W:#{item.weight}"
+			end
+			return s.join("\n")
+  		end
+	end
+
+	class Container < Box
+		attr_accessor :id, :weight_limit, :packings_limit, :items
+		attr_reader :packings
+
+		def initialize(id, dimensions, weight_limit, packings_limit=3)
+			super(dimensions.sort)
+			@id, @weight_limit, @packings_limit = id, weight_limit, packings_limit
+			@items, @packings = [], []
+		end
+
+		def pack(sorting_method = :sort_by_volume_into_approx_packings)
+			return if @items.empty? || !items_all_fit? || !items_all_light_enough?
+
+			@items_to_pack = self.send(sorting_method, @items).map(&:deep_copy)	
+			@packings = []
+
+			until @items_to_pack.empty? || @packings.count >= @packings_limit do
+				@current_packing = Packing.new(@weight_limit, @volume)
+
+				pack_box(@items_to_pack.clone, self)
+				@packings << @current_packing
+			end
+
+			@items_to_pack.empty? ? @packings.count : nil
+		end
+
+		def to_s
+			s = "\n*** #{@id} - #{@dimensions.to_a} V:#{@volume} WL:#{@weight_limit} PL:#{@packings_limit} ***\n\n"
+			s += @items.map(&:to_s).join("\n")
+			@packings.each_with_index { |packing, i| s += "\n\nPacking #{i} RW:#{packing.remaining_weight} RV:#{packing.remaining_volume}\n#{packing.to_s}"}
+			s += "\n\n"
+		end
+
+	private
+
+		def items_all_fit?
+			@items.all? { |item| fit?(item) } 
+		end
+
+		def items_all_light_enough?
+			@items.all? { |item| item.weight < @weight_limit } 
+		end
+
+		def pack_box(current_items, box_to_pack)
+			until current_items.empty?
+				item = current_items.pop
+
+				if box_to_pack.fit_with_rotation?(item)									
+					add_item_to_packing(box_to_pack, item) 
+					break if (current_items - [item]).empty?
+
+					sub_boxes = box_to_pack.break_up_remaining_space(item)
+					sub_boxes.sort_by!(&:volume).reverse!
+					sub_boxes.each do |box| 
+						break if box.volume == 0
+						purge_items!(current_items)
+						pack_box(current_items.clone, box)
+					end
+					break
+				end
+			end
+		end
+
+		def add_item_to_packing(box_to_pack, item_to_add)
+			item_to_add.position = box_to_pack.position
+			@items_to_pack.delete_if { |item| item == item_to_add }
+			@current_packing << item_to_add
+		end
+
+		def purge_items!(current_items)
+			current_items.delete_if { |item| @current_packing.include?(item) \
+										  || item.weight > @current_packing.remaining_weight \
+										  || item.volume > @current_packing.remaining_volume}
+		end
+
+		def sort_by_volume(items_to_sort)
+			items_to_sort.sort_by(&:volume)
+		end
+
+		def sort_by_shuffle(items_to_sort)
+			items_to_sort.shuffle
+		end
+
+		def sort_by_volume_into_approx_packings(items_to_sort)
+			split_into_approx_packings(items_to_sort.sort_by(&:volume))
+		end
+
+		def split_into_approx_packings(items_to_sort)
+			total_volume_of_items = items_to_sort.map(&:volume).reduce(:+) 
+			approx_number_of_packings = (total_volume_of_items.to_f / @volume).ceil
+			approx_packing_size = (items_to_sort.count.to_f / approx_number_of_packings).ceil
+			indexs = (0..items_to_sort.count-1).each_slice(approx_number_of_packings).reduce(:zip).flatten.compact
+			return indexs.map{ |i| items_to_sort[i] }
+		end
+
+	end
+
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: box_packer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Max White
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: A Heuristic First-Fit 3D Bin Packing Algorithm with Weight Limit
+email:
+- mushishi78@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- box_packer.gemspec
+- lib/box_packer.rb
+- lib/box_packer/version.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+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.2.1
+signing_key: 
+specification_version: 4
+summary: A Heuristic First-Fit 3D Bin Packing Algorithm with Weight Limit
+test_files: []