2b:null 2c:["$","title",null,{"children":"Prototyping a math library | Kjerand Pedersen | Observable"}] 31:T11b7,Point = { class Point { constructor(x, y) { if (!Util.isNumeric(x) || !Util.isNumeric(y)) { throw new Error(`Point: Expected arguments x and y to be numbers, but got ${x} and ${y}`); } this.x = x; this.y = y; } // The distance between two points static distance(p1, p2) { const dx = p2.x - p1.x; const dy = p2.y - p1.y; return Math.sqrt(dx**2 + dy**2); } // Find the orientation of three points static orientation(p, q, r) { const val = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y); if (val === 0) return Types.COLLINEAR; return (val > 0) ? Types.CLOCKWISE : Types.COUNTERCLOCKWISE; } /* p1, p2 and p3: Angle formed between p1 and p3 at p2 p1 and p2: Angle formed between the line p1p2 and the x axis p1: Angle between p1 and the origin */ static angle(p1, p2, p3) { if (p1 && p2 && p3) { const u = new Vector(p2, p3); const v = new Vector(p2, p1); return Vector.angle(u, v); } if(p1 && p2) { return new Angle(Math.atan2(p2.y - p1.y, p2.x - p1.x)); } return new Angle(Math.atan2(p1.y, p1.x)); } static fromPolarCoords(r, angle) { const a = angle instanceof Angle ? angle.value : angle; return new Point( r * Math.cos(a), r * Math.sin(a), ); } static fromArray(arr) { return new Point(arr[0], arr[1]); } static equals(p1, p2) { return Util.approxZero(p1.x - p2.x) && Util.approxZero(p1.y - p2.y); } static dx(p1, p2) { return p2.x - p1.x }; static dy(p1, p2) { return p2.y - p1.y }; static slope(p1, p2) { const dx = Point.dx(p1, p2); if (dx === 0) return undefined; return Point.dy(p1, p2) / Point.dx(p1, p2); }; static average(points) { const sum = points.reduce((s, p) => ({ x: s.x + p.x, y: s.y + p.y, }), { x: 0, y: 0 }); return new Point(sum.x / points.length, sum.y / points.length); } // order a set of points counter clockwise static order(points) { const center = Point.average(points); return points.sort((a, b) => { if (a.x - center.x >= 0 && b.x - center.x < 0) return 1; if (a.x - center.x < 0 && b.x - center.x >= 0) return -1; if (a.x - center.x == 0 && b.x - center.x == 0) { if (a.y - center.y >= 0 || b.y - center.y >= 0) return a.y > b.y ? 1 : -1; return b.y - a.y; } // compute the cross product of vectors (center -> a) x (center -> b) const det = (a.x - center.x) * (b.y - center.y) - (b.x - center.x) * (a.y - center.y); if (det < 0) return 1; if (det > 0) return -1; // points a and b are on the same line from the center // check which point is closer to the center const d1 = (a.x - center.x) * (a.x - center.x) + (a.y - center.y) * (a.y - center.y); const d2 = (b.x - center.x) * (b.x - center.x) + (b.y - center.y) * (b.y - center.y); return d1 - d2; }); } equals(p) { return Point.equals(this, p); } toPolarCoords() { return ({ r: Math.sqrt(this.x ** 2 + this.y ** 2), a: Point.angle(this), }); } toArray() { return [this.x, this.y]; } clone() { return new Point(this.x, this.y); } translate(dx, dy, mutate = false) { if (mutate) { this.x += dx; this.y += dy; return this; } return new Point(this.x + dx, this.y + dy); } translateByVector(V, factor = 1, mutate = false) { if (mutate) { this.x += V.x * factor; this.y += V.y * factor; return this; } return new Point(this.x + V.x * factor, this.y + V.y * factor); } asVector() { return new Vector(this.x, this.y); } // rotate point around q rotate(r, q = { x: 0, y: 0 }, mutate = false) { const v = new Vector(q, this); v.rotate(r, true); if (mutate) { this.x = v.x + q.x; this.y = v.y + q.y; return this; } return new Point(v.x + q.x, v.y + q.y); } } Point.ORIGO = new Point(0, 0); return Point; }32:Tfc2,Vector = { class Vector { constructor(a, b) { if (Util.isPointLike(a) && Util.isPointLike(b)) { this.x = b.x - a.x; this.y = b.y - a.y; } else if (Util.isNumeric(a) && Util.isNumeric(b)) { this.x = a; this.y = b; } else { throw new Error(`Vector constructor. Expected points or numeric values, but got '${a}' and '${b}'`); } } // Get unit vector from p2, centered between p1 and p3 static centralTo(p1, p2, p3) { if (!Util.isPointLike(p1) || !Util.isPointLike(p2) || !Util.isPointLike(p3)) { throw new Error('Invalid arguments!'); } const u = new Vector(p2, p1).unit(); const v = new Vector(p2, p3).unit(); return u.add(v).unit(); } static fromAngle(angle) { const rad = angle.value !== undefined ? angle.value : angle; const x = Math.cos(rad); const y = Math.sin(rad); return new Vector(x, y); } static angle(u, v) { return new Angle(Math.atan2(u.cross(v), u.dot(v))); } get isNull() { return this.x === 0 && this.y === 0; } clone() { return new Vector(this.x, this.y); } equals(v) { return Util.approxZero(this.x - v.x) && Util.approxZero(this.y - v.y); } length() { return Math.sqrt(this.x**2 + this.y**2); }; unit() { const l = this.length(); return l === 0 ? new Vector(0,0) : new Vector(this.x / l, this.y / l); }; normal() { const l = this.length(); return l === 0 ? new Vector(0,0) : new Vector(-(this.y / l), this.x / l); } angle() { return new Angle(Math.atan2(this.y, this.x)); } add(V, mutate = false) { if (mutate) { this.x += V.x; this.y += V.y; return this; } return new Vector(this.x + V.x, this.y + V.y); } sub(V, mutate = false) { if (mutate) { this.x -= V.x; this.y -= V.y; return this; } return new Vector(this.x - V.x, this.y - V.y); } scale(m, mutate = false) { if (mutate) { this.x *= m; this.y *= m return this; } return new Vector(this.x * m, this.y * m); } scaleXY(mx, my, mutate = false) { if (mutate) { this.x *= mx; this.y *= my return this; } return new Vector(this.x * mx, this.y * my); } cross(V) { return (this.x * V.y) - (this.y * V.x); } dot(V) { return (this.x * V.x) + (this.y * V.y); } projectOnto(V, limit = true) { const vl = V.length(); const proj = this.dot(V) / vl; if (limit && proj <= 0) return Vector.NULL; if (limit && proj > vl) return V.clone(); return V.unit().scale(proj); } rejectionFrom(V, limit = true) { const vl = V.length(); const proj = this.dot(V) / vl; if (limit && proj >= 0) return Vector.NULL; if (limit && proj > vl) return V.invert(); return V.unit().scale(proj); } invert(mutate = false) { if (mutate) { this.x = -this.x; this.y = -this.y; return this; } return new Vector(-this.x, -this.y); } orthogonal(mutate = false) { const _x = -this.y; const _y = this.x; if (mutate) { this.x = _x; this.y = _y; return this; } return new Vector(_x, _y); } rotate(r, mutate = false) { r = r instanceof Angle ? r.value : r; // x' = x cos r - y sin r // y' = y cos r + x sin r const sr = Math.sin(r); const cr = Math.cos(r); const newX = this.x * cr - this.y * sr; const newY = this.y * cr + this.x * sr; if (mutate) { this.x = newX; this.y = newY; return this; } return new Vector(newX, newY); } } Vector.UVX = new Vector(1, 0); Vector.UVY = new Vector(0, 1); Vector.NULL = new Vector(0, 0); return Vector; }33:Td44,Angle = { class Angle { constructor(angle) { if (angle instanceof Angle) { this.radians = angle.value; } else { this.radians = angle; } } static rad2deg(r) { return r * Angle.RAD2DEG; } static deg2rad(d) { return d * Angle.DEG2RAD; } get value() { return this.radians; } set value(rad) { this.radians = rad; } get degrees() { return this.radians * Angle.RAD2DEG; } set degrees(deg) { this.radians = deg * Angle.DEG2RAD; } get slope() { return (1 / Math.tan(this.value)); } // returns number representing quadrand I, II, III, or IV // returns undefined get quadrant() { const a = this.normalize().value; if (a > 0 && a < Angle.SPI) return 1; if (a > Angle.SPI && a < Angle.PI) return 4; if (a > -Angle.PI && a < -Angle.SPI) return 3; if (a > -Angle.SPI && a < 0) return 2; } // returns a number according to general direction, // where angles either is defined as pointing right // (0 <= a < PI) or otherwize left get generalDirection() { const a = this.normalize().value; if (a >= 0 && a < Angle.PI) return 1; return -1; } get rev() { return this.value * Angle.RAD2REV; } get positiveValue() { const v = this.value % Angle.TAU; return (v < 0 ? v + Angle.TAU : v); } cos() { return Math.cos(this.value); } sin() { return Math.sin(this.value); } tan() { return Math.tan(this.value); } invert(mutate = false) { const na = -this.value; if (mutate) { this.value = na; return this; } return new Angle(na); } // normalize angle between +/- PI normalize(mutate = false) { const na = this.value - Angle.TAU * Math.floor((this.value + Angle.PI) / Angle.TAU); if (mutate) { this.value = na; return this; } return new Angle(na); } // positive angle measured from start angle relative(start = 0, mutate = false) { if (!(start instanceof Angle)) start = new Angle(start); const a = new Angle(start.value + this.value); if (a.value < 0) { a.value += Angle.TAU; } if (mutate) { this.radians = a.value; return this; } return a; } suppl(mutate = false) { const n = this.normalize().value; if (n < 0 || n > Angle.PI) return null; const sa = Angle.PI - n; if (mutate) { this.value = sa; return this; } return new Angle(sa); } compl(mutate = false) { const n = this.normalize().value; if (n < 0 || n > Angle.SPI) return null; const ca = Angle.SPI - n; if (mutate) { this.value = ca; return this; } return new Angle(ca); } add(rad, mutate = false) { if (mutate) { this.value += rad; return this; } return new Angle(this.value + rad); } } Angle.TAU = Math.PI * 2; Angle.PI = Math.PI; Angle.SPI = Math.PI / 2; // Semi PI (or half of PI) Angle.QPI = Math.PI / 4; // Quarter of PI Angle.RAD2DEG = 180 / Angle.PI; Angle.DEG2RAD = Angle.PI / 180; Angle.RAD2REV = 1 / (Angle.TAU); return Angle; }34:T71c,class Line { constructor(vector, point = Point.ORIGO, cache = true) { this.vector = vector.unit(); this.point = point; this.cache = cache ? new Cache( () => `${this.vector.x},${this.vector.y},${this.point.x},${this.point.y}`, ) : undefined; } static fromPoints(p1, p2) { const v = new Vector(p1, p2).unit(); return new Line(v, p1); } static fromStandardForm(m, b) { const p1 = new Point(0, b); const p2 = new Point(1, m + b); return this.fromPoints(p1, p2); } get m() { if (this.vector.x === 0) return undefined; if (this.cache) { const m = this.cache.get('m'); if (m !== undefined) return m; } const m = this.vector.y / this.vector.x; if (this.cache) { this.cache.set('m', m); } return m; } get b() { if (this.cache) { const b = this.cache.get('b'); if (b !== undefined) return b; } const b = this.y(0); if (this.cache) { this.cache.set('b', b); } return b; } angle() { return this.vector.angle().normalize(true); } tx(x) { if (this.vector.x === 0) return undefined; const t = (x - this.point.x) / this.vector.x; return t; } ty(y) { if (this.vector.y === 0) return undefined; const t = (y - this.point.y) / this.vector.y; return t; } x(y) { const t = this.ty(y); if (t === undefined) return undefined; return this.point.x + t * this.vector.x; } y(x) { const t = this.tx(x); if (t === undefined) return undefined; return this.point.y + t * this.vector.y; } ys(...xs) { return xs.map(x => this.y(x)); } points(...xs) { return xs.map(x => new Point(x, this.y(x))); } clone() { return new Line(this.vector, this.point); } }35:T4af,class Ray extends Line { isBehind(p) { const { x: x0, y: y0 } = this.origin; const { x: x1, y: y1 } = p; const u = new Vector(this.origin, p); const projA = u.dot(this.vector); return this.vector.dot(u) < 0; } get origin() { return this.point; } set origin(p) { this.point = p; } proximityToPoint(p) { const u = new Vector(this.origin, p); return this.vector.dot(u) / u.length(); } x(y) { if (this.vector.y === 0) { if (y === this.origin.y) { return new Range(this.origin.x, this.vector.x < 0 ? -Infinity : +Infinity); } return undefined; } const t = this.ty(y); if (t === undefined) return undefined; const x = this.point.x + t * this.vector.x; return this.isBehind(new Point(x, y)) ? null : x; } y(x) { if (this.vector.x === 0) { if (x === this.origin.x) { return new Range(this.origin.y, this.vector.y < 0 ? -Infinity : +Infinity); } return undefined; } const t = this.tx(x); if (t === undefined) return undefined; const y = this.point.y + t * this.vector.y; return this.isBehind(new Point(x, y)) ? null : y; } }36:T89f,class LineSegment { constructor(p1, p2) { if (!Util.isPointLike(p1) || !Util.isPointLike(p2)) throw new Error('Invalid points!'); this.p1 = new Point(p1.x, p1.y); this.p2 = new Point(p2.x, p2.y); } get x1() { return this.p1.x; } get y1() { return this.p1.y; } get x2() { return this.p2.x; } get y2() { return this.p2.y; } length() { return Point.getLength(this.p1, this.p2); } isVertical() { return this.x1 === this.x2; } isHorizontal() { return this.y1 === this.y2; } boundingBox() { return ({ x1: Math.min(this.x1, this.x2), y1: Math.min(this.y1, this.y2), x2: Math.max(this.x1, this.x2), y2: Math.max(this.y1, this.y2), }); } centeroid() { return new Point( (this.x1 + this.x2) / 2, (this.y1 + this.y2) / 2, ); } toVector() { return new Vector(Point.dx(this.p1, this.p2), Point.dy(this.p1, this.p2)); } toLine() { if (Point.equals(this.p1, this.p2)) throw 'Points are equal and cannot form a line!'; return Line.fromPoints(this.p1, this.p2); } clone() { return new LineSegment(this.p1, this.p2); } equals(s, ignoreOrientation = false) { const isEqual = this.p1.equals(s.p1) && this.p2.equals(s.p2); if (isEqual) return true; if (ignoreOrientation) { return this.p1.equals(s.p2) && this.p2.equals(s.p1); } return false; } invert(mutate = false) { const _p1 = this.p2; const _p2 = this.p1; if (mutate) { this.p1 = _p1; this.p2 = _p2; return this; } return new LineSegment(_p1, _p2); } normalizeOrientation(mutate = false) { // normalizes the direction, so that the segment will point // from left to right, or from bottom to top if vertical const A = this; if (A.x2 < A.x1 || (A.isVertical() && A.y1 > A.y2)) { return A.invert(mutate); } return this; } translate(dx, dy, mutate = false) { if (mutate) { this.p1.translate(dx, dy, true); this.p2.translate(dx, dy, true); return this; } return new LineSegment( this.p1.translate(dx, dy), this.p2.translate(dx, dy), ); } }37:T1455,class Ellipse { constructor(center, radiusX, radiusY) { this.center = new Point(center.x, center.y); this.radiusX = radiusX; this.radiusY = radiusY; } get majorSemiAxis() { return Math.max(this.radiusX, this.radiusY); } get minorSemiAxis() { return Math.min(this.radiusX, this.radiusY); } isInternal(point) { const dx = point.x - this.center.x; const dy = point.y - this.center.y; return (dx ** 2 / this.radiusX ** 2) + (dy ** 2 / this.radiusY ** 2) < 1; } centeroid() { return this.center; } area() { return this.radiusX * this.radiusY * Angle.PI; } perimeter() { return Angle.TAU * Math.sqrt((this.radiusX ** 2 + this.radiusY **2) / 2); } boundingBox() { return ({ x1: this.center.x - this.radiusX, y1: this.center.y - this.radiusY, x2: this.center.x + this.radiusX, y2: this.center.y + this.radiusY, }); } // vector with direction according to angle and magnitude equal to the // length from the ellipse center to its circumference vectorAtAngle(angle) { const theta = (angle instanceof Angle ? angle : new Angle(angle)).normalize(); const sign = theta.value > Angle.SPI || theta.value < -Angle.SPI ? -1 : 1; const t = Math.atan(this.radiusX * theta.tan() / this.radiusY); return new Vector( this.radiusX * Math.cos(t) * sign, this.radiusY * Math.sin(t) * sign, ); } pointAtAngle(angle) { const v = this.vectorAtAngle(angle); return new Point( this.center.x + v.x, this.center.y + v.y, ); } tangentAtAngle(angle) { const aa = this.radiusX ** 2; const bb = this.radiusY ** 2; const v = this.vectorAtAngle(angle); return new Vector(-v.y / bb, v.x / aa).unit(); } normalAtAngle(angle) { const aa = this.radiusX ** 2; const bb = this.radiusY ** 2; const v = this.vectorAtAngle(angle); return new Vector(v.x / aa, v.y / bb).unit(); } inscribe(depth = 3) { const len = 2 ** depth; const verts = new Array(len * 4); const a2 = this.radiusX ** 2; const b2 = this.radiusY ** 2; const dcx = 2 * this.center.x; const dcy = 2 * this.center.y; let idx = 0; // recursive subdivide ellipse into sectors const subDivide = (r1, r2, target, level = 0) => { const u = new Vector(this.center, r1).add(new Vector(this.center, r2), true); const v = this.vectorAtAngle(u.angle()); const np = this.center.translate(v.x, v.y); if (level < target) { subDivide(r1, np, target, level + 1); subDivide(np, r2, target, level + 1); } else { const i = idx++; verts[i] = np; verts[len + (len - 1 - i)] = new Point(dcx - np.x, np.y); verts[2 * len + i] = new Point(dcx - np.x, dcy - np.y); verts[3 * len + (len - 1 - i)] = new Point(np.x, dcy - np.y); } }; let r1 = new Point(this.center.x - this.radiusX, this.center.y); let r2 = new Point(this.center.x, this.center.y - this.radiusY); subDivide(r1, r2, depth); return new Polygon(verts); } escribe(depth = 3) { const len = 2 * 2 ** (depth - 1); const verts = new Array(len * 4); const a2 = this.radiusX ** 2; const b2 = this.radiusY ** 2; const dcx = 2 * this.center.x; const dcy = 2 * this.center.y; let idx = 0; // recursive subdivide ellipse into sectors and find tangent // intersection points const subDivide = (r1, r2, t1, t2, target, level = 0) => { const u = new Vector(this.center, r1).add(new Vector(this.center, r2), true); const v = this.vectorAtAngle(u.angle()); const np = this.center.translate(v.x, v.y); const tv = new Vector(-v.y / b2, v.x / a2).unit(true); if (level < target) { subDivide(r1, np, t1, tv, target, level + 1); subDivide(np, r2, tv, t2, target, level + 1); } else { const ip1 = Intersect.vectors(r1, t1, np, tv); const ip2 = Intersect.vectors(np, tv, r2, t2); const idx1 = idx++; const idx2 = idx++; verts[idx1] = ip1; verts[idx2] = ip2; verts[len + (len - 1 - idx1)] = new Point(dcx - ip1.x, ip1.y); verts[len + (len - 1 - idx2)] = new Point(dcx - ip2.x, ip2.y); verts[2 * len + idx1] = new Point(dcx - ip1.x, dcy - ip1.y); verts[2 * len + idx2] = new Point(dcx - ip2.x, dcy - ip2.y); verts[3 * len + (len - 1 - idx1)] = new Point(ip1.x, dcy - ip1.y); verts[3 * len + (len - 1 - idx2)] = new Point(ip2.x, dcy - ip2.y); } }; let r1 = new Point(this.center.x - this.radiusX, this.center.y); let r2 = new Point(this.center.x, this.center.y - this.radiusY); let t1 = new Vector(0, -1); let t2 = new Vector(1, 0); subDivide(r1, r2, t1, t2, depth - 1); return new Polygon(verts); } scale(factor, mutate = false) { const rx = this.radiusX * factor; const ry = this.radiusY * factor; if (mutate) { this.radiusX = rx; this.radiusY = ry; return this; } return new Ellipse(this.center, rx, ry); } }38:Tf2b,class Circle extends Ellipse{ constructor(center, radius) { super(center, radius, radius); } get radius() { return this.radiusX; } get diameter() { return 2 * this.radius; } isInternal(point) { const v = new Vector(this.center, point); return v.length() < this.radius; } perimeter() { return Angle.TAU * this.radius; } pointAtAngle(angle) { const theta = angle instanceof Angle ? angle.value : angle; return new Point( this.center.x + this.radius * Math.cos(theta), this.center.y + this.radius * Math.sin(theta), ); } tangentsFromPoint(point) { const vc = new Vector(point, this.center); const l = vc.length(); if (l < this.radius) return null; if (l === this.radius) return [point]; const a = Math.asin(this.radius / l); const b = Math.atan2(vc.y, vc.x); let t = b - a; const t1 = new Point( this.center.x + this.radius * Math.sin(t), this.center.y + this.radius * -Math.cos(t), ); t = b + a const t2 = new Point( this.center.x + this.radius * -Math.sin(t), this.center.y + this.radius * Math.cos(t), ); return [t1, t2]; } exteriorTangents(circle) { const c1 = circle.radius > this.radius ? circle : this; const c2 = circle.radius > this.radius ? this : circle; const ri = c1.radius - c2.radius; if (ri === 0) { const v = new Vector(c1.center, c2.center); if (v.length() === 0) return null; const n = v.normal(true); return [ new LineSegment( c1.center.translateByVector(n, c1.radius), c2.center.translateByVector(n, c2.radius), ), new LineSegment( c1.center.translateByVector(n, -c1.radius), c2.center.translateByVector(n, -c2.radius), ), ]; } const c3 = new Circle(c1.center, ri); const ti = c3.tangentsFromPoint(c2.center); const tan = []; if (ti) { ti.map((t) => { const v = new Vector(c1.center, t).unit(true); const p1 = t.translateByVector(v, c2.radius); const p2 = c2.center.translateByVector(v, c2.radius); tan.push(new LineSegment(p1, p2)); }); } return tan.length > 0 ? tan : null; } interiorTangents(circle) { const c1 = circle.radius > this.radius ? circle : this; const c2 = circle.radius > this.radius ? this : circle; const ri = c1.radius + c2.radius; const c3 = new Circle(c1.center, ri); const ti = c3.tangentsFromPoint(c2.center); const tan = []; if (ti) { ti.map((t) => { const v = new Vector(c1.center, t).unit(true); const p1 = t.translateByVector(v, -c2.radius); const p2 = c2.center.translateByVector(v, -c2.radius); tan.push(new LineSegment(p1, p2)); }); } return tan.length > 0 ? tan : null; } inscribe(depth = 3) { const verts = []; const step = Angle.QPI / depth; let angle = 0; while (angle < Angle.TAU) { verts.push(this.pointAtAngle(angle)); angle += step; } return new Polygon(verts); } escribe(depth = 3) { const verts = []; const step = Angle.QPI / depth; let angle = step; let pp = this.center.translate(this.radius, 0); let pt = new Vector(0, 1); while (angle <= Angle.TAU) { const cp = this.pointAtAngle(angle); const t = new Vector(this.center, cp).orthogonal(true); const ip = Intersect.vectors(pp, pt, cp, t); verts.push(ip); pp = cp; pt = t; angle += step; } return new Polygon(verts); } scale(factor, mutate = false) { const r = this.radius * factor; if (mutate) { this.radius = r; return this; } return new Circle(this.center, r); } }39:T363e,class Polygon { constructor(vertices, cache = true) { if (!vertices || vertices.length <= 2) throw new Error('A minimum of 3 vertices are required to form a polygon!'); this.cache = cache ? new Cache(() => JSON.stringify(this.vertices)) : undefined; this.vertices = vertices.map(v => new Point(v.x, v.y)); } static rectangle (x = -1, y = 1, width = 2, height = 2) { const verts = [ new Point(x, y), new Point(x, y - height), new Point(x + width, y - height), new Point(x + width, y), ]; return new Polygon(verts); } static equilateral (edges = 3, radius = 1, center = Point.ORIGO, startAngle) { const verts = [] const step = Angle.TAU / edges; const start = startAngle || Angle.SPI; const end = Angle.TAU + start; for (var x = start; x < end; x += step) { let angle = x; verts.push(new Point( center.x + (radius * Math.cos(angle)), center.y + (radius * Math.sin(angle)), )); } return new Polygon(verts); } static findEar(vertices) { const len = vertices.length; if (len < 4) return null; const itr = Util.cycleIterator(len); for(let i = 0; i < len; i++) { const v0 = vertices[itr.prevFrom(i)]; const v1 = vertices[i]; const v2 = vertices[itr.nextFrom(i)]; const angle = Point.angle(v0, v1, v2); if (angle.positiveValue < Angle.PI) { const candidate = new Polygon([v0, v1, v2]); let isEar = true; let j = itr.nextFrom(i+1); while(j !== itr.prevFrom(i)) { if (candidate.isInternal(vertices[j])) { isEar = false; break; } j = itr.nextFrom(j); } if (isEar) { return ({ index: i, triangle: candidate, }); } } } return null; } static mapIndices(polygons) { const mapToIndices = new Array(polygons.length); const verts = []; const mapToPolygon = []; for (let i = 0; i < polygons.length; i++) { const pol = polygons[i]; const pIndices = new Array(pol.vertices.length); for (let j = 0; j < pol.vertices.length; j++) { const vert = pol.vertices[j]; let idx = verts.findIndex(d => d.equals(vert)); if (idx === -1) { idx = verts.length; verts.push(vert); mapToPolygon[idx] = []; } pIndices[j] = idx; mapToPolygon[idx].push(i); } mapToIndices[i] = pIndices; } const indices = verts.map((v, i) => ({ polygons: mapToPolygon[i], vertex: v, })); return ({ indices, polygons: mapToIndices, }); } static mapEdges(polygons) { const mapToEdges = new Array(polygons.length); const edges = []; const mapToPolygon = []; for (let i = 0; i < polygons.length; i++) { const pol = polygons[i]; const pIndices = []; const pEdges = pol.edges().filter(d => d.p1.equals(d.p2) === false); if (pEdges.length >= 3) { for (let j = 0; j < pEdges.length; j++) { const edge = pEdges[j]; let idx = edges.findIndex(d => d.equals(edge, true)); if (idx === -1) { idx = edges.length; edges.push(edge); mapToPolygon[idx] = []; } pIndices[j] = idx; mapToPolygon[idx].push(i); } } mapToEdges[i] = pIndices; } const indices = edges.map((v, i) => ({ polygons: mapToPolygon[i], edge: v, })); return ({ indices, polygons: mapToEdges, }); } static merge(polygons) { if (polygons.length === 1) return polygons; const map = Polygon.mapEdges(polygons); // find outer edges const edges = map.indices.filter(d => d.polygons.length === 1).map(d => d.edge); // link edges to form polygons and make sure they is oriented CCW const merged = []; let start = edges.pop(); start.normalizeOrientation(true); let end = start.p2; let verts = [start.p1, start.p2]; while (edges.length > 0) { const idx = edges.findIndex(d => d.p1.equals(end) || d.p2.equals(end)); if (idx === -1) { console.log('Ooops!', map, edges, end); break; } const edge = edges.splice(idx, 1)[0]; const vertex = edge.p1.equals(end) ? edge.p2 : edge.p1; // check for closed loop if (vertex.equals(verts[0])) { merged.push(new Polygon(verts).clean(true)); if (edges.length < 3) break; start = edges.pop(); start.normalizeOrientation(true); end = start.p2; verts = [start.p1, start.p2]; } else { verts.push(vertex); end = vertex; } } return merged; } clone() { return new Polygon(this.vertices.map(p => p)); } vectors() { return this.vertices.cycle((v, nv) => new Vector(v, nv)); } edges() { return this.vertices.cycle((v, nv) => new LineSegment(v, nv)); } areaSigned() { if (this.isSelfIntersecting()) return undefined; // Self-intersecting polygons not supported for this operation! const sum = this.vertices.cycle( (v, nv) => v.x * nv.y - v.y * nv.x ).reduce((sum, v) => sum + v, 0); return sum / 2; } area() { return Math.abs(this.areaSigned()); } perimeter() { return this.vectors().reduce((sum, v) => sum + v.length(), 0); } centeroid() { if (this.isSelfIntersecting()) return undefined; // Self-intersecting polygons not supported for this operation! if (this.cache) { const centeroid = this.cache.get('centeroid'); if (centeroid !== undefined) return centeroid; } let cx = 0; let cy = 0; let a = 0; const values = this.vertices.cycle((p, pn) => { const s = (p.x * pn.y - pn.x * p.y); cx += (p.x + pn.x) * s; cy += (p.y + pn.y) * s; a += s; }); const w = (1 / (6 * (a / 2))); const centeroid = new Point( cx * w, cy * w, ); if (this.cache) { this.cache.set('centeroid', centeroid); } return centeroid; } orientation() { return this.areaSigned() < 0 ? Types.CLOCKWISE : Types.COUNTERCLOCKWISE; } angles() { const cw = this.orientation() === Types.CLOCKWISE; return this.vertices.cycle((v, nv, pv) => cw ? Point.angle(nv, v, pv) : Point.angle(pv, v, nv)); } isSelfIntersecting() { const v = this.vertices; const len = v.length; if (len < 4) return false; if (this.cache) { const selfIntersects = this.cache.get('self_intersects'); if (selfIntersects !== undefined) return selfIntersects; } const decide = () => { const itr = Util.cycleIterator(len); for (let i = 0; i < len - 2; i++) { const a = v[i]; const b = v[itr.nextFrom(i)]; for (let j = itr.nextFrom(i + 1); j < len && j !== itr.prevFrom(i); j++) { const c = v[j]; const d = v[itr.nextFrom(j)]; if (FastIntersect.edges(a, b, c, d)) return true; } } return false; } const selfIntersects = decide(); if (this.cache) { this.cache.set('self_intersects', selfIntersects); } return selfIntersects; } isConvex() { const v = this.vertices; const len = v.length; if (len < 4) return true; if (this.cache) { const isConvex = this.cache.get('is_convex'); if (isConvex !== undefined) return isConvex; } const decide = () => { const cw = this.orientation() === Types.CLOCKWISE; for (let i = 0; i < len; i++) { const p0 = v[i]; const p1 = v[(i + 1) % len]; const p2 = v[(i + 2) % len]; const angle = cw ? Point.angle(p2, p1, p0) : Point.angle(p0, p1, p2); if (angle.positiveValue > Angle.PI) return false; } return true; } const isConvex = decide(); if (this.cache) { this.cache.set('is_convex', isConvex); } return isConvex; } isInternal(point) { let c = false; this.vertices.cycle((v, vn) => { if ( ((v.y > point.y) != (vn.y > point.y)) && (point.x < (vn.x - v.x) * (point.y-v.y) / (vn.y-v.y) + v.x) ) { c = !c; } }); return c; } // return all points inside of the polygon filterInternal(points) { const bbox = this.boundingBox(); let tests = points .filter(p => FastIntersect.boundingBoxAndPoint(bbox, p)) .map(p => ({ p, c: false })); if (tests.length === 0) return tests; this.vertices.cycle((v, vn) => { for (let i = 0; i < tests.length; i++) { const p = tests[i].p; if ( ((v.y > p.y) != (vn.y > p.y)) && (p.x < (vn.x - v.x) * (p.y-v.y) / (vn.y-v.y) + v.x) ) { tests[i].c = !tests[i].c; } } }); return tests.filter(t => t.c).map(t => t.p); } triangulate() { if (this.vertices.length < 4) return Object.assign({}, this); if (this.cache) { const triangles = this.cache.get('triangels'); if (triangles) return triangles; } const triangles = []; const stack = [...this.vertices]; if (this.isConvex()) { // simple fan const p0 = stack.pop(); let p1 = stack.pop(); while(stack.length > 0) { const p2 = stack.pop(); triangles.push(new Polygon([p0, p1, p2])); p1 = p2; } } else { // ear cutting if (this.orientation() === Types.CLOCKWISE) { stack.reverse(); } while(stack.length > 3) { const ear = Polygon.findEar(stack); if (!ear) break; stack.splice(ear.index, 1); triangles.push(ear.triangle); } triangles.push(new Polygon(stack)); } if (this.cache) { this.cache.set('triangles', triangles); } return triangles; } // remove redundant vertices clean(mutate = false) { if (this.vertices.length <= 3) return mutate ? this : this.clone(); const verts = [...this.vertices]; let i = 1; let p = 0; let n = 2; while (i < verts.length) { if (n === verts.length) n = 0; const v1 = new Vector(verts[p], verts[i]); const v2 = new Vector(verts[i], verts[n]); if (Util.approxZero(v1.cross(v2))) { verts.splice(i, 1); } else { p = i++; n = i + 1; } } if (mutate) { this.vertices = verts; return this; } return new Polygon(verts); } boundingBox() {0 if (this.cache) { const bbox = this.cache.get('bbox'); if (bbox) return bbox; } const bbox = this.vertices.reduce((box, p) => { if (p.x < box.x1 || box.x1 === null) box.x1 = p.x; if (p.x > box.x2 || box.x2 === null) box.x2 = p.x; if (p.y < box.y1 || box.y1 === null) box.y1 = p.y; if (p.y > box.y2 || box.y2 === null) box.y2 = p.y; return box; }, { x1: null, y1: null, x2: null, y2: null }); if (this.cache) { this.cache.set('bbox', bbox); } return bbox; } translate(dx, dy, mutate = false) { if (mutate) { this.vertices.forEach(v => v.translate(dx, dy, true)); return this; } return new Polygon(this.vertices.map(v => v.translate(dx, dy))); } rotate(angle, anchor, mutate = false) { const por = anchor || this.centeroid(); if (mutate) { this.vertices.forEach(v => v.rotate(angle, por, true)); return this; } return new Polygon(this.vertices.map(v => v.rotate(angle, por))); } mirror(axisLine, mutate = false) { const mirrored = this.vertices.map(v => { const pv = new Vector(axisLine.point, v); const proj = pv.projectOnto(axisLine.vector, false); const mv = proj.sub(pv); return new Point(v.x + 2 * mv.x, v.y + 2 * mv.y); }); if (mutate) { this.vertices = mirrored; return this; } return new Polygon(mirrored); } scale(factor, mutate = false) { const center = this.centeroid(); const scaled = this.vertices.map(v => { const sv = new Vector(center, v).scale(factor); return new Point(center.x + sv.x, center.y + sv.y); }); if (mutate) { this.vertices = scaled; return this; } return new Polygon(scaled); } position(at, options = {}, mutate = false) { const { edge: edgeIndex, my, it, offset } = Object.assign({ edgeIndex: 0, it: Types.CENTER, my: undefined, offset: 0, },( options || {})); const alignment = { [Types.LEFT]: 0, [Types.CENTER]: 0.5, [Types.RIGHT]: 1, } const itr = Util.cycleIterator(this.vertices.length); const edge = new LineSegment( this.vertices[edgeIndex], this.vertices[itr.nextFrom(edgeIndex)], ); const vEdge = edge.toVector(); const vAt = at.toVector(); const vMove = new Vector(this.vertices[edgeIndex], at.p1); const angle = Vector.angle(vEdge, vAt); const vIt = vAt.scale(alignment[it]); const vMy = vAt.unit().scale(vEdge.length() * alignment[my === undefined ? it : my]); const vOffset = vAt.normal().scale(offset); const transformed = this .translate(vMove.x, vMove.y, mutate) .rotate(angle, at.p1, mutate) .translate(vIt.x - vMy.x, vIt.y - vMy.y, mutate) .translate(vOffset.x, vOffset.y, mutate); return transformed; } centerAt(point, mutate = false) { const cp = this.centeroid(); if (!cp) return this; const v = new Vector(cp, point); return this.translate(v.x, v.y, mutate); } }3a:T2ce6,/* * If intersection detected, returns the shape(s) of the intersection, * otherwise returns false * Circles and ellipses should be converted to polygons for intersection * testing if no specific method is defined here. */ class Intersect { static vectors(p1, v1, p2, v2) { const c = v1.cross(v2); if (c === 0) return false; const t = new Vector(p1, p2).cross(v2) / c; return new Point(p1.x + t * v1.x, p1.y + t * v1.y); } // Two lines static lines(a, b) { if (a.m === b.m) { // same slope if (a.b === b.b) { // same line return a; } return false; // no intersection } const x = (b.b - a.b) / (a.m - b.m); const y = a.m * x + a.b; return new Point(x, y); } static lines2(a, b) { return Intersect.vectors(a.point, a.vector, b.point, b.vector); } // Two line segments static segments(s1, s2) { if (!FastIntersect.boundingBoxes( s1.boundingBox(), s2.boundingBox(), )) { return false; } const p = s1.p1; const q = s2.p1; const r = s1.toVector(); const s = s2.toVector(); const pq = new Vector(p, q); // q - p const r_x_s = r.cross(s); const pq_x_r = pq.cross(r); if (r_x_s === 0) { if (pq_x_r !== 0) return false; // parallell and not overlapping if (pq_x_r === 0) { // segments are collinear, check for overlap // t0 = (q − p) · r / (r · r) // t1 = (q + s − p) · r / (r · r) = t0 + s · r / (r · r) const rr = r.dot(r); const sr = s.dot(r); let t0 = pq.dot(r) / rr; let t1 = t0 + sr / rr; if (sr < 0) { const tmp = t1; t1 = t0; t0 = tmp; } if (t1 >= 0 && t0 <= 1) { t0 = Math.max(0, t0); t1 = Math.min(1, t1); return new LineSegment( new Point(p.x + t0 * r.x, p.y + t0 * r.y), new Point(p.x + t1 * r.x, p.y + t1 * r.y), ); } return false; } } // t = (q − p) × s / (r × s) // u = (q − p) × r / (r × s) const pq_x_s = pq.cross(s); const t = pq_x_s / r_x_s; const u = pq_x_r / r_x_s; if (t >= 0 && t <= 1 && u >= 0 && u <= 1) { return new Point(p.x + t * r.x, p.y + t * r.y); } return false; } // test two sets of segments static segmentSets(setA, setB) { const ips = []; for (let i = 0; i < setA.length; i++) { for (let j = 0; j < setB.length; j++) { if (FastIntersect.boundingBoxes(setA[i].boundingBox(), setB[j].boundingBox())) { const ip = Intersect.segments(setA[i], setB[j]); if (ip && ip instanceof Point) { ips.push(ip); } } } } return ips; } static lineAndSegment(seg, line) { if (seg.isVertical()) { const y = line.y(seg.x1); if (y <= Math.max(seg.y1, seg.y2) && y >= Math.min(seg.y1, seg.y2)) { return new Point(seg.x1, y); } } else { const l = seg.toLine(); const ip = Intersect.lines(l, line); if (ip instanceof Point) { if (FastIntersect.segmentAndPoint(seg, ip)) { return ip; } } else if (ip instanceof Line) { return seg; } } return false; } static circleAndLine(circle, line, skipBBoxTest = false) { if (!skipBBoxTest && !FastIntersect.circleAndLine(circle, line)) { return false; } const r = circle.radius; const cx = circle.center.x; const cy = circle.center.y; const lm = line.m; const lb = line.b; const a = lm ** 2 + 1; const b = 2 * (lm * lb - lm * cy - cx); const c = cy ** 2 - r ** 2 + cx ** 2 - 2 * lb * cy + lb ** 2; const quad = Polynomials.quadratic(a, b, c); if (quad.discriminant >= 0) { const roots = quad.roots(); if (Util.approxZero(roots[0] - roots[1])) { return new Point(roots[0], line.y(roots[0])); } else { return new LineSegment( new Point(roots[0], line.y(roots[0])), new Point(roots[1], line.y(roots[1])), ); } } return false; } static circleAndSegment(circle, segment, skipBBoxTest = false) { if (!skipBBoxTest && !FastIntersect.boundingBoxes(circle.boundingBox(), segment.boundingBox())) { return false; } const s = segment.normalizeOrientation(); const v = s.toVector(); const u = new Vector(circle.center, s.p1); // coefficients const a = v.dot(v) ; const b = 2 * u.dot(v); const c = u.dot(u) - (circle.radius ** 2); const quad = Polynomials.quadratic(a, b, c); if (quad.discriminant >= 0) { const [t1, t2] = quad.roots(); if ((t1 > 1 && t2 > 1) || (t1 < 0 && t2 < 0)) { return false; } // segment is completely inside if (t1 < 0 && t2 > 1) { return s; } // p2 of s is inside if (t2 > 1) { return new LineSegment( s.p1.translateByVector(v, t1), s.p2, ); } // p1 of s is inside if (t1 < 0) { return new LineSegment( s.p1, s.p1.translateByVector(v, t2), ); } // segment is a tangent to the circle if t2 - t1 ~ 0 if (Util.approxZero(t2 - t1)) { return s.p1.translateByVector(v, t1); } return new LineSegment( s.p1.translateByVector(v, t1), s.p1.translateByVector(v, t2), ); } } // alternative 1: use ellipse and line formula static ellipseAndLine(ellipse, line, skipBBoxTest = false) { if (!skipBBoxTest && !FastIntersect.boundingBoxAndLine(ellipse.boundingBox(), line)) { return false; } const aa = ellipse.radiusX ** 2; const bb = ellipse.radiusY ** 2; const cx = ellipse.center.x; const cy = ellipse.center.y; const cxx = cx ** 2; const cyy = cy ** 2; const lm = line.m; const lb = line.b; const lmm = lm ** 2; const lbb = lb ** 2; const a = bb + aa * lmm; const b = (-2 * bb * cx) + (2 * aa * lm * lb) + (-2 * aa * lm * cy); const c = (bb * cxx) + (aa * cyy) - (aa * bb) + (aa * lbb) + (-2 * aa * lb * cy); const quad = Polynomials.quadratic(a, b, c); if (quad.discriminant >= 0) { const roots = quad.roots(); if (Util.approxZero(roots[0] - roots[1])) { return new Point(roots[0], line.y(roots[0])); } else { return new LineSegment( new Point(roots[0], line.y(roots[0])), new Point(roots[1], line.y(roots[1])), ); } } return false; } // alternative 2: scale ellipse to a circle and use circle and line intersection static ellipseAndLine2(ellipse, line, skipBBoxTest = false) { if (!skipBBoxTest && !FastIntersect.boundingBoxAndLine(ellipse.boundingBox(), line)) { return false; } const scaleX = ellipse.radiusY / ellipse.radiusX; const [p1, p2] = line.points(0, 1).map(p => new Point(p.x * scaleX, p.y)); const tl = Line.fromPoints(p1, p2); const circle = { center: new Point(ellipse.center.x * scaleX, ellipse.center.y), radius: ellipse.radiusY, }; const il = Intersect.circleAndLine(circle, tl, true); if (il) { if (il instanceof Point) { return new Point(il.x / scaleX, il.y); } else { return new LineSegment( new Point(il.x1 / scaleX, il.y1), new Point(il.x2 / scaleX, il.y2), ); } } return false; } static ellipseAndSegment(ellipse, segment, skipBBoxTest = false) { if (!skipBBoxTest && !FastIntersect.boundingBoxes(ellipse.boundingBox(), segment.boundingBox())) { return false; } const scaleX = ellipse.radiusY / ellipse.radiusX; const tls = new LineSegment( new Point(segment.x1 * scaleX, segment.y1), new Point(segment.x2 * scaleX, segment.y2), ); const circle = { center: new Point(ellipse.center.x * scaleX, ellipse.center.y), radius: ellipse.radiusY, }; const il = Intersect.circleAndSegment(circle, tls, true); if (il) { if (il instanceof Point) { return new Point(il.x / scaleX, il.y); } else { return new LineSegment( new Point(il.x1 / scaleX, il.y1), new Point(il.x2 / scaleX, il.y2), ); } } return false; } static polygonAndLine(polygon, line) { const bbox = polygon.boundingBox(); if (!FastIntersect.boundingBoxAndLine(bbox, line)) return false; // convert line to segment const seg = new LineSegment(...line.points(bbox.x1 - 1, bbox.x2 + 1)); return Intersect.polygonAndSegment(polygon, seg, true); } static polygonAndSegment(polygon, segment, skipBBoxTest = false) { if (!skipBBoxTest && !FastIntersect.boundingBoxes( polygon.boundingBox(), segment.boundingBox(), )) { return false; } const ips = [ ...Intersect.segmentSets([segment], polygon.edges()), ...polygon.filterInternal([segment.p1, segment.p2]), ]; if (ips.length === 0) return false; if (ips.length % 2 !== 0) { debugger; return undefined; } const ordered = ips.sort((a, b) => { const dx = a.x - b.x; if (dx === 0) { return a.y - b.y; } return dx; }); const segments = []; for (let i = 0; i < ips.length - 1; i+=2) { segments.push(new LineSegment(ips[i], ips[i + 1])); } return segments; } // return all intersecting points between two polygons static intersectPolygons(a, b) { if (!FastIntersect.boundingBoxes( a.boundingBox(), b.boundingBox(), )) { return false; } const intersects = Intersect.segmentSets(a.edges(), b.edges()); const pointsInA = a.filterInternal(b.vertices); const pointsInB = b.filterInternal(a.vertices); const ips = [ ...intersects, ...pointsInA, ...pointsInB, ]; return ips.length > 0 ? ips : false; } // return polygon(s) representing intersections static polygons(a, b) { const intersects = []; const aIsConvex = a.isConvex(); const bIsConvex = b.isConvex(); if (aIsConvex && bIsConvex) { const verts = Intersect.intersectPolygons(a, b); if (verts) intersects.push(new Polygon(Point.order(verts), false)); } else if (aIsConvex) { const tb = b.triangulate(); for (let i = 0; i < tb.length; i++) { const verts = Intersect.intersectPolygons(a, tb[i]); if (verts) intersects.push(new Polygon(Point.order(verts), false)); } } else if (bIsConvex) { const ta = a.triangulate(); for (let i = 0; i < ta.length; i++) { const verts = Intersect.intersectPolygons(b, ta[i]); if (verts) intersects.push(new Polygon(Point.order(verts), false)); } } else { const ta = a.triangulate(); const tb = b.triangulate(); for (let i = 0; i < ta.length; i++) { for (let j = 0; j < tb.length; j++) { const verts = Intersect.intersectPolygons(ta[i], tb[j]); if (verts) intersects.push(new Polygon(Point.order(verts), false)); } } } return Polygon.merge(intersects).map(p => p.clean(true)); } }3b:T180f,/* * Minimum required effort to detect intersection. * returns either true if intersection detected, otherwise false */ class FastIntersect { // Line and point static pointAndLine(p, l) { return (l.y(p.x) === p.y); } // check if point p is above, on or below line defined by q and r // 0 => point is on line, > 0 => above line, < 0 => below line static pointRelationToLine(p, q, r) { return new Vector(q, r).cross(new Vector(q, p)); } // Line segment and point static segmentAndPoint(seg, p) { const { p1: a, p2: b } = seg; if (a.x == b.x && a.y == b.y) return false; const v1 = new Vector(a, b); const v2 = new Vector(a, p); const cp = v1.cross(v2); if (cp > Const.EPS) return false; const ab = v1.dot(v1); const ap = v1.dot(v2); return ap === 0 || ap === ab || (ap > 0 && ap < ab); } // bounding box intersection test static boundingBoxes(a, b) { return ( a.x2 > b.x1 && a.x1 < b.x2 && a.y2 > b.y1 && a.y1 < b.y2 ); } // test if a point is inside a bounding box static boundingBoxAndPoint(box, p) { return ( p.x >= box.x1 && p.x <= box.x2 && p.y >= box.y1 && p.y <= box.y2 ); } // test if line intersects bounding box static boundingBoxAndLine(box, line) { const testY = y => y >= box.y1 && y <= box.y2; const testX = x => x >= box.x1 && x <= box.x2; // slope is 0, test y intersect of line if (line.m === 0) return testY(line.b); if (testY(line.y(box.x1)) || testY(line.y(box.x2))) return true; if (testX(line.x(box.y1)) || testX(line.x(box.y2))) return true; return false; } static boundingBoxAndSegment(box, segment) { if (!FastIntersect.boundingBoxes(segment.boundingBox(), box)) return false; const bl = { x: box.x1, y: box.y2 }; const br = { x: box.x2, y: box.y2 }; const tr = { x: box.x2, y: box.y1 }; const tl = { x: box.x1, y: box.y1 }; const p1 = segment.p1; const p2 = segment.p2; const tests = [ () => FastIntersect.pointRelationToLine(bl, p1, p2), () => FastIntersect.pointRelationToLine(br, p1, p2), () => FastIntersect.pointRelationToLine(tr, p1, p2), () => FastIntersect.pointRelationToLine(tl, p1, p2), ]; if (Util.equallySigned(tests)) return false; return true; } static circles(a, b) { const v = new Vector(a.center, b.center); return v.length() < a.radius + b.radius; } static circleAndLine(circle, line) { const bbox = circle.boundingBox(); // convert line to segment const seg = new LineSegment(...line.points(bbox.x1 - 1, bbox.x2 + 1)); return FastIntersect.circleAndSegment(circle, seg); } static circleAndSegment(circle, segment) { const v = segment.toVector(); const u = new Vector(segment.p1, circle.center); const s = u.projectOnto(v); const l = u.sub(s).length(); return l < circle.radius; } static ellipses(a, b, depth = 3) { if (FastIntersect.boundingBoxes(a.boundingBox(), b.boundingBox())) { const pa = a.inscribe(depth); const pb = b.inscribe(depth); return FastIntersect.polygons(pa, pb, true); } return false; } static ellipseAndSegment(ellipse, segment) { const scaleX = ellipse.radiusY / ellipse.radiusX; const tls = new LineSegment( new Point(segment.x1 * scaleX, segment.y1), new Point(segment.x2 * scaleX, segment.y2), ); const circle = { center: new Point(ellipse.center.x * scaleX, ellipse.center.y), radius: ellipse.radiusY, }; return FastIntersect.circleAndSegment(circle, tls); } static ellipseAndLine(ellipse, line) { const bbox = ellipse.boundingBox(); // convert line to segment const seg = new LineSegment(...line.points(bbox.x1 - 1, bbox.x2 + 1)); return FastIntersect.ellipseAndSegment(ellipse, seg); } // test if two line segments, represented by pairs of points, intersects (true/false) static edges(a, b, p, q) { return ( Point.orientation(a, b, p) !== Point.orientation(a, b, q) && Point.orientation(q, p, b) !== Point.orientation(q, p, a) ); } static segments(s1, s2, skipBBoxTest = false) { if (!skipBBoxTest && !FastIntersect.boundingBoxes(s1.boundingBox(), s2.boundingBox())) { return false; } return FastIntersect.edges(s1.p1, s1.p2, s2.p1, s2.p2); } static segmentSets(setA, setB) { for (let i = 0; i < setA.length; i++) { for (let j = 0; j < setB.length; j++) { const test = FastIntersect.segments(setA[i], setB[j]); if (test) { return true; } } } return false; } static circleAndSegmentSet(circle, set) { for (let i = 0; i < set.length; i++) { const test = FastIntersect.circleAndSegment(circle, set[i]); if (test) { return true; } } return false; } static polygonAndLine(polygon, line) { const bbox = polygon.boundingBox(); if (!FastIntersect.boundingBoxAndLine(bbox, line)) return false; // convert line to segment const seg = new LineSegment(...line.points(bbox.x1 - 1, bbox.x2 + 1)); return (FastIntersect.segmentSets(polygon.edges(),[seg])); } static polygonAndCircle(polygon, circle) { if (!FastIntersect.boundingBoxes( polygon.boundingBox(), circle.boundingBox(), )) { return false; } if (polygon.isInternal(circle.center)) { return true; } return FastIntersect.circleAndSegmentSet(circle, polygon.edges()); } static polygons(a, b, skipBBoxTest = false) { if (!skipBBoxTest && !FastIntersect.boundingBoxes( a.boundingBox(), b.boundingBox(), )) { return false; } if (FastIntersect.segmentSets(a.edges(), b.edges())) return true; // check if a is completely inside b or b is completely inside a if (b.isInternal(a.vertices[0])) return true; if (a.isInternal(b.vertices[0])) return true; return false; } }3c:T8fa,class Util { static isNumeric(n) { const isit = (!Number.isNaN(parseFloat(n)) && isFinite(n)); return isit; } // Check if obj is an object with x and y properties static isPointLike(obj) { const isit = (Util.isNumeric(obj.x) && Util.isNumeric(obj.y)); // console.log('point check', isit, obj); return isit; } static approxTo(v, to, eps = Const.EPS) { return (Math.abs(v - to) < eps); } static approxZero(v, eps = Const.EPS) { return (Math.abs(v) < eps); } static cycleIterator(length) { return ({ nextFrom: j => (j + 1) % length, prevFrom: j => j <= 0 ? length - 1 + (j % length) : j - 1, }); } static toDecimals(value, decimals) { const factor = 10 ** decimals; return Math.round(value * factor) / factor; } static equallySigned(tests) { const t1 = tests[0]; const f = typeof t1 === 'function'; const first = (f ? t1() : t1) < 0; for (let i = 1; i < tests.length; i++) { if ((f ? tests[i]() : tests[i]) < 0 !== first) return false; } return true; } static allTrue(tests) { const t1 = tests[0]; const f = typeof t1 === 'function'; for (let i = 0; i < tests.length; i++) { if ((f ? tests[i]() : tests[i]) !== true) return false; } return true; } static allFalse(tests) { const t1 = tests[0]; const f = typeof t1 === 'function'; for (let i = 0; i < tests.length; i++) { if ((f ? tests[i]() : tests[i]) !== false) return false; } return true; } static anyTrue(tests) { const t1 = tests[0]; const f = typeof t1 === 'function'; for (let i = 0; i < tests.length; i++) { if ((f ? tests[i]() : tests[i]) === true) return true; } return false; } static anyFalse(tests) { const t1 = tests[0]; const f = typeof t1 === 'function'; for (let i = 0; i < tests.length; i++) { if ((f ? tests[i]() : tests[i]) === false) return true; } return false; } static allSame(tests) { const t1 = tests[0]; const f = typeof t1 === 'function'; const first = f ? t1() : t1; for (let i = 1; i < tests.length; i++) { if ((f ? tests[i]() : tests[i]) !== first) return false; } return true; } }3d:T899,{ const p = plotter(); yield p.node; p.polyline(points, { stroke: 'red', interactive: true, onChange: v => { mutable points = v; }, }); const join = +l_join; const cap = +l_cap; const halfWidth = thickness / 2; const lverts = []; const rverts = []; let prev = null; points.forEach((pt, i) => { const np = i < points.length - 1 ? points[i + 1] : null; if (np) { const v = new Vector(pt, np); const n = v.normal(); const p1 = pt.translateByVector(n, halfWidth); const p2 = pt.translateByVector(n, -halfWidth); const l1 = new Line(v, p1); const l2 = new Line(v, p2); if (prev) { const p3 = Intersect.lines2(prev.l1, l1); const p4 = Intersect.lines2(prev.l2, l2); if (join === Types.JOIN_BEVEL) { const a = Vector.angle(v.invert(), prev.v); console.log(i, a) if (a.value < 0) { lverts.push(pt.translateByVector(prev.n, halfWidth), p1); rverts.push(p4); } else { lverts.push(p3); rverts.push(pt.translateByVector(prev.n, -halfWidth), p2); } } else { lverts.push(p3); rverts.push(p4); } } else { if (cap === Types.CAP_PROJECTED) { const vu = v.unit(); lverts.push(p1.translateByVector(vu, -halfWidth)); rverts.push(p2.translateByVector(vu, -halfWidth)); } else { lverts.push(p1); rverts.push(p2); } } prev = { n, v, l1, l2 }; } else { const { n, v } = prev; const p1 = pt.translateByVector(n, halfWidth); const p2 = pt.translateByVector(n, -halfWidth); if (cap === Types.CAP_PROJECTED) { const vu = v.unit(); lverts.push(p1.translateByVector(vu, halfWidth)); rverts.push(p2.translateByVector(vu, halfWidth)); } else { lverts.push(p1); rverts.push(p2); } } }); const polygon = new Polygon(lverts.concat(rverts.reverse())); p.polygon(polygon.vertices, { fill: 'green' }); }3e:T41a,{ // create a copy of polly positioned along S const tp = polly.position(S, { edge, it: +align_it, my: align_my === '' ? undefined : +align_my, offset: +offset, }); // mirror the positioned polygon along S const mp = tp.mirror(S.toLine()); // plot it const p = plotter({ transitions: false }); yield p.node; p.polygon(polly.vertices, { fill: 'orange', interactive: true, onChange: v => { mutable polly = new Polygon(v.map(d => ({x: d.x, y: d.y}))); } }); p.segment(S.p1.x, S.p1.y, S.p2.x, S.p2.y, { interactive: true, stroke: 'purple', width: 3, onChange: v => { mutable S = new LineSegment(new Point(v.x1, v.y1), new Point(v.x2, v.y2)); }, }); const v1 = polly.vertices[edge]; const v2 = polly.vertices[edge + 1 < polly.vertices.length ? edge + 1 : 0]; p.segment(v1.x, v1.y, v2.x, v2.y, { stroke: 'indigo', width: 3 }); p.polygon(tp.vertices, { fill: '#ccc', }); p.polygon(mp.vertices, { fill: '#999', }); }3f:T581,{ const p = plotter({ transitions: false }); yield p.node; p.polygon(polyA.vertices, { fill: 'green', interactive: true, onChange: v => { mutable polyA = new Polygon(v); }, }); p.polygon(polyB.vertices, { fill: 'blue', interactive: true, onChange: v => { mutable polyB = new Polygon(v); }, }); const b1 = polyA.boundingBox(); const b2 = polyB.boundingBox(); p.rectangle(b1.x1, b1.y2, b1.x2, b1.y1, { stroke: 'green', dash: '2,2' }); p.rectangle(b2.x1, b2.y2, b2.x2, b2.y1, { stroke: 'blue', dash: '2,2' }); const fastintersect = FastIntersect.polygons(polyA, polyB); if (fastintersect) { const ips = Intersect.intersectPolygons(polyA, polyB); if (ips) { ips.map(ip => p.point(ip.x, ip.y, { color: 'red' })); } const ipollies = Intersect.polygons(polyA, polyB); // console.log(ipollies); if (ipollies) { ipollies.map(ip => p.polygon(ip.vertices, { fill: 'red' , stroke: 'red', interactive: true })); const area = ipollies.reduce((area, pol) => area + pol.area(), 0); p.text('Inters. area: ' + Util.toDecimals(area, 1), -3, -8, { anchor: 'end' }); p.text('% of green: ' + Util.toDecimals(area / polyA.area() * 100, 1), -3, -9, { anchor: 'end' }); p.text('% of blue: ' + Util.toDecimals(area / polyB.area() * 100, 1), -3, -10, { anchor: 'end' }); } } }40:Te42,{ const pointTan1 = C1.tangentsFromPoint(C2.center); const pointTan2 = C2.tangentsFromPoint(C1.center); const extTan = C2.exteriorTangents(C1); const intTan = C2.interiorTangents(C1); const p3 = C1.escribe(idepth); const p4 = C2.inscribe(idepth); // plot it const p = plotter(); yield p.node; p.circle(C1.center.x, C1.center.y, C1.radius, { stroke: 'green', fill: 'green', interactive: true, onChange: v => { mutable C1 = new Circle(new Point(v.cx, v.cy), v.r); }, }); p.circle(C2.center.x, C2.center.y, C2.radius, { stroke: 'purple', fill: 'purple', interactive: true, onChange: v => { mutable C2 = new Circle(new Point(v.cx, v.cy), v.r); }, }); p.polygon(p3.vertices, { stroke: 'green', interactive: false }); p.polygon(p4.vertices, { stroke: 'purple', interactive: false }); if (pointTan1) { pointTan1.map(t => { p.segment(C2.center.x, C2.center.y, t.x, t.y, { stroke: 'green', dash: '2,2' }); }); } if (pointTan2) { pointTan2.map(t => { p.segment(C1.center.x, C1.center.y, t.x, t.y, { stroke: 'purple', dash: '2,2' }); }); } extTan && extTan.map(t => { p.segment(t.x1, t.y1, t.x2, t.y2, { stroke: 'red' }); }); intTan && intTan.map(t => { p.segment(t.x1, t.y1, t.x2, t.y2, { stroke: '#777' }); }); /* p.ellipse(E1.center.x, E1.center.y, E1.radiusX, E1.radiusY, { stroke: 'red', fill: 'red', interactive: true, onChange: v => { mutable E1 = new Ellipse(new Point(v.cx, v.cy), v.rx, v.ry); }, }); p.ellipse(E2.center.x, E2.center.y, E2.radiusX, E2.radiusY, { stroke: 'blue', fill: 'blue', interactive: true, onChange: v => { mutable E2 = new Ellipse(new Point(v.cx, v.cy), v.rx, v.ry); }, }); p.line(L.m, L.b, { stroke: 'black' }); const bbox1 = E1.boundingBox(); p.rectangle(bbox1.x1, bbox1.y2, bbox1.x2, bbox1.y1, { dash: '3,3', stroke: 'red'}); const bbox2 = E2.boundingBox(); p.rectangle(bbox2.x1, bbox2.y2, bbox2.x2, bbox2.y1, { dash: '3,3', stroke: 'blue'}); const p1 = E1.escribe(idepth); p.polygon(p1.vertices, { stroke: 'red', interactive: false }); const p2 = E2.inscribe(idepth); p.polygon(p2.vertices, { stroke: 'blue', interactive: false }); //p.line(L.m, L.b, { stroke: 'black' }); if (FastIntersect.ellipses(E1, E2, idepth)) { p.text('Ellipses intersects', -9, -9, { anchor: 'start' }); }; p.segment(LS.x1, LS.y1, LS.x2, LS.y2, { interactive: true, onChange: v => { mutable LS = new LineSegment(new Point(v.x1, v.y1), new Point(v.x2, v.y2)); }, }); const ils = Intersect.ellipseAndSegment(E2, LS); if (ils) { if (ils instanceof Point) { p.point(ils.x, ils.y, { stroke: 'red' }); } else { p.segment(ils.x1, ils.y1, ils.x2, ils.y2, { stroke: 'red' }); } } const il = Intersect.ellipseAndLine(E2, L); if (il) { if (il instanceof Point) { p.point(il.x, il.y, { stroke: 'red' }); } else { p.segment(il.x1, il.y1, il.x2, il.y2, { stroke: 'red' }); } } const icl1 = Intersect.circleAndLine(C1, L); if (icl1) { if (icl1 instanceof Point) { p.point(icl1.x, icl1.y, { stroke: 'red' }); } else { p.segment(icl1.x1, icl1.y1, icl1.x2, icl1.y2, { stroke: 'red' }); } } const icl2 = Intersect.circleAndLine(C2, L); if (icl2) { if (icl2 && icl2 instanceof Point) { p.point(icl2.x, icl2.y, { stroke: 'red' }); } else { p.segment(icl2.x1, icl2.y1, icl2.x2, icl2.y2, { stroke: 'red' }); } } */ }41:T47e,{ const p = plotter(); yield p.node; p.ellipse(el.center.x, el.center.y, el.radiusX, el.radiusY, { stroke: 'gray', interactive: true, width: 4, onChange: v => { mutable el = new Ellipse(new Point(v.cx, v.cy), v.rx, v.ry); }, }); const circle = new Circle(new Point(el.center.x, el.center.y), Math.min(el.radiusX, el.radiusY)); p.circle(circle.center.x, circle.center.y, circle.radius); p.segment(el.center.x, el.center.y, pt.x, pt.y, { dash: '2,2' }); p.point(el.center.x, el.center.y, { color: 'darkorange' }); p.point(pt.x, pt.y, { size: 12, color: 'white', interactive: true, onChange: v => { mutable pt = new Point(v.x, v.y); }, }); const v = new Vector(el.center, pt); //console.log(v.angle().value, Angle.SPI); const cp = circle.pointAtAngle(v.angle()); p.point(cp.x, cp.y, { size: 4, color: 'blue' }); const ep = el.pointAtAngle(v.angle().positiveValue); p.point(ep.x, ep.y, { size: 6, color: 'red' }); const distance = Point.distance(ep, pt); p.text(Math.round(distance * 10) / 10, -9, -9, { anchor: 'start' }); }42:[] 2f:{"id":"189c2fd0983e4fad","slug":"prototyping-a-math-library","title":"Prototyping a math library","thumbnail":"70bf0feb91d3a242602aa28bb9dcdb27d31119e178fb857c21b34cb9762a2df5","access_level":"public","create_time":"$D2018-09-18T12:18:35.157Z","update_time":"$D2025-03-26T10:26:59.082Z","view_time":null,"first_public_time":"$D2018-10-06T12:37:56.756Z","fork":false,"stars":5,"starred":false,"owner":{"type":"team","id":"455184b0afc7f1fd","login":"kjerandp","name":"Kjerand Pedersen","avatar_url":"https://avatars-next.observableusercontent.com/3c52e0775a9b4937e6002e09ca22d564189c0d589cae2166e091b5fe3b7f2458","tier":"starter_2024"},"version":6456,"publish_version":null,"role":null,"authored":false,"authors":[{"type":"individual","id":"00080969d76f924b","login":"kjerandp","name":"Kjerand Pedersen","avatar_url":"https://avatars-next.observableusercontent.com/3c52e0775a9b4937e6002e09ca22d564189c0d589cae2166e091b5fe3b7f2458","tier":null}],"members":[{"type":"individual","id":"00080969d76f924b","login":"kjerandp","name":"Kjerand Pedersen","avatar_url":"https://avatars-next.observableusercontent.com/3c52e0775a9b4937e6002e09ca22d564189c0d589cae2166e091b5fe3b7f2458","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"subscribed":null,"forks":1,"collection":null,"type":"notebook","body":{"title":"Prototyping a math library","cells":[{"id":0,"value":"md`# Prototyping a math library\nThis is intended to become a math utillity lib. The idea is to prototype in ObservableHQ, then move it into a regular node project and publish it as a npm package. \n\n** UPDATE: ** This notebook has served its purpose and continued work on this project will be done here: https://github.com/kjerandp/math-utils-2d\n\nDocs and examples etc. to come!\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":42,"value":"md`## Lib definitions`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":4,"value":"$31","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":5700,"value":"class Range {\n constructor(from, to) {\n this.from = from;\n this.to = to;\n }\n \n get value() {\n return [this.from, this.to];\n }\n \n set value([from, to]) {\n this.from = from;\n this.to = to;\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":30,"value":"$32","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1627,"value":"$33","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":5535,"value":"$34","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1543,"value":"$35","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":12,"value":"$36","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3488,"value":"$37","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1546,"value":"$38","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":66,"value":"$39","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1638,"value":"$3a","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3864,"value":"$3b","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":4633,"value":"class Polynomials {\n static quadratic(a, b, c) {\n const dis = b ** 2 - 4 * a * c;\n \n return ({\n discriminant: dis,\n roots: () => {\n if (dis < 0) return null; \n const detSqrt = Math.sqrt(dis);\n const a2 = 2 * a;\n const r1 = (-b - detSqrt) / a2;\n const r2 = (-b + detSqrt) / a2;\n \n return [r1, r2];\n },\n });\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":536,"value":"$3c","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3650,"value":"Types = ({\n COLLINEAR: 0,\n CLOCKWISE: 1,\n COUNTERCLOCKWISE: -1,\n LEFT: -1,\n CENTER: 0,\n RIGHT: 1,\n CAP_BUTT: 1,\n CAP_PROJECTED: 2,\n JOIN_MITER: 1,\n JOIN_BEVEL: 2,\n})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":855,"value":"Const = ({\n EPS: 2 ** -37,\n})","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":5044,"value":"md`#### Cache\nSimple cache implementation to allow caching of certain instance operations. Currently implemented in polygon class.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":5008,"value":"class Cache {\n constructor(getValidityToken = () => true) {\n this.cache = new Map();\n \n // a function that should return a value, which can be used to\n // compare with locally stored validateToken in order to\n // determine if cache is still valid or not\n this.getValidityToken = getValidityToken; \n this.validateToken; \n }\n \n validate() {\n const validateToken = this.getValidityToken();\n if (!this.validateToken || this.validateToken === validateToken) {\n return true; \n }\n this.validateToken = validateToken;\n return false;\n }\n \n updateValidityToken() {\n const validateToken = this.getValidityToken();\n if (this.validateToken && this.validateToken !== validateToken) {\n this.cache.clear(); \n }\n this.validateToken = validateToken;\n }\n \n get(key) {\n if (!this.validate()) return undefined;\n return this.cache.get(key);\n }\n \n set(key, val) {\n this.updateValidityToken();\n this.cache.set(key, val);\n } \n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3229,"value":"md`### Array helpers`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3560,"value":"md`Array.cycle is a convenience wrapper of the map function to make the next and previous element available in the callback function. If i - 1 < 0 then prev will be the last element, If i + 1 > length - 1 then next will be the first element. Useful for \"shoe lace\"-types of operations.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3231,"value":"Array.prototype.cycle = function(cb, reverse = false) {\n if (reverse) {\n return this.map((d, i, arr) => {\n const cur = arr.length - (i + 1);\n const prev = cur + 1 < this.length ? cur + 1 : 0;\n const next = cur - 1 < 0 ? this.length - 1 : cur - 1;\n return cb(this[cur], this[next], this[prev], cur, next, prev, this);\n }); \n }\n return this.map((d, i) => {\n const next = i + 1 < this.length ? i + 1 : 0;\n const prev = i - 1 < 0 ? this.length - 1 : i - 1;\n return cb(d, this[next], this[prev], i, next, prev, this);\n });\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":6219,"value":"md`Set operations`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":6163,"value":"Array.prototype.intersect = function (other, compareFunc) {\n if (compareFunc) {\n return this.filter(v => other.findIndex(ov => compareFunc(v, ov)) !== -1);\n } else {\n return this.filter(v => other.indexOf(v) !== -1);\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":6179,"value":"Array.prototype.union = function (other, compareFunc) {\n if (compareFunc) {\n return [...this, ...other.filter(v => this.findIndex(ov => compareFunc(v, ov)) === -1)];\n } else {\n return [...this, ...other.filter(v => this.indexOf(v) === -1)];\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":6193,"value":"Array.prototype.except = function (other, compareFunc) {\n if (compareFunc) {\n return this.filter(v => other.findIndex(ov => compareFunc(v, ov)) === -1);\n } else {\n return this.filter(v => other.indexOf(v) === -1);\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":2557,"value":"md`# Testing`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3355,"value":"md`## Polygons` ","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":5740,"value":"mutable points = [\n new Point(-7, -8),\n new Point(-8, 1),\n new Point(-4, -2),\n new Point(-1, 4),\n new Point(5, -5),\n new Point(8, 3),\n new Point(4, 6),\n new Point(0, 7.5),\n new Point(-1, 6),\n new Point(-6, 6.2),\n new Point(1, 9.5),\n]","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":5750,"value":"viewof thickness = html``","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":5871,"value":"viewof l_cap = html``","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":5873,"value":"viewof l_join = html``","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":5742,"value":"$3d","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3358,"value":"mutable polly = Polygon.equilateral(sides, size, new Point(-5, 5)) ","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":4084,"value":"mutable S = new LineSegment(new Point(-1, -8), new Point(8, 2))","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":5504,"value":"md`Positioning, alignment and mirroring of polygons (move purple line segment around):`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3362,"value":"$3e","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":5621,"value":"viewof edge = html``","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":5627,"value":"viewof sides = html``","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":5665,"value":"viewof size = html``","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":5655,"value":"viewof offset = html``","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":5647,"value":"viewof align_it = html``","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":5645,"value":"viewof align_my = html``","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":5717,"value":"template = new Polygon([\n new Point(3, 0),\n new Point(-3, 5),\n new Point(5, 3),\n new Point(7, 0),\n new Point(1, -3),\n])","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":354,"value":"mutable polyA = template.centerAt({ x: 3, y: -2 })","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":356,"value":"mutable polyB = template\n .mirror(new Line(Vector.UVY))\n .scale(0.9)\n .rotate(-0.25)\n .centerAt({ x: 4, y: -2 })","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":5668,"value":"md`Intersection test`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":358,"value":"$3f","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3414,"value":"md`## Circle / Ellipse`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":4117,"value":"mutable E1 = new Ellipse(new Point(-5, 5), 2, 4)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":4119,"value":"mutable E2 = new Ellipse(new Point(5, 5), 4, 2)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":4532,"value":"mutable C1 = new Circle(new Point(-5, -5), 4)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":4565,"value":"mutable C2 = new Circle(new Point(5, 5), 2)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":4619,"value":"mutable L = Line.fromStandardForm(0.5, -5)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":4742,"value":"LX = Line.fromStandardForm(-0.5, -5)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":5134,"value":"mutable LS = new LineSegment(new Point(-2, -2), new Point(2, 4))","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":4123,"value":"$40","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":4581,"value":"viewof idepth = html``","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3957,"value":"md`Find point on ellipse given the angle between the center point and another point`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3913,"value":"mutable el = new Ellipse(new Point(0, 0), 6, 3)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3919,"value":"mutable pt = new Point(6, -4)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3916,"value":"$41","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":127,"value":"import { plotter } from '@kjerandp/plotter' ","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"}],"files":"$W42","stdlib":"1","titling":"auto"}} 30:"$2f:body"