linked-rolls 0.21.0 → 0.22.0

package/lib/RollCopy.d.ts

@@ -332,7 +332,9 @@ export declare const barOf: (copy: Pick<RollCopy, 'production'>) => TrackerBar;
 export declare function asSymbols(features: AnyFeature[], bar: TrackerBar): AnySymbol[];
 /**
  * The tracks a copy carries holes on that the tracker bar does not read.
- * A non-empty result usually means the scan is calibrated wrongly.
+ * A non-empty result usually means the scan is calibrated wrongly. A hole
+ * lying across several positions is counted against each one the bar
+ * cannot read, and not at all where it reads them all.
  */
 export declare function unreadTracks(features: AnyFeature[], bar: TrackerBar): Map<Track, number>;
 /**

package/lib/RollCopy.js

@@ -40,30 +40,27 @@ export function asSymbols(features, bar) {
     const end = bar.endsAt(holes);
     return holes
         .filter(feature => end === undefined || feature.horizontal.from <= end.at)
-        .flatMap((feature) => {
-        const meaning = bar.meaningOf(feature.vertical.from);
-        if (!meaning)
-            return [];
-        return [{
-                id: `symbol_${v4()}`,
-                ...meaning,
-                carriers: [assignReference(feature.id)]
-            }];
-    });
+        // An opening across two positions uncovers both bar holes and so
+        // reads as both commands; one on a single position gives the one.
+        .flatMap((feature) => bar.meaningsOf(feature.vertical).map(meaning => ({
+        id: `symbol_${v4()}`,
+        ...meaning,
+        carriers: [assignReference(feature.id)]
+    })));
 }
 /**
  * The tracks a copy carries holes on that the tracker bar does not read.
- * A non-empty result usually means the scan is calibrated wrongly.
+ * A non-empty result usually means the scan is calibrated wrongly. A hole
+ * lying across several positions is counted against each one the bar
+ * cannot read, and not at all where it reads them all.
  */
 export function unreadTracks(features, bar) {
     const counts = new Map();
     features
         .filter(feature => feature.type === 'Hole')
-        .filter(feature => !bar.meaningOf(feature.vertical.from))
-        .forEach(feature => {
-        const position = feature.vertical.from;
-        counts.set(position, (counts.get(position) || 0) + 1);
-    });
+        .flatMap(feature => bar.positionsIn(feature.vertical))
+        .filter(position => !bar.meaningOf(position))
+        .forEach(position => counts.set(position, (counts.get(position) || 0) + 1));
     return counts;
 }
 /**

package/lib/TrackerBar.d.ts

@@ -67,8 +67,20 @@ export interface TrackerBar {
      * the symbols afterwards.
      */
     endsAt(features: readonly PlacedOnBar[]): RollEnd | undefined;
-    /** `undefined` for a position the bar does not read. */
+    /**
+     * `undefined` for a position the bar does not read. A measured place
+     * is snapped to the nearest position: perforations sit on the grid and
+     * measurements of them scatter around it.
+     */
     meaningOf(position: Track): TrackMeaning | undefined;
+    /**
+     * What the bar reads off a feature, which may lie across more than one
+     * position. A perforation lifts every valve whose bar hole it uncovers,
+     * so an opening across two positions reads as two commands; one on a
+     * single position reads as the one `meaningOf` gives, and one on
+     * positions the bar does not read as none at all.
+     */
+    meaningsOf(span: OnBar): readonly TrackMeaning[];
     /**
      * `meaningOf` inverted: the position this bar reads the meaning on,
      * or `undefined` where it does not read it at all. A symbol's track
@@ -76,8 +88,10 @@ export interface TrackerBar {
      * sits on exactly one position of a given bar.
      */
     positionOf(meaning: TrackMeaning): Track | undefined;
-    /** `undefined` for a position the bar does not read. */
+    /** `undefined` for a position the bar does not read; snapped as `meaningOf` is. */
     roleOf(position: Track): TrackRole | undefined;
+    /** The positions a feature lies across, snapped to the grid. */
+    positionsIn(span: OnBar): readonly Track[];
 }
 /**
  * What a position says, as a key. Two bars read the same thing exactly
@@ -118,6 +132,15 @@ export type PlacedOnBar = {
         readonly from: Track;
     };
 };
+/**
+ * Where a feature lies across the bar: one place, or a run of them where
+ * `to` is given. Structural, so a feature's `vertical` passes as it is and
+ * this module need know nothing about features.
+ */
+export type OnBar = {
+    readonly from: Track;
+    readonly to?: Track;
+};
 export interface TrackerBarSpec {
     id: string;
     name: string;

package/lib/TrackerBar.js

@@ -20,24 +20,42 @@ const areasOf = ({ notes, trackCount }) => [
     { role: 'treble-expression', from: track(notes.to + 1), to: track(trackCount) }
 ];
 const scopeOf = (role) => role === 'bass-expression' ? 'bass' : 'treble';
+/**
+ * The bar position a measured place falls on. Places are measured off a
+ * scan and scatter around the grid, while the bar has holes only at whole
+ * positions, so the nearest one is the one uncovered.
+ */
+const snap = (place) => track(Math.round(place));
+/** The positions a span reaches, both ends snapped and the run between them. */
+const positionsBetween = (span) => {
+    const ends = [snap(span.from), snap(span.to ?? span.from)];
+    const [first, last] = [Math.min(...ends), Math.max(...ends)];
+    return Array.from({ length: last - first + 1 }, (_, step) => track(first + step));
+};
 export const describeTrackerBar = (spec) => {
     const areas = areasOf(spec);
-    const roleOf = (position) => areas.find(area => position >= area.from && position <= area.to)?.role;
+    const areaAt = (position) => areas.find(area => position >= area.from && position <= area.to)?.role;
+    const roleOf = (position) => areaAt(snap(position));
     const meaningOf = (position) => {
-        const role = roleOf(position);
+        const place = snap(position);
+        const role = areaAt(place);
         if (!role)
             return undefined;
         if (role === 'note') {
             return {
                 type: 'note',
-                pitch: position - spec.notes.from + spec.notes.lowestPitch
+                pitch: place - spec.notes.from + spec.notes.lowestPitch
             };
         }
-        const expressionType = spec.expressions.get(position);
+        const expressionType = spec.expressions.get(place);
         if (!expressionType)
             return undefined;
         return { type: 'expression', expressionType, scope: scopeOf(role) };
     };
+    const meaningsOf = (span) => positionsBetween(span).flatMap(position => {
+        const meaning = meaningOf(position);
+        return meaning ? [meaning] : [];
+    });
     const positions = new Map(Array.from({ length: spec.trackCount }, (_, i) => track(i + 1))
         .flatMap(position => {
         const meaning = meaningOf(position);
@@ -54,7 +72,7 @@ export const describeTrackerBar = (spec) => {
     const endsAt = (features) => {
         const hold = spec.rewindHold ?? mm(0);
         const candidates = features
-            .filter(feature => feature.vertical.from === rewind)
+            .filter(feature => snap(feature.vertical.from) === rewind)
             .filter(feature => !shared || feature.horizontal.to - feature.horizontal.from >= hold)
             .map(feature => feature.horizontal.from);
         return candidates.length ? { at: mm(Math.min(...candidates)), because: 'rewind' } : undefined;
@@ -70,8 +88,10 @@ export const describeTrackerBar = (spec) => {
         rewindTrack: track(rewind),
         ...(spec.paperSpeed && { paperSpeed: spec.paperSpeed }),
         meaningOf,
+        meaningsOf,
         positionOf: meaning => positions.get(keyOf(meaning)),
-        roleOf
+        roleOf,
+        positionsIn: positionsBetween
     };
 };
 /**

package/lib/alignment.js

@@ -59,8 +59,9 @@ const noteOnsets = (features, bar) => features
     .flatMap((feature) => {
     if (feature.type !== 'Hole')
         return [];
-    const meaning = bar.meaningOf(feature.vertical.from);
-    return meaning?.type === 'note' ? [{ pitch: meaning.pitch, at: feature.horizontal.from }] : [];
+    return bar.meaningsOf(feature.vertical)
+        .filter(meaning => meaning.type === 'note')
+        .map(meaning => ({ pitch: meaning.pitch, at: feature.horizontal.from }));
 })
     .sort(byPlace);
 const median = (values) => {

package/lib/constraints.js

@@ -79,8 +79,10 @@ const carriersOffTheirMeaning = (view, version, perforations) => {
         const copy = view.copyOf(carrier.id);
         if (!copy)
             return false;
-        const meaning = barOf(copy).meaningOf(carrier.vertical.from);
-        return !meaning || keyOf(meaning) !== keyOf(symbol);
+        // A carrier lying across several positions reads as several commands,
+        // and carries the symbol as long as one of them is the symbol's.
+        return !barOf(copy).meaningsOf(carrier.vertical)
+            .some(meaning => keyOf(meaning) === keyOf(symbol));
     };
     return perforations
         .filter(symbol => view.carriersOf(symbol).some(carrier => misread(carrier, symbol)))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-rolls",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "Digital editions of piano rolls: import, collation, editorial assumptions, JSON-LD export, and emulation through a reproducing system",
   "license": "MIT",
   "repository": {