boxify 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cbe525b48eb75a67ace2f93c09a24cb5b3e35065
+  data.tar.gz: 9392c2eb883e591352cecce4abe5a44ab217f366
+SHA512:
+  metadata.gz: 032807b6118f66d235f55adbed4b26bdb47c04ef1d982a8af34e8b931c9fef961e9df1de9ddefeef68e3f899cdcdd96273c7617dca0a1218b6ab01b283efad72
+  data.tar.gz: 6a3a8c7f69e04b7d081ee76baf0ecf262d73553cce602b7ce4526330f5c9ec9827dffbe71dae399242092b4a0ab79db304013a1df5adb9d7bb2806934a02d997

data/lib/boxify.rb

@@ -0,0 +1,8 @@
+require 'forwardable'
+require_relative 'boxify/dimensionable'
+require_relative 'boxify/container'
+require_relative 'boxify/box'
+require_relative 'boxify/space'
+require_relative 'boxify/eligible_box'
+require_relative 'boxify/placed_box'
+require_relative 'boxify/pack'

data/lib/boxify/box.rb

@@ -0,0 +1,90 @@
+module Boxify
+  class Box
+    include Dimensionable
+
+    attr_accessor :total_count
+
+    def initialize(width:, depth:, height:, total_count: 1)
+      @width = width
+      @depth = depth
+      @height = height
+      @total_count = total_count
+    end
+
+    def rotated
+      @rotated ||= Box.new(width: height, depth: depth, height: width)
+    end
+
+    def rotate
+      temp_width = width
+      @width = height
+      @height = temp_width
+    end
+  end
+
+  class BoxCollection
+
+    attr_reader :boxes
+
+    def initialize(boxes: boxes)
+      @boxes = boxes
+    end
+
+    def unplaced
+      boxes.select{ |b| b.total_count > 0 }
+    end
+
+    def delete(box)
+      return if box.total_count == 0
+      box.total_count -= 1
+    end
+
+    def total_count
+      boxes.map(&:total_count).inject(:+)
+    end
+
+    def flattened_dimensions
+      @flattened_dimensions ||= boxes.map { |b| [b.width, b.height, b.depth]}.flatten.uniq.sort
+    end
+
+    def longest_edge
+      @longest_edge ||= flattened_dimensions.max
+    end
+
+    def second_longest_edge
+      @second_longest_edge ||= flattened_dimensions[-2]
+    end
+
+    def box_with_widest_surface_area
+      boxes_sorted_by_surface_area.last
+    end
+
+    def box_with_minimum_height
+      boxes_sorted_by_height.first
+    end
+
+    def more_than_one_box_with_widest_surface_area?
+      number_of_boxes = unplaced.select {|b| b.surface_area == box_with_widest_surface_area.surface_area }.count
+      number_of_boxes > 1
+    end
+
+    def find_eligible_boxes(space)
+      unplaced.select{ |b| (b.width <= space.width) && (b.height <= space.height) }
+    end
+
+    # Find biggest (widest surface) box with minimum height
+    def find_biggest_box_with_minimum_height
+      more_than_one_box_with_widest_surface_area? ? box_with_minimum_height : box_with_widest_surface_area
+    end
+
+    private
+
+    def boxes_sorted_by_surface_area
+      unplaced.sort { |x,y| x.surface_area <=> y.surface_area }
+    end
+
+    def boxes_sorted_by_height
+      unplaced.sort { |x,y| x.height <=> y.height }
+    end
+  end
+end

data/lib/boxify/container.rb

@@ -0,0 +1,21 @@
+module Boxify
+  class Container
+    include Dimensionable
+
+    attr_accessor :placed_boxes
+
+    def initialize(width:, depth:, height:)
+      @width = width
+      @depth = depth
+      @height = height
+    end
+
+    def volume_of_placed_boxes
+      placed_boxes.volume
+    end
+
+    def wasted_space_percentage
+      (volume - volume_of_placed_boxes).to_f / volume * 100
+    end
+  end
+end

data/lib/boxify/dimensionable.rb

@@ -0,0 +1,17 @@
+module Boxify
+  module Dimensionable
+    attr_accessor :width, :depth, :height
+
+    def area
+      width * depth
+    end
+
+    def volume
+      width * height * depth
+    end
+
+    def surface_area
+      (2 * height * width) + (2 * height * depth) + (2 * width * depth)
+    end
+  end
+end

data/lib/boxify/eligible_box.rb

@@ -0,0 +1,51 @@
+module Boxify
+  class EligibleBox
+
+    attr_reader :boxes, :space
+
+    def initialize(boxes:, space:)
+      @boxes = boxes
+      @space = space
+    end
+
+    def self.find_all(boxes:, space:)
+      new(boxes: boxes, space: space).eligible_boxes
+    end
+
+    def self.find_best_fit(boxes:, space:)
+      new(boxes: boxes, space: space).eligible_box_with_largest_volume
+    end
+
+    def eligible_boxes
+      @eligible_boxes ||= find_eligible_boxes
+    end
+
+    def eligible_box_with_largest_volume
+      @eligible_box_with_largest_volume ||= find_box_with_largest_volume(eligible_boxes)
+    end
+
+    private
+
+    def find_eligible_boxes
+      da_boxes = boxes.select do |box|
+        true if (box.width <= space.width) && (box.height <= space.height)
+
+        rotated_copy = box.rotated
+        if (rotated_copy.width <= space.width) && (rotated_copy.height <= space.height)
+          box.rotate
+          true
+        end
+      end
+      da_boxes
+    end
+
+    def find_box_with_largest_volume(boxes)
+      if boxes.size > 1
+        # Return box with largest volume
+        boxes.sort{ |b| b.volume }.first
+      else
+        boxes.first
+      end
+    end
+  end
+end

data/lib/boxify/pack.rb

@@ -0,0 +1,99 @@
+module Boxify
+  class Pack
+    extend Forwardable
+
+    STARTING_LEVEL = 0
+
+    attr_reader :boxes, :placed_boxes, :level, :container, :volume_of_placed_boxes
+
+    def_delegators :@container, :volume_of_placed_boxes, :wasted_space_percentage
+    def_delegator :@container, :height, :container_height
+    def_delegator :@container, :depth, :container_depth
+    def_delegator :@container, :width, :container_width
+    def_delegator :@container, :volume, :container_volume
+
+    def initialize(boxes:)
+      @level = STARTING_LEVEL
+      @boxes = boxes
+      @placed_boxes = PlacedBoxCollection.new
+      @container = Container.new(width: boxes.longest_edge, depth: boxes.second_longest_edge, height: 0)
+    end
+
+    def pack
+      pack_level
+      container.placed_boxes = placed_boxes
+      true
+    end
+
+    def pack_level
+
+      # Increment level of box
+      increment_level
+
+      # Get biggest box as object
+      box = boxes.find_biggest_box_with_minimum_height
+
+      # Set container height (ck = ck + ci)
+      increment_height(box.height)
+
+      # Remove box from array (ki = ki - 1)
+      pack_box(box)
+
+      # Terminate if all boxes have been packed
+      return true if boxes.total_count == 0
+
+      # No space left (not even when rotated / length and width swapped)
+      if container.area - box.area <= 0
+        pack_level
+      else  # Space left, check if a package fits in
+        space = Space.new(width: container.width, depth: container.depth, height: container.height)
+        spaces = SpaceCollection.find_spaces_within_space(space: space, box: box)
+
+        # Fill each space with boxes
+        spaces.each do |space|
+          fill_space(space)
+        end
+
+        pack_level if boxes.total_count > 0
+      end
+    end
+
+
+    # Fills space with boxes recursively
+    def fill_space(space)
+      # Find box that fits into this space
+      eligible_box = find_eligible_box(space)
+
+      if eligible_box
+        pack_box(eligible_box)
+
+        spaces = SpaceCollection.find_spaces_within_space(space: space, box: eligible_box)
+
+        # Fill each space with boxes
+        spaces.each do |space|
+          fill_space(space)
+        end
+      end
+    end
+
+    private
+
+    # Set container height (ck = ck + ci)
+    def increment_height(height)
+      @container.height += height
+    end
+
+    def increment_level
+      @level += 1
+    end
+
+    def pack_box(box)
+      placed_boxes.add(box: box, level: level)
+      boxes.delete(box)
+    end
+
+    def find_eligible_box(space)
+      EligibleBox.find_best_fit(boxes: boxes.unplaced, space: space)
+    end
+  end
+end

data/lib/boxify/placed_box.rb

@@ -0,0 +1,31 @@
+module Boxify
+  class PlacedBox
+    extend Forwardable
+
+    attr_reader :box, :level
+
+    def_delegators :@box, :volume
+
+    def initialize(box:, level:)
+      @box = box
+      @level = level
+    end
+  end
+
+  class PlacedBoxCollection
+
+    attr_accessor :placed_boxes
+
+    def initialize(placed_boxes: [])
+      @placed_boxes = placed_boxes
+    end
+
+    def add(box:, level:)
+      @placed_boxes.push(PlacedBox.new(box: box, level: level))
+    end
+
+    def volume
+      placed_boxes.map(&:volume).inject(:+)
+    end
+  end
+end

data/lib/boxify/space.rb

@@ -0,0 +1,41 @@
+module Boxify
+  class Space
+    include Dimensionable
+
+    def initialize(width:, depth:, height:)
+      @width = width
+      @depth = depth
+      @height = height
+    end
+  end
+
+  class SpaceCollection
+    extend Forwardable
+
+    attr_reader :spaces
+
+    def_delegators :@spaces, :each
+
+    def initialize(spaces: spaces)
+      @spaces = spaces
+    end
+
+    def self.find_spaces_within_space(space:, box:)
+      spaces = []
+
+      if space.depth - box.depth > 0
+        spaces.push(Space.new(depth: space.depth - box.depth,
+                              width: space.width,
+                              height: box.height))
+      end
+
+      if space.width - box.width > 0
+        spaces.push(Space.new(depth: box.depth,
+                              width: space.width - box.width,
+                              height: box.height))
+      end
+
+      new(spaces: spaces)
+    end
+  end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: boxify
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Don Pottinger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-07 00:00:00.000000000 Z
+dependencies: []
+description: Ruby implementation of a Largest Area Fit First (LAFF) for 3D Rectangular
+  Box Packing algorithm
+email: don.pottinger@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/boxify.rb
+- lib/boxify/box.rb
+- lib/boxify/container.rb
+- lib/boxify/dimensionable.rb
+- lib/boxify/eligible_box.rb
+- lib/boxify/pack.rb
+- lib/boxify/placed_box.rb
+- lib/boxify/space.rb
+homepage: https://github.com/strukturedkaos/boxify
+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.2
+signing_key: 
+specification_version: 4
+summary: Ruby implementation of a Largest Area Fit First (LAFF) for 3D Rectangular
+  Box Packing algorithm
+test_files: []