linked-rolls 0.65.0 → 0.67.0

package/lib/model/RollCopy.d.ts

@@ -5,7 +5,7 @@ import { TrackCalibration } from "./TrackCalibration.js";
 import { AnyFeature, FeatureOrPatch, HorizontalSpan, Patch } from "./Feature.js";
 import { ActorAssignment, DateAssignment, ObjectAssumption, ReferenceAssumption } from "./Assumption.js";
 import { WithId, WithType } from "../shared/utils.js";
-import { Agent, Concept } from "./Agent.js";
+import { Agent, Concept, Software } from "./Agent.js";
 import { FeatureSource } from "./FeatureSource.js";
 import { Measure, Millimeters, Percent, Quantity, Track } from "./Quantity.js";
 import { Perforator } from "./Perforator.js";
@@ -161,6 +161,28 @@ export interface Alignment {
         date: Date;
     };
 }
+/**
+ * The width and length of a roll copy's paper, as they were measured on
+ * it or on its scan.
+ * @see crm:E54 Dimension
+ */
+export interface RollDimensions {
+    /**
+     * The width of the roll.
+     * @see reo:width
+     */
+    width: Millimeters;
+    /**
+     * The total height (length) of the roll.
+     * @see reo:height
+     */
+    height: Millimeters;
+    /**
+     * The unit of measurement.
+     * @see crm:P91 has unit
+     */
+    unit: 'mm';
+}
 /** The margins on the treble and bass sides of the roll, in the unit the scan was measured in. */
 export interface Margins<U extends 'px' | 'mm'> {
     treble: Quantity<U>;
@@ -209,11 +231,14 @@ export interface ProductionEvent {
      */
     system?: Concept;
     /**
-     * The paper speed the copy was cut for. A copy cut from the same
-     * master for another speed comes out longer or shorter than the
-     * roll it is aligned with by the ratio of the speeds. The alignment
-     * measures that ratio far more closely than a label states a speed,
-     * so the speed is held against what the alignments give
+     * The paper speed the copy was cut for, as the speed at the
+     * beginning of the roll: a tempo marking states it so, and the
+     * take-up spool accelerates from there. A performance of a version
+     * the copy bears witness to starts at it (`paperSpeedOf`). A copy cut
+     * from the same master for another speed comes out longer or shorter
+     * than the roll it is aligned with by the ratio of the speeds. The
+     * alignment measures that ratio far more closely than a label states
+     * a speed, so the speed is held against what the alignments give
      * (`alignmentProblems`) rather than used to find it.
      * @see reo:paperSpeed
      */
@@ -307,11 +332,14 @@ export type Modification = Partial<{
  */
 export interface RollCopy extends WithType<'RollCopy'>, WithId {
     /**
-     * Physical measurements of this roll copy, including
-     * dimensions, hole separation, margins, the alignment onto the
-     * edition's axis, and information about the measuring software. What the
-     * perforations tell about the machine that cut them is stated
-     * with the production.
+     * Physical measurements of this roll copy: its dimensions, hole
+     * separation and margins, the resolution of its scan, and how it
+     * lies on the edition's axis. What the perforations tell about the
+     * machine that cut them is stated with the production.
+     *
+     * A value the edition exports is an object assumption, so that it
+     * can say what took it: a measurement naming the program and its
+     * version, the scan or analysis it was taken on, and the day.
      * @see crm:P39i was measured by
      */
     measurements: Partial<{
@@ -319,23 +347,7 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
          * The physical dimensions of the roll.
          * @see reo:dimensions
          */
-        dimensions: {
-            /**
-             * The width of the roll.
-             * @see reo:width
-             */
-            width: Millimeters;
-            /**
-             * The total height (length) of the roll.
-             * @see reo:height
-             */
-            height: Millimeters;
-            /**
-             * The unit of measurement.
-             * @see crm:P91 has unit
-             */
-            unit: 'mm';
-        };
+        dimensions: ObjectAssumption<RollDimensions>;
         /**
          * The distance across the roll from the centre of one track to
          * the next, the track pitch or Teilung, in the unit the scan was
@@ -344,7 +356,7 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
          * along the roll.
          * @see reo:holeSeparation
          */
-        holeSeparation: Measure<'px'> | Measure<'mm'>;
+        holeSeparation: ObjectAssumption<Measure<'px'> | Measure<'mm'>>;
         /**
          * The margins on the treble and bass sides of the roll.
          * Not exported to RDF.
@@ -389,35 +401,13 @@ export interface RollCopy extends WithType<'RollCopy'>, WithId {
          * files do not state.
          * @see reo:scanResolution
          */
-        scanResolution: Measure<'px/in'>;
+        scanResolution: ObjectAssumption<Measure<'px/in'>>;
         /**
          * Relates this copy's scan to the tracker bar: how the scanning
          * software's hole numbering was shifted onto the bar, and where
          * the track grid sits in the image. Not exported to RDF.
          */
         trackCalibration: TrackCalibration;
-        /**
-         * Information about the software used to take the measurements.
-         * @see crmdig:L23 used software or firmware
-         */
-        measuredBy: {
-            /**
-             * The name of the measurement software.
-             * @see rdfs:label
-             */
-            software: string;
-            /**
-             * The version of the measurement software.
-             * @see owl:versionInfo
-             */
-            version: string;
-            /**
-             * The date on which the measurements were taken.
-             * @format date
-             * @see dcterms:date
-             */
-            date: Date;
-        };
     }>;
     /**
      * The production event that created this roll copy.
@@ -496,6 +486,8 @@ export declare const statesNothing: (modification: Modification) => boolean;
 export declare const featuresByAct: (copy: Pick<RollCopy, 'production' | 'modifications'>) => FeatureOrPatch[][];
 /** Every feature the copy states at a place of its own, whichever act made it. */
 export declare const featuresOf: (copy: Pick<RollCopy, 'production' | 'modifications'>) => FeatureOrPatch[];
+/** The programs the measurements of a copy name as having taken them, each once, as far as they name any. */
+export declare const measuringSoftwareOf: (copy: Pick<RollCopy, 'measurements'>) => Software[];
 /** Whether the condition is the stretch or shrinkage of the paper, as measured on the copy. */
 export declare const isPaperStretch: (condition: RollConditionAssignment) => condition is ObjectAssumption<PaperStretch>;
 /** What the copy's paper was measured to have done, where anything was measured. */

package/lib/model/RollCopy.js

@@ -35,6 +35,16 @@ export const statesNothing = (modification) => modification.type === 'Removal' ?
 export const featuresByAct = (copy) => [copy.production?.produced ?? [], ...copy.modifications.map(featuresMadeBy)];
 /** Every feature the copy states at a place of its own, whichever act made it. */
 export const featuresOf = (copy) => featuresByAct(copy).flat();
+/** The measurements of a copy the edition exports, each of which can say what took it. */
+const exportedMeasurementsOf = (copy) => [copy.measurements.dimensions, copy.measurements.holeSeparation, copy.measurements.scanResolution]
+    .filter(value => value !== undefined);
+/** The programs the measurements of a copy name as having taken them, each once, as far as they name any. */
+export const measuringSoftwareOf = (copy) => {
+    const named = exportedMeasurementsOf(copy)
+        .flatMap(value => value['@annotation']?.belief.reasons ?? [])
+        .flatMap(reason => reason.type === 'measurement' ? reason.software ?? [] : []);
+    return [...new Map(named.map(software => [`${software.name}\u0000${software.version ?? ''}`, software])).values()];
+};
 /** Whether the condition is the stretch or shrinkage of the paper, as measured on the copy. */
 export const isPaperStretch = (condition) => condition.conditionType === 'paper-stretch';
 /** What the copy's paper was measured to have done, where anything was measured. */

package/lib/model/Version.d.ts

@@ -33,6 +33,23 @@ export type Derivation = ReferenceAssumption & {
 };
 /** The tolerance the derivation was collated at, or the default where it states none. */
 export declare const collationToleranceOf: (derivation: Readonly<Derivation>) => CollationTolerance;
+/**
+ * How long a version's paper runs for a length of the paper of the
+ * version it derives from: about 0.77 for a Licensee or green re-cut of
+ * a red roll, cut for a slower paper speed.
+ * @see crm:E54 Dimension
+ */
+export interface LengthRatio {
+    /**
+     * @see crm:P90 has value
+     */
+    value: number;
+    /**
+     * The standard uncertainty of the value, one standard deviation.
+     * @see reo:uncertainty
+     */
+    uncertainty?: number;
+}
 /**
  * How a version was made, where that is known and worth stating.
  *
@@ -63,6 +80,19 @@ export interface VersionCreation {
      * @see crm:P33 used specific technique
      */
     procedure?: Concept;
+    /**
+     * How long the act made the version's paper for a length of the
+     * paper of the version it derives from. A re-cut for a system whose
+     * paper runs slower comes out shorter by the ratio of the speeds,
+     * and the alignments of the copies measure that ratio more closely
+     * than any label states a speed (`lengthRatioOf`). It is stated
+     * where the edition holds to it, as a measurement naming the copies
+     * it used and the program that found it, so that it can serve as a
+     * premise. A speed follows from it only together with a premise
+     * about the speed of the other version.
+     * @see reo:lengthRatio
+     */
+    lengthRatio?: ObjectAssumption<LengthRatio>;
 }
 /**
  * A version is defined by the sum of edits applied to the version it is

package/lib/readers/stanfordAton.js

@@ -1,5 +1,6 @@
 import { v4 } from "uuid";
 import { AtonParser } from "./AtonParser.js";
+import { assignDate } from "../model/Assumption.js";
 import { systemOf } from "../systems/TrackerBar.js";
 import { welteT100 } from "../systems/welteT100/bar.js";
 import { inMillimeters, mean, mm, pixelsPerInch, px, subtract, track } from "../model/Quantity.js";
@@ -120,19 +121,24 @@ const tearsIn = (tears, dpi, depictionOf) => {
         .sort((a, b) => a.horizontal.from - b.horizontal.from);
 };
 /**
- * The software behind an analysis and when it was run, as the
- * analysis file states them.
+ * The software behind an analysis and the day it was run, as the
+ * analysis file states them: the measurement the dimensions and the
+ * hole separation it gives rest on.
  */
-const measuredByOf = (rollinfo) => {
+const measurementOf = (rollinfo) => {
     const date = new Date(rollinfo.ANALYSIS_DATE);
     if (!rollinfo.HOLE_SOFTWARE || isNaN(date.getTime()))
         return undefined;
     return {
-        software: rollinfo.HOLE_SOFTWARE,
-        version: rollinfo.SOFTWARE_DATE ?? '',
-        date
+        type: 'measurement',
+        software: [{ name: rollinfo.HOLE_SOFTWARE, ...(rollinfo.SOFTWARE_DATE && { version: rollinfo.SOFTWARE_DATE }) }],
+        date: assignDate(new Date(date.getFullYear(), date.getMonth(), date.getDate()))
     };
 };
+/** The value held on the strength of the measurement, where the file names one, and plainly where it does not. */
+const takenBy = (measurement) => (value) => measurement
+    ? { ...value, '@annotation': { id: v4(), belief: { type: 'belief', id: v4(), certainty: 'true', reasons: [measurement] } } }
+    : value;
 export function readFromStanfordAton(atonString, { trackShift, system = welteT100, scan } = {}) {
     const parser = new AtonParser();
     const json = parser.parse(atonString);
@@ -141,7 +147,7 @@ export function readFromStanfordAton(atonString, { trackShift, system = welteT10
     const stanford = druid ? stanfordScan(druid) : undefined;
     const separation = readPx(json.ROLLINFO.HOLE_SEPARATION);
     const dpi = parseFloat(json.ROLLINFO.LENGTH_DPI);
-    const measuredBy = measuredByOf(json.ROLLINFO);
+    const measured = takenBy(measurementOf(json.ROLLINFO));
     const shift = trackShift ?? calibrationShiftIn(holes, system);
     const calibration = {
         unit: 'px',
@@ -196,15 +202,15 @@ export function readFromStanfordAton(atonString, { trackShift, system = welteT10
         modifications: [],
         ...((scan ?? stanford) && { scan: scan ?? stanford?.scan }),
         measurements: {
-            dimensions: {
+            dimensions: measured({
                 width: inMillimeters(readPx(json.ROLLINFO.ROLL_WIDTH), dpi),
                 height: inMillimeters(readPx(json.ROLLINFO.IMAGE_LENGTH), dpi),
                 unit: 'mm'
-            },
-            holeSeparation: {
+            }),
+            holeSeparation: measured({
                 value: separation,
                 unit: 'px'
-            },
+            }),
             margins: {
                 treble: readPx(json.ROLLINFO.HARD_MARGIN_TREBLE),
                 bass: readPx(json.ROLLINFO.HARD_MARGIN_BASS),
@@ -213,8 +219,7 @@ export function readFromStanfordAton(atonString, { trackShift, system = welteT10
             ...(Number.isFinite(dpi) && {
                 scanResolution: { value: pixelsPerInch(dpi), unit: 'px/in' }
             }),
-            trackCalibration: calibration,
-            ...(measuredBy && { measuredBy })
+            trackCalibration: calibration
         }
     };
 }