🎨 Updated prettier config
This commit is contained in:
Joost De Cock
parent
b8e632998b
commit
6710d76b08
401 changed files with 13193 additions and 15620 deletions
|
|
@ -1,95 +1,89 @@
|
|||
import Path from "./path";
|
||||
import Point from "./point";
|
||||
import Bezier from "bezier-js";
|
||||
import Path from './path'
|
||||
import Point from './point'
|
||||
import Bezier from 'bezier-js'
|
||||
|
||||
export function capitalize(string) {
|
||||
return string.charAt(0).toUpperCase() + string.slice(1);
|
||||
return string.charAt(0).toUpperCase() + string.slice(1)
|
||||
}
|
||||
|
||||
/** Returns internal hook name for a macro */
|
||||
export function macroName(name) {
|
||||
return `_macro_${name}`;
|
||||
return `_macro_${name}`
|
||||
}
|
||||
|
||||
/** Find intersection of two (endless) lines */
|
||||
export function beamsIntersect(a1, a2, b1, b2) {
|
||||
let slopeA = a1.slope(a2);
|
||||
let slopeB = b1.slope(b2);
|
||||
if (slopeA === slopeB) return false; // Parallel lines
|
||||
let slopeA = a1.slope(a2)
|
||||
let slopeB = b1.slope(b2)
|
||||
if (slopeA === slopeB) return false // Parallel lines
|
||||
|
||||
if (a1.x === a2.x)
|
||||
return new Point(a1.x, slopeB * a1.x + (b1.y - slopeB * b1.x));
|
||||
if (a1.x === a2.x) return new Point(a1.x, slopeB * a1.x + (b1.y - slopeB * b1.x))
|
||||
// Vertical line A
|
||||
else if (b1.x === b2.x)
|
||||
return new Point(b1.x, slopeA * b1.x + (a1.y - slopeA * a1.x));
|
||||
else if (b1.x === b2.x) return new Point(b1.x, slopeA * b1.x + (a1.y - slopeA * a1.x))
|
||||
// Vertical line B
|
||||
else {
|
||||
// Swap points if line A or B goes from right to left
|
||||
if (a1.x > a2.x) a1 = a2.copy();
|
||||
if (b1.x > b2.x) b1 = b2.copy();
|
||||
if (a1.x > a2.x) a1 = a2.copy()
|
||||
if (b1.x > b2.x) b1 = b2.copy()
|
||||
// Find y intercept
|
||||
let iA = a1.y - slopeA * a1.x;
|
||||
let iB = b1.y - slopeB * b1.x;
|
||||
let iA = a1.y - slopeA * a1.x
|
||||
let iB = b1.y - slopeB * b1.x
|
||||
|
||||
// Find intersection
|
||||
let x = (iB - iA) / (slopeA - slopeB);
|
||||
let y = slopeA * x + iA;
|
||||
let x = (iB - iA) / (slopeA - slopeB)
|
||||
let y = slopeA * x + iA
|
||||
|
||||
return new Point(x, y);
|
||||
return new Point(x, y)
|
||||
}
|
||||
}
|
||||
|
||||
/** Find intersection of two line segments */
|
||||
export function linesIntersect(a1, a2, b1, b2) {
|
||||
let p = beamsIntersect(a1, a2, b1, b2);
|
||||
if (!p) return false;
|
||||
let lenA = a1.dist(a2);
|
||||
let lenB = b1.dist(b2);
|
||||
let lenC = a1.dist(p) + p.dist(a2);
|
||||
let lenD = b1.dist(p) + p.dist(b2);
|
||||
if (
|
||||
Math.round(lenA) == Math.round(lenC) &&
|
||||
Math.round(lenB) == Math.round(lenD)
|
||||
)
|
||||
return p;
|
||||
else return false;
|
||||
let p = beamsIntersect(a1, a2, b1, b2)
|
||||
if (!p) return false
|
||||
let lenA = a1.dist(a2)
|
||||
let lenB = b1.dist(b2)
|
||||
let lenC = a1.dist(p) + p.dist(a2)
|
||||
let lenD = b1.dist(p) + p.dist(b2)
|
||||
if (Math.round(lenA) == Math.round(lenC) && Math.round(lenB) == Math.round(lenD)) return p
|
||||
else return false
|
||||
}
|
||||
|
||||
/** Finds out whether a point lies on an endless line */
|
||||
export function pointOnBeam(from, to, check, precision = 1e6) {
|
||||
if (from.sitsOn(check)) return true;
|
||||
if (to.sitsOn(check)) return true;
|
||||
let cross = check.dx(from) * to.dy(from) - check.dy(from) * to.dx(from);
|
||||
if (from.sitsOn(check)) return true
|
||||
if (to.sitsOn(check)) return true
|
||||
let cross = check.dx(from) * to.dy(from) - check.dy(from) * to.dx(from)
|
||||
|
||||
if (Math.abs(Math.round(cross * precision) / precision) === 0) return true;
|
||||
else return false;
|
||||
if (Math.abs(Math.round(cross * precision) / precision) === 0) return true
|
||||
else return false
|
||||
}
|
||||
|
||||
/** Finds out whether a point lies on a line segment */
|
||||
export function pointOnLine(from, to, check, precision = 1e6) {
|
||||
if (!pointOnBeam(from, to, check, precision)) return false;
|
||||
let lenA = from.dist(to);
|
||||
let lenB = from.dist(check) + check.dist(to);
|
||||
if (Math.round(lenA) == Math.round(lenB)) return true;
|
||||
else return false;
|
||||
if (!pointOnBeam(from, to, check, precision)) return false
|
||||
let lenA = from.dist(to)
|
||||
let lenB = from.dist(check) + check.dist(to)
|
||||
if (Math.round(lenA) == Math.round(lenB)) return true
|
||||
else return false
|
||||
}
|
||||
|
||||
/** Finds out whether a point lies on a curve */
|
||||
export function pointOnCurve(start, cp1, cp2, end, check) {
|
||||
if (start.sitsOn(check)) return true;
|
||||
if (end.sitsOn(check)) return true;
|
||||
if (start.sitsOn(check)) return true
|
||||
if (end.sitsOn(check)) return true
|
||||
let curve = new Bezier(
|
||||
{ x: start.x, y: start.y },
|
||||
{ x: cp1.x, y: cp1.y },
|
||||
{ x: cp2.x, y: cp2.y },
|
||||
{ x: end.x, y: end.y }
|
||||
);
|
||||
)
|
||||
let intersections = curve.intersects({
|
||||
p1: { x: check.x - 1, y: check.y },
|
||||
p2: { x: check.x + 1, y: check.y }
|
||||
});
|
||||
if (intersections.length > 0) return intersections.shift();
|
||||
else return false;
|
||||
})
|
||||
if (intersections.length > 0) return intersections.shift()
|
||||
else return false
|
||||
}
|
||||
|
||||
/** Splits a curve on a point */
|
||||
|
|
@ -97,7 +91,7 @@ export function splitCurve(start, cp1, cp2, end, split) {
|
|||
let [c1, c2] = new Path()
|
||||
.move(start)
|
||||
.curve(cp1, cp2, end)
|
||||
.split(split);
|
||||
.split(split)
|
||||
|
||||
return [
|
||||
{
|
||||
|
|
@ -112,215 +106,201 @@ export function splitCurve(start, cp1, cp2, end, split) {
|
|||
cp2: c2.ops[1].cp2,
|
||||
end: c2.ops[1].to
|
||||
}
|
||||
];
|
||||
]
|
||||
}
|
||||
|
||||
/** Find where an (endless) line intersects with a certain X-value */
|
||||
export function beamIntersectsX(from, to, x) {
|
||||
if (from.x === to.x) return false; // Vertical line
|
||||
let top = new Point(x, -10);
|
||||
let bottom = new Point(x, 10);
|
||||
if (from.x === to.x) return false // Vertical line
|
||||
let top = new Point(x, -10)
|
||||
let bottom = new Point(x, 10)
|
||||
|
||||
return beamsIntersect(from, to, top, bottom);
|
||||
return beamsIntersect(from, to, top, bottom)
|
||||
}
|
||||
|
||||
/** Find where an (endless) line intersects with a certain Y-value */
|
||||
export function beamIntersectsY(from, to, y) {
|
||||
if (from.y === to.y) return false; // Horizontal line
|
||||
let left = new Point(-10, y);
|
||||
let right = new Point(10, y);
|
||||
if (from.y === to.y) return false // Horizontal line
|
||||
let left = new Point(-10, y)
|
||||
let right = new Point(10, y)
|
||||
|
||||
return beamsIntersect(from, to, left, right);
|
||||
return beamsIntersect(from, to, left, right)
|
||||
}
|
||||
|
||||
/** Convert value in mm to cm or imperial units */
|
||||
export function units(value, to = "metric") {
|
||||
if (to === "imperial") return round(value / 25.4) + '"';
|
||||
else return round(value / 10) + "cm";
|
||||
export function units(value, to = 'metric') {
|
||||
if (to === 'imperial') return round(value / 25.4) + '"'
|
||||
else return round(value / 10) + 'cm'
|
||||
}
|
||||
|
||||
/** Find where a curve intersects with line */
|
||||
export function lineIntersectsCurve(start, end, from, cp1, cp2, to) {
|
||||
let intersections = [];
|
||||
let intersections = []
|
||||
let bz = new Bezier(
|
||||
{ x: from.x, y: from.y },
|
||||
{ x: cp1.x, y: cp1.y },
|
||||
{ x: cp2.x, y: cp2.y },
|
||||
{ x: to.x, y: to.y }
|
||||
);
|
||||
)
|
||||
let line = {
|
||||
p1: { x: start.x, y: start.y },
|
||||
p2: { x: end.x, y: end.y }
|
||||
};
|
||||
}
|
||||
for (let t of bz.intersects(line)) {
|
||||
let isect = bz.get(t);
|
||||
intersections.push(new Point(isect.x, isect.y));
|
||||
let isect = bz.get(t)
|
||||
intersections.push(new Point(isect.x, isect.y))
|
||||
}
|
||||
|
||||
if (intersections.length === 0) return false;
|
||||
else if (intersections.length === 1) return intersections[0];
|
||||
else return intersections;
|
||||
if (intersections.length === 0) return false
|
||||
else if (intersections.length === 1) return intersections[0]
|
||||
else return intersections
|
||||
}
|
||||
|
||||
/** Find where a curve intersects with a given X-value */
|
||||
export function curveIntersectsX(from, cp1, cp2, to, x) {
|
||||
let start = new Point(x, -10000);
|
||||
let end = new Point(x, 10000);
|
||||
return lineIntersectsCurve(start, end, from, cp1, cp2, to);
|
||||
let start = new Point(x, -10000)
|
||||
let end = new Point(x, 10000)
|
||||
return lineIntersectsCurve(start, end, from, cp1, cp2, to)
|
||||
}
|
||||
|
||||
/** Find where a curve intersects with a given Y-value */
|
||||
export function curveIntersectsY(from, cp1, cp2, to, y) {
|
||||
let start = new Point(-10000, y);
|
||||
let end = new Point(10000, y);
|
||||
return lineIntersectsCurve(start, end, from, cp1, cp2, to);
|
||||
let start = new Point(-10000, y)
|
||||
let end = new Point(10000, y)
|
||||
return lineIntersectsCurve(start, end, from, cp1, cp2, to)
|
||||
}
|
||||
|
||||
/** Find where a curve intersects with another curve */
|
||||
export function curvesIntersect(
|
||||
fromA,
|
||||
cp1A,
|
||||
cp2A,
|
||||
toA,
|
||||
fromB,
|
||||
cp1B,
|
||||
cp2B,
|
||||
toB
|
||||
) {
|
||||
let precision = 0.005; // See https://github.com/Pomax/bezierjs/issues/99
|
||||
let intersections = [];
|
||||
export function curvesIntersect(fromA, cp1A, cp2A, toA, fromB, cp1B, cp2B, toB) {
|
||||
let precision = 0.005 // See https://github.com/Pomax/bezierjs/issues/99
|
||||
let intersections = []
|
||||
let curveA = new Bezier(
|
||||
{ x: fromA.x, y: fromA.y },
|
||||
{ x: cp1A.x, y: cp1A.y },
|
||||
{ x: cp2A.x, y: cp2A.y },
|
||||
{ x: toA.x, y: toA.y }
|
||||
);
|
||||
)
|
||||
let curveB = new Bezier(
|
||||
{ x: fromB.x, y: fromB.y },
|
||||
{ x: cp1B.x, y: cp1B.y },
|
||||
{ x: cp2B.x, y: cp2B.y },
|
||||
{ x: toB.x, y: toB.y }
|
||||
);
|
||||
)
|
||||
|
||||
for (let tvalues of curveA.intersects(curveB, precision)) {
|
||||
let intersection = curveA.get(tvalues.substr(0, tvalues.indexOf("/")));
|
||||
intersections.push(new Point(intersection.x, intersection.y));
|
||||
let intersection = curveA.get(tvalues.substr(0, tvalues.indexOf('/')))
|
||||
intersections.push(new Point(intersection.x, intersection.y))
|
||||
}
|
||||
|
||||
if (intersections.length === 0) return false;
|
||||
else if (intersections.length === 1) return intersections.shift();
|
||||
if (intersections.length === 0) return false
|
||||
else if (intersections.length === 1) return intersections.shift()
|
||||
else {
|
||||
let unique = [];
|
||||
let unique = []
|
||||
for (let i of intersections) {
|
||||
let dupe = false;
|
||||
let dupe = false
|
||||
for (let u of unique) {
|
||||
if (i.sitsRoughlyOn(u)) dupe = true;
|
||||
if (i.sitsRoughlyOn(u)) dupe = true
|
||||
}
|
||||
if (!dupe) unique.push(i);
|
||||
if (!dupe) unique.push(i)
|
||||
}
|
||||
return unique;
|
||||
return unique
|
||||
}
|
||||
}
|
||||
|
||||
/** Find the intersections between two circles */
|
||||
export function circlesIntersect(c1, r1, c2, r2, sort = "x") {
|
||||
let dx = c1.dx(c2);
|
||||
let dy = c1.dy(c2);
|
||||
let dist = c1.dist(c2);
|
||||
export function circlesIntersect(c1, r1, c2, r2, sort = 'x') {
|
||||
let dx = c1.dx(c2)
|
||||
let dy = c1.dy(c2)
|
||||
let dist = c1.dist(c2)
|
||||
// Check for edge cases
|
||||
if (dist > parseFloat(r1) + parseFloat(r2)) return false; // Circles do not intersect
|
||||
if (dist < parseFloat(r2) - parseFloat(r1)) return false; // One circle is contained in the other
|
||||
if (dist === 0 && r1 === r2) return false; // Two circles are identical
|
||||
let chorddistance =
|
||||
(Math.pow(r1, 2) - Math.pow(r2, 2) + Math.pow(dist, 2)) / (2 * dist);
|
||||
let halfchordlength = Math.sqrt(Math.pow(r1, 2) - Math.pow(chorddistance, 2));
|
||||
let chordmidpointx = c1.x + (chorddistance * dx) / dist;
|
||||
let chordmidpointy = c1.y + (chorddistance * dy) / dist;
|
||||
if (dist > parseFloat(r1) + parseFloat(r2)) return false // Circles do not intersect
|
||||
if (dist < parseFloat(r2) - parseFloat(r1)) return false // One circle is contained in the other
|
||||
if (dist === 0 && r1 === r2) return false // Two circles are identical
|
||||
let chorddistance = (Math.pow(r1, 2) - Math.pow(r2, 2) + Math.pow(dist, 2)) / (2 * dist)
|
||||
let halfchordlength = Math.sqrt(Math.pow(r1, 2) - Math.pow(chorddistance, 2))
|
||||
let chordmidpointx = c1.x + (chorddistance * dx) / dist
|
||||
let chordmidpointy = c1.y + (chorddistance * dy) / dist
|
||||
let i1 = new Point(
|
||||
chordmidpointx + (halfchordlength * dy) / dist,
|
||||
chordmidpointy - (halfchordlength * dx) / dist
|
||||
);
|
||||
)
|
||||
let i2 = new Point(
|
||||
chordmidpointx - (halfchordlength * dy) / dist,
|
||||
chordmidpointy + (halfchordlength * dx) / dist
|
||||
);
|
||||
)
|
||||
|
||||
if ((sort === "x" && i1.x <= i2.x) || (sort === "y" && i1.y <= i2.y))
|
||||
return [i1, i2];
|
||||
else return [i2, i1];
|
||||
if ((sort === 'x' && i1.x <= i2.x) || (sort === 'y' && i1.y <= i2.y)) return [i1, i2]
|
||||
else return [i2, i1]
|
||||
}
|
||||
|
||||
/** Find the intersections between a beam and a circle */
|
||||
export function beamIntersectsCircle(c, r, p1, p2, sort = "x") {
|
||||
let dx = p2.x - p1.x;
|
||||
let dy = p2.y - p1.y;
|
||||
let A = Math.pow(dx, 2) + Math.pow(dy, 2);
|
||||
let B = 2 * (dx * (p1.x - c.x) + dy * (p1.y - c.y));
|
||||
let C = Math.pow(p1.x - c.x, 2) + Math.pow(p1.y - c.y, 2) - Math.pow(r, 2);
|
||||
export function beamIntersectsCircle(c, r, p1, p2, sort = 'x') {
|
||||
let dx = p2.x - p1.x
|
||||
let dy = p2.y - p1.y
|
||||
let A = Math.pow(dx, 2) + Math.pow(dy, 2)
|
||||
let B = 2 * (dx * (p1.x - c.x) + dy * (p1.y - c.y))
|
||||
let C = Math.pow(p1.x - c.x, 2) + Math.pow(p1.y - c.y, 2) - Math.pow(r, 2)
|
||||
|
||||
let det = Math.pow(B, 2) - 4 * A * C;
|
||||
let det = Math.pow(B, 2) - 4 * A * C
|
||||
|
||||
if (A <= 0.0000001 || det < 0) return false;
|
||||
if (A <= 0.0000001 || det < 0) return false
|
||||
// No real solutions
|
||||
else if (det === 0) {
|
||||
// One solution
|
||||
let t = (-1 * B) / (2 * A);
|
||||
let i1 = new Point(p1.x + t * dx, p1.y + t * dy);
|
||||
return [i1];
|
||||
let t = (-1 * B) / (2 * A)
|
||||
let i1 = new Point(p1.x + t * dx, p1.y + t * dy)
|
||||
return [i1]
|
||||
} else {
|
||||
// Two solutions
|
||||
let t = (-1 * B + Math.sqrt(det)) / (2 * A);
|
||||
let i1 = new Point(p1.x + t * dx, p1.y + t * dy);
|
||||
t = (-1 * B - Math.sqrt(det)) / (2 * A);
|
||||
let i2 = new Point(p1.x + t * dx, p1.y + t * dy);
|
||||
if ((sort === "x" && i1.x <= i2.x) || (sort === "y" && i1.y <= i2.y))
|
||||
return [i1, i2];
|
||||
else return [i2, i1];
|
||||
let t = (-1 * B + Math.sqrt(det)) / (2 * A)
|
||||
let i1 = new Point(p1.x + t * dx, p1.y + t * dy)
|
||||
t = (-1 * B - Math.sqrt(det)) / (2 * A)
|
||||
let i2 = new Point(p1.x + t * dx, p1.y + t * dy)
|
||||
if ((sort === 'x' && i1.x <= i2.x) || (sort === 'y' && i1.y <= i2.y)) return [i1, i2]
|
||||
else return [i2, i1]
|
||||
}
|
||||
}
|
||||
/** Find the intersections between a line and a circle */
|
||||
export function lineIntersectsCircle(c, r, p1, p2, sort = "x") {
|
||||
let intersections = beamIntersectsCircle(c, r, p1, p2, sort);
|
||||
if (intersections === false) return false;
|
||||
export function lineIntersectsCircle(c, r, p1, p2, sort = 'x') {
|
||||
let intersections = beamIntersectsCircle(c, r, p1, p2, sort)
|
||||
if (intersections === false) return false
|
||||
else {
|
||||
if (intersections.length === 1) {
|
||||
if (pointOnLine(p1, p2, intersections[0])) return intersections;
|
||||
else return false;
|
||||
if (pointOnLine(p1, p2, intersections[0])) return intersections
|
||||
else return false
|
||||
} else {
|
||||
let i1 = intersections[0];
|
||||
let i2 = intersections[1];
|
||||
if (!pointOnLine(p1, p2, i1, 5) && !pointOnLine(p1, p2, i2, 5))
|
||||
return false;
|
||||
let i1 = intersections[0]
|
||||
let i2 = intersections[1]
|
||||
if (!pointOnLine(p1, p2, i1, 5) && !pointOnLine(p1, p2, i2, 5)) return false
|
||||
else if (pointOnLine(p1, p2, i1, 5) && pointOnLine(p1, p2, i2, 5)) {
|
||||
if ((sort === "x" && i1.x <= i2.x) || (sort === "y" && i1.y <= i2.y))
|
||||
return [i1, i2];
|
||||
else return [i2, i1];
|
||||
} else if (pointOnLine(p1, p2, i1, 5)) return [i1];
|
||||
else if (pointOnLine(p1, p2, i2, 5)) return [i2];
|
||||
if ((sort === 'x' && i1.x <= i2.x) || (sort === 'y' && i1.y <= i2.y)) return [i1, i2]
|
||||
else return [i2, i1]
|
||||
} else if (pointOnLine(p1, p2, i1, 5)) return [i1]
|
||||
else if (pointOnLine(p1, p2, i2, 5)) return [i2]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export function curveEdge(curve, edge, steps = 500) {
|
||||
let x = Infinity;
|
||||
let y = Infinity;
|
||||
let p;
|
||||
if (edge === "bottom") y = -Infinity;
|
||||
if (edge === "right") x = -Infinity;
|
||||
let x = Infinity
|
||||
let y = Infinity
|
||||
let p
|
||||
if (edge === 'bottom') y = -Infinity
|
||||
if (edge === 'right') x = -Infinity
|
||||
for (let i = 0; i < steps; i++) {
|
||||
p = curve.get(i / steps);
|
||||
p = curve.get(i / steps)
|
||||
if (
|
||||
(edge === "top" && p.y < y) ||
|
||||
(edge === "bottom" && p.y > y) ||
|
||||
(edge === "right" && p.x > x) ||
|
||||
(edge === "left" && p.x < x)
|
||||
(edge === 'top' && p.y < y) ||
|
||||
(edge === 'bottom' && p.y > y) ||
|
||||
(edge === 'right' && p.x > x) ||
|
||||
(edge === 'left' && p.x < x)
|
||||
) {
|
||||
x = p.x;
|
||||
y = p.y;
|
||||
x = p.x
|
||||
y = p.y
|
||||
}
|
||||
}
|
||||
|
||||
return new Point(x, y);
|
||||
return new Point(x, y)
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -335,23 +315,23 @@ export function curveEdge(curve, edge, steps = 500) {
|
|||
* This method does that calculation.
|
||||
*/
|
||||
export function stretchToScale(stretch) {
|
||||
return 1 / (1 + parseFloat(stretch));
|
||||
return 1 / (1 + parseFloat(stretch))
|
||||
}
|
||||
|
||||
export function round(value) {
|
||||
return Math.round(value * 1e2) / 1e2;
|
||||
return Math.round(value * 1e2) / 1e2
|
||||
}
|
||||
|
||||
export function sampleStyle(run, runs) {
|
||||
let hue = (run - 1) * (330 / runs);
|
||||
let hue = (run - 1) * (330 / runs)
|
||||
|
||||
return `stroke: hsl(${hue}, 100%, 35%);`;
|
||||
return `stroke: hsl(${hue}, 100%, 35%);`
|
||||
}
|
||||
|
||||
export function deg2rad(degrees) {
|
||||
return degrees * (Math.PI / 180);
|
||||
return degrees * (Math.PI / 180)
|
||||
}
|
||||
|
||||
export function rad2deg(radians) {
|
||||
return (radians / Math.PI) * 180;
|
||||
return (radians / Math.PI) * 180
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue