bin_packing 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 729c8a0a3ebeb449568d02a4ec00f7a4ecc4a574
+  data.tar.gz: 7c53d882f799e197c921245ac9135c2b3ccc7b9b
+SHA512:
+  metadata.gz: 5efb09d2832044bbd32fa250945eb7d7c0108df2c992a56c62ea85312b9dd3d76a262afc5c4570dc53dd5fe7fa47804da34aea47a1d8e69c8f33b4ba642e37c5
+  data.tar.gz: 3d708805897abef9f009edb147d383f6b71654d9ed59d24abe20caab6632cbf6ac17c26dcc559e3218d2a297eba2dc40f5294e421b3ae754432f7f51281f7807

data/lib/bin_packing.rb

@@ -0,0 +1,19 @@
+require 'bin_packing/error'
+require 'bin_packing/box'
+require 'bin_packing/free_space_box'
+require 'bin_packing/bin'
+require 'bin_packing/score'
+require 'bin_packing/score_board_entry'
+require 'bin_packing/score_board'
+require 'bin_packing/heuristics/base'
+require 'bin_packing/heuristics/best_area_fit'
+require 'bin_packing/heuristics/best_long_side_fit'
+require 'bin_packing/heuristics/best_short_side_fit'
+require 'bin_packing/heuristics/bottom_left'
+require 'bin_packing/packer'
+require 'bin_packing/export_binding'
+require 'bin_packing/export'
+require 'bin_packing/version'
+
+module BinPacking
+end

data/lib/bin_packing/bin.rb

@@ -0,0 +1,180 @@
+module BinPacking
+  class Bin
+    attr_reader :width, :height, :boxes, :heuristic
+
+    def initialize(width, height, heuristic = nil)
+      @width = width
+      @height = height
+
+      @boxes = []
+      box = BinPacking::FreeSpaceBox.new(width, height)
+      @free_rectangles = [box]
+
+      @heuristic = heuristic || BinPacking::Heuristics::BestShortSideFit.new
+    end
+
+    def efficiency
+      boxes_area = 0
+      @boxes.each { |box| boxes_area += box.area }
+      boxes_area * 100 / area
+    end
+
+    def insert(box)
+      return false if box.packed?
+
+      @heuristic.find_position_for_new_node!(box, @free_rectangles)
+      return false unless box.packed?
+
+      num_rectangles_to_process = @free_rectangles.size
+      i = 0
+      while i < num_rectangles_to_process
+        if split_free_node(@free_rectangles[i], box)
+          @free_rectangles.delete_at(i)
+          num_rectangles_to_process -= 1
+        else
+          i += 1
+        end
+      end
+
+      prune_free_list
+
+      @boxes << box
+      true
+    end
+
+    def insert!(box)
+      unless insert(box)
+        raise ArgumentError, "Could not insert box #{box.inspect} "\
+                             "into bin #{inspect}."
+      end
+      self
+    end
+
+    def score_for(box)
+      @heuristic.find_position_for_new_node!(box.clone, @free_rectangles)
+    end
+
+    def is_larger_than?(box)
+      (@width >= box.width && @height >= box.height) ||
+        (@height >= box.width && @width >= box.height)
+    end
+
+    def label
+      "#{@width}x#{@height} #{efficiency}%"
+    end
+
+    private
+
+    def area
+      @width * @height
+    end
+
+    def place_rect(node)
+      num_rectangles_to_process = @free_rectangles.size
+      i = 0
+      while i < num_rectangles_to_process
+        if split_free_node(@free_rectangles[i], node)
+          @free_rectangles.delete_at(i)
+          num_rectangles_to_process -= 1
+        else
+          i += 1
+        end
+      end
+
+      prune_free_list
+
+      @boxes << node
+    end
+
+    def split_free_node(free_node, used_node)
+      # Test with SAT if the rectangles even intersect.
+      if used_node.x >= free_node.x + free_node.width ||
+          used_node.x + used_node.width <= free_node.x ||
+          used_node.y >= free_node.y + free_node.height ||
+          used_node.y + used_node.height <= free_node.y
+        return false
+      end
+
+      try_split_free_node_vertically(free_node, used_node)
+
+      try_split_free_node_horizontally(free_node, used_node)
+
+      true
+    end
+
+    def try_split_free_node_vertically(free_node, used_node)
+      if used_node.x < free_node.x + free_node.width && used_node.x + used_node.width > free_node.x
+        try_leave_free_space_at_top(free_node, used_node)
+        try_leave_free_space_at_bottom(free_node, used_node)
+      end
+    end
+
+    def try_leave_free_space_at_top(free_node, used_node)
+      if used_node.y > free_node.y && used_node.y < free_node.y + free_node.height
+        new_node = free_node.clone
+        new_node.height = used_node.y - new_node.y
+        @free_rectangles << new_node
+      end
+    end
+
+    def try_leave_free_space_at_bottom(free_node, used_node)
+      if used_node.y + used_node.height < free_node.y + free_node.height
+        new_node = free_node.clone
+        new_node.y = used_node.y + used_node.height
+        new_node.height = free_node.y + free_node.height - (used_node.y + used_node.height)
+        @free_rectangles << new_node
+      end
+    end
+
+    def try_split_free_node_horizontally(free_node, used_node)
+      if used_node.y < free_node.y + free_node.height && used_node.y + used_node.height > free_node.y
+        try_leave_free_space_on_left(free_node, used_node)
+        try_leave_free_space_on_right(free_node, used_node)
+      end
+    end
+
+    def try_leave_free_space_on_left(free_node, used_node)
+      if used_node.x > free_node.x && used_node.x < free_node.x + free_node.width
+        new_node = free_node.clone
+        new_node.width = used_node.x - new_node.x
+        @free_rectangles << new_node
+      end
+    end
+
+    def try_leave_free_space_on_right(free_node, used_node)
+      if used_node.x + used_node.width < free_node.x + free_node.width
+        new_node = free_node.clone
+        new_node.x = used_node.x + used_node.width
+        new_node.width = free_node.x + free_node.width - (used_node.x + used_node.width)
+        @free_rectangles << new_node
+      end
+    end
+
+    # Goes through the free rectangle list and removes any redundant entries.
+    def prune_free_list
+      i = 0
+      while i < @free_rectangles.size
+        j = i + 1
+        while j < @free_rectangles.size
+          if is_contained_in?(@free_rectangles[i], @free_rectangles[j])
+            @free_rectangles.delete_at(i)
+            i -= 1
+            break
+          end
+          if is_contained_in?(@free_rectangles[j], @free_rectangles[i])
+            @free_rectangles.delete_at(j)
+          else
+            j += 1
+          end
+        end
+        i += 1
+      end
+    end
+
+    def is_contained_in?(rect_a, rect_b)
+      return rect_a.x >= rect_b.x && rect_a.y >= rect_b.y &&
+        rect_a.x+rect_a.width <= rect_b.x+rect_b.width &&
+        rect_a.y+rect_a.height <= rect_b.y+rect_b.height
+    end
+  end
+end

data/lib/bin_packing/box.rb

@@ -0,0 +1,29 @@
+module BinPacking
+  class Box
+    attr_accessor :width, :height, :x, :y, :packed
+
+    def initialize(width, height)
+      @width = width
+      @height = height
+      @x = 0
+      @y = 0
+      @packed = false
+    end
+
+    def area
+      @area ||= @width * @height
+    end
+
+    def rotate
+      @width, @height = [@height, @width]
+    end
+
+    def packed?
+      @packed
+    end
+
+    def label
+      "#{@width}x#{@height} at [#{@x},#{@y}]"
+    end
+  end
+end

data/lib/bin_packing/error.rb

@@ -0,0 +1,4 @@
+module BinPacking
+  class Error < StandardError
+  end
+end

data/lib/bin_packing/export.rb

@@ -0,0 +1,15 @@
+module BinPacking
+  class Export
+    def initialize(*bins)
+      @bins = Array(bins).flatten
+    end
+
+    def to_html(options = {})
+      template_path = File.expand_path('../resources/export.html.erb', __FILE__)
+      template = File.read(template_path)
+      binding = ExportBinding.new(@bins, options[:zoom] || 1)
+      html = ERB.new(template).result(binding.get_binding)
+      html
+    end
+  end
+end

data/lib/bin_packing/export_binding.rb

@@ -0,0 +1,18 @@
+module BinPacking
+  class ExportBinding
+    attr_reader :bins
+
+    def initialize(bins, zoom)
+      @bins = bins
+      @zoom = zoom
+    end
+
+    def zoom(value)
+      (value * @zoom).to_i
+    end
+
+    def get_binding
+      binding
+    end
+  end
+end

data/lib/bin_packing/free_space_box.rb

@@ -0,0 +1,12 @@
+module BinPacking
+  class FreeSpaceBox
+    attr_accessor :x, :y, :width, :height
+
+    def initialize(width, height)
+      @width = width
+      @height = height
+      @x = 0
+      @y = 0
+    end
+  end
+end

data/lib/bin_packing/heuristics/base.rb

@@ -0,0 +1,38 @@
+module BinPacking
+  module Heuristics
+    class Base
+      def find_position_for_new_node!(box, free_rectangles)
+        best_score = BinPacking::Score.new
+        width = box.width
+        height = box.height
+
+        free_rectangles.each do |free_rect|
+          try_place_rect_in(free_rect, box, width, height, best_score)
+          try_place_rect_in(free_rect, box, height, width, best_score)
+        end
+
+        best_score
+      end
+
+      private
+
+      def try_place_rect_in(free_rect, box, rect_width, rect_height, best_score)
+        if free_rect.width >= rect_width && free_rect.height >= rect_height
+          score = calculate_score(free_rect, rect_width, rect_height)
+          if score > best_score
+            box.x = free_rect.x
+            box.y = free_rect.y
+            box.width = rect_width
+            box.height = rect_height
+            box.packed = true
+            best_score.assign(score)
+          end
+        end
+      end
+
+      def calculate_score(free_rect, rect_width, rect_height)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/bin_packing/heuristics/best_area_fit.rb

@@ -0,0 +1,15 @@
+module BinPacking
+  module Heuristics
+    class BestAreaFit < BinPacking::Heuristics::Base
+      private
+
+      def calculate_score(free_rect, rect_width, rect_height)
+        area_fit = free_rect.width * free_rect.height - rect_width * rect_height
+        leftover_horiz = (free_rect.width - rect_width).abs
+        leftover_vert = (free_rect.height - rect_height).abs
+        short_side_fit = [leftover_horiz, leftover_vert].min
+        BinPacking::Score.new(area_fit, short_side_fit)
+      end
+    end
+  end
+end

data/lib/bin_packing/heuristics/best_long_side_fit.rb

@@ -0,0 +1,13 @@
+module BinPacking
+  module Heuristics
+    class BestLongSideFit < BinPacking::Heuristics::Base
+      private
+
+      def calculate_score(free_rect, rect_width, rect_height)
+        leftover_horiz = (free_rect.width - rect_width).abs
+        leftover_vert = (free_rect.height - rect_height).abs
+        BinPacking::Score.new(*[leftover_horiz, leftover_vert].sort.reverse)
+      end
+    end
+  end
+end

data/lib/bin_packing/heuristics/best_short_side_fit.rb

@@ -0,0 +1,13 @@
+module BinPacking
+  module Heuristics
+    class BestShortSideFit < BinPacking::Heuristics::Base
+      private
+
+      def calculate_score(free_rect, rect_width, rect_height)
+        leftover_horiz = (free_rect.width - rect_width).abs
+        leftover_vert = (free_rect.height - rect_height).abs
+        BinPacking::Score.new(*[leftover_horiz, leftover_vert].sort)
+      end
+    end
+  end
+end

data/lib/bin_packing/heuristics/bottom_left.rb

@@ -0,0 +1,12 @@
+module BinPacking
+  module Heuristics
+    class BottomLeft < BinPacking::Heuristics::Base
+      private
+
+      def calculate_score(free_rect, rect_width, rect_height)
+        top_side_y = free_rect.y + rect_height
+        BinPacking::Score.new(top_side_y, free_rect.x)
+      end
+    end
+  end
+end

data/lib/bin_packing/packer.rb

@@ -0,0 +1,34 @@
+module BinPacking
+  class Packer
+    def initialize(bins)
+      @bins = bins
+      @unpacked_boxes = []
+    end
+
+    def pack(boxes, options = {})
+      packed_boxes = []
+      boxes = boxes.reject(&:packed?)
+      return packed_boxes if boxes.none?
+
+      limit = options[:limit] || BinPacking::Score::MAX_INT
+      board = BinPacking::ScoreBoard.new(@bins, boxes)
+      while entry = board.best_fit
+        entry.bin.insert!(entry.box)
+        board.remove_box(entry.box)
+        board.recalculate_bin(entry.bin)
+        packed_boxes << entry.box
+        break if packed_boxes.size >= limit
+      end
+
+      packed_boxes
+    end
+
+    def pack!(boxes)
+      packed_boxes = pack(boxes)
+      if packed_boxes.size != boxes.size
+        raise ArgumentError, "#{boxes.size - packed_boxes.size} boxes not "\
+                            "packed into #{@bins.size} bins!"
+      end
+    end
+  end
+end

data/lib/bin_packing/resources/export.html.erb

@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <style>
+      body {
+        margin: 0;
+      }
+
+      .bin {
+        position: relative;
+        margin: 20px;
+        background: #eee;
+      }
+
+      .bin .label {
+        position: absolute;
+        bottom: 5px;
+        right: 5px;
+      }
+
+      .box {
+        position: absolute;
+        border: 1px solid white;
+        background: #0a0;
+        box-sizing: border-box;
+      }
+
+      .box .box-label {
+        position: absolute;
+        top: 5px;
+        left: 5px;
+        color: #fff;
+      }
+    </style>
+  </head>
+  <body>
+    <div>
+      <% bins.each do |bin| %>
+        <div class="bin" style="width: <%= zoom(bin.width) %>px; height: <%= zoom(bin.height) %>px;">
+          <div>
+            <% bin.boxes.each do |box| %>
+              <div class="box" style="width: <%= zoom(box.width) %>px; height: <%= zoom(box.height) %>px; left: <%= zoom(box.x) %>px; top: <%= zoom(box.y) %>px;">
+                <span class="box-label"><%= box.label %></span>
+              </div>
+            <% end %>
+          </div>
+          <span class="label"><%= bin.label %></span>
+        </div>
+      <% end %>
+  </body>
+</html>

data/lib/bin_packing/score.rb

@@ -0,0 +1,43 @@
+module BinPacking
+  class Score
+    include Comparable
+
+    MAX_INT = (2**(0.size * 8 -2) -1)
+
+    attr_reader :score_1, :score_2
+
+    def self.new_blank
+      new
+    end
+
+    def initialize(score_1 = nil, score_2 = nil)
+      @score_1 = score_1 || MAX_INT
+      @score_2 = score_2 || MAX_INT
+    end
+
+    # Smaller number is greater (used by original algorithm).
+    def <=>(other)
+      if self.score_1 > other.score_1 || (self.score_1 == other.score_1 && self.score_2 > other.score_2)
+        -1
+      elsif self.score_1 < other.score_1 || (self.score_1 == other.score_1 && self.score_2 < other.score_2)
+        1
+      else
+        0
+      end
+    end
+
+    def assign(other)
+      @score_1 = other.score_1
+      @score_2 = other.score_2
+    end
+
+    def is_blank?
+      @score_1 == MAX_INT
+    end
+
+    def decrease_by(delta)
+      @score_1 += delta
+      @score_2 += delta
+    end
+  end
+end

data/lib/bin_packing/score_board.rb

@@ -0,0 +1,64 @@
+#       box_1 box_2 box_3 ...
+# bin_1  100   200    0
+# bin_2   0     5     0
+# bin_3   9    100    0
+# ...
+module BinPacking
+  class ScoreBoard
+    def initialize(bins, boxes)
+      @entries = []
+      bins.each do |bin|
+        add_bin_entries(bin, boxes)
+      end
+    end
+
+    def any?
+      @entries.any?
+    end
+
+    def largest_not_fiting_box
+      unfit = nil
+      fitting_boxes = Set.new(@entries.select(&:fit?).map(&:box))
+      @entries.each do |entry|
+        next if fitting_boxes.include?(entry.box)
+        unfit = entry if unfit.nil? || unfit.box.area < entry.box.area
+      end
+      unfit.try(:box)
+    end
+
+    def best_fit
+      best = nil
+      @entries.each do |entry|
+        next unless entry.fit?
+        best = entry if best.nil? || best.score < entry.score
+      end
+      best
+    end
+
+    def remove_box(box)
+      @entries.delete_if { |e| e.box == box }
+    end
+
+    def add_bin(bin)
+      add_bin_entries(bin, current_boxes)
+    end
+
+    def recalculate_bin(bin)
+      @entries.select { |e| e.bin == bin }.each(&:calculate)
+    end
+
+    private
+
+    def add_bin_entries(bin, boxes)
+      boxes.each do |box|
+        entry = BinPacking::ScoreBoardEntry.new(bin, box)
+        entry.calculate
+        @entries << entry
+      end
+    end
+
+    def current_boxes
+      @entries.map(&:box).uniq
+    end
+  end
+end

data/lib/bin_packing/score_board_entry.rb

@@ -0,0 +1,19 @@
+module BinPacking
+  class ScoreBoardEntry
+    attr_reader :bin, :box, :score
+
+    def initialize(bin, box)
+      @bin = bin
+      @box = box
+      @score = nil
+    end
+
+    def calculate
+      @score = @bin.score_for(@box)
+    end
+
+    def fit?
+      !@score.is_blank?
+    end
+  end
+end

data/lib/bin_packing/version.rb

@@ -0,0 +1,3 @@
+module BinPacking
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: bin_packing
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- MAK IT
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: |
+  Provides algorithm for placing rectangles (box-es) in one or multiple rectangular areas (bins) with reasonable allocation efficiency.
+email: info@makit.lv
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/bin_packing.rb
+- lib/bin_packing/bin.rb
+- lib/bin_packing/box.rb
+- lib/bin_packing/error.rb
+- lib/bin_packing/export.rb
+- lib/bin_packing/export_binding.rb
+- lib/bin_packing/free_space_box.rb
+- lib/bin_packing/heuristics/base.rb
+- lib/bin_packing/heuristics/best_area_fit.rb
+- lib/bin_packing/heuristics/best_long_side_fit.rb
+- lib/bin_packing/heuristics/best_short_side_fit.rb
+- lib/bin_packing/heuristics/bottom_left.rb
+- lib/bin_packing/packer.rb
+- lib/bin_packing/resources/export.html.erb
+- lib/bin_packing/score.rb
+- lib/bin_packing/score_board.rb
+- lib/bin_packing/score_board_entry.rb
+- lib/bin_packing/version.rb
+homepage: http://rubygems.org/gems/bin_packing
+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: 2D bin packing algorithm
+test_files: []