linked-rolls 0.0.1

package/lib/Emulation.js

@@ -0,0 +1,474 @@
+import { MIDIControlEvents } from "midifile-ts";
+import { KinematicConversion } from "./PlaceTimeConversion";
+import { getSnapshot } from "./Version";
+import { dimensionOf } from "./Symbol";
+function resize(arr, newSize, defaultValue) {
+    while (newSize > arr.length)
+        arr.push(defaultValue);
+}
+const simplifySymbol = (symbol) => {
+    if (!symbol.carriers || !symbol.carriers.length)
+        return null;
+    const mean = dimensionOf(symbol);
+    return {
+        ...symbol,
+        ...mean
+    };
+};
+export class Emulation {
+    constructor(options = {
+        welte_p: 35,
+        welte_f: 90,
+        welte_mf: 60,
+        welte_loud: 75,
+        trackerBarDiameter: 1.413,
+        punchExtensionFraction: 0.75,
+        slow_decay_rate: 2380,
+        fastC_decay_rate: 300,
+        fastD_decay_rate: 400,
+        division: 54
+    }) {
+        Object.defineProperty(this, "placeTimeConversion", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new KinematicConversion()
+        });
+        Object.defineProperty(this, "midiEvents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        // sorted list of events with the negotiated assumptions already applied
+        Object.defineProperty(this, "negotiatedEvents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        // stores a velocity for every millisecond
+        Object.defineProperty(this, "trebleVelocities", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "bassVelocities", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "startTempo", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "endTempo", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "source", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        options.slow_step = (options.welte_mf - options.welte_p) / options.slow_decay_rate;
+        options.fastC_step = (options.welte_mf - options.welte_p) / options.fastC_decay_rate;
+        options.fastD_step = -(options.welte_f - options.welte_p) / options.fastD_decay_rate;
+        this.options = options;
+    }
+    findRollTempo(tempo) {
+        if (!tempo) {
+            this.startTempo = 104.331;
+            this.endTempo = 104.331;
+            return;
+        }
+        this.startTempo = tempo.startsWith;
+        this.endTempo = tempo.endsWith;
+    }
+    assignPhysicalTime(skipToFirstNote = false) {
+        if (this.negotiatedEvents.length === 0)
+            return;
+        const first = skipToFirstNote ? this.negotiatedEvents[0].horizontal.from : 0;
+        for (const event of this.negotiatedEvents) {
+            if (!event.assumedPhysicalTime) {
+                // convert from mm to cm and then to time
+                event.assumedPhysicalTime = [
+                    this.placeTimeConversion.placeToTime((event.horizontal.from - first) / 10),
+                    this.placeTimeConversion.placeToTime((event.horizontal.to - first) / 10)
+                ];
+            }
+        }
+    }
+    applyTrackerBarExtension() {
+        const correction = this.options.trackerBarDiameter * this.options.punchExtensionFraction + 0.5;
+        for (const event of this.negotiatedEvents) {
+            if (event.horizontal.to) {
+                event.horizontal.to += correction;
+            }
+        }
+    }
+    convertEventsToMIDI() {
+        for (const event of this.negotiatedEvents) {
+            if (event.type === 'expression') {
+                const expression = event;
+                const map = new Map([
+                    ['SustainPedalOn', 'sustainPedalOn'],
+                    ['SustainPedalOff', 'sustainPedalOff'],
+                    ['SoftPedalOn', 'softPedalOn'],
+                    ['SoftPedalOff', 'softPedalOff']
+                ]);
+                if (map.has(expression.expressionType)) {
+                    this.midiEvents.push({
+                        type: map.get(expression.expressionType),
+                        performs: event,
+                        at: event.assumedPhysicalTime[0],
+                    });
+                }
+            }
+            else if (event.type === 'note') {
+                const note = event;
+                // take velocity from the calculated velocity list
+                const pitch = note.pitch;
+                if (event.vertical.from >= this.options.division) {
+                    this.insertNote(event, pitch, this.trebleVelocities[+(event.assumedPhysicalTime[0] * 1000).toFixed()]);
+                }
+                else {
+                    this.insertNote(event, pitch, this.bassVelocities[+(event.assumedPhysicalTime[0] * 1000).toFixed()]);
+                }
+            }
+        }
+        this.midiEvents.sort((a, b) => a.at - b.at);
+    }
+    emulateFromRoll(events) {
+        this.startTempo = 104.331;
+        this.endTempo = 104.331;
+        this.negotiatedEvents = events
+            .map(simplifySymbol)
+            .filter(s => s !== null);
+        this.applyTrackerBarExtension();
+        this.assignPhysicalTime();
+        this.applyTrackerBarExtension();
+        this.calculateVelocities('treble');
+        this.calculateVelocities('bass');
+        this.convertEventsToMIDI();
+        return this.midiEvents;
+    }
+    emulateVersion(version, rollTempo, skipToFirstNote = false) {
+        this.source = version.id;
+        this.negotiatedEvents =
+            getSnapshot(version)
+                .filter(s => s.type === 'note' || s.type === 'expression')
+                .map(simplifySymbol)
+                .filter(s => s !== null);
+        this.findRollTempo(rollTempo);
+        this.applyTrackerBarExtension();
+        this.assignPhysicalTime(skipToFirstNote);
+        this.calculateVelocities('treble');
+        this.calculateVelocities('bass');
+        this.convertEventsToMIDI();
+        return this.midiEvents;
+    }
+    /**
+     * 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) {
+        if (!this.negotiatedEvents.length)
+            return;
+        const velocities = scope === 'treble' ? this.trebleVelocities : this.bassVelocities;
+        const isMF = []; // is MF hook on?
+        const isSlowC = []; // is slow crescendo on?
+        const isFastC = []; // is fast crescendo on?
+        const isFastD = []; // is fast decrescendo on?
+        let lastOnsetMs = this.negotiatedEvents[this.negotiatedEvents.length - 1].assumedPhysicalTime[0];
+        if (!lastOnsetMs) {
+            console.log('Failed calculating the last onset.');
+            return;
+        }
+        lastOnsetMs *= 1000;
+        // set all of the times to piano by default
+        resize(velocities, lastOnsetMs, this.options.welte_p);
+        // fill all hook maps with false
+        for (const target of [isMF, isSlowC, isFastC, isFastD]) {
+            resize(target, lastOnsetMs, false);
+        }
+        // Lock and Cancel
+        let valve_mf_on = false;
+        let valve_slowc_on = false;
+        let valve_mf_starttime = 0; // 0 for off
+        let valve_slowc_starttime = 0;
+        // First pass: For each time section calculate the current boolean
+        // state of each expression.
+        for (const negotiatedEvent of this.negotiatedEvents) {
+            if (negotiatedEvent.type !== 'expression')
+                continue;
+            if (scope === 'treble' && negotiatedEvent.vertical.from < this.options.division)
+                continue;
+            else if (scope === 'bass' && negotiatedEvent.vertical.from >= this.options.division)
+                continue;
+            const event = negotiatedEvent;
+            const startMs = event.assumedPhysicalTime[0] * 1000;
+            const endMs = event.assumedPhysicalTime[1] * 1000;
+            // console.log('encoutering expression', event.expressionType["@id"], 'from', startMs, 'to', endMs)
+            if (event.expressionType === 'MezzoforteOn') {
+                // update the mezzoforte start time
+                // only if the mf valve is not on already
+                if (!valve_mf_on) {
+                    valve_mf_on = true;
+                    valve_mf_starttime = startMs;
+                }
+            }
+            else if (event.expressionType === 'MezzoforteOff') {
+                if (valve_mf_on) {
+                    // fill from the mezzoforte start time to here ...
+                    isMF.fill(true, valve_mf_starttime, startMs);
+                }
+                valve_mf_on = false;
+            }
+            else if (event.expressionType === 'SlowCrescendoOn') {
+                // update the slow crescendo start time
+                // only if slow crescendo is not on already
+                if (!valve_slowc_on) {
+                    valve_slowc_on = true;
+                    valve_slowc_starttime = startMs;
+                }
+            }
+            else if (event.expressionType === 'SlowCrescendoOff') {
+                if (valve_slowc_on) {
+                    // fill from the mezzoforte start time to here ...
+                    isSlowC.fill(true, valve_slowc_starttime, startMs);
+                }
+                valve_slowc_on = false;
+            }
+            else if (event.expressionType === 'ForzandoOn') {
+                // Forzando On/Off are a direct operations (length of perforation matters)
+                isFastC.fill(true, startMs, endMs);
+            }
+            else if (event.expressionType === 'ForzandoOff') {
+                // Forzando On/Off are a direct operations (length of perforation matters)
+                isFastD.fill(true, startMs, endMs);
+            }
+        }
+        // TODO: deal with the last case (if crescendo OFF is missing)
+        // Second pass, update the current velocity according to the previous one
+        let amount = 0.0;
+        let eps = 0.0001;
+        for (let i = 1; i < lastOnsetMs; i++) {
+            if (!isSlowC[i] && !isFastC[i] && !isFastD[i]) {
+                // slow decrescendo is always on
+                amount = -this.options.slow_step;
+            }
+            else {
+                amount =
+                    (isSlowC[i] ? this.options.slow_step : 0) +
+                        (isFastC[i] ? this.options.fastC_step : 0) +
+                        (isFastD[i] ? this.options.fastD_step : 0);
+            }
+            velocities[i] = velocities[i - 1] + amount;
+            if (isMF[i]) {
+                if (velocities[i - 1] > this.options.welte_mf) {
+                    if (amount < 0) {
+                        velocities[i] = Math.max(this.options.welte_mf + eps, velocities[i]);
+                    }
+                    else {
+                        velocities[i] = Math.min(this.options.welte_f, velocities[i]);
+                    }
+                }
+                else if (velocities[i - 1] < this.options.welte_mf) {
+                    if (amount > 0) {
+                        velocities[i] = Math.min(this.options.welte_mf - eps, velocities[i]);
+                    }
+                    else {
+                        velocities[i] = Math.max(this.options.welte_p, velocities[i]);
+                    }
+                }
+            }
+            else {
+                // slow crescendo will only reach welte_loud
+                if (isSlowC[i] && !isFastC[i] && velocities[i - 1] < this.options.welte_loud) {
+                    velocities[i] = Math.min(velocities[i], this.options.welte_loud - eps);
+                }
+            }
+            // regulating max and min
+            velocities[i] = Math.max(this.options.welte_p, velocities[i]);
+            velocities[i] = Math.min(this.options.welte_f, velocities[i]);
+        }
+    }
+    insertNote(event, pitch, velocity) {
+        this.midiEvents.push({
+            type: 'noteOn',
+            performs: event,
+            velocity,
+            at: event.assumedPhysicalTime[0],
+            pitch
+        });
+        this.midiEvents.push({
+            type: 'noteOff',
+            performs: event,
+            velocity: 127,
+            at: event.assumedPhysicalTime[1],
+            pitch
+        });
+    }
+    findEventsPerforming(id) {
+        return this.midiEvents.filter(event => event.performs.id === id);
+    }
+    asMIDI() {
+        const events = [];
+        this.midiEvents.sort((a, b) => a.at - b.at);
+        let currentTime = 0;
+        // insert metadata first
+        events.push({
+            type: 'meta',
+            subtype: 'text',
+            text: 'linked-rolls (based on midi2exp)',
+            deltaTime: 0
+        });
+        if (this.source) {
+            events.push({
+                type: 'meta',
+                subtype: 'text',
+                text: this.source,
+                deltaTime: 0
+            });
+        }
+        events.push({
+            type: 'meta',
+            subtype: 'text',
+            text: `place-time-conversion: ${this.placeTimeConversion.summary}`,
+            deltaTime: 0
+        });
+        for (const [key, value] of Object.entries(this.options)) {
+            events.push({
+                type: 'meta',
+                subtype: 'text',
+                text: `${key}=${value}`,
+                deltaTime: 0
+            });
+        }
+        events.push({
+            type: 'meta',
+            subtype: 'setTempo',
+            microsecondsPerBeat: 1000000,
+            deltaTime: 0
+        });
+        for (const event of this.midiEvents) {
+            const deltaTimeMs = (event.at - currentTime) * 1000;
+            if (event.type === 'noteOn') {
+                console.log('dealing with note on', event.pitch, event.at, deltaTimeMs);
+                events.push({
+                    type: 'meta',
+                    subtype: 'text',
+                    deltaTime: deltaTimeMs,
+                    text: event.performs.id
+                });
+                events.push({
+                    type: 'channel',
+                    subtype: 'noteOn',
+                    noteNumber: event.pitch,
+                    velocity: +event.velocity.toFixed(0),
+                    deltaTime: 0,
+                    channel: 0
+                });
+            }
+            else if (event.type === 'noteOff') {
+                events.push({
+                    type: 'channel',
+                    subtype: 'noteOff',
+                    noteNumber: event.pitch,
+                    velocity: 127,
+                    deltaTime: deltaTimeMs,
+                    channel: 0
+                });
+            }
+            else if (event.type === 'sustainPedalOn') {
+                events.push({
+                    type: 'meta',
+                    subtype: 'text',
+                    deltaTime: deltaTimeMs,
+                    text: event.performs.id
+                });
+                events.push({
+                    type: 'channel',
+                    subtype: 'controller',
+                    controllerType: MIDIControlEvents.SUSTAIN,
+                    deltaTime: 0,
+                    channel: 0,
+                    value: 127
+                });
+            }
+            else if (event.type === 'sustainPedalOff') {
+                events.push({
+                    type: 'meta',
+                    subtype: 'text',
+                    deltaTime: deltaTimeMs,
+                    text: event.performs.id
+                });
+                events.push({
+                    type: 'channel',
+                    subtype: 'controller',
+                    controllerType: MIDIControlEvents.SUSTAIN,
+                    deltaTime: 0,
+                    channel: 0,
+                    value: 0
+                });
+            }
+            else if (event.type === 'softPedalOn') {
+                events.push({
+                    type: 'meta',
+                    subtype: 'text',
+                    deltaTime: deltaTimeMs,
+                    text: event.performs.id
+                });
+                events.push({
+                    type: 'channel',
+                    subtype: 'controller',
+                    controllerType: MIDIControlEvents.SOFT_PEDAL,
+                    deltaTime: 0,
+                    channel: 0,
+                    value: 127
+                });
+            }
+            else if (event.type === 'softPedalOff') {
+                events.push({
+                    type: 'meta',
+                    subtype: 'text',
+                    deltaTime: deltaTimeMs,
+                    text: event.performs.id
+                });
+                events.push({
+                    type: 'channel',
+                    subtype: 'controller',
+                    controllerType: MIDIControlEvents.SOFT_PEDAL,
+                    deltaTime: 0,
+                    channel: 0,
+                    value: 0
+                });
+            }
+            currentTime = event.at;
+        }
+        return {
+            header: {
+                ticksPerBeat: 1000,
+                formatType: 0,
+                trackCount: 1
+            },
+            tracks: [events]
+        };
+    }
+}

package/lib/Feature.d.ts

@@ -0,0 +1,37 @@
+import { ConditionState } from "./ConditionState";
+import { EditorialAssumption } from "./EditorialAssumption";
+import { WithId } from "./WithId";
+export interface FeatureCondition extends ConditionState<'missing-perforation' | 'damaged-perforation' | 'illegible'> {
+}
+export type FeatureConditionAssignment = EditorialAssumption<'conditionAssignment', FeatureCondition>;
+export interface HorizontalSpan {
+    unit: 'mm';
+    from: number;
+    to: number;
+}
+export interface VerticalSpan {
+    unit: 'track';
+    from: number;
+    to?: number;
+}
+export interface RollFeature extends WithId {
+    /**
+     * IIIF region in string form.
+     */
+    annotates?: string;
+    horizontal: HorizontalSpan;
+    vertical: VerticalSpan;
+    /**
+     * Describes whether the event takes place
+     * on the verso or recto side of the roll.
+     * Since the same perforation is present on both
+     * sides, this property is left optional for now.
+     */
+    side?: 'verso' | 'recto';
+    /**
+     * This can be used e.g. to indicate a perforation
+     * which is torn out or in any other way damaged.
+     */
+    condition?: FeatureConditionAssignment;
+}
+export declare const isRollFeature: (obj: object) => obj is RollFeature;

package/lib/Feature.js

@@ -0,0 +1,3 @@
+export const isRollFeature = (obj) => {
+    return 'horizontal' in obj && 'vertical' in obj;
+};

package/lib/Measurement.d.ts

@@ -0,0 +1,9 @@
+import { WithId } from "./WithId";
+/**
+ * Based on D11 Digital Measurement Event and D10 Software Execution
+ */
+export interface RollMeasurement extends WithId {
+    actor?: string;
+    software: string;
+    date: string;
+}

package/lib/Measurement.js

@@ -0,0 +1 @@
+export {};

package/lib/PlaceTimeConversion.d.ts

@@ -0,0 +1,65 @@
+export declare abstract class PlaceTimeConversion {
+    abstract get summary(): string;
+    abstract placeToTime(x1: number): number;
+    abstract timeToPlace(t1: number): number;
+}
+export declare class NoAccelerationConversion implements PlaceTimeConversion {
+    get summary(): string;
+    metersPerMinute: number;
+    /**
+     * Converts physical place (in cm) to time (in seconds).
+     * @param x1 - The distance in mm.
+     * @returns Time in seconds.
+     */
+    placeToTime(cm: number): number;
+    /**
+     * Converts time (in seconds) to physical place (in cm).
+     * @param t1 - The time in seconds.
+     * @returns Distance in cm.
+     */
+    timeToPlace(t1: number): number;
+}
+declare enum SpeedUnit {
+    MetersPerMinute = 0,
+    FeetPerMinute = 1
+}
+declare enum AccelerationUnit {
+    MillimetersPerSecondSquared = 0,
+    FeetPerMinuteSquared = 1
+}
+export declare class KinematicConversion implements PlaceTimeConversion {
+    get summary(): string;
+    static readonly slowSpeed = 9.46;
+    static readonly normalSpeed = 9.85;
+    static readonly stanfordAcceleration = 0.3147;
+    static readonly baertschAcceleration = 0.1772;
+    private feetPerMinute;
+    private acceleration;
+    constructor(feetPerMinute?: number, acceleration?: number);
+    setSpeed(speed: number, unit: SpeedUnit): void;
+    setAcceleration(acceleration: number, unit: AccelerationUnit): void;
+    /**
+     * Converts physical place (in cm) to time (in seconds).
+     * @param x1 - The distance in mm.
+     * @returns Time in seconds.
+     */
+    placeToTime(cm: number): number;
+    /**
+     * Converts time (in seconds) to physical place (in cm).
+     * @param t1 - The time in seconds.
+     * @returns Distance in cm.
+     */
+    timeToPlace(t1: number): number;
+}
+export declare class GottschewskiConversion implements PlaceTimeConversion {
+    get summary(): string;
+    paperThickness: number;
+    initialCircumference: number;
+    secondsPerTurn: number;
+    /**
+     * @param x1 in centimeters
+     */
+    placeToTime(x1: number): number;
+    timeToPlace(t1: number): number;
+}
+export {};