完成世界书、骰子、apiconfig页面处理
This commit is contained in:
82
frontend/node_modules/robust-predicates/README.md
generated
vendored
Normal file
82
frontend/node_modules/robust-predicates/README.md
generated
vendored
Normal file
@@ -0,0 +1,82 @@
|
||||
# robust-predicates
|
||||
|
||||
Fast robust predicates for computational geometry in JavaScript. Provides reliable 2D and 3D point orientation tests (`orient2d`, `orient3d`, `incircle`, `insphere`) that are not susceptible to floating point errors (without sacrificing performance). A modern port of [Jonathan R Shewchuk's C code](https://www.cs.cmu.edu/~quake/robust.html), an industry standard since 1996.
|
||||
|
||||
<a href="https://observablehq.com/@mourner/non-robust-arithmetic-as-art"><img width="600" height="200" src="predicates.png" /></a>
|
||||
|
||||
_Figure: non-robust vs robust `orient2d` test for points within a tiny range (2<sup>-42</sup>)._
|
||||
|
||||
[](https://github.com/mourner/robust-predicates/actions)
|
||||
[](https://github.com/mourner/projects)
|
||||
[](https://unpkg.com/robust-predicates)
|
||||
|
||||
## [Demo](https://observablehq.com/@mourner/non-robust-arithmetic-as-art)
|
||||
|
||||
## API
|
||||
|
||||
Note: unlike J. Shewchuk's original code, all the functions in this library assume `y` axis is oriented _downwards_ ↓, so the semantics are different.
|
||||
|
||||
### `orient2d(ax,ay, bx,by, cx,cy)`
|
||||
|
||||
- Returns a *positive* value if the points `a`, `b`, and `c` occur in _counterclockwise_ order (`c` lies to the left of the directed line defined by points `a` and `b`).
|
||||
- Returns a *negative* value if they occur in _clockwise_ order (`c` lies to the right of the directed line `ab`).
|
||||
- Returns *zero* if they are _collinear_.
|
||||
|
||||
The result is also an approximation of twice the signed area of the triangle defined by the three points.
|
||||
|
||||
### `incircle(ax,ay, bx,by, cx,cy, dx,dy)`
|
||||
|
||||
- Returns a _positive_ value if the point `d` lies _outside_ the circle passing through `a`, `b`, and `c`.
|
||||
- Returns a _negative_ value if it lies _inside_.
|
||||
- Returns _zero_ if the four points are _cocircular_.
|
||||
|
||||
The points `a`, `b`, and `c` must be in _counterclockwise_ order, or the sign of the result will be reversed.
|
||||
|
||||
### `orient3d(ax,ay,az, bx,by,bz, cx,cy,cz, dx,dy,dz)`
|
||||
|
||||
- Returns a _positive_ value if the point `d` lies _above_ the plane passing through `a`, `b`, and `c`, meaning that `a`, `b`, and `c` appear in counterclockwise order when viewed from `d`.
|
||||
- Returns a _negative_ value if `d` lies _below_ the plane.
|
||||
- Returns _zero_ if the points are _coplanar_.
|
||||
|
||||
The result is also an approximation of six times the signed volume of the tetrahedron defined by the four points.
|
||||
|
||||
### `insphere(ax,ay,az, bx,by,bz, cx,cy,cz, dx,dy,dz, ex,ey,ez)`
|
||||
|
||||
- Returns a _positive_ value if the point `e` lies _outside_ the sphere passing through `a`, `b`, `c`, and `d`.
|
||||
- Returns a _negative_ value if it lies _inside_.
|
||||
- Returns _zero_ if the five points are _cospherical_.
|
||||
|
||||
The points `a`, `b`, `c`, and `d` must be ordered so that they have a _positive orientation_
|
||||
(as defined by `orient3d`), or the sign of the result will be reversed.
|
||||
|
||||
### `orient2dfast`, `orient3dfast`, `incirclefast`, `inspherefast`
|
||||
|
||||
Simple, approximate, non-robust versions of predicates above. Use when robustness isn't needed.
|
||||
|
||||
## Example
|
||||
|
||||
```js
|
||||
import {orient2d} from 'robust-predicates';
|
||||
|
||||
const ccw = orient2d(ax, ay, bx, by, cx, cy) > 0;
|
||||
````
|
||||
|
||||
## Install
|
||||
|
||||
Install with `npm install robust-predicates` or `yarn add robust-predicates`, or use one of the browser builds:
|
||||
|
||||
- [predicates.min.js](https://unpkg.com/robust-predicates/umd/predicates.min.js) (all predicates)
|
||||
- [orient2d.min.js](https://unpkg.com/robust-predicates/umd/orient2d.min.js) (`orient2d`, `orient2dfast`)
|
||||
- [orient3d.min.js](https://unpkg.com/robust-predicates/umd/orient3d.min.js) (`orient3d`, `orient3dfast`)
|
||||
- [incircle.min.js](https://unpkg.com/robust-predicates/umd/incircle.min.js) (`incircle`, `incirclefast`)
|
||||
- [insphere.min.js](https://unpkg.com/robust-predicates/umd/insphere.min.js) (`insphere`, `inspherefast`)
|
||||
|
||||
## Thanks
|
||||
|
||||
This project is just a port — all the brilliant, hard work was done by [Jonathan Richard Shewchuk](https://people.eecs.berkeley.edu/~jrs/).
|
||||
|
||||
The port was also inspired by [Mikola Lysenko](https://twitter.com/MikolaLysenko)'s excellent [Robust Arithmetic Notes](https://github.com/mikolalysenko/robust-arithmetic-notes) and related projects like [robust-orientation](https://github.com/mikolalysenko/robust-orientation) and [robust-in-sphere](https://github.com/mikolalysenko/robust-in-sphere).
|
||||
|
||||
## License
|
||||
|
||||
Since the original code is in the public domain, this project follows the same choice. See [Unlicense](https://unlicense.org).
|
||||
462
frontend/node_modules/robust-predicates/esm/orient3d.js
generated
vendored
Normal file
462
frontend/node_modules/robust-predicates/esm/orient3d.js
generated
vendored
Normal file
@@ -0,0 +1,462 @@
|
||||
import {epsilon, splitter, resulterrbound, estimate, vec, sum, scale} from './util.js';
|
||||
|
||||
const o3derrboundA = (7 + 56 * epsilon) * epsilon;
|
||||
const o3derrboundB = (3 + 28 * epsilon) * epsilon;
|
||||
const o3derrboundC = (26 + 288 * epsilon) * epsilon * epsilon;
|
||||
|
||||
const bc = vec(4);
|
||||
const ca = vec(4);
|
||||
const ab = vec(4);
|
||||
const at_b = vec(4);
|
||||
const at_c = vec(4);
|
||||
const bt_c = vec(4);
|
||||
const bt_a = vec(4);
|
||||
const ct_a = vec(4);
|
||||
const ct_b = vec(4);
|
||||
const bct = vec(8);
|
||||
const cat = vec(8);
|
||||
const abt = vec(8);
|
||||
const u = vec(4);
|
||||
|
||||
const _8 = vec(8);
|
||||
const _8b = vec(8);
|
||||
const _16 = vec(8);
|
||||
const _12 = vec(12);
|
||||
|
||||
let fin = vec(192);
|
||||
let fin2 = vec(192);
|
||||
|
||||
function finadd(finlen, alen, a) {
|
||||
finlen = sum(finlen, fin, alen, a, fin2);
|
||||
const tmp = fin; fin = fin2; fin2 = tmp;
|
||||
return finlen;
|
||||
}
|
||||
|
||||
function tailinit(xtail, ytail, ax, ay, bx, by, a, b) {
|
||||
let bvirt, c, ahi, alo, bhi, blo, _i, _j, _k, _0, s1, s0, t1, t0, u3, negate;
|
||||
if (xtail === 0) {
|
||||
if (ytail === 0) {
|
||||
a[0] = 0;
|
||||
b[0] = 0;
|
||||
return 1;
|
||||
} else {
|
||||
negate = -ytail;
|
||||
s1 = negate * ax;
|
||||
c = splitter * negate;
|
||||
ahi = c - (c - negate);
|
||||
alo = negate - ahi;
|
||||
c = splitter * ax;
|
||||
bhi = c - (c - ax);
|
||||
blo = ax - bhi;
|
||||
a[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
a[1] = s1;
|
||||
s1 = ytail * bx;
|
||||
c = splitter * ytail;
|
||||
ahi = c - (c - ytail);
|
||||
alo = ytail - ahi;
|
||||
c = splitter * bx;
|
||||
bhi = c - (c - bx);
|
||||
blo = bx - bhi;
|
||||
b[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
b[1] = s1;
|
||||
return 2;
|
||||
}
|
||||
} else {
|
||||
if (ytail === 0) {
|
||||
s1 = xtail * ay;
|
||||
c = splitter * xtail;
|
||||
ahi = c - (c - xtail);
|
||||
alo = xtail - ahi;
|
||||
c = splitter * ay;
|
||||
bhi = c - (c - ay);
|
||||
blo = ay - bhi;
|
||||
a[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
a[1] = s1;
|
||||
negate = -xtail;
|
||||
s1 = negate * by;
|
||||
c = splitter * negate;
|
||||
ahi = c - (c - negate);
|
||||
alo = negate - ahi;
|
||||
c = splitter * by;
|
||||
bhi = c - (c - by);
|
||||
blo = by - bhi;
|
||||
b[0] = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
b[1] = s1;
|
||||
return 2;
|
||||
} else {
|
||||
s1 = xtail * ay;
|
||||
c = splitter * xtail;
|
||||
ahi = c - (c - xtail);
|
||||
alo = xtail - ahi;
|
||||
c = splitter * ay;
|
||||
bhi = c - (c - ay);
|
||||
blo = ay - bhi;
|
||||
s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
t1 = ytail * ax;
|
||||
c = splitter * ytail;
|
||||
ahi = c - (c - ytail);
|
||||
alo = ytail - ahi;
|
||||
c = splitter * ax;
|
||||
bhi = c - (c - ax);
|
||||
blo = ax - bhi;
|
||||
t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_i = s0 - t0;
|
||||
bvirt = s0 - _i;
|
||||
a[0] = s0 - (_i + bvirt) + (bvirt - t0);
|
||||
_j = s1 + _i;
|
||||
bvirt = _j - s1;
|
||||
_0 = s1 - (_j - bvirt) + (_i - bvirt);
|
||||
_i = _0 - t1;
|
||||
bvirt = _0 - _i;
|
||||
a[1] = _0 - (_i + bvirt) + (bvirt - t1);
|
||||
u3 = _j + _i;
|
||||
bvirt = u3 - _j;
|
||||
a[2] = _j - (u3 - bvirt) + (_i - bvirt);
|
||||
a[3] = u3;
|
||||
s1 = ytail * bx;
|
||||
c = splitter * ytail;
|
||||
ahi = c - (c - ytail);
|
||||
alo = ytail - ahi;
|
||||
c = splitter * bx;
|
||||
bhi = c - (c - bx);
|
||||
blo = bx - bhi;
|
||||
s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
t1 = xtail * by;
|
||||
c = splitter * xtail;
|
||||
ahi = c - (c - xtail);
|
||||
alo = xtail - ahi;
|
||||
c = splitter * by;
|
||||
bhi = c - (c - by);
|
||||
blo = by - bhi;
|
||||
t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_i = s0 - t0;
|
||||
bvirt = s0 - _i;
|
||||
b[0] = s0 - (_i + bvirt) + (bvirt - t0);
|
||||
_j = s1 + _i;
|
||||
bvirt = _j - s1;
|
||||
_0 = s1 - (_j - bvirt) + (_i - bvirt);
|
||||
_i = _0 - t1;
|
||||
bvirt = _0 - _i;
|
||||
b[1] = _0 - (_i + bvirt) + (bvirt - t1);
|
||||
u3 = _j + _i;
|
||||
bvirt = u3 - _j;
|
||||
b[2] = _j - (u3 - bvirt) + (_i - bvirt);
|
||||
b[3] = u3;
|
||||
return 4;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function tailadd(finlen, a, b, k, z) {
|
||||
let bvirt, c, ahi, alo, bhi, blo, _i, _j, _k, _0, s1, s0, u3;
|
||||
s1 = a * b;
|
||||
c = splitter * a;
|
||||
ahi = c - (c - a);
|
||||
alo = a - ahi;
|
||||
c = splitter * b;
|
||||
bhi = c - (c - b);
|
||||
blo = b - bhi;
|
||||
s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
c = splitter * k;
|
||||
bhi = c - (c - k);
|
||||
blo = k - bhi;
|
||||
_i = s0 * k;
|
||||
c = splitter * s0;
|
||||
ahi = c - (c - s0);
|
||||
alo = s0 - ahi;
|
||||
u[0] = alo * blo - (_i - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_j = s1 * k;
|
||||
c = splitter * s1;
|
||||
ahi = c - (c - s1);
|
||||
alo = s1 - ahi;
|
||||
_0 = alo * blo - (_j - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_k = _i + _0;
|
||||
bvirt = _k - _i;
|
||||
u[1] = _i - (_k - bvirt) + (_0 - bvirt);
|
||||
u3 = _j + _k;
|
||||
u[2] = _k - (u3 - _j);
|
||||
u[3] = u3;
|
||||
finlen = finadd(finlen, 4, u);
|
||||
if (z !== 0) {
|
||||
c = splitter * z;
|
||||
bhi = c - (c - z);
|
||||
blo = z - bhi;
|
||||
_i = s0 * z;
|
||||
c = splitter * s0;
|
||||
ahi = c - (c - s0);
|
||||
alo = s0 - ahi;
|
||||
u[0] = alo * blo - (_i - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_j = s1 * z;
|
||||
c = splitter * s1;
|
||||
ahi = c - (c - s1);
|
||||
alo = s1 - ahi;
|
||||
_0 = alo * blo - (_j - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_k = _i + _0;
|
||||
bvirt = _k - _i;
|
||||
u[1] = _i - (_k - bvirt) + (_0 - bvirt);
|
||||
u3 = _j + _k;
|
||||
u[2] = _k - (u3 - _j);
|
||||
u[3] = u3;
|
||||
finlen = finadd(finlen, 4, u);
|
||||
}
|
||||
return finlen;
|
||||
}
|
||||
|
||||
function orient3dadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, permanent) {
|
||||
let finlen;
|
||||
let adxtail, bdxtail, cdxtail;
|
||||
let adytail, bdytail, cdytail;
|
||||
let adztail, bdztail, cdztail;
|
||||
let bvirt, c, ahi, alo, bhi, blo, _i, _j, _k, _0, s1, s0, t1, t0, u3;
|
||||
|
||||
const adx = ax - dx;
|
||||
const bdx = bx - dx;
|
||||
const cdx = cx - dx;
|
||||
const ady = ay - dy;
|
||||
const bdy = by - dy;
|
||||
const cdy = cy - dy;
|
||||
const adz = az - dz;
|
||||
const bdz = bz - dz;
|
||||
const cdz = cz - dz;
|
||||
|
||||
s1 = bdx * cdy;
|
||||
c = splitter * bdx;
|
||||
ahi = c - (c - bdx);
|
||||
alo = bdx - ahi;
|
||||
c = splitter * cdy;
|
||||
bhi = c - (c - cdy);
|
||||
blo = cdy - bhi;
|
||||
s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
t1 = cdx * bdy;
|
||||
c = splitter * cdx;
|
||||
ahi = c - (c - cdx);
|
||||
alo = cdx - ahi;
|
||||
c = splitter * bdy;
|
||||
bhi = c - (c - bdy);
|
||||
blo = bdy - bhi;
|
||||
t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_i = s0 - t0;
|
||||
bvirt = s0 - _i;
|
||||
bc[0] = s0 - (_i + bvirt) + (bvirt - t0);
|
||||
_j = s1 + _i;
|
||||
bvirt = _j - s1;
|
||||
_0 = s1 - (_j - bvirt) + (_i - bvirt);
|
||||
_i = _0 - t1;
|
||||
bvirt = _0 - _i;
|
||||
bc[1] = _0 - (_i + bvirt) + (bvirt - t1);
|
||||
u3 = _j + _i;
|
||||
bvirt = u3 - _j;
|
||||
bc[2] = _j - (u3 - bvirt) + (_i - bvirt);
|
||||
bc[3] = u3;
|
||||
s1 = cdx * ady;
|
||||
c = splitter * cdx;
|
||||
ahi = c - (c - cdx);
|
||||
alo = cdx - ahi;
|
||||
c = splitter * ady;
|
||||
bhi = c - (c - ady);
|
||||
blo = ady - bhi;
|
||||
s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
t1 = adx * cdy;
|
||||
c = splitter * adx;
|
||||
ahi = c - (c - adx);
|
||||
alo = adx - ahi;
|
||||
c = splitter * cdy;
|
||||
bhi = c - (c - cdy);
|
||||
blo = cdy - bhi;
|
||||
t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_i = s0 - t0;
|
||||
bvirt = s0 - _i;
|
||||
ca[0] = s0 - (_i + bvirt) + (bvirt - t0);
|
||||
_j = s1 + _i;
|
||||
bvirt = _j - s1;
|
||||
_0 = s1 - (_j - bvirt) + (_i - bvirt);
|
||||
_i = _0 - t1;
|
||||
bvirt = _0 - _i;
|
||||
ca[1] = _0 - (_i + bvirt) + (bvirt - t1);
|
||||
u3 = _j + _i;
|
||||
bvirt = u3 - _j;
|
||||
ca[2] = _j - (u3 - bvirt) + (_i - bvirt);
|
||||
ca[3] = u3;
|
||||
s1 = adx * bdy;
|
||||
c = splitter * adx;
|
||||
ahi = c - (c - adx);
|
||||
alo = adx - ahi;
|
||||
c = splitter * bdy;
|
||||
bhi = c - (c - bdy);
|
||||
blo = bdy - bhi;
|
||||
s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
t1 = bdx * ady;
|
||||
c = splitter * bdx;
|
||||
ahi = c - (c - bdx);
|
||||
alo = bdx - ahi;
|
||||
c = splitter * ady;
|
||||
bhi = c - (c - ady);
|
||||
blo = ady - bhi;
|
||||
t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_i = s0 - t0;
|
||||
bvirt = s0 - _i;
|
||||
ab[0] = s0 - (_i + bvirt) + (bvirt - t0);
|
||||
_j = s1 + _i;
|
||||
bvirt = _j - s1;
|
||||
_0 = s1 - (_j - bvirt) + (_i - bvirt);
|
||||
_i = _0 - t1;
|
||||
bvirt = _0 - _i;
|
||||
ab[1] = _0 - (_i + bvirt) + (bvirt - t1);
|
||||
u3 = _j + _i;
|
||||
bvirt = u3 - _j;
|
||||
ab[2] = _j - (u3 - bvirt) + (_i - bvirt);
|
||||
ab[3] = u3;
|
||||
|
||||
finlen = sum(
|
||||
sum(
|
||||
scale(4, bc, adz, _8), _8,
|
||||
scale(4, ca, bdz, _8b), _8b, _16), _16,
|
||||
scale(4, ab, cdz, _8), _8, fin);
|
||||
|
||||
let det = estimate(finlen, fin);
|
||||
let errbound = o3derrboundB * permanent;
|
||||
if (det >= errbound || -det >= errbound) {
|
||||
return det;
|
||||
}
|
||||
|
||||
bvirt = ax - adx;
|
||||
adxtail = ax - (adx + bvirt) + (bvirt - dx);
|
||||
bvirt = bx - bdx;
|
||||
bdxtail = bx - (bdx + bvirt) + (bvirt - dx);
|
||||
bvirt = cx - cdx;
|
||||
cdxtail = cx - (cdx + bvirt) + (bvirt - dx);
|
||||
bvirt = ay - ady;
|
||||
adytail = ay - (ady + bvirt) + (bvirt - dy);
|
||||
bvirt = by - bdy;
|
||||
bdytail = by - (bdy + bvirt) + (bvirt - dy);
|
||||
bvirt = cy - cdy;
|
||||
cdytail = cy - (cdy + bvirt) + (bvirt - dy);
|
||||
bvirt = az - adz;
|
||||
adztail = az - (adz + bvirt) + (bvirt - dz);
|
||||
bvirt = bz - bdz;
|
||||
bdztail = bz - (bdz + bvirt) + (bvirt - dz);
|
||||
bvirt = cz - cdz;
|
||||
cdztail = cz - (cdz + bvirt) + (bvirt - dz);
|
||||
|
||||
if (adxtail === 0 && bdxtail === 0 && cdxtail === 0 &&
|
||||
adytail === 0 && bdytail === 0 && cdytail === 0 &&
|
||||
adztail === 0 && bdztail === 0 && cdztail === 0) {
|
||||
return det;
|
||||
}
|
||||
|
||||
errbound = o3derrboundC * permanent + resulterrbound * Math.abs(det);
|
||||
det +=
|
||||
adz * (bdx * cdytail + cdy * bdxtail - (bdy * cdxtail + cdx * bdytail)) + adztail * (bdx * cdy - bdy * cdx) +
|
||||
bdz * (cdx * adytail + ady * cdxtail - (cdy * adxtail + adx * cdytail)) + bdztail * (cdx * ady - cdy * adx) +
|
||||
cdz * (adx * bdytail + bdy * adxtail - (ady * bdxtail + bdx * adytail)) + cdztail * (adx * bdy - ady * bdx);
|
||||
if (det >= errbound || -det >= errbound) {
|
||||
return det;
|
||||
}
|
||||
|
||||
const at_len = tailinit(adxtail, adytail, bdx, bdy, cdx, cdy, at_b, at_c);
|
||||
const bt_len = tailinit(bdxtail, bdytail, cdx, cdy, adx, ady, bt_c, bt_a);
|
||||
const ct_len = tailinit(cdxtail, cdytail, adx, ady, bdx, bdy, ct_a, ct_b);
|
||||
|
||||
const bctlen = sum(bt_len, bt_c, ct_len, ct_b, bct);
|
||||
finlen = finadd(finlen, scale(bctlen, bct, adz, _16), _16);
|
||||
|
||||
const catlen = sum(ct_len, ct_a, at_len, at_c, cat);
|
||||
finlen = finadd(finlen, scale(catlen, cat, bdz, _16), _16);
|
||||
|
||||
const abtlen = sum(at_len, at_b, bt_len, bt_a, abt);
|
||||
finlen = finadd(finlen, scale(abtlen, abt, cdz, _16), _16);
|
||||
|
||||
if (adztail !== 0) {
|
||||
finlen = finadd(finlen, scale(4, bc, adztail, _12), _12);
|
||||
finlen = finadd(finlen, scale(bctlen, bct, adztail, _16), _16);
|
||||
}
|
||||
if (bdztail !== 0) {
|
||||
finlen = finadd(finlen, scale(4, ca, bdztail, _12), _12);
|
||||
finlen = finadd(finlen, scale(catlen, cat, bdztail, _16), _16);
|
||||
}
|
||||
if (cdztail !== 0) {
|
||||
finlen = finadd(finlen, scale(4, ab, cdztail, _12), _12);
|
||||
finlen = finadd(finlen, scale(abtlen, abt, cdztail, _16), _16);
|
||||
}
|
||||
|
||||
if (adxtail !== 0) {
|
||||
if (bdytail !== 0) {
|
||||
finlen = tailadd(finlen, adxtail, bdytail, cdz, cdztail);
|
||||
}
|
||||
if (cdytail !== 0) {
|
||||
finlen = tailadd(finlen, -adxtail, cdytail, bdz, bdztail);
|
||||
}
|
||||
}
|
||||
if (bdxtail !== 0) {
|
||||
if (cdytail !== 0) {
|
||||
finlen = tailadd(finlen, bdxtail, cdytail, adz, adztail);
|
||||
}
|
||||
if (adytail !== 0) {
|
||||
finlen = tailadd(finlen, -bdxtail, adytail, cdz, cdztail);
|
||||
}
|
||||
}
|
||||
if (cdxtail !== 0) {
|
||||
if (adytail !== 0) {
|
||||
finlen = tailadd(finlen, cdxtail, adytail, bdz, bdztail);
|
||||
}
|
||||
if (bdytail !== 0) {
|
||||
finlen = tailadd(finlen, -cdxtail, bdytail, adz, adztail);
|
||||
}
|
||||
}
|
||||
|
||||
return fin[finlen - 1];
|
||||
}
|
||||
|
||||
export function orient3d(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz) {
|
||||
const adx = ax - dx;
|
||||
const bdx = bx - dx;
|
||||
const cdx = cx - dx;
|
||||
const ady = ay - dy;
|
||||
const bdy = by - dy;
|
||||
const cdy = cy - dy;
|
||||
const adz = az - dz;
|
||||
const bdz = bz - dz;
|
||||
const cdz = cz - dz;
|
||||
|
||||
const bdxcdy = bdx * cdy;
|
||||
const cdxbdy = cdx * bdy;
|
||||
|
||||
const cdxady = cdx * ady;
|
||||
const adxcdy = adx * cdy;
|
||||
|
||||
const adxbdy = adx * bdy;
|
||||
const bdxady = bdx * ady;
|
||||
|
||||
const det =
|
||||
adz * (bdxcdy - cdxbdy) +
|
||||
bdz * (cdxady - adxcdy) +
|
||||
cdz * (adxbdy - bdxady);
|
||||
|
||||
const permanent =
|
||||
(Math.abs(bdxcdy) + Math.abs(cdxbdy)) * Math.abs(adz) +
|
||||
(Math.abs(cdxady) + Math.abs(adxcdy)) * Math.abs(bdz) +
|
||||
(Math.abs(adxbdy) + Math.abs(bdxady)) * Math.abs(cdz);
|
||||
|
||||
const errbound = o3derrboundA * permanent;
|
||||
if (det > errbound || -det > errbound) {
|
||||
return det;
|
||||
}
|
||||
|
||||
return orient3dadapt(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz, permanent);
|
||||
}
|
||||
|
||||
export function orient3dfast(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz) {
|
||||
const adx = ax - dx;
|
||||
const bdx = bx - dx;
|
||||
const cdx = cx - dx;
|
||||
const ady = ay - dy;
|
||||
const bdy = by - dy;
|
||||
const cdy = cy - dy;
|
||||
const adz = az - dz;
|
||||
const bdz = bz - dz;
|
||||
const cdz = cz - dz;
|
||||
|
||||
return adx * (bdy * cdz - bdz * cdy) +
|
||||
bdx * (cdy * adz - cdz * ady) +
|
||||
cdx * (ady * bdz - adz * bdy);
|
||||
}
|
||||
908
frontend/node_modules/robust-predicates/umd/incircle.js
generated
vendored
Normal file
908
frontend/node_modules/robust-predicates/umd/incircle.js
generated
vendored
Normal file
@@ -0,0 +1,908 @@
|
||||
(function (global, factory) {
|
||||
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
|
||||
typeof define === 'function' && define.amd ? define(['exports'], factory) :
|
||||
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.predicates = {}));
|
||||
})(this, (function (exports) { 'use strict';
|
||||
|
||||
const epsilon = 1.1102230246251565e-16;
|
||||
const splitter = 134217729;
|
||||
const resulterrbound = (3 + 8 * epsilon) * epsilon;
|
||||
|
||||
// fast_expansion_sum_zeroelim routine from oritinal code
|
||||
function sum(elen, e, flen, f, h) {
|
||||
let Q, Qnew, hh, bvirt;
|
||||
let enow = e[0];
|
||||
let fnow = f[0];
|
||||
let eindex = 0;
|
||||
let findex = 0;
|
||||
if ((fnow > enow) === (fnow > -enow)) {
|
||||
Q = enow;
|
||||
enow = e[++eindex];
|
||||
} else {
|
||||
Q = fnow;
|
||||
fnow = f[++findex];
|
||||
}
|
||||
let hindex = 0;
|
||||
if (eindex < elen && findex < flen) {
|
||||
if ((fnow > enow) === (fnow > -enow)) {
|
||||
Qnew = enow + Q;
|
||||
hh = Q - (Qnew - enow);
|
||||
enow = e[++eindex];
|
||||
} else {
|
||||
Qnew = fnow + Q;
|
||||
hh = Q - (Qnew - fnow);
|
||||
fnow = f[++findex];
|
||||
}
|
||||
Q = Qnew;
|
||||
if (hh !== 0) {
|
||||
h[hindex++] = hh;
|
||||
}
|
||||
while (eindex < elen && findex < flen) {
|
||||
if ((fnow > enow) === (fnow > -enow)) {
|
||||
Qnew = Q + enow;
|
||||
bvirt = Qnew - Q;
|
||||
hh = Q - (Qnew - bvirt) + (enow - bvirt);
|
||||
enow = e[++eindex];
|
||||
} else {
|
||||
Qnew = Q + fnow;
|
||||
bvirt = Qnew - Q;
|
||||
hh = Q - (Qnew - bvirt) + (fnow - bvirt);
|
||||
fnow = f[++findex];
|
||||
}
|
||||
Q = Qnew;
|
||||
if (hh !== 0) {
|
||||
h[hindex++] = hh;
|
||||
}
|
||||
}
|
||||
}
|
||||
while (eindex < elen) {
|
||||
Qnew = Q + enow;
|
||||
bvirt = Qnew - Q;
|
||||
hh = Q - (Qnew - bvirt) + (enow - bvirt);
|
||||
enow = e[++eindex];
|
||||
Q = Qnew;
|
||||
if (hh !== 0) {
|
||||
h[hindex++] = hh;
|
||||
}
|
||||
}
|
||||
while (findex < flen) {
|
||||
Qnew = Q + fnow;
|
||||
bvirt = Qnew - Q;
|
||||
hh = Q - (Qnew - bvirt) + (fnow - bvirt);
|
||||
fnow = f[++findex];
|
||||
Q = Qnew;
|
||||
if (hh !== 0) {
|
||||
h[hindex++] = hh;
|
||||
}
|
||||
}
|
||||
if (Q !== 0 || hindex === 0) {
|
||||
h[hindex++] = Q;
|
||||
}
|
||||
return hindex;
|
||||
}
|
||||
|
||||
function sum_three(alen, a, blen, b, clen, c, tmp, out) {
|
||||
return sum(sum(alen, a, blen, b, tmp), tmp, clen, c, out);
|
||||
}
|
||||
|
||||
// scale_expansion_zeroelim routine from oritinal code
|
||||
function scale(elen, e, b, h) {
|
||||
let Q, sum, hh, product1, product0;
|
||||
let bvirt, c, ahi, alo, bhi, blo;
|
||||
|
||||
c = splitter * b;
|
||||
bhi = c - (c - b);
|
||||
blo = b - bhi;
|
||||
let enow = e[0];
|
||||
Q = enow * b;
|
||||
c = splitter * enow;
|
||||
ahi = c - (c - enow);
|
||||
alo = enow - ahi;
|
||||
hh = alo * blo - (Q - ahi * bhi - alo * bhi - ahi * blo);
|
||||
let hindex = 0;
|
||||
if (hh !== 0) {
|
||||
h[hindex++] = hh;
|
||||
}
|
||||
for (let i = 1; i < elen; i++) {
|
||||
enow = e[i];
|
||||
product1 = enow * b;
|
||||
c = splitter * enow;
|
||||
ahi = c - (c - enow);
|
||||
alo = enow - ahi;
|
||||
product0 = alo * blo - (product1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
sum = Q + product0;
|
||||
bvirt = sum - Q;
|
||||
hh = Q - (sum - bvirt) + (product0 - bvirt);
|
||||
if (hh !== 0) {
|
||||
h[hindex++] = hh;
|
||||
}
|
||||
Q = product1 + sum;
|
||||
hh = sum - (Q - product1);
|
||||
if (hh !== 0) {
|
||||
h[hindex++] = hh;
|
||||
}
|
||||
}
|
||||
if (Q !== 0 || hindex === 0) {
|
||||
h[hindex++] = Q;
|
||||
}
|
||||
return hindex;
|
||||
}
|
||||
|
||||
function estimate(elen, e) {
|
||||
let Q = e[0];
|
||||
for (let i = 1; i < elen; i++) Q += e[i];
|
||||
return Q;
|
||||
}
|
||||
|
||||
function vec(n) {
|
||||
return new Float64Array(n);
|
||||
}
|
||||
|
||||
const iccerrboundA = (10 + 96 * epsilon) * epsilon;
|
||||
const iccerrboundB = (4 + 48 * epsilon) * epsilon;
|
||||
const iccerrboundC = (44 + 576 * epsilon) * epsilon * epsilon;
|
||||
|
||||
const bc = vec(4);
|
||||
const ca = vec(4);
|
||||
const ab = vec(4);
|
||||
const aa = vec(4);
|
||||
const bb = vec(4);
|
||||
const cc = vec(4);
|
||||
const u = vec(4);
|
||||
const v = vec(4);
|
||||
const axtbc = vec(8);
|
||||
const aytbc = vec(8);
|
||||
const bxtca = vec(8);
|
||||
const bytca = vec(8);
|
||||
const cxtab = vec(8);
|
||||
const cytab = vec(8);
|
||||
const abt = vec(8);
|
||||
const bct = vec(8);
|
||||
const cat = vec(8);
|
||||
const abtt = vec(4);
|
||||
const bctt = vec(4);
|
||||
const catt = vec(4);
|
||||
|
||||
const _8 = vec(8);
|
||||
const _16 = vec(16);
|
||||
const _16b = vec(16);
|
||||
const _16c = vec(16);
|
||||
const _32 = vec(32);
|
||||
const _32b = vec(32);
|
||||
const _48 = vec(48);
|
||||
const _64 = vec(64);
|
||||
|
||||
let fin = vec(1152);
|
||||
let fin2 = vec(1152);
|
||||
|
||||
function finadd(finlen, a, alen) {
|
||||
finlen = sum(finlen, fin, a, alen, fin2);
|
||||
const tmp = fin; fin = fin2; fin2 = tmp;
|
||||
return finlen;
|
||||
}
|
||||
|
||||
function incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent) {
|
||||
let finlen;
|
||||
let adxtail, bdxtail, cdxtail, adytail, bdytail, cdytail;
|
||||
let axtbclen, aytbclen, bxtcalen, bytcalen, cxtablen, cytablen;
|
||||
let abtlen, bctlen, catlen;
|
||||
let abttlen, bcttlen, cattlen;
|
||||
let n1, n0;
|
||||
|
||||
let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;
|
||||
|
||||
const adx = ax - dx;
|
||||
const bdx = bx - dx;
|
||||
const cdx = cx - dx;
|
||||
const ady = ay - dy;
|
||||
const bdy = by - dy;
|
||||
const cdy = cy - dy;
|
||||
|
||||
s1 = bdx * cdy;
|
||||
c = splitter * bdx;
|
||||
ahi = c - (c - bdx);
|
||||
alo = bdx - ahi;
|
||||
c = splitter * cdy;
|
||||
bhi = c - (c - cdy);
|
||||
blo = cdy - bhi;
|
||||
s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
t1 = cdx * bdy;
|
||||
c = splitter * cdx;
|
||||
ahi = c - (c - cdx);
|
||||
alo = cdx - ahi;
|
||||
c = splitter * bdy;
|
||||
bhi = c - (c - bdy);
|
||||
blo = bdy - bhi;
|
||||
t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_i = s0 - t0;
|
||||
bvirt = s0 - _i;
|
||||
bc[0] = s0 - (_i + bvirt) + (bvirt - t0);
|
||||
_j = s1 + _i;
|
||||
bvirt = _j - s1;
|
||||
_0 = s1 - (_j - bvirt) + (_i - bvirt);
|
||||
_i = _0 - t1;
|
||||
bvirt = _0 - _i;
|
||||
bc[1] = _0 - (_i + bvirt) + (bvirt - t1);
|
||||
u3 = _j + _i;
|
||||
bvirt = u3 - _j;
|
||||
bc[2] = _j - (u3 - bvirt) + (_i - bvirt);
|
||||
bc[3] = u3;
|
||||
s1 = cdx * ady;
|
||||
c = splitter * cdx;
|
||||
ahi = c - (c - cdx);
|
||||
alo = cdx - ahi;
|
||||
c = splitter * ady;
|
||||
bhi = c - (c - ady);
|
||||
blo = ady - bhi;
|
||||
s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
t1 = adx * cdy;
|
||||
c = splitter * adx;
|
||||
ahi = c - (c - adx);
|
||||
alo = adx - ahi;
|
||||
c = splitter * cdy;
|
||||
bhi = c - (c - cdy);
|
||||
blo = cdy - bhi;
|
||||
t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_i = s0 - t0;
|
||||
bvirt = s0 - _i;
|
||||
ca[0] = s0 - (_i + bvirt) + (bvirt - t0);
|
||||
_j = s1 + _i;
|
||||
bvirt = _j - s1;
|
||||
_0 = s1 - (_j - bvirt) + (_i - bvirt);
|
||||
_i = _0 - t1;
|
||||
bvirt = _0 - _i;
|
||||
ca[1] = _0 - (_i + bvirt) + (bvirt - t1);
|
||||
u3 = _j + _i;
|
||||
bvirt = u3 - _j;
|
||||
ca[2] = _j - (u3 - bvirt) + (_i - bvirt);
|
||||
ca[3] = u3;
|
||||
s1 = adx * bdy;
|
||||
c = splitter * adx;
|
||||
ahi = c - (c - adx);
|
||||
alo = adx - ahi;
|
||||
c = splitter * bdy;
|
||||
bhi = c - (c - bdy);
|
||||
blo = bdy - bhi;
|
||||
s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
t1 = bdx * ady;
|
||||
c = splitter * bdx;
|
||||
ahi = c - (c - bdx);
|
||||
alo = bdx - ahi;
|
||||
c = splitter * ady;
|
||||
bhi = c - (c - ady);
|
||||
blo = ady - bhi;
|
||||
t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_i = s0 - t0;
|
||||
bvirt = s0 - _i;
|
||||
ab[0] = s0 - (_i + bvirt) + (bvirt - t0);
|
||||
_j = s1 + _i;
|
||||
bvirt = _j - s1;
|
||||
_0 = s1 - (_j - bvirt) + (_i - bvirt);
|
||||
_i = _0 - t1;
|
||||
bvirt = _0 - _i;
|
||||
ab[1] = _0 - (_i + bvirt) + (bvirt - t1);
|
||||
u3 = _j + _i;
|
||||
bvirt = u3 - _j;
|
||||
ab[2] = _j - (u3 - bvirt) + (_i - bvirt);
|
||||
ab[3] = u3;
|
||||
|
||||
finlen = sum(
|
||||
sum(
|
||||
sum(
|
||||
scale(scale(4, bc, adx, _8), _8, adx, _16), _16,
|
||||
scale(scale(4, bc, ady, _8), _8, ady, _16b), _16b, _32), _32,
|
||||
sum(
|
||||
scale(scale(4, ca, bdx, _8), _8, bdx, _16), _16,
|
||||
scale(scale(4, ca, bdy, _8), _8, bdy, _16b), _16b, _32b), _32b, _64), _64,
|
||||
sum(
|
||||
scale(scale(4, ab, cdx, _8), _8, cdx, _16), _16,
|
||||
scale(scale(4, ab, cdy, _8), _8, cdy, _16b), _16b, _32), _32, fin);
|
||||
|
||||
let det = estimate(finlen, fin);
|
||||
let errbound = iccerrboundB * permanent;
|
||||
if (det >= errbound || -det >= errbound) {
|
||||
return det;
|
||||
}
|
||||
|
||||
bvirt = ax - adx;
|
||||
adxtail = ax - (adx + bvirt) + (bvirt - dx);
|
||||
bvirt = ay - ady;
|
||||
adytail = ay - (ady + bvirt) + (bvirt - dy);
|
||||
bvirt = bx - bdx;
|
||||
bdxtail = bx - (bdx + bvirt) + (bvirt - dx);
|
||||
bvirt = by - bdy;
|
||||
bdytail = by - (bdy + bvirt) + (bvirt - dy);
|
||||
bvirt = cx - cdx;
|
||||
cdxtail = cx - (cdx + bvirt) + (bvirt - dx);
|
||||
bvirt = cy - cdy;
|
||||
cdytail = cy - (cdy + bvirt) + (bvirt - dy);
|
||||
if (adxtail === 0 && bdxtail === 0 && cdxtail === 0 && adytail === 0 && bdytail === 0 && cdytail === 0) {
|
||||
return det;
|
||||
}
|
||||
|
||||
errbound = iccerrboundC * permanent + resulterrbound * Math.abs(det);
|
||||
det += ((adx * adx + ady * ady) * ((bdx * cdytail + cdy * bdxtail) - (bdy * cdxtail + cdx * bdytail)) +
|
||||
2 * (adx * adxtail + ady * adytail) * (bdx * cdy - bdy * cdx)) +
|
||||
((bdx * bdx + bdy * bdy) * ((cdx * adytail + ady * cdxtail) - (cdy * adxtail + adx * cdytail)) +
|
||||
2 * (bdx * bdxtail + bdy * bdytail) * (cdx * ady - cdy * adx)) +
|
||||
((cdx * cdx + cdy * cdy) * ((adx * bdytail + bdy * adxtail) - (ady * bdxtail + bdx * adytail)) +
|
||||
2 * (cdx * cdxtail + cdy * cdytail) * (adx * bdy - ady * bdx));
|
||||
|
||||
if (det >= errbound || -det >= errbound) {
|
||||
return det;
|
||||
}
|
||||
|
||||
if (bdxtail !== 0 || bdytail !== 0 || cdxtail !== 0 || cdytail !== 0) {
|
||||
s1 = adx * adx;
|
||||
c = splitter * adx;
|
||||
ahi = c - (c - adx);
|
||||
alo = adx - ahi;
|
||||
s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);
|
||||
t1 = ady * ady;
|
||||
c = splitter * ady;
|
||||
ahi = c - (c - ady);
|
||||
alo = ady - ahi;
|
||||
t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);
|
||||
_i = s0 + t0;
|
||||
bvirt = _i - s0;
|
||||
aa[0] = s0 - (_i - bvirt) + (t0 - bvirt);
|
||||
_j = s1 + _i;
|
||||
bvirt = _j - s1;
|
||||
_0 = s1 - (_j - bvirt) + (_i - bvirt);
|
||||
_i = _0 + t1;
|
||||
bvirt = _i - _0;
|
||||
aa[1] = _0 - (_i - bvirt) + (t1 - bvirt);
|
||||
u3 = _j + _i;
|
||||
bvirt = u3 - _j;
|
||||
aa[2] = _j - (u3 - bvirt) + (_i - bvirt);
|
||||
aa[3] = u3;
|
||||
}
|
||||
if (cdxtail !== 0 || cdytail !== 0 || adxtail !== 0 || adytail !== 0) {
|
||||
s1 = bdx * bdx;
|
||||
c = splitter * bdx;
|
||||
ahi = c - (c - bdx);
|
||||
alo = bdx - ahi;
|
||||
s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);
|
||||
t1 = bdy * bdy;
|
||||
c = splitter * bdy;
|
||||
ahi = c - (c - bdy);
|
||||
alo = bdy - ahi;
|
||||
t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);
|
||||
_i = s0 + t0;
|
||||
bvirt = _i - s0;
|
||||
bb[0] = s0 - (_i - bvirt) + (t0 - bvirt);
|
||||
_j = s1 + _i;
|
||||
bvirt = _j - s1;
|
||||
_0 = s1 - (_j - bvirt) + (_i - bvirt);
|
||||
_i = _0 + t1;
|
||||
bvirt = _i - _0;
|
||||
bb[1] = _0 - (_i - bvirt) + (t1 - bvirt);
|
||||
u3 = _j + _i;
|
||||
bvirt = u3 - _j;
|
||||
bb[2] = _j - (u3 - bvirt) + (_i - bvirt);
|
||||
bb[3] = u3;
|
||||
}
|
||||
if (adxtail !== 0 || adytail !== 0 || bdxtail !== 0 || bdytail !== 0) {
|
||||
s1 = cdx * cdx;
|
||||
c = splitter * cdx;
|
||||
ahi = c - (c - cdx);
|
||||
alo = cdx - ahi;
|
||||
s0 = alo * alo - (s1 - ahi * ahi - (ahi + ahi) * alo);
|
||||
t1 = cdy * cdy;
|
||||
c = splitter * cdy;
|
||||
ahi = c - (c - cdy);
|
||||
alo = cdy - ahi;
|
||||
t0 = alo * alo - (t1 - ahi * ahi - (ahi + ahi) * alo);
|
||||
_i = s0 + t0;
|
||||
bvirt = _i - s0;
|
||||
cc[0] = s0 - (_i - bvirt) + (t0 - bvirt);
|
||||
_j = s1 + _i;
|
||||
bvirt = _j - s1;
|
||||
_0 = s1 - (_j - bvirt) + (_i - bvirt);
|
||||
_i = _0 + t1;
|
||||
bvirt = _i - _0;
|
||||
cc[1] = _0 - (_i - bvirt) + (t1 - bvirt);
|
||||
u3 = _j + _i;
|
||||
bvirt = u3 - _j;
|
||||
cc[2] = _j - (u3 - bvirt) + (_i - bvirt);
|
||||
cc[3] = u3;
|
||||
}
|
||||
|
||||
if (adxtail !== 0) {
|
||||
axtbclen = scale(4, bc, adxtail, axtbc);
|
||||
finlen = finadd(finlen, sum_three(
|
||||
scale(axtbclen, axtbc, 2 * adx, _16), _16,
|
||||
scale(scale(4, cc, adxtail, _8), _8, bdy, _16b), _16b,
|
||||
scale(scale(4, bb, adxtail, _8), _8, -cdy, _16c), _16c, _32, _48), _48);
|
||||
}
|
||||
if (adytail !== 0) {
|
||||
aytbclen = scale(4, bc, adytail, aytbc);
|
||||
finlen = finadd(finlen, sum_three(
|
||||
scale(aytbclen, aytbc, 2 * ady, _16), _16,
|
||||
scale(scale(4, bb, adytail, _8), _8, cdx, _16b), _16b,
|
||||
scale(scale(4, cc, adytail, _8), _8, -bdx, _16c), _16c, _32, _48), _48);
|
||||
}
|
||||
if (bdxtail !== 0) {
|
||||
bxtcalen = scale(4, ca, bdxtail, bxtca);
|
||||
finlen = finadd(finlen, sum_three(
|
||||
scale(bxtcalen, bxtca, 2 * bdx, _16), _16,
|
||||
scale(scale(4, aa, bdxtail, _8), _8, cdy, _16b), _16b,
|
||||
scale(scale(4, cc, bdxtail, _8), _8, -ady, _16c), _16c, _32, _48), _48);
|
||||
}
|
||||
if (bdytail !== 0) {
|
||||
bytcalen = scale(4, ca, bdytail, bytca);
|
||||
finlen = finadd(finlen, sum_three(
|
||||
scale(bytcalen, bytca, 2 * bdy, _16), _16,
|
||||
scale(scale(4, cc, bdytail, _8), _8, adx, _16b), _16b,
|
||||
scale(scale(4, aa, bdytail, _8), _8, -cdx, _16c), _16c, _32, _48), _48);
|
||||
}
|
||||
if (cdxtail !== 0) {
|
||||
cxtablen = scale(4, ab, cdxtail, cxtab);
|
||||
finlen = finadd(finlen, sum_three(
|
||||
scale(cxtablen, cxtab, 2 * cdx, _16), _16,
|
||||
scale(scale(4, bb, cdxtail, _8), _8, ady, _16b), _16b,
|
||||
scale(scale(4, aa, cdxtail, _8), _8, -bdy, _16c), _16c, _32, _48), _48);
|
||||
}
|
||||
if (cdytail !== 0) {
|
||||
cytablen = scale(4, ab, cdytail, cytab);
|
||||
finlen = finadd(finlen, sum_three(
|
||||
scale(cytablen, cytab, 2 * cdy, _16), _16,
|
||||
scale(scale(4, aa, cdytail, _8), _8, bdx, _16b), _16b,
|
||||
scale(scale(4, bb, cdytail, _8), _8, -adx, _16c), _16c, _32, _48), _48);
|
||||
}
|
||||
|
||||
if (adxtail !== 0 || adytail !== 0) {
|
||||
if (bdxtail !== 0 || bdytail !== 0 || cdxtail !== 0 || cdytail !== 0) {
|
||||
s1 = bdxtail * cdy;
|
||||
c = splitter * bdxtail;
|
||||
ahi = c - (c - bdxtail);
|
||||
alo = bdxtail - ahi;
|
||||
c = splitter * cdy;
|
||||
bhi = c - (c - cdy);
|
||||
blo = cdy - bhi;
|
||||
s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
t1 = bdx * cdytail;
|
||||
c = splitter * bdx;
|
||||
ahi = c - (c - bdx);
|
||||
alo = bdx - ahi;
|
||||
c = splitter * cdytail;
|
||||
bhi = c - (c - cdytail);
|
||||
blo = cdytail - bhi;
|
||||
t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_i = s0 + t0;
|
||||
bvirt = _i - s0;
|
||||
u[0] = s0 - (_i - bvirt) + (t0 - bvirt);
|
||||
_j = s1 + _i;
|
||||
bvirt = _j - s1;
|
||||
_0 = s1 - (_j - bvirt) + (_i - bvirt);
|
||||
_i = _0 + t1;
|
||||
bvirt = _i - _0;
|
||||
u[1] = _0 - (_i - bvirt) + (t1 - bvirt);
|
||||
u3 = _j + _i;
|
||||
bvirt = u3 - _j;
|
||||
u[2] = _j - (u3 - bvirt) + (_i - bvirt);
|
||||
u[3] = u3;
|
||||
s1 = cdxtail * -bdy;
|
||||
c = splitter * cdxtail;
|
||||
ahi = c - (c - cdxtail);
|
||||
alo = cdxtail - ahi;
|
||||
c = splitter * -bdy;
|
||||
bhi = c - (c - -bdy);
|
||||
blo = -bdy - bhi;
|
||||
s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
t1 = cdx * -bdytail;
|
||||
c = splitter * cdx;
|
||||
ahi = c - (c - cdx);
|
||||
alo = cdx - ahi;
|
||||
c = splitter * -bdytail;
|
||||
bhi = c - (c - -bdytail);
|
||||
blo = -bdytail - bhi;
|
||||
t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_i = s0 + t0;
|
||||
bvirt = _i - s0;
|
||||
v[0] = s0 - (_i - bvirt) + (t0 - bvirt);
|
||||
_j = s1 + _i;
|
||||
bvirt = _j - s1;
|
||||
_0 = s1 - (_j - bvirt) + (_i - bvirt);
|
||||
_i = _0 + t1;
|
||||
bvirt = _i - _0;
|
||||
v[1] = _0 - (_i - bvirt) + (t1 - bvirt);
|
||||
u3 = _j + _i;
|
||||
bvirt = u3 - _j;
|
||||
v[2] = _j - (u3 - bvirt) + (_i - bvirt);
|
||||
v[3] = u3;
|
||||
bctlen = sum(4, u, 4, v, bct);
|
||||
s1 = bdxtail * cdytail;
|
||||
c = splitter * bdxtail;
|
||||
ahi = c - (c - bdxtail);
|
||||
alo = bdxtail - ahi;
|
||||
c = splitter * cdytail;
|
||||
bhi = c - (c - cdytail);
|
||||
blo = cdytail - bhi;
|
||||
s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
t1 = cdxtail * bdytail;
|
||||
c = splitter * cdxtail;
|
||||
ahi = c - (c - cdxtail);
|
||||
alo = cdxtail - ahi;
|
||||
c = splitter * bdytail;
|
||||
bhi = c - (c - bdytail);
|
||||
blo = bdytail - bhi;
|
||||
t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_i = s0 - t0;
|
||||
bvirt = s0 - _i;
|
||||
bctt[0] = s0 - (_i + bvirt) + (bvirt - t0);
|
||||
_j = s1 + _i;
|
||||
bvirt = _j - s1;
|
||||
_0 = s1 - (_j - bvirt) + (_i - bvirt);
|
||||
_i = _0 - t1;
|
||||
bvirt = _0 - _i;
|
||||
bctt[1] = _0 - (_i + bvirt) + (bvirt - t1);
|
||||
u3 = _j + _i;
|
||||
bvirt = u3 - _j;
|
||||
bctt[2] = _j - (u3 - bvirt) + (_i - bvirt);
|
||||
bctt[3] = u3;
|
||||
bcttlen = 4;
|
||||
} else {
|
||||
bct[0] = 0;
|
||||
bctlen = 1;
|
||||
bctt[0] = 0;
|
||||
bcttlen = 1;
|
||||
}
|
||||
if (adxtail !== 0) {
|
||||
const len = scale(bctlen, bct, adxtail, _16c);
|
||||
finlen = finadd(finlen, sum(
|
||||
scale(axtbclen, axtbc, adxtail, _16), _16,
|
||||
scale(len, _16c, 2 * adx, _32), _32, _48), _48);
|
||||
|
||||
const len2 = scale(bcttlen, bctt, adxtail, _8);
|
||||
finlen = finadd(finlen, sum_three(
|
||||
scale(len2, _8, 2 * adx, _16), _16,
|
||||
scale(len2, _8, adxtail, _16b), _16b,
|
||||
scale(len, _16c, adxtail, _32), _32, _32b, _64), _64);
|
||||
|
||||
if (bdytail !== 0) {
|
||||
finlen = finadd(finlen, scale(scale(4, cc, adxtail, _8), _8, bdytail, _16), _16);
|
||||
}
|
||||
if (cdytail !== 0) {
|
||||
finlen = finadd(finlen, scale(scale(4, bb, -adxtail, _8), _8, cdytail, _16), _16);
|
||||
}
|
||||
}
|
||||
if (adytail !== 0) {
|
||||
const len = scale(bctlen, bct, adytail, _16c);
|
||||
finlen = finadd(finlen, sum(
|
||||
scale(aytbclen, aytbc, adytail, _16), _16,
|
||||
scale(len, _16c, 2 * ady, _32), _32, _48), _48);
|
||||
|
||||
const len2 = scale(bcttlen, bctt, adytail, _8);
|
||||
finlen = finadd(finlen, sum_three(
|
||||
scale(len2, _8, 2 * ady, _16), _16,
|
||||
scale(len2, _8, adytail, _16b), _16b,
|
||||
scale(len, _16c, adytail, _32), _32, _32b, _64), _64);
|
||||
}
|
||||
}
|
||||
if (bdxtail !== 0 || bdytail !== 0) {
|
||||
if (cdxtail !== 0 || cdytail !== 0 || adxtail !== 0 || adytail !== 0) {
|
||||
s1 = cdxtail * ady;
|
||||
c = splitter * cdxtail;
|
||||
ahi = c - (c - cdxtail);
|
||||
alo = cdxtail - ahi;
|
||||
c = splitter * ady;
|
||||
bhi = c - (c - ady);
|
||||
blo = ady - bhi;
|
||||
s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
t1 = cdx * adytail;
|
||||
c = splitter * cdx;
|
||||
ahi = c - (c - cdx);
|
||||
alo = cdx - ahi;
|
||||
c = splitter * adytail;
|
||||
bhi = c - (c - adytail);
|
||||
blo = adytail - bhi;
|
||||
t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_i = s0 + t0;
|
||||
bvirt = _i - s0;
|
||||
u[0] = s0 - (_i - bvirt) + (t0 - bvirt);
|
||||
_j = s1 + _i;
|
||||
bvirt = _j - s1;
|
||||
_0 = s1 - (_j - bvirt) + (_i - bvirt);
|
||||
_i = _0 + t1;
|
||||
bvirt = _i - _0;
|
||||
u[1] = _0 - (_i - bvirt) + (t1 - bvirt);
|
||||
u3 = _j + _i;
|
||||
bvirt = u3 - _j;
|
||||
u[2] = _j - (u3 - bvirt) + (_i - bvirt);
|
||||
u[3] = u3;
|
||||
n1 = -cdy;
|
||||
n0 = -cdytail;
|
||||
s1 = adxtail * n1;
|
||||
c = splitter * adxtail;
|
||||
ahi = c - (c - adxtail);
|
||||
alo = adxtail - ahi;
|
||||
c = splitter * n1;
|
||||
bhi = c - (c - n1);
|
||||
blo = n1 - bhi;
|
||||
s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
t1 = adx * n0;
|
||||
c = splitter * adx;
|
||||
ahi = c - (c - adx);
|
||||
alo = adx - ahi;
|
||||
c = splitter * n0;
|
||||
bhi = c - (c - n0);
|
||||
blo = n0 - bhi;
|
||||
t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_i = s0 + t0;
|
||||
bvirt = _i - s0;
|
||||
v[0] = s0 - (_i - bvirt) + (t0 - bvirt);
|
||||
_j = s1 + _i;
|
||||
bvirt = _j - s1;
|
||||
_0 = s1 - (_j - bvirt) + (_i - bvirt);
|
||||
_i = _0 + t1;
|
||||
bvirt = _i - _0;
|
||||
v[1] = _0 - (_i - bvirt) + (t1 - bvirt);
|
||||
u3 = _j + _i;
|
||||
bvirt = u3 - _j;
|
||||
v[2] = _j - (u3 - bvirt) + (_i - bvirt);
|
||||
v[3] = u3;
|
||||
catlen = sum(4, u, 4, v, cat);
|
||||
s1 = cdxtail * adytail;
|
||||
c = splitter * cdxtail;
|
||||
ahi = c - (c - cdxtail);
|
||||
alo = cdxtail - ahi;
|
||||
c = splitter * adytail;
|
||||
bhi = c - (c - adytail);
|
||||
blo = adytail - bhi;
|
||||
s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
t1 = adxtail * cdytail;
|
||||
c = splitter * adxtail;
|
||||
ahi = c - (c - adxtail);
|
||||
alo = adxtail - ahi;
|
||||
c = splitter * cdytail;
|
||||
bhi = c - (c - cdytail);
|
||||
blo = cdytail - bhi;
|
||||
t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_i = s0 - t0;
|
||||
bvirt = s0 - _i;
|
||||
catt[0] = s0 - (_i + bvirt) + (bvirt - t0);
|
||||
_j = s1 + _i;
|
||||
bvirt = _j - s1;
|
||||
_0 = s1 - (_j - bvirt) + (_i - bvirt);
|
||||
_i = _0 - t1;
|
||||
bvirt = _0 - _i;
|
||||
catt[1] = _0 - (_i + bvirt) + (bvirt - t1);
|
||||
u3 = _j + _i;
|
||||
bvirt = u3 - _j;
|
||||
catt[2] = _j - (u3 - bvirt) + (_i - bvirt);
|
||||
catt[3] = u3;
|
||||
cattlen = 4;
|
||||
} else {
|
||||
cat[0] = 0;
|
||||
catlen = 1;
|
||||
catt[0] = 0;
|
||||
cattlen = 1;
|
||||
}
|
||||
if (bdxtail !== 0) {
|
||||
const len = scale(catlen, cat, bdxtail, _16c);
|
||||
finlen = finadd(finlen, sum(
|
||||
scale(bxtcalen, bxtca, bdxtail, _16), _16,
|
||||
scale(len, _16c, 2 * bdx, _32), _32, _48), _48);
|
||||
|
||||
const len2 = scale(cattlen, catt, bdxtail, _8);
|
||||
finlen = finadd(finlen, sum_three(
|
||||
scale(len2, _8, 2 * bdx, _16), _16,
|
||||
scale(len2, _8, bdxtail, _16b), _16b,
|
||||
scale(len, _16c, bdxtail, _32), _32, _32b, _64), _64);
|
||||
|
||||
if (cdytail !== 0) {
|
||||
finlen = finadd(finlen, scale(scale(4, aa, bdxtail, _8), _8, cdytail, _16), _16);
|
||||
}
|
||||
if (adytail !== 0) {
|
||||
finlen = finadd(finlen, scale(scale(4, cc, -bdxtail, _8), _8, adytail, _16), _16);
|
||||
}
|
||||
}
|
||||
if (bdytail !== 0) {
|
||||
const len = scale(catlen, cat, bdytail, _16c);
|
||||
finlen = finadd(finlen, sum(
|
||||
scale(bytcalen, bytca, bdytail, _16), _16,
|
||||
scale(len, _16c, 2 * bdy, _32), _32, _48), _48);
|
||||
|
||||
const len2 = scale(cattlen, catt, bdytail, _8);
|
||||
finlen = finadd(finlen, sum_three(
|
||||
scale(len2, _8, 2 * bdy, _16), _16,
|
||||
scale(len2, _8, bdytail, _16b), _16b,
|
||||
scale(len, _16c, bdytail, _32), _32, _32b, _64), _64);
|
||||
}
|
||||
}
|
||||
if (cdxtail !== 0 || cdytail !== 0) {
|
||||
if (adxtail !== 0 || adytail !== 0 || bdxtail !== 0 || bdytail !== 0) {
|
||||
s1 = adxtail * bdy;
|
||||
c = splitter * adxtail;
|
||||
ahi = c - (c - adxtail);
|
||||
alo = adxtail - ahi;
|
||||
c = splitter * bdy;
|
||||
bhi = c - (c - bdy);
|
||||
blo = bdy - bhi;
|
||||
s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
t1 = adx * bdytail;
|
||||
c = splitter * adx;
|
||||
ahi = c - (c - adx);
|
||||
alo = adx - ahi;
|
||||
c = splitter * bdytail;
|
||||
bhi = c - (c - bdytail);
|
||||
blo = bdytail - bhi;
|
||||
t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_i = s0 + t0;
|
||||
bvirt = _i - s0;
|
||||
u[0] = s0 - (_i - bvirt) + (t0 - bvirt);
|
||||
_j = s1 + _i;
|
||||
bvirt = _j - s1;
|
||||
_0 = s1 - (_j - bvirt) + (_i - bvirt);
|
||||
_i = _0 + t1;
|
||||
bvirt = _i - _0;
|
||||
u[1] = _0 - (_i - bvirt) + (t1 - bvirt);
|
||||
u3 = _j + _i;
|
||||
bvirt = u3 - _j;
|
||||
u[2] = _j - (u3 - bvirt) + (_i - bvirt);
|
||||
u[3] = u3;
|
||||
n1 = -ady;
|
||||
n0 = -adytail;
|
||||
s1 = bdxtail * n1;
|
||||
c = splitter * bdxtail;
|
||||
ahi = c - (c - bdxtail);
|
||||
alo = bdxtail - ahi;
|
||||
c = splitter * n1;
|
||||
bhi = c - (c - n1);
|
||||
blo = n1 - bhi;
|
||||
s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
t1 = bdx * n0;
|
||||
c = splitter * bdx;
|
||||
ahi = c - (c - bdx);
|
||||
alo = bdx - ahi;
|
||||
c = splitter * n0;
|
||||
bhi = c - (c - n0);
|
||||
blo = n0 - bhi;
|
||||
t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_i = s0 + t0;
|
||||
bvirt = _i - s0;
|
||||
v[0] = s0 - (_i - bvirt) + (t0 - bvirt);
|
||||
_j = s1 + _i;
|
||||
bvirt = _j - s1;
|
||||
_0 = s1 - (_j - bvirt) + (_i - bvirt);
|
||||
_i = _0 + t1;
|
||||
bvirt = _i - _0;
|
||||
v[1] = _0 - (_i - bvirt) + (t1 - bvirt);
|
||||
u3 = _j + _i;
|
||||
bvirt = u3 - _j;
|
||||
v[2] = _j - (u3 - bvirt) + (_i - bvirt);
|
||||
v[3] = u3;
|
||||
abtlen = sum(4, u, 4, v, abt);
|
||||
s1 = adxtail * bdytail;
|
||||
c = splitter * adxtail;
|
||||
ahi = c - (c - adxtail);
|
||||
alo = adxtail - ahi;
|
||||
c = splitter * bdytail;
|
||||
bhi = c - (c - bdytail);
|
||||
blo = bdytail - bhi;
|
||||
s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
t1 = bdxtail * adytail;
|
||||
c = splitter * bdxtail;
|
||||
ahi = c - (c - bdxtail);
|
||||
alo = bdxtail - ahi;
|
||||
c = splitter * adytail;
|
||||
bhi = c - (c - adytail);
|
||||
blo = adytail - bhi;
|
||||
t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
|
||||
_i = s0 - t0;
|
||||
bvirt = s0 - _i;
|
||||
abtt[0] = s0 - (_i + bvirt) + (bvirt - t0);
|
||||
_j = s1 + _i;
|
||||
bvirt = _j - s1;
|
||||
_0 = s1 - (_j - bvirt) + (_i - bvirt);
|
||||
_i = _0 - t1;
|
||||
bvirt = _0 - _i;
|
||||
abtt[1] = _0 - (_i + bvirt) + (bvirt - t1);
|
||||
u3 = _j + _i;
|
||||
bvirt = u3 - _j;
|
||||
abtt[2] = _j - (u3 - bvirt) + (_i - bvirt);
|
||||
abtt[3] = u3;
|
||||
abttlen = 4;
|
||||
} else {
|
||||
abt[0] = 0;
|
||||
abtlen = 1;
|
||||
abtt[0] = 0;
|
||||
abttlen = 1;
|
||||
}
|
||||
if (cdxtail !== 0) {
|
||||
const len = scale(abtlen, abt, cdxtail, _16c);
|
||||
finlen = finadd(finlen, sum(
|
||||
scale(cxtablen, cxtab, cdxtail, _16), _16,
|
||||
scale(len, _16c, 2 * cdx, _32), _32, _48), _48);
|
||||
|
||||
const len2 = scale(abttlen, abtt, cdxtail, _8);
|
||||
finlen = finadd(finlen, sum_three(
|
||||
scale(len2, _8, 2 * cdx, _16), _16,
|
||||
scale(len2, _8, cdxtail, _16b), _16b,
|
||||
scale(len, _16c, cdxtail, _32), _32, _32b, _64), _64);
|
||||
|
||||
if (adytail !== 0) {
|
||||
finlen = finadd(finlen, scale(scale(4, bb, cdxtail, _8), _8, adytail, _16), _16);
|
||||
}
|
||||
if (bdytail !== 0) {
|
||||
finlen = finadd(finlen, scale(scale(4, aa, -cdxtail, _8), _8, bdytail, _16), _16);
|
||||
}
|
||||
}
|
||||
if (cdytail !== 0) {
|
||||
const len = scale(abtlen, abt, cdytail, _16c);
|
||||
finlen = finadd(finlen, sum(
|
||||
scale(cytablen, cytab, cdytail, _16), _16,
|
||||
scale(len, _16c, 2 * cdy, _32), _32, _48), _48);
|
||||
|
||||
const len2 = scale(abttlen, abtt, cdytail, _8);
|
||||
finlen = finadd(finlen, sum_three(
|
||||
scale(len2, _8, 2 * cdy, _16), _16,
|
||||
scale(len2, _8, cdytail, _16b), _16b,
|
||||
scale(len, _16c, cdytail, _32), _32, _32b, _64), _64);
|
||||
}
|
||||
}
|
||||
|
||||
return fin[finlen - 1];
|
||||
}
|
||||
|
||||
function incircle(ax, ay, bx, by, cx, cy, dx, dy) {
|
||||
const adx = ax - dx;
|
||||
const bdx = bx - dx;
|
||||
const cdx = cx - dx;
|
||||
const ady = ay - dy;
|
||||
const bdy = by - dy;
|
||||
const cdy = cy - dy;
|
||||
|
||||
const bdxcdy = bdx * cdy;
|
||||
const cdxbdy = cdx * bdy;
|
||||
const alift = adx * adx + ady * ady;
|
||||
|
||||
const cdxady = cdx * ady;
|
||||
const adxcdy = adx * cdy;
|
||||
const blift = bdx * bdx + bdy * bdy;
|
||||
|
||||
const adxbdy = adx * bdy;
|
||||
const bdxady = bdx * ady;
|
||||
const clift = cdx * cdx + cdy * cdy;
|
||||
|
||||
const det =
|
||||
alift * (bdxcdy - cdxbdy) +
|
||||
blift * (cdxady - adxcdy) +
|
||||
clift * (adxbdy - bdxady);
|
||||
|
||||
const permanent =
|
||||
(Math.abs(bdxcdy) + Math.abs(cdxbdy)) * alift +
|
||||
(Math.abs(cdxady) + Math.abs(adxcdy)) * blift +
|
||||
(Math.abs(adxbdy) + Math.abs(bdxady)) * clift;
|
||||
|
||||
const errbound = iccerrboundA * permanent;
|
||||
|
||||
if (det > errbound || -det > errbound) {
|
||||
return det;
|
||||
}
|
||||
return incircleadapt(ax, ay, bx, by, cx, cy, dx, dy, permanent);
|
||||
}
|
||||
|
||||
function incirclefast(ax, ay, bx, by, cx, cy, dx, dy) {
|
||||
const adx = ax - dx;
|
||||
const ady = ay - dy;
|
||||
const bdx = bx - dx;
|
||||
const bdy = by - dy;
|
||||
const cdx = cx - dx;
|
||||
const cdy = cy - dy;
|
||||
|
||||
const abdet = adx * bdy - bdx * ady;
|
||||
const bcdet = bdx * cdy - cdx * bdy;
|
||||
const cadet = cdx * ady - adx * cdy;
|
||||
const alift = adx * adx + ady * ady;
|
||||
const blift = bdx * bdx + bdy * bdy;
|
||||
const clift = cdx * cdx + cdy * cdy;
|
||||
|
||||
return alift * bcdet + blift * cadet + clift * abdet;
|
||||
}
|
||||
|
||||
exports.incircle = incircle;
|
||||
exports.incirclefast = incirclefast;
|
||||
|
||||
}));
|
||||
1
frontend/node_modules/robust-predicates/umd/predicates.min.js
generated
vendored
Normal file
1
frontend/node_modules/robust-predicates/umd/predicates.min.js
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
Reference in New Issue
Block a user