linked-rolls 0.0.1 → 0.1.1

package/lib/EditionView.js

@@ -0,0 +1,294 @@
+import { idOf, idsOf } from "./Assumption";
+export const getAt = (path, obj) => {
+    let node = obj;
+    for (const key of path) {
+        if (node == null)
+            return undefined;
+        node = node[key];
+    }
+    return node;
+};
+const referenceKeys = new Set([
+    'delete',
+    'comprehends',
+    'motivation'
+]);
+export class EditionView {
+    /**
+     * Dimensions cache: one frequent operation is to find the average
+     * dimensions of a symbol based on its carriers. This cache stores
+     * the computed dimensions for reuse.
+     */
+    //private readonly dimensionsCache: Map<string, { horizontal: HorizontalSpan, vertical: VerticalSpan }> = new Map()
+    constructor(edition) {
+        Object.defineProperty(this, "edition", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Map from id to object
+         */
+        Object.defineProperty(this, "byId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        /**
+         * Map from id to its path within the edition
+         */
+        Object.defineProperty(this, "paths", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        /**
+         * Map from id to paths where it is referenced
+         */
+        Object.defineProperty(this, "links", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        this.edition = edition;
+        this.indexObjects();
+        //this.buildDimensionsCache()
+    }
+    // private buildDimensionsCache() {
+    //     for (const version of this.edition.versions) {
+    //         for (const symbol of version.edits.flatMap(edit => edit.insert || [])) {
+    //             const dim = this.dimensionOf(symbol)
+    //             if (dim) {
+    //                 this.dimensionsCache.set(symbol.id, dim)
+    //             }
+    //         }
+    //     }
+    // }
+    atPath(path) {
+        const node = getAt(path, this.edition);
+        return node || null;
+    }
+    indexObjects() {
+        const visited = new WeakSet();
+        const isObject = (v) => v !== null && typeof v === "object";
+        const traverse = (node, path) => {
+            if (!isObject(node))
+                return;
+            if (visited.has(node))
+                return;
+            visited.add(node);
+            const anyNode = node;
+            if (typeof anyNode.id === "string") {
+                if (Object.keys(anyNode).filter(k => k !== '@annotation').length === 1) {
+                    // this is a reference-only object, store link
+                    if (!this.links.has(anyNode.id)) {
+                        this.links.set(anyNode.id, new Set());
+                    }
+                    this.links.get(anyNode.id).add([...path, 'id']);
+                }
+                else {
+                    if (!this.byId.has(anyNode.id)) {
+                        this.byId.set(anyNode.id, node);
+                        this.paths.set(anyNode.id, [...path]);
+                    }
+                }
+            }
+            Object
+                .keys(anyNode)
+                .filter(k => referenceKeys.has(k))
+                .forEach(key => {
+                const ref = anyNode[key];
+                if (typeof ref === "string") {
+                    if (!this.links.has(ref)) {
+                        this.links.set(ref, new Set());
+                    }
+                    this.links.get(ref).add([...path, key]);
+                }
+                else if (Array.isArray(ref)) {
+                    for (const r of ref) {
+                        if (typeof r === "string") {
+                            if (!this.links.has(anyNode.id)) {
+                                this.links.set(anyNode.id, new Set());
+                            }
+                            this.links.get(anyNode.id).add([...path, key]);
+                        }
+                    }
+                }
+            });
+            if (Array.isArray(node)) {
+                for (let i = 0; i < node.length; i++) {
+                    traverse(node[i], [...path, i]);
+                }
+            }
+            else {
+                for (const key of Object.keys(node)) {
+                    traverse(anyNode[key], [...path, key]);
+                }
+            }
+        };
+        traverse(this.edition, []);
+    }
+    get(anyId) {
+        return this.byId.get(anyId);
+    }
+    getAll(anyIds) {
+        return anyIds.map(id => this.get(id)).filter((v) => !!v);
+    }
+    getPath(anyId) {
+        return this.paths.get(anyId);
+    }
+    linksTo(anyId) {
+        return Array.from(this.links.get(anyId) || []);
+    }
+    travelUp(versionId, callback) {
+        const v = this.get(versionId);
+        if (!v)
+            return;
+        callback(v);
+        if (v.basedOn) {
+            this.travelUp(idOf(v.basedOn), callback);
+        }
+    }
+    carriersOf(symbol) {
+        return this.getAll(idsOf(symbol.carriers));
+    }
+    predecessorOf(versionId) {
+        const v = this.get(versionId);
+        if (!v?.basedOn)
+            return;
+        return this.get(idOf(v.basedOn));
+    }
+    dimensionOf(symbol) {
+        // if (this.dimensionsCache.has(symbol.id)) {
+        //     return this.dimensionsCache.get(symbol.id);
+        // }
+        const carriers = this.getAll(idsOf(symbol.carriers));
+        if (carriers.length === 0) {
+            return;
+        }
+        const horizontalFrom = carriers.reduce((hAcc, h) => hAcc + h.horizontal.from, 0) / carriers.length;
+        const horizontalTo = carriers.reduce((hAcc, h) => hAcc + h.horizontal.to, 0) / carriers.length;
+        const verticalFrom = carriers.reduce((vAcc, v) => vAcc + v.vertical.from, 0) / carriers.length;
+        const definedVerticalTo = carriers.filter(v => v.vertical.to !== undefined);
+        let verticalTo = undefined;
+        if (definedVerticalTo.length > 0) {
+            verticalTo = definedVerticalTo
+                .reduce((vAcc, v) => vAcc + v.vertical.to, 0) / definedVerticalTo.length;
+        }
+        return {
+            horizontal: { unit: 'mm', from: horizontalFrom, to: horizontalTo },
+            vertical: { unit: 'track', from: verticalFrom, to: verticalTo }
+        };
+    }
+    snapshot(versionId) {
+        const snapshot = [];
+        const toDelete = [];
+        this.travelUp(versionId, s => {
+            snapshot.push(...s.edits.flatMap(edit => edit.insert || []));
+            // as we travel further up, remove symbols that are 
+            // deleted in the versions further down
+            const deleted = [];
+            for (const toRemove of toDelete) {
+                const index = snapshot.findIndex(s => s.id === toRemove);
+                if (index !== -1) {
+                    snapshot.splice(index, 1);
+                    deleted.push(toRemove);
+                }
+            }
+            for (const del of deleted) {
+                toDelete.splice(toDelete.indexOf(del), 1);
+            }
+            // collect symbols that are deleted in the current version
+            toDelete.push(...s.edits.flatMap(edit => edit.delete || []));
+        });
+        return snapshot.sort((a, b) => {
+            const aDimension = this.dimensionOf(a);
+            const bDimension = this.dimensionOf(b);
+            return (aDimension?.horizontal.from || 0) - (bDimension?.horizontal.from || 0);
+        });
+    }
+    isCollatable(symbolA, symbolB, tolerance = {
+        toleranceEnd: 5,
+        toleranceStart: 5
+    }) {
+        // two symbols are collatible if they share the same 
+        // symbol characteristics (pitch, expression type etc.)
+        // and occur in the same horizontal position.
+        if (symbolA.type === 'note' && symbolB.type === 'note') {
+            if (symbolA.pitch !== symbolB.pitch)
+                return false;
+        }
+        else if (symbolA.type === 'expression' && symbolB.type === 'expression') {
+            if (symbolA.expressionType !== symbolB.expressionType)
+                return false;
+            if (symbolA.scope !== symbolB.scope)
+                return false;
+        }
+        const dimensionA = this.dimensionOf(symbolA);
+        const dimensionB = this.dimensionOf(symbolB);
+        if (!dimensionA || !dimensionB)
+            return false;
+        const distanceStart = Math.abs(dimensionA.horizontal.from - dimensionB.horizontal.from);
+        const distanceEnd = Math.abs(dimensionA.horizontal.to - dimensionB.horizontal.to);
+        if (distanceStart > tolerance.toleranceStart
+            || distanceEnd > tolerance.toleranceEnd) {
+            // the symbols are too far apart to be collated
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Assigns a generation (depth) to every node.
+     */
+    withGenerations() {
+        const memo = new Map();
+        const inStack = new Set();
+        const computeGeneration = (id) => {
+            if (memo.has(id))
+                return memo.get(id);
+            if (inStack.has(id)) {
+                throw new Error(`Cycle detected involving node '${id}'. Check parentId links.`);
+            }
+            const node = this.get(id);
+            if (!node) {
+                memo.set(id, 0);
+                return 0;
+            }
+            inStack.add(id);
+            let gen;
+            const basedOn = node.basedOn && idOf(node.basedOn);
+            if (basedOn === undefined) {
+                gen = 0; // root
+            }
+            else if (!this.get(basedOn)) {
+                // Orphaned parent reference — treat boundary as root
+                gen = 0;
+            }
+            else {
+                gen = 1 + computeGeneration(basedOn);
+            }
+            inStack.delete(id);
+            memo.set(id, gen);
+            return gen;
+        };
+        // Compute for all nodes (order doesn’t matter)
+        const withGen = this.edition.versions.map(n => ({
+            ...n,
+            generation: computeGeneration(n.id),
+        }));
+        return withGen;
+    }
+    simplifySymbol(symbol) {
+        const dim = this.dimensionOf(symbol);
+        if (!symbol.carriers.length || !dim)
+            return null;
+        return {
+            ...symbol,
+            ...dim
+        };
+    }
+}

package/lib/Emulation.d.ts

@@ -1,76 +1,29 @@
 import { MidiFile } from "midifile-ts";
-import { AnySymbol, Expression, Note } from "./Symbol";
-import { PlaceTimeConversion } from "./PlaceTimeConversion";
+import { EditionView } from "./EditionView";
 import { Version } from "./Version";
-import { RollFeature } from "./Feature";
-import { RollTempo } from "./Edition";
-interface PerformedRollFeature<T> {
-    type: T;
-    performs: (AnySymbol | NegotiatedEvent);
-    at: number;
-}
-interface PerformedNoteEvent<T> extends PerformedRollFeature<T> {
-    pitch: number;
-    velocity: number;
-}
-export interface PerformedNoteOnEvent extends PerformedNoteEvent<'noteOn'> {
-}
-export interface PerformedNoteOffEvent extends PerformedNoteEvent<'noteOff'> {
-}
-export interface PerformedSustainPedalOnEvent extends PerformedRollFeature<'sustainPedalOn'> {
-}
-export interface PerformedSustainPedalOffEvent extends PerformedRollFeature<'sustainPedalOff'> {
-}
-export interface PerformedSoftPedalOnEvent extends PerformedRollFeature<'softPedalOn'> {
-}
-export interface PerformedSoftPedalOffEvent extends PerformedRollFeature<'softPedalOff'> {
-}
-export type AnyPerformedRollFeature = PerformedNoteOnEvent | PerformedNoteOffEvent | PerformedSustainPedalOnEvent | PerformedSustainPedalOffEvent | PerformedSoftPedalOnEvent | PerformedSoftPedalOffEvent;
-type AssumedPhysicalTimeSpan = {
-    assumedPhysicalTime?: [number, number];
-};
-export type NegotiatedEvent = Omit<Note | Expression, 'carriers'> & Pick<RollFeature, 'horizontal' | 'vertical'> & AssumedPhysicalTimeSpan;
-export type EmulationOptions = {
-    welte_p: number;
-    welte_f: number;
-    welte_mf: number;
-    welte_loud: number;
-    slow_decay_rate: number;
-    fastC_decay_rate: number;
-    fastD_decay_rate: number;
-    trackerBarDiameter: number;
-    punchExtensionFraction: number;
-    slow_step?: number;
-    fastC_step?: number;
-    fastD_step?: number;
-    division: number;
+import { AnyPerformedRollFeature, EmulatedCurve, NegotiatedEvent, ReproducingSystem } from "./ReproducingSystem";
+export type EmulationScope = {
+    /** Only notes whose onset lies within this span of the roll, in mm, are played. */
+    range?: [number, number];
+    /** Start the clock at the first note rather than at the beginning of the roll. */
+    skipToFirstNote?: boolean;
 };
-export declare class Emulation {
-    placeTimeConversion: PlaceTimeConversion;
-    midiEvents: (AnyPerformedRollFeature)[];
+/**
+ * A version of the edition, performed: the symbols are negotiated into
+ * placed events, the reproducing system plays them, and the result goes
+ * out as MIDI in which every note and pedal step is labelled with the
+ * symbol it performs.
+ */
+export declare class Emulation<Options extends object> {
+    readonly system: ReproducingSystem<Options>;
+    options: Options;
+    midiEvents: AnyPerformedRollFeature[];
     negotiatedEvents: NegotiatedEvent[];
-    trebleVelocities: number[];
-    bassVelocities: number[];
-    startTempo?: number;
-    endTempo?: number;
+    curves: readonly EmulatedCurve[];
     source?: string;
-    options: EmulationOptions;
-    constructor(options?: EmulationOptions);
-    private findRollTempo;
-    private assignPhysicalTime;
-    private applyTrackerBarExtension;
-    private convertEventsToMIDI;
-    emulateFromRoll(events: (Note | Expression)[]): AnyPerformedRollFeature[];
-    emulateVersion(version: Version, rollTempo?: RollTempo, skipToFirstNote?: boolean): AnyPerformedRollFeature[];
-    /**
-     * The original code of the calculateVelocities() method,
-     * written by Kitty Shi and Craig Stuart Sapp,
-     * was taken from the midi2exp project (https://github.com/pianoroll/midi2exp)
-     * and adapted to the different data representation.
-     */
-    calculateVelocities(scope: 'treble' | 'bass'): void;
-    private insertNote;
+    constructor(system: ReproducingSystem<Options>, options?: Options);
+    applyConstraints(): void;
+    emulateVersion(version: Version, view: EditionView, { range, skipToFirstNote }?: EmulationScope): AnyPerformedRollFeature[];
     findEventsPerforming(id: string): AnyPerformedRollFeature[];
     asMIDI(): MidiFile;
 }
-export {};