Initial Commit

Author: amithkk

.gitignore

@@ -0,0 +1,153 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintainted in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+output.json

README.md

@@ -0,0 +1,31 @@
+# BinPack Solver With Instructions
+
+## Setup Instructions
+
+1. Create a virtualenv with `python -m virtualenv venv`
+2. Activate the virtualenv (using appropriate script in venv/Scripts)
+3. Install dependencies with `pip install -r requirements.txt`
+
+## Running the solver
+
+1. Place input parameters in `input.json`
+2. Run `python main.py`
+3. Output will be presented in `output.json`, statistics of the packing will be displayed on the terminal
+
+
+## Visualization
+
+![](img/viz.png)
+
+To visualize your packing process , go to [binpack-viewer.amith.ml](https://binpack-viewer.amith.ml/) and drag and drop the generated `viz.json` file
+
+
+## Example Output
+
+
+```
+❯ python main.py
+Completed solving with 93.07% fill. (6.93% trim loss)
+Generated 45 instructions after simplification.
+Find results in output.json
+```

img/viz.png

@@ -0,0 +1,19 @@
+{
+    "container": {
+        "l": "19.4ft",
+        "w": "7.8ft",
+        "h": "8.6ft"
+    },
+    "carton_small": {
+        "l": "12in",
+        "w": "18in",
+        "h": "24in",
+        "count": 300
+    },
+    "carton_big": {
+        "l": "24in",
+        "w": "18in", 
+        "h": "36in", 
+        "count": 250
+    }
+}

input.json

@@ -0,0 +1,63 @@
+from pack_solver import *
+from itertools import groupby
+
+def rot_instruction(box: SolvedBox):
+    rot = box.position.rotation
+    if rot == Rotation.ORIGINAL:
+        return 'Place'
+    else:
+        return 'Rotate sideways and place'
+
+
+def row_reset(x1, y1, z1, x2, y2, z2):
+    st = 'on the next row'
+    if y2 > y1:
+        st = f'{st} on top'
+    elif z2 > z1:
+        st = f'{st} in front'
+    return st
+
+
+def rel_placement(x1, y1, z1, x2, y2, z2):
+    end = 'the previous box'
+    if x2 == 0 and x1 != x2:
+        return row_reset(x1, y1, z1, x2, y2, z2)
+    if x2 > x1:
+        return f'to the right of {end}'
+    elif x2 < x1:
+        return f'to the left of {end}'
+    elif y2 > y1:
+        return f'above {end}'
+    elif y2 < y1:
+        return f'below {end}'
+    elif z2 < z1:
+        return f'in front of {end}'
+    elif z2 > z1:
+        return f'behind {end}'
+
+def simplify_instructions(instructions: List):
+    simplified_instructions = []
+    for k, g in groupby(instructions):
+        repeat_c = len(list(g))
+        if repeat_c == 1:
+            simplified_instructions.append(f'{k[0]} {k[1]}')
+        else:
+            simplified_instructions.append(f'{k[0]} {repeat_c} of {k[1]}')
+    return simplified_instructions
+
+
+def make_instructions(solved_container: SolvedContainer):
+    instructions_expanded = []
+    for i, box in enumerate(solved_container.solved_boxes): 
+        if i == 0:
+            instructions_expanded.append(
+            [f'To start stacking, {rot_instruction(box)}', f'{box.name} at left-back of container'])
+            continue
+        prev = solved_container.solved_boxes[i-1]
+        px, py, pz = prev.position.x, prev.position.y, prev.position.z
+        x, y, z = box.position.x, box.position.y, box.position.z
+        instructions_expanded.append(
+        [rot_instruction(box), f'{box.name} {rel_placement(px,py,pz,x,y,z)}'])
+    return simplify_instructions(instructions_expanded)
+
+

instruction_encode.py

@@ -0,0 +1,64 @@
+import json
+from pack_solver import *
+from instruction_encode import make_instructions
+from pint import UnitRegistry
+from visualize import make_visuals
+
+ureg = UnitRegistry()
+Q_ = ureg.Quantity
+
+problem_input = None
+with open("input.json", "r") as infile:
+    problem_input = json.load(infile)
+
+
+def to_inch(x: str):
+    return round(Q_(x).to("inch").to_tuple()[0], 2)
+
+
+container_dimensions = Dimension(to_inch(problem_input["container"]["l"]),
+                                 to_inch(problem_input["container"]["w"]),
+                                 to_inch(problem_input["container"]["h"]))
+
+carton_small_dimensions = Dimension(to_inch(problem_input["carton_small"]["l"]),
+                                    to_inch(
+                                        problem_input["carton_small"]["w"]),
+                                    to_inch(problem_input["carton_small"]["h"]))
+
+carton_big_dimensions = Dimension(to_inch(problem_input["carton_big"]["l"]),
+                                  to_inch(problem_input["carton_big"]["w"]),
+                                  to_inch(problem_input["carton_big"]["h"]))
+
+
+packer = Packer()
+packer.add_container(Container("Container", container_dimensions))
+packer.add_boxes(Box("carton_small", carton_small_dimensions,
+                 problem_input["carton_small"]["count"]))
+packer.add_boxes(Box("carton_big", carton_big_dimensions,
+                 problem_input["carton_big"]["count"]))
+packing_results = packer.pack()
+
+container = packing_results[0]
+boxes = container.solved_boxes
+
+carton_small_count = len(
+    list(filter(lambda x: x.name == "carton_small", boxes)))
+carton_big_count = len(list(filter(lambda x: x.name == "carton_big", boxes)))
+instructions = make_instructions(packing_results[0])
+out_payload = {
+    "carton_small": carton_small_count,
+    "carton_big": carton_big_count,
+    "instructions": instructions
+}
+
+with open("output.json", "w") as outfile:
+    outfile.write(json.dumps(out_payload, indent=4))
+
+with open("viz.json", "w") as outfile:
+    outfile.write(json.dumps(make_visuals(packer.containers[0], container), indent=4))
+
+print(
+    f"Completed solving with {container.percentage_fill:.2f}% fill. ({100-container.percentage_fill:.2f}% trim loss)")
+print(f"Generated {len(instructions)} instructions after simplification.")
+print("Find results in output.json")
+print("Visualization output created as viz.json")