@urpflanze/gcode-exporter
Version:
Export urpflanze scene to GCODE
1,525 lines (1,447 loc) • 51.9 kB
JavaScript
/*!
* @license Urpflanze GCODE Exporter v"0.0.7"
* urpflanze-gcode-exporter.js
*
* Github: https://github.com/urpflanze-org/gcode-exporter
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
/******/ var __webpack_modules__ = ([
/* 0 */,
/* 1 */
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
//# sourceMappingURL=types.js.map
/***/ }),
/* 2 */
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "GCODEExporter": () => (/* binding */ GCODEExporter)
/* harmony export */ });
/* harmony import */ var _urpflanze_core_dist_cjs_Utilities__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3);
/* harmony import */ var simplify_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
/* harmony import */ var simplify_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(simplify_js__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(8);
class GCODEExporter {
static parse(scene, settings) {
const bindedSettings = {
...GCODEExporter.defaults,
...settings,
};
return GCODEExporter.generate(scene, bindedSettings).join('\n');
}
/**
* Set units to inches or millimeters.
* When unit is set, all positions, offsets, rates, accelerations, etc., specified in G-code parameters are interpreted in that unit.
*
* @param unit 'millimeters' | 'inches'
* @returns
*/
static setUnit(unit) {
return unit === 'inches' ? 'G20' : 'G21';
}
/**
* In this mode all coordinates are interpreted as relative to the last position.
*
* @returns
*/
static useRelativePosition() {
return 'G91';
}
/**
* All coordinates given in G-code are interpreted as positions in the logical coordinate space
*
* @returns
*/
static useAbsolutePosition() {
return 'G90';
}
/**
* Up pen and go home
*
* @param penUpCommand
* @returns
*/
static goHome(penUpCommand) {
return [penUpCommand, 'G28 X0 Y0'];
}
/**
* Store the origin position that the machine goes to when the {G28} command is issued
*
* @param x
* @param y
* @param decimals
* @returns
*/
static setCurrentMachinePosition(x, y, decimals) {
return `G28.1 X${(0,_utilities__WEBPACK_IMPORTED_MODULE_2__.round)(x, decimals)} Y${(0,_utilities__WEBPACK_IMPORTED_MODULE_2__.round)(y, decimals)}`;
}
/**
* Set the current position to the values specified.
*
* @param x
* @param y
* @param decimals
* @returns
*/
static setCurrentWorkspacePosition(x, y, decimals) {
return `G92 X${(0,_utilities__WEBPACK_IMPORTED_MODULE_2__.round)(x, decimals)} Y${(0,_utilities__WEBPACK_IMPORTED_MODULE_2__.round)(y, decimals)}`;
}
/**
* Linear move.
* G0 is a rapid moviment (max speed)
* G1 moviment of setted velocity
*
* @param x
* @param y
* @param decimals
* @param velocity
* @returns
*/
static goTo(x, y, decimals, velocity) {
return typeof velocity !== 'undefined'
? `G1 X${(0,_utilities__WEBPACK_IMPORTED_MODULE_2__.round)(x, decimals)} Y${(0,_utilities__WEBPACK_IMPORTED_MODULE_2__.round)(y, decimals)} F${velocity}`
: `G0 X${(0,_utilities__WEBPACK_IMPORTED_MODULE_2__.round)(x, decimals)} Y${(0,_utilities__WEBPACK_IMPORTED_MODULE_2__.round)(y, decimals)}`;
}
/**
* Up the pen, move and down
*
* @param penUpCommand
* @param penDownCommand
* @param x
* @param y
* @param round
* @returns
*/
static moveTo(penUpCommand, penDownCommand, x, y, round) {
return [penUpCommand, this.goTo(x, y, round), penDownCommand];
}
/**
* goTo alias
*
* @param x
* @param y
* @param velocity
* @param round
* @returns
*/
static lineTo(x, y, velocity, round) {
return this.goTo(x, y, round, velocity);
}
/**
* Generate gcode frm scene
*
* @param scene
* @param settings
* @returns
*/
static generate(scene, settings) {
// Calculate workspace area
const workspaceWidth = settings.maxX - settings.minX;
const workspaceHeight = settings.maxY - settings.minY;
const workspaceRatio = workspaceWidth / workspaceHeight;
// Calculate drawArea from scene
const sceneRatio = scene.width / scene.height;
const drawArea = [
workspaceRatio > sceneRatio ? (scene.width * workspaceHeight) / scene.height : workspaceWidth,
workspaceRatio > sceneRatio ? workspaceHeight : (scene.height * workspaceWidth) / scene.width,
];
const drawAreaSceneOffset = [(workspaceWidth - drawArea[0]) / 2, (workspaceHeight - drawArea[1]) / 2];
// Adapt drawArea to workspace
const scale = workspaceRatio > sceneRatio ? scene.width / drawArea[0] : scene.height / drawArea[1];
// const machineCenterPosition = [(settings.maxX + settings.minX) / 2, (settings.maxY + settings.minY) / 2]
const gcode = [];
(0,_utilities__WEBPACK_IMPORTED_MODULE_2__.concat)(gcode, settings.penUpCommand);
(0,_utilities__WEBPACK_IMPORTED_MODULE_2__.concat)(gcode, this.setUnit(settings.unit));
(0,_utilities__WEBPACK_IMPORTED_MODULE_2__.concat)(gcode, this.useAbsolutePosition());
(0,_utilities__WEBPACK_IMPORTED_MODULE_2__.concat)(gcode, this.setCurrentMachinePosition(settings.minX, settings.minY, settings.decimals));
(0,_utilities__WEBPACK_IMPORTED_MODULE_2__.concat)(gcode, this.setCurrentWorkspacePosition(settings.minX, settings.minY, settings.decimals));
const sceneChilds = scene.getChildren();
for (let i = 0, len = sceneChilds.length; i < len; i++) {
sceneChilds[i].generate(0, true);
const childBuffer = sceneChilds[i].getBuffer() || [];
const childIndexedBuffer = sceneChilds[i].getIndexedBuffer() || [];
let childVertexIndex = 0;
for (let currentBufferIndex = 0, len = childIndexedBuffer.length; currentBufferIndex < len; currentBufferIndex++) {
const currentIndexing = childIndexedBuffer[currentBufferIndex];
const initialPointX = (0,_urpflanze_core_dist_cjs_Utilities__WEBPACK_IMPORTED_MODULE_0__.clamp)(settings.minX, settings.maxX, settings.minX + childBuffer[childVertexIndex] / scale + drawAreaSceneOffset[0]);
const initialPointY = (0,_urpflanze_core_dist_cjs_Utilities__WEBPACK_IMPORTED_MODULE_0__.clamp)(settings.minY, settings.maxY, settings.minY + childBuffer[childVertexIndex + 1] / scale + drawAreaSceneOffset[1]);
(0,_utilities__WEBPACK_IMPORTED_MODULE_2__.concat)(gcode, this.moveTo(settings.penUpCommand, settings.penDownCommand, initialPointX, initialPointY, settings.decimals));
const simplifiedBuffer = GCODEExporter.pointsToBuffer(simplify_js__WEBPACK_IMPORTED_MODULE_1__(GCODEExporter.bufferToPoints(childBuffer.slice(childVertexIndex, childVertexIndex + currentIndexing.frameLength)), 1 / 10 ** settings.decimals, true));
for (let i = 0, len = simplifiedBuffer.length; i < len; i += 2) {
const currentX = (0,_urpflanze_core_dist_cjs_Utilities__WEBPACK_IMPORTED_MODULE_0__.clamp)(settings.minX, settings.maxX, settings.minX + simplifiedBuffer[i] / scale + drawAreaSceneOffset[0]);
const currentY = (0,_urpflanze_core_dist_cjs_Utilities__WEBPACK_IMPORTED_MODULE_0__.clamp)(settings.minY, settings.maxY, settings.minY + simplifiedBuffer[i + 1] / scale + drawAreaSceneOffset[1]);
(0,_utilities__WEBPACK_IMPORTED_MODULE_2__.concat)(gcode, this.lineTo(currentX, currentY, settings.velocity, settings.decimals));
}
if (currentIndexing.shape.isClosed())
(0,_utilities__WEBPACK_IMPORTED_MODULE_2__.concat)(gcode, this.lineTo(initialPointX, initialPointY, settings.velocity, settings.decimals));
childVertexIndex += currentIndexing.frameLength;
}
}
/**
*
* @param penUpCommand
* @returns
*/
(0,_utilities__WEBPACK_IMPORTED_MODULE_2__.concat)(gcode, this.goHome(settings.penUpCommand));
return gcode;
}
static bufferToPoints(buffer) {
const result = [];
for (let i = 0, len = buffer.length; i < len; i += 2)
result.push({ x: buffer[i], y: buffer[i + 1] });
return result;
}
static pointsToBuffer(points) {
const result = [];
for (let i = 0, len = points.length; i < len; i++) {
result.push(points[i].x);
result.push(points[i].y);
}
return Float32Array.from(result);
}
}
GCODEExporter.defaults = {
minX: 0,
minY: 0,
maxX: 297,
maxY: 210,
unit: 'millimeters',
velocity: 1500,
penUpCommand: 'M3 S30',
penDownCommand: 'M3 S0',
decimals: 2,
};
//# sourceMappingURL=GCODEExporter.js.map
/***/ }),
/* 3 */
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.interpolate = exports.prepareBufferForInterpolation = exports.distributePointsInBuffer = exports.distanceFromRepetition = exports.angle2FromRepetition = exports.angleFromRepetition = exports.random = exports.noise = exports.relativeClamp = exports.clamp = exports.lerp = exports.toRadians = exports.toDegrees = exports.now = void 0;
const SimplexNoise = __webpack_require__(4);
const repetitions_1 = __webpack_require__(5);
const Vec2_1 = __webpack_require__(6);
const measurement = typeof performance !== 'undefined' ? performance : Date;
/**
* Get current timestamp in milliseconds
*
* @category Utilities
* @returns {number}
*/
function now() {
return measurement.now();
}
exports.now = now;
// aOr: (...args: Array<any>): any => {
// for (let i = 0; i < args.length; i++) if (Utilities.isDef(args[i])) return args[i]
// },
/**
* Convert number from radians to degrees
*
* @category Utilities
*
* @example
* ```javascript
* Urpflanze.toDegrees(Math.PI) // 180
* ```
*
* @param {number} radians
* @returns {number}
*/
function toDegrees(radians) {
return (radians * 180) / Math.PI;
}
exports.toDegrees = toDegrees;
/**
* Convert angle from degrees to radians
* @example
* ```javascript
* Urpflanze.toRadians(180) // 3.141592653589793
* ```
*
* @category Utilities
* @param {number} degrees
* @returns {number}
*/
function toRadians(degrees) {
return (degrees * Math.PI) / 180;
}
exports.toRadians = toRadians;
/**
* Linear interpolation from `a` when `i` as 0 an `b` when `i' as 1
*
* @category Utilities
* @param {number} a
* @param {number} b
* @param {number} i
* @returns {number}
*/
function lerp(a, b, i) {
return (1 - i) * a + i * b;
}
exports.lerp = lerp;
/**
* Return number between min and max
*
* @category Utilities
* @example
* ```javascript
* Urpflanze.clamp(0, 1, 1.2) // 1
* Urpflanze.clamp(0, 1, -2) // 0
* ```
* @param {number} min
* @param {number} max
* @param {number} value
* @returns {number}
*/
function clamp(min, max, value) {
return value <= min ? min : value >= max ? max : value;
}
exports.clamp = clamp;
/**
* Map number between refMin e refMax from min and max
*
* @category Utilities
*
* @example
* ```javascript
* Urpflanze.relativeClamp(0, 1, 0.5, 100, 200) // 150
* ```
*
* @param {number} refMin
* @param {number} refMax
* @param {number} value
* @param {number} toMin
* @param {number} toMax
* @returns {number}
*/
function relativeClamp(refMin, refMax, value, toMin, toMax) {
return clamp(toMin, toMax, ((value - refMin) / (refMax - refMin)) * (toMax - toMin) + toMin);
}
exports.relativeClamp = relativeClamp;
/**
* @internal
* @ignore
*/
const noises = {
random: new SimplexNoise(Math.random),
};
/**
* <a href="https://github.com/jwagner/simplex-noise.js" target="_blank">SimplexNoise</a>
* Use 'random' as seed property for random seed.
* Return value between -1 and 1
*
* @category Utilities
*
* @param {string} [seed='random']
* @param {number} [x=0]
* @param {number} [y=0]
* @param {number} [z=0]
* @param {number} [min=-1]
* @param {number} [max=-1]
* @returns {number} between -1 and 1
*/
function noise(seed = 'random', x = 0, y = 0, z = 0, min = -1, max = 1) {
if (typeof noises[seed] === 'undefined') {
noises[seed] = new SimplexNoise(seed);
}
const value = noises[seed].noise3D(x, y, z);
return min !== -1 || max !== 1 ? (0.5 + value * 0.5) * (max - min) + min : value;
}
exports.noise = noise;
/**
* @internal
* @ignore
*/
const randoms = {};
/**
* Random number generator
* @example
* ```javascript
* Urpflanze.random('seed') // 0.9367527104914188
* ```
*
* @category Utilities
* @param {string} seed
* @param {number} min
* @param {number} max
* @param {number} decimals
* @returns {number}
*/
function random(seed, min = 0, max = 1, decimals) {
const key = seed + '';
if (typeof randoms[key] === 'undefined') {
const seed = xmur3(key);
randoms[key] = sfc32(seed(), seed(), seed(), seed());
}
const value = min + randoms[key]() * (max - min);
return typeof decimals !== 'undefined' ? Math.round(value * 10 ** decimals) / 10 ** decimals : value;
}
exports.random = random;
/**
*
* @internal
* @param str
* @returns
*/
function xmur3(str) {
let i = 0, h = 1779033703 ^ str.length;
for (; i < str.length; i++)
(h = Math.imul(h ^ str.charCodeAt(i), 3432918353)), (h = (h << 13) | (h >>> 19));
return function () {
h = Math.imul(h ^ (h >>> 16), 2246822507);
h = Math.imul(h ^ (h >>> 13), 3266489909);
return (h ^= h >>> 16) >>> 0;
};
}
/**
* @internal
* @param a
* @param b
* @param c
* @param d
* @returns
*/
function sfc32(a, b, c, d) {
return function () {
a >>>= 0;
b >>>= 0;
c >>>= 0;
d >>>= 0;
let t = (a + b) | 0;
a = b ^ (b >>> 9);
b = (c + (c << 3)) | 0;
c = (c << 21) | (c >>> 11);
d = (d + 1) | 0;
t = (t + d) | 0;
c = (c + t) | 0;
return (t >>> 0) / 4294967296;
};
}
/**
* Return angle (atan) from offset (or center) for matrix repetition.
* Offset is array between [-1, -1] and [1, 1].
* The return value is between -Math.PI / 2 and Math.PI / 2
*
* @category Utilities
*
* @param {IRepetition} repetition
* @param {[number, number]} offsetFromCenter
* @returns {number} between -Math.PI / 2 and Math.PI / 2
*/
function angleFromRepetition(repetition, offsetFromCenter = [0, 0]) {
if (repetition.type === repetitions_1.ERepetitionType.Matrix) {
const centerMatrix = [(repetition.col.count - 1) / 2, (repetition.row.count - 1) / 2];
centerMatrix[0] += centerMatrix[0] * offsetFromCenter[0];
centerMatrix[1] += centerMatrix[1] * offsetFromCenter[1];
const x = repetition.col.index - 1 - centerMatrix[0];
const y = repetition.row.index - 1 - centerMatrix[1];
return x === 0 ? 0 : Math.atan(y / x);
}
return (repetition.angle - Math.PI) / 2;
}
exports.angleFromRepetition = angleFromRepetition;
/**
* Return angle (atan2, 4 quadrants) from offset (or center) for matrix repetition.
* Offset is array between [-1, -1] and [1, 1].
* The return value is between -Math.PI an Math.PI
*
* @category Utilities
*
* @param {IRepetition} repetition
* @param {[number, number]} offsetFromCenter
* @returns {number} between -Math.PI an Math.PI
*/
function angle2FromRepetition(repetition, offsetFromCenter = [0, 0]) {
if (repetition.type === repetitions_1.ERepetitionType.Matrix) {
const centerMatrix = [(repetition.col.count - 1) / 2, (repetition.row.count - 1) / 2];
centerMatrix[0] += centerMatrix[0] * offsetFromCenter[0];
centerMatrix[1] += centerMatrix[1] * offsetFromCenter[1];
const x = repetition.col.index - 1 - centerMatrix[0];
const y = repetition.row.index - 1 - centerMatrix[1];
return x === 0 ? 0 : Math.atan2(y, x);
}
return repetition.angle - Math.PI;
}
exports.angle2FromRepetition = angle2FromRepetition;
/**
* Return distance from offset (or center) for matrix repetition.
* The return value is between 0 and 1
*
* @category Utilities
*
* @param {IRepetition} repetition
* @param {[number, number]} offsetFromCenter offset relative to distance prop
* @returns {number} between 0 and 1
*/
function distanceFromRepetition(repetition, offsetFromCenter = [0, 0]) {
if (repetition.type === repetitions_1.ERepetitionType.Matrix) {
const centerMatrix = [0.5, 0.5];
centerMatrix[0] += centerMatrix[0] * offsetFromCenter[0];
centerMatrix[1] += centerMatrix[1] * offsetFromCenter[1];
const current = [repetition.col.offset, repetition.row.offset];
return Vec2_1.default.distance(current, centerMatrix);
}
return 1;
}
exports.distanceFromRepetition = distanceFromRepetition;
/// Interpolation
/**
* Evenly distributes a number of points in a buffer
*
* @category Utilities.Buffer interpolation
* @export
* @param {Float32Array} buffer current buffer
* @param {number} pointsToAdd points to add
* @return {*} {Float32Array}
*/
function distributePointsInBuffer(buffer, pointsToAdd) {
const bufferLen = buffer.length;
const pointsLen = bufferLen / 2;
const finalBufferLength = (pointsLen + pointsToAdd) * 2;
const edges = pointsLen - 1;
if (edges > 1) {
const lastPoint = bufferLen - 2;
const newPointsOnEdge = Math.floor(pointsToAdd / edges);
const bufferWithPointsEveryEdge = bufferLen + newPointsOnEdge * lastPoint;
let remainingPoints = (finalBufferLength - bufferWithPointsEveryEdge) / 2;
const edgeRemainingIndex = Math.round(edges / remainingPoints);
const result = new Float32Array(finalBufferLength);
for (let i = 0, edgeIndex = 0, r = 0; i < lastPoint; i += 2, edgeIndex++, r += 2) {
const ax = buffer[i];
const ay = buffer[i + 1];
const bx = buffer[i + 2];
const by = buffer[i + 3];
result[r] = ax;
result[r + 1] = ay;
const addReminingPoints = remainingPoints > 0 && (edgeIndex % edgeRemainingIndex === 0 || i === lastPoint - 2);
const currentPointsOnEdge = newPointsOnEdge + (addReminingPoints ? 1 : 0);
const newPointOffset = 1 / (currentPointsOnEdge + 1);
for (let h = 0; h < currentPointsOnEdge; h++, r += 2) {
const o = newPointOffset * (h + 1);
result[r + 2] = (1 - o) * ax + o * bx;
result[r + 3] = (1 - o) * ay + o * by;
}
if (addReminingPoints) {
remainingPoints--;
}
}
result[finalBufferLength - 2] = buffer[bufferLen - 2];
result[finalBufferLength - 1] = buffer[bufferLen - 1];
return result;
}
const result = new Float32Array(finalBufferLength);
for (let i = 0; i < finalBufferLength; i += 2) {
result[i] = buffer[i % bufferLen];
result[i + 1] = buffer[(i + 1) % bufferLen];
}
return result;
}
exports.distributePointsInBuffer = distributePointsInBuffer;
/**
* Leads two buffers to have the same number of points
*
* @category Utilities.Buffer interpolation
* @param from
* @param to
* @returns
*/
function prepareBufferForInterpolation(from, to) {
const fromBufferLength = from.length;
const toBufferLength = to.length;
if (fromBufferLength === toBufferLength) {
return [from, to];
}
// const maxBufferLength = fromBufferLength > toBufferLength ? fromBufferLength : toBufferLength
const difference = Math.abs(fromBufferLength - toBufferLength);
// const minBufferLength = maxBufferLength - difference
/////
const b = fromBufferLength < toBufferLength ? to : from;
const t = fromBufferLength < toBufferLength ? from : to;
const a = distributePointsInBuffer(t, Math.floor(difference / 2));
// a[maxBufferLength - 2] = t[minBufferLength - 2]
// a[maxBufferLength - 1] = t[minBufferLength - 1]
return fromBufferLength > toBufferLength ? [b, a] : [a, b];
}
exports.prepareBufferForInterpolation = prepareBufferForInterpolation;
/**
* Interpolate two buffer
*
* @category Utilities.Buffer interpolation
* @param from
* @param to
* @param offset
* @returns
*/
function interpolate(from, to, initialOffset = 0.5) {
const [a, b] = prepareBufferForInterpolation(from, to);
const maxBufferLength = Math.max(a.length, b.length);
const offset = typeof initialOffset === 'number' ? [initialOffset] : initialOffset;
const maxPoints = maxBufferLength / 2;
if (offset.length !== maxPoints) {
const tl = offset.length;
for (let i = 0; i < maxPoints; i++) {
offset[i] = offset[i % tl];
}
}
////
const result = new Float32Array(maxBufferLength);
for (let i = 0, off = 0; i < maxBufferLength; i += 2, off++) {
result[i] = (1 - offset[off]) * a[i] + offset[off] * b[i];
result[i + 1] = (1 - offset[off]) * a[i + 1] + offset[off] * b[i + 1];
}
return result;
}
exports.interpolate = interpolate;
//# sourceMappingURL=Utilities.js.map
/***/ }),
/* 4 */
/***/ ((module, exports, __webpack_require__) => {
var __WEBPACK_AMD_DEFINE_RESULT__;/*
* A fast javascript implementation of simplex noise by Jonas Wagner
Based on a speed-improved simplex noise algorithm for 2D, 3D and 4D in Java.
Which is based on example code by Stefan Gustavson (stegu@itn.liu.se).
With Optimisations by Peter Eastman (peastman@drizzle.stanford.edu).
Better rank ordering method by Stefan Gustavson in 2012.
Copyright (c) 2018 Jonas Wagner
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
(function() {
'use strict';
var F2 = 0.5 * (Math.sqrt(3.0) - 1.0);
var G2 = (3.0 - Math.sqrt(3.0)) / 6.0;
var F3 = 1.0 / 3.0;
var G3 = 1.0 / 6.0;
var F4 = (Math.sqrt(5.0) - 1.0) / 4.0;
var G4 = (5.0 - Math.sqrt(5.0)) / 20.0;
function SimplexNoise(randomOrSeed) {
var random;
if (typeof randomOrSeed == 'function') {
random = randomOrSeed;
}
else if (randomOrSeed) {
random = alea(randomOrSeed);
} else {
random = Math.random;
}
this.p = buildPermutationTable(random);
this.perm = new Uint8Array(512);
this.permMod12 = new Uint8Array(512);
for (var i = 0; i < 512; i++) {
this.perm[i] = this.p[i & 255];
this.permMod12[i] = this.perm[i] % 12;
}
}
SimplexNoise.prototype = {
grad3: new Float32Array([1, 1, 0,
-1, 1, 0,
1, -1, 0,
-1, -1, 0,
1, 0, 1,
-1, 0, 1,
1, 0, -1,
-1, 0, -1,
0, 1, 1,
0, -1, 1,
0, 1, -1,
0, -1, -1]),
grad4: new Float32Array([0, 1, 1, 1, 0, 1, 1, -1, 0, 1, -1, 1, 0, 1, -1, -1,
0, -1, 1, 1, 0, -1, 1, -1, 0, -1, -1, 1, 0, -1, -1, -1,
1, 0, 1, 1, 1, 0, 1, -1, 1, 0, -1, 1, 1, 0, -1, -1,
-1, 0, 1, 1, -1, 0, 1, -1, -1, 0, -1, 1, -1, 0, -1, -1,
1, 1, 0, 1, 1, 1, 0, -1, 1, -1, 0, 1, 1, -1, 0, -1,
-1, 1, 0, 1, -1, 1, 0, -1, -1, -1, 0, 1, -1, -1, 0, -1,
1, 1, 1, 0, 1, 1, -1, 0, 1, -1, 1, 0, 1, -1, -1, 0,
-1, 1, 1, 0, -1, 1, -1, 0, -1, -1, 1, 0, -1, -1, -1, 0]),
noise2D: function(xin, yin) {
var permMod12 = this.permMod12;
var perm = this.perm;
var grad3 = this.grad3;
var n0 = 0; // Noise contributions from the three corners
var n1 = 0;
var n2 = 0;
// Skew the input space to determine which simplex cell we're in
var s = (xin + yin) * F2; // Hairy factor for 2D
var i = Math.floor(xin + s);
var j = Math.floor(yin + s);
var t = (i + j) * G2;
var X0 = i - t; // Unskew the cell origin back to (x,y) space
var Y0 = j - t;
var x0 = xin - X0; // The x,y distances from the cell origin
var y0 = yin - Y0;
// For the 2D case, the simplex shape is an equilateral triangle.
// Determine which simplex we are in.
var i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords
if (x0 > y0) {
i1 = 1;
j1 = 0;
} // lower triangle, XY order: (0,0)->(1,0)->(1,1)
else {
i1 = 0;
j1 = 1;
} // upper triangle, YX order: (0,0)->(0,1)->(1,1)
// A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
// a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
// c = (3-sqrt(3))/6
var x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
var y1 = y0 - j1 + G2;
var x2 = x0 - 1.0 + 2.0 * G2; // Offsets for last corner in (x,y) unskewed coords
var y2 = y0 - 1.0 + 2.0 * G2;
// Work out the hashed gradient indices of the three simplex corners
var ii = i & 255;
var jj = j & 255;
// Calculate the contribution from the three corners
var t0 = 0.5 - x0 * x0 - y0 * y0;
if (t0 >= 0) {
var gi0 = permMod12[ii + perm[jj]] * 3;
t0 *= t0;
n0 = t0 * t0 * (grad3[gi0] * x0 + grad3[gi0 + 1] * y0); // (x,y) of grad3 used for 2D gradient
}
var t1 = 0.5 - x1 * x1 - y1 * y1;
if (t1 >= 0) {
var gi1 = permMod12[ii + i1 + perm[jj + j1]] * 3;
t1 *= t1;
n1 = t1 * t1 * (grad3[gi1] * x1 + grad3[gi1 + 1] * y1);
}
var t2 = 0.5 - x2 * x2 - y2 * y2;
if (t2 >= 0) {
var gi2 = permMod12[ii + 1 + perm[jj + 1]] * 3;
t2 *= t2;
n2 = t2 * t2 * (grad3[gi2] * x2 + grad3[gi2 + 1] * y2);
}
// Add contributions from each corner to get the final noise value.
// The result is scaled to return values in the interval [-1,1].
return 70.0 * (n0 + n1 + n2);
},
// 3D simplex noise
noise3D: function(xin, yin, zin) {
var permMod12 = this.permMod12;
var perm = this.perm;
var grad3 = this.grad3;
var n0, n1, n2, n3; // Noise contributions from the four corners
// Skew the input space to determine which simplex cell we're in
var s = (xin + yin + zin) * F3; // Very nice and simple skew factor for 3D
var i = Math.floor(xin + s);
var j = Math.floor(yin + s);
var k = Math.floor(zin + s);
var t = (i + j + k) * G3;
var X0 = i - t; // Unskew the cell origin back to (x,y,z) space
var Y0 = j - t;
var Z0 = k - t;
var x0 = xin - X0; // The x,y,z distances from the cell origin
var y0 = yin - Y0;
var z0 = zin - Z0;
// For the 3D case, the simplex shape is a slightly irregular tetrahedron.
// Determine which simplex we are in.
var i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords
var i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords
if (x0 >= y0) {
if (y0 >= z0) {
i1 = 1;
j1 = 0;
k1 = 0;
i2 = 1;
j2 = 1;
k2 = 0;
} // X Y Z order
else if (x0 >= z0) {
i1 = 1;
j1 = 0;
k1 = 0;
i2 = 1;
j2 = 0;
k2 = 1;
} // X Z Y order
else {
i1 = 0;
j1 = 0;
k1 = 1;
i2 = 1;
j2 = 0;
k2 = 1;
} // Z X Y order
}
else { // x0<y0
if (y0 < z0) {
i1 = 0;
j1 = 0;
k1 = 1;
i2 = 0;
j2 = 1;
k2 = 1;
} // Z Y X order
else if (x0 < z0) {
i1 = 0;
j1 = 1;
k1 = 0;
i2 = 0;
j2 = 1;
k2 = 1;
} // Y Z X order
else {
i1 = 0;
j1 = 1;
k1 = 0;
i2 = 1;
j2 = 1;
k2 = 0;
} // Y X Z order
}
// A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
// a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
// a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
// c = 1/6.
var x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
var y1 = y0 - j1 + G3;
var z1 = z0 - k1 + G3;
var x2 = x0 - i2 + 2.0 * G3; // Offsets for third corner in (x,y,z) coords
var y2 = y0 - j2 + 2.0 * G3;
var z2 = z0 - k2 + 2.0 * G3;
var x3 = x0 - 1.0 + 3.0 * G3; // Offsets for last corner in (x,y,z) coords
var y3 = y0 - 1.0 + 3.0 * G3;
var z3 = z0 - 1.0 + 3.0 * G3;
// Work out the hashed gradient indices of the four simplex corners
var ii = i & 255;
var jj = j & 255;
var kk = k & 255;
// Calculate the contribution from the four corners
var t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0;
if (t0 < 0) n0 = 0.0;
else {
var gi0 = permMod12[ii + perm[jj + perm[kk]]] * 3;
t0 *= t0;
n0 = t0 * t0 * (grad3[gi0] * x0 + grad3[gi0 + 1] * y0 + grad3[gi0 + 2] * z0);
}
var t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1;
if (t1 < 0) n1 = 0.0;
else {
var gi1 = permMod12[ii + i1 + perm[jj + j1 + perm[kk + k1]]] * 3;
t1 *= t1;
n1 = t1 * t1 * (grad3[gi1] * x1 + grad3[gi1 + 1] * y1 + grad3[gi1 + 2] * z1);
}
var t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2;
if (t2 < 0) n2 = 0.0;
else {
var gi2 = permMod12[ii + i2 + perm[jj + j2 + perm[kk + k2]]] * 3;
t2 *= t2;
n2 = t2 * t2 * (grad3[gi2] * x2 + grad3[gi2 + 1] * y2 + grad3[gi2 + 2] * z2);
}
var t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3;
if (t3 < 0) n3 = 0.0;
else {
var gi3 = permMod12[ii + 1 + perm[jj + 1 + perm[kk + 1]]] * 3;
t3 *= t3;
n3 = t3 * t3 * (grad3[gi3] * x3 + grad3[gi3 + 1] * y3 + grad3[gi3 + 2] * z3);
}
// Add contributions from each corner to get the final noise value.
// The result is scaled to stay just inside [-1,1]
return 32.0 * (n0 + n1 + n2 + n3);
},
// 4D simplex noise, better simplex rank ordering method 2012-03-09
noise4D: function(x, y, z, w) {
var perm = this.perm;
var grad4 = this.grad4;
var n0, n1, n2, n3, n4; // Noise contributions from the five corners
// Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
var s = (x + y + z + w) * F4; // Factor for 4D skewing
var i = Math.floor(x + s);
var j = Math.floor(y + s);
var k = Math.floor(z + s);
var l = Math.floor(w + s);
var t = (i + j + k + l) * G4; // Factor for 4D unskewing
var X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space
var Y0 = j - t;
var Z0 = k - t;
var W0 = l - t;
var x0 = x - X0; // The x,y,z,w distances from the cell origin
var y0 = y - Y0;
var z0 = z - Z0;
var w0 = w - W0;
// For the 4D case, the simplex is a 4D shape I won't even try to describe.
// To find out which of the 24 possible simplices we're in, we need to
// determine the magnitude ordering of x0, y0, z0 and w0.
// Six pair-wise comparisons are performed between each possible pair
// of the four coordinates, and the results are used to rank the numbers.
var rankx = 0;
var ranky = 0;
var rankz = 0;
var rankw = 0;
if (x0 > y0) rankx++;
else ranky++;
if (x0 > z0) rankx++;
else rankz++;
if (x0 > w0) rankx++;
else rankw++;
if (y0 > z0) ranky++;
else rankz++;
if (y0 > w0) ranky++;
else rankw++;
if (z0 > w0) rankz++;
else rankw++;
var i1, j1, k1, l1; // The integer offsets for the second simplex corner
var i2, j2, k2, l2; // The integer offsets for the third simplex corner
var i3, j3, k3, l3; // The integer offsets for the fourth simplex corner
// simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order.
// Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w
// impossible. Only the 24 indices which have non-zero entries make any sense.
// We use a thresholding to set the coordinates in turn from the largest magnitude.
// Rank 3 denotes the largest coordinate.
i1 = rankx >= 3 ? 1 : 0;
j1 = ranky >= 3 ? 1 : 0;
k1 = rankz >= 3 ? 1 : 0;
l1 = rankw >= 3 ? 1 : 0;
// Rank 2 denotes the second largest coordinate.
i2 = rankx >= 2 ? 1 : 0;
j2 = ranky >= 2 ? 1 : 0;
k2 = rankz >= 2 ? 1 : 0;
l2 = rankw >= 2 ? 1 : 0;
// Rank 1 denotes the second smallest coordinate.
i3 = rankx >= 1 ? 1 : 0;
j3 = ranky >= 1 ? 1 : 0;
k3 = rankz >= 1 ? 1 : 0;
l3 = rankw >= 1 ? 1 : 0;
// The fifth corner has all coordinate offsets = 1, so no need to compute that.
var x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords
var y1 = y0 - j1 + G4;
var z1 = z0 - k1 + G4;
var w1 = w0 - l1 + G4;
var x2 = x0 - i2 + 2.0 * G4; // Offsets for third corner in (x,y,z,w) coords
var y2 = y0 - j2 + 2.0 * G4;
var z2 = z0 - k2 + 2.0 * G4;
var w2 = w0 - l2 + 2.0 * G4;
var x3 = x0 - i3 + 3.0 * G4; // Offsets for fourth corner in (x,y,z,w) coords
var y3 = y0 - j3 + 3.0 * G4;
var z3 = z0 - k3 + 3.0 * G4;
var w3 = w0 - l3 + 3.0 * G4;
var x4 = x0 - 1.0 + 4.0 * G4; // Offsets for last corner in (x,y,z,w) coords
var y4 = y0 - 1.0 + 4.0 * G4;
var z4 = z0 - 1.0 + 4.0 * G4;
var w4 = w0 - 1.0 + 4.0 * G4;
// Work out the hashed gradient indices of the five simplex corners
var ii = i & 255;
var jj = j & 255;
var kk = k & 255;
var ll = l & 255;
// Calculate the contribution from the five corners
var t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0;
if (t0 < 0) n0 = 0.0;
else {
var gi0 = (perm[ii + perm[jj + perm[kk + perm[ll]]]] % 32) * 4;
t0 *= t0;
n0 = t0 * t0 * (grad4[gi0] * x0 + grad4[gi0 + 1] * y0 + grad4[gi0 + 2] * z0 + grad4[gi0 + 3] * w0);
}
var t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1;
if (t1 < 0) n1 = 0.0;
else {
var gi1 = (perm[ii + i1 + perm[jj + j1 + perm[kk + k1 + perm[ll + l1]]]] % 32) * 4;
t1 *= t1;
n1 = t1 * t1 * (grad4[gi1] * x1 + grad4[gi1 + 1] * y1 + grad4[gi1 + 2] * z1 + grad4[gi1 + 3] * w1);
}
var t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2;
if (t2 < 0) n2 = 0.0;
else {
var gi2 = (perm[ii + i2 + perm[jj + j2 + perm[kk + k2 + perm[ll + l2]]]] % 32) * 4;
t2 *= t2;
n2 = t2 * t2 * (grad4[gi2] * x2 + grad4[gi2 + 1] * y2 + grad4[gi2 + 2] * z2 + grad4[gi2 + 3] * w2);
}
var t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3;
if (t3 < 0) n3 = 0.0;
else {
var gi3 = (perm[ii + i3 + perm[jj + j3 + perm[kk + k3 + perm[ll + l3]]]] % 32) * 4;
t3 *= t3;
n3 = t3 * t3 * (grad4[gi3] * x3 + grad4[gi3 + 1] * y3 + grad4[gi3 + 2] * z3 + grad4[gi3 + 3] * w3);
}
var t4 = 0.6 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4;
if (t4 < 0) n4 = 0.0;
else {
var gi4 = (perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] % 32) * 4;
t4 *= t4;
n4 = t4 * t4 * (grad4[gi4] * x4 + grad4[gi4 + 1] * y4 + grad4[gi4 + 2] * z4 + grad4[gi4 + 3] * w4);
}
// Sum up and scale the result to cover the range [-1,1]
return 27.0 * (n0 + n1 + n2 + n3 + n4);
}
};
function buildPermutationTable(random) {
var i;
var p = new Uint8Array(256);
for (i = 0; i < 256; i++) {
p[i] = i;
}
for (i = 0; i < 255; i++) {
var r = i + ~~(random() * (256 - i));
var aux = p[i];
p[i] = p[r];
p[r] = aux;
}
return p;
}
SimplexNoise._buildPermutationTable = buildPermutationTable;
function alea() {
// Johannes Baagøe <baagoe@baagoe.com>, 2010
var s0 = 0;
var s1 = 0;
var s2 = 0;
var c = 1;
var mash = masher();
s0 = mash(' ');
s1 = mash(' ');
s2 = mash(' ');
for (var i = 0; i < arguments.length; i++) {
s0 -= mash(arguments[i]);
if (s0 < 0) {
s0 += 1;
}
s1 -= mash(arguments[i]);
if (s1 < 0) {
s1 += 1;
}
s2 -= mash(arguments[i]);
if (s2 < 0) {
s2 += 1;
}
}
mash = null;
return function() {
var t = 2091639 * s0 + c * 2.3283064365386963e-10; // 2^-32
s0 = s1;
s1 = s2;
return s2 = t - (c = t | 0);
};
}
function masher() {
var n = 0xefc8249d;
return function(data) {
data = data.toString();
for (var i = 0; i < data.length; i++) {
n += data.charCodeAt(i);
var h = 0.02519603282416938 * n;
n = h >>> 0;
h -= n;
h *= n;
n = h >>> 0;
h -= n;
n += h * 0x100000000; // 2^32
}
return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
};
}
// amd
if (true) !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() {return SimplexNoise;}).call(exports, __webpack_require__, exports, module),
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
// common js
if (true) exports.SimplexNoise = SimplexNoise;
// browser
else {}
// nodejs
if (true) {
module.exports = SimplexNoise;
}
})();
/***/ }),
/* 5 */
/***/ ((__unused_webpack_module, exports) => {
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.ERepetitionType = void 0;
/**
* Repetition type enumerator.
*
* @category Types & Interfaces.Repetitions
* @internal
*/
var ERepetitionType;
(function (ERepetitionType) {
/**
* Defines the type of repetition of the shape,
* in a circular way starting from the center of the scene
* @order 1
*/
ERepetitionType[ERepetitionType["Ring"] = 1] = "Ring";
/**
* Defines the type of repetition of the shape,
* on a nxm grid starting from the center of the scene
* @order 2
*/
ERepetitionType[ERepetitionType["Matrix"] = 2] = "Matrix";
})(ERepetitionType = exports.ERepetitionType || (exports.ERepetitionType = {}));
//# sourceMappingURL=repetitions.js.map
/***/ }),
/* 6 */
/***/ ((__unused_webpack_module, exports) => {
Object.defineProperty(exports, "__esModule", ({ value: true }));
/**
* Temporany matrix
*
* @internal
* @ignore
*/
const MATRIX = new Array(4);
/**
* Vec2 operation
*
* @category Math
*/
const Vec2 = {
/**
* from new vertex
*
* @param {Array<number> | number} [x=0]
* @param {number} [y]
* @returns {Array<number>}
*/
from: (x = 0, y) => {
const out = new Array(2);
if (typeof x === 'number') {
out[0] = x;
out[1] = y !== null && y !== void 0 ? y : x;
}
else {
out[0] = x[0];
out[1] = x[1];
}
return out;
},
normalize: (v) => {
const len = Vec2.length(v);
return len !== 0 ? [v[0] / len, v[1] / len] : [0, 0];
},
/**
* Distance between two points
*
* @param {Array<number>} a
* @param {Array<number>} b
* @returns {number}
*/
distance: (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]),
/**
* dot product
*
* @param {Array<number>} a
* @param {Array<number>} b
* @returns {number}
*/
dot: (a, b) => a[0] * b[0] + a[1] * b[1],
/**
* length of point
*
* @param {Array<number>} vec
* @returns {number}
*/
length: (vec) => Math.hypot(vec[0], vec[1]),
/**
* angle between two point
*
* @param {Array<number>} a
* @param {Array<number>} b
* @returns {number}
*/
angle: (a, b) => {
a = Vec2.normalize(a);
b = Vec2.normalize(b);
return Math.acos(Vec2.dot(a, b));
},
/**
* skewX point
*
* @param {Array<number>} vec
* @param {number} m
*/
skewX: (vec, m) => {
vec[0] += Math.tan(m) * vec[1];
},
/**
* skewY point
*
* @param {Array<number>} vec
* @param {number} m
*/
skewY: (vec, m) => {
vec[1] += Math.tan(m) * vec[0];
},
/**
* squeezeX point
*
* @param {Array<number>} vec
* @param {number} m
*/
squeezeX: (vec, m) => {
vec[1] += vec[1] * (vec[0] * -m);
},
/**
* squeezeY point
*
* @param {Array<number>} vec
* @param {number} m
*/
squeezeY: (vec, m) => {
vec[0] += vec[0] * (vec[1] * m);
},
/**
* Rotate point
*
* @param {Array<number>} vec
* @param {Array<number>} MATRIX
* @param {Array<number>} fromPoint
* @internal
*/
rotate: (vec, MATRIX, fromPoint) => {
const p0 = vec[0] - fromPoint[0];
const p1 = vec[1] - fromPoint[1];
vec[0] = p0 * MATRIX[0] + p1 * MATRIX[1] + fromPoint[0];
vec[1] = p0 * MATRIX[2] + p1 * MATRIX[3] + fromPoint[1];
},
/**
* RotateX point
*
* @param {Array<number>} vec
* @param {Array<number>} fromPoint
* @param {number} rad
*/
rotateX: (vec, fromPoint, rad) => {
MATRIX[0] = 1;
MATRIX[1] = 0;
MATRIX[2] = 0;
MATRIX[3] = Math.cos(rad);
Vec2.rotate(vec, MATRIX, fromPoint);
},
/**
* RotateY point
*
* @param {Array<number>} vec
* @param {Array<number>} fromPoint
* @param {number} rad
*/
rotateY: (vec, fromPoint, rad) => {
MATRIX[0] = Math.cos(rad);
MATRIX[1] = 0;
MATRIX[2] = 0;
MATRIX[3] = 1;
Vec2.rotate(vec, MATRIX, fromPoint);
},
/**
* RotateZ point
*
* @param {Array<number>} vec
* @param {Array<number>} fromPoint
* @param {number} rad
*/
rotateZ: (vec, fromPoint, rad) => {
MATRIX[0] = Math.cos(rad);
MATRIX[1] = -Math.sin(rad);
MATRIX[2] = Math.sin(rad);
MATRIX[3] = Math.cos(rad);
Vec2.rotate(vec, MATRIX, fromPoint);
},
/**
* Translate vertex
*
* @param {Array<number>} vec
* @param {Array<number>} to
*/
translate: (vec, to) => {
vec[0] += to[0];
vec[1] += to[1];
},
/**
* Scale vertex
*
* @param {Array<number>} vec
* @param {Array<number>} to
*/
scale: (vec, to) => {
vec[0] *= to[0];
vec[1] *= to[1];
},
/**
* Scale vertex
*
* @param {Array<number>} vec
* @param {Array<number>} to
*/
divide: (vec, to) => {
vec[0] /= to[0];
vec[1] /= to[1];
},
/**
* Vec to string
*
* @param {Array<number>} vec
* @return {string}
*/
toString: (vec) => `x: ${vec[0]}, y: ${vec[1]}`,
/**
* Vertex [0, 0]
*/
ZERO: Array.from([0, 0]),
/**
* Vertex [1, 1]
*/
ONE: Array.from([1, 1]),
};
exports["default"] = Vec2;
//# sourceMappingURL=Vec2.js.map
/***/ }),
/* 7 */
/***/ ((module, exports, __webpack_require__) => {
var __WEBPACK_AMD_DEFINE_RESULT__;/*
(c) 2017, Vladimir Agafonkin
Simplify.js, a high-performance JS polyline simplification library
mourner.github.io/simplify-js
*/
(function () { 'use strict';
// to suit your point format, run search/replace for '.x' and '.y';
// for 3D version, see 3d branch (configurability would draw significant performance overhead)
// square distance between 2 points
function getSqDist(p1, p2) {
var dx = p1.x - p2.x,
dy = p1.y - p2.y;
return dx * dx + dy * dy;
}
// square distance from a point to a segment
function getSqSegDist(p, p1, p2) {
var x = p1.x,
y = p1.y,
dx = p2.x - x,
dy = p2.y - y;
if (dx !== 0 || dy !== 0) {
var t = ((p.x - x) * dx + (p.y - y) * dy) / (dx * dx + dy * dy);
if (t > 1) {
x = p2.x;
y = p2.y;
} else if (t > 0) {
x += dx * t;
y += dy * t;
}
}
dx = p.x - x;
dy = p.y - y;
return dx * dx + dy * dy;
}
// rest of the code doesn't care about point format
// basic distance-based simplification
function simplifyRadialDist(points, sqTolerance) {
var prevPoint = points[0],
newPoints = [prevPoint],
point;
for (var i = 1, len = points.length; i < len; i++) {
point = points[i];
if (getSqDist(point, prevPoint) > sqTolerance) {
newPoints.push(point);
prevPoint = point;
}
}
if (prevPoint !== point) newPoints.push(point);
return newPoints;
}
function simplifyDPStep(points, first, last, sqTolerance, simplified) {
var maxSqDist = sqTolerance,
index;
for (var i = first + 1; i < last; i++) {
var sqDist = getSqSegDist(points[i], points[first], points[last]);
if (sqDist > maxSqDist) {
index = i;
maxSqDist = sqDist;
}
}
if (maxSqDist > sqTolerance) {
if (index - first > 1) simplifyDPStep(points, first, index, sqTolerance, simplified);
simplified.push(points[index]);
if (last - index > 1) simplifyDPStep(points, index, last, sqTolerance, simplified);
}
}
// simplification using Ramer-Douglas-Peucker algorithm
function simplifyDouglasPeucker(points, sqTolerance) {
var last = points.length - 1;
var simplified = [points[0]];
simplifyDPStep(points, 0, last, sqTolerance, simplified);
simplified.push(points[last]);
return simplified;
}
// both algorithms combined for awesome performance
function simplify(points, tolerance, highestQuality) {
if (points.length <= 2) return points;
var sqTolerance = tolerance !== undefined ? tolerance * tolerance : 1;
points = highestQuality ? points : simplifyRadialDist(points, sqTolerance);
points = simplifyDouglasPeucker(points, sqTolerance);
return points;
}
// export as AMD module / Node module / browser or worker variable
if (true) !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() { return simplify; }).call(exports, __webpack_require__, exports, module),
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
else {}
})();
/***/ }),
/* 8 */
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "round": () => (/* binding */ round),
/* harmony export */ "concat": () => (/* binding */ concat)
/* harmony export */ });
const round = (value, decimals) => Math.round(value * 10 ** decimals) / 10 ** decimals;
const concat = (result, data) => {
if (typeof data === 'string')
result.push(data);
else
data.forEach(line => result.push(line));
};
//# sourceMappingURL=utilities.js.map
/***/ })
/******/ ]);
/************************************************************************/
/******/ // The module cache
/******/ var __webpack_module_cache__ = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ var cachedModule = __webpack_module_cache__[moduleId];
/******/ if (cachedModule !== undefined) {
/******/ return cachedModule.exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = __webpack_module_cache__[moduleId] = {
/******/ // no module.id needed
/******/ // no module.loaded needed
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/************************************************************************/
/******/ /* webpack/runtime/compat get default export */
/******/ (() => {
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = (module) => {
/******/ var getter = module && module.__esModule ?
/******/ () => (module['default']) :
/******/ () => (module);
/******/ __webpack_require__.d(getter, { a: getter });
/******/ return getter;
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/define property getters */
/******/ (() => {
/******/ // define getter