@d3plus/math 3.0.0-alpha.0

package/es/src/shapeEdgePoint.js

@@ -0,0 +1,45 @@
+var pi = Math.PI;
+/**
+    @function shapeEdgePoint
+    @desc Calculates the x/y position of a point at the edge of a shape, from the center of the shape, given a specified pixel distance and radian angle.
+    @param {Number} angle The angle, in radians, of the offset point.
+    @param {Number} distance The pixel distance away from the origin.
+    @returns {String} [shape = "circle"] The type of shape, which can be either "circle" or "square".
+*/ export default function(angle, distance) {
+    var shape = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "circle";
+    if (angle < 0) angle = pi * 2 + angle;
+    if (shape === "square") {
+        var diagonal = 45 * (pi / 180);
+        var x = 0, y = 0;
+        if (angle < pi / 2) {
+            var tan = Math.tan(angle);
+            x += angle < diagonal ? distance : distance / tan;
+            y += angle < diagonal ? tan * distance : distance;
+        } else if (angle <= pi) {
+            var tan1 = Math.tan(pi - angle);
+            x -= angle < pi - diagonal ? distance / tan1 : distance;
+            y += angle < pi - diagonal ? distance : tan1 * distance;
+        } else if (angle < diagonal + pi) {
+            x -= distance;
+            y -= Math.tan(angle - pi) * distance;
+        } else if (angle < 3 * pi / 2) {
+            x -= distance / Math.tan(angle - pi);
+            y -= distance;
+        } else if (angle < 2 * pi - diagonal) {
+            x += distance / Math.tan(2 * pi - angle);
+            y -= distance;
+        } else {
+            x += distance;
+            y -= Math.tan(2 * pi - angle) * distance;
+        }
+        return [
+            x,
+            y
+        ];
+    } else if (shape === "circle") {
+        return [
+            distance * Math.cos(angle),
+            distance * Math.sin(angle)
+        ];
+    } else return null;
+};

package/es/src/simplify.js

@@ -0,0 +1,96 @@
+import pointDistanceSquared from "./pointDistanceSquared.js";
+/**
+    @desc square distance from a point to a segment
+    @param {Array} point
+    @param {Array} segmentAnchor1
+    @param {Array} segmentAnchor2
+    @private
+*/ function getSqSegDist(p, p1, p2) {
+    var x = p1[0], y = p1[1];
+    var dx = p2[0] - x, dy = p2[1] - y;
+    if (dx !== 0 || dy !== 0) {
+        var t = ((p[0] - x) * dx + (p[1] - y) * dy) / (dx * dx + dy * dy);
+        if (t > 1) {
+            x = p2[0];
+            y = p2[1];
+        } else if (t > 0) {
+            x += dx * t;
+            y += dy * t;
+        }
+    }
+    dx = p[0] - x;
+    dy = p[1] - y;
+    return dx * dx + dy * dy;
+}
+/**
+    @desc basic distance-based simplification
+    @param {Array} polygon
+    @param {Number} sqTolerance
+    @private
+*/ function simplifyRadialDist(poly, sqTolerance) {
+    var point, prevPoint = poly[0];
+    var newPoints = [
+        prevPoint
+    ];
+    for(var i = 1, len = poly.length; i < len; i++){
+        point = poly[i];
+        if (pointDistanceSquared(point, prevPoint) > sqTolerance) {
+            newPoints.push(point);
+            prevPoint = point;
+        }
+    }
+    if (prevPoint !== point) newPoints.push(point);
+    return newPoints;
+}
+/**
+    @param {Array} polygon
+    @param {Number} first
+    @param {Number} last
+    @param {Number} sqTolerance
+    @param {Array} simplified
+    @private
+*/ function simplifyDPStep(poly, first, last, sqTolerance, simplified) {
+    var index, maxSqDist = sqTolerance;
+    for(var i = first + 1; i < last; i++){
+        var sqDist = getSqSegDist(poly[i], poly[first], poly[last]);
+        if (sqDist > maxSqDist) {
+            index = i;
+            maxSqDist = sqDist;
+        }
+    }
+    if (maxSqDist > sqTolerance) {
+        if (index - first > 1) simplifyDPStep(poly, first, index, sqTolerance, simplified);
+        simplified.push(poly[index]);
+        if (last - index > 1) simplifyDPStep(poly, index, last, sqTolerance, simplified);
+    }
+}
+/**
+    @desc simplification using Ramer-Douglas-Peucker algorithm
+    @param {Array} polygon
+    @param {Number} sqTolerance
+    @private
+*/ function simplifyDouglasPeucker(poly, sqTolerance) {
+    var last = poly.length - 1;
+    var simplified = [
+        poly[0]
+    ];
+    simplifyDPStep(poly, 0, last, sqTolerance, simplified);
+    simplified.push(poly[last]);
+    return simplified;
+}
+/**
+    @function largestRect
+    @desc Simplifies the points of a polygon using both the Ramer-Douglas-Peucker algorithm and basic distance-based simplification. Adapted to an ES6 module from the excellent [Simplify.js](http://mourner.github.io/simplify-js/).
+    @author Vladimir Agafonkin
+    @param {Array} poly An Array of points that represent a polygon.
+    @param {Number} [tolerance = 1] Affects the amount of simplification (in the same metric as the point coordinates).
+    @param {Boolean} [highestQuality = false] Excludes distance-based preprocessing step which leads to highest quality simplification but runs ~10-20 times slower.
+
+*/ export default function(poly) {
+    var tolerance = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1, highestQuality = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    if (poly.length <= 2) return poly;
+    var sqTolerance = tolerance * tolerance;
+    poly = highestQuality ? poly : simplifyRadialDist(poly, sqTolerance);
+    poly = simplifyDouglasPeucker(poly, sqTolerance);
+    return poly;
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@d3plus/math",
+  "version": "3.0.0-alpha.0",
+  "description": "Mathematical functions to aid in calculating visualizations.",
+  "license": "MIT",
+  "type": "module",
+  "exports": "./es/index.js",
+  "browser": "./umd/d3plus-math.full.js",
+  "engines": {
+    "node": ">=18"
+  },
+  "sideEffects": false,
+  "files": [
+    "umd",
+    "es"
+  ],
+  "homepage": "https://d3plus.org",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/d3plus/d3plus.git",
+    "directory": "packages/math"
+  },
+  "keywords": [
+    "math",
+    "d3",
+    "d3plus",
+    "data",
+    "visualization"
+  ],
+  "scripts": {
+    "build:esm": "node ../../scripts/build-esm.js",
+    "build:umd": "node ../../scripts/build-umd.js",
+    "dev": "node ../../scripts/dev.js",
+    "test": "eslint index.js src/**/*.js && eslint --global=it test && mocha 'test/**/*-test.js'"
+  },
+  "dependencies": {
+    "d3-array": "^3.2.4",
+    "d3-polygon": "^3.0.1"
+  }
+}