2382 lines
69 KiB
JavaScript
2382 lines
69 KiB
JavaScript
/** Copyright Stewart Allen <sa@grid.space> -- All Rights Reserved */
|
|
|
|
"use strict";
|
|
|
|
import { base, config, util } from './base.js';
|
|
import { ClipperLib } from '../ext/clip2.esm.js';
|
|
import { newBounds } from './bounds.js';
|
|
import { newPoint, pointFromClipper } from './point.js';
|
|
import { polygons as POLY } from './polygons.js';
|
|
import { earcut } from '../geo/base.js';
|
|
|
|
const { Vector3 } = THREE;
|
|
|
|
let XAXIS = new Vector3(1,0,0),
|
|
DEG2RAD = Math.PI / 180,
|
|
Clipper = ClipperLib.Clipper,
|
|
ClipType = ClipperLib.ClipType,
|
|
PolyType = ClipperLib.PolyType,
|
|
PolyFillType = ClipperLib.PolyFillType,
|
|
CleanPolygon = Clipper.CleanPolygon,
|
|
FillNonZero = PolyFillType.pftNonZero,
|
|
FillEvenOdd = PolyFillType.pftEvenOdd,
|
|
PathSubject = PolyType.ptSubject,
|
|
PathClip = PolyType.ptClip,
|
|
EndType = ClipperLib.EndType,
|
|
JoinType = ClipperLib.JoinType,
|
|
PolyTree = ClipperLib.PolyTree,
|
|
ClipXOR = ClipType.ctXor,
|
|
ClipDiff = ClipType.ctDifference,
|
|
ClipUnion = ClipType.ctUnion,
|
|
ClipIntersect = ClipType.ctIntersection,
|
|
ClipperOffset = ClipperLib.ClipperOffset
|
|
;
|
|
|
|
let seqid = Math.round(Math.random() * 0xffffffff);
|
|
|
|
export class Polygon {
|
|
constructor(points) {
|
|
this.id = seqid++; // polygon unique id
|
|
this.open = false;
|
|
this.points = []; // ordered array of points
|
|
this.depth = 0; // depth nested from top parent (density for support fill)
|
|
if (points) {
|
|
this.addPoints(points);
|
|
}
|
|
}
|
|
|
|
get length() {
|
|
return this.points.length;
|
|
}
|
|
|
|
get deepLength() {
|
|
let len = this.length;
|
|
if (this.inner) {
|
|
for (let inner of this.inner) {
|
|
len += inner.length;
|
|
}
|
|
}
|
|
return len;
|
|
}
|
|
|
|
get bounds() {
|
|
if (this._bounds) {
|
|
return this._bounds;
|
|
}
|
|
let bounds = this._bounds = newBounds();
|
|
for (let point of this.points) {
|
|
bounds.update(point);
|
|
}
|
|
return bounds;
|
|
}
|
|
|
|
toPath2D(offset) {
|
|
return base.paths.pointsToPath(this.points, offset, this.open);
|
|
}
|
|
|
|
toPath3D(offset, height, z) {
|
|
return base.paths.pathTo3D(this.toPath2D(offset), height, z);
|
|
}
|
|
|
|
toString(verbose) {
|
|
let l;
|
|
if (this.inner && this.inner.length) {
|
|
l = '/' + this.inner.map(i => i.toString(verbose)).join(',');
|
|
} else {
|
|
l = '';
|
|
}
|
|
if (verbose) {
|
|
return `P[{${this.area().toFixed(2)}}[${this.points.length}](${this.points.map(p=>`${p.x},${p.y}`).join('|')})${l}]`;
|
|
} else {
|
|
return `P[${this.points.length,this.area().toFixed(2)}${l}]`;
|
|
}
|
|
}
|
|
|
|
toArray() {
|
|
let ov = this.open ? 1 : 0;
|
|
return this.points.map((p, i) => i === 0 ? [ov, p.x, p.y, p.z] : [p.x, p.y, p.z]).flat();
|
|
}
|
|
|
|
fromArray(array) {
|
|
this.open = array[0] === 1;
|
|
for (let i = 1; i < array.length;) {
|
|
this.add(array[i++], array[i++], array[i++]);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
fromVectors(array) {
|
|
return this.addVerts(array.map(v => [ ...v ]).flat());
|
|
}
|
|
|
|
toObject() {
|
|
return {
|
|
points: this.toArray(),
|
|
inner: this.inner?.map(i => i.toArray())
|
|
};
|
|
}
|
|
|
|
fromObject(obj) {
|
|
this.fromArray(obj.points);
|
|
this.inner = obj.inner?.map(a => newPolygon().fromArray(a))
|
|
return this;
|
|
}
|
|
|
|
matches(poly) {
|
|
let tarr = Array.isArray(poly) ? poly : poly.toArray();
|
|
let parr = this.toArray();
|
|
if (tarr.length === parr.length) {
|
|
for (let i = 0; i < tarr.length; i++) {
|
|
if (Math.abs(tarr[i] - parr[i]) > 0.0001) return false;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
xray(deep) {
|
|
const xray = {
|
|
id: this.id,
|
|
len: this.points.length,
|
|
open: this.open,
|
|
depth: this.depth,
|
|
parent: this.parent ? true : false
|
|
};
|
|
if (this.inner) {
|
|
xray.inner = deep ? this.inner.xray(deep) : this.inner;
|
|
}
|
|
return xray;
|
|
}
|
|
|
|
// return which plane (x,y,z) this polygon is coplanar with
|
|
alignment() {
|
|
if (this._aligned) return this._aligned;
|
|
|
|
let diff = {
|
|
x: false,
|
|
y: false,
|
|
z: false
|
|
};
|
|
let last = undefined;
|
|
|
|
// flatten points into array for earcut()
|
|
this.points.forEach(p => {
|
|
if (last) {
|
|
diff.x = diff.x || last.x !== p.x;
|
|
diff.y = diff.y || last.y !== p.y;
|
|
diff.z = diff.z || last.z !== p.z;
|
|
}
|
|
last = p;
|
|
});
|
|
|
|
return this._aligned =
|
|
diff.x === false ? 'yz' :
|
|
diff.y === false ? 'xz' : 'xy';
|
|
}
|
|
|
|
// ensure alignment with XY plane. mark if axes are swapped.
|
|
ensureXY() {
|
|
if (this._swapped) return this;
|
|
switch (this.alignment()) {
|
|
case 'xy':
|
|
break;
|
|
case 'yz':
|
|
this.swap(true, false)._swapped = true;
|
|
break;
|
|
case 'xz':
|
|
this.swap(false, true)._swapped = true;
|
|
break;
|
|
default:
|
|
throw `invalid alignment`;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
// restore to original planar alignment if swapped
|
|
restoreXY() {
|
|
if (!this._swapped) return this;
|
|
switch (this.alignment()) {
|
|
case 'xy':
|
|
break;
|
|
case 'yz':
|
|
this.swap(true, false)._swapped = false;
|
|
break;
|
|
case 'xz':
|
|
this.swap(false, true)._swapped = false;
|
|
break;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
earcut() {
|
|
// gather all points into a single array including inner polys
|
|
// keeping track of array offset indices for inners
|
|
let out = [];
|
|
let holes = [];
|
|
|
|
// flatten points into array for earcut()
|
|
this.points.forEach(p => {
|
|
out.push(p.x, p.y, p.z);
|
|
});
|
|
|
|
// add hole offsets for inner polygons
|
|
if (this.inner) {
|
|
this.inner.forEach(p => {
|
|
holes.push(out.length / 3);
|
|
p.points.forEach(p => {
|
|
out.push(p.x, p.y, p.z);
|
|
})
|
|
});
|
|
}
|
|
|
|
// perform earcut()
|
|
let cut = earcut(out, holes, 3);
|
|
let ret = [];
|
|
|
|
// preserve swaps in new polys
|
|
for (let i = 0; i < cut.length; i += 3) {
|
|
let p = new Polygon();
|
|
p._aligned = this._aligned;
|
|
p._swapped = this._swapped;
|
|
for (let j = 0; j < 3; j++) {
|
|
let n = cut[i + j] * 3;
|
|
p.add(out[n], out[n + 1], out[n + 2]);
|
|
}
|
|
ret.push(p);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
setInner(inner) {
|
|
this.inner = inner;
|
|
return this;
|
|
}
|
|
|
|
// generate a trace path around the inside of a polygon
|
|
// including inner polys. return the noodle and the remainder
|
|
// of the polygon with the noodle removed (for the next pass)
|
|
noodle(width) {
|
|
// inset outer polygon
|
|
let inner = this.inner;
|
|
let inset = this.clone().offset(width);
|
|
let noodot = [ this.clone().setInner(inset) ];
|
|
let noodin = [];
|
|
// subtract inners from the inset
|
|
if (inner) {
|
|
noodot = POLY.subtract(noodot, inner, []);
|
|
// for each inner, offset and subtract noodle + itself
|
|
let nood = [];
|
|
for (let innie of inner) {
|
|
let inexp = innie.clone().offset(-width);
|
|
let intrm = POLY.trimTo(inexp, [ this ]);
|
|
let inood = POLY.subtract(intrm, [ ...noodot, innie ], []);
|
|
nood.push(...inood);
|
|
}
|
|
noodin = POLY.union(nood, 0, true);
|
|
}
|
|
// unify inner noodles and outer noodle
|
|
let noodle = POLY.union([ ...noodot, ...noodin ], 0, true);
|
|
// subtract noodle from poly for next noodle calc
|
|
let remain = POLY.subtract([ this ], noodle, []);
|
|
return { noodle, remain };
|
|
}
|
|
|
|
// generate center crossing point cloud
|
|
centers(step, z, min, max, opt = {}) {
|
|
let cloud = [],
|
|
bounds = this.bounds,
|
|
lines = opt.lines || false,
|
|
stepoff = step / 2,
|
|
set = [this.points];
|
|
|
|
if (this.inner) {
|
|
for (let inner of this.inner) {
|
|
set.push(inner.points);
|
|
}
|
|
}
|
|
|
|
for (let y of util.lerp(bounds.miny + stepoff, bounds.maxy - stepoff, step, true)) {
|
|
let ints = [];
|
|
for (let points of set) {
|
|
let length = points.length;
|
|
for (let i = 0; i < length; i++) {
|
|
let p1 = points[i % length];
|
|
let p2 = points[(i + 1) % length];
|
|
if (
|
|
(p1.y <= y && p2.y > y) ||
|
|
(p1.y > y && p2.y <= y)
|
|
) ints.push([p1, p2]);
|
|
}
|
|
}
|
|
let cntr = [];
|
|
if (ints.length && ints.length % 2 === 0) {
|
|
for (let int of ints) {
|
|
let [p1, p2] = int;
|
|
if (p2.y < p1.y) {
|
|
let tp = p1;
|
|
p1 = p2;
|
|
p2 = tp;
|
|
}
|
|
let minx = Math.min(p1.x, p2.x);
|
|
let maxx = Math.max(p1.x, p2.x);
|
|
let miny = Math.min(p1.y, p2.y);
|
|
let maxy = Math.max(p1.y, p2.y);
|
|
let dx = p2.x - p1.x;
|
|
let dy = maxy - miny;
|
|
let pct = (y - miny) / dy;
|
|
let xpo = p1.x + pct * dx;
|
|
cntr.push(xpo);
|
|
}
|
|
}
|
|
cntr.sort((a, b) => {
|
|
return b - a;
|
|
});
|
|
let lp, eo = 0;
|
|
for (let x of cntr) {
|
|
let p = newPoint(x, y, z);
|
|
if (eo++ % 2) {
|
|
let d = lp.distTo2D(p);
|
|
if (d >= min && d <= max) {
|
|
if (lines) {
|
|
cloud.push(lp);
|
|
cloud.push(p);
|
|
} else {
|
|
cloud.push(newPoint(
|
|
(lp.x + p.x) / 2, y, z
|
|
));
|
|
}
|
|
}
|
|
} else {
|
|
lp = p;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (let x of util.lerp(bounds.minx + stepoff, bounds.maxx - stepoff, step, true)) {
|
|
let ints = [];
|
|
for (let points of set) {
|
|
let length = points.length;
|
|
for (let i = 0; i < length; i++) {
|
|
let p1 = points[i % length];
|
|
let p2 = points[(i + 1) % length];
|
|
if (
|
|
(p1.x <= x && p2.x > x) ||
|
|
(p1.x > x && p2.x <= x)
|
|
) ints.push([p1, p2]);
|
|
}
|
|
}
|
|
let cntr = [];
|
|
if (ints.length && ints.length % 2 === 0) {
|
|
for (let int of ints) {
|
|
let [p1, p2] = int;
|
|
if (p2.x < p1.x) {
|
|
let tp = p1;
|
|
p1 = p2;
|
|
p2 = tp;
|
|
}
|
|
let minx = Math.min(p1.x, p2.x);
|
|
let maxx = Math.max(p1.x, p2.x);
|
|
let miny = Math.min(p1.y, p2.y);
|
|
let maxy = Math.max(p1.y, p2.y);
|
|
let dx = maxx - minx;
|
|
let dy = p2.y - p1.y;
|
|
let pct = (x - minx) / dx;
|
|
let ypo = p1.y + pct * dy;
|
|
cntr.push(ypo);
|
|
}
|
|
}
|
|
cntr.sort((a, b) => {
|
|
return b - a;
|
|
});
|
|
let lp, eo = 0;
|
|
for (let y of cntr) {
|
|
let p = newPoint(x, y, z);
|
|
if (eo++ % 2) {
|
|
let d = lp.distTo2D(p);
|
|
if (d >= min && d <= max) {
|
|
if (lines) {
|
|
cloud.push(lp);
|
|
cloud.push(p);
|
|
} else {
|
|
cloud.push(newPoint(
|
|
x, (lp.y + p.y) / 2, z
|
|
));
|
|
}
|
|
}
|
|
} else {
|
|
lp = p;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (lines) {
|
|
return cloud;
|
|
}
|
|
|
|
let mindist = opt.mindist || step * 1.5;
|
|
|
|
function build(poly) {
|
|
let lastp = poly.last();
|
|
let minp;
|
|
let mind = Infinity;
|
|
for (let point of cloud) {
|
|
let dist = point.distTo2D(lastp);
|
|
if (dist < mindist && dist < mind) {
|
|
mind = dist;
|
|
minp = point;
|
|
}
|
|
}
|
|
if (minp) {
|
|
cloud = cloud.filter(p => p !== minp);
|
|
poly.push(minp);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// join points into polys
|
|
let polys = [];
|
|
let poly = [];
|
|
while (cloud.length) {
|
|
if (poly.length === 0) {
|
|
poly = [cloud.shift()];
|
|
polys.push(poly);
|
|
continue;
|
|
}
|
|
if (build(poly)) {
|
|
continue;
|
|
}
|
|
if (!poly.flip) {
|
|
poly.reverse();
|
|
poly.flip = true;
|
|
continue;
|
|
}
|
|
if (poly.length) {
|
|
poly = [];
|
|
} else {
|
|
throw "whoop there it is";
|
|
}
|
|
}
|
|
|
|
return polys
|
|
.filter(poly => poly.length > 1)
|
|
.map(poly => {
|
|
let np = base.newPolygon().setOpen();
|
|
for (let p of poly) {
|
|
np.push(p);
|
|
}
|
|
if (np.last().distTo2D(np.first()) <= max) {
|
|
np.setClosed();
|
|
}
|
|
np = np.clean();
|
|
return np;
|
|
});
|
|
}
|
|
|
|
debur(dist) {
|
|
if (this.len < 2) {
|
|
return null;
|
|
}
|
|
const pa = this.points,
|
|
pln = pa.length,
|
|
open = this.open,
|
|
newp = newPolygon().copyZ(this.z),
|
|
min = dist || base.config.precision_merge;
|
|
let lo;
|
|
newp.push(lo = pa[0]);
|
|
for (let i = 1; i < pln; i++) {
|
|
if (lo.distTo2D(pa[i]) >= min) {
|
|
newp.push(lo = pa[i]);
|
|
}
|
|
}
|
|
newp.open = open;
|
|
newp.parent = this.parent;
|
|
if (newp.length < 2) {
|
|
return null;
|
|
}
|
|
return newp;
|
|
}
|
|
|
|
miter(debug) {
|
|
if (this.length < 3) return this;
|
|
|
|
const slo = [],
|
|
pa = this.points,
|
|
pln = pa.length,
|
|
open = this.open;
|
|
let last;
|
|
for (let i = 1; i < pln; i++) {
|
|
slo.push(pa[i - 1].slopeTo(last = pa[i]));
|
|
}
|
|
if (!open) {
|
|
slo.push(last.slopeTo(pa[0]));
|
|
}
|
|
|
|
const ang = new Array(pln).fill(0);
|
|
let redo = false;
|
|
const aln = open ? pln - 1 : pln;
|
|
for (let i = 1; i < aln; i++) {
|
|
ang[i] = slopeDiff(slo[i - 1], slo[i]);
|
|
redo |= ang[i] > 90;
|
|
}
|
|
if (!open) {
|
|
// ang[pln-1] = slopeDiff(slo[pln-2], slo[pln-1]);
|
|
ang[0] = slopeDiff(slo[pln - 1], slo[0]);
|
|
redo |= ang[pln - 1] > 90;
|
|
redo |= ang[0] > 90;
|
|
}
|
|
if (redo) {
|
|
const newp = newPolygon().copyZ(this.z);
|
|
// newp.debug = this.debug = true;
|
|
newp.open = open;
|
|
for (let i = 0; i < pln; i++) {
|
|
const p = pa[(i + pln) % pln];
|
|
const d = ang[(i + pln) % pln];
|
|
if (d > 179) {
|
|
const s = slo[(i + pln) % pln];
|
|
const pp = pa[(i + pln - 1) % pln];
|
|
const ps = slo[(i + pln - 1) % pln];
|
|
newp.push(p.follow(p.slopeTo(pp).normal(), 0.001));
|
|
newp.push(p.follow(s.clone().normal().invert(), 0.001));
|
|
} else if (d > 90) {
|
|
const s = slo[(i + pln) % pln];
|
|
const pp = pa[(i + pln - 1) % pln];
|
|
const ps = slo[(i + pln - 1) % pln];
|
|
newp.push(p.follow(p.slopeTo(pp), 0.001));
|
|
newp.push(p.follow(s, 0.001));
|
|
} else {
|
|
p.parent = newp;
|
|
newp.push(p);
|
|
}
|
|
}
|
|
return newp;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
createConvexHull(points) {
|
|
function removeMiddle(a, b, c) {
|
|
let cross = (a.x - b.x) * (c.y - b.y) - (a.y - b.y) * (c.x - b.x);
|
|
let dot = (a.x - b.x) * (c.x - b.x) + (a.y - b.y) * (c.y - b.y);
|
|
return cross < 0 || cross == 0 && dot <= 0;
|
|
}
|
|
|
|
points.sort(function(a, b) {
|
|
return a.x != b.x ? a.x - b.x : a.y - b.y;
|
|
});
|
|
|
|
let n = points.length;
|
|
let hull = [];
|
|
|
|
for (let i = 0; i < 2 * n; i++) {
|
|
let j = i < n ? i : 2 * n - 1 - i;
|
|
while (hull.length >= 2 && removeMiddle(hull[hull.length - 2], hull[hull.length - 1], points[j]))
|
|
hull.pop();
|
|
hull.push(points[j]);
|
|
}
|
|
|
|
hull.pop();
|
|
this.addPoints(hull);
|
|
|
|
return this;
|
|
}
|
|
|
|
stepsFromRoot() {
|
|
let p = this.parent,
|
|
steps = 0;
|
|
while (p) {
|
|
if (p.inner && p.inner.length > 1) steps++;
|
|
p = p.parent;
|
|
}
|
|
return steps;
|
|
}
|
|
|
|
first() {
|
|
return this.points[0];
|
|
}
|
|
|
|
last() {
|
|
return this.points[this.length - 1];
|
|
}
|
|
|
|
flip(axis) {
|
|
for (let p of this.points) {
|
|
p[axis] = -p[axis];
|
|
}
|
|
for (let i of this.inner || []) {
|
|
i.flip(axis);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
swap(x, y) {
|
|
this._bounds = undefined;
|
|
if (x) {
|
|
for (let p of this.points) {
|
|
p.swapXZ();
|
|
}
|
|
} else if (y) {
|
|
for (let p of this.points) {
|
|
p.swapYZ();
|
|
}
|
|
}
|
|
if (this.inner) {
|
|
for (let inner of this.inner) {
|
|
inner.swap(x, y);
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
// return average of all point positions
|
|
average() {
|
|
let ap = newPoint(0, 0, 0, null);
|
|
this.points.forEach(p => {
|
|
ap.x += p.x;
|
|
ap.y += p.y;
|
|
ap.z += p.z;
|
|
});
|
|
ap.x /= this.points.length;
|
|
ap.y /= this.points.length;
|
|
ap.z /= this.points.length;
|
|
return ap;
|
|
}
|
|
|
|
// TODO: review usage
|
|
center(point) {
|
|
return this.bounds.center(this.getZ());
|
|
}
|
|
|
|
/**
|
|
* using perimeter length, find 3 equally spaced points to
|
|
* return a more accruate center point.
|
|
* @returns {Point} center of a polygon assuming it's a circle
|
|
*/
|
|
calcCircleCenter() {
|
|
let pe = this.perimeter(),
|
|
pe1 = pe / 3, // point 2
|
|
pe2 = pe1 * 2, // point 3
|
|
p = this.points,
|
|
l = p.length,
|
|
i = 1,
|
|
td = 0,
|
|
lp = p[0], // first point
|
|
ap = [ lp ]; // array of 3 points
|
|
while (i < l) {
|
|
let np = p[i++];
|
|
let d = lp.distTo2D(np);
|
|
td += d;
|
|
if (ap.length === 1 && td >= pe1) {
|
|
ap.push(np);
|
|
} else if (ap.length === 2 && td >= pe2) {
|
|
ap.push(np);
|
|
break;
|
|
}
|
|
lp = np;
|
|
}
|
|
let center = util.center2d(...ap);
|
|
return newPoint(center.x, center.y, p[0].z, null);
|
|
}
|
|
|
|
/**
|
|
* iterate over poly points and find sequences of 5 or more points
|
|
* with a common center point and collect as a midpoint/radius
|
|
*/
|
|
findArcCenters(opt = {}) {
|
|
if (this.length < 6) return [];
|
|
let tolerance = opt.tolerance || 1e-2,
|
|
inside = opt.inside ?? true,
|
|
seq = this.points.slice(),
|
|
util = base.util;
|
|
if (this.isClosed()) seq.appendAll(seq.slice(0,5));
|
|
let recs = [], // accumulated arc points
|
|
cand = []; // candidate center array
|
|
for (let pos=3; pos<seq.length; pos++) {
|
|
let next = util.circleCenter(...seq.slice(pos-3, pos));
|
|
let prev = cand.peek();
|
|
if (inside && !newPoint(next.x,next.y).inPolygon(this)) {
|
|
// require point be inside current polygon
|
|
next = null;
|
|
}
|
|
// console.log({ pos, next, prev, cand });
|
|
if (next && !prev) {
|
|
// seed candidate list
|
|
cand.push(next);
|
|
continue;
|
|
}
|
|
if (!next) {
|
|
// next is a bust, reset candidate list
|
|
cand.length = 0;
|
|
continue;
|
|
}
|
|
// const dist = util.dist2D(next,prev);
|
|
// console.log({ dist: dist.round(6) });
|
|
if (util.dist2D(next,prev) < tolerance) {
|
|
// add new candidate
|
|
cand.push(next);
|
|
continue;
|
|
} else if (cand.length >= 3) {
|
|
// emit record on 5 points
|
|
recs.push(cand.peek());
|
|
}
|
|
// reset candidate array
|
|
cand = [ next ];
|
|
}
|
|
if (cand.length >= 3) {
|
|
recs.push(cand.peek());
|
|
}
|
|
// filter dups
|
|
recs.sort((a,b) => {
|
|
return util.dist2D(a,b);
|
|
});
|
|
recs = recs.filter((r,i) => {
|
|
if (i > 0) {
|
|
return util.dist2D(r, recs[i-1]) < tolerance*10 ? null : r;
|
|
} else {
|
|
return r;
|
|
}
|
|
});
|
|
return recs;
|
|
}
|
|
|
|
/**
|
|
* add points forming a rectangle around a center point
|
|
*
|
|
* @param {Point} center
|
|
* @param {number} width
|
|
* @param {number} height
|
|
*/
|
|
centerRectangle(center, width, height) {
|
|
width /= 2;
|
|
height /= 2;
|
|
this.push(newPoint(center.x - width, center.y - height, center.z));
|
|
this.push(newPoint(center.x + width, center.y - height, center.z));
|
|
this.push(newPoint(center.x + width, center.y + height, center.z));
|
|
this.push(newPoint(center.x - width, center.y + height, center.z));
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* create square spiral (used for purge blocks)
|
|
*/
|
|
centerSpiral(center, lenx, leny, offset, count) {
|
|
count *= 4;
|
|
offset /= 2;
|
|
let pos = {
|
|
x: center.x - lenx / 2,
|
|
y: center.y + leny / 2,
|
|
z: center.z
|
|
},
|
|
dir = {
|
|
x: 1,
|
|
y: 0,
|
|
i: 0
|
|
},
|
|
t;
|
|
while (count-- > 0) {
|
|
this.push(newPoint(pos.x, pos.y, pos.z));
|
|
pos.x += dir.x * lenx;
|
|
pos.y += dir.y * leny;
|
|
switch (dir.i++) {
|
|
case 0:
|
|
t = dir.x;
|
|
dir.x = dir.y;
|
|
dir.y = -t;
|
|
break;
|
|
case 1:
|
|
t = dir.x;
|
|
dir.x = dir.y;
|
|
dir.y = t;
|
|
break;
|
|
case 2:
|
|
t = dir.x;
|
|
dir.x = dir.y;
|
|
dir.y = -t;
|
|
break;
|
|
case 3:
|
|
t = dir.x;
|
|
dir.x = dir.y;
|
|
dir.y = t;
|
|
break;
|
|
}
|
|
lenx -= offset / 2;
|
|
leny -= offset / 2;
|
|
dir.i = dir.i % 4;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* add points forming a circle around a center point
|
|
*/
|
|
centerCircle(center, radius, points, clockwise) {
|
|
let angle = 0,
|
|
add = 360 / points;
|
|
if (clockwise) add = -add;
|
|
while (points-- > 0) {
|
|
this.push(newPoint(
|
|
util.round(Math.cos(angle * DEG2RAD) * radius, 7) + center.x,
|
|
util.round(Math.sin(angle * DEG2RAD) * radius, 7) + center.y,
|
|
center.z
|
|
));
|
|
angle += add;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* move all poly points by some offset
|
|
*/
|
|
move(offset, skipinner) {
|
|
this._bounds = undefined;
|
|
this.points = this.points.map(point => point.move(offset));
|
|
if (!skipinner && this.inner) {
|
|
for (let inner of this.inner) {
|
|
inner.move(offset);
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* scale polygon around origin
|
|
*/
|
|
scale(scale, round) {
|
|
let x, y, z;
|
|
if (typeof(scale) === 'number') {
|
|
x = y = z = scale;
|
|
} else {
|
|
x = scale.x;
|
|
y = scale.y;
|
|
z = scale.z;
|
|
}
|
|
this._bounds = undefined;
|
|
this.points.forEach(point => {
|
|
if (round) {
|
|
point.x = (point.x * x).round(round);
|
|
point.y = (point.y * y).round(round);
|
|
point.z = (point.z * z).round(round);
|
|
} else {
|
|
point.x = point.x * x;
|
|
point.y = point.y * y;
|
|
point.z = point.z * z;
|
|
}
|
|
});
|
|
if (this.inner) {
|
|
for (let inner of this.inner) {
|
|
inner.scale(scale, round);
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
rotate(degrees) {
|
|
let rad = degrees * DEG2RAD;
|
|
if (rad)
|
|
this.points = this.points.map(p => {
|
|
let [ x, y ] = base.util.rotate(p.x, p.y, rad);
|
|
p.x = x;
|
|
p.y = y;
|
|
return p;
|
|
});
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* hint fill angle hinting from longest segment
|
|
*/
|
|
hintFillAngle() {
|
|
let index = 0,
|
|
points = this.points,
|
|
length = points.length,
|
|
prev,
|
|
next,
|
|
dist2,
|
|
longest,
|
|
mincir = config.hint_min_circ,
|
|
minlen = config.hint_len_min,
|
|
maxlen = config.hint_len_max || Infinity;
|
|
|
|
while (index < length) {
|
|
prev = points[index];
|
|
next = points[++index % length];
|
|
dist2 = prev.distToSq2D(next);
|
|
if (dist2 >= minlen && dist2 <= maxlen && (!longest || dist2 > longest.len)) {
|
|
longest = {
|
|
p1: prev,
|
|
p2: next,
|
|
len: dist2
|
|
};
|
|
}
|
|
}
|
|
|
|
if (longest && this.circularity() >= mincir) {
|
|
this.fillang = longest.p1.slopeTo(longest.p2).normal();
|
|
}
|
|
|
|
return this.fillang;
|
|
}
|
|
|
|
/**
|
|
* todo make more efficient
|
|
*
|
|
* @param {Boolean} deep
|
|
* @returns {Polygon}
|
|
*/
|
|
clone(deep, fields) {
|
|
let np = newPolygon().copyZ(this.getZ()),
|
|
ln = this.length,
|
|
i = 0;
|
|
|
|
while (i < ln) np.push(this.points[i++]);
|
|
|
|
fields && fields.forEach(field => np[field] = this[field]);
|
|
this.fillang && (np.fillang = this.fillang);
|
|
np.depth = this.depth;
|
|
np.open = this.open;
|
|
|
|
if (deep && this.inner) {
|
|
np.inner = this.inner.clone(false, fields);
|
|
}
|
|
|
|
return np;
|
|
}
|
|
|
|
// special shallow for-render-or-read-only cloning
|
|
cloneZ(z, deep = true) {
|
|
let p = newPolygon();
|
|
p.z = z;
|
|
p.open = this.open;
|
|
p.points = this.points;
|
|
if (deep && this.inner) {
|
|
p.inner = this.inner.map(p => p.cloneZ(z, false));
|
|
}
|
|
return p;
|
|
}
|
|
|
|
copyZ(z) {
|
|
if (z !== undefined) {
|
|
this.z = z;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
setA(a) {
|
|
for (let p of this.points) {
|
|
p.setA(a);
|
|
}
|
|
if (this.inner) {
|
|
for (let inner of this.inner) {
|
|
inner.setA(a);
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* set all points' z value
|
|
*
|
|
* @param {number} z
|
|
* @returns {Polygon} this
|
|
*/
|
|
setZ(z) {
|
|
let ar = this.points,
|
|
ln = ar.length,
|
|
i = 0;
|
|
while (i < ln) ar[i++].z = z;
|
|
this.z = z;
|
|
if (this.inner) this.inner.forEach(c => c.setZ(z));
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* @returns {number} z value of first point
|
|
*/
|
|
getZ(i) {
|
|
return this.z !== undefined ? this.z : this.points[i || 0]?.z || 0;
|
|
}
|
|
|
|
/**
|
|
*/
|
|
render(layer, color, recursive, open) {
|
|
layer.poly(this, color, recursive, open);
|
|
}
|
|
|
|
renderSolid(layer, color) {
|
|
layer.solid(this, color);
|
|
}
|
|
|
|
/**
|
|
* add new point and return polygon reference for chaining
|
|
*/
|
|
add(x, y, z) {
|
|
this.push(newPoint(x, y, z));
|
|
return this;
|
|
}
|
|
|
|
addObj(obj) {
|
|
if (Array.isArray(obj)) {
|
|
for (let o of obj) {
|
|
this.addObj(o);
|
|
}
|
|
return this;
|
|
}
|
|
return this.add(obj.x, obj.y, obj.z);
|
|
}
|
|
|
|
/**
|
|
* append array of points to polygon and return polygon
|
|
*/
|
|
addPoints(points) {
|
|
let poly = this,
|
|
length = points.length,
|
|
i = 0;
|
|
while (i < length) {
|
|
poly.push(points[i++]);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* @param {int[]} verts flat array of x,y,z vertices
|
|
*/
|
|
addVerts(verts) {
|
|
for (let i=0; i<verts.length; ) {
|
|
this.add(
|
|
verts[i++],
|
|
verts[i++],
|
|
verts[i++]
|
|
);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* append point to polygon and return point
|
|
*/
|
|
push(p) {
|
|
// clone any point belonging to another polygon
|
|
if (p.poly) p = p.clone();
|
|
p.poly = this;
|
|
this.points.push(p);
|
|
return p;
|
|
}
|
|
|
|
/**
|
|
* append point to polygon and return polygon
|
|
*/
|
|
append(p) {
|
|
this.push(p);
|
|
return this;
|
|
}
|
|
|
|
/** close polygon */
|
|
setClosed() {
|
|
this.open = false;
|
|
return this;
|
|
}
|
|
|
|
/** open polygon */
|
|
setOpen() {
|
|
this.open = true;
|
|
return this;
|
|
}
|
|
|
|
setOpenValue(b) {
|
|
this.open = b;
|
|
return this;
|
|
}
|
|
|
|
isOpen() {
|
|
return this.open;
|
|
}
|
|
|
|
isClosed() {
|
|
return !this.open;
|
|
}
|
|
|
|
appearsClosed() {
|
|
return this.first().isEqual(this.last());
|
|
}
|
|
|
|
setClockwise() {
|
|
if (!this.isClockwise()) this.reverse();
|
|
return this;
|
|
}
|
|
|
|
setCounterClockwise() {
|
|
if (this.isClockwise()) this.reverse();
|
|
return this;
|
|
}
|
|
|
|
isClockwise() {
|
|
return this.area(true) > 0;
|
|
}
|
|
|
|
showKey() {
|
|
return [this.first().key, this.last().key, this.length].join('~~');
|
|
}
|
|
|
|
applyRotations() {
|
|
for (let point of this.points) {
|
|
if (point.a) {
|
|
let p2 = new Vector3(point.x, point.y, point.z)
|
|
.applyAxisAngle(XAXIS, point.a * DEG2RAD);
|
|
point.x = p2.x;
|
|
point.y = p2.y;
|
|
point.z = p2.z;
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* set this polygon's winding in alignment with the supplied polygon
|
|
*/
|
|
alignWinding(poly, toLongest) {
|
|
if (toLongest && this.length > poly.length) {
|
|
poly.alignWinding(this, false);
|
|
} else if (this.isClockwise() !== poly.isClockwise()) {
|
|
this.reverse();
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* set this polygon's winding in opposition to supplied polygon
|
|
*/
|
|
opposeWinding(poly, toLongest) {
|
|
if (toLongest && this.length > poly.length) {
|
|
poly.opposeWinding(this, false);
|
|
} else if (this.isClockwise() === poly.isClockwise()) {
|
|
this.reverse();
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* @returns {boolean} true if both polygons wind the same way
|
|
*/
|
|
sameWindings(poly) {
|
|
return this.isClockwise() === poly.isClockwise();
|
|
}
|
|
|
|
/**
|
|
* reverse direction of polygon points.
|
|
*/
|
|
reverse() {
|
|
if (this.area2) {
|
|
this.area2 = -this.area2;
|
|
}
|
|
this.points = this.points.reverse();
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* return true if this polygon is (likely) nested inside parent
|
|
*/
|
|
isNested(parent) {
|
|
if (parent.bounds.contains(this.bounds)) {
|
|
return this.isInside(parent, config.precision_nested_sq);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Ease down along the polygonal path.
|
|
*
|
|
* 1. Travel from fromPoint to closest point on polygon, to rampZ above that that point,
|
|
* 2. ease-down starts, following the polygonal path, decreasing Z at a fixed slope until target Z is hit,
|
|
* 3. then the rest of the path is completed and repeated at target Z until touchdown point is reached.
|
|
* 4. this function should probably move to CAM prepare since it's only called from there
|
|
*/
|
|
forEachPointEaseDown(fn, fromPoint, degrees = 45) {
|
|
let index = this.findClosestPointTo(fromPoint).index,
|
|
fromZ = fromPoint.z,
|
|
offset = 0,
|
|
points = this.points,
|
|
length = points.length,
|
|
touch = -1, // first point to touch target z
|
|
targetZ = points[0].z,
|
|
dist2next,
|
|
last,
|
|
next,
|
|
done;
|
|
|
|
// Slope for computations.
|
|
const slope = Math.tan((degrees * Math.PI) / 180);
|
|
// Z height above polygon Z from which to start the ease-down.
|
|
// Machine will travel from "fromPoint" to "nearest point x, y, z' => with z' = point z + rampZ",
|
|
// then start the ease down along path.
|
|
const rampZ = 2.0;
|
|
while (true) {
|
|
next = points[index % length];
|
|
if (last && next.z < fromZ) {
|
|
// When "in Ease-Down" (ie. while target Z not yet reached) - follow path while slowly decreasing Z.
|
|
let deltaZ = fromZ - next.z;
|
|
dist2next = last.distTo2D(next);
|
|
let deltaZFullMove = dist2next * slope;
|
|
|
|
if (deltaZFullMove > deltaZ) {
|
|
// Too long: easing along full path would overshoot depth, synth intermediate point at target Z.
|
|
//
|
|
// XXX: please check my super basic trig - this should follow from `last` to `next` up until the
|
|
// intersect at the target Z distance.
|
|
fn(last.followTo(next, dist2next * deltaZ / deltaZFullMove).setZ(next.z), offset++);
|
|
} else {
|
|
// Ok: execute full move at desired slope.
|
|
next = next.clone().setZ(fromZ - deltaZFullMove);
|
|
}
|
|
|
|
fromZ = next.z;
|
|
} else if (offset === 0 && next.z < fromZ) {
|
|
// First point, move to rampZ height above next.
|
|
let deltaZ = fromZ - next.z;
|
|
fromZ = next.z + Math.min(deltaZ, rampZ)
|
|
next = next.clone().setZ(fromZ);
|
|
}
|
|
last = next;
|
|
fn(next, offset++);
|
|
if ((index % length) === touch) {
|
|
break;
|
|
}
|
|
if (touch < 0 && next.z <= targetZ) {
|
|
// Save touch-down index so as to be able to "complete" the full cut at target Z,
|
|
// i.e. keep following the path loop until the touch down point is reached again.
|
|
touch = ((index + length) % length);
|
|
}
|
|
index++;
|
|
}
|
|
|
|
return last;
|
|
}
|
|
|
|
forEachPoint(fn, close, start) {
|
|
let index = start || 0,
|
|
points = this.points,
|
|
length = points.length,
|
|
count = close ? length + 1 : length,
|
|
offset = 0,
|
|
pos;
|
|
|
|
while (count-- > 0) {
|
|
pos = index % length;
|
|
if (fn(points[pos], pos, points, offset++)) return;
|
|
index++;
|
|
}
|
|
}
|
|
|
|
forEachSegment(fn, open, start) {
|
|
let index = start || 0,
|
|
points = this.points,
|
|
length = points.length,
|
|
count = open ? length - 1 : length,
|
|
pos1, pos2;
|
|
|
|
while (count-- > 0) {
|
|
pos1 = index % length;
|
|
pos2 = (index + 1) % length;
|
|
if (fn(points[pos1], points[pos2], pos1, pos2)) return;
|
|
index++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* returns intersections sorted by closest to lp1
|
|
*/
|
|
intersections(lp1, lp2, deep) {
|
|
let list = [];
|
|
this.forEachSegment(function(pp1, pp2, ip1, ip2) {
|
|
let int = util.intersect(lp1, lp2, pp1, pp2, base.key.SEGINT, false);
|
|
if (int) {
|
|
list.push(int);
|
|
// console.log('pp1.pos',pp1.pos,'to',ip1);
|
|
// console.log('pp2.pos',pp2.pos,'to',ip2);
|
|
pp1.pos = ip1;
|
|
pp2.pos = ip2;
|
|
}
|
|
});
|
|
list.sort(function(p1, p2) {
|
|
return util.distSq(lp1, p1) - util.distSq(lp1, p2);
|
|
});
|
|
if (deep && this.inner) {
|
|
this.inner.forEach(p => {
|
|
let ints = p.intersections(lp1, lp2);
|
|
if (ints) list.appendAll(ints);
|
|
});
|
|
}
|
|
return list;
|
|
}
|
|
|
|
// return true if any line segments on either poly crosses the other
|
|
// this is a shallow test and does not inspect inners
|
|
intersects(poly) {
|
|
let p0 = this.points.slice(); p0.push(p0[0]);
|
|
let p1 = poly.points.slice(); p1.push(p1[0]);
|
|
for (let i=1; i<p0.length; i++) {
|
|
let a = p0[i-1];
|
|
let b = p0[i];
|
|
for (let j=1; j<p1.length; j++) {
|
|
let c = p1[j-1];
|
|
let d = p1[j];
|
|
if (util.intersect(a, b, c, d, base.key.SEGINT)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* using two points, split polygon into two open polygons
|
|
* or return null if p1,p2 does not intersect or poly is open
|
|
*/
|
|
bisect(p1, p2) {
|
|
if (this.isOpen()) return null;
|
|
|
|
let copy = this.clone().setClockwise();
|
|
|
|
let int = copy.intersections(p1, p2);
|
|
if (!int || int.length !== 2) return null;
|
|
|
|
return [copy.emitSegment(int[0], int[1]), copy.emitSegment(int[1], int[0]).reverse()];
|
|
}
|
|
|
|
/**
|
|
* emit new open poly between two intersection points of a clockwise poly.
|
|
* used in cam tabs and fdm output perimeter traces on infill
|
|
*/
|
|
emitSegment(i1, i2) {
|
|
let poly = newPolygon(),
|
|
start = i1.p2.pos,
|
|
end = i2.p1.pos;
|
|
// console.log({emitSeg: this, i1, i2, start, end});
|
|
poly.setOpen();
|
|
poly.push(i1);
|
|
this.forEachPoint(function(p, pos) {
|
|
poly.push(p);
|
|
if (p === i2.p1) {
|
|
// console.log('hit end point @', pos);
|
|
return true;
|
|
}
|
|
}, true, start);
|
|
poly.push(i2);
|
|
// console.log({emit: poly});
|
|
return poly;
|
|
}
|
|
|
|
/**
|
|
* @param {Polygon} poly
|
|
* @param {number} [tolerance]
|
|
* @returns {boolean} any points inside OR on edge
|
|
*/
|
|
hasPointsInside(poly, tolerance) {
|
|
if (!poly.overlaps(this)) return false;
|
|
|
|
let mid, exit = false;
|
|
|
|
this.forEachSegment((prev, next) => {
|
|
// check midpoint on long lines
|
|
if (prev.distTo2D(next) > config.precision_midpoint_check_dist) {
|
|
mid = prev.midPointTo(next);
|
|
if (mid.inPolygon(poly) || mid.nearPolygon(poly, tolerance || config.precision_close_to_poly_sq)) {
|
|
return exit = true;
|
|
}
|
|
}
|
|
if (next.inPolygon(poly) || next.nearPolygon(poly, tolerance || config.precision_close_to_poly_sq)) {
|
|
return exit = true;
|
|
}
|
|
});
|
|
|
|
return exit;
|
|
}
|
|
|
|
/**
|
|
* returns true if any point on this polygon
|
|
* is within radius of a point on the target
|
|
*/
|
|
isNear(poly, radius, cache) {
|
|
const midcheck = config.precision_midpoint_check_dist;
|
|
const dist = radius || config.precision_close_to_poly_sq;
|
|
let near = false;
|
|
let mem = cache ? this.cacheNear = this.cacheNear || {} : undefined;
|
|
|
|
if (mem && mem[poly.id] !== undefined) {
|
|
return mem[poly.id];
|
|
}
|
|
|
|
this.forEachSegment((prev, next) => {
|
|
// check midpoint on long lines
|
|
if (prev.distToSq2D(next) > midcheck) {
|
|
if (prev.midPointTo(next).nearPolygon(poly, dist)) {
|
|
return near = true; // stops iteration
|
|
}
|
|
}
|
|
if (next.nearPolygon(poly, dist)) {
|
|
return near = true; // stops iteration
|
|
}
|
|
});
|
|
|
|
if (mem) {
|
|
mem[poly.id] = near;
|
|
}
|
|
|
|
return near;
|
|
}
|
|
|
|
/**
|
|
* TODO replace isNested() with isInside() ?
|
|
*
|
|
* @param {Polygon} poly
|
|
* @param {number} [tolerance]
|
|
* @returns {boolean} all points inside OR on edge
|
|
*/
|
|
isInside(poly, tolerance) {
|
|
// throw new Error("isInside");
|
|
const neardist = tolerance || config.precision_close_to_poly_sq;
|
|
if (!this.bounds.isNested(poly.bounds, neardist * 3)) {
|
|
return false;
|
|
}
|
|
|
|
let mid,
|
|
midcheck = config.precision_midpoint_check_dist,
|
|
exit = true;
|
|
|
|
this.forEachSegment((prev, next) => {
|
|
// check midpoint on long lines (TODO: should be distToSq2D()?)
|
|
if (prev.distTo2D(next) > midcheck) {
|
|
mid = prev.midPointTo(next);
|
|
if (!(mid.inPolygon(poly) || mid.nearPolygon(poly, neardist))) {
|
|
exit = false;
|
|
return true;
|
|
}
|
|
}
|
|
if (!(next.inPolygon(poly) || next.nearPolygon(poly, neardist))) {
|
|
exit = false;
|
|
return true;
|
|
}
|
|
}, this.open);
|
|
|
|
return exit;
|
|
}
|
|
|
|
/**
|
|
* @param {Polygon} poly
|
|
* @param {number} [tolerance]
|
|
* @returns {boolean} all points inside poly AND not inside children
|
|
*/
|
|
// PRO.contains = function(poly, tolerance) {
|
|
// return (poly && poly.isInside(this, tolerance) && poly.isOutsideAll(this.inner, tolerance));
|
|
// };
|
|
|
|
containedBySet(polys) {
|
|
if (!polys) return false;
|
|
for (let i = 0; i < polys.length; i++) {
|
|
if (polys[i].contains(this)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
addInner(child) {
|
|
child.parent = this;
|
|
if (this.inner) {
|
|
this.inner.push(child);
|
|
} else {
|
|
this.inner = [child];
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* @returns {number} number of inner polygons
|
|
*/
|
|
innerCount() {
|
|
return this.inner ? this.inner.length : 0;
|
|
}
|
|
|
|
/**
|
|
* @returns {boolean} if has 1 or more inner polygons
|
|
*/
|
|
hasInner() {
|
|
return this.inner && this.inner.length > 0;
|
|
}
|
|
|
|
/**
|
|
* remove all inner polygons
|
|
*/
|
|
clearInner() {
|
|
this.inner = null;
|
|
return this;
|
|
}
|
|
|
|
freeParentRefs() {
|
|
if (this.inner && this.inner.length > 0) {
|
|
for (let inner of this.inner) {
|
|
inner.freeParentRefs();
|
|
delete inner.parent;
|
|
}
|
|
}
|
|
for (let p of this.points) {
|
|
delete p.poly;
|
|
}
|
|
}
|
|
|
|
newUndeleted() {
|
|
let poly = newPolygon();
|
|
this.forEachPoint(p => {
|
|
if (!p.del) poly.push(p);
|
|
});
|
|
return poly;
|
|
}
|
|
|
|
/**
|
|
* http://www.ehow.com/how_5138742_calculate-circularity.html
|
|
* @returns {number} 0.0 - 1.0 from flat to perfectly circular
|
|
*/
|
|
circularity() {
|
|
return (4 * Math.PI * this.area()) / util.sqr(this.perimeter());
|
|
}
|
|
|
|
circularityDeep() {
|
|
return (4 * Math.PI * this.areaDeep()) / util.sqr(this.perimeter());
|
|
}
|
|
|
|
/**
|
|
* @returns {number} perimeter length (sum of all segment lengths)
|
|
*/
|
|
perimeter() {
|
|
if (this.perim) {
|
|
return this.perim;
|
|
}
|
|
|
|
let len = 0.0;
|
|
|
|
this.forEachSegment((prev, next) => {
|
|
len += Math.sqrt(prev.distToSq2D(next));
|
|
}, this.open);
|
|
|
|
return this.perim = len;
|
|
}
|
|
|
|
perimeterDeep() {
|
|
let len = this.perimeter();
|
|
if (this.inner) this.inner.forEach(p => {
|
|
len += p.perimeter()
|
|
});
|
|
return len;
|
|
}
|
|
|
|
/**
|
|
* calculate and return the area enclosed by the polygon.
|
|
* if raw is true, return a signed area equal to 2x the
|
|
* enclosed area which also indicates winding direction.
|
|
*
|
|
* @param {boolean} [raw]
|
|
* @returns {number} area
|
|
*/
|
|
area(raw) {
|
|
if (this.length < 3) {
|
|
return 0;
|
|
}
|
|
if (this.area2 === undefined) {
|
|
this.area2 = 0.0;
|
|
for (let p = this.points, pl = p.length, pi = 0, p1, p2; pi < pl; pi++) {
|
|
p1 = p[pi];
|
|
p2 = p[(pi + 1) % pl];
|
|
this.area2 += (p2.x - p1.x) * (p2.y + p1.y);
|
|
}
|
|
}
|
|
return raw ? this.area2 : Math.abs(this.area2 / 2);
|
|
}
|
|
|
|
/**
|
|
* return the area of a polygon with the area of all
|
|
* inner polygons subtracted
|
|
*
|
|
* @returns {number} area
|
|
*/
|
|
areaDeep() {
|
|
if (!this.inner) {
|
|
return this.area();
|
|
}
|
|
let i, c = this.inner,
|
|
a = this.area();
|
|
for (i = 0; i < c.length; i++) {
|
|
a -= c[i].area();
|
|
}
|
|
return a;
|
|
}
|
|
|
|
/**
|
|
* @param {Polygon} poly
|
|
* @returns {boolean}
|
|
*/
|
|
overlaps(poly) {
|
|
return this.bounds.overlaps(poly.bounds, config.precision_merge);
|
|
}
|
|
|
|
/**
|
|
* create poly from coordinate Array (aka dump)
|
|
*
|
|
* @param {number[]} arr
|
|
* @param {number} [z]
|
|
*/
|
|
fromXYArray(arr, z) {
|
|
let i = 0;
|
|
while (i < arr.length) {
|
|
this.add(arr[i++], arr[i++], z || 0);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* shortcut to de-rez poly
|
|
*/
|
|
simple() {
|
|
return this.clean(true, undefined, Math.min(config.clipper / 10, config.clipperClean * 5));
|
|
}
|
|
|
|
/**
|
|
* simplify and merge collinear. only works for single
|
|
* non-nested polygons. used primarily in slicer/connectLines.
|
|
*/
|
|
clean(deep, parent, merge = config.clipperClean) {
|
|
let clean = CleanPolygon(this.toClipper()[0], merge),
|
|
poly = fromClipperPath(clean, this.getZ());
|
|
if (poly.length === 0) return this;
|
|
if (deep && this.inner) {
|
|
poly.inner = this.inner.map(inr => inr.clean(false, poly, merge));
|
|
}
|
|
poly.parent = parent || this.parent;
|
|
poly.area2 = this.area2;
|
|
poly.open = this.open;
|
|
if (this.open) {
|
|
// when open, ensure first point on new poly matches old
|
|
let start = this.points[0];
|
|
let points = poly.points;
|
|
let length = points.length;
|
|
let mi, min = Infinity;
|
|
for (let i = 0; i < length; i++) {
|
|
let d = points[i].distTo2D(start);
|
|
if (d < min) {
|
|
min = d;
|
|
mi = i;
|
|
}
|
|
}
|
|
// mi > 0 means first point didn't match
|
|
if (mi) {
|
|
let nupoints = [];
|
|
for (let i = mi; i < length; i++) {
|
|
nupoints.push(points[i]);
|
|
}
|
|
for (let i = 0; i < mi; i++) {
|
|
nupoints.push(points[i]);
|
|
}
|
|
poly.points = nupoints;
|
|
}
|
|
}
|
|
return poly;
|
|
}
|
|
|
|
toClipper(inout) {
|
|
let poly = this,
|
|
out = inout || [];
|
|
out.push(poly.points.map(p => p.toClipper()));
|
|
if (poly.inner) {
|
|
for (let inner of poly.inner) {
|
|
inner.toClipper(out);
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
|
|
/**
|
|
* return offset polygon(s) from original using distance. may result in
|
|
* more than one new polygon if trace is self-intersecting or null if new
|
|
* polygon is too small or offset is otherwise not possible due to geometry.
|
|
*
|
|
* @param {number} offset positive = inset, negative = outset
|
|
* @param {Polygon[]} [output]
|
|
* @returns {?Polygon[]} returns output array provided as input or new array if not provided
|
|
*/
|
|
offset(offset, output) {
|
|
return POLY.expand([this], -offset, this.getZ(), output);
|
|
}
|
|
|
|
/**
|
|
* ofsetting an open line uses a different procedure and options
|
|
*
|
|
* @param {number} distance
|
|
* @param {'square'|'round'|'miter'} type
|
|
* @returns {Polygon[]}
|
|
*/
|
|
offset_open(distance, type = 'miter', miterLimit = 2) {
|
|
if (this.isOpen()) {
|
|
let coff = new ClipperOffset(),
|
|
dudd = (coff.MiterLimit = miterLimit),
|
|
tree = new PolyTree(),
|
|
entt = {
|
|
'square' : EndType.etOpenSquare,
|
|
'round' : EndType.etOpenRound,
|
|
'miter' : EndType.etOpenSquare
|
|
}[type] || EndType.etOpenSquare,
|
|
jntt = {
|
|
'square': JoinType.jtSquare,
|
|
'round': JoinType.jtRound,
|
|
'miter': JoinType.jtMiter
|
|
}[type] || JoinType.jtMiter;
|
|
coff.AddPaths(this.toClipper(), jntt, entt);
|
|
coff.Execute(tree, distance * config.clipper);
|
|
return POLY.fromClipperTree(tree, this.getZ(), null, null, 0);
|
|
} else {
|
|
return this.offset(distance);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* todo need something more clever for polygons that overlap with
|
|
* todo differing resolutions (like circles)
|
|
*
|
|
* @param {Polygon} poly
|
|
* @param {boolean} [recurse]
|
|
* @param {number} [precision]
|
|
* @returns {boolean} true if polygons are, essentially, the same
|
|
*/
|
|
isEquivalent(poly, recurse, precision) {
|
|
// throw new Error("isEquivalent");
|
|
let area1 = Math.abs(this.area());
|
|
let area2 = Math.abs(poly.area());
|
|
if (util.isCloseTo(area1, area2, precision || config.precision_poly_area) &&
|
|
this.bounds.equals(poly.bounds, precision || config.precision_poly_bounds)) {
|
|
// use circularity near 1 to eliminate the extensive check below
|
|
let c1 = this.circularity(),
|
|
c2 = poly.circularity();
|
|
if (Math.abs(c1 - c2) < config.precision_circularity && ((1 - c1) < config.precision_circularity)) {
|
|
return true;
|
|
}
|
|
|
|
if (recurse) {
|
|
let i, ai = this.inner,
|
|
bi = poly.inner;
|
|
if (ai !== bi) {
|
|
if (ai === null || bi === null || ai.length != bi.length) {
|
|
return false;
|
|
}
|
|
for (i = 0; i < ai.length; i++) {
|
|
if (!ai[i].isEquivalent(bi[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
let exit = true,
|
|
pointok,
|
|
dist,
|
|
min;
|
|
|
|
this.forEachPoint(i2p => {
|
|
pointok = false;
|
|
poly.forEachSegment((i1p1, i1p2) => {
|
|
// if point is close to poly, terminate search, go to next point
|
|
if ((dist = i2p.distToLine(i1p1, i1p2)) < config.precision_poly_merge) {
|
|
return pointok = true;
|
|
}
|
|
// otherwise track min and keep searching
|
|
min = Math.min(min, dist);
|
|
});
|
|
// fail poly if one point is bad
|
|
if (!pointok) {
|
|
exit = false;
|
|
// terminate search
|
|
return true;
|
|
}
|
|
});
|
|
return exit;
|
|
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* find the point of this polygon closest to
|
|
* the provided point. assist generating optimal
|
|
* print paths.
|
|
*
|
|
* @param {Point} target
|
|
* @return {Object} {distance, point, index: point_index}
|
|
*/
|
|
findClosestPointTo(target) {
|
|
let dist,
|
|
index,
|
|
closest,
|
|
mindist = Infinity;
|
|
|
|
this.forEachPoint((point, pos) => {
|
|
dist = Math.sqrt(point.distToSq2D(target));
|
|
if (dist < mindist) {
|
|
index = pos;
|
|
mindist = dist;
|
|
closest = point;
|
|
}
|
|
});
|
|
|
|
return {
|
|
point: closest,
|
|
distance: mindist,
|
|
index: index
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @param {Polygon[]} out
|
|
* @param {[]} deep recurse and track recursion
|
|
* @param {boolean} crush remove inner array after flatten
|
|
* @returns {Polygon[]}
|
|
*/
|
|
flattenTo(out, deep, crush) {
|
|
out.push(this);
|
|
if (deep) {
|
|
if (deep.contains(this)) {
|
|
console.log('flat recursion @', this);
|
|
return;
|
|
}
|
|
deep.push(this);
|
|
}
|
|
if (this.inner) {
|
|
for (let p of this.inner) {
|
|
p.flattenTo(out, deep, crush);
|
|
}
|
|
}
|
|
if (crush) {
|
|
this.inner = undefined;
|
|
}
|
|
return out;
|
|
}
|
|
|
|
shortestSegmentLength() {
|
|
let len = Infinity;
|
|
this.forEachSegment((p1, p2) => {
|
|
len = Math.min(len, p1.distTo2D(p2));
|
|
});
|
|
return len;
|
|
}
|
|
|
|
/**
|
|
* @param {Polygon} poly clipping mask
|
|
* @returns {?Polygon[]}
|
|
*/
|
|
diff(poly) {
|
|
let fillang = this.fillang && this.area() > poly.area() ? this.fillang : poly.fillang,
|
|
clip = new Clipper(),
|
|
tree = new PolyTree(),
|
|
sp1 = this.toClipper(),
|
|
sp2 = poly.toClipper();
|
|
|
|
clip.AddPaths(sp1, PathSubject, true);
|
|
clip.AddPaths(sp2, PathClip, true);
|
|
|
|
if (clip.Execute(ClipDiff, tree, FillEvenOdd, FillEvenOdd)) {
|
|
poly = POLY.fromClipperTree(tree, poly.getZ());
|
|
poly.forEach(p => p.fillang = fillang);
|
|
return poly;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {Polygon} poly poly to xor against this one
|
|
* @returns {?Polygon[]}
|
|
*/
|
|
xor(poly) {
|
|
let fillang = this.fillang && this.area() > poly.area() ? this.fillang : poly.fillang,
|
|
clip = new Clipper(),
|
|
tree = new PolyTree(),
|
|
sp1 = this.toClipper(),
|
|
sp2 = poly.toClipper();
|
|
|
|
clip.AddPaths(sp1, PathSubject, true);
|
|
clip.AddPaths(sp2, PathClip, true);
|
|
|
|
if (clip.Execute(ClipXOR, tree, FillNonZero, FillNonZero)) {
|
|
poly = POLY.fromClipperTree(tree, poly.getZ());
|
|
poly.forEach(p => p.fillang = fillang);
|
|
return poly;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {Polygon} poly clipping mask
|
|
* @returns {?Polygon[]}
|
|
*/
|
|
mask(poly, nullOnEquiv, minarea) {
|
|
let fillang = this.fillang && this.area() > poly.area() ? this.fillang : poly.fillang,
|
|
clip = new Clipper(),
|
|
tree = new PolyTree(),
|
|
sp1 = this.toClipper(),
|
|
sp2 = poly.toClipper();
|
|
clip.AddPaths(sp1, PathSubject, true);
|
|
clip.AddPaths(sp2, PathClip, true);
|
|
|
|
if (clip.Execute(ClipIntersect, tree, FillEvenOdd, FillEvenOdd)) {
|
|
poly = POLY.fromClipperTree(tree, this.getZ(), undefined, undefined, minarea);
|
|
poly.forEach(p => {
|
|
p.fillang = fillang;
|
|
})
|
|
if (nullOnEquiv && poly.length === 1 && poly[0].isEquivalent(this)) {
|
|
return null;
|
|
}
|
|
return poly;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// cut poly using array of closed polygons. used primarily in cnc
|
|
// to cut perimeters using tabs resulting in open poly lines.
|
|
cut(polys, inter) {
|
|
let target = this;
|
|
|
|
if (!target.open) {
|
|
target = this.clone(true).setOpen();
|
|
target.push(target.first());
|
|
if (target.inner) {
|
|
target.inner.forEach(ip => {
|
|
ip.setOpen();
|
|
ip.push(ip.first());
|
|
});
|
|
}
|
|
}
|
|
|
|
let clip = new Clipper(),
|
|
tree = new PolyTree(),
|
|
type = inter ? ClipIntersect : ClipDiff,
|
|
sp1 = target.toClipper(),
|
|
sp2 = POLY.toClipper(polys);
|
|
|
|
clip.AddPaths(sp1, PathSubject, false);
|
|
clip.AddPaths(sp2, PathClip, true);
|
|
|
|
if (clip.Execute(type, tree, FillEvenOdd, FillEvenOdd)) {
|
|
let cuts = POLY.fromClipperTree(tree, target.getZ(), null, null, 0);
|
|
cuts.forEach(no => {
|
|
// heal open but really closed polygons because cutting
|
|
// has to open the poly to perform the cut. but the result
|
|
// may have been no intersection leaving an open poly
|
|
if (no.open && no.first().distTo2D(no.last()) < 0.001) {
|
|
no.open = false;
|
|
no.points.pop();
|
|
}
|
|
no.depth = this.depth;
|
|
});
|
|
return cuts;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// find the intersection of two polygons
|
|
intersect(poly, min) {
|
|
if (!this.overlaps(poly)) return null;
|
|
|
|
if (this.isInside(poly)) {
|
|
return [this];
|
|
}
|
|
|
|
let clip = new Clipper(),
|
|
tree = new PolyTree(),
|
|
sp1 = this.toClipper(),
|
|
sp2 = poly.toClipper(),
|
|
minarea = min >= 0 ? min : 0.1;
|
|
|
|
clip.AddPaths(sp1, PathSubject, true);
|
|
clip.AddPaths(sp2, PathClip, true);
|
|
|
|
if (clip.Execute(ClipIntersect, tree, FillNonZero, FillNonZero)) {
|
|
let inter = POLY
|
|
.fromClipperTreeUnion(tree, poly.getZ(), minarea)
|
|
// .filter(p => p.isEquivalent(this) || p.isInside(this))
|
|
.filter(p => p.isInside(this));
|
|
return inter;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
areaDiff(poly) {
|
|
let a1 = this.area(),
|
|
a2 = poly.area();
|
|
return (a1 > a2) ? a2 / a1 : a1 / a2;
|
|
}
|
|
|
|
// does not work with nested polys
|
|
simplify(opt = {}) {
|
|
let z = this.getZ();
|
|
|
|
// use expand / deflate technique instead
|
|
if (opt.pump) {
|
|
let p2 = POLY.offset([this], opt.pump, {
|
|
z
|
|
});
|
|
if (p2) {
|
|
p2 = POLY.offset(p2, -opt.pump, {
|
|
z
|
|
});
|
|
return p2;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
let clip = this.toClipper(),
|
|
res = Clipper.SimplifyPolygons(clip, FillNonZero);
|
|
|
|
if (!(res && res.length)) {
|
|
return null;
|
|
}
|
|
|
|
return res.map(array => {
|
|
let poly = newPolygon();
|
|
for (let pt of array) {
|
|
poly.push(pointFromClipper(pt, z));
|
|
}
|
|
return poly;
|
|
});
|
|
}
|
|
|
|
unionMatch(polys) {
|
|
return polys.filter(poly => poly.isEquivalent(this)).length;
|
|
}
|
|
|
|
/**
|
|
* return logical OR of two polygons' enclosed areas
|
|
*
|
|
* @param {Polygon} poly
|
|
* @returns {?Polygon} intersected polygon, null if no intersection, or all when indicated
|
|
*/
|
|
union(poly, min, all) {
|
|
if (!this.overlaps(poly)) return null;
|
|
|
|
let fillang = this.fillang && this.area() > poly.area() ? this.fillang : poly.fillang,
|
|
clip = new Clipper(),
|
|
tree = new PolyTree(),
|
|
sp1 = this.toClipper(),
|
|
sp2 = poly.toClipper(),
|
|
minarea = min ?? 0.1;
|
|
|
|
clip.AddPaths(sp1, PathSubject, true);
|
|
clip.AddPaths(sp2, PathClip, true);
|
|
|
|
if (clip.Execute(ClipUnion, tree, FillEvenOdd, FillEvenOdd)) {
|
|
let union = POLY.fromClipperTreeUnion(tree, poly.getZ(), minarea);
|
|
if (all) {
|
|
if (union.length === 2) {
|
|
return null;
|
|
// if (this.unionMatch(union) || poly.unionMatch(union)) {
|
|
// return null;
|
|
// }
|
|
}
|
|
return union;
|
|
}
|
|
if (union.length === 1) {
|
|
union = union[0];
|
|
union.fillang = fillang;
|
|
return union;
|
|
} else {
|
|
console.trace({
|
|
check_union_call_path: union,
|
|
this: this,
|
|
poly
|
|
});
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
annotate(obj = {}) {
|
|
Object.assign(this, obj);
|
|
return this;
|
|
}
|
|
|
|
// turn 2d polygon into a 2.5D ribbon extruded in Z
|
|
ribbonZ(z = 1, zadd = 0, rev) {
|
|
let poly = this.clone().setClockwise();
|
|
let faces = [];
|
|
let points = poly.points;
|
|
let length = points.length;
|
|
if (rev) {
|
|
points = points.slice().reverse();
|
|
}
|
|
for (let i=0; i<length; i++) {
|
|
let p0 = points[i];
|
|
let p1 = points[(i + 1) % length];
|
|
faces.push(p0.x, p0.y, p0.z + zadd);
|
|
faces.push(p1.x, p1.y, p1.z + z + zadd);
|
|
faces.push(p1.x, p1.y, p0.z + zadd);
|
|
faces.push(p0.x, p0.y, p0.z + zadd);
|
|
faces.push(p0.x, p0.y, p0.z + z + zadd);
|
|
faces.push(p1.x, p1.y, p1.z + z + zadd);
|
|
}
|
|
return faces;
|
|
}
|
|
|
|
// for turning a poly with an inner offset into a
|
|
// 3d mesh if and only if the inner has the same
|
|
// circularity and <= num points
|
|
// primarily used to make chamfers
|
|
ribbonMesh(swap) {
|
|
if (!(this.inner && this.inner.length === 1)) {
|
|
return undefined;
|
|
}
|
|
let outer = this.clone().setClockwise();
|
|
let inner = this.inner[0].clone().setClockwise();
|
|
let c0 = outer.circularity();
|
|
let c1 = inner.circularity();
|
|
let n0 = outer.points.length;
|
|
let n1 = inner.points.length;
|
|
let p0 = outer.points.slice();
|
|
let p1 = inner.points.slice();
|
|
let min = { d: Infinity, i:0, j:0 };
|
|
// find the closests two points inner/outer
|
|
for (let i=0; i<p0.length; i++) {
|
|
for (let j=0; j<p1.length; j++) {
|
|
let d = p0[i].distTo2D(p1[j]);
|
|
if (d < min.d) {
|
|
min = { d, i, j };
|
|
}
|
|
}
|
|
}
|
|
// slide the arrays until the closest points are aligned at index = 0
|
|
p0 = p0.slice(min.i).concat(p0.slice(0, min.i)); p0.push(p0[0]);
|
|
p1 = p1.slice(min.j).concat(p1.slice(0, min.j)); p1.push(p1[0]);
|
|
// walk both arrays moving to the next poly + point that forms
|
|
// the shortest line segment between the two points (inner / outer)
|
|
let faces = [];
|
|
let pi0 = 0;
|
|
let pi1 = 0;
|
|
let pp0 = p0[pi0];
|
|
let pp1 = p1[pi1];
|
|
for (;;) {
|
|
let pn0 = p0[pi0 + 1];
|
|
let pn1 = p1[pi1 + 1];
|
|
if ((!pn0 && pn1) || (pn1 && pp0.distTo2D(pn1) < pp1.distTo2D(pn0))) {
|
|
// emit and increment bottom
|
|
faces.push(pp0.x, pp0.y, pp0.z);
|
|
if (swap) {
|
|
faces.push(pp1.x, pp1.y, pp1.z);
|
|
faces.push(pn1.x, pn1.y, pn1.z);
|
|
} else {
|
|
faces.push(pn1.x, pn1.y, pn1.z);
|
|
faces.push(pp1.x, pp1.y, pp1.z);
|
|
}
|
|
pi1++;
|
|
pp1 = p1[pi1];
|
|
} else if (pn0) {
|
|
// emit and increment top
|
|
faces.push(pp0.x, pp0.y, pp0.z);
|
|
if (swap) {
|
|
faces.push(pp1.x, pp1.y, pp1.z);
|
|
faces.push(pn0.x, pn0.y, pn0.z);
|
|
} else {
|
|
faces.push(pn0.x, pn0.y, pn0.z);
|
|
faces.push(pp1.x, pp1.y, pp1.z);
|
|
}
|
|
pi0++;
|
|
pp0 = p0[pi0];
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
return faces;
|
|
}
|
|
|
|
// extrude poly (with inner voids) into 3d mesh
|
|
extrude(z = 1, opt = {}) {
|
|
let earcut = this.earcut(); // array of 3-point polygons
|
|
|
|
// return just the 2D face when no Z depth specified
|
|
// used primarily by mesh.sketch render()
|
|
if (z === 0) {
|
|
return earcut.map(face => face.points.map(p => [ p.x, p.y, p.z ])).flat().flat();
|
|
}
|
|
|
|
let inv = z < 0;
|
|
|
|
if (inv) {
|
|
z = -z;
|
|
}
|
|
|
|
let chamfer = opt.chamfer || 0;
|
|
let chamfer_top = opt.chamfer_top || chamfer;
|
|
let chamfer_bottom = opt.chamfer_bottom || chamfer;
|
|
|
|
if (inv) {
|
|
let tmp = chamfer_top;
|
|
chamfer_top = chamfer_bottom;
|
|
chamfer_bottom = tmp;
|
|
}
|
|
|
|
let zadd = (typeof opt === 'number' ? opt : opt.zadd || 0); // z bottom
|
|
let obj = []; // flat output vertex array (float-x,float-y,float-z,...)
|
|
let top_face = earcut;
|
|
let bottom_face = earcut;
|
|
let z_top = z + zadd;
|
|
let z_bottom = zadd;
|
|
let z_side_top = z;
|
|
let z_side_bottom = z_bottom;
|
|
|
|
// chamfer bottom only on negative chamfer
|
|
if (chamfer < 0) {
|
|
chamfer_top = 0;
|
|
chamfer_bottom = -chamfer;
|
|
}
|
|
|
|
// create chamfers (when defined)
|
|
if (chamfer_top) {
|
|
let inset = this.offset(chamfer_top);
|
|
if (inset.length === 1) {
|
|
inset[0].setZ(z_top);
|
|
top_face = inset[0].earcut();
|
|
z_side_top -= chamfer_top;
|
|
let renest = POLY.renest([this.clone(true).setZ(z_side_top), inset[0]]);
|
|
for (let rnpoly of renest) {
|
|
obj.appendAll(rnpoly.ribbonMesh(true));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (chamfer_bottom) {
|
|
let inset = this.offset(chamfer_bottom);
|
|
if (inset.length === 1) {
|
|
inset[0].setZ(0);
|
|
bottom_face = inset[0].earcut();
|
|
z_side_top -= chamfer_top || chamfer_bottom;
|
|
z_side_bottom += chamfer_bottom;
|
|
let renest = POLY.renest([this.clone(true).setZ(z_side_bottom), inset[0]]);
|
|
for (let rnpoly of renest) {
|
|
obj.appendAll(rnpoly.ribbonMesh(false));
|
|
}
|
|
}
|
|
}
|
|
|
|
for (let poly of top_face) {
|
|
for (let point of poly.points) {
|
|
obj.push(point.x, point.y, z_top);
|
|
}
|
|
}
|
|
|
|
// bottom face (reversed to reverse normals)
|
|
for (let poly of bottom_face) {
|
|
for (let point of poly.points.reverse()) {
|
|
obj.push(point.x, point.y, z_bottom);
|
|
}
|
|
}
|
|
|
|
// outside wall
|
|
let rib = z - chamfer_top - chamfer_bottom;
|
|
obj.appendAll(this.ribbonZ(rib, z_side_bottom));
|
|
for (let inner of this.inner || []) {
|
|
// inside wall(s)
|
|
obj.appendAll(inner.ribbonZ(rib, z_side_bottom, true));
|
|
}
|
|
|
|
if (inv) {
|
|
for (let i=2; i<obj.length; i+=3) {
|
|
obj[i] -= z;
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
// split long straight lines into segments no longer than max
|
|
// and return a new polygon
|
|
segment(max = 1) {
|
|
const newp = [];
|
|
const points = this.points;
|
|
const length = points.length;
|
|
const l0 = this.open ? length - 1 : length;
|
|
for (let i=0, p=points, l1=length, l2=l1+1; i<l0; i++) {
|
|
const p1 = p[i];
|
|
const p2 = p[(i + 1) % l1];
|
|
const dx = p2.x - p1.x;
|
|
const dy = p2.y - p1.y;
|
|
const dl = Math.sqrt(dx * dx + dy * dy);
|
|
newp.push(p1);
|
|
if (dl < max) {
|
|
continue;
|
|
}
|
|
const div = dl / max;
|
|
const fit = div | 0;
|
|
const add = fit - 1;
|
|
const ix = dx / fit;
|
|
const iy = dy / fit;
|
|
let ox = p1.x + ix;
|
|
let oy = p1.y + iy;
|
|
for (let i=0; i<add; i++) {
|
|
newp.push(newPoint(ox, oy, (p1.z + p2.z) / 2));
|
|
ox += ix;
|
|
oy += iy;
|
|
}
|
|
}
|
|
if (newp.length > length) {
|
|
return newPolygon().addPoints(newp.map(p => p.clone())).setOpenValue(this.open);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
midpoints(dist = 0.01) {
|
|
const newp = [];
|
|
const points = this.points;
|
|
const length = points.length;
|
|
const l0 = this.open ? length - 1 : length;
|
|
let mod = 0;
|
|
for (let i=0, p=points; i<l0; i++) {
|
|
const p1 = p[i];
|
|
const p2 = p[(i + 1) % length];
|
|
const dx = p2.x - p1.x;
|
|
const dy = p2.y - p1.y;
|
|
const ln = Math.sqrt(dx * dx + dy * dy);
|
|
if (ln < dist) {
|
|
newp.push(p1.midPointTo(p2));
|
|
mod++;
|
|
} else {
|
|
newp.push(p1);
|
|
}
|
|
}
|
|
if (mod) {
|
|
return newPolygon().addPoints(newp.map(p => p.clone())).setOpenValue(this.open);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
}
|
|
|
|
export function slopeDiff(s1, s2) {
|
|
const n1 = s1.angle;
|
|
const n2 = s2.angle;
|
|
let diff = n2 - n1;
|
|
while (diff < -180) diff += 360;
|
|
while (diff > 180) diff -= 360;
|
|
return Math.abs(diff);
|
|
}
|
|
|
|
export function fromClipperPath(path, z) {
|
|
let poly = newPolygon(),
|
|
i = 0,
|
|
l = path.length;
|
|
while (i < l) {
|
|
// poly.push(newPoint(null,null,z,null,path[i++]));
|
|
poly.push(pointFromClipper(path[i++], z));
|
|
}
|
|
return poly;
|
|
}
|
|
|
|
export function newPolygon(points) {
|
|
return new Polygon(points);
|
|
}
|