py3dbl 1.0.0__tar.gz

py3dbl-1.0.0/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+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.

py3dbl-1.0.0/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: py3dbl
+Version: 1.0.0
+Summary: A powerful tool for 3D bin packing problem solving
+Author-email: Giuliano Pardini <giulianpardini@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Giulian7/py3dbl
+Project-URL: Issues, https://github.com/Giulian7/py3dbl/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# About this project
+
+	This project is a complete  
+
+# How to run and test
+
+	1. Clone this repository on your machine
+	2. Create a virtual enviroment (e.g. *python3 -m venv "enviroment_name"*)
+	3. Install the required packages as of *requirements.txt* (e.g. *pip install -r requirements.txt*)
+	4. Execute *test.ipynb* and enjoy the visit (to execute a jupyter notebook simply run *jupyter notebook "notebook_name"*)

py3dbl-1.0.0/README.md

@@ -0,0 +1,10 @@
+# About this project
+
+	This project is a complete  
+
+# How to run and test
+
+	1. Clone this repository on your machine
+	2. Create a virtual enviroment (e.g. *python3 -m venv "enviroment_name"*)
+	3. Install the required packages as of *requirements.txt* (e.g. *pip install -r requirements.txt*)
+	4. Execute *test.ipynb* and enjoy the visit (to execute a jupyter notebook simply run *jupyter notebook "notebook_name"*)

py3dbl-1.0.0/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "py3dbl"
+version = "1.0.0"
+authors = [
+  { name="Giuliano Pardini", email="giulianpardini@gmail.com" },
+]
+description = "A powerful tool for 3D bin packing problem solving"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+Homepage = "https://github.com/Giulian7/py3dbl"
+Issues = "https://github.com/Giulian7/py3dbl/issues"

py3dbl-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

py3dbl-1.0.0/src/py3dbl/__init__.py

@@ -0,0 +1,8 @@
+from py3dbl_core.Packer import Packer
+from py3dbl_core.Bin import Bin, BinModel
+from py3dbl_core.Item import Item
+from py3dbl_core.Space import Volume, Vector3
+from .item_generator import item_generator
+from .render import render_bin_interactive, render_item_interactive, render_volume_interactive
+from py3dbl_core.Constraints import Constraint, constraint, constraints
+from py3dbl_core.Algorithms import PackingAlgorithm, algorithm, algorithms

py3dbl-1.0.0/src/py3dbl/benchmark.py

@@ -0,0 +1,3 @@
+#import benchmarking as b
+#from py3dbl.Constraints import constraints
+#b.packing_benchmarker(["py3dbp","base_packer"],[constraints['weight_within_limit'],constraints['fits_inside_bin'],constraints['no_overlap']],end=300,start=100)

py3dbl-1.0.0/src/py3dbl/benchmarking.py

@@ -0,0 +1,115 @@
+import py3dbl
+import time
+import platform
+from datetime import datetime
+
+START = 100
+STEP = 100
+ITER = 3
+
+BIN_PARAMS = {
+    "width":2,
+    "depth":2,
+    "height":2,
+    "max_weight":100
+}
+
+ITEM_PARAMS = {
+    "width":(.1,1),
+    "depth":(.1,1),
+    "height":(.1,1),
+    "weight":(.1,1)
+}
+
+def packing_benchmarker(algorithms : list[str], constraints : list[py3dbl.Constraints.Constraint], end : int, start : int = START, step : int = 100, bin_params : dict = BIN_PARAMS, item_params : dict = ITEM_PARAMS, iterations : int = ITER, output_file : str = "benchmarking_result.txt"):
+    """
+    Put the listed algorithms in the same conditions (constraints set, item batch, model, ecc.) and test it for the number of times set by iterations
+    
+    :param algorithms: List names of algorithms to use, the name should be a registred in py3dbl.algorithms or py3dbp
+    """
+    
+    model = py3dbl.BinModel(None,[bin_params['width'],bin_params['height'],bin_params['depth']],bin_params['max_weight'],constraints)
+    def packer_from_algorithm(algorithm : str):
+        if algorithm == 'py3dbp':
+            # in case of py3dbp I need to adjust the packer interface
+            import py3dbp
+            def _add_batch(packer,batch):
+                for i in batch:
+                    packer.items.append(py3dbp.Item(None,i.width,i.height,i.depth,i.weight))
+                    packer.bins.append(py3dbp.Bin(None,bin_params['width'],bin_params['height'],bin_params['depth'],bin_params['max_weight']))
+            def _reset_items(self):
+                self.items = list()
+                self.bins = list()
+            packer = py3dbp.Packer()
+            packer.reset_items = (lambda :_reset_items(packer))
+            packer.add_batch = (lambda batch: _add_batch(packer, batch))
+            packer.pack = (lambda : py3dbp.Packer.pack(packer,distribute_items=True))
+            def _count_bin(packer):
+                idx = 0
+                for bin in packer.bins:
+                    if len(bin.items) == 0:
+                        break
+                    idx += 1
+                return idx
+            packer.used_bins = (lambda : _count_bin(packer))
+        else:
+            packer = py3dbl.Packer(algorithm=py3dbl.algorithms[algorithm],default_bin=model)
+            packer.used_bins = (lambda : len(packer.current_configuration))
+        packer.name = algorithm
+        return packer
+    
+    packers = [packer_from_algorithm(algorithm) for algorithm in algorithms]
+
+    results = dict()
+    with open(output_file,mode="a",newline='') as file:
+        file.write(("="*10)+datetime.now().strftime("%Y-%m-%d %H:%M:%S")+("="*10)+"\n")
+        file.write("System Information:\n")
+        uname = platform.uname()
+        file.writelines([
+            f" System: {uname.system}\n",
+            f" Node Name: {uname.node}\n",
+            f" Release: {uname.release}\n",
+            f" Version: {uname.version}\n",
+            f" Machine: {uname.machine}\n",
+            f" Processor: {uname.processor}\n"
+        ])
+        file.write("Banchmarking Parameters:\n")
+        file.writelines([
+            " items dimensions:\n",
+            *["  "+str(param)+": "+str(value)+"\n" for param,value in item_params.items()],
+            " bin parameters:\n",
+            *["  "+str(param)+": "+str(value)+"\n" for param,value in bin_params.items()],
+            " constraints:\n",
+            *["  "+str(constraint)+"\n" for constraint in constraints]
+        ])
+        for size in range(start,end+1,step):
+            results[size] = dict()
+            for algorithm in algorithms:
+                results[size][algorithm] = {"time":0,"bins":0}
+            for _ in range(iterations):
+                items = py3dbl.item_generator(
+                    width=item_params['width'],
+                    height=item_params['height'],
+                    depth=item_params['depth'],
+                    weight=item_params['weight'],
+                    batch_size=size,
+                    use_gaussian_distrib=False
+                )
+                for packer in packers:
+                    packer.reset_items()
+                    packer.add_batch(items)
+                    start = time.time()
+                    packer.pack()
+                    end = time.time()
+                    results[size][packer.name]["time"] += end-start
+                    results[size][packer.name]["bins"] += packer.used_bins()
+                    
+
+            file.write(str(size)+" items:\n")
+            for algorithm,result in results[size].items():
+                result["time"] /= iterations
+                result["bins"] /= iterations
+                file.write(" " + algorithm + ":\n")
+                file.write("  time: " + str(round(result["time"],2)) + ", bins: " + str(round(result["bins"],2)) + "\n")
+
+        return results

py3dbl-1.0.0/src/py3dbl/item_generator.py

@@ -0,0 +1,60 @@
+from decimal import Decimal
+from random import random,randint,gauss
+from py3dbl_core.Item import Item
+from py3dbl_core.Space import Vector3, Volume
+
+def item_generator(width : tuple[Decimal,Decimal] , height : tuple[Decimal,Decimal], depth : tuple[Decimal,Decimal], weight : tuple[Decimal,Decimal], priority_range : tuple[int,int] = (0,0), batch_size : int = 1, use_gaussian_distrib : bool = False, decimals : int = 3) -> Item|list[Item]:
+    """
+    Generate Item objects with the given specifics
+    
+    :param width: Width min-max range or mu-sigma params
+    :type width: tuple[Decimal, Decimal]
+    :param height: Height min-max range or mu-sigma params
+    :type height: tuple[Decimal, Decimal]
+    :param depth: Depth min-max range or mu-sigma params
+    :type depth: tuple[Decimal, Decimal]
+    :param weight: Weight min-max range or mu-sigma params
+    :type weight: tuple[Decimal, Decimal]
+    :param priority_range: Priority min-max range
+    :type priority_range: tuple[int, int]
+    :param batch_size: Number of items to generate
+    :type batch_size: int
+    :param use_gaussian_distrib: if True size and weight are gaussian varibles and width,height,depth and weight are the mu-sigma params associated, if False size and weight are simple random variables and width,height,depth and weight are the minimum and maximum values
+    :type use_gaussian_distrib: bool
+    """
+    
+    randf = (lambda mu,sigma: abs(gauss(mu,sigma))) if use_gaussian_distrib else (lambda min,max: abs(min+random()*(max-min)))
+    
+    if batch_size == 1:
+        ret = Item(
+            name    = None,
+            volume  = Volume(
+                size = Vector3(
+                    x=Decimal(randf(width[0],width[1])),
+                    y=Decimal(randf(height[0],height[1])),
+                    z=Decimal(randf(depth[0],depth[1]))
+                )
+            ),
+            weight  = Decimal(randf(weight[0],weight[1])),
+            priority= (randint(priority_range[0],priority_range[1]))
+        )
+        ret.format_numbers(decimals)
+        return ret
+    else:
+        items = []
+        for i in range(0,batch_size):
+            item = Item(
+                name    = str(i),
+                volume  = Volume(
+                    size = Vector3(
+                        x=Decimal(randf(width[0],width[1])),
+                        y=Decimal(randf(height[0],height[1])),
+                        z=Decimal(randf(depth[0],depth[1]))
+                    )
+                ),
+                weight  = Decimal(randf(weight[0],weight[1])),
+                priority= (randint(priority_range[0],priority_range[1]))
+            )
+            item.format_numbers(decimals)
+            items.append(item)
+        return items

py3dbl-1.0.0/src/py3dbl/render.py

@@ -0,0 +1,78 @@
+import plotly.graph_objects as go
+from py3dbl_core.Bin import Bin
+from py3dbl_core.Item import Item
+from py3dbl_core.Space import Volume
+
+COLORS = ["cyan","red","yellow","blue","green","brown","magenta"]
+BORDER_WIDTH = 1
+BORDER_COLOR = "black"
+TRANSPARENCY = .5
+
+def render_volume_interactive(volume : Volume, fig : go.Figure, color : str, name : str = "", show_border : bool = True, border_width : float = BORDER_WIDTH, border_color : str = BORDER_COLOR, transparency : float = TRANSPARENCY):   
+    """
+    An interactive 3D rendering of a volume object
+    
+    :param volume: Target volume
+    :type volume: Volume
+    :param fig: A go figure as rendering target
+    :type fig: go.Figure
+    :param color: Color of the rendered volume
+    :type color: str
+    :param name: A name to associate to the volume
+    :type name: str
+    :param border_width: Size of the volume's border
+    :type border_width: float
+    :param border_color: Color of the volume's border
+    :type border_color: str
+    :param transparency: Transparency of the object
+    :type transparency: float
+    """
+    x, y, z = [float(value) for value in volume.position]   # position from bottom-back-left corner
+    w, h, d = [float(value) for value in volume.size] # actual dimensions of the item (considered rotation)
+    fig.add_trace(go.Mesh3d(
+            x=[x, x+w, x+w, x, x, x+w, x+w, x],
+            z=[y, y, y+h, y+h, y, y, y+h, y+h],
+            y=[z, z, z, z, z+d, z+d, z+d, z+d],
+            contour_show = show_border,
+            contour_width= border_width,
+            contour_color= border_color,
+            color=color,
+            opacity= (1.0 - transparency),
+            name=name,
+            alphahull=0,
+            showscale=False
+        ))
+    
+def render_item_interactive(item : Item, fig : go.Figure, color : str, show_border : bool = True, border_width : float = BORDER_WIDTH, border_color : str = BORDER_COLOR, transparency : float = TRANSPARENCY):
+    render_volume_interactive(item,fig,color,item.name,show_border,border_width,border_color,transparency)
+
+def render_bin_interactive(bin : Bin, colors : list[str] = COLORS, render_bin : bool = True, border_width : float = BORDER_WIDTH, border_color : str = BORDER_COLOR, transparency : float = TRANSPARENCY):
+
+    fig = go.Figure()
+
+    bin_render_params = {
+        "color": "lightgrey",
+        "name": "Bin",
+        "show_border": False
+    }
+
+    for dead_volume in bin._model.dead_volumes:
+         render_volume_interactive(volume=dead_volume,fig=fig,transparency=.1,**bin_render_params)
+
+    for idx,item in enumerate(bin.items):
+        render_item_interactive(item=item,fig=fig,color=colors[idx%len(colors)],border_width=border_width,border_color=border_color,transparency=transparency)
+
+    if render_bin:
+        render_volume_interactive(Volume(bin.dimensions),fig=fig,transparency=.9,**bin_render_params)
+
+    fig.update_layout(
+        scene=dict(
+            xaxis=dict(title='Width'),
+            zaxis=dict(title='Height'),
+            yaxis=dict(title='Depth'),
+            aspectmode='data'
+        ),
+        title=f"3D Packing Visualization - {bin}"
+    )
+
+    fig.show()

py3dbl-1.0.0/src/py3dbl/using_py3dbl.py

@@ -0,0 +1,21 @@
+import py3dbl
+
+packer = py3dbl.Packer(algorithm=py3dbl.algorithms['base_packer'])
+packer.set_default_bin(py3dbl.BinModel(
+    name="Container",
+    size=[2,2,4],
+    max_weight=3000,
+    constraints=[
+        py3dbl.constraints['weight_within_limit'],
+        py3dbl.constraints['fits_inside_bin'],
+        py3dbl.constraints['no_overlap']
+        ],
+    ))
+packer.add_batch(py3dbl.item_generator(
+    width=(.1,1),
+    height=(.1,1),
+    depth=(.1,1),
+    weight=(.1,1),
+    batch_size=100
+))
+packer.pack()

py3dbl-1.0.0/src/py3dbl.egg-info/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: py3dbl
+Version: 1.0.0
+Summary: A powerful tool for 3D bin packing problem solving
+Author-email: Giuliano Pardini <giulianpardini@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Giulian7/py3dbl
+Project-URL: Issues, https://github.com/Giulian7/py3dbl/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# About this project
+
+	This project is a complete  
+
+# How to run and test
+
+	1. Clone this repository on your machine
+	2. Create a virtual enviroment (e.g. *python3 -m venv "enviroment_name"*)
+	3. Install the required packages as of *requirements.txt* (e.g. *pip install -r requirements.txt*)
+	4. Execute *test.ipynb* and enjoy the visit (to execute a jupyter notebook simply run *jupyter notebook "notebook_name"*)

py3dbl-1.0.0/src/py3dbl.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+README.md
+pyproject.toml
+src/py3dbl/__init__.py
+src/py3dbl/benchmark.py
+src/py3dbl/benchmarking.py
+src/py3dbl/item_generator.py
+src/py3dbl/render.py
+src/py3dbl/using_py3dbl.py
+src/py3dbl.egg-info/PKG-INFO
+src/py3dbl.egg-info/SOURCES.txt
+src/py3dbl.egg-info/dependency_links.txt
+src/py3dbl.egg-info/top_level.txt
+src/py3dbl_core/Algorithms.py
+src/py3dbl_core/Bin.py
+src/py3dbl_core/Constraints.py
+src/py3dbl_core/Decimal.py
+src/py3dbl_core/Item.py
+src/py3dbl_core/Packer.py
+src/py3dbl_core/Space.py

py3dbl-1.0.0/src/py3dbl.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

py3dbl-1.0.0/src/py3dbl.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+py3dbl
+py3dbl_core