easy-box-packer-plus 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fb6b977f33b387d3733c82b4faec7f1580c5f60e1e467d621751022cfe73d513
+  data.tar.gz: d4a624202c61440e27047d2334f94afbd8a272a1d5f560cc32339ed0abad71d9
+SHA512:
+  metadata.gz: 8ae1deab86f2cec0b1749c87be6298506d4c4e9614abeb5baa5a519adda3dca59ad076a9444d8eb022e9e663a2663b295349449bdf92b04a738b7373432c4d94
+  data.tar.gz: 6b304ad8faea9e6fc00bbca9ae909b03e752f73ca751259ab4250301ad9392c237d895de1eacac977d23e0099cef3d96821e7b6bd086f0d284b969fc24db6a52

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Marcelo Alarcon
+
+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,131 @@
+# EasyBoxPackerPlus
+
+This is a clone of the [gem easy-box-packer](https://github.com/alChaCC/easy-box-packer) with added functionality to pass a hash with custom options for the items. I want to extend my gratitude to the original authors, [@mushishi78](https://github.com/mushishi78) of the [box_packer gem](https://github.com/mushishi78/box_packer/) and [@alChaCC](https://github.com/alChaCC) of the [easy-box-packer gem](https://github.com/alChaCC/easy-box-packer), for their efforts in the algorithm inspired by ["The Three-Dimensional Bin Packing Problem with Heterogeneous Bins"](https://www.researchgate.net/publication/273121476_A_genetic_algorithm_for_the_three-dimensional_bin_packing_problem_with_heterogeneous_bins) and ["A New Heuristic Algorithm for the 3D Bin Packing Problem."](https://www.researchgate.net/publication/226249396_A_New_Heuristic_Algorithm_for_the_3D_Bin_Packing_Problem).
+This gem was created because the latter has not been updated in over six years.
+
+## Installation
+
+Add to gemfile:
+
+``` ruby
+gem 'easy-box-packer-plus', '~> 0.0.4'
+```
+
+## Usage
+
+### Check all items can be packed in a container
+
+``` ruby
+require 'easy-box-packer'
+
+cont = EasyBoxPacker.pack(
+  container: { dimensions: [15, 20, 13], weight_limit: 50 },
+  items: [
+    { dimensions: [2, 3, 5], weight: 47, options: {id: '2221', label: 'green shoes' } },
+    { dimensions: [2, 3, 5], weight: 47, options: {id: '2222', label: 'orange cap' } },
+    { dimensions: [3, 3, 1], weight: 24, options: {id: '2223', label: 'blue jeans' } },
+    { dimensions: [1, 1, 4], weight: 7, options: {id: '2224', label: 'black coat' } },
+  ]
+)
+
+cont[:packings].length # 3
+cont[:packings][0][:weight] # 47
+cont[:packings][0][:placements].length # 1
+cont[:packings][0][:placements][0][:dimensions] # [2, 3, 5]
+cont[:packings][0][:placements][0][:position] # [0, 0, 0]
+cont[:packings][1][:weight] # 47
+cont[:packings][1][:placements].length # 1
+cont[:packings][1][:placements][0][:dimensions] # [2, 3, 5]
+cont[:packings][1][:placements][0][:position] # [0, 0, 0]
+cont[:packings][2][:weight] # 31
+cont[:packings][2][:placements].length # 2
+cont[:packings][2][:placements][0][:dimensions] # [1, 3, 3]
+cont[:packings][2][:placements][0][:position] # [0, 0, 0]
+cont[:packings][2][:placements][1][:dimensions] # [4, 1, 1]
+cont[:packings][2][:placements][1][:position] # [3, 0, 0]
+```
+Now you can access any key you have placed inside the options hash within the items hash:
+```
+{
+  "packings": [{
+    "placements": [{
+      "dimensions": [2, 3, 5],
+      "position": [0, 0, 0],
+      "weight": 47.0,
+      "id": "2222",
+      "label": "orange cap"
+    }],
+    "weight": 47.0,
+    "spaces": [{
+      "dimensions": [18, 15, 13],
+      "position": [2, 0, 0]
+    }, {
+      "dimensions": [2, 12, 13],
+      "position": [0, 3, 0]
+    }, {
+      "dimensions": [2, 3, 8],
+      "position": [0, 0, 5]
+    }]
+  }, {
+    "placements": [{
+      "dimensions": [2, 3, 5],
+      "position": [0, 0, 0],
+      "weight": 47.0,
+      "id": "2221",
+      "label": "green shoes"
+    }],
+    "weight": 47.0,
+    "spaces": [{
+      "dimensions": [18, 15, 13],
+      "position": [2, 0, 0]
+    }, {
+      "dimensions": [2, 12, 13],
+      "position": [0, 3, 0]
+    }, {
+      "dimensions": [2, 3, 8],
+      "position": [0, 0, 5]
+    }]
+  }, {
+    "placements": [{
+      "dimensions": [1, 1, 4],
+      "position": [0, 0, 0],
+      "weight": 7.0,
+      "id": "2224",
+      "label": "black coat"
+    }, {
+      "dimensions": [1, 3, 3],
+      "position": [0, 1, 0],
+      "weight": 24.0,
+      "id": "2223",
+      "label": "blue jeans"
+    }],
+    "weight": 31.0,
+    "spaces": [{
+      "dimensions": [19, 15, 13],
+      "position": [1, 0, 0]
+    }, {
+      "dimensions": [1, 1, 9],
+      "position": [0, 0, 4]
+    }, {
+      "dimensions": [1, 11, 13],
+      "position": [0, 4, 0]
+    }, {
+      "dimensions": [1, 3, 10],
+      "position": [0, 1, 3]
+    }, {
+      "dimensions": [0, 3, 3],
+      "position": [1, 1, 0]
+    }]
+  }],
+  "errors": []
+}
+```
+
+### Get a reasonable smallest container by given boxes
+
+```
+container = EasyBoxPacker.find_smallest_container(
+    items: Array.new(1000) {{ dimensions: [1, 1, 1] }}
+  )
+container # [10, 10, 10]
+```

data/easy-box-packer-plus.rb

@@ -0,0 +1,476 @@
+module EasyBoxPackerPlus
+  class << self
+    def pack(container:, items:)
+      packings = []
+      errors   = []
+      # pack from biggest to smallest
+      items.sort_by { |h| h[:dimensions].sort.reverse }.reverse.each do |item|
+        # If the item is just too big for the container lets give up on this
+        if item[:weight].to_f > container[:weight_limit].to_f
+          errors << "Item: #{item} is too heavy for container"
+          next
+        end
+
+        # 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].to_f + item[:weight].to_f > container[:weight_limit].to_f
+
+          # remove volume size = 0 (not possible to pack)
+          packing[:spaces].reject! { |space| space[:dimensions].inject(:*) == 0 }
+          # try minimum space first
+          packing[:spaces].sort_by { |h| h[:dimensions].sort }.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].to_f.round(2)
+            packing[:spaces] -= [space]
+            packing[:spaces] += break_up_space(space, placement)
+            item_has_been_packed = true
+            break
+          end
+          break if item_has_been_packed
+        end
+        next 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
+        unless placement
+          errors << "Item: #{item} cannot be placed in container"
+          next
+        end
+        # Otherwise lets put the item in a new packing
+        # and break up the remaing free space around it
+        packings += [{
+          placements: [placement],
+          weight: item[:weight].to_f.round(2),
+          spaces: break_up_space(space, placement)
+        }]
+      end
+
+      packings[0][:weight] = packings[0][:weight].round(2)
+      
+      if packings.size > 1 && check_container_is_bigger_than_greedy_box(container, items)
+        { packings: generate_packing_for_greedy_box(items), errors: [] }
+      else
+        { packings: packings, errors: errors }
+      end
+    end
+
+    def find_smallest_container(items:)
+      possible_containers = []
+      invalid_containers  = []
+
+      min_vol = items.map { |h| h[:dimensions].inject(&:*) }.inject(&:+)
+      # order items from biggest to smallest
+      sorted_items = items.sort_by { |h| h[:dimensions].sort }.reverse
+
+      # base_container = sorted_items.first
+      based_container = sorted_items.first
+
+      if sorted_items.size == 1
+        return based_container[:dimensions]
+      end
+
+      find_possible_container(
+        possible_containers: possible_containers,
+        invalid_containers: invalid_containers,
+        container: based_container[:dimensions],
+        items: sorted_items.map {|i| i[:dimensions]},
+        item_index: 1,
+        min_vol: min_vol)
+
+      select_container = possible_containers.map { |a| a.sort }.sort_by { |a| [a.inject(&:*), a.inject(&:+)] }.each do |c|
+        packing = pack(
+          container: { dimensions: c },
+          items: items)
+        break c if packing[:packings].size == 1 && packing[:errors].size == 0
+      end
+      check_container_is_bigger_than_greedy_box({dimensions: select_container}, items) ? item_greedy_box(items) : select_container
+    end
+
+    private
+
+    def std(contents)
+      n = contents.size
+      contents.map!(&:to_f)
+      mean = contents.reduce(&:+)/n
+      sum_sqr = contents.map {|x| x * x}.reduce(&:+)
+      Math.sqrt(((sum_sqr - n * mean * mean)/(n-1)).abs)
+    end
+
+    def find_possible_container(possible_containers:,invalid_containers:,container:, items:, item_index:, min_vol:)
+      return unless items[item_index]
+      c_length, c_width, c_height = container.sort.reverse
+      b_length, b_width, b_height = items[item_index].sort.reverse
+      c_permutations = [
+        [c_width,  c_height, c_length],
+        [c_length, c_width,  c_height],
+        [c_length, c_height, c_width]
+      ]
+      b_permutations = [
+        [b_width,  b_height, b_length],
+        [b_length, b_width,  b_height],
+        [b_length, b_height, b_width]
+      ]
+
+      tmp_possible_containers = []
+      # (1) loops base_container 3 rotations
+      c_permutations.each do |c_perm|
+        # (2) try to puts items to 3 points, then it will create 3 different possible containers
+        b_permutations.each do |b_perm|
+          tmp_possible_containers << [  c_perm[0] + b_perm[0],     [c_perm[1], b_perm[1]].max, [c_perm[2], b_perm[2]].max]
+          tmp_possible_containers << [ [c_perm[0], b_perm[0]].max,  c_perm[1] + b_perm[1],     [c_perm[2], b_perm[2]].max]
+          tmp_possible_containers << [ [c_perm[0], b_perm[0]].max, [c_perm[1], b_perm[1]].max,  c_perm[2]+ b_perm[2]]
+        end
+      end
+      removed_tried_container = tmp_possible_containers.map { |a| a.sort }.uniq - possible_containers - invalid_containers
+
+      return unless removed_tried_container.any?
+      # (3) loop all container from smallest spaces to biggest space
+      removed_tried_container.sort_by { |a| [a.inject(&:*), a.inject(&:+)] }.each do |cont|
+        # (4) next unless l * w * h >= minimum_space
+        if cont.inject(&:*) >= min_vol
+          possible_containers << cont
+        # else
+          # puts "invalid: #{cont}"
+          # invalid_containers << cont
+          # find_possible_container(possible_containers: possible_containers, invalid_containers: invalid_containers, container: cont, items: items, item_index: item_index + 1, min_vol: min_vol)
+        end
+      end
+      # minimum_space = (removed_tried_container).sort_by { |a| [a.inject(&:*), a.inject(&:+)] }.first
+      minimum_std = removed_tried_container.sort_by { |a| [std(a), a.inject(&:*), a.inject(&:+)] }.first
+      [minimum_std].uniq.compact.each do |cont|
+        find_possible_container(possible_containers: possible_containers, invalid_containers: invalid_containers, container: cont, items: items, item_index: item_index + 1, min_vol: min_vol)
+      end
+    end
+
+    def place(item, space)
+      item_length, item_width, item_height = 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]
+      ]
+
+      possible_rotations_and_margins = []
+
+      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]
+
+        possible_margin   = [space[:dimensions][0] - perm[0], space[:dimensions][1] - perm[1], space[:dimensions][2] - perm[2]]
+        possible_rotations_and_margins << { margin: possible_margin, rotation: perm }
+      end
+
+      # select rotation with smallest margin
+      final = possible_rotations_and_margins.sort_by { |a| a[:margin].sort }.first
+      return unless final
+      
+      result = {
+        dimensions: final[:rotation].map {|dim| (dim).round(2)},
+        position: space[:position].map {|dim| (dim).round(2)},
+        weight: item[:weight].to_f,
+      }
+      
+      unless item[:options].nil?
+        item[:options].each {|k,v| result[k] = v }
+      end
+      
+      result
+    end
+
+    def break_up_space(space, placement)
+      return_possible_spaces = [
+        # HEIGHT SPACE => WIDTH  => LENGTH
+        [
+          {
+            dimensions: [
+              space[:dimensions][0],
+              space[:dimensions][1],
+              space[:dimensions][2] - placement[:dimensions][2]
+            ],
+            position: [
+              space[:position][0],
+              space[:position][1],
+              space[:position][2] + placement[:dimensions][2]
+            ]
+          },
+          {
+            dimensions: [
+              space[:dimensions][0],
+              space[:dimensions][1] - placement[:dimensions][1],
+              placement[:dimensions][2]
+            ],
+            position: [
+              space[:position][0],
+              space[:position][1] + placement[:dimensions][1],
+              space[:position][2]
+            ]
+          },
+          {
+            dimensions: [
+              space[:dimensions][0] - placement[:dimensions][0],
+              placement[:dimensions][1],
+              placement[:dimensions][2]
+            ],
+            position: [
+              space[:position][0] + placement[:dimensions][0],
+              space[:position][1],
+              space[:position][2]
+            ]
+          }
+        ],
+        # HEIGHT SPACE => LENGTH => WIDTH
+        [
+          {
+            dimensions: [
+              space[:dimensions][0],
+              space[:dimensions][1],
+              space[:dimensions][2] - placement[:dimensions][2]
+            ],
+            position: [
+              space[:position][0],
+              space[:position][1],
+              space[:position][2] + placement[:dimensions][2]
+            ]
+          },
+          {
+            dimensions: [
+              space[:dimensions][0] - placement[:dimensions][0],
+              space[:dimensions][1],
+              placement[:dimensions][2]
+            ],
+            position: [
+              space[:position][0] + placement[:dimensions][0],
+              space[:position][1],
+              space[:position][2]
+            ]
+          },
+          {
+            dimensions: [
+              placement[:dimensions][0],
+              space[:dimensions][1] - placement[:dimensions][1],
+              placement[:dimensions][2]
+            ],
+            position: [
+              space[:position][0],
+              space[:position][1] + placement[:dimensions][1],
+              space[:position][2]
+            ]
+          }
+        ],
+        # LENGTH SPACE => HEIGHT => WIDTH
+        [
+          {
+            dimensions: [
+              space[:dimensions][0] - placement[:dimensions][0],
+              space[:dimensions][1],
+              space[:dimensions][2]
+            ],
+            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][2]
+            ],
+            position: [
+              space[:position][0],
+              space[:position][1],
+              space[:position][2] + placement[:dimensions][2]
+            ]
+          },
+          {
+            dimensions: [
+              placement[:dimensions][0],
+              space[:dimensions][1] - placement[:dimensions][1],
+              placement[:dimensions][2]
+            ],
+            position: [
+              space[:position][0],
+              space[:position][1] + placement[:dimensions][1],
+              space[:position][2]
+            ]
+          }
+        ],
+        # LENGTH SPACE => WIDTH  => HEIGHT
+        [
+          {
+            dimensions: [
+              space[:dimensions][0] - placement[:dimensions][0],
+              space[:dimensions][1],
+              space[:dimensions][2]
+            ],
+            position: [
+              space[:position][0] + placement[:dimensions][0],
+              space[:position][1],
+              space[:position][2]
+            ]
+          },
+          {
+            dimensions: [
+              placement[:dimensions][0],
+              space[:dimensions][1] - placement[:dimensions][1],
+              space[:dimensions][2]
+            ],
+            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]
+            ]
+          }
+        ],
+        # WIDTH SPACE  => LENGTH => HEIGHT
+        [
+          {
+            dimensions: [
+              space[:dimensions][0],
+              space[:dimensions][1] - placement[:dimensions][1],
+              space[:dimensions][2]
+            ],
+            position: [
+              space[:position][0],
+              space[:position][1] + placement[:dimensions][1],
+              space[:position][2]
+            ]
+          },
+          {
+            dimensions: [
+              space[:dimensions][0] - placement[:dimensions][0],
+              placement[:dimensions][1],
+              space[:dimensions][2]
+            ],
+            position: [
+              space[:position][0] + placement[:dimensions][0],
+              space[:position][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]
+            ]
+          }
+        ],
+        # WIDTH SPACE  => HEIGHT => LENGTH
+        [
+          {
+            dimensions: [
+              space[:dimensions][0],
+              space[:dimensions][1] - placement[:dimensions][1],
+              space[:dimensions][2]
+            ],
+            position: [
+              space[:position][0],
+              space[:position][1] + placement[:dimensions][1],
+              space[:position][2]
+            ]
+          },
+          {
+            dimensions: [
+              space[:dimensions][0],
+              placement[:dimensions][1],
+              space[:dimensions][2] - placement[:dimensions][2]
+            ],
+            position: [
+              space[:position][0],
+              space[:position][1],
+              space[:position][2] + placement[:dimensions][2]
+            ]
+          },
+          {
+            dimensions: [
+              space[:dimensions][0] - placement[:dimensions][0],
+              placement[:dimensions][1],
+              placement[:dimensions][2]
+            ],
+            position: [
+              space[:position][0] + placement[:dimensions][0],
+              space[:position][1],
+              space[:position][2]
+            ]
+          }
+        ]
+      ]
+      # PICK biggest
+      dim_array = return_possible_spaces.sort_by { |a| a.map {|aa| aa[:dimensions].sort}}.last
+
+      result = dim_array&.map do |elem|
+        elem.transform_values do |value|
+          value.map { |v| v.round(2) }
+        end
+      end
+      
+      result
+    end
+ 
+    def item_greedy_box(items)
+      array_of_lwh            = items.map { |i| i[:dimensions].sort.reverse }
+      items_max_length        = array_of_lwh.max { |x, y| x[0] <=> y[0] }[0]
+      items_max_width         = array_of_lwh.max { |x, y| x[1] <=> y[1] }[1]
+      items_total_height      = array_of_lwh.inject(0) { |sum, x| sum+=x[2] }.round(1)
+      [items_max_length, items_max_width, items_total_height]
+    end
+
+    def check_container_is_bigger_than_greedy_box(container, items)
+      c = container[:dimensions].sort.reverse
+      greedy_box = item_greedy_box(items)
+      c[0] >= greedy_box[0] && c[1] >= greedy_box[1] && c[2] >= greedy_box[2] && container[:weight_limit].to_f >= items.inject(0) { |sum, i| sum += i[:weight].to_f }
+    end
+
+    def generate_packing_for_greedy_box(items)
+      return_h = {placements: [], weight: 0, spaces: []}
+      height   = 0
+      items.each do |i|
+        return_h[:placements] << { dimensions: i[:dimensions], :position=>[0, 0, height], weight: i[:weight].to_f }
+        return_h[:weight] += i[:weight].to_f
+        height += i[:dimensions].sort.first.to_f
+      end
+      [return_h]
+    end
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: easy-box-packer-plus
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Marcelo Alarcon
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-07-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  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:
+email: marceloalarconbarrenechea@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- easy-box-packer-plus.rb
+homepage: https://github.com/chelobotix/easy-box-packer-plus
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- "."
+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: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: 3D bin-packing with weight limit using first-fit decreasing algorithm. The
+  functionality has been extended to include an internal options hash, allowing any
+  desired values to be passed to the items, such as IDs and labels for each item.
+  This ensures that when the gem returns the result, these keys are included in the
+  output.
+test_files: []