box_packer 0.0.2 → 1.0.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MmU3YzNiYTFmYzA1YTM5MzFiYTc0NDA4MzYzODQ4YWQwZGM1OTI5Yg==
-  data.tar.gz: !binary |-
-    NjdhYzg2OGM1ZjRhZDBjNTBiOWVlYzkwNjE5NGFlMDRjZmIwNTIzYw==
+SHA1:
+  metadata.gz: 9bd4f81789b4f8f8dc272b4893f2ce1aaf5bf174
+  data.tar.gz: 2cbf0f36b648dc9d90872f17a118347fe6ad1d9c
 SHA512:
-  metadata.gz: !binary |-
-    ZTNkNmJmZWI4ODI5YzE0MjY2ZTcyZjI2OWJkZWE4NjhjY2VmNDg3MDBkOTI4
-    YjQ1MDEwY2UwZDhlYjA1NjI0OWJhODhkNGQ4YmQ4MjNkZDZiZTkzZmVhNmVk
-    NzE3MWM0MTA2M2VmYTg0YTk0NzQxYTc2NWFjNmYyNTMzNTkxNDY=
-  data.tar.gz: !binary |-
-    OThjYjRlOWRhMDQ5OTMyNzNjNDI0M2QxNTRmYzE0NGM4ODYyMTM2YzA2MTVj
-    YTE0ZDdlMmM5MGI4MDU0MTRmYWI3Nzc5NjU0YTRiYjllNWRiNTM0NDFiMGFm
-    OGZmMTljZmJmZTFhYjA4YTgzMDU1MzQwNDkxODVhNDhlZTY1NzU=
+  metadata.gz: 69dfe26e637c5f2fbd885af2949978cc5e7af0451c182a2ed7825d291c95e3780f81a7beb79ecb1f2f1d5aef2e273db51e8c4fdaf0260926504786166da79e90
+  data.tar.gz: ed7bf4a3b8f79fabbc84d1ea23ecbd583a6885c65aa2877cb721bfc811f0c0702244b27a4cde5c671b45d7eaa9c81cea3cbb513e727d933edc3ecf2e661d2b9b

data/.gitignore

@@ -1,17 +1 @@
 *.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/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/README.md

@@ -1,46 +1,93 @@
 BoxPacker
 =========
 
-A Heuristic First-Fit 3D Bin Packing Algorithm with Weight Limit. 
+A heuristic first-fit 3D bin packing algorithm with optional weight and bin limits. 
 
 Installation
 ------------
 
-Add this line to your application's Gemfile:
+Install gem:
 
-    gem 'box_packer'
+``` console
+gem  install 'box_packer'
+```
 
-And then execute:
+Or add to gemfile:
 
-    $ bundle
+``` ruby
+gem  'box_packer'
+```
 
 Usage
 -----
 
-```Ruby
-require "box_packer"
+``` ruby
+require 'box_packer'
 
-container = BoxPacker::Container.new("MyContainer", [6, 3, 7], 50)
+BoxPacker.container [3, 6, 7] do 
+	add_item [1,3,5]
+	add_item [4,3,5]
+	add_item [3,5,5]
+	pack! # returns 2
 
-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)
+	puts packed_successfully	         # true
+	puts packings.count	                 # 2
+	puts packings[0].include? items[1]   # false
+	puts packings[0][1].position         # (5,0,0)
 
-container.pack          #=> 2
-puts container
+	puts self  	# |Container| 7x6x3
+				# |  Packing| Remaining Volume:36
+				# |     Item| 5x5x3 (0,0,0) Volume:75
+				# |     Item| 1x5x3 (5,0,0) Volume:15
+				# |  Packing| Remaining Volume:66
+				# |     Item| 5x4x3 (0,0,0) Volume:60
+	
+end
 ```
 
-``` console
-*** MyContainer - [3, 6, 7] V:126 WL:50 PL:3 ***
+With optional labels, weights and packings limit:
+
+``` ruby
+BoxPacker.container [15, 20, 13], label: 'Parcel', weight_limit: 50, packings_limit: 3 do 
+	add_item [2, 3, 5], label: 'Shoes', weight: 47
+	add_item [3, 3, 1], label: 'Watch', weight: 24
+	add_item [1, 1, 4], label: 'Bag',   weight:  7
+	pack! # returns 2
+
+	puts self  	# |Container| Parcel 20x15x13 Weight Limit:50 Packings Limit:3
+				# |  Packing| Remaining Volume:3870 Remaining Weight:3
+				# |     Item| Shoes 5x3x2 (0,0,0) Volume:30 Weight:47
+				# |  Packing| Remaining Volume:3887 Remaining Weight:19
+				# |     Item| Watch 3x3x1 (0,0,0) Volume:9 Weight:24
+				# |     Item| Bag 4x1x1 (3,0,0) Volume:4 Weight:7
+end
+```
+
+Alternative builder API:
+
+``` ruby
+BoxPacker.builder do |b|
+	c1 = b.container [10,5,11]
+	c2 = b.container [17,23,14]
+
+	c1.items = [b.item([1,1,4]), b.item([4,6,7]), b.item([5,8,10])]
+	c2.items = c1.items
+
+	c1.pack! # 2
+	c2.pack! # 1
 
-MyItem01 - [1, 3, 5] V:15 W:10
-MyItem02 - [2, 2, 5] V:20 W:13
-MyItem03 - [3, 5, 5] V:75 W:36
+	puts c1  # |Container| 11x10x5
+			 # |  Packing| Remaining Volume:146
+			 # |     Item| 10x8x5 (0,0,0) Volume:400
+			 # |     Item| 4x1x1 (0,8,0) Volume:4
+			 # |  Packing| Remaining Volume:382
+			 # |     Item| 7x6x4 (10,0,0) Volume:168
 
-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
+	puts c2  # |Container| 23x17x14
+			 # |  Packing| Remaining Volume:4902
+			 # |     Item| 10x8x5 (0,0,0) Volume:400
+			 # |     Item| 7x6x4 (10,0,0) Volume:168
+			 # |     Item| 4x1x1 (17,0,0) Volume:4
 
-Packing 1 RW:40 RV:111
-MyItem01 - [1, 3, 5] Pos:[0, 0, 0] V:15 W:10
+end
 ```

data/box_packer.gemspec

@@ -1,23 +1,26 @@
-# 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.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.authors       = ['Max White']
+  spec.email         = ['mushishi78@gmail.com']
+  spec.description   = 'A Heuristic First-Fit 3D Bin Packing Algorithm with Weight Limit'
+  spec.summary       = '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.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+
+  spec.add_dependency 'attr_extras'
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
 end

data/lib/box_packer.rb

@@ -1,196 +1,3 @@
-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
+require_relative 'box_packer/version'
+require_relative 'box_packer/builder'
+require_relative 'box_packer/container'

data/lib/box_packer/box.rb

@@ -0,0 +1,39 @@
+require 'attr_extras'
+require 'forwardable'
+require_relative 'position'
+
+module BoxPacker
+	class Box
+		extend Forwardable
+		attr_initialize :dimensions, [:position]
+		def_delegators :dimensions, :volume, :each_rotation, :width, :height, :depth
+		attr_accessor :dimensions, :position
+
+		def position
+			@position ||= Position[0, 0, 0]
+		end
+
+		def orient!
+			@dimensions = Dimensions[*dimensions.to_a.sort!.reverse!]
+		end
+
+		def >=(other_box)
+			dimensions >= other_box.dimensions
+		end
+
+		def sub_boxes(item)	
+			sub_boxes = sub_boxes_args(item).select{ |(d, p)| d.volume > 0 }
+			sub_boxes.map!{ |args| Box.new(*args) }
+			sub_boxes.sort_by!(&:volume).reverse!
+		end
+
+	private
+
+		def sub_boxes_args(item)
+			[[      width +      height + depth - item.width,  position: position + item.width  ],
+			 [ item.width +      height + depth - item.height, position: position + item.height ],
+			 [ item.width + item.height + depth - item.depth,  position: position + item.depth  ]]
+		end
+
+	end
+end

data/lib/box_packer/builder.rb

@@ -0,0 +1,22 @@
+require_relative 'container'
+require_relative 'item'
+
+module BoxPacker
+
+	def self.builder(&b)
+		b.call(Builder.new) if block_given?
+	end
+
+	class Builder
+
+		def container(*args, &b)
+			Container.new(*args, &b)
+		end
+
+		def item(*args)
+			Item.new(*args)
+		end
+
+	end
+	
+end