hanzi-chai 0.3.0

package/dist/component.js

@@ -0,0 +1,278 @@
+import { defaultDegenerator, generateSliceBinaries } from "./degenerator.js";
+import { select } from "./selector.js";
+import { bisectLeft, bisectRight } from "d3-array";
+import { findTopology, renderSVGGlyph } from "./topology.js";
+import { mergeClassifier } from "./classifier.js";
+import { isComponent } from "./utils.js";
+import { getGlyphBoundingBox, recursiveRenderCompound } from "./compound.js";
+import { affineMerge } from "./affine.js";
+export class InvalidGlyphError extends Error {
+}
+export const makeIntervalSum = (strokes, rootsSet) => {
+    const array = [...Array(strokes).keys()].map((x) => 1 << x).reverse();
+    const intervalSums = new Set();
+    for (let start = 0; start !== strokes - 1; ++start) {
+        let sum = array[start];
+        for (let end = start + 1; end !== strokes; ++end) {
+            sum += array[end];
+            if (rootsSet.has(sum)) {
+                intervalSums.add(sum);
+            }
+        }
+    }
+    return intervalSums;
+};
+/**
+ * 根据一个部件中包含的所有字根的情况，导出所有可能的拆分方案
+ *
+ * @param strokes - 部件笔画数
+ * @param roots - 部件包含的字根列表，其中每个字根用二进制表示
+ *
+ * 函数通过递归的方式，每次选取剩余部分的第一笔，然后在字根列表中找到包含这个笔画的所有字根
+ * 将这些可能性与此前已经拆分的部分组合，得到新的拆分方案
+ * 直到所有的笔画都使用完毕
+ */
+export const generateSchemes = (strokes, roots, requiredRoots) => {
+    const schemeList = [];
+    const total = (1 << strokes) - 1;
+    const intervalSums = makeIntervalSum(strokes, requiredRoots);
+    const combineNext = (partialSum, scheme, revcumsum) => {
+        const restBin = total - partialSum;
+        const restBin1st = 1 << (restBin.toString(2).length - 1);
+        const start = bisectLeft(roots, restBin1st);
+        const end = bisectRight(roots, restBin);
+        for (const binary of roots.slice(start, end)) {
+            if ((partialSum & binary) !== 0)
+                continue;
+            const newPartialSum = partialSum + binary;
+            const newRevcumsum = revcumsum.map((x) => x + binary);
+            const newScheme = scheme.concat(binary);
+            if (newRevcumsum.some((x) => intervalSums.has(x))) {
+                continue;
+            }
+            newRevcumsum.push(binary);
+            if (newPartialSum === total) {
+                schemeList.push(newScheme);
+            }
+            else {
+                combineNext(newPartialSum, newScheme, newRevcumsum);
+            }
+        }
+    };
+    combineNext(0, [], []);
+    return schemeList;
+};
+export class NoSchemeError extends Error {
+}
+export class MultipleSchemeError extends Error {
+}
+/**
+ * 通过自动拆分算法，给定字根列表，对部件进行拆分
+ * @param component - 部件
+ * @param rootData - 字根列表
+ * @param config - 配置
+ * @param classifier - 笔画分类器
+ *
+ * 如果拆分唯一，则返回拆分结果；否则返回错误
+ *
+ * @returns 拆分结果
+ * @throws NoSchemeError 无拆分方案
+ * @throws MultipleSchemeError 多个拆分方案
+ */
+export const getComponentScheme = (component, rootData, config, classifier) => {
+    const currentRoots = new Set([...config.roots.keys()]);
+    const optionalRoots = new Set([...config.optionalRoots.keys()]);
+    const requiredRoots = new Set([...currentRoots].filter((x) => !optionalRoots.has(x)));
+    if (requiredRoots.has(component.name))
+        return {
+            strokes: component.glyph.length,
+            sequence: [component.name],
+            full: [component.name],
+            operator: undefined,
+        };
+    if (config.analysis.serializer === "erbi") {
+        const firstStroke = component.glyph[0];
+        const secondStroke = component.glyph[1];
+        const first = classifier[firstStroke.feature].toString();
+        const second = secondStroke
+            ? classifier[secondStroke.feature].toString()
+            : "0";
+        const sequence = [first + second];
+        if (component.glyph.length > 2) {
+            const lastStroke = component.glyph[component.glyph.length - 1];
+            const last = classifier[lastStroke.feature].toString();
+            sequence.push(last);
+        }
+        return {
+            strokes: component.glyph.length,
+            sequence,
+            full: sequence,
+            operator: undefined,
+        };
+    }
+    const rootMap = new Map(component.glyph.map((stroke, index) => {
+        const binary = 1 << (component.glyph.length - 1 - index);
+        return [binary, classifier[stroke.feature].toString()];
+    }));
+    for (const root of rootData) {
+        const binaries = generateSliceBinaries(config.analysis?.degenerator ?? defaultDegenerator, component, root);
+        binaries.forEach((binary) => rootMap.set(binary, root.name));
+    }
+    const roots = Array.from(rootMap.keys()).sort((a, b) => a - b);
+    const requiredRootsBinary = new Set([...rootMap].filter(([K, v]) => requiredRoots.has(v)).map(([K, v]) => K));
+    const schemeList = generateSchemes(component.glyph.length, roots, requiredRootsBinary);
+    if (schemeList.length === 0) {
+        return new NoSchemeError();
+    }
+    const selectResult = select(config, component, schemeList, rootMap, requiredRootsBinary);
+    if (selectResult instanceof Error) {
+        return selectResult;
+    }
+    const best = selectResult.find((x) => x.scheme.every((y) => currentRoots.has(rootMap.get(y)) || /\d/.test(rootMap.get(y))));
+    let sequence = best.scheme.map((n) => rootMap.get(n));
+    return {
+        sequence,
+        full: [...sequence],
+        strokes: component.glyph.length,
+        map: rootMap,
+        best,
+        schemes: selectResult,
+        operator: undefined,
+    };
+};
+/**
+ * 递归渲染一个部件（基本部件或者衍生部件）
+ * 如果是基本部件就直接返回，如果是衍生部件则先渲染源字的图形，然后解引用得到这个部件的图形
+ *
+ * @param component - 部件
+ * @param repertoire - 原始字符集
+ * @param glyphCache - 部件缓存
+ *
+ * @returns 部件的 SVG 图形
+ * @throws InvalidGlyphError 无法渲染
+ */
+export const recursiveRenderComponent = (component, repertoire, glyphCache = new Map(), depth = 0) => {
+    if (depth > 100) {
+        console.error("Recursion depth exceeded", component);
+        return new InvalidGlyphError();
+    }
+    if (component.type === "basic_component")
+        return component.strokes;
+    if (component.type === "derived_component") {
+        const sourceComponent = repertoire[component.source]?.glyphs?.find?.(isComponent);
+        if (sourceComponent === undefined)
+            return new InvalidGlyphError();
+        const sourceGlyph = recursiveRenderComponent(sourceComponent, repertoire, glyphCache, depth + 1);
+        if (sourceGlyph instanceof InvalidGlyphError)
+            return sourceGlyph;
+        const glyph = [];
+        component.strokes.forEach((x) => {
+            if (x.feature === "reference") {
+                const sourceStroke = sourceGlyph[x.index];
+                // 允许指标越界
+                if (sourceStroke === undefined)
+                    return;
+                glyph.push(sourceStroke);
+            }
+            else {
+                glyph.push(x);
+            }
+        });
+        return glyph;
+    }
+    if (component.type === "spliced_component") {
+        const glyphs = [];
+        for (const name of component.operandList) {
+            const sourceComponent = repertoire[name]?.glyphs?.find?.(isComponent);
+            if (sourceComponent === undefined)
+                return new InvalidGlyphError();
+            const sourceGlyph = recursiveRenderComponent(sourceComponent, repertoire, glyphCache, depth + 1);
+            if (sourceGlyph instanceof InvalidGlyphError)
+                return sourceGlyph;
+            const box = getGlyphBoundingBox(sourceGlyph);
+            glyphs.push({ strokes: sourceGlyph, box });
+        }
+        const asCompound = { ...component, type: "compound" };
+        return affineMerge(asCompound, glyphs).strokes;
+    }
+    if (component.type === "identity") {
+        const sourceComponent = repertoire[component.source]?.glyphs?.find?.(isComponent);
+        if (sourceComponent === undefined)
+            return new InvalidGlyphError();
+        return recursiveRenderComponent(sourceComponent, repertoire, glyphCache, depth + 1);
+    }
+    return new InvalidGlyphError();
+};
+/**
+ * 把一个基本部件从 SVG 图形出发，先渲染成 Bezier 图形，然后计算拓扑
+ *
+ * 这样，便于后续的字根认同计算
+ */
+export const computeComponent = (name, svgglyph) => {
+    const glyph = renderSVGGlyph(svgglyph);
+    const topology = findTopology(glyph);
+    const cache = { glyph, topology, name };
+    return cache;
+};
+/**
+ * 将所有的字根都计算成 ComputedComponent
+ *
+ * @param repertoire - 字符集
+ * @param config - 配置
+ *
+ * @returns 所有计算后字根的列表
+ */
+export const renderRootList = (repertoire, elements) => {
+    const rootList = new Map();
+    for (const root of elements) {
+        const glyph = repertoire[root]?.glyph;
+        if (glyph === undefined)
+            continue;
+        if (glyph.type === "basic_component") {
+            rootList.set(root, computeComponent(root, glyph.strokes));
+        }
+        else {
+            const rendered = recursiveRenderCompound(glyph, repertoire);
+            if (rendered instanceof Error)
+                continue;
+            rootList.set(root, computeComponent(root, rendered.strokes));
+        }
+    }
+    return rootList;
+};
+/**
+ * 对所有部件进行拆分
+ *
+ * @param repertoire - 字符集
+ * @param config - 配置
+ *
+ * @returns 拆分结果和无法拆分的汉字列表
+ */
+export const disassembleComponents = (repertoire, config, characters, components) => {
+    const rootMap = renderRootList(repertoire, [
+        ...config.roots.keys(),
+        ...config.optionalRoots.keys(),
+    ]);
+    const rootList = [...rootMap.values()];
+    const classifier = mergeClassifier(config.analysis?.classifier);
+    const result = [];
+    const error = [];
+    Object.entries(repertoire).forEach(([name, character]) => {
+        if (character.glyph?.type !== "basic_component" || !components.has(name))
+            return;
+        const cache = rootMap.has(name)
+            ? rootMap.get(name)
+            : computeComponent(name, character.glyph.strokes);
+        const scheme = getComponentScheme(cache, rootList, config, classifier);
+        if (scheme instanceof Error) {
+            error.push(name);
+        }
+        else {
+            result.push([name, scheme]);
+        }
+    });
+    result.sort((a, b) => {
+        return a[1].strokes - b[1].strokes;
+    });
+    return [new Map(result), error];
+};

package/dist/compound.d.ts

@@ -0,0 +1,64 @@
+import type { AnalysisConfig } from "./repertoire.js";
+import type { ComponentResults, ComponentAnalysis, CommonAnalysis } from "./component.js";
+import { InvalidGlyphError } from "./component.js";
+import type { Compound, Repertoire, Operator, SVGGlyph, CompoundCharacter, SVGGlyphWithBox } from "./data.js";
+import type { BoundingBox } from "./bezier.js";
+export type CompoundResults = Map<string, CompoundAnalysis | ComponentAnalysis>;
+type PartitionResult = ComponentAnalysis | CompoundAnalysis;
+export type CompoundAnalysis = CompoundBasicAnalysis | CompoundGenuineAnalysis;
+/**
+ * 复合体本身是字根字，没有拆分细节
+ */
+interface CompoundBasicAnalysis extends CommonAnalysis {
+    operator: Operator;
+}
+/**
+ * 复合体通过自动拆分算法导出的拆分结果
+ */
+interface CompoundGenuineAnalysis extends CompoundBasicAnalysis {
+    operandResults: PartitionResult[];
+}
+export declare const getGlyphBoundingBox: (glyph: SVGGlyph) => BoundingBox;
+/**
+ * 将复合体递归渲染为 SVG 图形
+ *
+ * @param compound - 复合体
+ * @param repertoire - 原始字符集
+ *
+ * @returns SVG 图形
+ * @throws InvalidGlyphError 无法渲染
+ */
+export declare const recursiveRenderCompound: (compound: Compound, repertoire: Repertoire, glyphCache?: Map<string, SVGGlyphWithBox>) => SVGGlyphWithBox | InvalidGlyphError;
+/**
+ * 将复合体递归渲染为 SVG 图形
+ *
+ * @param compound - 复合体
+ * @param repertoire - 原始字符集
+ *
+ * @returns SVG 图形
+ * @throws InvalidGlyphError 无法渲染
+ */
+export declare const recursiveRenderStrokeSequence: (compound: Compound, repertoire: Repertoire, sequenceCache?: Map<string, string>) => string | InvalidGlyphError;
+/**
+ * 对字符集进行拓扑排序，得到复合体的拆分顺序
+ *
+ * @param repertoire - 字符集
+ *
+ * @returns 拓扑排序后的复合体
+ *
+ * @remarks 这个实现目前比较低效，需要改进
+ */
+export declare const topologicalSort: (repertoire: Repertoire, required: Set<string>, config: AnalysisConfig) => Map<string, CompoundCharacter>;
+type Serializer = (r: PartitionResult[], g: Compound, c: AnalysisConfig) => CompoundAnalysis;
+export declare const serializerTypes: readonly ["sequential", "zhangma", "zhenma", "snow2", "xkjd", "shouyou", "feihua", "erbi"];
+export type SerializerType = (typeof serializerTypes)[number];
+export declare const serializerMap: Record<SerializerType, Serializer>;
+/**
+ * 对复合体进行拆分
+ *
+ * @param repertoire - 字符集
+ * @param config - 配置
+ * @param componentResults - 部件拆分结果
+ */
+export declare const disassembleCompounds: (repertoire: Repertoire, config: AnalysisConfig, componentResults: ComponentResults, characters: string[], requiredCompounds: Set<string>) => readonly [CompoundResults, string[]];
+export {};