[ { "path": ".gitignore", "content": "__pycache__\n.idea" }, { "path": "LICENSE", "content": "MIT License\n\nCopyright (c) 2020 Emad Ehsan\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n" }, { "path": "Pipfile", "content": "[[source]]\nurl = \"https://pypi.org/simple\"\nverify_ssl = true\nname = \"pypi\"\n\n[packages]\nortools = \"*\"\npytest = \"*\"\nmatplotlib = \"*\"\ntyper = \"*\"\n\n[dev-packages]\n\n[requires]\npython_version = \"3.9\"\n" }, { "path": "README.md", "content": "# Cutting Stock Problem\nCutting Stock Problem (CSP) deals with planning the cutting of items (rods / sheets) from given stock items (which are usually of fixed size).\n\n## New to Cutting Stock Problem? Understand Visually\n\n\t\"Video\n\n\n\nThis implementation of CSP tries to answer\n> How to minimize number of stock items used while cutting customer order\n\n\nwhile doing so, it also caters\n> How to cut the stock for customer orders so that waste is minimum\n\n\nThe OR Tools also helps us in calculating the number of possible solutions for your problem. So in addition, we can also compute\n> In how many ways can we cut given order from fixed size Stock?\n\n\n## Quick Usage\nThis is how CSP Tools looks in action. Click [CSP Tool](https://emadehsan.com/csp/) to use it\n\n\t\"CSP\n\n\n## Libraries\n* [Google OR-Tools](https://developers.google.com/optimization)\n\n## Quick Start\nInstall [Pipenv](https://pipenv.pypa.io/en/latest/), if not already installed\n```sh\n$ pip3 install --user pipenv\n```\n\nClone this project and install packages\n```sh\n$ git clone https://github.com/emadehsan/csp\n$ cd csp\n$ pipenv install\n\n# activate env\n$ pipenv shell\n```\n\n## Run\nIf you run the `stock_cutter_1d.py` file directly, it runs the example which uses 120 as length of stock Rod and generates some customer rods to cut. You can update these at the end of `stock_cutter_1d.py`.\n```sh\n(csp) $ python csp/stock_cutter_1d.py\n```\n\nOutput:\n\n```sh\nnumRollsUsed 5\nStatus: OPTIMAL\nRoll #0: [0.0, [33, 33, 18, 18, 18]]\nRoll #1: [2.9999999999999925, [33, 30, 18, 18, 18]]\nRoll #2: [5.999999999999993, [30, 30, 18, 18, 18]]\nRoll #3: [2.9999999999999987, [33, 33, 33, 18]]\nRoll #4: [21.0, [33, 33, 33]]```\n```\n\n![Graph of Output](./github/graph-1d-b.PNG)\n\n\n### Using input file\nIf you want to describe your inputs in a file, [infile.txt](./infile.txt) describes the expected format\n\n```sh\n(csp) $ python3 csp/stock_cutter_1d.py infile.txt\n```\n\n\n## Thinks to keep in mind\n* Works with integers only: IP (Integer Programming) problems working with integers only. If you have some values that have decimal part, you can multiply all of your inputs with some number that will make them integers (or close estimation).\n* You cannot specify units: Whether your input is in Inches or Meters, you have to keep a record of that yourself and conversions if any.\n\n\n## CSP 2D\nCode for 2-dimensional Cutting Stock Problem is in [`deployment/stock_cutter.py`](deployment/stock_cutter.py) file. The `deployment` directory also contains code for the API server and deploying it on Heroku.\n\n## Resources\nThe whole code for this project is taken from Serge Kruk's\n* [Practical Python AI Projects: Mathematical Models of Optimization Problems with Google OR-Tools](https://amzn.to/3iPceJD)\n* [Repository of the code in Serge's book](https://github.com/sgkruk/Apress-AI/)\n" }, { "path": "csp/__init__.py", "content": "" }, { "path": "csp/read_lengths.py", "content": "import pathlib\nfrom typing import List\nimport re\nfrom math import ceil\ndef get_data(infile:str)->List[float]:\n \"\"\" Reads a file of numbers and returns a list of (count, number) pairs.\"\"\"\n _p = pathlib.Path(infile)\n input_text = _p.read_text()\n numbers = [ceil(float(n)) for n in re.findall(r'[0-9.]+', _p.read_text())]\n quan = []\n nr = []\n for n in numbers:\n if n not in nr and n != 0:\n quan.append(numbers.count(n))\n nr.append(n)\n return list(zip(quan,nr))\n\n" }, { "path": "csp/stock_cutter_1d.py", "content": "'''\nOriginal Author: Serge Kruk\nOriginal Version: https://github.com/sgkruk/Apress-AI/blob/master/cutting_stock.py\n\nUpdated by: Emad Ehsan\n'''\nfrom ortools.linear_solver import pywraplp\nfrom math import ceil\nfrom random import randint\nimport json\nfrom read_lengths import get_data\nimport typer\nfrom typing import Optional\n\ndef newSolver(name,integer=False):\n return pywraplp.Solver(name,\\\n pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING \\\n if integer else \\\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\n\n'''\nreturn a printable value\n'''\ndef SolVal(x):\n if type(x) is not list:\n return 0 if x is None \\\n else x if isinstance(x,(int,float)) \\\n else x.SolutionValue() if x.Integer() is False \\\n else int(x.SolutionValue())\n elif type(x) is list:\n return [SolVal(e) for e in x]\n\ndef ObjVal(x):\n return x.Objective().Value()\n\n\ndef gen_data(num_orders):\n R=[] # small rolls\n # S=0 # seed?\n for i in range(num_orders):\n R.append([randint(1,12), randint(5,40)])\n return R\n\n\ndef solve_model(demands, parent_width=100):\n '''\n demands = [\n [1, 3], # [quantity, width]\n [3, 5],\n ...\n ]\n\n parent_width = integer\n '''\n num_orders = len(demands)\n solver = newSolver('Cutting Stock', True)\n k,b = bounds(demands, parent_width)\n\n # array of boolean declared as int, if y[i] is 1, \n # then y[i] Big roll is used, else it was not used\n y = [ solver.IntVar(0, 1, f'y_{i}') for i in range(k[1]) ] \n\n # x[i][j] = 3 means that small-roll width specified by i-th order\n # must be cut from j-th order, 3 tmies \n x = [[solver.IntVar(0, b[i], f'x_{i}_{j}') for j in range(k[1])] \\\n for i in range(num_orders)]\n \n unused_widths = [ solver.NumVar(0, parent_width, f'w_{j}') \\\n for j in range(k[1]) ] \n \n # will contain the number of big rolls used\n nb = solver.IntVar(k[0], k[1], 'nb')\n\n # consntraint: demand fullfilment\n for i in range(num_orders): \n # small rolls from i-th order must be at least as many in quantity\n # as specified by the i-th order\n solver.Add(sum(x[i][j] for j in range(k[1])) >= demands[i][0]) \n\n # constraint: max size limit\n for j in range(k[1]):\n # total width of small rolls cut from j-th big roll, \n # must not exceed big rolls width\n solver.Add( \\\n sum(demands[i][1]*x[i][j] for i in range(num_orders)) \\\n <= parent_width*y[j] \\\n ) \n\n # width of j-th big roll - total width of all orders cut from j-th roll\n # must be equal to unused_widths[j]\n # So, we are saying that assign unused_widths[j] the remaining width of j'th big roll\n solver.Add(parent_width*y[j] - sum(demands[i][1]*x[i][j] for i in range(num_orders)) == unused_widths[j])\n\n '''\n Book Author's note from page 201:\n [the following constraint] breaks the symmetry of multiple solutions that are equivalent \n for our purposes: any permutation of the rolls. These permutations, and there are K! of \n them, cause most solvers to spend an exorbitant time solving. With this constraint, we \n tell the solver to prefer those permutations with more cuts in roll j than in roll j + 1. \n The reader is encouraged to solve a medium-sized problem with and without this \n symmetry-breaking constraint. I have seen problems take 48 hours to solve without the \n constraint and 48 minutes with. Of course, for problems that are solved in seconds, the \n constraint will not help; it may even hinder. But who cares if a cutting stock instance \n solves in two or in three seconds? We care much more about the difference between two \n minutes and three hours, which is what this constraint is meant to address\n '''\n if j < k[1]-1: # k1 = total big rolls\n # total small rolls of i-th order cut from j-th big roll must be >=\n # totall small rolls of i-th order cut from j+1-th big roll\n solver.Add(sum(x[i][j] for i in range(num_orders)) >= sum(x[i][j+1] for i in range(num_orders)))\n\n # find & assign to nb, the number of big rolls used\n solver.Add(nb == solver.Sum(y[j] for j in range(k[1])))\n\n ''' \n minimize total big rolls used\n let's say we have y = [1, 0, 1]\n here, total big rolls used are 2. 0-th and 2nd. 1st one is not used. So we want our model to use the \n earlier rolls first. i.e. y = [1, 1, 0]. \n The trick to do this is to define the cost of using each next roll to be higher. So the model would be\n forced to used the initial rolls, when available, instead of the next rolls.\n\n So instead of Minimize ( Sum of y ) or Minimize( Sum([1,1,0]) )\n we Minimize( Sum([1*1, 1*2, 1*3]) )\n ''' \n\n '''\n Book Author's note from page 201:\n\n There are alternative objective functions. For example, we could have minimized the sum of the waste. This makes sense, especially if the demand constraint is formulated as an inequality. Then minimizing the sum of waste Chapter 7 advanCed teChniques\n will spend more CPU cycles trying to find more efficient patterns that over-satisfy demand. This is especially good if the demand widths recur regularly and storing cut rolls in inventory to satisfy future demand is possible. Note that the running time will grow quickly with such an objective function\n '''\n\n Cost = solver.Sum((j+1)*y[j] for j in range(k[1]))\n\n solver.Minimize(Cost)\n\n status = solver.Solve()\n numRollsUsed = SolVal(nb)\n\n return status, \\\n numRollsUsed, \\\n rolls(numRollsUsed, SolVal(x), SolVal(unused_widths), demands), \\\n SolVal(unused_widths), \\\n solver.WallTime()\n\ndef bounds(demands, parent_width=100):\n '''\n b = [sum of widths of individual small rolls of each order]\n T = local var. stores sum of widths of adjecent small-rolls. When the width reaches 100%, T is set to 0 again.\n k = [k0, k1], k0 = minimum big-rolls requierd, k1: number of big rolls that can be consumed / cut from\n TT = local var. stores sum of widths of of all small-rolls. At the end, will be used to estimate lower bound of big-rolls\n '''\n num_orders = len(demands)\n b = []\n T = 0\n k = [0,1]\n TT = 0\n\n for i in range(num_orders):\n # q = quantity, w = width; of i-th order\n quantity, width = demands[i][0], demands[i][1]\n # TODO Verify: why min of quantity, parent_width/width?\n # assumes widths to be entered as percentage\n # int(round(parent_width/demands[i][1])) will always be >= 1, because widths of small rolls can't exceed parent_width (which is width of big roll)\n # b.append( min(demands[i][0], int(round(parent_width / demands[i][1]))) )\n b.append( min(quantity, int(round(parent_width / width))) )\n\n # if total width of this i-th order + previous order's leftover (T) is less than parent_width\n # it's fine. Cut it.\n if T + quantity*width <= parent_width:\n T, TT = T + quantity*width, TT + quantity*width\n # else, the width exceeds, so we have to cut only as much as we can cut from parent_width width of the big roll\n else:\n while quantity:\n if T + width <= parent_width:\n T, TT, quantity = T + width, TT + width, quantity-1\n else:\n k[1],T = k[1]+1, 0 # use next roll (k[1] += 1)\n k[0] = int(round(TT/parent_width+0.5))\n\n print('k', k)\n print('b', b)\n\n return k, b\n\n'''\n nb: array of number of rolls to cut, of each order\n \n w: \n demands: [\n [quantity, width],\n [quantity, width],\n [quantity, width],\n ]\n'''\ndef rolls(nb, x, w, demands):\n consumed_big_rolls = []\n num_orders = len(x) \n # go over first row (1st order)\n # this row contains the list of all the big rolls available, and if this 1st (0-th) order\n # is cut from any big roll, that big roll's index would contain a number > 0\n for j in range(len(x[0])):\n # w[j]: width of j-th big roll \n # int(x[i][j]) * [demands[i][1]] width of all i-th order's small rolls that are to be cut from j-th big roll \n RR = [ abs(w[j])] + [ int(x[i][j])*[demands[i][1]] for i in range(num_orders) \\\n if x[i][j] > 0 ] # if i-th order has some cuts from j-th order, x[i][j] would be > 0\n consumed_big_rolls.append(RR)\n\n return consumed_big_rolls\n\n\n\n'''\nthis model starts with some patterns and then optimizes those patterns\n'''\ndef solve_large_model(demands, parent_width=100):\n num_orders = len(demands)\n iter = 0\n patterns = get_initial_patterns(demands)\n # print('method#solve_large_model, patterns', patterns)\n\n # list quantities of orders\n quantities = [demands[i][0] for i in range(num_orders)]\n print('quantities', quantities)\n\n while iter < 20:\n status, y, l = solve_master(patterns, quantities, parent_width=parent_width)\n iter += 1\n\n # list widths of orders\n widths = [demands[i][1] for i in range(num_orders)]\n new_pattern, objectiveValue = get_new_pattern(l, widths, parent_width=parent_width)\n\n # print('method#solve_large_model, new_pattern', new_pattern)\n # print('method#solve_large_model, objectiveValue', objectiveValue)\n\n for i in range(num_orders):\n # add i-th cut of new pattern to i-thp pattern\n patterns[i].append(new_pattern[i])\n\n status, y, l = solve_master(patterns, quantities, parent_width=parent_width, integer=True) \n\n return status, \\\n patterns, \\\n y, \\\n rolls_patterns(patterns, y, demands, parent_width=parent_width)\n\n\n'''\nDantzig-Wolfe decomposition splits the problem into a Master Problem MP and a sub-problem SP.\n\nThe Master Problem: provided a set of patterns, find the best combination satisfying the demand\n\nC: patterns\nb: demand\n'''\ndef solve_master(patterns, quantities, parent_width=100, integer=False):\n title = 'Cutting stock master problem'\n num_patterns = len(patterns)\n n = len(patterns[0])\n # print('**num_patterns x n: ', num_patterns, 'x', n)\n # print('**patterns recived:')\n # for p in patterns:\n # print(p)\n\n constraints = []\n\n solver = newSolver(title, integer)\n\n # y is not boolean, it's an integer now (as compared to y in approach used by solve_model)\n y = [ solver.IntVar(0, 1000, '') for j in range(n) ] # right bound?\n # minimize total big rolls (y) used\n Cost = sum(y[j] for j in range(n)) \n solver.Minimize(Cost)\n\n # for every pattern\n for i in range(num_patterns):\n # add constraint that this pattern (demand) must be met\n # there are m such constraints, for each pattern\n constraints.append(solver.Add( sum(patterns[i][j]*y[j] for j in range(n)) >= quantities[i]) ) \n\n status = solver.Solve()\n y = [int(ceil(e.SolutionValue())) for e in y]\n\n l = [0 if integer else constraints[i].DualValue() for i in range(num_patterns)]\n # sl = [0 if integer else constraints[i].name() for i in range(num_patterns)]\n # print('sl: ', sl)\n\n # l = [0 if integer else u[i].Ub() for i in range(m)]\n toreturn = status, y, l\n # l_to_print = [round(dd, 2) for dd in toreturn[2]]\n # print('l: ', len(l_to_print), '->', l_to_print)\n # print('l: ', toreturn[2])\n return toreturn\n\ndef get_new_pattern(l, w, parent_width=100):\n solver = newSolver('Cutting stock sub-problem', True)\n n = len(l)\n new_pattern = [ solver.IntVar(0, parent_width, '') for i in range(n) ]\n\n # maximizes the sum of the values times the number of occurrence of that roll in a pattern\n Cost = sum( l[i] * new_pattern[i] for i in range(n))\n solver.Maximize(Cost)\n\n # ensuring that the pattern stays within the total width of the large roll \n solver.Add( sum( w[i] * new_pattern[i] for i in range(n)) <= parent_width ) \n\n status = solver.Solve()\n return SolVal(new_pattern), ObjVal(solver)\n\n\n'''\nthe initial patterns must be such that they will allow a feasible solution, \none that satisfies all demands. \nConsidering the already complex model, let’s keep it simple. \nOur initial patterns have exactly one roll per pattern, as obviously feasible as inefficient.\n'''\ndef get_initial_patterns(demands):\n num_orders = len(demands)\n return [[0 if j != i else 1 for j in range(num_orders)]\\\n for i in range(num_orders)]\n\ndef rolls_patterns(patterns, y, demands, parent_width=100):\n R, m, n = [], len(patterns), len(y)\n\n for j in range(n):\n for _ in range(y[j]):\n RR = []\n for i in range(m):\n if patterns[i][j] > 0:\n RR.extend( [demands[i][1]] * int(patterns[i][j]) )\n used_width = sum(RR)\n R.append([parent_width - used_width, RR])\n\n return R\n\n\n'''\nchecks if all small roll widths (demands) smaller than parent roll's width\n'''\ndef checkWidths(demands, parent_width):\n for quantity, width in demands:\n if width > parent_width:\n print(f'Small roll width {width} is greater than parent rolls width {parent_width}. Exiting')\n return False\n return True\n\n\n'''\n params\n child_rolls: \n list of lists, each containing quantity & width of rod / roll to be cut\n e.g.: [ [quantity, width], [quantity, width], ...]\n parent_rolls: \n list of lists, each containing quantity & width of rod / roll to cut from\n e.g.: [ [quantity, width], [quantity, width], ...]\n'''\ndef StockCutter1D(child_rolls, parent_rolls, output_json=True, large_model=True):\n\n # at the moment, only parent one width of parent rolls is supported\n # quantity of parent rolls is calculated by algorithm, so user supplied quantity doesn't matter?\n # TODO: or we can check and tell the user the user when parent roll quantity is insufficient\n parent_width = parent_rolls[0][1]\n\n if not checkWidths(demands=child_rolls, parent_width=parent_width):\n return []\n\n\n print('child_rolls', child_rolls)\n print('parent_rolls', parent_rolls)\n\n if not large_model:\n print('Running Small Model...')\n status, numRollsUsed, consumed_big_rolls, unused_roll_widths, wall_time = \\\n solve_model(demands=child_rolls, parent_width=parent_width)\n\n # convert the format of output of solve_model to be exactly same as solve_large_model\n print('consumed_big_rolls before adjustment: ', consumed_big_rolls)\n new_consumed_big_rolls = []\n for big_roll in consumed_big_rolls:\n if len(big_roll) < 2:\n # sometimes the solve_model return a solution that contanis an extra [0.0] entry for big roll\n consumed_big_rolls.remove(big_roll)\n continue\n unused_width = big_roll[0]\n subrolls = []\n for subitem in big_roll[1:]:\n if isinstance(subitem, list):\n # if it's a list, concatenate with the other lists, to make a single list for this big_roll\n subrolls = subrolls + subitem\n else:\n # if it's an integer, add it to the list\n subrolls.append(subitem)\n new_consumed_big_rolls.append([unused_width, subrolls])\n print('consumed_big_rolls after adjustment: ', new_consumed_big_rolls)\n consumed_big_rolls = new_consumed_big_rolls\n \n else:\n print('Running Large Model...');\n status, A, y, consumed_big_rolls = solve_large_model(demands=child_rolls, parent_width=parent_width)\n\n numRollsUsed = len(consumed_big_rolls)\n # print('A:', A, '\\n')\n # print('y:', y, '\\n')\n\n\n STATUS_NAME = ['OPTIMAL',\n 'FEASIBLE',\n 'INFEASIBLE',\n 'UNBOUNDED',\n 'ABNORMAL',\n 'NOT_SOLVED'\n ]\n\n output = {\n \"statusName\": STATUS_NAME[status],\n \"numSolutions\": '1',\n \"numUniqueSolutions\": '1',\n \"numRollsUsed\": numRollsUsed,\n \"solutions\": consumed_big_rolls # unique solutions\n }\n\n\n # print('Wall Time:', wall_time)\n print('numRollsUsed', numRollsUsed)\n print('Status:', output['statusName'])\n print('Solutions found :', output['numSolutions'])\n print('Unique solutions: ', output['numUniqueSolutions'])\n\n if output_json:\n return json.dumps(output) \n else:\n return consumed_big_rolls\n\n\n'''\nDraws the big rolls on the graph. Each horizontal colored line represents one big roll.\nIn each big roll (multi-colored horizontal line), each color represents small roll to be cut from it.\nIf the big roll ends with a black color, that part of the big roll is unused width.\n\nTODO: Assign each child roll a unique color\n'''\ndef drawGraph(consumed_big_rolls, child_rolls, parent_width):\n import matplotlib.pyplot as plt\n import matplotlib.patches as patches\n\n # TODO: to add support for multiple different parent rolls, update here\n xSize = parent_width # width of big roll\n ySize = 10 * len(consumed_big_rolls) # one big roll will take 10 units vertical space\n\n # draw rectangle\n fig,ax = plt.subplots(1)\n plt.xlim(0, xSize)\n plt.ylim(0, ySize)\n plt.gca().set_aspect('equal', adjustable='box')\n \n # print coords\n coords = []\n colors = ['r', 'g', 'b', 'y', 'brown', 'violet', 'pink', 'gray', 'orange', 'b', 'y']\n colorDict = {}\n i = 0\n for quantity, width in child_rolls:\n colorDict[width] = colors[i % 11]\n i+= 1\n\n # start plotting each big roll horizontly, from the bottom\n y1 = 0\n for i, big_roll in enumerate(consumed_big_rolls):\n '''\n big_roll = [leftover_width, [small_roll_1_1, small_roll_1_2, other_small_roll_2_1]]\n '''\n unused_width = big_roll[0]\n small_rolls = big_roll[1]\n\n x1 = 0\n x2 = 0\n y2 = y1 + 8 # the height of each big roll will be 8 \n for j, small_roll in enumerate(small_rolls):\n x2 = x2 + small_roll\n print(f\"{x1}, {y1} -> {x2}, {y2}\")\n width = abs(x1-x2)\n height = abs(y1-y2)\n # print(f\"Rect#{idx}: {width}x{height}\")\n # Create a Rectangle patch\n rect_shape = patches.Rectangle((x1,y1), width, height, facecolor=colorDict[small_roll], label=f'{small_roll}')\n ax.add_patch(rect_shape) # Add the patch to the Axes\n x1 = x2 # x1 for next small roll in same big roll will be x2 of current roll \n\n # now that all small rolls have been plotted, check if a there is unused width in this big roll\n # set the unused width at the end as black colored rectangle\n if unused_width > 0:\n width = unused_width\n rect_shape = patches.Rectangle((x1,y1), width, height, facecolor='black', label='Unused')\n ax.add_patch(rect_shape) # Add the patch to the Axes\n\n y1 += 10 # next big roll will be plotted on top of current, a roll height is 8, so 2 will be margin between rolls\n\n plt.show()\n\n\nif __name__ == '__main__':\n\n # child_rolls = [\n # [quantity, width],\n # ]\n app = typer.Typer()\n\n\n def main(infile_name: Optional[str] = typer.Argument(None)):\n\n if infile_name:\n child_rolls = get_data(infile_name)\n else:\n child_rolls = gen_data(3)\n parent_rolls = [[10, 120]] # 10 doesn't matter, itls not used at the moment\n\n consumed_big_rolls = StockCutter1D(child_rolls, parent_rolls, output_json=False, large_model=False)\n typer.echo(f\"{consumed_big_rolls}\")\n\n\n for idx, roll in enumerate(consumed_big_rolls):\n typer.echo(f\"Roll #{idx}:{roll}\")\n\n drawGraph(consumed_big_rolls, child_rolls, parent_width=parent_rolls[0][1])\n\nif __name__ == \"__main__\":\n typer.run(main)\n" }, { "path": "deployment/.editorconfig", "content": "# Editor configuration, see http://editorconfig.org\n# source: https://stackoverflow.com/a/51398290/3578289\nroot = true\n\n[*]\ncharset = utf-8\nindent_style = space\nindent_size = 4\ninsert_final_newline = true\ntrim_trailing_whitespace = true\n\n[*.md]\nmax_line_length = off\ntrim_trailing_whitespace = false\n" }, { "path": "deployment/.gitignore", "content": "node_modules/\n__pycache__\nserver/__pycache__/\n*.csv\n\n.DS_Store\nfrontend/dist/\n\n# local env files\n.env.local\n.env.*.local\n\n# Log files\nnpm-debug.log*\nyarn-debug.log*\nyarn-error.log*\n\n# Editor directories and files\n.idea\n.vscode\n*.suo\n*.ntvs*\n*.njsproj\n*.sln\n*.sw*\n" }, { "path": "deployment/Procfile", "content": "web: gunicorn server:app" }, { "path": "deployment/csp.py", "content": "from __future__ import print_function\nimport collections, json\nfrom ortools.sat.python import cp_model\n\n# to draw rectangles\nimport matplotlib.pyplot as plt\nimport matplotlib.patches as patches\n\n\"\"\"\n Cutting Stock problem\n params\n child_rects: \n lists of multiple rectangles' coords\n e.g.: [ [w, h], [w, h], ...]\n parent_rects: rectangle coords\n lists of multiple rectangles' coords\n e.g.: [ [w, h], [w, h], ...]\n\"\"\"\ndef StockCutter(child_rects, parent_rects):\n \n # Create the model\n model = cp_model.CpModel()\n\n # parent rect (to cut from). horizon = [ width, height ] of parent sheet\n # for now, parent rectangle is just one\n # TODO: to add functionality of cutting from multiple parent sheets, start here:\n horizon = parent_rects[0] \n\n # Named Tuple to store information about created variables\n sheet_type = collections.namedtuple('sheet_type', 'x1 y1 x2 y2 x_interval y_interval')\n\n # Store for all model variables\n all_vars = {}\n\n # sum of to save area of all small rects, to cut from parent rect\n total_child_area = 0 \n\n # hold the widths (x) and heights (y) interval vars of each sheet\n x_intervals = []\n y_intervals = []\n\n # create model vars and intervals\n for rect_id, rect in enumerate(child_rects):\n width = rect[0]\n height = rect[1]\n area = width * height\n total_child_area += area\n # print(f\"Rect: {width}x{height}, Area: {area}\")\n\n suffix = '_%i_%i' % (width, height)\n\n # interval to represent width. max value can be the width of parent rect\n x1_var = model.NewIntVar(0, horizon[0], 'x1' + suffix)\n x2_var = model.NewIntVar(0, horizon[0], 'x2' + suffix)\n x_interval_var = model.NewIntervalVar(x1_var, width, x2_var, 'x_interval' + suffix)\n\n # interval to represent height. max value can be the height of parent rect\n y1_var = model.NewIntVar(0, horizon[1], 'y1' + suffix)\n y2_var = model.NewIntVar(0, horizon[1], 'y2' + suffix)\n y_interval_var = model.NewIntervalVar(y1_var, height, y2_var, 'y_interval' + suffix)\n \n x_intervals.append(x_interval_var)\n y_intervals.append(y_interval_var)\n\n # store the variables for later use\n all_vars[rect_id] = sheet_type(\n x1=x1_var, \n y1=y1_var, \n x2=x2_var, \n y2=y2_var, \n x_interval=x_interval_var,\n y_interval=y_interval_var\n )\n\n # add constraint: no over lap of rectangles allowed\n model.AddNoOverlap2D(x_intervals, y_intervals)\n\n # Solve model\n solver = cp_model.CpSolver()\n\n solution_printer = VarArraySolutionPrinter(all_vars)\n\n # Search for all solutions is only defined on satisfiability problems\n status = solver.SearchForAllSolutions(model, solution_printer) # use for satisfiability problem\n # status = solver.Solve(model) # use for Optimization Problem\n\n print('Status:', solver.StatusName(status))\n print('Solutions found :', solution_printer.solution_count())\n\n solutions = solution_printer.get_unique_solutions() \n\n # call draw methods here, if want to draw with matplotlib\n\n int_solutions = solutions_to_int(solutions)\n\n statusName = solver.StatusName(status)\n numSolutions = solution_printer.solution_count()\n numUniqueSolutions = len(solutions)\n\n output = {\n \"statusName\": statusName,\n \"numSolutions\": numSolutions,\n \"numUniqueSolutions\": numUniqueSolutions,\n \"solutions\": int_solutions # unique solutions\n }\n\n # return json.dumps(output)\n\n # draw\n for idx, sol in enumerate(solutions):\n # sol is string of coordinates of all rectangles in this solution\n # format: x1,y1,x2,y2-x1,y1,x2,y2\n print('Sol#', idx)\n rect_strs = sol.split('-')\n rect_coords = [\n # [x1,y1,x2,y2],\n # [x1,y1,x2,y2],\n ]\n for rect_str in rect_strs:\n coords_str = rect_str.split(',')\n coords = [int(c) for c in coords_str]\n rect_coords.append(coords)\n print('rect_coords')\n # print(rect_coords)\n drawRectsFromCoords(rect_coords)\n\ndef drawRectsFromCoords(rect_coords):\n # draw rectangle\n fig,ax = plt.subplots(1)\n plt.xlim(0,6) # todo 7\n plt.ylim(0,6)\n plt.gca().set_aspect('equal', adjustable='box')\n \n # print coords\n coords = []\n colors = ['r', 'g', 'b', 'y', 'brown', 'black', 'violet', 'pink', 'gray', 'orange', 'b', 'y']\n for idx, coords in enumerate(rect_coords):\n x1=coords[0]\n y1=coords[1]\n x2=coords[2]\n y2=coords[3]\n # print(f\"{x1}, {y1} -> {x2}, {y2}\")\n\n width = abs(x1-x2)\n height = abs(y1-y2)\n # print(f\"Rect#{idx}: {width}x{height}\")\n\n # Create a Rectangle patch\n rect_shape = patches.Rectangle((x1,y1), width, height,facecolor=colors[idx])\n # Add the patch to the Axes\n ax.add_patch(rect_shape)\n plt.show()\n\n\n\n\n\n\"\"\"\n TODO complete this, add to git\n params:\n str_solutions: list of strings. 1 string contains is solution\n\"\"\"\ndef solutions_to_int(str_solutions):\n\n # list of solutions, each solution is a list of rectangle coords that look like [x1,y1,x2,y2]\n int_solutions = []\n\n # go over all solutions and convert them to int>list>json\n for idx, sol in enumerate(str_solutions):\n # sol is string of coordinates of all rectangles in this solution\n # format: x1,y1,x2,y2-x1,y1,x2,y2\n \n rect_strs = sol.split('-')\n rect_coords = [\n # [x1,y1,x2,y2],\n # [x1,y1,x2,y2],\n # ...\n ]\n\n # convert each rectangle's coords to int\n for rect_str in rect_strs:\n coords_str = rect_str.split(',')\n coords = [int(c) for c in coords_str]\n rect_coords.append(coords)\n\n # print('rect_coords', rect_coords)\n\n # call draw methods here, if want to draw individual solutions with matplotlib\n\n int_solutions.append(rect_coords)\n\n return int_solutions\n\n\n\"\"\"\n To get all the solutions of the problem, as they come up. \n https://developers.google.com/optimization/cp/cp_solver#all_solutions\n\n The solutions are all unique. But for the child rectangles that have same dimensions, \n some solution will be repetitive. Because for the algorithm, they are different solutions, \n but because of same size, they are merely permutations of the similar child rectangles - \n having other rectangles' positions fixed.\n\n We want to remove repetitive extra solutions. One way to do this is\n 1. Stringify every rectangle coords in a solution\n (1,2)->(2,3) becomes \"1,2,2,3\"\n\n # here the rectangles are stored as a string: \"1,2,2,3\" where x1=1, y1=2, x2=2, y2=3\n \n 2. Put all these string coords into a sorted list. This sorting is important. \n Because the rectangles (1,2)->(2,3) and (3,3)->(4,4) are actually same size (1x1) rectangles. \n And they can appear in 1st solution as \n [(1,2)->(2,3) , (3,3)->(4,4)]\n and in the 2nd solution as\n [(3,3)->(4,4) , (1,2)->(2,3)]\n\n but this sorted list of strings will ensure both solutions are represented as\n\n [..., \"1,2,2,3\", \"3,3,4,4\", ...]\n\n 3. Join the Set of \"strings (rectangles)\" in to one big string seperated by '-'. For every solution.\n So in resulting big strings (solutions), we will have two similar strings (solutions) \n that be similar and also contain\n\n \"....1,2,2,3-3,3,4,4-....\"\n\n 4. Now add all these \"strings (solutions)\" into a Set. this adding to the set \n will remove similar strings. And hence duplicate solutions will be removed.\n\n\"\"\"\nclass VarArraySolutionPrinter(cp_model.CpSolverSolutionCallback):\n\n def __init__(self, variables):\n cp_model.CpSolverSolutionCallback.__init__(self)\n self.__variables = variables\n self.__solution_count = 0\n\n # hold the calculated solutions\n self.__solutions = []\n self.__unique_solutions = set()\n\n def on_solution_callback(self):\n self.__solution_count += 1\n # print('Sol#: ', self.__solution_count)\n\n # using list to hold the coordinate strings of rectangles\n rect_strs = []\n\n # extra coordinates of all rectangles for this solution \n for rect_id in self.__variables:\n rect = self.__variables[rect_id]\n x1 = self.Value(rect.x1)\n x2 = self.Value(rect.x2)\n y1 = self.Value(rect.y1)\n y2 = self.Value(rect.y2)\n\n rect_str = f\"{x1},{y1},{x2},{y2}\"\n # print(rect_str)\n\n rect_strs.append(rect_str)\n # print(f'Rect #{rect_id}: {x1},{y1} -> {x2},{y2}')\n\n # print(rect_strs)\n\n # sort the rectangles\n rect_strs = sorted(rect_strs)\n\n # single solution as a string\n solution_str = '-'.join(rect_strs)\n # print(solution_str)\n\n # store the solutions\n self.__solutions.append(solution_str)\n self.__unique_solutions.add(solution_str) # __unique_solutions is a set, so duplicates will get removed\n\n\n def solution_count(self):\n return self.__solution_count\n\n # returns all solutions \n def get_solutions(self):\n return self.__solutions\n\n \"\"\"\n returns unique solutions\n returns the permutation free list of solution strings \n \"\"\"\n def get_unique_solutions(self):\n return list(self.__unique_solutions) # __unique_solutions is a Set, convert to list\n\n\n\n# for testing\nif __name__ == '__main__':\n\n child_rects = [\n # [2, 2],\n # [1, 3],\n # [4, 3],\n # [1, 1],\n # [2, 4],\n\n [3, 3],\n [3, 3],\n [3, 3],\n [3, 3],\n ]\n\n parent_rects = [[6,6]]\n\n StockCutter(child_rects, parent_rects)" }, { "path": "deployment/frontend/.gitignore", "content": ".DS_Store\nnode_modules\n/dist\n\n\n# local env files\n.env.local\n.env.*.local\n\n# Log files\nnpm-debug.log*\nyarn-debug.log*\nyarn-error.log*\npnpm-debug.log*\n\n# Editor directories and files\n.idea\n.vscode\n*.suo\n*.ntvs*\n*.njsproj\n*.sln\n*.sw?\n" }, { "path": "deployment/frontend/README.md", "content": "# frontend\n\n## Project setup\n```\nnpm install\n```\n\n### Compiles and hot-reloads for development\n```\nnpm run serve\n```\n\n### Compiles and minifies for production\n```\nnpm run build\n```\n\n### Lints and fixes files\n```\nnpm run lint\n```\n\n### Customize configuration\nSee [Configuration Reference](https://cli.vuejs.org/config/).\n" }, { "path": "deployment/frontend/babel.config.js", "content": "module.exports = {\n presets: [\n '@vue/cli-plugin-babel/preset'\n ]\n}\n" }, { "path": "deployment/frontend/package.json", "content": "{\n \"name\": \"frontend\",\n \"version\": \"0.1.0\",\n \"private\": true,\n \"scripts\": {\n \"serve\": \"vue-cli-service serve\",\n \"build\": \"vue-cli-service build\",\n \"lint\": \"vue-cli-service lint\"\n },\n \"dependencies\": {\n \"axios\": \"^0.21.1\",\n \"bootstrap\": \"^5.1.0\",\n \"bootstrap-vue\": \"^2.21.2\",\n \"core-js\": \"^3.6.5\",\n \"d3\": \"^7.0.1\",\n \"vue\": \"^3.2.6\"\n },\n \"devDependencies\": {\n \"@types/d3\": \"^7.0.0\",\n \"@vue/cli-plugin-babel\": \"~4.5.0\",\n \"@vue/cli-plugin-eslint\": \"~4.5.0\",\n \"@vue/cli-service\": \"~4.5.0\",\n \"@vue/compiler-sfc\": \"^3.0.0\",\n \"babel-eslint\": \"^10.1.0\",\n \"eslint\": \"^6.7.2\",\n \"eslint-plugin-vue\": \"^7.0.0\"\n },\n \"eslintConfig\": {\n \"root\": true,\n \"env\": {\n \"node\": true\n },\n \"extends\": [\n \"plugin:vue/vue3-essential\",\n \"eslint:recommended\"\n ],\n \"parserOptions\": {\n \"parser\": \"babel-eslint\"\n },\n \"rules\": {}\n },\n \"browserslist\": [\n \"> 1%\",\n \"last 2 versions\",\n \"not dead\"\n ]\n}\n" }, { "path": "deployment/frontend/public/index.html", "content": "\n\n \n \n \n \n favicon.ico\">\n <%= htmlWebpackPlugin.options.title %>\n \n \n \n
\n \n \n\n" }, { "path": "deployment/frontend/src/App.vue", "content": "\n\n\n\n\n" }, { "path": "deployment/frontend/src/assets/style.scss", "content": "\n\nbody {\n /* font-size: 0.9em; */\n background-color: #ecf0f1;\n}\n\n.btn {\n padding: 2px 8px;\n}\n\ninput {\n border: 0px solid #000;\n margin: 0;\n background: transparent;\n width: 100%;\n}\ntable tr td {\n border-right: 1px solid #000;\n border-bottom: 1px solid #000;\n}\ntable {\n background: #fff none repeat scroll 0 0;\n border-left: 1px solid #000;\n border-top: 1px solid #000;\n}\ntable tr:nth-child(even) {\n background: #95a5a6;\n}\ntable tr:nth-child(odd) {\n background: #bdc3c7;\n}\n.active {\n font-weight: bold;\n}\n\n.information {\n border-radius: 100%;\n background: #444;\n color: white;\n padding: 2px 5px;\n font-size: 80%;\n font-weight: bold;\n}" }, { "path": "deployment/frontend/src/components/CspTool.vue", "content": "\n\n\n\n\n\n" }, { "path": "deployment/frontend/src/main.js", "content": "import { createApp } from 'vue'\n\n// import Vue from 'vue'\n// import { BootstrapVue, IconsPlugin } from 'bootstrap-vue'\n// Import Bootstrap an BootstrapVue CSS files (order is important)\nimport 'bootstrap/dist/css/bootstrap.css'\n// import 'bootstrap-vue/dist/bootstrap-vue.css'\n\n// Make BootstrapVue available throughout your project\n// Vue.use(BootstrapVue)\n// Optionally install the BootstrapVue icon components plugin\n// Vue.use(IconsPlugin)\n\n\nimport App from './App.vue'\n\ncreateApp(App).mount('#app')\n" }, { "path": "deployment/requirements.txt", "content": "gunicorn\nFlask\nFlask-Cors\nortools\n" }, { "path": "deployment/server.py", "content": "from flask import Flask, json, request\nfrom flask_cors import CORS, cross_origin\n\nimport stock_cutter # local module\n\napp = Flask(__name__)\ncors = CORS(app)\napp.config['CORS_HEADERS'] = 'Content-Type'\n\n@app.route('/', methods=['GET'])\n@cross_origin()\ndef get_csp():\n\treturn 'Cutting Stock Problem'\n\n'''\nroute for receving data for 1D problem \n'''\n@app.route('/stocks_1d', methods=['POST'])\n@cross_origin()\ndef post_stocks_1d():\n\t'''\n\texpects two params to be present\n\tchild_rolls:\n\t\tarray of arrays. E.g [ [quantity, width], [quantity, width], ... ]\n\n\tparent_rolls:\n\t\tarray of arrays. E.g [ [quantity, width], [quantity, width], ... ]\n\t'''\n\timport stock_cutter_1d\n\n\tdata = request.json\n\tprint('data: ', data)\n\n\tchild_rolls = data['child_rolls']\n\tparent_rolls = data['parent_rolls']\n\n\t'''\n\tit can be\n\texactCuts: cut exactly as many as specified by user\n\tminWaste: cut some items, more than specified, to avoid waste\n\t'''\n\tcutStyle = data['cutStyle']\n\n\t# output = stock_cutter_1d.StockCutter1D(child_rolls, parent_rolls, cutStyle=cutStyle)\n\toutput = stock_cutter_1d.StockCutter1D(child_rolls, parent_rolls, large_model=False, cutStyle=cutStyle)\n\n\treturn output\n\n\n\n'''\nroute for 2D\n'''\n@app.route('/stocks_2d', methods=['POST'])\n@cross_origin()\ndef post_stocks():\n\t'''\n\texpects two params to be present\n\tchild_rects:\n\t\tarray of arrays. Each inner array is like [w, h] i.e. width & height of rectangle\n\n\tparent_rects:\n\t\tarray of arrays. Each inner array is like [w, h] i.e. width & height of rectangle\n\t'''\n\tdata = request.json\n\tprint('data: ', data)\n\n\tchild_rects = data['child_rects']\n\tparent_rects = data['parent_rects']\n\n\toutput = stock_cutter.StockCutter(child_rects, parent_rects)\n\n\treturn output\n\n\n\nif __name__ == '__main__':\n # app.run()\n\tapp.run(threaded=True, port=5000)\n" }, { "path": "deployment/stock_cutter.py", "content": "'''\n@Author Emad Ehsan\nCutting Stock problem 2D\nNot complete.\nWhat's remaining: Finding Optimized solution that minimizes the waste.\n'''\n\nimport collections, json\nfrom ortools.sat.python import cp_model\n\n\"\"\"\n params\n child_rects: \n lists of multiple rectangles' coords\n e.g.: [ [w, h], [w, h], ...]\n parent_rects: rectangle coords\n lists of multiple rectangles' coords\n e.g.: [ [w, h], [w, h], ...]\n\"\"\"\ndef StockCutter(child_rects, parent_rects, output_json=True):\n \n # Create the model\n model = cp_model.CpModel()\n\n # parent rect (to cut from). horizon = [ width, height ] of parent sheet\n # for now, parent rectangle is just one\n # TODO: to add functionality of cutting from multiple parent sheets, start here:\n horizon = parent_rects[0] \n total_parent_area = horizon[0] * horizon[1] # width x height\n\n # Named Tuple to store information about created variables\n sheet_type = collections.namedtuple('sheet_type', 'x1 y1 x2 y2 x_interval y_interval is_extra')\n\n # Store for all model variables\n all_vars = {}\n\n # sum of to save area of all small rects, to cut from parent rect\n total_child_area = 0 \n\n # hold the widths (x) and heights (y) interval vars of each sheet\n x_intervals = []\n y_intervals = []\n\n # create model vars and intervals\n for rect_id, rect in enumerate(child_rects):\n width = rect[0]\n height = rect[1]\n area = width * height\n total_child_area += area\n # print(f\"Rect: {width}x{height}, Area: {area}\")\n\n suffix = '_%i_%i' % (width, height)\n\n # interval to represent width. max value can be the width of parent rect\n x1_var = model.NewIntVar(0, horizon[0], 'x1' + suffix)\n x2_var = model.NewIntVar(0, horizon[0], 'x2' + suffix)\n x_interval_var = model.NewIntervalVar(x1_var, width, x2_var, 'x_interval' + suffix)\n\n # interval to represent height. max value can be the height of parent rect\n y1_var = model.NewIntVar(0, horizon[1], 'y1' + suffix)\n y2_var = model.NewIntVar(0, horizon[1], 'y2' + suffix)\n y_interval_var = model.NewIntervalVar(y1_var, height, y2_var, 'y_interval' + suffix)\n \n x_intervals.append(x_interval_var)\n y_intervals.append(y_interval_var)\n\n # store the variables for later use\n all_vars[rect_id] = sheet_type(\n x1=x1_var, \n y1=y1_var, \n x2=x2_var, \n y2=y2_var, \n x_interval=x_interval_var,\n y_interval=y_interval_var,\n is_extra=False # to keep track of 1x1 custom rects added in next step\n )\n\n # model.Minimize(x1_var)\n # model.Minimize(y1_var)\n\n\n # TODO: Minimize (x1,y1) values. So that rectangles are placed at the start\n # this reduced the areas wasted by place rectangles in the middle / at the end\n # even though the space at the start is available.\n # >\n # for rect_id in range(len(child_rects)):\n # model.Minimize(all_vars[rect_id].x1 + all_vars[rect_id].y1)\n # model.Minimize(all_vars[rect_id].x2 + all_vars[rect_id].y2)\n # model.Minimize(all_vars[rect_id].x1)\n # model.Minimize(all_vars[rect_id].x2)\n # model.Minimize(all_vars[rect_id].y1)\n # model.Minimize(all_vars[rect_id].y2)\n\n\n '''\n FIXME: experiment\n Experment: treat the remaining area as small units of 1x1 rectangles. Push these rects to higher x,y.\n '''\n # leftover_area = total_parent_area - total_child_area\n # if leftover_area >= 0:\n # '''\n # each unit of leftover_area can be represented by 1x1 rectangles. \n # For leftover_area = 4 (e.g. 2x2 originally), we can use 4 rects of 1x1. Why? Because\n # 1. leftover_area would not always be continous. It is possible it is in the form of two \n # separate 2x1 rects or one 2x2 or four rects of 1x1. So we need the simplest version, \n # that can cover all types of rects. And it is 1x1\n # 2. 1x1 can represent non-adjecent weirdly shaped locations in the parent area that were leftover.\n # '''\n # num_1x1rects = leftover_area\n\n # for i in range(num_1x1rects):\n # print(f'{i}-th 1x1')\n # suffix = '_%i_%i' % (1, 1)\n\n # # interval to represent width. max value can be the width of parent rect\n # x1_var = model.NewIntVar(0, horizon[0], 'x1' + suffix)\n # x2_var = model.NewIntVar(0, horizon[0], 'x2' + suffix)\n # x_interval_var = model.NewIntervalVar(x1_var, 1, x2_var, 'x_interval' + suffix)\n\n # # interval to represent height. max value can be the height of parent rect\n # y1_var = model.NewIntVar(0, horizon[1], 'y1' + suffix)\n # y2_var = model.NewIntVar(0, horizon[1], 'y2' + suffix)\n # y_interval_var = model.NewIntervalVar(y1_var, 1, y2_var, 'y_interval' + suffix)\n \n # x_intervals.append(x_interval_var)\n # y_intervals.append(y_interval_var)\n\n # # store the variables for later use\n # all_vars[rect_id] = sheet_type(\n # x1=x1_var, \n # y1=y1_var, \n # x2=x2_var, \n # y2=y2_var, \n # x_interval=x_interval_var,\n # y_interval=y_interval_var,\n # is_extra=True\n # )\n # model.Maximize(x1_var)\n # model.Maximize(y1_var)\n # else:\n # print(f'Problem identified: Area of small rects is larger than parent rect by {leftover_area}')\n\n \n\n\n # add constraint: no over lap of rectangles allowed\n model.AddNoOverlap2D(x_intervals, y_intervals)\n\n # Solve model\n solver = cp_model.CpSolver()\n\n '''\n Search for all solutions is only defined on satisfiability problems\n '''\n # solution_printer = VarArraySolutionPrinter(all_vars)\n # status = solver.SearchForAllSolutions(model, solution_printer) # use for satisfiability problem\n # solutions = solution_printer.get_unique_solutions()\n # int_solutions = str_solutions_to_int(solutions)\n # output = {\n # \"statusName\": solver.StatusName(status),\n # \"numSolutions\": solution_printer.solution_count(),\n # \"numUniqueSolutions\": len(solutions),\n # \"solutions\": int_solutions # unique solutions\n # }\n\n '''\n for single solution\n '''\n status = solver.Solve(model) # use for Optimization Problem\n singleSolution = getSingleSolution(solver, all_vars)\n int_solutions = [singleSolution] # convert to array\n output = {\n \"statusName\": solver.StatusName(status),\n \"numSolutions\": '1',\n \"numUniqueSolutions\": '1',\n \"solutions\": int_solutions # unique solutions\n }\n\n\n print('Time:', solver.WallTime())\n print('Status:', output['statusName'])\n print('Solutions found :', output['numSolutions'])\n print('Unique solutions: ', output['numUniqueSolutions'])\n\n if output_json:\n return json.dumps(output) \n else:\n return int_solutions # integer representation of solutions\n\n'''\n This method is used to extract the single solution from the solver.\n Because in the case where VarArraySolutionPrinter is not used, the answers are not \n yet extracted from the solver. Use this method to extract the solver.\n'''\ndef getSingleSolution(solver, all_vars):\n solution = []\n # extra coordinates of all rectangles for this solution \n for rect_id in all_vars:\n rect = all_vars[rect_id]\n x1 = solver.Value(rect.x1)\n x2 = solver.Value(rect.x2)\n y1 = solver.Value(rect.y1)\n y2 = solver.Value(rect.y2)\n\n # rect_str = f\"{x1},{y1},{x2},{y2}\"\n coords = [x1, y1, x2, y2];\n # print(rect_str)\n\n solution.append(coords)\n # print(f'Rect #{rect_id}: {x1},{y1} -> {x2},{y2}')\n\n # print(rect_strs)\n # sort the rectangles\n # rect_strs = sorted(rect_strs)\n # single solution as a string\n # solution_str = '-'.join(rect_strs)\n return solution\n\n\n\"\"\"\n converts from string format to integer values. String format, in previous step, was used \n to exclude duplicates.\n params:\n str_solutions: list of strings. 1 string contains is solution\n\"\"\"\ndef str_solutions_to_int(str_solutions):\n\n # list of solutions, each solution is a list of rectangle coords that look like [x1,y1,x2,y2]\n int_solutions = []\n\n # go over all solutions and convert them to int>list>json\n for idx, sol in enumerate(str_solutions):\n # sol is string of coordinates of all rectangles in this solution\n # format: x1,y1,x2,y2-x1,y1,x2,y2\n \n rect_strs = sol.split('-')\n rect_coords = [\n # [x1,y1,x2,y2],\n # [x1,y1,x2,y2],\n # ...\n ]\n\n # convert each rectangle's coords to int\n for rect_str in rect_strs:\n coords_str = rect_str.split(',')\n coords = [int(c) for c in coords_str]\n rect_coords.append(coords)\n\n # print('rect_coords', rect_coords)\n\n int_solutions.append(rect_coords)\n\n return int_solutions\n\n\n\"\"\"\n To get all the solutions of the problem, as they come up. \n https://developers.google.com/optimization/cp/cp_solver#all_solutions\n\n The solutions are all unique. But for the child rectangles that have same dimensions, \n some solution will be repetitive. Because for the algorithm, they are different solutions, \n but because of same size, they are merely permutations of the similar child rectangles - \n having other rectangles' positions fixed.\n\n We want to remove repetitive extra solutions. One way to do this is\n 1. Stringify every rectangle coords in a solution\n (1,2)->(2,3) becomes \"1,2,2,3\"\n\n # here the rectangles are stored as a string: \"1,2,2,3\" where x1=1, y1=2, x2=2, y2=3\n \n 2. Put all these string coords into a sorted list. This sorting is important. \n Because the rectangles (1,2)->(2,3) and (3,3)->(4,4) are actually same size (1x1) rectangles. \n And they can appear in 1st solution as \n [(1,2)->(2,3) , (3,3)->(4,4)]\n and in the 2nd solution as\n [(3,3)->(4,4) , (1,2)->(2,3)]\n\n but this sorted list of strings will ensure both solutions are represented as\n\n [..., \"1,2,2,3\", \"3,3,4,4\", ...]\n\n 3. Join the Set of \"strings (rectangles)\" in to one big string seperated by '-'. For every solution.\n So in resulting big strings (solutions), we will have two similar strings (solutions) \n that be similar and also contain\n\n \"....1,2,2,3-3,3,4,4-....\"\n\n 4. Now add all these \"strings (solutions)\" into a Set. this adding to the set \n will remove similar strings. And hence duplicate solutions will be removed.\n\n\"\"\"\nclass VarArraySolutionPrinter(cp_model.CpSolverSolutionCallback):\n\n def __init__(self, variables):\n cp_model.CpSolverSolutionCallback.__init__(self)\n self.__variables = variables\n self.__solution_count = 0\n\n # hold the calculated solutions\n self.__solutions = []\n self.__unique_solutions = set()\n\n def on_solution_callback(self):\n self.__solution_count += 1\n # print('Sol#: ', self.__solution_count)\n\n # using list to hold the coordinate strings of rectangles\n rect_strs = []\n\n # extra coordinates of all rectangles for this solution \n for rect_id in self.__variables:\n rect = self.__variables[rect_id]\n x1 = self.Value(rect.x1)\n x2 = self.Value(rect.x2)\n y1 = self.Value(rect.y1)\n y2 = self.Value(rect.y2)\n\n rect_str = f\"{x1},{y1},{x2},{y2}\"\n # print(rect_str)\n\n rect_strs.append(rect_str)\n # print(f'Rect #{rect_id}: {x1},{y1} -> {x2},{y2}')\n\n # print(rect_strs)\n\n # sort the rectangles\n rect_strs = sorted(rect_strs)\n\n # single solution as a string\n solution_str = '-'.join(rect_strs)\n # print(solution_str)\n\n # store the solutions\n self.__solutions.append(solution_str)\n self.__unique_solutions.add(solution_str) # __unique_solutions is a set, so duplicates will get removed\n\n\n def solution_count(self):\n return self.__solution_count\n\n # returns all solutions \n def get_solutions(self):\n return self.__solutions\n\n \"\"\"\n returns unique solutions\n returns the permutation free list of solution strings \n \"\"\"\n def get_unique_solutions(self):\n return list(self.__unique_solutions) # __unique_solutions is a Set, convert to list\n\n\n'''\nnon-API method. Used for testing and running locally / in a Notebook.\nDraws the rectangles\n'''\n\ndef drawRectsFromCoords(rect_coords, parent_rects):\n import matplotlib.pyplot as plt\n import matplotlib.patches as patches\n\n # TODO: to add support for multiple parent rects, update here\n xSize = parent_rects[0][0]\n ySize = parent_rects[0][1]\n\n # draw rectangle\n fig,ax = plt.subplots(1)\n plt.xlim(0,xSize)\n plt.ylim(0,ySize)\n plt.gca().set_aspect('equal', adjustable='box')\n \n # print coords\n coords = []\n colors = ['r', 'g', 'b', 'y', 'brown', 'black', 'violet', 'pink', 'gray', 'orange', 'b', 'y']\n for idx, coords in enumerate(rect_coords):\n x1=coords[0]\n y1=coords[1]\n x2=coords[2]\n y2=coords[3]\n # print(f\"{x1}, {y1} -> {x2}, {y2}\")\n\n width = abs(x1-x2)\n height = abs(y1-y2)\n # print(f\"Rect#{idx}: {width}x{height}\")\n\n # Create a Rectangle patch\n rect_shape = patches.Rectangle((x1,y1), width, height,facecolor=colors[idx])\n # Add the patch to the Axes\n ax.add_patch(rect_shape)\n plt.show()\n\n\n\n\n# for testing\nif __name__ == '__main__':\n\n child_rects = [\n # [1, 1],\n # [2, 2],\n # [1, 3],\n # [4, 3],\n # [2, 4],\n # [2, 2],\n\n [27, 17],\n [27, 17],\n [18, 56],\n\n # [3, 3],\n # [3, 3],\n # [3, 3],\n # [3, 3],\n ]\n\n # parent_rects = [[6,6]]\n parent_rects = [[84,72]]\n\n solutions = StockCutter(child_rects, parent_rects, output_json=False) # get the integer solution\n\n for sol in solutions:\n print(sol)\n drawRectsFromCoords(sol, parent_rects)" }, { "path": "deployment/stock_cutter_1d.py", "content": "'''\nOriginal Author: Serge Kruk\nOriginal Version: https://github.com/sgkruk/Apress-AI/blob/master/cutting_stock.py\n\nUpdated by: Emad Ehsan\nV2: https://github.com/emadehsan/Apress-AI/blob/master/my-models/custom_cutting_stock.py\n\nV3 is following:\n'''\nfrom ortools.linear_solver import pywraplp\nfrom math import ceil\nfrom random import randint\nimport json\n\ndef newSolver(name,integer=False):\n return pywraplp.Solver(name,\\\n pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING \\\n if integer else \\\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\n\n'''\nreturn a printable value\n'''\ndef SolVal(x):\n if type(x) is not list:\n return 0 if x is None \\\n else x if isinstance(x,(int,float)) \\\n else x.SolutionValue() if x.Integer() is False \\\n else int(x.SolutionValue())\n elif type(x) is list:\n return [SolVal(e) for e in x]\n\ndef ObjVal(x):\n return x.Objective().Value()\n\n\ndef gen_data(num_orders):\n R=[] # small rolls\n # S=0 # seed?\n for i in range(num_orders):\n R.append([randint(1,12), randint(5,40)])\n return R\n\n\ndef solve_model(demands, parent_width=100, cutStyle='exactCuts'):\n ''' demands = [\n [1, 3], # [quantity, width]\n [3, 5],\n ...\n ]\n\n parent_width = integer\n '''\n num_orders = len(demands)\n solver = newSolver('Cutting Stock', True)\n k,b = bounds(demands, parent_width)\n\n # array of boolean declared as int, if y[i] is 1, \n # then y[i] Big roll is used, else it was not used\n y = [ solver.IntVar(0, 1, f'y_{i}') for i in range(k[1]) ] \n\n # x[i][j] = 3 means that small-roll width specified by i-th order\n # must be cut from j-th order, 3 tmies \n x = [[solver.IntVar(0, b[i], f'x_{i}_{j}') for j in range(k[1])] \\\n for i in range(num_orders)]\n \n unused_widths = [ solver.NumVar(0, parent_width, f'w_{j}') \\\n for j in range(k[1]) ] \n \n # will contain the number of big rolls used\n nb = solver.IntVar(k[0], k[1], 'nb')\n\n # consntraint: demand fullfilment\n for i in range(num_orders): \n # small rolls from i-th order must be at least as many in quantity\n # as specified by the i-th order\n if cutStyle == 'minWaste':\n solver.Add(sum(x[i][j] for j in range(k[1])) >= demands[i][0]) \n else:\n # probably cutStyle == exactCuts\n solver.Add(sum(x[i][j] for j in range(k[1])) == demands[i][0]) \n\n # constraint: max size limit\n for j in range(k[1]):\n # total width of small rolls cut from j-th big roll, \n # must not exceed big rolls width\n solver.Add( \\\n sum(demands[i][1]*x[i][j] for i in range(num_orders)) \\\n <= parent_width*y[j] \\\n ) \n\n # width of j-th big roll - total width of all orders cut from j-th roll\n # must be equal to unused_widths[j]\n # So, we are saying that assign unused_widths[j] the remaining width of j'th big roll\n solver.Add(parent_width*y[j] - sum(demands[i][1]*x[i][j] for i in range(num_orders)) == unused_widths[j])\n\n '''\n Book Author's note from page 201:\n [the following constraint] breaks the symmetry of multiple solutions that are equivalent \n for our purposes: any permutation of the rolls. These permutations, and there are K! of \n them, cause most solvers to spend an exorbitant time solving. With this constraint, we \n tell the solver to prefer those permutations with more cuts in roll j than in roll j + 1. \n The reader is encouraged to solve a medium-sized problem with and without this \n symmetry-breaking constraint. I have seen problems take 48 hours to solve without the \n constraint and 48 minutes with. Of course, for problems that are solved in seconds, the \n constraint will not help; it may even hinder. But who cares if a cutting stock instance \n solves in two or in three seconds? We care much more about the difference between two \n minutes and three hours, which is what this constraint is meant to address\n '''\n if j < k[1]-1: # k1 = total big rolls\n # total small rolls of i-th order cut from j-th big roll must be >=\n # totall small rolls of i-th order cut from j+1-th big roll\n solver.Add(sum(x[i][j] for i in range(num_orders)) >= sum(x[i][j+1] for i in range(num_orders)))\n\n # find & assign to nb, the number of big rolls used\n solver.Add(nb == solver.Sum(y[j] for j in range(k[1])))\n\n ''' \n minimize total big rolls used\n let's say we have y = [1, 0, 1]\n here, total big rolls used are 2. 0-th and 2nd. 1st one is not used. So we want our model to use the \n earlier rolls first. i.e. y = [1, 1, 0]. \n The trick to do this is to define the cost of using each next roll to be higher. So the model would be\n forced to used the initial rolls, when available, instead of the next rolls.\n\n So instead of Minimize ( Sum of y ) or Minimize( Sum([1,1,0]) )\n we Minimize( Sum([1*1, 1*2, 1*3]) )\n ''' \n\n '''\n Book Author's note from page 201:\n\n There are alternative objective functions. For example, we could have minimized the sum of the waste. This makes sense, especially if the demand constraint is formulated as an inequality. Then minimizing the sum of waste Chapter 7 advanCed teChniques\n will spend more CPU cycles trying to find more efficient patterns that over-satisfy demand. This is especially good if the demand widths recur regularly and storing cut rolls in inventory to satisfy future demand is possible. Note that the running time will grow quickly with such an objective function\n '''\n\n Cost = solver.Sum((j+1)*y[j] for j in range(k[1]))\n\n solver.Minimize(Cost)\n\n status = solver.Solve()\n numRollsUsed = SolVal(nb)\n\n return status, \\\n numRollsUsed, \\\n rolls(numRollsUsed, SolVal(x), SolVal(unused_widths), demands), \\\n SolVal(unused_widths), \\\n solver.WallTime()\n\ndef bounds(demands, parent_width=100):\n '''\n b = [sum of widths of individual small rolls of each order]\n T = local var. stores sum of widths of adjecent small-rolls. When the width reaches 100%, T is set to 0 again.\n k = [k0, k1], k0 = minimum big-rolls requierd, k1: number of big rolls that can be consumed / cut from\n TT = local var. stores sum of widths of of all small-rolls. At the end, will be used to estimate lower bound of big-rolls\n '''\n num_orders = len(demands)\n b = []\n T = 0\n k = [0,1]\n TT = 0\n\n for i in range(num_orders):\n # q = quantity, w = width; of i-th order\n quantity, width = demands[i][0], demands[i][1]\n # TODO Verify: why min of quantity, parent_width/width?\n # assumes widths to be entered as percentage\n # int(round(parent_width/demands[i][1])) will always be >= 1, because widths of small rolls can't exceed parent_width (which is width of big roll)\n # b.append( min(demands[i][0], int(round(parent_width / demands[i][1]))) )\n b.append( min(quantity, int(round(parent_width / width))) )\n\n # if total width of this i-th order + previous order's leftover (T) is less than parent_width\n # it's fine. Cut it.\n if T + quantity*width <= parent_width:\n T, TT = T + quantity*width, TT + quantity*width\n # else, the width exceeds, so we have to cut only as much as we can cut from parent_width width of the big roll\n else:\n while quantity:\n if T + width <= parent_width:\n T, TT, quantity = T + width, TT + width, quantity-1\n else:\n k[1],T = k[1]+1, 0 # use next roll (k[1] += 1)\n k[0] = int(round(TT/parent_width+0.5))\n\n print('k', k)\n print('b', b)\n\n return k, b\n\n'''\n nb: array of number of rolls to cut, of each order\n \n w: \n demands: [\n [quantity, width],\n [quantity, width],\n [quantity, width],\n ]\n'''\ndef rolls(nb, x, w, demands):\n consumed_big_rolls = []\n num_orders = len(x) \n # go over first row (1st order)\n # this row contains the list of all the big rolls available, and if this 1st (0-th) order\n # is cut from any big roll, that big roll's index would contain a number > 0\n for j in range(len(x[0])):\n # w[j]: width of j-th big roll \n # int(x[i][j]) * [demands[i][1]] width of all i-th order's small rolls that are to be cut from j-th big roll \n RR = [ abs(w[j])] + [ int(x[i][j])*[demands[i][1]] for i in range(num_orders) \\\n if x[i][j] > 0 ] # if i-th order has some cuts from j-th order, x[i][j] would be > 0\n consumed_big_rolls.append(RR)\n\n return consumed_big_rolls\n\n\n\n'''\nthis model starts with some patterns and then optimizes those patterns\n'''\ndef solve_large_model(demands, parent_width=100, cutStyle='exactCuts'):\n num_orders = len(demands)\n iter = 0\n patterns = get_initial_patterns(demands)\n # print('method#solve_large_model, patterns', patterns)\n\n # list quantities of orders\n quantities = [demands[i][0] for i in range(num_orders)]\n print('quantities', quantities)\n\n while iter < 20:\n status, y, l = solve_master(patterns, quantities, parent_width=parent_width, cutStyle=cutStyle)\n iter += 1\n\n # list widths of orders\n widths = [demands[i][1] for i in range(num_orders)]\n new_pattern, objectiveValue = get_new_pattern(l, widths, parent_width=parent_width)\n\n # print('method#solve_large_model, new_pattern', new_pattern)\n # print('method#solve_large_model, objectiveValue', objectiveValue)\n\n for i in range(num_orders):\n # add i-th cut of new pattern to i-thp pattern\n patterns[i].append(new_pattern[i])\n\n status, y, l = solve_master(patterns, quantities, parent_width=parent_width, integer=True, cutStyle=cutStyle) \n\n return status, \\\n patterns, \\\n y, \\\n rolls_patterns(patterns, y, demands, parent_width=parent_width)\n\n\n'''\nDantzig-Wolfe decomposition splits the problem into a Master Problem MP and a sub-problem SP.\n\nThe Master Problem: provided a set of patterns, find the best combination satisfying the demand\n\nC: patterns\nb: demand\n'''\ndef solve_master(patterns, quantities, parent_width=100, integer=False, cutStyle='exactCuts'):\n title = 'Cutting stock master problem'\n num_patterns = len(patterns)\n n = len(patterns[0])\n # print('**num_patterns x n: ', num_patterns, 'x', n)\n # print('**patterns recived:')\n # for p in patterns:\n # print(p)\n\n constraints = []\n\n solver = newSolver(title, integer)\n\n # y is not boolean, it's an integer now (as compared to y in approach used by solve_model)\n y = [ solver.IntVar(0, 1000, '') for j in range(n) ] # right bound?\n # minimize total big rolls (y) used\n Cost = sum(y[j] for j in range(n)) \n solver.Minimize(Cost)\n\n # for every pattern\n for i in range(num_patterns):\n # add constraint that this pattern (demand) must be met\n # there are m such constraints, for each pattern\n\n if cutStyle == 'minWaste':\n constraints.append(solver.Add( sum(patterns[i][j]*y[j] for j in range(n)) >= quantities[i]) ) \n else:\n # probably cutStyle == exactCuts\n constraints.append(solver.Add( sum(patterns[i][j]*y[j] for j in range(n)) == quantities[i]) ) \n\n\n status = solver.Solve()\n y = [int(ceil(e.SolutionValue())) for e in y]\n\n l = [0 if integer else constraints[i].DualValue() for i in range(num_patterns)]\n # sl = [0 if integer else constraints[i].name() for i in range(num_patterns)]\n # print('sl: ', sl)\n\n # l = [0 if integer else u[i].Ub() for i in range(m)]\n toreturn = status, y, l\n # l_to_print = [round(dd, 2) for dd in toreturn[2]]\n # print('l: ', len(l_to_print), '->', l_to_print)\n # print('l: ', toreturn[2])\n return toreturn\n\n\n'''\nTODO Make sense of this:\n'''\ndef get_new_pattern(l, w, parent_width=100):\n solver = newSolver('Cutting stock sub-problem', True)\n n = len(l)\n new_pattern = [ solver.IntVar(0, parent_width, '') for i in range(n) ]\n\n # maximizes the sum of the values times the number of occurrence of that roll in a pattern\n Cost = sum( l[i] * new_pattern[i] for i in range(n))\n solver.Maximize(Cost)\n\n # ensuring that the pattern stays within the total width of the large roll \n solver.Add( sum( w[i] * new_pattern[i] for i in range(n)) <= parent_width ) \n\n status = solver.Solve()\n return SolVal(new_pattern), ObjVal(solver)\n\n\n'''\nthe initial patterns must be such that they will allow a feasible solution, \none that satisfies all demands. \nConsidering the already complex model, let’s keep it simple. \nOur initial patterns have exactly one roll per pattern, as obviously feasible as inefficient.\n'''\ndef get_initial_patterns(demands):\n num_orders = len(demands)\n return [[0 if j != i else 1 for j in range(num_orders)]\\\n for i in range(num_orders)]\n\ndef rolls_patterns(patterns, y, demands, parent_width=100):\n R, m, n = [], len(patterns), len(y)\n\n for j in range(n):\n for _ in range(y[j]):\n RR = []\n for i in range(m):\n if patterns[i][j] > 0:\n RR.extend( [demands[i][1]] * int(patterns[i][j]) )\n used_width = sum(RR)\n R.append([parent_width - used_width, RR])\n\n return R\n\n\n'''\nchecks if all small roll widths (demands) smaller than parent roll's width\n'''\ndef checkWidths(demands, parent_width):\n for quantity, width in demands:\n if width > parent_width:\n print(f'Small roll width {width} is greater than parent rolls width {parent_width}. Exiting')\n return False\n return True\n\n\n'''\n params\n child_rolls: \n list of lists, each containing quantity & width of rod / roll to be cut\n e.g.: [ [quantity, width], [quantity, width], ...]\n parent_rolls: \n list of lists, each containing quantity & width of rod / roll to cut from\n e.g.: [ [quantity, width], [quantity, width], ...]\n cutStyle:\n there are two types of cutting style\n 1. cut exactly as many items as specified: exactCuts\n 2. cut some items more than specified to minimize waste: minWaste\n'''\ndef StockCutter1D(child_rolls, parent_rolls, output_json=True, large_model=True, cutStyle='exactCuts'):\n\n # at the moment, only parent one width of parent rolls is supported\n # quantity of parent rolls is calculated by algorithm, so user supplied quantity doesn't matter?\n # TODO: or we can check and tell the user the user when parent roll quantity is insufficient\n parent_width = parent_rolls[0][1]\n\n if not checkWidths(demands=child_rolls, parent_width=parent_width):\n return []\n\n\n print('child_rolls', child_rolls)\n print('parent_rolls', parent_rolls)\n\n if not large_model:\n print('Running Small Model...')\n status, numRollsUsed, consumed_big_rolls, unused_roll_widths, wall_time = \\\n solve_model(demands=child_rolls, parent_width=parent_width, cutStyle=cutStyle)\n\n # convert the format of output of solve_model to be exactly same as solve_large_model\n print('consumed_big_rolls before adjustment: ', consumed_big_rolls)\n new_consumed_big_rolls = []\n for big_roll in consumed_big_rolls:\n if len(big_roll) < 2:\n # sometimes the solve_model return a solution that contanis an extra [0.0] entry for big roll\n consumed_big_rolls.remove(big_roll)\n continue\n unused_width = big_roll[0]\n subrolls = []\n for subitem in big_roll[1:]:\n if isinstance(subitem, list):\n # if it's a list, concatenate with the other lists, to make a single list for this big_roll\n subrolls = subrolls + subitem\n else:\n # if it's an integer, add it to the list\n subrolls.append(subitem)\n new_consumed_big_rolls.append([unused_width, subrolls])\n print('consumed_big_rolls after adjustment: ', new_consumed_big_rolls)\n consumed_big_rolls = new_consumed_big_rolls\n \n else:\n print('Running Large Model...');\n status, A, y, consumed_big_rolls = solve_large_model(demands=child_rolls, parent_width=parent_width, cutStyle=cutStyle)\n\n numRollsUsed = len(consumed_big_rolls)\n # print('A:', A, '\\n')\n # print('y:', y, '\\n')\n\n\n STATUS_NAME = ['OPTIMAL',\n 'FEASIBLE',\n 'INFEASIBLE',\n 'UNBOUNDED',\n 'ABNORMAL',\n 'NOT_SOLVED'\n ]\n\n output = {\n \"statusName\": STATUS_NAME[status],\n \"numSolutions\": '1',\n \"numUniqueSolutions\": '1',\n \"numRollsUsed\": numRollsUsed,\n \"solutions\": consumed_big_rolls # unique solutions\n }\n\n\n # print('Wall Time:', wall_time)\n print('numRollsUsed', numRollsUsed)\n print('Status:', output['statusName'])\n print('Solutions found :', output['numSolutions'])\n print('Unique solutions: ', output['numUniqueSolutions'])\n\n if output_json:\n return json.dumps(output) \n else:\n return consumed_big_rolls\n\n\n'''\nDraws the big rolls on the graph. Each horizontal colored line represents one big roll.\nIn each big roll (multi-colored horizontal line), each color represents small roll to be cut from it.\nIf the big roll ends with a black color, that part of the big roll is unused width.\n\nTODO: Assign each child roll a unique color\n'''\ndef drawGraph(consumed_big_rolls, child_rolls, parent_width):\n import matplotlib.pyplot as plt\n import matplotlib.patches as patches\n\n # TODO: to add support for multiple different parent rolls, update here\n xSize = parent_width # width of big roll\n ySize = 10 * len(consumed_big_rolls) # one big roll will take 10 units vertical space\n\n # draw rectangle\n fig,ax = plt.subplots(1)\n plt.xlim(0, xSize)\n plt.ylim(0, ySize)\n plt.gca().set_aspect('equal', adjustable='box')\n \n # print coords\n coords = []\n colors = ['r', 'g', 'b', 'y', 'brown', 'violet', 'pink', 'gray', 'orange', 'b', 'y']\n colorDict = {}\n i = 0\n for quantity, width in child_rolls:\n colorDict[width] = colors[i % 11]\n i+= 1\n\n # start plotting each big roll horizontly, from the bottom\n y1 = 0\n for i, big_roll in enumerate(consumed_big_rolls):\n '''\n big_roll = [leftover_width, [small_roll_1_1, small_roll_1_2, other_small_roll_2_1]]\n '''\n unused_width = big_roll[0]\n small_rolls = big_roll[1]\n\n x1 = 0\n x2 = 0\n y2 = y1 + 8 # the height of each big roll will be 8 \n for j, small_roll in enumerate(small_rolls):\n x2 = x2 + small_roll\n print(f\"{x1}, {y1} -> {x2}, {y2}\")\n width = abs(x1-x2)\n height = abs(y1-y2)\n # print(f\"Rect#{idx}: {width}x{height}\")\n # Create a Rectangle patch\n rect_shape = patches.Rectangle((x1,y1), width, height, facecolor=colorDict[small_roll], label=f'{small_roll}')\n ax.add_patch(rect_shape) # Add the patch to the Axes\n x1 = x2 # x1 for next small roll in same big roll will be x2 of current roll \n\n # now that all small rolls have been plotted, check if a there is unused width in this big roll\n # set the unused width at the end as black colored rectangle\n if unused_width > 0:\n width = unused_width\n rect_shape = patches.Rectangle((x1,y1), width, height, facecolor='black', label='Unused')\n ax.add_patch(rect_shape) # Add the patch to the Axes\n\n y1 += 10 # next big roll will be plotted on top of current, a roll height is 8, so 2 will be margin between rolls\n\n plt.show()\n\n\nif __name__ == '__main__':\n\n child_rolls = [\n # [quantity, width],\n # [6, 25],\n # [12, 21],\n # [7, 26],\n # [3, 23],\n # [8, 33],\n # [2, 15],\n # [2, 34],\n\n # [3, 3],\n # [3, 4],\n\n [3,3],\n [3,1],\n [2,4],\n [2,2]\n\n # [3,30],\n # [2,72],\n # [5,50]\n ]\n\n # child_rolls = gen_data(3)\n # parent_rolls = [[10, 120]]\n # parent_rolls = [[10, 8]]\n parent_rolls = [[10, 6]]\n # parent_rolls = [[10, 144]]\n\n\n consumed_big_rolls = StockCutter1D(child_rolls, parent_rolls, output_json=False, large_model=False)\n print (consumed_big_rolls)\n\n for idx, roll in enumerate(consumed_big_rolls):\n print(f'Roll #{idx}:', roll)\n\n\n drawGraph(consumed_big_rolls, child_rolls, parent_width=parent_rolls[0][1])" }, { "path": "infile.txt", "content": "58\t58\t38\n58\t58\t47.25\n58\t58\t47.25\n58\t58\t47\n58\t58\t22.75\n58\t58\t58.25\n58.25\t58.25\t58.25\n58.25\t58.25\t58.5\n58\t58\t71\n58\t58\t28.5\n\t\t\n\t\t\n\t\t\n34.5\t34.5\t64.5\n16.5\t16.5\t70\n46.5\t46.5\t47\n23\t23\t75" }, { "path": "tests/basic_test.py", "content": "import pytest\nfrom csp.read_lengths import get_data\n\ndef test_get_data():\n infile = \"infile.txt\"\n nrs = get_data(infile)\n print(nrs)\n assert nrs[0][1] == 38\n" } ]