@joint/core 4.0.0

package/src/g/ellipse.mjs

@@ -0,0 +1,245 @@
+import { Rect } from './rect.mjs';
+import { Point } from './point.mjs';
+import { types } from './types.mjs';
+
+const {
+    sqrt,
+    round,
+    pow
+} = Math;
+
+export const Ellipse = function(c, a, b) {
+
+    if (!(this instanceof Ellipse)) {
+        return new Ellipse(c, a, b);
+    }
+
+    if (c instanceof Ellipse) {
+        return new Ellipse(new Point(c.x, c.y), c.a, c.b);
+    }
+
+    c = new Point(c);
+    this.x = c.x;
+    this.y = c.y;
+    this.a = a;
+    this.b = b;
+};
+
+Ellipse.fromRect = function(rect) {
+
+    rect = new Rect(rect);
+    return new Ellipse(rect.center(), rect.width / 2, rect.height / 2);
+};
+
+Ellipse.prototype = {
+
+    type: types.Ellipse,
+
+    bbox: function() {
+
+        return new Rect(this.x - this.a, this.y - this.b, 2 * this.a, 2 * this.b);
+    },
+
+    /**
+     * @returns {g.Point}
+     */
+    center: function() {
+
+        return new Point(this.x, this.y);
+    },
+
+    clone: function() {
+
+        return new Ellipse(this);
+    },
+
+    /**
+     * @param {g.Point} p
+     * @returns {boolean}
+     */
+    containsPoint: function(p) {
+
+        return this.normalizedDistance(p) <= 1;
+    },
+
+    equals: function(ellipse) {
+
+        return !!ellipse &&
+            ellipse.x === this.x &&
+            ellipse.y === this.y &&
+            ellipse.a === this.a &&
+            ellipse.b === this.b;
+    },
+
+    // inflate by dx and dy
+    // @param dx {delta_x} representing additional size to x
+    // @param dy {delta_y} representing additional size to y -
+    // dy param is not required -> in that case y is sized by dx
+    inflate: function(dx, dy) {
+        if (dx === undefined) {
+            dx = 0;
+        }
+
+        if (dy === undefined) {
+            dy = dx;
+        }
+
+        this.a += 2 * dx;
+        this.b += 2 * dy;
+
+        return this;
+    },
+
+    intersectionWithLine: function(line) {
+
+        var intersections = [];
+        var a1 = line.start;
+        var a2 = line.end;
+        var rx = this.a;
+        var ry = this.b;
+        var dir = line.vector();
+        var diff = a1.difference(new Point(this));
+        var mDir = new Point(dir.x / (rx * rx), dir.y / (ry * ry));
+        var mDiff = new Point(diff.x / (rx * rx), diff.y / (ry * ry));
+
+        var a = dir.dot(mDir);
+        var b = dir.dot(mDiff);
+        var c = diff.dot(mDiff) - 1.0;
+        var d = b * b - a * c;
+
+        if (d < 0) {
+            return null;
+        } else if (d > 0) {
+            var root = sqrt(d);
+            var ta = (-b - root) / a;
+            var tb = (-b + root) / a;
+
+            if ((ta < 0 || 1 < ta) && (tb < 0 || 1 < tb)) {
+                // if ((ta < 0 && tb < 0) || (ta > 1 && tb > 1)) outside else inside
+                return null;
+            } else {
+                if (0 <= ta && ta <= 1) intersections.push(a1.lerp(a2, ta));
+                if (0 <= tb && tb <= 1) intersections.push(a1.lerp(a2, tb));
+            }
+        } else {
+            var t = -b / a;
+            if (0 <= t && t <= 1) {
+                intersections.push(a1.lerp(a2, t));
+            } else {
+                // outside
+                return null;
+            }
+        }
+
+        return intersections;
+    },
+
+    // Find point on me where line from my center to
+    // point p intersects my boundary.
+    // @param {number} angle If angle is specified, intersection with rotated ellipse is computed.
+    intersectionWithLineFromCenterToPoint: function(p, angle) {
+
+        p = new Point(p);
+
+        if (angle) p.rotate(new Point(this.x, this.y), angle);
+
+        var dx = p.x - this.x;
+        var dy = p.y - this.y;
+        var result;
+
+        if (dx === 0) {
+            result = this.bbox().pointNearestToPoint(p);
+            if (angle) return result.rotate(new Point(this.x, this.y), -angle);
+            return result;
+        }
+
+        var m = dy / dx;
+        var mSquared = m * m;
+        var aSquared = this.a * this.a;
+        var bSquared = this.b * this.b;
+
+        var x = sqrt(1 / ((1 / aSquared) + (mSquared / bSquared)));
+        x = dx < 0 ? -x : x;
+
+        var y = m * x;
+        result = new Point(this.x + x, this.y + y);
+
+        if (angle) return result.rotate(new Point(this.x, this.y), -angle);
+        return result;
+    },
+
+    /**
+     * @param {g.Point} point
+     * @returns {number} result < 1 - inside ellipse, result == 1 - on ellipse boundary, result > 1 - outside
+     */
+    normalizedDistance: function(point) {
+
+        var x0 = point.x;
+        var y0 = point.y;
+        var a = this.a;
+        var b = this.b;
+        var x = this.x;
+        var y = this.y;
+
+        return ((x0 - x) * (x0 - x)) / (a * a) + ((y0 - y) * (y0 - y)) / (b * b);
+    },
+
+    round: function(precision) {
+
+        let f = 1; // case 0
+        if (precision) {
+            switch (precision) {
+                case 1: f = 10; break;
+                case 2: f = 100; break;
+                case 3: f = 1000; break;
+                default: f = pow(10, precision); break;
+            }
+        }
+
+        this.x = round(this.x * f) / f;
+        this.y = round(this.y * f) / f;
+        this.a = round(this.a * f) / f;
+        this.b = round(this.b * f) / f;
+        return this;
+    },
+
+    /** Compute angle between tangent and x axis
+     * @param {g.Point} p Point of tangency, it has to be on ellipse boundaries.
+     * @returns {number} angle between tangent and x axis
+     */
+    tangentTheta: function(p) {
+
+        var refPointDelta = 30;
+        var x0 = p.x;
+        var y0 = p.y;
+        var a = this.a;
+        var b = this.b;
+        var center = this.bbox().center();
+        var m = center.x;
+        var n = center.y;
+
+        var q1 = x0 > center.x + a / 2;
+        var q3 = x0 < center.x - a / 2;
+
+        var y, x;
+        if (q1 || q3) {
+            y = x0 > center.x ? y0 - refPointDelta : y0 + refPointDelta;
+            x = (a * a / (x0 - m)) - (a * a * (y0 - n) * (y - n)) / (b * b * (x0 - m)) + m;
+
+        } else {
+            x = y0 > center.y ? x0 + refPointDelta : x0 - refPointDelta;
+            y = (b * b / (y0 - n)) - (b * b * (x0 - m) * (x - m)) / (a * a * (y0 - n)) + n;
+        }
+
+        return (new Point(x, y)).theta(p);
+
+    },
+
+    toString: function() {
+
+        return (new Point(this.x, this.y)).toString() + ' ' + this.a + ' ' + this.b;
+    }
+};
+
+// For backwards compatibility:
+export const ellipse = Ellipse;

package/src/g/extend.mjs

@@ -0,0 +1,64 @@
+// Local helper function.
+// Add properties from arguments on top of properties from `obj`.
+// This allows for rudimentary inheritance.
+// - The `obj` argument acts as parent.
+// - This function creates a new object that inherits all `obj` properties and adds/replaces those that are present in arguments.
+// - A high-level example: calling `extend(Vehicle, Car)` would be akin to declaring `class Car extends Vehicle`.
+export function extend(obj) {
+    // In JavaScript, the combination of a constructor function (e.g. `g.Line = function(...) {...}`) and prototype (e.g. `g.Line.prototype = {...}) is akin to a C++ class.
+    // - When inheritance is not necessary, we can leave it at that. (This would be akin to calling extend with only `obj`.)
+    // - But, what if we wanted the `g.Line` quasiclass to inherit from another quasiclass (let's call it `g.GeometryObject`) in JavaScript?
+    // - First, realize that both of those quasiclasses would still have their own separate constructor function.
+    // - So what we are actually saying is that we want the `g.Line` prototype to inherit from `g.GeometryObject` prototype.
+    // - This method provides a way to do exactly that.
+    // - It copies parent prototype's properties, then adds extra ones from child prototype/overrides parent prototype properties with child prototype properties.
+    // - Therefore, to continue with the example above:
+    //   - `g.Line.prototype = extend(g.GeometryObject.prototype, linePrototype)`
+    //   - Where `linePrototype` is a properties object that looks just like `g.Line.prototype` does right now.
+    //   - Then, `g.Line` would allow the programmer to access to all methods currently in `g.Line.Prototype`, plus any non-overridden methods from `g.GeometryObject.prototype`.
+    //   - In that aspect, `g.GeometryObject` would then act like the parent of `g.Line`.
+    // - Multiple inheritance is also possible, if multiple arguments are provided.
+    // - What if we wanted to add another level of abstraction between `g.GeometryObject` and `g.Line` (let's call it `g.LinearObject`)?
+    //   - `g.Line.prototype = extend(g.GeometryObject.prototype, g.LinearObject.prototype, linePrototype)`
+    //   - The ancestors are applied in order of appearance.
+    //   - That means that `g.Line` would have inherited from `g.LinearObject` that would have inherited from `g.GeometryObject`.
+    //   - Any number of ancestors may be provided.
+    // - Note that neither `obj` nor any of the arguments need to actually be prototypes of any JavaScript quasiclass, that was just a simplified explanation.
+    // - We can create a new object composed from the properties of any number of other objects (since they do not have a constructor, we can think of those as interfaces).
+    //   - `extend({ a: 1, b: 2 }, { b: 10, c: 20 }, { c: 100, d: 200 })` gives `{ a: 1, b: 10, c: 100, d: 200 }`.
+    //   - Basically, with this function, we can emulate the `extends` keyword as well as the `implements` keyword.
+    // - Therefore, both of the following are valid:
+    //   - `Lineto.prototype = extend(Line.prototype, segmentPrototype, linetoPrototype)`
+    //   - `Moveto.prototype = extend(segmentPrototype, movetoPrototype)`
+
+    var i;
+    var n;
+
+    var args = [];
+    n = arguments.length;
+    for (i = 1; i < n; i++) { // skip over obj
+        args.push(arguments[i]);
+    }
+
+    if (!obj) throw new Error('Missing a parent object.');
+    var child = Object.create(obj);
+
+    n = args.length;
+    for (i = 0; i < n; i++) {
+
+        var src = args[i];
+
+        var inheritedProperty;
+        var key;
+        for (key in src) {
+
+            if (src.hasOwnProperty(key)) {
+                delete child[key]; // delete property inherited from parent
+                inheritedProperty = Object.getOwnPropertyDescriptor(src, key); // get new definition of property from src
+                Object.defineProperty(child, key, inheritedProperty); // re-add property with new definition (includes getter/setter methods)
+            }
+        }
+    }
+
+    return child;
+}

package/src/g/geometry.helpers.mjs

@@ -0,0 +1,58 @@
+// Declare shorthands to the most used math functions.
+const {
+    round,
+    floor,
+    PI
+} = Math;
+
+export const scale = {
+
+    // Return the `value` from the `domain` interval scaled to the `range` interval.
+    linear: function(domain, range, value) {
+
+        var domainSpan = domain[1] - domain[0];
+        var rangeSpan = range[1] - range[0];
+        return (((value - domain[0]) / domainSpan) * rangeSpan + range[0]) || 0;
+    }
+};
+
+export const normalizeAngle = function(angle) {
+
+    return (angle % 360) + (angle < 0 ? 360 : 0);
+};
+
+export const snapToGrid = function(value, gridSize) {
+
+    return gridSize * round(value / gridSize);
+};
+
+export const toDeg = function(rad) {
+
+    return (180 * rad / PI) % 360;
+};
+
+export const toRad = function(deg, over360) {
+
+    over360 = over360 || false;
+    deg = over360 ? deg : (deg % 360);
+    return deg * PI / 180;
+};
+
+// Return a random integer from the interval [min,max], inclusive.
+export const random = function(min, max) {
+
+    if (max === undefined) {
+        // use first argument as max, min is 0
+        max = (min === undefined) ? 1 : min;
+        min = 0;
+
+    } else if (max < min) {
+        // switch max and min
+        const temp = min;
+        min = max;
+        max = temp;
+    }
+
+    return floor((Math.random() * (max - min + 1)) + min);
+};
+

package/src/g/index.mjs

@@ -0,0 +1,17 @@
+// Geometry library.
+// -----------------
+
+export * from './geometry.helpers.mjs';
+export * from './bezier.mjs';
+export * from './curve.mjs';
+export * from './ellipse.mjs';
+export * from './line.mjs';
+export * from './path.mjs';
+export * from './point.mjs';
+export * from './polyline.mjs';
+export * from './polygon.mjs';
+export * from './rect.mjs';
+export * from './types.mjs';
+
+import * as _intersection from './intersection.mjs';
+export const intersection = _intersection;