Good idea! I've put a UI on the script above. Also I made a couple of improvemnents:
1. Now the fitting algorithm is run multiple times (see the Max Attempts value), changing the order (and possibly rotation) each time. It is a non-intelligent, naive approach, but it does improve the result in many cases. If you don't have many items to pack, you can crank it up to several thousand attempts. If you have many items to pack, it might take too long. The first four attempts cycle through the sort modes considered most-promising and the fifth and subsequent attempts are just random. It is interesting to look at the results text afterwardsāsometimes the best result occurred after a thousand random attemptsābut mostly it's much earlier.
2. The script now tries to pack any available artboards in the document, starting from the first. So to use the script, set up your artboards how you want them.
Usage: set up artboards that you want packed, select the items to pack, then run script. Note that an "item" can be a group or any page item.
I've not tested it much, and I'm sure it'll break in some cases, so please let me know how it goes. I will try to edit the script in this post to fix problems.
- Mark
Update: 2021-10-30_2235
- script now iterates over, and scores, each attempt, rather than each artboard's attempt (the last version may give a worse result even if the early artboards are good)
- added a random button to the UIāthis is fun to do some quick, interactive packing, but is unlikely to provide the strongest packing.
- added a Try harder checkboxāselect this to stop the script from stopping at the first viable solution (ie. no remaining unpacked items)
Update: 2021-11-02_0856
- script now handles clipped objects correctly (I think!). It's general solution which may be handy for other scripts (see function getItemBounds).
- added an option (in script settings object, not UI) for showing the packing gridājust for debugging
Update: 2021-11-07_1422
- script now handles groups with nested clipping groups
/*
Pack selected items onto artboards
by m1b: https://community.adobe.com/t5/user/viewprofilepage/user-id/13791991
here: https://community.adobe.com/t5/illustrator-discussions/how-to-organize-multiple-different-objects-on-one-sheet-with-a-defined-gap-inbetween-them/m-p/12475475#M295934
version: 2021-11-07_1412
Bin packing algorithm by trentium: https://stackoverflow.com/users/7696162/trentium
from here: https://stackoverflow.com/questions/56642111/bin-packing-js-implementation-using-box-rotation-for-best-fit
* modified to conform with ExtendScript syntax and minor functionality I wanted
Notes:
- script will pack items into available artboards, so set those up according
to your packing needs.
- if you enable 'Try Harder' the script won't stop at the first adequate packing
attempt (ie. no unpacked items); mostly this is fine, but sometimes further
attempts can yield better a result. Look at the results text to see which attempt
was chosen as best. Go and make yourself a coffee while it tries thousands of
attempts: sometimes it will hit on a winner.
- the first 4 attempts always use pre-set sort functions, chosen as being most likely
to provide a good result; after that every attempt does a random shuffle.
- the pre-calculated Max Attempts number is just a very rough guide and doesn't mean much.
- the Random button runs a single, random-ordered packing without dismissing the dialog,
which could be handy if you're looking for an aesthetic result.
- scoring system but favours packing more items in fewer bins with less remaining.
- scoring can be weighted somewhat to maximize area or maximize item count.
- padding or margin can be negative (to cause overlaps).
- comment out the settings.ui line to run with no UI.
- the term 'bin' is used synonymously with 'artboard' in this script, from 'bin packing'.
*/
try {
var settings = {
// document
document: app.activeDocument,
// page items (can be groupItems)
items: app.activeDocument.selection,
// space between items, in pts, or can use 'mm' or 'inch'
padding: '1mm',
// space around edges of artboards, in pts, or can use 'mm' or 'inch'
margin: '5mm',
// is it okay to rotate 90 degrees?
allowRotation: true,
// which is better:
// fit more items? use 'count' (default if left undefined)
// fit larger area of items? use 'area'
bestFitBy: 'count',
// the number of attempts to fit items;
// more attempts sometimes works better
// but often doesn't
// leave undefined to auto-calculate
maxAttempts: undefined,
// should we stop on first successul packing,
// or keep trying to improve?
tryHarder: false,
// leave undefined if don't need UI
ui: packingDialog,
// debugging options
showGrid: false,
showOnlyGrid: false
}
} catch (error) {
alert('Please select some items and try again.')
}
function packingDialog(packFunction) {
settings.packFunction = packFunction;
var dialog = makeUI();
if (dialog == undefined) return;
dialog.center();
var result = dialog.show();
dialog = null;
if (result == 1) {
// do the packing
// show progress window
var pb = makeProgressWindow();
if (pb == undefined) return;
settings.pb = pb;
pb.center();
pb.show();
packFunction(settings);
}
// the packing settings UI
function makeUI() {
var doc = settings.document,
items = settings.items,
padding = settings.padding || '0 mm',
margin = settings.margin || '0 mm',
maxAttempts = settings.maxAttempts || Math.round((4 + (0.75 / items.length * 5000)));
var w = new Window("dialog", 'Pack Items', undefined, { closeButton: false });
w.preferredSize.width = 250;
var introGroup = w.add('group {orientation:"column", alignChildren: "fill", alignment: ["fill","top"], margins: [15,15,15,15] }');
introGroup.add('statictext { text:"Trying to pack ' + settings.items.length + ' items onto ' + settings.document.artboards.length + ' artboards", justify: "center" }');
var panelGroup = w.add('group {orientation:"row", alignChildren:["left","top"] }');
var panel1 = panelGroup.add('panel');
var panel2 = panelGroup.add('panel');
var paddingGroup = panel1.add("group {orientation:'column', alignment:['center','top'], alignChildren: ['left','top'], margins:[0,10,0,0], preferredSize: [120,-1] }"),
paddingLabel = paddingGroup.add('statictext { text: "Space between items:" }'),
paddingField = paddingGroup.add('edittext {text: "' + padding + '", preferredSize: [120,-1] }');
var marginGroup = panel1.add("group {orientation:'column', alignment:['center','top'], alignChildren: ['left','top'], margins:[0,10,0,0], preferredSize: [120,-1] }"),
marginLabel = marginGroup.add('statictext { text: "Artboard margin:" }'),
marginField = marginGroup.add('edittext {text: "' + margin + '", preferredSize: [120,-1] }');
var maxAttemptsGroup = panel2.add('group {orientation:"column", alignment:["center","top"], alignChildren: ["left","top"], margins:[0,10,0,0], preferredSize: [120,-1] }'),
maxAttemptsLabel = maxAttemptsGroup.add('statictext { text:"Max attempts:" }'),
maxAttemptsField = maxAttemptsGroup.add('edittext { text: "' + maxAttempts + '", preferredSize: [120,-1] }');
var bestFitGroup = panel2.add('group {orientation:"column", alignment:["center","top"], alignChildren: ["left","top"], margins:[0,10,0,0], preferredSize: [120,-1] }'),
bestFitLabel = bestFitGroup.add('statictext { text:"Maximize:" }'),
bestFitMenu = bestFitGroup.add('dropDownList { preferredSize:[120,-1] }');
var checkboxGroup = panel2.add('group {orientation:"column", alignment:["center","top"], alignChildren: ["left","top"], margins:[0,20,0,0], preferredSize: [120,-1] }'),
allowRotationCheckbox = checkboxGroup.add("Checkbox { alignment:'left', text:'Allow 90Ā° rotation', margins:[0,10,0,0], value:" + settings.allowRotation + " }"),
tryHarderCheckbox = checkboxGroup.add("Checkbox { alignment:'left', text:'Try harder', margins:[0,10,0,0], value:" + settings.tryHarder + " }");
var buttonGroup = w.add('group {orientation:"row", alignment:["center","bottom"], alignChildren: ["right","bottom"], margins: [0,-5,0,0] }'),
randomGroup = buttonGroup.add('group {orientation:"column", alignment:["center","bottom"], alignChildren: ["right","bottom"], margins: [0,0,50,0] }'),
randomResult = randomGroup.add('statictext { text:"", alignment: ["fill","bottom"], justify: "center" }'),
randomButton = randomGroup.add('button', undefined, 'Random'),
cancelButton = buttonGroup.add('button', undefined, 'Cancel', { name: 'cancel' }),
packButton = buttonGroup.add('button', undefined, 'Pack', { name: 'ok' });
bestFitMenu.add('item', 'Items packed');
bestFitMenu.add('item', 'Area packed');
bestFitMenu.selection = 0;
function updateSettings() {
settings.padding = paddingField.text;
settings.margin = marginField.text;
settings.maxAttempts = Number(maxAttemptsField.text);
settings.bestFitBy = bestFitMenu.selection.index == 0 ? 'count' : 'area';
settings.allowRotation = allowRotationCheckbox.value;
settings.tryHarder = tryHarderCheckbox.value;
}
randomButton.onClick = function () {
if (settings.lastAttemptWasRandom == true)
undoRandomAttempt();
updateSettings();
settings.randomAttempt = true;
var result = settings.packFunction(settings);
randomResult.text = result.packedItemCount + ' / ' + result.totalItemCount;
// randomResult.text = result.score;
settings.lastAttemptWasRandom = true;
settings.randomAttempt = false;
app.redraw();
}
function undoRandomAttempt() {
app.undo();
settings.lastAttemptWasRandom = false;
}
packButton.onClick = function () {
if (settings.lastAttemptWasRandom == true)
undoRandomAttempt();
updateSettings();
w.close(1);
};
return w;
}
// the progress bars and results UI
function makeProgressWindow() {
if (!w)
var w = new Window('window', 'Packing Items', undefined, { closeButton: false, resize: true });
var itemsPackedGroup = w.add("group {orientation:'column', alignChildren: 'fill', alignment:['fill','top'], margins: [15,15,15,15] }"),
pb1Label = itemsPackedGroup.add('statictext { text:"Items packed" }'),
pb1Row = itemsPackedGroup.add("group {orientation:'row', alignChildren: 'fill', alignment:['fill','top'], margins: [15,15,15,15] }"),
pb1 = pb1Row.add('progressbar { bounds: [12, 12, 400, 12], value: 0, maxvalue: 100 }');
pb1.display = pb1Row.add('statictext { text:"1 / 1", size:[100,24] }');
w.stack = w.add("group {orientation:'stack', alignment:['fill','fill']}");
var progressGroup = w.stack.add("group {orientation:'column', alignChildren: 'fill', alignment:['fill','fill'] }");
var attemptsGroup = progressGroup.add("group {orientation:'column', alignChildren: 'fill', alignment:['fill','top'], margins: [15,15,15,15] }"),
pb2Label = attemptsGroup.add('statictext { text:"Attempt number" }'),
pb2Row = attemptsGroup.add("group {orientation:'row', alignChildren: 'fill', alignment:['fill','top'], margins: [15,15,15,15] }"),
pb2 = pb2Row.add('progressbar { bounds: [12, 12, 400, 12], value: 0, maxvalue: 100 }');
pb2.display = pb2Row.add('statictext { text:"1 / 1", minimumSize: [100,24] }');
var resultsGroup = w.stack.add("group {orientation:'column', alignChildren: ['fill','fill'], alignment: ['fill','fill'], margins: [15,0,15,0], visible: false }"),
infoText = resultsGroup.add('statictext { text:"results", preferredSize: [-1,100], properties: { multiline: true } }');
var resultsButtons = resultsGroup.add("group {orientation:'row', alignment:['right','bottom'], scrolling: true }"),
doneButton = resultsButtons.add('button', undefined, 'Done', { name: 'ok' });
doneButton.onClick = function () { w.close(1) };
w.defaultElement = doneButton;
w.setProgress = function (pbIndex, value, maxValue) {
var pb = [pb1, pb2][pbIndex - 1];
pb.value = value;
if (maxValue != undefined)
pb.maxvalue = maxValue;
pb.display.text = value + ' / ' + maxValue;
w.update();
}
w.setBestBinCount = function (binCount, attempt) {
pb1Label.text = 'Items packed in ' + binCount + ' artboards on attempt ' + attempt + '.';
}
w.showResults = function (text, n) {
infoText.text = text;
infoText.size.height = n * 23;
resultsGroup.visible = true;
progressGroup.visible = false;
w.update();
}
return w;
}
}
// Blocks are used to keep track
// of items during packing
function Block(doc, item, margin, padding) {
var bounds = getItemBounds(item);
this.doc = doc;
this.item = item;
this.margin = margin;
this.padding = padding;
this.isRotated = false;
this.binIndex = undefined;
this.w = bounds[2] - bounds[0] + this.padding;
this.h = bounds[1] - bounds[3] + this.padding;
this.dx = item.left - bounds[0];
this.dy = item.top - bounds[1];
this.dimensions = {
w: this.w,
h: this.h,
dx: this.dx,
dy: this.dy
};
this.rotatedDimensions = {
w: this.h,
h: this.w,
dx: -this.dy,
dy: item.visibleBounds[2] - bounds[2]
}
}
// swap block between 0 and 90 degree rotation
Block.prototype.rotate = function () {
this.isRotated = !this.isRotated;
this.w = this.isRotated ? this.rotatedDimensions.w : this.dimensions.w;
this.h = this.isRotated ? this.rotatedDimensions.h : this.dimensions.h;
this.dx = this.isRotated ? this.rotatedDimensions.dx : this.dimensions.dx;
this.dy = this.isRotated ? this.rotatedDimensions.dy : this.dimensions.dy;
}
// actually position the item
// where it will be packed
Block.prototype.positionItem = function () {
if (!this.packed) return;
if (this.isRotated) this.item.rotate(90);
var artboardRect = this.doc.artboards[this.binIndex].artboardRect,
l = this.x0 + artboardRect[0] + this.margin,
t = -(this.y0 - artboardRect[1] + this.margin),
r = this.x1 + artboardRect[0] + this.margin,
b = -(this.y1 - artboardRect[1] + this.margin);
if (settings.showGrid) var r = rectanglePathItem([l, t, r, b]);
if (settings.showOnlyGrid) return;
// position the item
this.item.left = l + this.dx;
this.item.top = t + this.dy;
}
// just for debugging
Block.prototype.toString = function () {
if (!this.packed) return '[Object Block, not packed]';
return '[Object Block, bin:' + this.binIndex
+ ', isRotated:' + this.isRotated
+ ', x0:' + this.x0
+ ', y0:' + this.y0
+ ', w:' + this.w
+ ', h:' + this.h
+ ']';
}
// randomises order of an array
if (!Array.prototype.shuffle) Array.prototype.shuffle = (function (Object, max, min) {
"use strict";
return function shuffle(picks) {
if (this === null || this === undefined) throw TypeError("Array.prototype.shuffle called on null or undefined");
var p = picks === null || picks === undefined || picks == 0 ? this.length : picks;
var i = this.length, j = 0, temp;
while (i--) {
j = Math.floor(Math.random() * (i + 1));
// swap randomly chosen element with current element
temp = this[i];
this[i] = this[j];
this[j] = temp;
}
return this.slice(0, p);
};
})(Object, Math.max, Math.min);
(function () {
Packer2 = function (w, h, allowRotation) {
this.allowRotation = (allowRotation == true);
this.init(w, h);
};
Packer2.prototype = {
init: function (w, h) {
this._root = { x: 0, y: 0, w: w, h: h }
},
intersect: function (block0, block1) {
//
// Returns the intersecting block of
// block0 and block1.
//
var ix0 = Math.max(block0.x0, block1.x0);
var ix1 = Math.min(block0.x1, block1.x1);
var iy0 = Math.max(block0.y0, block1.y0);
var iy1 = Math.min(block0.y1, block1.y1);
if (ix0 <= ix1 && iy0 <= iy1) {
return { x0: ix0, y0: iy0, x1: ix1, y1: iy1 };
} else {
return null;
}
},
chunkContains: function (heapBlock0, heapBlock1) {
//
// Determine whether heapBlock0 totally encompasses (ie, contains) heapBlock1.
//
return heapBlock0.x0 <= heapBlock1.x0 && heapBlock0.y0 <= heapBlock1.y0 && heapBlock1.x1 <= heapBlock0.x1 && heapBlock1.y1 <= heapBlock0.y1;
},
expand: function (heapBlock0, heapBlock1) {
//
// Extend heapBlock0 and heapBlock1 if they are
// adjoining or overlapping.
//
if (heapBlock0.x0 <= heapBlock1.x0 && heapBlock1.x1 <= heapBlock0.x1 && heapBlock1.y0 <= heapBlock0.y1) {
heapBlock1.y0 = Math.min(heapBlock0.y0, heapBlock1.y0);
heapBlock1.y1 = Math.max(heapBlock0.y1, heapBlock1.y1);
}
if (heapBlock0.y0 <= heapBlock1.y0 && heapBlock1.y1 <= heapBlock0.y1 && heapBlock1.x0 <= heapBlock0.x1) {
heapBlock1.x0 = Math.min(heapBlock0.x0, heapBlock1.x0);
heapBlock1.x1 = Math.max(heapBlock0.x1, heapBlock1.x1);
}
},
unionMax: function (heapBlock0, heapBlock1) {
//
// Given two heap blocks, determine whether...
//
if (heapBlock0 && heapBlock1) {
// ...heapBlock0 and heapBlock1 intersect, and if so...
var i = this.intersect(heapBlock0, heapBlock1);
if (i) {
if (this.chunkContains(heapBlock0, heapBlock1)) {
// ...if heapBlock1 is contained by heapBlock0...
heapBlock1 = null;
} else if (this.chunkContains(heapBlock1, heapBlock0)) {
// ...or if heapBlock0 is contained by heapBlock1...
heapBlock0 = null;
} else {
// ...otherwise, var's expand both heapBlock0 and
// heapBlock1 to encompass as much of the intersected
// space as possible. In this instance, both heapBlock0
// and heapBlock1 will overlap.
this.expand(heapBlock0, heapBlock1);
this.expand(heapBlock1, heapBlock0);
}
}
}
},
unionAll: function () {
//
// Loop through the entire heap, looking to eliminate duplicative
// heapBlocks, and to extend adjoining or intersecting heapBlocks,
// despite this introducing overlapping heapBlocks.
//
for (var i = 0; i < this.heap.length; i++) {
for (var j = 0; j < this.heap.length; j++) {
if (i !== j) {
this.unionMax(this.heap[i], this.heap[j]);
if (this.heap[i] && this.heap[j]) {
if (this.chunkContains(this.heap[j], this.heap[i])) {
this.heap[i] = null;
} else if (this.chunkContains(this.heap[i], this.heap[j])) {
this.heap[j] = null;
}
}
}
}
}
// Eliminate the duplicative (ie, nulled) heapBlocks.
var onlyBlocks = [];
for (var i = 0; i < this.heap.length; i++) {
if (this.heap[i]) {
onlyBlocks.push(this.heap[i]);
}
}
this.heap = onlyBlocks;
},
fit: function (blocks, binIndex) {
//
// Loop through all the blocks, looking for a heapBlock
// that it can fit into.
//
this.heap = [{ x0: 0, y0: 0, x1: this._root.w, y1: this._root.h }];
var n, block, area = 0, packedBlocks = [], remainingBlocks = [];
for (n = 0; n < blocks.length; n++) {
block = blocks[n];
if (this.findInHeap(block)) {
this.adjustHeap(block);
} else if (this.allowRotation) {
// If the block didn't fit in its current orientation,
// rotate its dimensions and look again.
block.rotate();
if (this.findInHeap(block)) {
this.adjustHeap(block);
}
}
// was it packed?
if (block.packed) {
block.binIndex = binIndex;
packedBlocks.push(block);
area += block.w * block.h;
} else {
remainingBlocks.push(block);
}
}
return { count: packedBlocks.length, area: area, packedBlocks: packedBlocks, remainingBlocks: remainingBlocks };
},
findInHeap: function (block) {
//
// Find a heapBlock that can contain the block.
//
for (var i = 0; i < this.heap.length; i++) {
var heapBlock = this.heap[i];
if (heapBlock && block.w <= heapBlock.x1 - heapBlock.x0 && block.h <= heapBlock.y1 - heapBlock.y0) {
block.x0 = heapBlock.x0;
block.y0 = heapBlock.y0;
block.x1 = heapBlock.x0 + block.w;
block.y1 = heapBlock.y0 + block.h;
block.packed = true;
return true;
}
}
return false;
},
adjustHeap: function (block) {
//
// Find all heap entries that intersect with block,
// and adjust the heap by breaking up the heapBlock
// into the possible 4 blocks that remain after
// removing the intersecting portion.
//
var n = this.heap.length;
for (var i = 0; i < n; i++) {
var heapBlock = this.heap[i];
var overlap = this.intersect(heapBlock, block);
if (overlap) {
// Top
if (overlap.y1 !== heapBlock.y1) {
this.heap.push({
x0: heapBlock.x0,
y0: overlap.y1,
x1: heapBlock.x1,
y1: heapBlock.y1
});
}
// Right
if (overlap.x1 !== heapBlock.x1) {
this.heap.push({
x0: overlap.x1,
y0: heapBlock.y0,
x1: heapBlock.x1,
y1: heapBlock.y1
});
}
// Bottom
if (heapBlock.y0 !== overlap.y0) {
this.heap.push({
x0: heapBlock.x0,
y0: heapBlock.y0,
x1: heapBlock.x1,
y1: overlap.y0
});
}
// Left
if (heapBlock.x0 != overlap.x0) {
this.heap.push({
x0: heapBlock.x0,
y0: heapBlock.y0,
x1: overlap.x0,
y1: heapBlock.y1
});
}
this.heap[i] = null;
}
}
this.unionAll();
}
}
// here is where the main code starts
if (settings) {
settings.info = [];
if (settings.items.length > 0) {
if (settings.ui != undefined) {
// pack items with UI
settings.ui(packItems);
} else {
// pack items with no UI
packItems(settings);
}
} else {
alert('No items selected\nPlease select some items to pack and try again.');
}
}
// pack page items according to parameters
function packItems(p) {
var doc = p.document || app.activeDocument,
items = p.items || doc.selection,
padding = p.padding || 0,
margin = p.margin || 0,
allowRotation = p.allowRotation || false,
bestFitBy = p.bestFitBy || 'count',
maxAttempts = p.maxAttempts || Math.round((4 + (0.75 / items.length * 5000))),
randomAttempt = p.randomAttempt || false,
preferCount = (bestFitBy == 'count'),
preferArea = (bestFitBy == 'area'),
pb = settings.pb,
totalItemCount = items.length,
totalItemArea = 0;
if (padding.constructor.name == 'String')
padding = parseNumberString(padding);
if (margin.constructor.name == 'String')
margin = parseNumberString(margin);
if (randomAttempt == true) maxAttempts = 1;
// make bins
var bins = [],
artboards = doc.artboards;
for (var b = 0; b < artboards.length; b++) {
var rect = artboards[b].artboardRect;
bins.push({
artboard: artboards[b],
width: rect[2] - rect[0] + padding - (margin * 2),
height: rect[3] - rect[1] + padding + (margin * 2)
});
}
if (pb) pb.setProgress(1, 0, totalItemCount);
// sort functions to be tested in order, before trying random sorting
var sortFunctions = [
function (a, b) { return (b.w * b.h) - (a.w * a.h) },
function (a, b) { return Math.max(b.w, b.h) - Math.max(a.w, a.h) },
function (a, b) { return b.w - a.w },
function (a, b) { return b.h - a.h }
];
var bestAttempt = {
index: 0,
count: 0,
area: 0,
binCount: bins.length,
blocks: undefined,
info: undefined,
score: undefined
};
// loop over attempts
for (var a = 0; a < maxAttempts; a++) {
if (pb) pb.setProgress(2, a + 1, maxAttempts);
var attempt = {
index: a + 1,
count: 0,
area: 0,
binCount: 0,
packedBlocks: [],
remainingBlocks: [],
info: [],
score: 0
};
// make a fresh array of 'blocks' which will store positioning information
for (var j = 0; j < items.length; j++) {
attempt.remainingBlocks.push(new Block(doc, items[j], margin, padding));
if (a == 0) totalItemArea += items[j].width * items[j].height;
}
if (randomAttempt == true || attempt.index > sortFunctions.length) {
// random sort
attempt.remainingBlocks.shuffle();
} else {
// try all the sortFunctions once in order
attempt.remainingBlocks.sort(sortFunctions[a]);
}
// loop over bins
for (var b = 0; b < bins.length; b++) {
var bin = bins[b],
// instantiate Trentium's packer
packer = new Packer2(bin.width, -bin.height, allowRotation),
// do the fitting
result = packer.fit(attempt.remainingBlocks, b);
attempt.area += result.area;
attempt.binCount = b + 1;
attempt.packedBlocks = attempt.packedBlocks.concat(result.packedBlocks);
attempt.remainingBlocks = result.remainingBlocks;
if (result.count == 0) break;
// calculate score for this bin
var scoreFactor = (preferCount == true)
? totalItemCount / result.count
: totalItemArea / result.area;
attempt.score += (bins.length / (b + 1)) * scoreFactor * 100;
// add a line to info for this attempt
attempt.info.push('Packed ' + result.count + ' items onto artboard ' + (b + 1) + '.');
if (attempt.remainingBlocks.length == 0) break;
} // bin loop
// an attempt with a lower binCount always wins
attempt.score += (bins.length - attempt.binCount) * 10000;
attempt.score -= attempt.remainingBlocks.length * 10000;
// is this the best attempt so far?
if (attempt.score > bestAttempt.score || bestAttempt.score == undefined) {
bestAttempt.binCount = attempt.binCount;
bestAttempt.area = attempt.area;
bestAttempt.index = attempt.index;
bestAttempt.info = attempt.info.slice(0);
bestAttempt.score = attempt.score;
bestAttempt.packedBlocks = attempt.packedBlocks.slice(0);
if (pb) {
pb.setProgress(1, bestAttempt.packedBlocks.length, totalItemCount);
pb.setBestBinCount(bestAttempt.binCount, bestAttempt.index);
}
if (settings.tryHarder != true && attempt.remainingBlocks.length == 0) break;
}
} // attempts loop
var finalPackedBlockCount = 0;
if (bestAttempt.packedBlocks != undefined) {
finalPackedBlockCount = bestAttempt.packedBlocks.length;
// position the items from the best attempt
for (var i = 0; i < finalPackedBlockCount; i++)
bestAttempt.packedBlocks[i].positionItem();
}
if (randomAttempt != true) {
settings.info = settings.info.concat(bestAttempt.info);
var remainingBlockCount = totalItemCount - finalPackedBlockCount;
if (remainingBlockCount > 0)
settings.info.push(remainingBlockCount + ' item' + (remainingBlockCount > 1 ? 's' : '') + ' remaining.');
if (pb) {
pb.setProgress(1, finalPackedBlockCount, totalItemCount);
pb.showResults(settings.info.join('\n'), settings.info.length);
pb = null;
}
settings = null;
}
// return some info
return { packedItemCount: finalPackedBlockCount, totalItemCount: totalItemCount, score: Math.round(bestAttempt.score) };
} // end packItems
})();
// returns number as points
// converting from mm or inches
// eg '10 mm' returns 28.34645669,
// '1 inch' returns 72
function parseNumberString(str) {
var unit = 1,
inch = 72,
mm = 2.834645669;
if (str.search(/mm/) != -1) {
unit = mm;
} else if (str.search(/(in|inch|\")/) != -1) {
unit = inch;
}
return (parseFloat(str.match(/[\d.-]+/)[0]) * unit);
}
// just draw a rectangle stroke black stroke
function rectanglePathItem(rect) {
var doc = app.activeDocument;
var l = rect[0], t = rect[1], r = rect[2], b = rect[3];
var K100 = new GrayColor();
K100.gray = 100;
var rectangleItem = doc.activeLayer.pathItems.add();
rectangleItem.setEntirePath(Array(Point(l, t), Array(r, t), Array(r, b), Array(l, b)));
rectangleItem.closed = true;
rectangleItem.filled = false;
rectangleItem.stroked = true;
rectangleItem.strokeColor = K100;
return r;
}
// returns visibleBounds or geometricBounds of item
// including correct bounds of clipped group
function getItemBounds(item, geometric, bounds) {
var newBounds = [];
if (item.typename == 'GroupItem') {
var children = item.pageItems,
contentBounds = [];
if (item.hasOwnProperty('clipped') && item.clipped == true) {
// item is clipping group
var clipBounds;
for (var i = 0; i < children.length; i++) {
var child = children[i];
if (child.hasOwnProperty('clipping') && child.clipping == true) {
// the clipping item
clipBounds = child.geometricBounds;
} else {
// a clipped content item
var b = expandBounds(getItemBounds(child, geometric, bounds), contentBounds);
}
}
newBounds = intersectionOfBounds([clipBounds, contentBounds]);
} else {
// item is a normal group
for (var i = 0; i < children.length; i++) {
var child = children[i];
var b = expandBounds(getItemBounds(child, geometric, bounds), contentBounds);
}
newBounds = contentBounds;
}
} else {
// item is not clipping group
newBounds = geometric ? item.geometricBounds : item.visibleBounds;
}
if (bounds == undefined) {
bounds = newBounds;
} else {
bounds = expandBounds(newBounds, bounds);
}
return bounds;
}
// returns bounds that encompass two bounds
function expandBounds(b1, b2) {
var expanded = b2;
for (var i = 0; i < 4; i++) {
if (b1[i] != undefined && b2[i] == undefined) expanded[i] = b1[i];
if (b1[i] == undefined && b2[i] != undefined) expanded[i] = b2[i];
if (b1[i] == undefined && b2[i] == undefined) return;
}
if (b1[0] < b2[0]) expanded[0] = b1[0];
if (b1[1] > b2[1]) expanded[1] = b1[1];
if (b1[2] > b2[2]) expanded[2] = b1[2];
if (b1[3] < b2[3]) expanded[3] = b1[3];
return expanded;
}
function intersectionOfBounds(arrayOfBounds) {
bounds = arrayOfBounds.slice(0).sort(function (a, b) { return b[0] - a[0] || a[1] - b[1] });
var intersection = bounds.shift();
while (b = bounds.shift()) {
if (!boundsDoIntersect(intersection, b)) return;
var l = Math.max(intersection[0], b[0]),
t = Math.min(intersection[1], b[1]),
r = Math.min(intersection[2], b[2]),
b = Math.max(intersection[3], b[3]);
intersection = [l, t, r, b];
}
return intersection;
}
function boundsDoIntersect(bounds1, bounds2) {
return !(
bounds2[0] > bounds1[2] ||
bounds2[2] < bounds1[0] ||
bounds2[1] < bounds1[3] ||
bounds2[3] > bounds1[1]
);
}
1 Correct answer
19
Replies
AdChoices