Use primitive-quadify-off-curves to do curve conversion.
This commit is contained in:
belleve
parent
b4ba453ad8
commit
bae8c1c6c0
9 changed files with 462 additions and 468 deletions
24
.eslintrc.json
Normal file
24
.eslintrc.json
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
{
|
||||
"env": {
|
||||
"node": true,
|
||||
"commonjs": true,
|
||||
"es6": true
|
||||
},
|
||||
"parserOptions": {
|
||||
"ecmaVersion": 2018,
|
||||
"ecmaFeatures": {
|
||||
"jsx": true,
|
||||
"experimentalObjectRestSpread": true
|
||||
}
|
||||
},
|
||||
"extends": "eslint:recommended",
|
||||
"rules": {
|
||||
"indent": ["error", "tab", { "SwitchCase": 1 }],
|
||||
"linebreak-style": ["error", "windows"],
|
||||
"quotes": ["error", "double", { "allowTemplateLiterals": true }],
|
||||
"semi": ["error", "always"],
|
||||
"no-var":"error",
|
||||
"no-console": 0,
|
||||
"no-constant-condition": ["error", { "checkLoops": false }]
|
||||
}
|
||||
}
|
||||
|
|
@ -152,7 +152,6 @@ if (argv.charmap) {
|
|||
fs.writeFileSync(argv.charmap, JSON.stringify(charmap), "utf8");
|
||||
}
|
||||
|
||||
if (argv.o) {
|
||||
function regulateGlyph(g, skew) {
|
||||
if (!g.contours) return;
|
||||
|
||||
|
|
@ -193,7 +192,6 @@ if (argv.o) {
|
|||
g.contours = caryllShapeOps.removeOverlap(c1, 1, 256, true);
|
||||
|
||||
// Finalize
|
||||
Glyph.prototype.cleanup.call(g, 0.1);
|
||||
g.contours = c2q.contours(g.contours);
|
||||
for (let k = 0; k < g.contours.length; k++) {
|
||||
const contour = g.contours[k];
|
||||
|
|
@ -203,10 +201,14 @@ if (argv.o) {
|
|||
}
|
||||
}
|
||||
|
||||
if (argv.o) {
|
||||
const skew =
|
||||
(argv.uprightify ? 1 : 0) * Math.tan(((font.post.italicAngle || 0) / 180) * Math.PI);
|
||||
const excludeUnicodes = new Set();
|
||||
excludeUnicodes.add(0x80);
|
||||
for (let c = 0x2500; c <= 0x259f; c++) excludeUnicodes.add(c);
|
||||
// autoref
|
||||
autoref(font.glyf);
|
||||
autoref(font.glyf, excludeUnicodes);
|
||||
// regulate
|
||||
for (let g of font.glyf) regulateGlyph(g, skew);
|
||||
|
||||
|
|
|
|||
|
|
@ -24,6 +24,10 @@
|
|||
"ttf2woff2": "^2.0.3",
|
||||
"unorm": "^1.4.1",
|
||||
"verda": "^0.1.4",
|
||||
"yargs": "^12.0.0"
|
||||
"yargs": "^12.0.0",
|
||||
"primitive-quadify-off-curves": "^0.4.0"
|
||||
},
|
||||
"devDependencies": {
|
||||
"eslint": "^5.2.0"
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,6 @@
|
|||
var Point = require("./point");
|
||||
"use strict";
|
||||
|
||||
const Point = require("./point");
|
||||
|
||||
function delta(a, b) {
|
||||
return Math.round((a - b) * 32);
|
||||
|
|
@ -6,11 +8,11 @@ function delta(a, b) {
|
|||
|
||||
function contourHash(c) {
|
||||
if (!c || c.length < 2) return ".";
|
||||
var lx = c[0].x,
|
||||
let lx = c[0].x,
|
||||
ly = c[0].y;
|
||||
var buf = "";
|
||||
for (var j = 1; j < c.length; j++) {
|
||||
var z = c[j];
|
||||
let buf = "";
|
||||
for (let j = 1; j < c.length; j++) {
|
||||
const z = c[j];
|
||||
buf += `${z.on ? "o" : "f"}${z.cubic ? "c" : "q"}${delta(z.x, lx)},${delta(z.y, ly)};`;
|
||||
(lx = z.x), (ly = z.y);
|
||||
}
|
||||
|
|
@ -19,8 +21,8 @@ function contourHash(c) {
|
|||
|
||||
function match(g1, g2, _n) {
|
||||
for (let j = 0; j + g1.contours.length <= g2.contours.length; j++) {
|
||||
var found = true;
|
||||
for (var k = j; k < g2.contours.length && k - j < g1.contours.length; k++) {
|
||||
let found = true;
|
||||
for (let k = j; k < g2.contours.length && k - j < g1.contours.length; k++) {
|
||||
if (
|
||||
g1.contours[k - j].hash !== g2.contours[k].hash ||
|
||||
!(
|
||||
|
|
@ -46,7 +48,8 @@ function match(g1, g2, _n) {
|
|||
glyph: g1.name,
|
||||
_n: _n,
|
||||
x: refX,
|
||||
y: refY
|
||||
y: refY,
|
||||
roundToGrid: false
|
||||
});
|
||||
g2.contours.splice(j, g1.contours.length);
|
||||
return true;
|
||||
|
|
@ -56,31 +59,31 @@ function match(g1, g2, _n) {
|
|||
}
|
||||
|
||||
function unlinkRef(g, dx, dy, glyf) {
|
||||
var cntrs = g.contours.map(c => c.map(z => new Point(z.x + dx, z.y + dy, z.on, z.cubic)));
|
||||
let contours = g.contours.map(c => c.map(z => new Point(z.x + dx, z.y + dy, z.on, z.cubic)));
|
||||
if (g.references)
|
||||
for (let r of g.references) {
|
||||
cntrs = cntrs.concat(unlinkRef(glyf[r._n], r.x + dx, r.y + dy, glyf));
|
||||
contours = contours.concat(unlinkRef(glyf[r._n], r.x + dx, r.y + dy, glyf));
|
||||
}
|
||||
return cntrs;
|
||||
return contours;
|
||||
}
|
||||
|
||||
function autoref(glyf) {
|
||||
supporessNaN(glyf);
|
||||
function autoref(glyf, excludeUnicodes) {
|
||||
suppressNaN(glyf);
|
||||
|
||||
for (var j = 0; j < glyf.length; j++) {
|
||||
var g = glyf[j];
|
||||
for (let j = 0; j < glyf.length; j++) {
|
||||
const g = glyf[j];
|
||||
if (g.contours) {
|
||||
for (var k = 0; k < g.contours.length; k++) {
|
||||
var contour = g.contours[k];
|
||||
for (let k = 0; k < g.contours.length; k++) {
|
||||
const contour = g.contours[k];
|
||||
contour.hash = contourHash(contour);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Refl-referencify, forward.
|
||||
for (var j = 0; j < glyf.length; j++) {
|
||||
for (let j = 0; j < glyf.length; j++) {
|
||||
if (!glyf[j].contours.length || (glyf[j].references && glyf[j].references.length)) continue;
|
||||
for (var k = j + 1; k < glyf.length; k++) {
|
||||
for (let k = j + 1; k < glyf.length; k++) {
|
||||
if (glyf[j].contours.length === glyf[k].contours.length) {
|
||||
match(glyf[j], glyf[k], j);
|
||||
}
|
||||
|
|
@ -88,44 +91,42 @@ function autoref(glyf) {
|
|||
}
|
||||
|
||||
// referencify, backward
|
||||
for (var j = 0; j < glyf.length; j++) {
|
||||
for (let j = 0; j < glyf.length; j++) {
|
||||
if (glyf[j].cmpPriority < 0) continue;
|
||||
if (!glyf[j].contours.length) continue;
|
||||
if (glyf[j].references && glyf[j].references.length) continue;
|
||||
for (var k = glyf.length - 1; k >= 0; k--) {
|
||||
for (let k = glyf.length - 1; k >= 0; k--) {
|
||||
if (glyf[j].contours.length > glyf[k].contours.length) continue;
|
||||
if (
|
||||
glyf[j].contours.length > glyf[k].contours.length ||
|
||||
(glyf[j].contours.length === glyf[k].contours.length &&
|
||||
!(glyf[k].references && glyf[k].references.length))
|
||||
)
|
||||
glyf[j].contours.length === glyf[k].contours.length &&
|
||||
!(glyf[k].references && glyf[k].references.length)
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
while (match(glyf[j], glyf[k], j)) "pass";
|
||||
}
|
||||
}
|
||||
|
||||
// unlink composite
|
||||
for (var j = 0; j < glyf.length; j++) {
|
||||
if (!glyf[j].flatten) {
|
||||
for (let j = 0; j < glyf.length; j++) {
|
||||
if (!glyf[j].references || glyf[j].references.length === 0) continue;
|
||||
if (
|
||||
glyf[j].contours.length === 0 &&
|
||||
!(glyf[j].unicode && glyf[j].unicode[0] < 0x80) &&
|
||||
!(glyf[j].unicode && glyf[j].unicode[0] >= 0x2500 && glyf[j].unicode[0] <= 0x259f)
|
||||
)
|
||||
!(glyf[j].unicode && excludeUnicodes.has(glyf[j].unicode[0]))
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
var cs = unlinkRef(glyf[j], 0, 0, glyf);
|
||||
glyf[j].contours = g.contours.concat(cs);
|
||||
glyf[j].contours = unlinkRef(glyf[j], 0, 0, glyf);
|
||||
glyf[j].references = [];
|
||||
}
|
||||
}
|
||||
|
||||
function supporessNaN(glyf) {
|
||||
for (var j = 0; j < glyf.length; j++) {
|
||||
var g = glyf[j];
|
||||
function suppressNaN(glyf) {
|
||||
for (let j = 0; j < glyf.length; j++) {
|
||||
let g = glyf[j];
|
||||
if (!g.contours) continue;
|
||||
for (var k = 0; k < g.contours.length; k++) {
|
||||
var contour = g.contours[k];
|
||||
for (let k = 0; k < g.contours.length; k++) {
|
||||
let contour = g.contours[k];
|
||||
for (let z of contour) {
|
||||
if (!isFinite(z.x)) z.x = 0;
|
||||
if (!isFinite(z.y)) z.y = 0;
|
||||
|
|
|
|||
|
|
@ -1,24 +1,15 @@
|
|||
var Transform = require('./transform.js');
|
||||
"use strict";
|
||||
|
||||
var ANGLES = 12;
|
||||
var VERYCROWD = 2;
|
||||
var SMALLANGLE = 0.05;
|
||||
var SMALLANGLE_CLEANMORE = 0.075;
|
||||
var CROWD = 4;
|
||||
var LOOSE = 6;
|
||||
var SMALL = 1e-4;
|
||||
var CLOSE = 1;
|
||||
function cross(z1, z2, z3) {
|
||||
return (z2.x - z1.x) * (z3.y - z1.y) - (z3.x - z1.x) * (z2.y - z1.y);
|
||||
}
|
||||
function dot(z1, z2, z3) {
|
||||
return (z2.x - z1.x) * (z3.x - z1.x) + (z3.y - z1.y) * (z2.y - z1.y);
|
||||
}
|
||||
const Transform = require("./transform.js");
|
||||
const quadify = require("primitive-quadify-off-curves");
|
||||
|
||||
const ANGLES = 12;
|
||||
const SMALL = 1e-4;
|
||||
function solveTS(a, b, c, out, flag) {
|
||||
var delta = b * b - 4 * a * c;
|
||||
const delta = b * b - 4 * a * c;
|
||||
if (delta > 0) {
|
||||
var t1 = (Math.sqrt(delta) - b) / (2 * a);
|
||||
var t2 = (-Math.sqrt(delta) - b) / (2 * a);
|
||||
const t1 = (Math.sqrt(delta) - b) / (2 * a);
|
||||
const t2 = (-Math.sqrt(delta) - b) / (2 * a);
|
||||
if (flag) {
|
||||
if (t1 >= 0 && t1 <= 1) out.push(t1);
|
||||
if (t2 >= 0 && t2 <= 1) out.push(t2);
|
||||
|
|
@ -27,7 +18,7 @@ function solveTS(a, b, c, out, flag) {
|
|||
if (t2 > 0 && t2 < 1) out.push(t2);
|
||||
}
|
||||
} else if (delta === 0) {
|
||||
var t = -b / (2 * a);
|
||||
const t = -b / (2 * a);
|
||||
if (flag) {
|
||||
if (t >= 0 && t <= 1) out.push(t);
|
||||
} else {
|
||||
|
|
@ -36,22 +27,22 @@ function solveTS(a, b, c, out, flag) {
|
|||
}
|
||||
}
|
||||
function findExtrema(z1, z2, z3, z4, out) {
|
||||
var a = 3 * (-z1.y + 3 * z2.y - 3 * z3.y + z4.y);
|
||||
var b = 6 * (z1.y - 2 * z2.y + z3.y);
|
||||
var c = 3 * (z2.y - z1.y);
|
||||
const a = 3 * (-z1.y + 3 * z2.y - 3 * z3.y + z4.y);
|
||||
const b = 6 * (z1.y - 2 * z2.y + z3.y);
|
||||
const c = 3 * (z2.y - z1.y);
|
||||
solveTS(a, b, c, out);
|
||||
}
|
||||
function findInflections(z1, z2, z3, z4, out) {
|
||||
var ax = z2.x - z1.x;
|
||||
var ay = z2.y - z1.y;
|
||||
var bx = z3.x - z2.x - ax;
|
||||
var by = z3.y - z2.y - ay;
|
||||
var cx = z4.x - z3.x - ax - 2 * bx;
|
||||
var cy = z4.y - z3.y - ay - 2 * by;
|
||||
solveTS(bx * cy - by * cx, ax * cy - ay * cx, ax * by - ay * bx, out, true);
|
||||
}
|
||||
// function findInflections(z1, z2, z3, z4, out) {
|
||||
// const ax = z2.x - z1.x;
|
||||
// const ay = z2.y - z1.y;
|
||||
// const bx = z3.x - z2.x - ax;
|
||||
// const by = z3.y - z2.y - ay;
|
||||
// const cx = z4.x - z3.x - ax - 2 * bx;
|
||||
// const cy = z4.y - z3.y - ay - 2 * by;
|
||||
// solveTS(bx * cy - by * cx, ax * cy - ay * cx, ax * by - ay * bx, out, true);
|
||||
// }
|
||||
function rotate(z, angle) {
|
||||
var c = Math.cos(angle),
|
||||
const c = Math.cos(angle),
|
||||
s = Math.sin(angle);
|
||||
return {
|
||||
x: c * z.x + s * z.y,
|
||||
|
|
@ -62,9 +53,9 @@ function ASCEND(a, b) {
|
|||
return a - b;
|
||||
}
|
||||
function fineAllExtrema(z1, z2, z3, z4, angles) {
|
||||
var exs = [];
|
||||
findInflections(z1, z2, z3, z4, exs);
|
||||
for (var a = 0; a < angles; a += 1) {
|
||||
let exs = [];
|
||||
// findInflections(z1, z2, z3, z4, exs);
|
||||
for (let a = 0; a < angles; a += 1) {
|
||||
findExtrema(z1, z2, z3, z4, exs);
|
||||
z1 = rotate(z1, Math.PI / angles);
|
||||
z2 = rotate(z2, Math.PI / angles);
|
||||
|
|
@ -76,13 +67,16 @@ function fineAllExtrema(z1, z2, z3, z4, angles) {
|
|||
function mix(z1, z2, t) {
|
||||
if (t <= 0) return z1;
|
||||
if (t >= 1) return z2;
|
||||
var x = (1 - t) * z1.x + t * z2.x, y = (1 - t) * z1.y + t * z2.y
|
||||
let x = (1 - t) * z1.x + t * z2.x,
|
||||
y = (1 - t) * z1.y + t * z2.y;
|
||||
return { x: x, y: y };
|
||||
}
|
||||
function bez2(z1, z2, z3, t) {
|
||||
if (t <= 0) return z1;
|
||||
if (t >= 1) return z3;
|
||||
var c1 = (1 - t) * (1 - t), c2 = 2 * (1 - t) * t, c3 = t * t;
|
||||
let c1 = (1 - t) * (1 - t),
|
||||
c2 = 2 * (1 - t) * t,
|
||||
c3 = t * t;
|
||||
return {
|
||||
x: c1 * z1.x + c2 * z2.x + c3 * z3.x,
|
||||
y: c1 * z1.y + c2 * z2.y + c3 * z3.y
|
||||
|
|
@ -91,8 +85,10 @@ function bez2(z1, z2, z3, t) {
|
|||
function bez3(z1, z2, z3, z4, t) {
|
||||
if (t <= 0) return z1;
|
||||
if (t >= 1) return z4;
|
||||
var c1 = (1 - t) * (1 - t) * (1 - t), c2 = 3 * t * (1 - t) * (1 - t),
|
||||
c3 = 3 * t * t * (1 - t), c4 = t * t * t;
|
||||
let c1 = (1 - t) * (1 - t) * (1 - t),
|
||||
c2 = 3 * t * (1 - t) * (1 - t),
|
||||
c3 = 3 * t * t * (1 - t),
|
||||
c4 = t * t * t;
|
||||
return {
|
||||
x: c1 * z1.x + c2 * z2.x + c3 * z3.x + c4 * z4.x,
|
||||
y: c1 * z1.y + c2 * z2.y + c3 * z3.y + c4 * z4.y
|
||||
|
|
@ -104,8 +100,8 @@ function splitBefore(z1, z2, z3, z4, t) {
|
|||
function splitAfter(z1, z2, z3, z4, t) {
|
||||
return [bez3(z1, z2, z3, z4, t), bez2(z2, z3, z4, t), mix(z3, z4, t), z4];
|
||||
}
|
||||
function splitAtExtrema(z1, z2, z3, z4, angles, splitpoints) {
|
||||
var ts = fineAllExtrema(z1, z2, z3, z4, angles);
|
||||
function splitAtExtrema(z1, z2, z3, z4, angles, curve) {
|
||||
const ts = fineAllExtrema(z1, z2, z3, z4, angles);
|
||||
if (ts[0] < SMALL) {
|
||||
ts[0] = 0;
|
||||
} else {
|
||||
|
|
@ -116,236 +112,262 @@ function splitAtExtrema(z1, z2, z3, z4, angles, splitpoints) {
|
|||
} else {
|
||||
ts.push(1);
|
||||
}
|
||||
for (var k = 0; k < ts.length; k++) {
|
||||
for (let k = 0; k < ts.length; k++) {
|
||||
if (k > 0) {
|
||||
var t1 = ts[k - 1];
|
||||
var t2 = ts[k];
|
||||
var bef = splitBefore(z1, z2, z3, z4, t2);
|
||||
var seg = splitAfter(bef[0], bef[1], bef[2], bef[3], t1 / t2);
|
||||
const t1 = ts[k - 1];
|
||||
const t2 = ts[k];
|
||||
const bef = splitBefore(z1, z2, z3, z4, t2);
|
||||
const seg = splitAfter(bef[0], bef[1], bef[2], bef[3], t1 / t2);
|
||||
seg[1].on = seg[2].on = false;
|
||||
seg[1].cubic = seg[2].cubic = true;
|
||||
seg[3].on = true;
|
||||
splitpoints.push(seg[1], seg[2], seg[3]);
|
||||
curve.push(seg[1], seg[2], seg[3]);
|
||||
}
|
||||
}
|
||||
}
|
||||
function splitSegment(z1, z2, z3, z4, angles, splitpoints) {
|
||||
var ts = [];
|
||||
var inflectAtEnd = false;
|
||||
findInflections(z1, z2, z3, z4, ts);
|
||||
ts = ts.sort(ASCEND);
|
||||
if (ts[0] < SMALL) {
|
||||
ts[0] = 0;
|
||||
splitpoints[splitpoints.length - 1].inflect = true;
|
||||
} else {
|
||||
ts.unshift(0);
|
||||
}
|
||||
if (ts[ts.length - 1] > 1 - SMALL) {
|
||||
inflectAtEnd = true;
|
||||
ts[ts.length - 1] = 1;
|
||||
} else {
|
||||
ts.push(1);
|
||||
}
|
||||
for (var k = 0; k < ts.length; k++) {
|
||||
if (k > 0) {
|
||||
var t1 = ts[k - 1];
|
||||
var t2 = ts[k];
|
||||
var bef = splitBefore(z1, z2, z3, z4, t2);
|
||||
var seg = splitAfter(bef[0], bef[1], bef[2], bef[3], t1 / t2);
|
||||
splitAtExtrema(seg[0], seg[1], seg[2], seg[3], angles, splitpoints);
|
||||
if (t2 < 1 || inflectAtEnd)
|
||||
splitpoints[splitpoints.length - 1].inflect = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
function fitpts(p1, c1, c2, p2) {
|
||||
var d1 = {
|
||||
x: c1.x - p1.x,
|
||||
y: c1.y - p1.y
|
||||
};
|
||||
var d2 = {
|
||||
x: c2.x - p2.x,
|
||||
y: c2.y - p2.y
|
||||
};
|
||||
|
||||
var det = d2.x * d1.y - d2.y * d1.x;
|
||||
if (Math.abs(det) < 1e-6) return null;
|
||||
var u = ((p2.y - p1.y) * d2.x - (p2.x - p1.x) * d2.y) / det;
|
||||
var v = ((p2.y - p1.y) * d1.x - (p2.x - p1.x) * d1.y) / det;
|
||||
if (u <= 0 || v <= 0) return null;
|
||||
var mid = {
|
||||
x: p1.x + d1.x * u,
|
||||
y: p1.y + d1.y * u
|
||||
};
|
||||
return [mix(mid, p1, 1 / 3), mix(mid, p2, 1 / 3)];
|
||||
}
|
||||
function distance(z1, z2) {
|
||||
return Math.sqrt((z1.x - z2.x) * (z1.x - z2.x) + (z1.y - z2.y) * (z1.y - z2.y));
|
||||
}
|
||||
function veryclose(z1, z2) {
|
||||
// function splitSegment(z1, z2, z3, z4, angles, curve) {
|
||||
// let ts = [];
|
||||
// let inflectAtEnd = false;
|
||||
// // findInflections(z1, z2, z3, z4, ts);
|
||||
// // ts = ts.sort(ASCEND);
|
||||
// if (ts[0] < SMALL) {
|
||||
// ts[0] = 0;
|
||||
// curve[curve.length - 1].inflect = true;
|
||||
// } else {
|
||||
// ts.unshift(0);
|
||||
// }
|
||||
// if (ts[ts.length - 1] > 1 - SMALL) {
|
||||
// inflectAtEnd = true;
|
||||
// ts[ts.length - 1] = 1;
|
||||
// } else {
|
||||
// ts.push(1);
|
||||
// }
|
||||
// for (let k = 0; k < ts.length; k++) {
|
||||
// if (k > 0) {
|
||||
// const t1 = ts[k - 1];
|
||||
// const t2 = ts[k];
|
||||
// const bef = splitBefore(z1, z2, z3, z4, t2);
|
||||
// const seg = splitAfter(bef[0], bef[1], bef[2], bef[3], t1 / t2);
|
||||
// splitAtExtrema(seg[0], seg[1], seg[2], seg[3], angles, curve);
|
||||
// if (t2 < 1 || inflectAtEnd) curve[curve.length - 1].inflect = true;
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
function veryClose(z1, z2) {
|
||||
return (z1.x - z2.x) * (z1.x - z2.x) + (z1.y - z2.y) * (z1.y - z2.y) <= SMALL;
|
||||
}
|
||||
function angleBetween(z1, z2, z3, z4) {
|
||||
return (Math.atan2(z2.y - z1.y, z2.x - z1.x) - Math.atan2(z4.y - z3.y, z4.x - z3.x)) % Math.PI;
|
||||
|
||||
function splitCurve(sourceCurve) {
|
||||
const curve = [sourceCurve[0]];
|
||||
let last = sourceCurve[0];
|
||||
for (let j = 1; j < sourceCurve.length; j++) {
|
||||
if (sourceCurve[j].on) {
|
||||
const z1 = last,
|
||||
z4 = sourceCurve[j];
|
||||
// const z2 = mix(z1, z4, 1 / 3);
|
||||
//const z3 = mix(z1, z4, 2 / 3);
|
||||
if (!veryClose(z1, z4)) {
|
||||
curve.push(z4);
|
||||
// splitAtExtrema(z1, z2, z3, z4, ANGLES, curve);
|
||||
last = z4;
|
||||
}
|
||||
function pldistance(z1, z2, z) {
|
||||
return Math.abs((z2.y - z1.y) * z.x - (z2.x - z1.x) * z.y + z2.x * z1.y - z2.y * z1.x) / Math.sqrt((z2.x - z1.x) * (z2.x - z1.x) + (z2.y - z1.y) * (z2.y - z1.y));
|
||||
}
|
||||
function estimateSegments(z1, z2) {
|
||||
var hspan = Math.abs(z1.x - z2.x);
|
||||
var vspan = Math.abs(z1.y - z2.y);
|
||||
return hspan <= 5 * CROWD || vspan <= 5 * CROWD ? VERYCROWD : hspan <= 10 * LOOSE || vspan <= 10 * LOOSE ? CROWD : LOOSE;
|
||||
}
|
||||
function enoughRotate(bef, z0, z1, z2, aft, cleanMore, flagl, flagr) {
|
||||
var angleRotatedBefore = Math.abs(angleBetween(bef.next || z1, bef, z1, z0));
|
||||
var angleRotatedAfter = Math.abs(angleBetween(aft.prev || z1, aft, z1, z2));
|
||||
var smallanglel = (cleanMore ? SMALLANGLE_CLEANMORE : SMALLANGLE) * (flagl && cleanMore ? 1 : 2);
|
||||
var smallangler = (cleanMore ? SMALLANGLE_CLEANMORE : SMALLANGLE) * (flagr && cleanMore ? 1 : 2);
|
||||
return !((angleRotatedBefore < smallanglel || angleRotatedBefore > Math.PI - smallanglel) && pldistance(z1, z0, bef) <= CLOSE && distance(z1, bef) <= 5 * CROWD
|
||||
|| (flagr ? false : (angleRotatedAfter < smallangler || angleRotatedAfter > Math.PI - smallangler) && pldistance(z1, z2, aft) <= CLOSE && distance(z1, aft) <= 5 * CROWD));
|
||||
}
|
||||
function fairify(scurve, gizmo, denseQ, cleanMore) {
|
||||
for (var j = 0; j < scurve.length; j++) {
|
||||
if (!isFinite(scurve[j].x)) scurve[j].x = 0;
|
||||
if (!isFinite(scurve[j].y)) scurve[j].y = 0;
|
||||
scurve[j] = Transform.untransform(gizmo, scurve[j]);
|
||||
}
|
||||
var splitpoints = [scurve[0]];
|
||||
var last = scurve[0];
|
||||
for (var j = 1; j < scurve.length; j++) {
|
||||
if (scurve[j].on) {
|
||||
splitpoints.push(last = scurve[j]);
|
||||
} else if (scurve[j].cubic) {
|
||||
var z1 = last,
|
||||
z2 = scurve[j],
|
||||
z3 = scurve[j + 1],
|
||||
z4 = scurve[j + 2];
|
||||
if (!(veryclose(z1, z2) && veryclose(z2, z3) && veryclose(z3, z4))) {
|
||||
splitSegment(z1, z2, z3, z4, ANGLES, splitpoints);
|
||||
} else if (sourceCurve[j].cubic) {
|
||||
const z1 = last,
|
||||
z2 = sourceCurve[j],
|
||||
z3 = sourceCurve[j + 1],
|
||||
z4 = sourceCurve[j + 2];
|
||||
if (!(veryClose(z1, z2) && veryClose(z2, z3) && veryClose(z3, z4))) {
|
||||
splitAtExtrema(z1, z2, z3, z4, ANGLES, curve);
|
||||
last = z4;
|
||||
}
|
||||
j += 2;
|
||||
} else {
|
||||
var z1 = last,
|
||||
zm = scurve[j],
|
||||
z4 = scurve[j + 1];
|
||||
if (!(veryclose(z1, zm) && veryclose(zm, z4))) {
|
||||
var z2 = mix(zm, z1, 1 / 3);
|
||||
var z3 = mix(zm, z4, 1 / 3);
|
||||
splitSegment(z1, z2, z3, z4, ANGLES, splitpoints);
|
||||
const z1 = last,
|
||||
zm = sourceCurve[j],
|
||||
z4 = sourceCurve[j + 1];
|
||||
if (!(veryClose(z1, zm) && veryClose(zm, z4))) {
|
||||
const z2 = mix(zm, z1, 1 / 3);
|
||||
const z3 = mix(zm, z4, 1 / 3);
|
||||
splitAtExtrema(z1, z2, z3, z4, ANGLES, curve);
|
||||
last = z4;
|
||||
}
|
||||
j += 1;
|
||||
}
|
||||
}
|
||||
// Mark corners and extrema
|
||||
for (var j = 1; j < splitpoints.length - 1; j++) {
|
||||
if (splitpoints[j].on && !splitpoints[j - 1].on) {
|
||||
splitpoints[j].prev = splitpoints[j - 1];
|
||||
return curve;
|
||||
}
|
||||
if (splitpoints[j].on && !splitpoints[j + 1].on) {
|
||||
splitpoints[j].next = splitpoints[j + 1];
|
||||
|
||||
function cross(z1, z2, z3) {
|
||||
return (z2.x - z1.x) * (z3.y - z1.y) - (z3.x - z1.x) * (z2.y - z1.y);
|
||||
}
|
||||
if (splitpoints[j].on && !splitpoints[j - 1].on && !splitpoints[j + 1].on) {
|
||||
var z1 = splitpoints[j],
|
||||
z0 = splitpoints[j - 1],
|
||||
z2 = splitpoints[j + 1];
|
||||
if (cross(z1, z0, z2) < 1e-6 && dot(z1, z0, z2) < 0) {
|
||||
var angle0 = Math.atan2(z2.y - z0.y, z2.x - z0.x);
|
||||
var angle = Math.abs(angle0 / Math.PI * 2 % 1);
|
||||
if (Math.abs(Math.abs(angle0) - Math.PI / 2) <= SMALL || angle <= SMALL || angle >= 1 - SMALL) {
|
||||
z1.mark = true; // extremum
|
||||
z1.inflect = false;
|
||||
} else {
|
||||
var isInflection = false;
|
||||
if (j > 2 && j < splitpoints.length - 2) {
|
||||
var za = bez3(z1, z0, splitpoints[j - 2], splitpoints[j - 3], SMALL);
|
||||
var zb = bez3(z1, z2, splitpoints[j + 2], splitpoints[j + 3], SMALL);
|
||||
var inflect = ((z0.y - z2.y) * (za.x - z0.x) + (z2.x - z0.x) * (za.y - z0.y))
|
||||
* ((z0.y - z2.y) * (zb.x - z0.x) + (z2.x - z0.x) * (zb.y - z0.y));
|
||||
if (inflect < 0)
|
||||
isInflection = true;
|
||||
}
|
||||
if (z1.inflect || isInflection) {
|
||||
z1.mark = true;
|
||||
z1.asinflect = true;
|
||||
function dot(z1, z2, z3) {
|
||||
return (z2.x - z1.x) * (z3.x - z1.x) + (z3.y - z1.y) * (z2.y - z1.y);
|
||||
}
|
||||
|
||||
function markCorners(curve) {
|
||||
for (let j = 0; j < curve.length; j++) {
|
||||
if (!curve[j].on) continue;
|
||||
const z1 = curve[j],
|
||||
z0 = curve[(j - 1 + curve.length) % curve.length],
|
||||
z2 = curve[(j + 1) % curve.length];
|
||||
if (Math.abs(cross(z1, z0, z2)) < 1e-6) {
|
||||
// Z0 -- Z1 -- Z2 are linear
|
||||
if (!z0.on && !z2.on && dot(z1, z0, z2) < 0) {
|
||||
const angle0 = Math.atan2(z2.y - z0.y, z2.x - z0.x);
|
||||
const angle = Math.abs(((angle0 / Math.PI) * 2) % 1);
|
||||
if (
|
||||
Math.abs(Math.abs(angle0) - Math.PI / 2) <= SMALL ||
|
||||
angle <= SMALL ||
|
||||
angle >= 1 - SMALL
|
||||
) {
|
||||
z1.mark = true; // curve extremum
|
||||
}
|
||||
} else if (z0.on && z2.on && dot(z1, z0, z2) < 0) {
|
||||
// Colinear on-knots
|
||||
// Remove
|
||||
} else {
|
||||
z1.mark = true; // also corner
|
||||
}
|
||||
} else if (splitpoints[j].on) {
|
||||
splitpoints[j].mark = true; // corner
|
||||
}
|
||||
}
|
||||
splitpoints[0].mark = splitpoints[splitpoints.length - 1].mark = true;
|
||||
// Mark cleanup inflections
|
||||
for (var pass = 0; pass < 2; pass++) {
|
||||
for (var j = 1; j < splitpoints.length - 1; j++) {
|
||||
if (splitpoints[j].mark) {
|
||||
for (var k = j - 1; k >= 0 && !splitpoints[k].mark; k--);
|
||||
lastmark = splitpoints[k];
|
||||
for (var k = j + 1; k < splitpoints.length && !splitpoints[k].mark; k++);
|
||||
nextmark = splitpoints[k];
|
||||
}
|
||||
if (splitpoints[j].mark && splitpoints[j].asinflect) {
|
||||
var z1 = splitpoints[j],
|
||||
z0 = splitpoints[j - 1],
|
||||
z2 = splitpoints[j + 1];
|
||||
if (!(denseQ || enoughRotate(lastmark, z0, z1, z2, nextmark, cleanMore, lastmark.asinflect, nextmark.asinflect))) {
|
||||
//z1.mark = false;
|
||||
z0.remove = z1.remove = z2.remove = true;
|
||||
} else {
|
||||
z1.mark = true; // corner
|
||||
}
|
||||
}
|
||||
}
|
||||
for (var j = 0; j < splitpoints.length; j++) if (splitpoints[j].remove) {
|
||||
splitpoints[j].mark = false;
|
||||
|
||||
class BezierCurveCluster {
|
||||
constructor(zs) {
|
||||
let segments = [];
|
||||
let lengths = [];
|
||||
let last = zs[0];
|
||||
for (let j = 1; j < zs.length; j++) {
|
||||
if (zs[j].on) {
|
||||
const z1 = last,
|
||||
z4 = zs[j];
|
||||
const z2 = mix(z1, z4, 1 / 3);
|
||||
const z3 = mix(z1, z4, 2 / 3);
|
||||
segments.push(new quadify.CubicBezierCurve(z1, z2, z3, z4));
|
||||
lengths.push(Math.hypot(z4.x - z1.x, z4.y - z1.y));
|
||||
last = z4;
|
||||
} else if (zs[j].cubic) {
|
||||
const z1 = last,
|
||||
z2 = zs[j],
|
||||
z3 = zs[j + 1],
|
||||
z4 = zs[j + 2];
|
||||
segments.push(new quadify.CubicBezierCurve(z1, z2, z3, z4));
|
||||
lengths.push(Math.hypot(z4.x - z1.x, z4.y - z1.y));
|
||||
last = z4;
|
||||
j += 2;
|
||||
} else {
|
||||
const z1 = last,
|
||||
zm = zs[j],
|
||||
z4 = zs[j + 1];
|
||||
const z2 = mix(zm, z1, 1 / 3);
|
||||
const z3 = mix(zm, z4, 1 / 3);
|
||||
segments.push(new quadify.CubicBezierCurve(z1, z2, z3, z4));
|
||||
lengths.push(Math.hypot(z4.x - z1.x, z4.y - z1.y));
|
||||
last = z4;
|
||||
j += 1;
|
||||
}
|
||||
}
|
||||
// Mark diagonals
|
||||
var lastmark = splitpoints[0];
|
||||
for (var k = 1; k < splitpoints.length && !splitpoints[k].mark; k++);
|
||||
var nextmark = splitpoints[k];
|
||||
var segments = estimateSegments(lastmark, nextmark);
|
||||
for (var j = 1; j < splitpoints.length - 1; j++) {
|
||||
if (splitpoints[j].mark) {
|
||||
lastmark = splitpoints[j];
|
||||
for (var k = j + 1; k < splitpoints.length && !splitpoints[k].mark; k++);
|
||||
nextmark = splitpoints[k];
|
||||
segments = estimateSegments(lastmark, nextmark);
|
||||
|
||||
let totalLength = 0;
|
||||
for (let j = 0; j < lengths.length; j++) totalLength += lengths[j];
|
||||
let lengthSofar = 0;
|
||||
for (let j = 0; j < lengths.length; j++) {
|
||||
let segLen = lengths[j];
|
||||
lengths[j] = lengthSofar / totalLength;
|
||||
lengthSofar += segLen;
|
||||
}
|
||||
if (splitpoints[j].on && !splitpoints[j].mark) {
|
||||
var z1 = splitpoints[j],
|
||||
z0 = splitpoints[j - 1],
|
||||
z2 = splitpoints[j + 1];
|
||||
var angle0 = Math.atan2(z2.y - z0.y, z2.x - z0.x);
|
||||
var angle = Math.abs(angle0 / Math.PI * segments % 1);
|
||||
var angleRotatedBefore = Math.abs(angleBetween(z1, lastmark, z1, z0));
|
||||
var angleRotatedAfter = Math.abs(angleBetween(z1, nextmark, z1, z2));
|
||||
if (!(Math.abs(Math.abs(angle0) - Math.PI / 2) <= SMALL || angle <= SMALL || angle >= 1 - SMALL)
|
||||
|| !(denseQ || enoughRotate(lastmark, z0, z1, z2, nextmark))) {
|
||||
z1.remove = z0.remove = z2.remove = true;
|
||||
this.segments = segments;
|
||||
this.lengths = lengths;
|
||||
// console.log(this.eval(0), this.eval(1 / 2), this.eval(1));
|
||||
// console.log(this.derivative(0), this.derivative(1 / 2), this.derivative(1));
|
||||
}
|
||||
getIndex(t) {
|
||||
let j = this.lengths.length - 1;
|
||||
while (j > 0 && this.lengths[j] > t) j--;
|
||||
return j;
|
||||
}
|
||||
eval(t) {
|
||||
const j = this.getIndex(t);
|
||||
const tBefore = this.lengths[j];
|
||||
const tNext = j < this.lengths.length - 1 ? this.lengths[j + 1] : 1;
|
||||
const tRelative = (t - tBefore) / (tNext - tBefore);
|
||||
return this.segments[j].eval(tRelative);
|
||||
}
|
||||
derivative(t) {
|
||||
const j = this.getIndex(t);
|
||||
const tBefore = this.lengths[j];
|
||||
const tNext = j < this.lengths.length - 1 ? this.lengths[j + 1] : 1;
|
||||
const tRelative = (t - tBefore) / (tNext - tBefore);
|
||||
// console.log(
|
||||
// t,
|
||||
// tRelative,
|
||||
// tNext,
|
||||
// tBefore,
|
||||
// tNext - tBefore,
|
||||
// this.segments[j].derivative(tRelative)
|
||||
// );
|
||||
const d = this.segments[j].derivative(tRelative);
|
||||
d.x /= tNext - tBefore;
|
||||
d.y /= tNext - tBefore;
|
||||
return d;
|
||||
}
|
||||
}
|
||||
|
||||
function buildCurve(curve) {
|
||||
let exitPoints = [];
|
||||
for (let j = 0; j < curve.length; j++) {
|
||||
if (!curve[j].mark) continue;
|
||||
let k = j;
|
||||
for (; k < curve.length && (k === j || !curve[k].mark); k++);
|
||||
exitPoints.push(curve[j]);
|
||||
const pts = curve.slice(j, k + 1);
|
||||
let nPtsOffPoints = 0;
|
||||
for (const z of pts) {
|
||||
if (!z.on) nPtsOffPoints += 1;
|
||||
}
|
||||
// Rebuild curve
|
||||
for (var j = 0; j < splitpoints.length; j++) if (splitpoints[j].on && !splitpoints[j].remove && splitpoints[j + 1] && !splitpoints[j + 1].on) {
|
||||
for (var k = j + 2; k < splitpoints.length && splitpoints[k].remove; k++);
|
||||
if (k - j > 2) {
|
||||
var zs = fitpts(splitpoints[j], splitpoints[j + 1], splitpoints[k], splitpoints[k + 1]);
|
||||
if (zs) {
|
||||
zs[0].on = zs[1].on = false;
|
||||
zs[0].cubic = zs[1].cubic = true;
|
||||
splitpoints[j + 1] = zs[0];
|
||||
splitpoints[k] = zs[1];
|
||||
if (nPtsOffPoints > 0) {
|
||||
const curve = new BezierCurveCluster(pts);
|
||||
const offPoints = quadify.autoQuadify(curve, 1 / 4);
|
||||
if (!offPoints) continue;
|
||||
for (let k = 0; k < offPoints.length; k++) {
|
||||
const z = offPoints[k];
|
||||
if (k > 0) {
|
||||
const z0 = offPoints[k - 1];
|
||||
exitPoints.push({
|
||||
x: (z.x + z0.x) / 2,
|
||||
y: (z.y + z0.y) / 2,
|
||||
on: true
|
||||
});
|
||||
}
|
||||
exitPoints.push({
|
||||
x: z.x,
|
||||
y: z.y,
|
||||
cubic: false,
|
||||
on: false
|
||||
});
|
||||
}
|
||||
}
|
||||
j = k;
|
||||
j = k - 1;
|
||||
}
|
||||
return exitPoints;
|
||||
}
|
||||
|
||||
module.exports = function(sourceCurve, gizmo) {
|
||||
for (let j = 0; j < sourceCurve.length; j++) {
|
||||
if (!isFinite(sourceCurve[j].x)) sourceCurve[j].x = 0;
|
||||
if (!isFinite(sourceCurve[j].y)) sourceCurve[j].y = 0;
|
||||
sourceCurve[j] = Transform.untransform(gizmo, sourceCurve[j]);
|
||||
}
|
||||
const curve = splitCurve(sourceCurve);
|
||||
markCorners(curve);
|
||||
const builtCurve = buildCurve(curve);
|
||||
const ans = [];
|
||||
for (let j = 0; j < builtCurve.length; j++) {
|
||||
if (builtCurve[j] && !builtCurve[j].remove) {
|
||||
ans.push(Transform.transformPoint(gizmo, builtCurve[j]));
|
||||
}
|
||||
var ans = [];
|
||||
for (var j = 0; j < splitpoints.length; j++)if (splitpoints[j] && !splitpoints[j].remove) {
|
||||
ans.push(Transform.transformPoint(gizmo, splitpoints[j]));
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
module.exports = fairify;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -251,102 +251,3 @@ export all : class Glyph
|
|||
set {.x lx .y ly} zf
|
||||
inc j
|
||||
return c
|
||||
|
||||
public [cleanup t] : begin
|
||||
foreach c [range 0 this.contours.length] : begin
|
||||
local ocontour this.contours.(c)
|
||||
# add infections
|
||||
local contour {[new Point ocontour.0.x ocontour.0.y ocontour.0.on]}
|
||||
local flag 0
|
||||
foreach [j : range 1 (ocontour.length - 1)] : piecewise
|
||||
flag : dec flag
|
||||
ocontour.(j).on : contour.push ocontour.(j)
|
||||
ocontour.(j).cubic : begin
|
||||
local p0 contour.(contour.length - 1)
|
||||
local p1 ocontour.(j)
|
||||
local p2 ocontour.(j + 1)
|
||||
local p3 ocontour.(j + 2)
|
||||
local strand : new Bezier p0.x p0.y p1.x p1.y p2.x p2.y p3.x p3.y
|
||||
local ts [strand.extrema].y
|
||||
piecewise
|
||||
(!ts || ts.length < 1) : contour.push p1 p2 p3
|
||||
true : begin
|
||||
set ts [ts.sort byx]
|
||||
ts.unshift 0
|
||||
ts.push 1
|
||||
foreach [k : range 0 (ts.length - 1)] : begin
|
||||
local s : strand.split ts.(k) ts.(k + 1)
|
||||
if s.points : begin
|
||||
contour.push : new Point s.points.1.x s.points.1.y false true
|
||||
contour.push : new Point s.points.2.x s.points.2.y false true
|
||||
contour.push : new Point s.points.3.x s.points.3.y true
|
||||
set flag 2
|
||||
true : begin
|
||||
local p0 contour.(contour.length - 1)
|
||||
local p1 ocontour.(j)
|
||||
local p2 ocontour.(j + 1)
|
||||
if [not p2.on] : set p2 : new Point [mix p1.x p2.x 0.5] [mix p1.y p2.y 0.5] true
|
||||
local strand : new Bezier p0.x p0.y p1.x p1.y p2.x p2.y
|
||||
local ts [strand.extrema].y
|
||||
piecewise
|
||||
(!ts || ts.length < 1) : contour.push p1 p2
|
||||
true : begin
|
||||
set ts [ts.sort byx]
|
||||
ts.unshift 0
|
||||
ts.push 1
|
||||
foreach [k : range 0 (ts.length - 1)] : begin
|
||||
local s : strand.split ts.(k) ts.(k + 1)
|
||||
if s.points : contour.push
|
||||
new Point s.points.1.x s.points.1.y false
|
||||
new Point s.points.2.x s.points.2.y true
|
||||
set flag 1
|
||||
|
||||
contour.push [new Point ocontour.(ocontour.length - 1).x ocontour.(ocontour.length - 1).y ocontour.(ocontour.length - 1).on]
|
||||
|
||||
# cleanup
|
||||
local cleanedContour {}
|
||||
foreach j [range 1 : contour.length - 1] : begin
|
||||
local p0 contour.(j - 1)
|
||||
local p1 contour.(j)
|
||||
local p2 contour.(j + 1)
|
||||
if [oncurveRemovable p0 p1 p2 t] : set p1.unimportant true
|
||||
foreach point [items-of contour] : if [not point.unimportant] : cleanedContour.push point
|
||||
set contour cleanedContour
|
||||
|
||||
set cleanedContour {}
|
||||
foreach j [range 0 contour.length] : if ([not contour.(j).cubic] && [not contour.(j).unimportant]) : begin
|
||||
local found false
|
||||
for [local k : j + 1] ((k < contour.length) && (
|
||||
[not contour.(k).cubic] && [closepoint contour.(j) contour.(k) t]
|
||||
|| contour.(k).cubic && contour.(k + 1).cubic
|
||||
&& [closepoint contour.(j) contour.(k) t]
|
||||
&& [closepoint contour.(j) contour.(k) t]
|
||||
&& [closepoint contour.(j) contour.(k + 2) t])) [inc k] : begin
|
||||
set contour.(k).unimportant true
|
||||
set found true
|
||||
if (contour.(k).cubic && contour.(k + 1).cubic
|
||||
&& [closepoint contour.(j) contour.(k) t]
|
||||
&& [closepoint contour.(j) contour.(k) t]
|
||||
&& [closepoint contour.(j) contour.(k + 2) t]) : begin
|
||||
set contour.(k + 1).unimportant true
|
||||
set contour.(k + 2).unimportant true
|
||||
set k : k + 2
|
||||
if found : begin
|
||||
set contour.(j).on true
|
||||
set j (k - 1)
|
||||
foreach point [items-of contour] : if [not point.unimportant] : cleanedContour.push point
|
||||
this.contours.(c) = cleanedContour
|
||||
set this.contours : this.contours.filter : lambda [c] : begin
|
||||
if [not c.length] : return false
|
||||
local xmin c.(0).x
|
||||
local xmax c.(0).x
|
||||
local ymin c.(0).y
|
||||
local ymax c.(0).y
|
||||
foreach z [items-of c] : begin
|
||||
if (z.x < xmin) : set xmin z.x
|
||||
if (z.x > xmax) : set xmax z.x
|
||||
if (z.y < ymin) : set ymin z.y
|
||||
if (z.y > ymax) : set ymax z.y
|
||||
return : ymax - ymin > 1 && xmax - xmin > 1
|
||||
return this
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
function maskBit(x, y) {
|
||||
return (x & (1 << y));
|
||||
return x & (1 << y);
|
||||
}
|
||||
|
||||
module.exports = maskBit;
|
||||
|
|
|
|||
|
|
@ -1,72 +1,112 @@
|
|||
module.exports = function(xs, ys) {
|
||||
var i, length = xs.length;
|
||||
let i,
|
||||
length = xs.length;
|
||||
|
||||
// Deal with length issues
|
||||
if (length != ys.length) { throw 'Need an equal count of xs and ys.'; }
|
||||
if (length === 0) { return function(x) { return 0; }; }
|
||||
if (length != ys.length) {
|
||||
throw "Need an equal count of xs and ys.";
|
||||
}
|
||||
if (length === 0) {
|
||||
return function() {
|
||||
return 0;
|
||||
};
|
||||
}
|
||||
if (length === 1) {
|
||||
// Impl: Precomputing the result prevents problems if ys is mutated later and allows garbage collection of ys
|
||||
// Impl: Unary plus properly converts values to numbers
|
||||
var result = +ys[0];
|
||||
return function(x) { return result; };
|
||||
let result = +ys[0];
|
||||
return function() {
|
||||
return result;
|
||||
};
|
||||
}
|
||||
|
||||
// Rearrange xs and ys so that xs is sorted
|
||||
var indexes = [];
|
||||
for (i = 0; i < length; i++) { indexes.push(i); }
|
||||
indexes.sort(function(a, b) { return xs[a] < xs[b] ? -1 : 1; });
|
||||
var oldXs = xs, oldYs = ys;
|
||||
let indexes = [];
|
||||
for (i = 0; i < length; i++) {
|
||||
indexes.push(i);
|
||||
}
|
||||
indexes.sort(function(a, b) {
|
||||
return xs[a] < xs[b] ? -1 : 1;
|
||||
});
|
||||
let oldXs = xs,
|
||||
oldYs = ys;
|
||||
// Impl: Creating new arrays also prevents problems if the input arrays are mutated later
|
||||
xs = []; ys = [];
|
||||
xs = [];
|
||||
ys = [];
|
||||
// Impl: Unary plus properly converts values to numbers
|
||||
for (i = 0; i < length; i++) { xs.push(+oldXs[indexes[i]]); ys.push(+oldYs[indexes[i]]); }
|
||||
for (i = 0; i < length; i++) {
|
||||
xs.push(+oldXs[indexes[i]]);
|
||||
ys.push(+oldYs[indexes[i]]);
|
||||
}
|
||||
|
||||
// Get consecutive differences and slopes
|
||||
var dys = [], dxs = [], ms = [];
|
||||
let dys = [],
|
||||
dxs = [],
|
||||
ms = [];
|
||||
for (i = 0; i < length - 1; i++) {
|
||||
var dx = xs[i + 1] - xs[i], dy = ys[i + 1] - ys[i];
|
||||
dxs.push(dx); dys.push(dy); ms.push(dy / dx);
|
||||
const dx = xs[i + 1] - xs[i],
|
||||
dy = ys[i + 1] - ys[i];
|
||||
dxs.push(dx);
|
||||
dys.push(dy);
|
||||
ms.push(dy / dx);
|
||||
}
|
||||
|
||||
// Get degree-1 coefficients
|
||||
var c1s = [ms[0]];
|
||||
let c1s = [ms[0]];
|
||||
for (i = 0; i < dxs.length - 1; i++) {
|
||||
var m = ms[i], mNext = ms[i + 1];
|
||||
const m = ms[i],
|
||||
mNext = ms[i + 1];
|
||||
if (m * mNext <= 0) {
|
||||
c1s.push(0);
|
||||
} else {
|
||||
var dx = dxs[i], dxNext = dxs[i + 1], common = dx + dxNext;
|
||||
c1s.push(3 * common / ((common + dxNext) / m + (common + dx) / mNext));
|
||||
const dx = dxs[i],
|
||||
dxNext = dxs[i + 1],
|
||||
common = dx + dxNext;
|
||||
c1s.push((3 * common) / ((common + dxNext) / m + (common + dx) / mNext));
|
||||
}
|
||||
}
|
||||
c1s.push(ms[ms.length - 1]);
|
||||
|
||||
// Get degree-2 and degree-3 coefficients
|
||||
var c2s = [], c3s = [];
|
||||
let c2s = [],
|
||||
c3s = [];
|
||||
for (i = 0; i < c1s.length - 1; i++) {
|
||||
var c1 = c1s[i], m = ms[i], invDx = 1 / dxs[i], common = c1 + c1s[i + 1] - m - m;
|
||||
c2s.push((m - c1 - common) * invDx); c3s.push(common * invDx * invDx);
|
||||
const c1 = c1s[i],
|
||||
m = ms[i],
|
||||
invDx = 1 / dxs[i],
|
||||
common = c1 + c1s[i + 1] - m - m;
|
||||
c2s.push((m - c1 - common) * invDx);
|
||||
c3s.push(common * invDx * invDx);
|
||||
}
|
||||
|
||||
// Return interpolant function
|
||||
return function(x) {
|
||||
// The rightmost point in the dataset should give an exact result
|
||||
var i = xs.length - 1;
|
||||
if (x == xs[i]) { return ys[i]; }
|
||||
let i = xs.length - 1;
|
||||
if (x == xs[i]) {
|
||||
return ys[i];
|
||||
}
|
||||
|
||||
// Search for the interval x is in, returning the corresponding y if x is one of the original xs
|
||||
var low = 0, mid, high = c3s.length - 1;
|
||||
let low = 0,
|
||||
mid,
|
||||
high = c3s.length - 1;
|
||||
while (low <= high) {
|
||||
mid = Math.floor(0.5 * (low + high));
|
||||
var xHere = xs[mid];
|
||||
if (xHere < x) { low = mid + 1; }
|
||||
else if (xHere > x) { high = mid - 1; }
|
||||
else { return ys[mid]; }
|
||||
let xHere = xs[mid];
|
||||
if (xHere < x) {
|
||||
low = mid + 1;
|
||||
} else if (xHere > x) {
|
||||
high = mid - 1;
|
||||
} else {
|
||||
return ys[mid];
|
||||
}
|
||||
}
|
||||
i = Math.max(0, high);
|
||||
|
||||
// Interpolate
|
||||
var diff = x - xs[i], diffSq = diff * diff;
|
||||
let diff = x - xs[i],
|
||||
diffSq = diff * diff;
|
||||
return ys[i] + c1s[i] * diff + c2s[i] * diffSq + c3s[i] * diff * diffSq;
|
||||
};
|
||||
};
|
||||
10
verdafile.js
10
verdafile.js
|
|
@ -27,12 +27,12 @@ want(...argv._);
|
|||
////// Oracles //////
|
||||
///////////////////////////////////////////////////////////
|
||||
|
||||
oracle(`o:version`).def(async target => {
|
||||
oracle(`o:version`).def(async () => {
|
||||
const package_json = JSON.parse(fs.readFileSync(path.join(__dirname, "package.json")));
|
||||
return package_json.version;
|
||||
});
|
||||
|
||||
oracle(`o:raw-plans`).def(async target => {
|
||||
oracle(`o:raw-plans`).def(async () => {
|
||||
const t = toml.parse(fs.readFileSync(path.resolve(__dirname, "build-plans.toml")));
|
||||
for (const prefix in t.buildPlans) {
|
||||
const plan = t.buildPlans[prefix];
|
||||
|
|
@ -287,7 +287,7 @@ task("contents:***").def(async (target, gid) => {
|
|||
});
|
||||
|
||||
// Archive
|
||||
task(`${ARCHIVE_DIR}/*-*.zip`).def(async (target, gid, version) => {
|
||||
task(`${ARCHIVE_DIR}/*-*.zip`).def(async (target, gid) => {
|
||||
// Note: this target does NOT depend on the font files.
|
||||
const [exportPlans] = await target.need(`o:export-plans`, `dir:${target.path.dir}`);
|
||||
await target.need(`contents:${exportPlans[gid]}`);
|
||||
|
|
@ -308,7 +308,7 @@ task("collection-fonts:***").def(async (target, cid) => {
|
|||
const [{ groups }] = await target.need("o:collect-plans");
|
||||
await target.need(groups[cid].map(file => `${DIST}/collections/${cid}/${file}.ttc`));
|
||||
});
|
||||
task(`${ARCHIVE_DIR}/ttc-*-*.zip`).def(async (target, cid, version) => {
|
||||
task(`${ARCHIVE_DIR}/ttc-*-*.zip`).def(async (target, cid) => {
|
||||
// Note: this target does NOT depend on the font files.
|
||||
await target.need(`dir:${target.path.dir}`);
|
||||
await target.need(`collection-fonts:${cid}`);
|
||||
|
|
@ -375,7 +375,7 @@ task(`all:archives`).def(async target => {
|
|||
);
|
||||
});
|
||||
|
||||
phony(`clean`).def(async target => {
|
||||
phony(`clean`).def(async () => {
|
||||
await rm(`build`);
|
||||
await rm(`dist`);
|
||||
await rm(`release-archives`);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue