box_packer 1.2.3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 577f9d185a95ed861e725040c6af624d2470fbea
-  data.tar.gz: e1959d0f2230fd26b464b5340d31cd45ea29c3b2
+  metadata.gz: b379d4407ae68ae0444cb2b5c2718f4ecdda9e5a
+  data.tar.gz: 883feddbe4f741e7d2f6cba5547635d467f54d80
 SHA512:
-  metadata.gz: 708d9ad7db2ca97d46c275e9545ff67e1aadd6788fc439dff8a78acc46d8b334a95d1c8d27a686b61357093a8a11bcf1f41b9c1bacc28ab72aa9d1933a88bcb6
-  data.tar.gz: 704c4c92f46af99ecf269347ecef930f41368922642c3447aed04e2dfdf0e77330a356da14bdcffd2b21eaa5cbb98bd5d985abb1e307849d7e926d3342983626
+  metadata.gz: 1711debc5d423788042c3b9ec7c9cde8e66431b4ddc18b1a31c85ee7bff0392787b097e2f225ab8924a5b5013a101a5229c1fdeae40e74d6c391dabd88e8c766
+  data.tar.gz: cd1147664c5a9d1091fa958a466f3f5d11a2c0daad15cf5f5aae186c140dc4ecfc683c2ecde4ac8c0ca7a218b5b165a9b42e4d9b2b5a2e639f86c3a11074eb78

data/LICENSE.txt

@@ -1,22 +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.
+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

@@ -1,115 +1,50 @@
-BoxPacker
-=========
+# BoxPacker
 
-[![Gem Version](https://badge.fury.io/rb/box_packer.svg)](http://badge.fury.io/rb/box_packer)
+First fit heuristic algorithm for 3D bin-packing with weight limit.
 
-A heuristic first-fit 3D bin packing algorithm with optional weight and bin limits.
+## Version 2
 
-Installation
-------------
+For version 2 this entire solution has been rewritten with an emphasis on making a much simpler
+and easier to understand implementation. However, I haven't gone to the trouble of reproducing
+all the previous functionality, so if you still need that, it can be found here:
+[1.2.4](https://github.com/mushishi78/box_packer/tree/1.2.4)
 
-Install gem:
+## Installation
 
-``` console
-gem  install 'box_packer'
-```
-
-Or add to gemfile:
+Add to gemfile:
 
 ``` ruby
 gem  'box_packer'
 ```
 
-Usage
------
+## Usage
 
 ``` ruby
 require 'box_packer'
 
-BoxPacker.container [3, 6, 7] do
-  add_item [1,3,5]
-  add_item [4,3,5]
-  add_item [3,5,5]
-  pack! # 2
-
-  puts packed_successfully           # true
-  puts packings.count                # 2
-  puts packings[0].include? items[1] # false
-  puts packings[0][1].position       # (5,0,0)
-
-  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
-```
-
-With optional labels, weights, quantity 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, quantity: 2
-  add_item [3, 3, 1], label: 'Watch', weight: 24
-  add_item [1, 1, 4], label: 'Bag',   weight:  7
-  pack! # 3
-
-  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: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
-
-  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
-
-  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
-
-end
+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] # [5, 3, 2]
+packings[0][:placements][0][:position] # [0, 0, 0]
+packings[1][:weight] # 47
+packings[1][:placements].length # 1
+packings[1][:placements][0][:dimensions] # [5, 3, 2]
+packings[1][:placements][0][:position] # [0, 0, 0]
+packings[2][:weight] # 31
+packings[2][:placements].length # 2
+packings[2][:placements][0][:dimensions] # [3, 3, 1]
+packings[2][:placements][0][:position] # [0, 0, 0]
+packings[2][:placements][1][:dimensions] # [4, 1, 1]
+packings[2][:placements][1][:position] # [3, 0, 0]
 ```
-
-Export SVG
-----------
-
-``` ruby
-BoxPacker.container [3, 4, 2] do
-  add_item [1,3,2], label: 'Bag', colour: 'red'
-  add_item [3,3,1], label: 'Hat', colour: 'blue'
-  add_item [1,2,2], label: 'Shoes', colour: 'green'
-  add_item [3,1,1], label: 'Slipper', colour: 'purple'
-  add_item [2,1,1], label: 'Dragon', colour: 'orange'
-  pack!
-  draw!('examples/example', scale_longest_side_to: 500, margin: 15)
-end
-```
-
-Output:
-
-![SVG Output](https://rawgit.com/mushishi78/box_packer/master/examples/example1.svg)

data/box_packer.rb

@@ -0,0 +1,127 @@
+module BoxPacker
+  class << self
+    def pack(container:, items:)
+      packings = []
+
+      items.each do |item|
+        # If the item is just too big for the container lets give up on this
+        raise 'Item is too heavy for container' if item[:weight] > container[:weight_limit]
+
+        # 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] + item[:weight] > container[:weight_limit]
+
+          packing[:spaces].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]
+            packing[:spaces] -= [space]
+            packing[:spaces] += break_up_space(space, placement)
+            item_has_been_packed = true
+            break
+          end
+          break if item_has_been_packed
+        end
+        break 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
+        raise 'Item cannot be placed in container' unless placement
+
+        # Otherwise lets put the item in a new packing
+        # and break up the remaing free space around it
+        packings += [{
+          placements: [placement],
+          weight: item[:weight],
+          spaces: break_up_space(space, placement)
+        }]
+      end
+
+      packings
+    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]
+      ]
+
+      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]
+
+        return {
+          dimensions: perm,
+          position: space[:position],
+          weight: item[:weight]
+        }
+      end
+    end
+
+    def break_up_space(space, placement)
+      [
+        {
+          dimensions: [
+            space[:dimensions][0],
+            space[:dimensions][1],
+            space[:dimensions][2] - placement[:dimensions][0]
+          ],
+          position: [
+            space[:position][0] + placement[:dimensions][0],
+            space[:position][1],
+            space[:position][2]
+          ]
+        },
+        {
+          dimensions: [
+            placement[:dimensions][0],
+            space[:dimensions][1],
+            space[:dimensions][2] - placement[:dimensions][1]
+          ],
+          position: [
+            space[:position][0],
+            space[:position][1] + placement[:dimensions][1],
+            space[:position][2]
+          ]
+        },
+        {
+          dimensions: [
+            placement[:dimensions][0],
+            placement[:dimensions][1],
+            space[:dimensions][2] - placement[:dimensions][2]
+          ],
+          position: [
+            space[:position][0],
+            space[:position][1],
+            space[:position][2] + placement[:dimensions][2]
+          ]
+        }
+      ]
+    end
+  end
+end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: box_packer
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 2.0.0
 platform: ruby
 authors:
 - Max White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-23 00:00:00.000000000 Z
+date: 2016-11-13 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: rasem
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.6'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -52,17 +38,7 @@ extra_rdoc_files: []
 files:
 - LICENSE.txt
 - README.md
-- lib/box_packer.rb
-- lib/box_packer/box.rb
-- lib/box_packer/builder.rb
-- lib/box_packer/container.rb
-- lib/box_packer/dimensions.rb
-- lib/box_packer/item.rb
-- lib/box_packer/packer.rb
-- lib/box_packer/packing.rb
-- lib/box_packer/position.rb
-- lib/box_packer/svg_exporter.rb
-- lib/box_packer/vector.rb
+- box_packer.rb
 homepage: https://github.com/mushishi78/box_packer
 licenses:
 - MIT
@@ -70,7 +46,7 @@ metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
-- lib
+- "."
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -83,8 +59,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.6.0
 signing_key: 
 specification_version: 4
-summary: 3D bin-packing algorithm with optional weight and bin limits.
+summary: First fit heuristic algorithm for 3D bin-packing with weight limit.
 test_files: []

data/lib/box_packer.rb

@@ -1,2 +0,0 @@
-require 'box_packer/container'
-require 'box_packer/builder'

data/lib/box_packer/box.rb

@@ -1,39 +0,0 @@
-require 'forwardable'
-require_relative 'position'
-require_relative 'dimensions'
-
-module BoxPacker
-  class Box
-    extend Forwardable
-
-    def initialize(dimensions, opts = {})
-      @dimensions = dimensions
-      @position = opts[:position] || Position[0, 0, 0]
-    end
-
-    def_delegators :dimensions, :volume, :each_rotation, :width, :height, :depth
-    attr_accessor :dimensions, :position
-
-    def orient!
-      @dimensions = Dimensions[*dimensions.to_a.sort!.reverse!]
-    end
-
-    def >=(other)
-      dimensions >= other.dimensions
-    end
-
-    def sub_boxes(item)
-      sub_boxes = sub_boxes_args(item).select { |(d, _)| 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

@@ -1,18 +0,0 @@
-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

data/lib/box_packer/container.rb

@@ -1,102 +0,0 @@
-require_relative 'dimensions'
-require_relative 'item'
-require_relative 'packer'
-require_relative 'packing'
-require_relative 'svg_exporter'
-require_relative 'box'
-
-module BoxPacker
-  def self.container(*args, &b)
-    Container.new(*args, &b)
-  end
-
-  class Container < Box
-    attr_accessor :label, :weight_limit, :packings_limit
-    attr_reader :items, :packing, :packings, :packed_successfully
-
-    def initialize(dimensions, opts = {}, &b)
-      super(Dimensions[*dimensions])
-      @label = opts[:label]
-      @weight_limit = opts[:weight_limit]
-      @packings_limit = opts[:packings_limit]
-      @items = opts[:items] || []
-      orient!
-      instance_exec(&b) if b
-    end
-
-    def add_item(dimensions, opts = {})
-      quantity = opts.delete(:quantity) || 1
-      quantity.times do
-        items << Item.new(dimensions, opts)
-      end
-    end
-
-    def <<(item)
-      items << item.dup
-    end
-
-    def items=(new_items)
-      @items = new_items.map(&:dup)
-    end
-
-    def pack!
-      prepare_to_pack!
-      return unless packable?
-      if @packed_successfully = Packer.pack(self)
-        packings.count
-      else
-        @packings = []
-        false
-      end
-    end
-
-    def new_packing!
-      @packing = Packing.new(volume, weight_limit)
-      @packings << @packing
-    end
-
-    def to_s
-      s = "\n|Container|"
-      s << " #{label}" if label
-      s << " #{dimensions}"
-      s << " Weight Limit:#{weight_limit}" if weight_limit
-      s << " Packings Limit:#{packings_limit}" if packings_limit
-      s << "\n"
-      s << (packed_successfully ? packings.map(&:to_s).join : '|         | Did Not Pack!')
-    end
-
-    def draw!(filename, opts = {})
-      exporter = SVGExporter.new(self, opts)
-      exporter.draw
-      exporter.save(filename)
-    end
-
-    private
-
-    def packable?
-      return false if items.empty?
-      total_weight = 0
-
-      items.each do |item|
-        if weight_limit && item.weight
-          return false if item.weight > weight_limit
-          total_weight += item.weight
-        end
-
-        return false unless self >= item
-      end
-
-      if weight_limit && packings_limit
-        return total_weight <= weight_limit * packings_limit
-      end
-
-      true
-    end
-
-    def prepare_to_pack!
-      items.each(&:orient!)
-      @packings = []
-      @packed_successfully = false
-    end
-  end
-end

data/lib/box_packer/dimensions.rb

@@ -1,26 +0,0 @@
-require_relative 'vector'
-
-module BoxPacker
-  class Dimensions < Vector
-    def volume
-      @volume ||= to_a.reduce(&:*)
-    end
-
-    def >=(other)
-      zip_map(other, :>=).reduce(&:&)
-    end
-
-    def each_rotation
-      yield Dimensions[x, y, z]
-      yield Dimensions[x, z, y]
-      yield Dimensions[z, x, y]
-      yield Dimensions[z, y, x]
-      yield Dimensions[y, x, z]
-      yield Dimensions[y, z, x]
-    end
-
-    def to_s
-      to_a.join('x')
-    end
-  end
-end

data/lib/box_packer/item.rb

@@ -1,34 +0,0 @@
-require_relative 'box'
-require_relative 'dimensions'
-
-module BoxPacker
-  class Item < Box
-    attr_accessor :label, :weight
-    attr_reader :colour
-
-    def initialize(dimensions, opts = {})
-      super(Dimensions[*dimensions])
-      @label = opts[:label].to_s
-      @weight = opts[:weight]
-      @colour = opts[:colour] || '%06x' % (rand * 0xffffff)
-    end
-
-    def rotate_to_fit_into(box)
-      each_rotation do |rotation|
-        if box.dimensions >= rotation
-          @dimensions = rotation
-          return true
-        end
-      end
-      false
-    end
-
-    def to_s
-      s = '|     Item|'
-      s << " #{label}" if label
-      s << " #{dimensions} #{position} Volume:#{volume}"
-      s << " Weight:#{weight}" if weight
-      s << "\n"
-    end
-  end
-end

data/lib/box_packer/packer.rb

@@ -1,63 +0,0 @@
-module BoxPacker
-  class Packer
-    extend Forwardable
-
-    def self.pack(container)
-      new(container).pack
-    end
-
-    def initialize(container)
-      @container = container
-    end
-
-    def_delegators :container, :new_packing!, :packings_limit, :packings, :packing
-
-    def pack
-      @items = container.items.sort_by!(&:volume).reverse!
-
-      until too_many_packings?
-        new_packing!
-        pack_box(@items, container)
-        return true if @items.empty?
-      end
-      false
-    end
-
-    private
-
-    attr_reader :container
-
-    def too_many_packings?
-      packings.count >= packings_limit if packings_limit
-    end
-
-    def pack_box(possible_items, box)
-      possible_items = possible_items.dup
-      until possible_items.empty?
-        item = possible_items.shift
-        next unless item.rotate_to_fit_into(box)
-
-        pack_item!(item, possible_items, box)
-        break if possible_items.empty?
-
-        box.sub_boxes(item).each do |sub_box|
-          purge!(possible_items)
-          pack_box(possible_items, sub_box)
-        end
-        break
-      end
-    end
-
-    def pack_item!(item, possible_items, box)
-      item.position = box.position
-      possible_items.delete(item)
-      packing << @items.delete(item)
-    end
-
-    def purge!(possible_items)
-      possible_items.keep_if do |item|
-        packing.fit?(item)
-      end
-    end
-  end
-end

data/lib/box_packer/packing.rb

@@ -1,39 +0,0 @@
-require 'delegate'
-
-module BoxPacker
-  class Packing < SimpleDelegator
-    attr_reader :remaining_weight, :remaining_volume
-
-    def initialize(total_volume, total_weight)
-      super([])
-      @remaining_volume = total_volume
-      @remaining_weight = total_weight
-    end
-
-    def <<(item)
-      @remaining_volume -= item.volume
-      @remaining_weight -= item.weight if weight?(item)
-      super
-    end
-
-    def fit?(item)
-      return false if include?(item)
-      return false if remaining_volume < item.volume
-      return false if weight?(item) && remaining_weight < item.weight
-      true
-    end
-
-    def to_s
-      s = "|  Packing| Remaining Volume:#{remaining_volume}"
-      s << " Remaining Weight:#{remaining_weight}" if remaining_weight
-      s << "\n"
-      s << map(&:to_s).join
-    end
-
-    private
-
-    def weight?(item)
-      remaining_weight && item.weight
-    end
-  end
-end

data/lib/box_packer/position.rb

@@ -1,9 +0,0 @@
-require_relative 'vector'
-
-module BoxPacker
-  class Position < Vector
-    def to_s
-      "(#{to_a.join(',')})"
-    end
-  end
-end

data/lib/box_packer/svg_exporter.rb

@@ -1,117 +0,0 @@
-require 'rasem'
-
-module BoxPacker
-  class SVGExporter
-    def initialize(container, opts = {})
-      @container = container
-      @images = []
-      @margin  = opts[:margin] || 10
-
-      dimensions = container.dimensions.to_a
-      longest_side = dimensions.max
-      sides_total = dimensions.reduce(&:+)
-      scale_longest_side_to = opts[:scale_longest_side_to] || 400
-
-      @scale = scale_longest_side_to / longest_side.to_f
-      @image_width = (longest_side * scale * 2) + (margin * 3)
-      @image_height = (sides_total * scale) + (margin * 4)
-    end
-
-    def save(filename)
-      images.each_with_index do |image, i|
-        image.close
-
-        File.open("#{filename}#{i + 1}.svg", 'w') do |f|
-          f << image.output
-        end
-      end
-    end
-
-    def draw
-      container.packings.each do |packing|
-        Face.reset(margin, scale, container.dimensions)
-        new_image
-        6.times do
-          face = Face.new(packing)
-          image.rectangle(*face.outline, stroke: 'black', stroke_width: 1, fill: 'white')
-          face.rectangles_and_labels.each do |h|
-            image.rectangle(*h[:rectangle])
-            image.text(*h[:label])
-          end
-        end
-      end
-    end
-
-    private
-
-    attr_reader :container, :scale, :margin, :images, :image, :image_width, :image_height
-
-    def new_image
-      @image = Rasem::SVGImage.new(image_width, image_height)
-      images << image
-    end
-
-    class Face
-      attr_reader :width, :height, :axes
-
-      def self.reset(margin, scale, container_dimensions)
-        @@coords_mapping = [0, 1, 2]
-        @@front = true
-        @@margin = margin
-        @@axes = [margin, margin]
-        @@scale = scale
-        @@container_dimensions = container_dimensions
-      end
-
-      def iterate_class_variables
-        if front
-          @@axes[0] = width + @@margin * 2
-        else
-          @@coords_mapping.rotate!
-          @@axes[0] = @@margin
-          @@axes[1] += height + @@margin
-        end
-        @@front = !@@front
-      end
-
-      def initialize(packing)
-        @i, @j, @k = @@coords_mapping.dup
-        @front = @@front
-        @axes = @@axes.dup
-        @width = @@container_dimensions[i] * @@scale
-        @height = @@container_dimensions[j] * @@scale
-        iterate_class_variables
-        @items = sorted_items(packing)
-      end
-
-      def outline
-        @axes + [width, height]
-      end
-
-      def rectangles_and_labels
-        items.map do |item|
-          x = axes[0] + item.position[i] * @@scale
-          y = axes[1] + item.position[j] * @@scale
-          width = item.dimensions[i] * @@scale
-          height = item.dimensions[j] * @@scale
-          label_x = x + width / 2 - item.label.length
-          label_y = y + height / 2
-          {
-            rectangle: [x, y, width, height, fill: item.colour],
-            label: [label_x, label_y, item.label]
-          }
-        end
-      end
-
-      private
-
-      attr_reader :packing, :i, :j, :k, :front, :items
-
-      def sorted_items(packing)
-        items = packing.sort_by { |i| i.position[k] }
-        items.reverse! unless front
-        items
-      end
-    end
-  end
-end

data/lib/box_packer/vector.rb

@@ -1,51 +0,0 @@
-module BoxPacker
-  class Vector
-    def self.[](*args)
-      new(*args)
-    end
-
-    def initialize(x, y, z)
-      @x, @y, @z = x, y, z
-    end
-
-    attr_reader :x, :y, :z
-
-    def +(other)
-      self.class.new(*zip_map(other, :+))
-    end
-
-    def -(other)
-      self.class.new(*zip_map(other, :-))
-    end
-
-    def width
-      self.class.new(x, 0, 0)
-    end
-
-    def height
-      self.class.new(0, y, 0)
-    end
-
-    def depth
-      self.class.new(0, 0, z)
-    end
-
-    def to_a
-      [x, y, z]
-    end
-
-    def ==(other)
-      zip_map(other, :==).reduce(&:&)
-    end
-
-    def eql?(other)
-      zip_map(other, :eql?).reduce(&:&)
-    end
-
-    private
-
-    def zip_map(other, method)
-      to_a.zip(other.to_a).map { |a, b| a.send(method, b) }
-    end
-  end
-end