@cornerstonejs/metadata 5.13.2 → 5.15.0

package/dist/esm/displayset/scenarioFixtures.test.js

@@ -0,0 +1,206 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { createDisplaySetFromGroup } from './createDisplaySetFromGroup.js';
+import { compiledDisplaySetRules } from './compiledDisplaySetRules.js';
+import { createDisplaySetSplitRules, displaySetRules } from './displaySetRules.js';
+import { groupInstancesBySplitRules } from './groupInstancesBySplitRules.js';
+import { ctLocalizers, ctSeriesWithScouts, fourViewMammogram, geDiffusionSeries, t2SeriesWithZeroBValue, uidsOf, usSweepsAndClips, } from './__fixtures__/scenarioInstances.js';
+function displaySetsOf(instances, rules, read = (displaySet) => displaySet.SeriesDescription) {
+    return groupInstancesBySplitRules([...instances].reverse(), rules).map((group, splitNumber) => {
+        const displaySet = createDisplaySetFromGroup(group, {
+            splitNumber,
+        });
+        return {
+            rule: displaySet.splitRuleId,
+            uids: uidsOf(group.instances),
+            description: read(displaySet),
+        };
+    });
+}
+function withDefaults(rules, options) {
+    return createDisplaySetSplitRules({ ...displaySetRules, ...rules }, options);
+}
+const bySliceLocation = (a, b) => a.SliceLocation - b.SliceLocation;
+const dwiByBValue = {
+    dwiByBValue: {
+        priority: -1,
+        context: {
+            bValue: 'Number(DiffusionBValue)',
+            isDiffusion: 'series.instances.max(bValue) > 0',
+        },
+        matches: {
+            Modality: 'MR',
+            isDiffusion: true,
+            isImage: true,
+            DiffusionBValue: { notNull: true },
+        },
+        groupBy: ['SeriesInstanceUID', 'bValue'],
+        sortBy: ['SliceLocation'],
+        attributes: {
+            SeriesDescription: {
+                template: '{SeriesDescription} b={DiffusionBValue}',
+            },
+        },
+    },
+};
+describe('diffusion MR', () => {
+    it('splits a GE DWI series by the b-value of the private tag (0043,1039), only with a declaration of the tag', () => {
+        const series = geDiffusionSeries();
+        const geDwiByBValue = {
+            geDwiByBValue: {
+                priority: -1,
+                context: {
+                    geBValues: { attribute: '00431039', vr: 'IS', vm: '4' },
+                    bValue: 'Number(geBValues)',
+                    isDiffusion: 'series.instances.max(bValue) > 0',
+                },
+                matches: {
+                    Modality: 'MR',
+                    isDiffusion: true,
+                    isImage: true,
+                    bValue: { notNull: true },
+                },
+                groupBy: ['SeriesInstanceUID', 'bValue'],
+                sortBy: ['SliceLocation'],
+                attributes: {
+                    SeriesDescription: { template: '{SeriesDescription} b={bValue}' },
+                },
+            },
+        };
+        const atB = (bValue) => uidsOf(series
+            .filter((i) => i['00431039'][0] === bValue)
+            .sort(bySliceLocation));
+        expect(displaySetsOf(series, withDefaults(geDwiByBValue))).toEqual([
+            { rule: 'geDwiByBValue', uids: atB('0'), description: 'DWI ASSET b=0' },
+            {
+                rule: 'geDwiByBValue',
+                uids: atB('1000'),
+                description: 'DWI ASSET b=1000',
+            },
+        ]);
+        expect(atB('0').length).toBe(32);
+        const defaults = displaySetsOf(series, compiledDisplaySetRules);
+        expect(defaults.map((d) => [d.rule, d.uids.length])).toEqual([
+            ['volume3d', 64],
+        ]);
+    });
+    it('does not split an MR series whose images all carry DiffusionBValue = 0', () => {
+        const series = t2SeriesWithZeroBValue();
+        expect(displaySetsOf(series, withDefaults(dwiByBValue))).toEqual([
+            {
+                rule: 'volume3d',
+                uids: uidsOf(series),
+                description: undefined,
+            },
+        ]);
+    });
+});
+describe('CT localizers', () => {
+    const ctScout = {
+        ctScout: {
+            priority: -1,
+            context: {
+                isLocalizer: "includes(ImageType, 'LOCALIZER')",
+                hasScout: 'series.instances.count(isLocalizer) > 0 && ' +
+                    'series.instances.count(isLocalizer) < series.instances.count()',
+            },
+            matches: { Modality: 'CT', hasScout: true, isLocalizer: true },
+            groupBy: ['SeriesInstanceUID'],
+            attributes: {
+                label: { template: 'SCOUT' },
+                SeriesDescription: { template: 'SCOUT {SeriesDescription}' },
+            },
+        },
+    };
+    const rules = withDefaults(ctScout);
+    const viewOf = (displaySet) => displaySet.label;
+    it('puts the localizers of a mixed series in their own display set, and keeps the axial slices in volume3d', () => {
+        const series = ctSeriesWithScouts();
+        const localizers = series.slice(0, 2);
+        const axial = series.slice(2);
+        expect(displaySetsOf(series, rules, viewOf)).toEqual([
+            {
+                rule: 'ctScout',
+                uids: uidsOf(localizers),
+                description: 'SCOUT',
+            },
+            {
+                rule: 'volume3d',
+                uids: uidsOf(axial),
+                description: undefined,
+            },
+        ]);
+    });
+    it('keeps a series of localizers only as one display set', () => {
+        const series = ctLocalizers('1.2.392.200036.9116.2.6.1.48.1214833767.99');
+        expect(displaySetsOf(series, rules).map((d) => [d.rule, d.uids])).toEqual([
+            ['volume3d', uidsOf(series)],
+        ]);
+    });
+});
+describe('ultrasound', () => {
+    const usTimeClusters = {
+        usTimeClusters: {
+            priority: -1,
+            context: { timeClustersMaxGap: 20 },
+            matches: {
+                isImage: true,
+                Modality: 'US',
+                isMultiFrame: false,
+                sweepCount: { greaterThan: 1 },
+                sweepStart: { notNull: true },
+            },
+            groupBy: ['SeriesInstanceUID', 'sweepStart'],
+            sortBy: ['acquisitionSeconds'],
+            attributes: {
+                SeriesDescription: {
+                    template: '{SeriesDescription} +{sweepOffset} s',
+                },
+            },
+        },
+    };
+    const { instances, sweeps, clips } = usSweepsAndClips();
+    const rules = withDefaults(usTimeClusters);
+    it('makes one display set for each sweep of single images, in time order', () => {
+        expect(displaySetsOf(instances, rules).slice(0, 2)).toEqual([
+            {
+                rule: 'usTimeClusters',
+                uids: uidsOf(sweeps[0]),
+                description: 'US ABDOMEN +0 s',
+            },
+            {
+                rule: 'usTimeClusters',
+                uids: uidsOf(sweeps[1]),
+                description: 'US ABDOMEN +90 s',
+            },
+        ]);
+    });
+    it('keeps each cine clip of the series as its own display set', () => {
+        expect(displaySetsOf(instances, rules)
+            .slice(2)
+            .map((d) => d.uids)).toEqual(clips.map((clip) => uidsOf([clip])));
+    });
+});
+describe('mammography', () => {
+    it('splits a four-view series without ViewPosition into RCC, LCC, RMLO and LMLO with mammoViewSplit.json', () => {
+        const ruleSet = JSON.parse(readFileSync(join(__dirname, '../../../core/examples/displaySetRules/mammoViewSplit.json'), 'utf8'));
+        const viewCodeOf = (instance) => instance.ViewCodeSequence?.[0]
+            ?.CodeValue;
+        const options = {
+            context: {
+                viewCode: viewCodeOf,
+                mammoView: (instance) => ({ 'R-10242': 'CC', 'R-10226': 'MLO' })[viewCodeOf(instance) ?? ''],
+            },
+        };
+        expect(ruleSet.requires.context).toEqual(Object.keys(options.context ?? {}).sort());
+        const series = fourViewMammogram();
+        const result = displaySetsOf(series, withDefaults(ruleSet.rules, options), (displaySet) => displaySet.descriptionName);
+        expect(result.map((d) => d.rule)).toEqual(Array(4).fill('mammoViewSplit'));
+        expect(Object.fromEntries(result.map((d) => [d.description, d.uids]))).toEqual({
+            RCC: uidsOf([series[0]]),
+            LCC: uidsOf([series[1]]),
+            RMLO: uidsOf([series[2]]),
+            LMLO: uidsOf([series[3]]),
+        });
+    });
+});

package/dist/esm/displayset/seriesContext.test.d.ts

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

package/dist/esm/displayset/seriesContext.test.js

@@ -0,0 +1,238 @@
+import { createDisplaySetFromGroup } from './createDisplaySetFromGroup.js';
+import { groupInstancesBySplitRules, orderInstancesForRule, } from './groupInstancesBySplitRules.js';
+import { withInstances } from './displaySetContext.js';
+import { createDisplaySetSplitRules } from './displaySetRules.js';
+import { planeGeometry, timeClusters } from './seriesFunctions.js';
+const AXIAL = [1, 0, 0, 0, 1, 0];
+const slice = (id, z, overrides = {}) => ({
+    SOPInstanceUID: id,
+    SeriesInstanceUID: 'series-1',
+    Modality: 'CT',
+    ImageOrientationPatient: AXIAL,
+    ImagePositionPatient: [0, 0, z],
+    ...overrides,
+});
+const CT_SOP_CLASS = '1.2.840.10008.5.1.4.1.1.2';
+describe('the display set context over a split', () => {
+    const options = {
+        context: {
+            mixesIrregular: 'planeGeometry.regularCount >= 3 && planeGeometry.irregularCount > 0 && planeGeometry.complete',
+        },
+    };
+    const ruleSet = {
+        regularVolume: {
+            priority: -2,
+            matches: {
+                isImage: true,
+                Modality: ['CT', 'MR', 'PT', 'NM'],
+                mixesIrregular: true,
+                sliceIndex: { notNull: true },
+            },
+            groupBy: ['SeriesInstanceUID'],
+            sortBy: ['sliceDistance'],
+            attributes: {
+                SeriesDescription: {
+                    template: '{SeriesDescription} ({sliceSpacing} mm)',
+                },
+            },
+        },
+        irregularImages: {
+            priority: -1,
+            matches: {
+                isImage: true,
+                Modality: ['CT', 'MR', 'PT', 'NM'],
+                mixesIrregular: true,
+                sliceIndex: null,
+            },
+            groupBy: ['SeriesInstanceUID'],
+            attributes: {
+                SeriesDescription: { template: '{SeriesDescription} (other images)' },
+            },
+        },
+    };
+    const series = [
+        slice('r3', 7.5),
+        slice('r0', 0),
+        slice('low', -1.3),
+        slice('r1', 2.5),
+        slice('r4', 10),
+        slice('r2', 5),
+        slice('mid', 3.7),
+    ].map((instance) => ({
+        ...instance,
+        SOPClassUID: CT_SOP_CLASS,
+        Rows: 512,
+        SeriesDescription: 'AX',
+    }));
+    it('splits the lattice from the other images, and labels each display set from its own instances', () => {
+        const groups = groupInstancesBySplitRules(series, createDisplaySetSplitRules(ruleSet, options));
+        expect(groups.map((group) => [
+            group.matchedRule.id,
+            group.instances.map((i) => i.SOPInstanceUID),
+            createDisplaySetFromGroup(group)
+                .SeriesDescription,
+        ])).toEqual([
+            ['regularVolume', ['r0', 'r1', 'r2', 'r3', 'r4'], 'AX (2.5 mm)'],
+            ['irregularImages', ['low', 'mid'], 'AX (other images)'],
+        ]);
+    });
+});
+describe('series functions in the series and in one display set', () => {
+    const series = [0, 1, 2, 3, 4, 5, 6, 7].map((z) => slice(`z${z}`, z, { EchoNumbers: z % 2 ? 2 : 1 }));
+    const rules = createDisplaySetSplitRules({
+        echoes: {
+            priority: 1,
+            matches: { sliceSpacing: 1 },
+            groupBy: ['SeriesInstanceUID', 'EchoNumbers'],
+            sortBy: ['displaySet.sliceDistance'],
+            attributes: {
+                spacing: 'displaySet.sliceSpacing',
+                firstDistance: {
+                    expression: 'displaySet.instances.min(displaySet.sliceDistance)',
+                },
+                seriesCount: 'seriesInstanceCount',
+                seriesSpacing: 'sliceSpacing',
+                seriesFirstDistance: {
+                    expression: 'displaySet.instances.min(sliceDistance)',
+                },
+            },
+        },
+    });
+    it('tests the lattice of the series in matches, and measures each display set in sortBy and attributes', () => {
+        const groups = groupInstancesBySplitRules([...series].reverse(), rules);
+        expect(groups.map((group) => {
+            const displaySet = createDisplaySetFromGroup(group);
+            return [
+                group.instances.map((i) => i.SOPInstanceUID),
+                displaySet.spacing,
+                displaySet.firstDistance,
+                displaySet.seriesCount,
+                displaySet.seriesSpacing,
+                displaySet.seriesFirstDistance,
+            ];
+        })).toEqual([
+            [['z0', 'z2', 'z4', 'z6'], 2, 0, 8, 1, 0],
+            [['z1', 'z3', 'z5', 'z7'], 2, 0, 8, 1, 1],
+        ]);
+    });
+    it('computes a series value one time for each split, and not one time for each display set', () => {
+        const compute = jest.fn((instances) => ({
+            count: instances.length,
+        }));
+        const rules = createDisplaySetSplitRules({
+            pairs: {
+                priority: 1,
+                groupBy: ['pair'],
+                sortBy: ['seriesCount', 'InstanceNumber'],
+                attributes: { count: { expression: 'summary.count' } },
+            },
+        }, {
+            context: {
+                pair: { attribute: 'Pair' },
+                summary: { function: 'summarize' },
+                seriesCount: 'summary.count',
+            },
+            seriesFunctions: {
+                summarize: { compute, fields: { count: 'series' } },
+            },
+        });
+        const groups = groupInstancesBySplitRules([0, 1, 2, 3, 4, 5].map((n) => slice(`z${n}`, n, { InstanceNumber: n, Pair: Math.floor(n / 2) })), rules);
+        const counts = groups.map((group) => createDisplaySetFromGroup(group)
+            .count);
+        expect(counts).toEqual([6, 6, 6]);
+        expect(compute).toHaveBeenCalledTimes(1);
+    });
+});
+describe('a sort after the series gets new instances', () => {
+    it('does not count an instance twice when the host naturalizes it again', () => {
+        const rules = createDisplaySetSplitRules({ all: { priority: 1 } });
+        const [group] = groupInstancesBySplitRules([slice('z0', 0), slice('z2', 2)], rules);
+        const copies = group.instances.map((instance) => ({ ...instance }));
+        expect(withInstances(group.series, copies)).toBe(group.series);
+    });
+    it('computes the context values again, so the new instance takes its place', () => {
+        const rules = createDisplaySetSplitRules({
+            bySlice: { priority: 1, sortBy: ['sliceDistance'] },
+        });
+        const [group] = groupInstancesBySplitRules([slice('z4', 4), slice('z0', 0), slice('z2', 2)], rules);
+        const reordered = orderInstancesForRule([...group.instances, slice('z1', 1)], group.matchedRule, { series: group.series });
+        expect(reordered.map((instance) => instance.ImagePositionPatient[2])).toEqual([0, 1, 2, 4]);
+    });
+});
+describe('planeGeometry', () => {
+    const series = [
+        slice('r0', 0),
+        slice('r1', 2.5),
+        slice('r2', 5),
+        slice('r3', 7.5),
+        slice('r4', 10),
+        slice('low', -1.3),
+        slice('mid', 3.7),
+        slice('sag', 0, { ImageOrientationPatient: [0, 1, 0, 0, 0, 1] }),
+    ];
+    const geometry = (instances) => planeGeometry(instances, { args: {} });
+    it('finds the regular lattice, and leaves the other instances off it', () => {
+        const result = geometry(series);
+        expect(result.spacing).toBe(2.5);
+        expect(result.normal).toEqual([0, 0, 1]);
+        expect(result.origin).toEqual([0, 0, 0]);
+        expect(result.index).toEqual({ r0: 0, r1: 1, r2: 2, r3: 3, r4: 4 });
+        expect([
+            result.regularCount,
+            result.irregularCount,
+            result.positions,
+            result.complete,
+            result.duplicates,
+        ]).toEqual([5, 3, 5, true, false]);
+        expect(result.distance.low).toBeCloseTo(-1.3);
+    });
+    it('gives the same result for any order of the instances', () => {
+        expect(geometry([...series].reverse())).toEqual(geometry(series));
+    });
+    it('reads two echoes of one slice as one position, and not as a gap of 0', () => {
+        const echoes = [0, 2, 4].flatMap((z) => [
+            slice(`a${z}`, z),
+            slice(`b${z}`, z + 0.002),
+        ]);
+        const result = geometry(echoes);
+        expect(result.spacing).toBe(2);
+        expect([result.regularCount, result.positions, result.duplicates]).toEqual([
+            6,
+            3,
+            true,
+        ]);
+    });
+    it('finds the lattice of a long series with work that grows about linearly', () => {
+        const count = 5000;
+        const long = Array.from({ length: count }, (_, i) => slice(`s${i}`, i % 97 ? i * 1.25 : i * 1.25 + 0.4));
+        const round = jest.spyOn(Math, 'round');
+        try {
+            const result = geometry(long);
+            expect([result.spacing, result.regularCount]).toEqual([1.25, 4948]);
+            expect(round.mock.calls.length).toBeLessThan(100 * count);
+        }
+        finally {
+            round.mockRestore();
+        }
+    });
+});
+describe('timeClusters', () => {
+    const us = (id, AcquisitionTime) => ({
+        SOPInstanceUID: id,
+        AcquisitionDate: '20260101',
+        AcquisitionTime,
+    });
+    it('starts a cluster after a gap of more than maxGap seconds', () => {
+        const result = timeClusters([
+            us('a', '100000'),
+            us('b', '100004'),
+            us('c', '100100'),
+            us('d', '100103.5'),
+            { SOPInstanceUID: 'untimed' },
+        ], { args: { maxGap: 10 } });
+        const startOf = (id) => result.start[id] - result.first;
+        expect(result.clusters).toBe(2);
+        expect(result.untimedCount).toBe(1);
+        expect(['a', 'b', 'c', 'd'].map(startOf)).toEqual([0, 0, 60, 60]);
+    });
+});

package/dist/esm/displayset/seriesFunctions.d.ts

@@ -0,0 +1,29 @@
+import type { NaturalizedInstance, SeriesFunction, SeriesFunctionDefinition } from './types.js';
+export declare function instanceKey(instance: NaturalizedInstance): string | undefined;
+export type PlaneGeometry = {
+    normal?: number[];
+    origin?: number[];
+    spacing?: number;
+    regularCount: number;
+    irregularCount: number;
+    positions: number;
+    complete: boolean;
+    duplicates: boolean;
+    distance: Record<string, number>;
+    index: Record<string, number>;
+};
+export declare const planeGeometry: SeriesFunction;
+export declare function dicomDateTimeToSeconds(date: unknown, time: unknown): number | undefined;
+export type TimeClusters = {
+    time: Record<string, number>;
+    start: Record<string, number>;
+    first?: number;
+    clusters: number;
+    untimedCount: number;
+};
+export declare const timeClusters: SeriesFunction;
+export type RevisionChains = {
+    active: Record<string, string>;
+};
+export declare const revisionChains: SeriesFunction;
+export declare const BUILT_IN_SERIES_FUNCTIONS: Readonly<Record<string, SeriesFunctionDefinition>>;