linked-rolls 0.0.1

package/lib/PlaceTimeConversion.js

@@ -0,0 +1,175 @@
+export class PlaceTimeConversion {
+}
+export class NoAccelerationConversion {
+    constructor() {
+        Object.defineProperty(this, "metersPerMinute", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 3
+        }); // according to most sources
+    }
+    get summary() {
+        return `no aceleration (${this.metersPerMinute} m/min)`;
+    }
+    /**
+     * Converts physical place (in cm) to time (in seconds).
+     * @param x1 - The distance in mm.
+     * @returns Time in seconds.
+     */
+    placeToTime(cm) {
+        const meters = cm / 100; // convert to m
+        const t = meters / this.metersPerMinute;
+        return t * 60;
+    }
+    /**
+     * Converts time (in seconds) to physical place (in cm).
+     * @param t1 - The time in seconds.
+     * @returns Distance in cm.
+     */
+    timeToPlace(t1) {
+        return (this.metersPerMinute * (t1 / 60)) * 100;
+    }
+}
+var SpeedUnit;
+(function (SpeedUnit) {
+    SpeedUnit[SpeedUnit["MetersPerMinute"] = 0] = "MetersPerMinute";
+    SpeedUnit[SpeedUnit["FeetPerMinute"] = 1] = "FeetPerMinute";
+})(SpeedUnit || (SpeedUnit = {}));
+var AccelerationUnit;
+(function (AccelerationUnit) {
+    AccelerationUnit[AccelerationUnit["MillimetersPerSecondSquared"] = 0] = "MillimetersPerSecondSquared";
+    AccelerationUnit[AccelerationUnit["FeetPerMinuteSquared"] = 1] = "FeetPerMinuteSquared";
+})(AccelerationUnit || (AccelerationUnit = {}));
+export class KinematicConversion {
+    get summary() {
+        return `kinematic (acceleration: ${this.acceleration} ft/s², speed: ${this.feetPerMinute} ft/min)`;
+    }
+    constructor(feetPerMinute = KinematicConversion.normalSpeed, acceleration = KinematicConversion.baertschAcceleration) {
+        Object.defineProperty(this, "feetPerMinute", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "acceleration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.feetPerMinute = feetPerMinute;
+        this.acceleration = acceleration;
+    }
+    setSpeed(speed, unit) {
+        if (unit === SpeedUnit.FeetPerMinute) {
+            this.feetPerMinute = speed;
+        }
+        else if (unit === SpeedUnit.MetersPerMinute) {
+            this.feetPerMinute = speed * 3.2808399;
+        }
+        else {
+            throw new Error('Unsupported unit');
+        }
+    }
+    setAcceleration(acceleration, unit) {
+        if (unit === AccelerationUnit.FeetPerMinuteSquared) {
+            this.acceleration = acceleration;
+        }
+        else if (unit === AccelerationUnit.MillimetersPerSecondSquared) {
+            this.acceleration = acceleration * 0.0032808399 * 3600;
+        }
+        else {
+            throw new Error('Unsupported unit');
+        }
+    }
+    /**
+     * Converts physical place (in cm) to time (in seconds).
+     * @param x1 - The distance in mm.
+     * @returns Time in seconds.
+     */
+    placeToTime(cm) {
+        const x1 = cm / 30.48;
+        const v = this.feetPerMinute;
+        const a = this.acceleration;
+        const t = (Math.sqrt(2 * a * x1 + Math.pow(v, 2)) - v) / a;
+        return t * 60;
+    }
+    /**
+     * Converts time (in seconds) to physical place (in cm).
+     * @param t1 - The time in seconds.
+     * @returns Distance in cm.
+     */
+    timeToPlace(t1) {
+        // Convert seconds -> minutes
+        const T = t1 / 60;
+        const xFeet = this.feetPerMinute * T + 0.5 * this.acceleration * Math.pow(T, 2);
+        // Convert feet -> millimeters
+        const xMM = xFeet * 304.8;
+        return xMM / 10;
+    }
+}
+Object.defineProperty(KinematicConversion, "slowSpeed", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 9.46
+});
+Object.defineProperty(KinematicConversion, "normalSpeed", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 9.85
+});
+Object.defineProperty(KinematicConversion, "stanfordAcceleration", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 0.3147
+}); // cf. https://github.com/pianoroll/midi2exp/commit/6a29060
+Object.defineProperty(KinematicConversion, "baertschAcceleration", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 0.1772
+}); // = 0.015 mm/s^2, cf. Baertsch p. 33
+export class GottschewskiConversion {
+    constructor() {
+        Object.defineProperty(this, "paperThickness", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0.0075
+        });
+        Object.defineProperty(this, "initialCircumference", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 22.25
+        });
+        Object.defineProperty(this, "secondsPerTurn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 4.64
+        }); // is that correct? Philips says 120 RPM (p. 113)
+    }
+    get summary() {
+        return `Gottschewski (assuming paper thickness: ${this.paperThickness}, initial circumference: ${this.initialCircumference}, seconds per turn: ${this.secondsPerTurn})`;
+    }
+    /**
+     * @param x1 in centimeters
+     */
+    placeToTime(x1) {
+        const Q0 = Math.pow(this.initialCircumference, 2) / (4 * Math.PI);
+        const v0 = this.initialCircumference / this.secondsPerTurn;
+        const d = Q0 / this.paperThickness;
+        return Math.pow(d, 0.5) * (1 / v0) * 2 * (Math.pow(d + x1, 0.5) - Math.pow(d, 0.5));
+    }
+    timeToPlace(t1) {
+        const Q0 = Math.pow(this.initialCircumference, 2) / (4 * Math.PI);
+        const v0 = this.initialCircumference / this.secondsPerTurn;
+        const d = Q0 / this.paperThickness;
+        return Math.pow((t1 * v0) / (2 * Math.pow(d, 0.5)) + Math.pow(d, 0.5), 2) - d;
+    }
+}

package/lib/RollCopy.d.ts

@@ -0,0 +1,85 @@
+import { ConditionState } from "./ConditionState";
+import { AnySymbol } from "./Symbol";
+import { EditorialAssumption } from "./EditorialAssumption";
+import { PlaceTimeConversion } from "./PlaceTimeConversion";
+import { RollFeature } from "./Feature";
+/**
+ * This condition state is used to describe to roll's
+ * paper shrinkage or stretching. It might be calculated
+ * on the basis of comparing the vertical or horizontal
+ * extent with other witnesses of the same roll.
+ */
+export interface PaperStretch extends ConditionState<'paper-stretch'> {
+    factor: number;
+}
+export interface GeneralRollCondition extends ConditionState<'general'> {
+}
+export type RollConditionAssignment = EditorialAssumption<'conditionAssignment', GeneralRollCondition | PaperStretch>;
+export interface Shift {
+    horizontal: number;
+    vertical: number;
+}
+export type DateAssignment = EditorialAssumption<'dateAssignment', Date>;
+export interface ProductionEvent {
+    company: string;
+    system: string;
+    paper: string;
+    date: DateAssignment;
+}
+export declare class RollCopy {
+    type: 'RollCopy';
+    id: string;
+    measurements: Partial<{
+        dimensions: {
+            width: number;
+            height: number;
+            unit: string;
+        };
+        punchDiameter: {
+            value: number;
+            unit: string;
+        };
+        holeSeparation: {
+            value: number;
+            unit: string;
+        };
+        margins: {
+            treble: number;
+            bass: number;
+            unit: string;
+        };
+        shift: Shift;
+        measuredBy: {
+            software: string;
+            version: string;
+            date: Date;
+        };
+    }>;
+    productionEvent?: ProductionEvent;
+    conditions: RollConditionAssignment[];
+    location: string;
+    /**
+     * Provides a reconstructed version of the roll,
+     * with shift, stretch and emendations already
+     * taken into account. This property will not be
+     * exported in the final JSON.
+     */
+    features: RollFeature[];
+    scan?: string;
+    insertFeature(feature: RollFeature): void;
+    setShift(shift: Shift): void;
+    setStretch(stretch: EditorialAssumption<'conditionAssignment', PaperStretch>): void;
+    shallowClone(): RollCopy;
+}
+export declare function asSymbols(features: RollFeature[]): AnySymbol[];
+export declare function readFromStanfordAton(atonString: string, adjustByRewind?: boolean, shift?: number): RollCopy;
+/**
+ * Spencer Chase's rolls seem to be scanned at a roll speed of
+ * 83 (=8.3 feet per minute).
+ *
+ * @param midiBuffer
+ * @param conversion
+ */
+export declare function readFromSpencerMIDI(midiBuffer: ArrayBuffer, conversion?: PlaceTimeConversion): RollCopy;
+export declare function shiftVertically(features: RollFeature[], amount: number): void;
+export declare const findCopiesCarrying: (sources: RollCopy[], symbol: AnySymbol) => Set<string>;

package/lib/RollCopy.js

@@ -0,0 +1,273 @@
+import { AtonParser } from "./aton/AtonParser";
+import { v4 } from "uuid";
+import { assign, flat } from "./EditorialAssumption";
+import { read } from "midifile-ts";
+import { asSpans } from "./asMIDISpans";
+import { KinematicConversion } from "./PlaceTimeConversion";
+import { WelteT100 } from "./TrackerBar";
+const applyShift = (shift, to) => {
+    for (const event of to) {
+        event.horizontal.from += shift.horizontal;
+        if (event.horizontal.to) {
+            event.horizontal.to += shift.horizontal;
+        }
+        event.vertical.from += shift.vertical;
+        if (event.vertical.to) {
+            event.vertical.to += shift.vertical;
+        }
+    }
+};
+const applyStretch = (stretch, to) => {
+    for (const event of to) {
+        event.horizontal.from *= stretch;
+        if (event.horizontal.to) {
+            event.horizontal.to *= stretch;
+        }
+    }
+};
+export class RollCopy {
+    constructor() {
+        Object.defineProperty(this, "type", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'RollCopy'
+        });
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: v4()
+        });
+        Object.defineProperty(this, "measurements", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "productionEvent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "conditions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "location", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        /**
+         * Provides a reconstructed version of the roll,
+         * with shift, stretch and emendations already
+         * taken into account. This property will not be
+         * exported in the final JSON.
+         */
+        Object.defineProperty(this, "features", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "scan", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // P138i has representation => IIIF Image Link
+    }
+    insertFeature(feature) {
+        this.measurements.shift && applyShift(this.measurements.shift, [feature]);
+        const stretch = flat(this.conditions)
+            .find(state => state.type === 'paper-stretch');
+        if (stretch) {
+            applyStretch(stretch.factor, [feature]);
+        }
+        this.features.push(feature);
+    }
+    setShift(shift) {
+        this.measurements.shift = shift;
+        applyShift(shift, this.features);
+    }
+    setStretch(stretch) {
+        this.conditions.push(stretch);
+        applyStretch(flat(stretch).factor, this.features);
+    }
+    shallowClone() {
+        const copy = new RollCopy();
+        copy.id = this.id;
+        copy.measurements = { ...this.measurements };
+        copy.productionEvent = this.productionEvent;
+        copy.location = this.location;
+        copy.conditions = [...this.conditions];
+        copy.scan = this.scan;
+        copy.features = [...this.features];
+        return copy;
+    }
+}
+export function asSymbols(features) {
+    return features.map((feature) => {
+        return {
+            id: `symbol_${v4()}`,
+            ...new WelteT100().meaningOf(feature.vertical.from),
+            carriers: [assign('carrierAssignment', feature)]
+        };
+    });
+}
+export function readFromStanfordAton(atonString, adjustByRewind = true, shift = 0) {
+    function pixelsToMillimeters(pixels, dpi) {
+        return pixels / dpi * 25.4;
+    }
+    const parser = new AtonParser();
+    const json = parser.parse(atonString);
+    const holes = json.ROLLINFO.HOLES.HOLE;
+    const druid = json.ROLLINFO.DRUID;
+    const holeSeparation = parseFloat(json.ROLLINFO.HOLE_SEPARATION.replace('px'));
+    const hardMarginBass = parseFloat(json.ROLLINFO.HARD_MARGIN_BASS.replace('px'));
+    const hardMarginTreble = parseFloat(json.ROLLINFO.HARD_MARGIN_TREBLE.replace('px'));
+    const dpi = parseFloat(json.ROLLINFO.LENGTH_DPI.replace('ppi'));
+    const rollWidth = parseFloat(json.ROLLINFO.ROLL_WIDTH.replace('px')) / dpi * 25.4;
+    const rollHeight = parseFloat(json.ROLLINFO.IMAGE_LENGTH.replace('px')) / dpi * 25.4;
+    let averagePunchDiameter = -1;
+    const lastHole = +holes[holes.length - 1].TRACKER_HOLE;
+    const rewindShift = adjustByRewind ? 91 - lastHole : shift;
+    const copy = new RollCopy();
+    copy.measurements = {
+        dimensions: {
+            width: rollWidth,
+            height: rollHeight,
+            unit: 'mm'
+        },
+        punchDiameter: {
+            value: averagePunchDiameter,
+            unit: 'mm'
+        },
+        holeSeparation: {
+            value: holeSeparation,
+            unit: 'px'
+        },
+        margins: {
+            treble: hardMarginTreble,
+            bass: hardMarginBass,
+            unit: 'px'
+        },
+        // todo
+        shift: {
+            horizontal: 0,
+            vertical: 0
+        }
+    };
+    let circularPunches = 0;
+    const features = [];
+    for (let i = 0; i < holes.length; i++) {
+        const hole = holes[i];
+        const circularity = +hole.CIRCULARITY.replace('px', '');
+        if (circularity > 0.95) {
+            const perimeterInMM = pixelsToMillimeters(+hole.PERIMETER.replace('px', ''), dpi);
+            averagePunchDiameter += perimeterInMM;
+            circularPunches += 1;
+        }
+        if (!hole.NOTE_ATTACK || !hole.OFF_TIME)
+            continue;
+        const trackerHole = +hole.TRACKER_HOLE + rewindShift;
+        const noteAttack = +hole.NOTE_ATTACK.replace('px', '');
+        const offset = +hole.OFF_TIME.replace('px', '');
+        const height = offset - noteAttack;
+        const column = +hole.ORIGIN_COL.replace('px', '');
+        const columnWidth = +hole.WIDTH_COL.replace('px', '');
+        const annotates = `https://stacks.stanford.edu/image/iiif/${druid}/${druid}_0001/${column},${noteAttack},${columnWidth},${height}/128,/270/default.jpg`;
+        const feature = {
+            id: v4(),
+            annotates,
+            vertical: {
+                from: trackerHole,
+                unit: 'track'
+            },
+            horizontal: {
+                unit: 'mm',
+                from: pixelsToMillimeters(noteAttack, dpi),
+                to: pixelsToMillimeters(offset, dpi)
+            }
+        };
+        features.push(feature);
+    }
+    averagePunchDiameter /= circularPunches;
+    averagePunchDiameter /= Math.PI;
+    copy.scan = `https://stacks.stanford.edu/image/iiif/${druid}%2F${druid}_0001/`;
+    copy.features = features;
+    return copy;
+}
+/**
+ * Spencer Chase's rolls seem to be scanned at a roll speed of
+ * 83 (=8.3 feet per minute).
+ *
+ * @param midiBuffer
+ * @param conversion
+ */
+export function readFromSpencerMIDI(midiBuffer, conversion = new KinematicConversion(8.3)) {
+    const midi = read(midiBuffer);
+    const features = [];
+    const copy = new RollCopy();
+    const spans = asSpans(midi);
+    for (const span of spans) {
+        const left = conversion.timeToPlace(span.onsetMs / 1000) * 10;
+        const right = conversion.timeToPlace(span.offsetMs / 1000) * 10;
+        const horizontalDimension = {
+            from: left,
+            to: right,
+            unit: 'mm'
+        };
+        if (span.type !== 'note')
+            continue;
+        const midiShift = 13;
+        let trackerHole = span.pitch - midiShift;
+        // for whatever reasons, the expression tracks
+        // of the Spencer Chase's MIDI rolls are off
+        // by two on the bass-side.
+        if (trackerHole < 10) {
+            trackerHole -= 2;
+        }
+        const feature = {
+            vertical: {
+                from: trackerHole,
+                unit: 'track'
+            },
+            horizontal: horizontalDimension,
+            id: v4()
+        };
+        features.push(feature);
+    }
+    copy.features = features;
+    return copy;
+}
+export function shiftVertically(features, amount) {
+    for (const event of features) {
+        event.vertical.from += amount;
+        try {
+            const newEvent = new WelteT100().meaningOf(event.vertical.from);
+            for (const key in newEvent) {
+                event[key] = newEvent[key];
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+}
+export const findCopiesCarrying = (sources, symbol) => {
+    const result = new Set();
+    for (const feature of flat(symbol.carriers)) {
+        for (const copy of sources) {
+            if (copy.features.includes(feature)) {
+                result.add(copy.id);
+            }
+        }
+    }
+    return result;
+};

package/lib/RollEvent.d.ts

@@ -0,0 +1,76 @@
+import { RollMeasurement } from "./Measurement";
+import { WithId } from "./WithId";
+export interface HorizontalSpan {
+    unit: 'mm';
+    from: number;
+    to: number;
+}
+export interface VerticalSpan {
+    unit: 'track';
+    from: number;
+    to?: number;
+}
+export interface RollFeature<T> extends WithId {
+    type: T;
+    /**
+     * 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';
+    measurement: RollMeasurement;
+}
+export interface Note extends RollFeature<'note'> {
+    pitch: number;
+}
+export type ExpressionScope = 'bass' | 'treble';
+export type ExpressionType = 'SustainPedalOn' | 'SustainPedalOff' | 'SoftPedalOn' | 'SoftPedalOff' | 'MezzoforteOff' | 'MezzoforteOn' | 'SlowCrescendoOn' | 'SlowCrescendoOff' | 'ForzandoOn' | 'ForzandoOff' | 'MotorOff' | 'MotorOn' | 'Rewind' | 'ElectricCutOff';
+export interface Expression extends RollFeature<'expression'> {
+    scope: ExpressionScope;
+    expressionType: ExpressionType;
+}
+export declare const isRollEvent: (e: any) => e is AnyRollEvent;
+export interface Perforation extends RollFeature<'perforation'> {
+    accelerating?: boolean;
+}
+/**
+ * This denotes perforations that are covered by an editor.
+ * The covered perforation is not considered to be part
+ * of the original note or expression hole anymore.
+ */
+export interface Cover extends RollFeature<'cover'> {
+    /**
+     * This property can be used to indicate e.g. the
+     * color or material of the cover.
+     */
+    note?: string;
+}
+/**
+ * For handwritten insertions like e. g. the
+ * perforation date in the end of a roll.
+ */
+export interface HandwrittenText extends RollFeature<'handwrittenText'> {
+    text: string;
+    rotation?: number;
+}
+/**
+ * This type can be used to indicate stamps like e. g. the
+ * "controlliert" stamp in the beginning of rolls or the
+ * date at the end of (later) Welte rolls.
+ */
+export interface Stamp extends RollFeature<'stamp'> {
+    text: string;
+    rotation?: number;
+}
+export interface RollLabel extends RollFeature<'rollLabel'> {
+    text: string;
+    signed: boolean;
+}
+export type AnyRollEvent = Note | Expression | HandwrittenText | Stamp | Cover | RollLabel;

package/lib/RollEvent.js

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

package/lib/Stage.d.ts

@@ -0,0 +1,37 @@
+import { ActorAssignment, Edit } from "./Edit";
+import { EditorialAssumption, Motivation } from "./EditorialAssumption";
+import { AnySymbol } from "./Symbol";
+export interface Derivation extends EditorialAssumption<'derivation', Stage> {
+}
+declare const versionType: readonly ["edition", "authorised-revision", "unauthorised-revision", "gloss"];
+export type VersionType = typeof versionType[number];
+/**
+ * Stage + Stage Creation
+ */
+export interface Stage {
+    id: string;
+    siglum: string;
+    actor?: ActorAssignment;
+    basedOn?: Derivation;
+    edits: Edit[];
+    motivations: Motivation<string>[];
+    type: VersionType;
+}
+export declare const traverseStages: (stage: Stage, callback: (stage: Stage) => void) => void;
+export declare const getSnapshot: (stage: Stage) => AnySymbol[];
+/**
+ * Walks through the stages. If it finds a symbol that is still
+ * part of the tradition (i.e. it is included in the current snapshot)
+ * and is equivalent with the given symbol, it will add the feature
+ * carrying the symbol to the collated symbol. Otherwise, the
+ * given symbol will be added to the current stage's insertions.
+ *
+ * All symbols of the tradition that are not included in the given
+ * symbols are considered to be deleted.
+ *
+ * @param creation
+ * @param symbols
+ * @returns
+ */
+export declare function fillEdits(currentStage: Stage, symbols: AnySymbol[]): void;
+export {};