hanzi-chai 0.3.0

package/dist/bezier.js

@@ -0,0 +1,140 @@
+import { add, subtract, mean, multiply, divide, distance, dot } from "./mathjs.js";
+export const sortTwoNumbers = (ar) => ar.sort((a, b) => a - b);
+const getBoundingBox = (a) => [a.controls[0], a.controls[a.controls.length - 1]];
+const getIntervalOnOrientation = (a) => {
+    const start = a.controls[0];
+    const end = a.controls.at(-1);
+    const i1 = sortTwoNumbers([start[0], end[0]]);
+    const i2 = sortTwoNumbers([start[1], end[1]]);
+    if (a.orientation === "horizontal") {
+        return [i1, i2];
+    }
+    return [i2, i1];
+};
+const evaluate = (a, t) => {
+    if (a.type === "linear") {
+        return add(multiply(1 - t, a.controls[0]), multiply(t, a.controls[1]));
+    }
+    if (a.type === "arc") {
+        return [0, 0];
+    }
+    const v01 = add(multiply((1 - t) ** 3, a.controls[0]), multiply(3 * (1 - t) ** 2 * t, a.controls[1]));
+    const v23 = add(multiply(3 * (1 - t) * t ** 2, a.controls[2]), multiply(t ** 3, a.controls[3]));
+    return add(v01, v23);
+};
+const makeCurve = (start, { command, parameterList }) => {
+    if (command === "a") {
+        return {
+            type: "arc",
+            orientation: "horizontal",
+            controls: [start, start],
+        };
+    }
+    if (command === "c" || command === "z") {
+        const p1 = add(start, parameterList.slice(0, 2));
+        const p2 = add(start, parameterList.slice(2, 4));
+        const p3 = add(start, parameterList.slice(4));
+        return {
+            type: "cubic",
+            orientation: command === "c" ? "vertical" : "horizontal",
+            controls: [start, p1, p2, p3],
+        };
+    }
+    let p1;
+    switch (command) {
+        case "h":
+            p1 = add(start, [parameterList[0], 0]);
+            break;
+        case "v":
+            p1 = add(start, [0, parameterList[0]]);
+            break;
+    }
+    return {
+        type: "linear",
+        orientation: command === "v" ? "vertical" : "horizontal",
+        controls: [start, p1],
+    };
+};
+const render = ({ feature, start, curveList }) => {
+    const r = { feature, curveList: [] };
+    let previousPosition = start;
+    for (const draw of curveList) {
+        const curve = makeCurve(previousPosition, draw);
+        previousPosition =
+            curve.type === "linear"
+                ? curve.controls[1]
+                : curve.type === "arc"
+                    ? curve.controls[1]
+                    : curve.controls[3];
+        r.curveList.push(curve);
+    }
+    return r;
+};
+const area = (p, q) => p[0] * q[1] - p[1] * q[0];
+const getIntervalPosition = (i, j) => {
+    const [imin, imax] = i.sort((a, b) => a - b);
+    const [jmin, jmax] = j.sort((a, b) => a - b);
+    // totally disjoint
+    if (imax < jmin)
+        return -1;
+    if (imin > jmax)
+        return 1;
+    // generally smaller or larger
+    if (imin < jmin && imax < jmax)
+        return -0.5;
+    if (imin > jmin && imax > jmax)
+        return +0.5;
+    return 0;
+};
+const findCrossPoint = (a, at, b, bt) => {
+    const [astart, aend] = [evaluate(a, at[0]), evaluate(a, at[1])];
+    const [bstart, bend] = [evaluate(b, bt[0]), evaluate(b, bt[1])];
+    const xposition = getIntervalPosition([astart[0], aend[0]], [bstart[0], bend[0]]);
+    const yposition = getIntervalPosition([astart[1], aend[1]], [bstart[1], bend[1]]);
+    const totallyDisjoint = [-1, 1];
+    if (totallyDisjoint.includes(xposition) ||
+        totallyDisjoint.includes(yposition))
+        return undefined;
+    const [alength, blength] = [distance(astart, aend), distance(bstart, bend)];
+    const threshold = 1;
+    if (alength < threshold && blength < threshold)
+        return divide(add(add(astart, aend), add(bstart, bend)), 4);
+    const [atmid, btmid] = [mean(at), mean(bt)];
+    const a_firsthalf = [at[0], atmid];
+    const a_secondhalf = [atmid, at[1]];
+    const b_firsthalf = [bt[0], btmid];
+    const b_secondhalf = [btmid, bt[1]];
+    return (findCrossPoint(a, a_firsthalf, b, b_firsthalf) ||
+        findCrossPoint(a, a_firsthalf, b, b_secondhalf) ||
+        findCrossPoint(a, a_secondhalf, b, b_firsthalf) ||
+        findCrossPoint(a, a_secondhalf, b, b_secondhalf));
+};
+/**
+ * Determine if the point is on a given segment
+ * @param from - starting point
+ * @param to - end point
+ * @param point - another point
+ * @returns
+ */
+const isCollinear = (from, to, point) => {
+    const [u, v] = [subtract(to, point), subtract(from, point)];
+    return area(u, v) === 0 && dot(u, v) < 0;
+};
+const curveLength = (curve) => {
+    const [start, end] = getBoundingBox(curve);
+    return distance(start, end);
+};
+const sort = (a) => a.sort((a, b) => a - b);
+const contains = (r1, r2) => {
+    return r1[0] <= r2[0] && r1[1] >= r2[1];
+};
+const _isBoundedBy = (curve, xrange, yrange) => {
+    const [start, end] = getBoundingBox(curve);
+    const thisXRange = sort([start[0], end[0]]);
+    const thisYRange = sort([start[1], end[1]]);
+    return contains(xrange, thisXRange) && contains(yrange, thisYRange);
+};
+const isBoundedBy = (stroke, xrange, yrange) => {
+    return stroke.curveList.every((x) => _isBoundedBy(x, xrange, yrange));
+};
+export { getBoundingBox, getIntervalOnOrientation, getIntervalPosition, render, makeCurve, area, curveLength, findCrossPoint, isCollinear, isBoundedBy, };

package/dist/classifier.d.ts

@@ -0,0 +1,109 @@
+import type { Draw } from "./data.js";
+/**
+ * 笔画名称参考 Unicode 中的 CJK 笔画块（共 38 种笔画）
+ * 本系统共 41 种笔画，和 CJK 笔画的区别在于：
+ * 1. U+31D2（P）称为平撇，而 U+31D3（SP）称为撇
+ * 2. 仿照撇，在捺中分出了平捺、点中分出了平点
+ * 3. 添加「特殊笔画」分类，用于表示一些无法归类的笔画
+ * https://en.wikipedia.org/wiki/CJK_Strokes_(Unicode_block)
+ * 分类参考 GF2001-2001 给出的笔画分类规范，将笔画分为 5 类，用数字表示
+ */
+export declare const classifier: {
+    横: number;
+    提: number;
+    竖: number;
+    竖钩: number;
+    撇: number;
+    平撇: number;
+    点: number;
+    平点: number;
+    捺: number;
+    平捺: number;
+    挑捺: number;
+    横钩: number;
+    横撇: number;
+    横折: number;
+    横折钩: number;
+    横斜钩: number;
+    横折提: number;
+    横折折: number;
+    横折弯: number;
+    横撇弯钩: number;
+    横折弯钩: number;
+    横斜弯钩: number;
+    横折折撇: number;
+    横折折折: number;
+    横折折折钩: number;
+    竖提: number;
+    竖折: number;
+    竖弯: number;
+    竖弯左: number;
+    竖弯钩: number;
+    竖折撇: number;
+    竖折折钩: number;
+    竖折折: number;
+    撇点: number;
+    撇折: number;
+    弯钩: number;
+    斜钩: number;
+    撇钩: number;
+    卧钩: number;
+    圈: number;
+    特殊笔画: number;
+};
+/**
+ * 给定方案配置文件中的不完整的分类器，将其与默认的分类器合并
+ * 得到一个完整的分类器
+ */
+export declare const mergeClassifier: (partialClassifier?: Record<Feature, number>) => {
+    横: number;
+    提: number;
+    竖: number;
+    竖钩: number;
+    撇: number;
+    平撇: number;
+    点: number;
+    平点: number;
+    捺: number;
+    平捺: number;
+    挑捺: number;
+    横钩: number;
+    横撇: number;
+    横折: number;
+    横折钩: number;
+    横斜钩: number;
+    横折提: number;
+    横折折: number;
+    横折弯: number;
+    横撇弯钩: number;
+    横折弯钩: number;
+    横斜弯钩: number;
+    横折折撇: number;
+    横折折折: number;
+    横折折折钩: number;
+    竖提: number;
+    竖折: number;
+    竖弯: number;
+    竖弯左: number;
+    竖弯钩: number;
+    竖折撇: number;
+    竖折折钩: number;
+    竖折折: number;
+    撇点: number;
+    撇折: number;
+    弯钩: number;
+    斜钩: number;
+    撇钩: number;
+    卧钩: number;
+    圈: number;
+    特殊笔画: number;
+};
+export type Feature = keyof typeof classifier;
+export type Classifier = typeof classifier;
+/**
+ * 特定类型的笔画在数据库中的表示所包含的 SVG 命令的类别和数量是固定的
+ * 比如，横折折折钩的表示一定是 h v h v，不会有其他可能性
+ * 另外，平撇、平点、平捺的命令是 z，这个不是规范的 SVG 命令，只是为了和撇、点、捺的 c 区分
+ * z 和 c 的实际效果是一样的
+ */
+export declare const schema: Record<Feature, Draw["command"][]>;

package/dist/classifier.js

@@ -0,0 +1,108 @@
+/**
+ * 笔画名称参考 Unicode 中的 CJK 笔画块（共 38 种笔画）
+ * 本系统共 41 种笔画，和 CJK 笔画的区别在于：
+ * 1. U+31D2（P）称为平撇，而 U+31D3（SP）称为撇
+ * 2. 仿照撇，在捺中分出了平捺、点中分出了平点
+ * 3. 添加「特殊笔画」分类，用于表示一些无法归类的笔画
+ * https://en.wikipedia.org/wiki/CJK_Strokes_(Unicode_block)
+ * 分类参考 GF2001-2001 给出的笔画分类规范，将笔画分为 5 类，用数字表示
+ */
+export const classifier = {
+    横: 1,
+    提: 1,
+    竖: 2,
+    竖钩: 2,
+    撇: 3,
+    平撇: 3,
+    点: 4,
+    平点: 4,
+    捺: 4,
+    平捺: 4,
+    挑捺: 4,
+    横钩: 5,
+    横撇: 5,
+    横折: 5,
+    横折钩: 5,
+    横斜钩: 5,
+    横折提: 5,
+    横折折: 5,
+    横折弯: 5,
+    横撇弯钩: 5,
+    横折弯钩: 5,
+    横斜弯钩: 5,
+    横折折撇: 5,
+    横折折折: 5,
+    横折折折钩: 5,
+    竖提: 5,
+    竖折: 5,
+    竖弯: 5,
+    竖弯左: 5,
+    竖弯钩: 5,
+    竖折撇: 5,
+    竖折折钩: 5,
+    竖折折: 5,
+    撇点: 5,
+    撇折: 5,
+    弯钩: 5,
+    斜钩: 5,
+    撇钩: 5,
+    卧钩: 5,
+    圈: 5,
+    特殊笔画: 5,
+};
+/**
+ * 给定方案配置文件中的不完整的分类器，将其与默认的分类器合并
+ * 得到一个完整的分类器
+ */
+export const mergeClassifier = (partialClassifier) => {
+    return { ...classifier, ...(partialClassifier ?? {}) };
+};
+/**
+ * 特定类型的笔画在数据库中的表示所包含的 SVG 命令的类别和数量是固定的
+ * 比如，横折折折钩的表示一定是 h v h v，不会有其他可能性
+ * 另外，平撇、平点、平捺的命令是 z，这个不是规范的 SVG 命令，只是为了和撇、点、捺的 c 区分
+ * z 和 c 的实际效果是一样的
+ */
+export const schema = {
+    横: ["h"],
+    提: ["h"], // 美化：提
+    竖: ["v"],
+    竖钩: ["v"], // 美化：钩
+    撇: ["c"],
+    平撇: ["z"],
+    点: ["c"],
+    平点: ["z"],
+    捺: ["c"],
+    平捺: ["z"],
+    挑捺: ["h", "c"],
+    横钩: ["h"], // 美化：钩
+    横撇: ["h", "c"],
+    横折: ["h", "v"],
+    横折钩: ["h", "v"], // 美化：钩
+    横斜钩: ["h", "c"], // 美化：钩
+    横折提: ["h", "v", "h"], // 美化：提
+    横折折: ["h", "v", "h"],
+    横折弯: ["h", "v", "h"],
+    横撇弯钩: ["h", "c", "v"], // 美化：钩
+    横折弯钩: ["h", "v", "h"], // 美化：钩
+    横斜弯钩: ["h", "c"], // 美化：钩
+    横折折撇: ["h", "v", "h", "c"],
+    横折折折: ["h", "v", "h", "v"],
+    横折折折钩: ["h", "v", "h", "v"], // 美化：钩
+    竖提: ["v", "h"], // 美化：提
+    竖折: ["v", "h"],
+    竖弯: ["v", "h"],
+    竖弯左: ["v", "h"],
+    竖弯钩: ["v", "h"], // 美化：钩
+    竖折撇: ["v", "h", "c"],
+    竖折折钩: ["v", "h", "v"], // 美化：钩
+    竖折折: ["v", "h", "v"],
+    撇点: ["c", "c"],
+    撇折: ["c", "h"],
+    弯钩: ["v"], // 美化：钩
+    斜钩: ["c"], // 美化：钩
+    撇钩: ["c"], // 美化：钩
+    卧钩: ["c"], // 美化：钩
+    圈: ["a"],
+    特殊笔画: ["c"],
+};

package/dist/component.d.ts

@@ -0,0 +1,115 @@
+import type { SieveName } from "./config.js";
+import type { Repertoire, PrimitiveRepertoire, SVGGlyph, Component, Identity } from "./data.js";
+import type { RenderedGlyph, Topology } from "./topology.js";
+import { type Classifier } from "./classifier.js";
+import type { AnalysisConfig } from "./repertoire.js";
+export declare class InvalidGlyphError extends Error {
+}
+export declare const makeIntervalSum: (strokes: number, rootsSet: Set<number>) => Set<number>;
+/**
+ * 根据一个部件中包含的所有字根的情况，导出所有可能的拆分方案
+ *
+ * @param strokes - 部件笔画数
+ * @param roots - 部件包含的字根列表，其中每个字根用二进制表示
+ *
+ * 函数通过递归的方式，每次选取剩余部分的第一笔，然后在字根列表中找到包含这个笔画的所有字根
+ * 将这些可能性与此前已经拆分的部分组合，得到新的拆分方案
+ * 直到所有的笔画都使用完毕
+ */
+export declare const generateSchemes: (strokes: number, roots: number[], requiredRoots: Set<number>) => number[][];
+/**
+ * 计算后的部件 ComputedComponent
+ *
+ * 在基本部件 BasicComponent 的基础上，将 SVG 命令转换为参数曲线
+ * 再基于参数曲线计算拓扑
+ */
+export interface ComputedComponent {
+    name: string;
+    glyph: RenderedGlyph;
+    topology: Topology;
+}
+export declare class NoSchemeError extends Error {
+}
+export declare class MultipleSchemeError extends Error {
+}
+/**
+ * 通过自动拆分算法，给定字根列表，对部件进行拆分
+ * @param component - 部件
+ * @param rootData - 字根列表
+ * @param config - 配置
+ * @param classifier - 笔画分类器
+ *
+ * 如果拆分唯一，则返回拆分结果；否则返回错误
+ *
+ * @returns 拆分结果
+ * @throws NoSchemeError 无拆分方案
+ * @throws MultipleSchemeError 多个拆分方案
+ */
+export declare const getComponentScheme: (component: ComputedComponent, rootData: ComputedComponent[], config: AnalysisConfig, classifier: Classifier) => ComponentAnalysis | NoSchemeError | MultipleSchemeError;
+/**
+ * 部件的拆分结果
+ */
+export type ComponentAnalysis = ComponentBasicAnalysis | ComponentGenuineAnalysis;
+export interface SchemeWithData {
+    scheme: number[];
+    roots: string[];
+    evaluation: Map<SieveName, number | number[]>;
+    optional: boolean;
+}
+export interface CommonAnalysis {
+    sequence: string[];
+    sequencePartIndex?: number[];
+    full: string[];
+}
+/**
+ * 部件本身是字根字，或者是由自定义部件拆分指定的无理拆分，无拆分细节
+ */
+export interface ComponentBasicAnalysis extends CommonAnalysis {
+    strokes: number;
+    operator: undefined;
+}
+/**
+ * 部件通过自动拆分算法分析得到的拆分结果的全部细节
+ */
+export interface ComponentGenuineAnalysis extends ComponentBasicAnalysis {
+    map: Map<number, string>;
+    best: SchemeWithData;
+    schemes: SchemeWithData[];
+}
+export type ComponentResults = Map<string, ComponentAnalysis>;
+/**
+ * 递归渲染一个部件（基本部件或者衍生部件）
+ * 如果是基本部件就直接返回，如果是衍生部件则先渲染源字的图形，然后解引用得到这个部件的图形
+ *
+ * @param component - 部件
+ * @param repertoire - 原始字符集
+ * @param glyphCache - 部件缓存
+ *
+ * @returns 部件的 SVG 图形
+ * @throws InvalidGlyphError 无法渲染
+ */
+export declare const recursiveRenderComponent: (component: Component | Identity, repertoire: PrimitiveRepertoire, glyphCache?: Map<string, SVGGlyph>, depth?: number) => SVGGlyph | InvalidGlyphError;
+/**
+ * 把一个基本部件从 SVG 图形出发，先渲染成 Bezier 图形，然后计算拓扑
+ *
+ * 这样，便于后续的字根认同计算
+ */
+export declare const computeComponent: (name: string, svgglyph: SVGGlyph) => ComputedComponent;
+/**
+ * 将所有的字根都计算成 ComputedComponent
+ *
+ * @param repertoire - 字符集
+ * @param config - 配置
+ *
+ * @returns 所有计算后字根的列表
+ */
+export declare const renderRootList: (repertoire: Repertoire, elements: string[]) => Map<string, ComputedComponent>;
+/**
+ * 对所有部件进行拆分
+ *
+ * @param repertoire - 字符集
+ * @param config - 配置
+ *
+ * @returns 拆分结果和无法拆分的汉字列表
+ */
+export declare const disassembleComponents: (repertoire: Repertoire, config: AnalysisConfig, characters: string[], components: Set<string>) => [ComponentResults, string[]];