@cornerstonejs/metadata 5.13.2 → 5.15.0

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

@@ -1,16 +1,15 @@
 import type { IDisplaySet } from './IDisplaySet.js';
-import type { NaturalizedInstance, ViewportTypeHint } from './types.js';
+import type { NaturalizedInstance } from './types.js';
 export type BaseDisplaySetOptions = {
     displaySetId: string;
-    viewportTypes?: readonly ViewportTypeHint[];
     instances?: NaturalizedInstance[];
     imageIds?: Iterable<string>;
     underlyingImageIds?: Iterable<string>;
+    isDisplayable?: boolean;
 };
 export declare class BaseDisplaySet implements IDisplaySet {
     displaySetId: string;
-    viewportTypes: readonly ViewportTypeHint[];
-    preferredViewportType: ViewportTypeHint;
+    isDisplayable: boolean;
     readonly instances: readonly NaturalizedInstance[];
     readonly imageIds: readonly string[];
     readonly underlyingImageIds: readonly string[];

package/dist/esm/displayset/BaseDisplaySet.js

@@ -1,11 +1,7 @@
-import { getPreferredViewportType } from './viewportTypes.js';
 export class BaseDisplaySet {
     constructor(options) {
         this.displaySetId = options.displaySetId;
-        this.viewportTypes = options.viewportTypes?.length
-            ? [...options.viewportTypes]
-            : ['stack'];
-        this.preferredViewportType = getPreferredViewportType(this.viewportTypes);
+        this.isDisplayable = options.isDisplayable ?? true;
         this.instances = [...(options.instances ?? [])];
         this.imageIds = [...(options.imageIds ?? [])];
         this.underlyingImageIds = [...(options.underlyingImageIds ?? [])];

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

@@ -1,13 +1,19 @@
-import type { NaturalizedInstance, ViewportTypeHint } from './types.js';
+import type { NaturalizedInstance } from './types.js';
 export interface IDisplaySet {
     displaySetId: string;
-    viewportTypes: readonly ViewportTypeHint[];
-    preferredViewportType: ViewportTypeHint;
+    splitKey?: string;
+    splitRuleId?: string;
+    splitGroupId?: string;
+    handler?: string;
+    viewportTypes?: readonly string[];
+    isDisplayable: boolean;
     instances: readonly NaturalizedInstance[];
     imageIds: readonly string[];
     underlyingImageIds: readonly string[];
     isMultiFrame?: boolean;
     isClip?: boolean;
+    isReconstructable?: boolean;
     numImageFrames?: number;
     splitNumber?: number;
+    sopClassUids?: readonly string[];
 }

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

@@ -1,5 +1,5 @@
 import { BaseDisplaySet, type BaseDisplaySetOptions } from './BaseDisplaySet.js';
-import type { NaturalizedInstance, ViewportTypeHint } from './types.js';
+import type { NaturalizedInstance } from './types.js';
 export type ImageStackDisplaySetOptions = Omit<BaseDisplaySetOptions, 'imageIds' | 'underlyingImageIds'> & {
     instances?: NaturalizedInstance[];
     imageIds?: Iterable<string>;
@@ -10,11 +10,9 @@ export declare class ImageStackDisplaySet extends BaseDisplaySet {
     constructor(options: ImageStackDisplaySetOptions);
     static fromInstances(instances: NaturalizedInstance[], options?: {
         displaySetId?: string;
-        viewportTypes?: readonly ViewportTypeHint[];
         imageIds?: Iterable<string>;
     }): ImageStackDisplaySet;
     static fromImageIds(imageIds: string[], getNaturalizedInstance: (imageId: string) => NaturalizedInstance | undefined, options?: {
         displaySetId?: string;
-        viewportTypes?: readonly ViewportTypeHint[];
     }): ImageStackDisplaySet;
 }

package/dist/esm/displayset/ImageStackDisplaySet.js

@@ -40,7 +40,6 @@ export class ImageStackDisplaySet extends BaseDisplaySet {
             `display-set-${instances[0]?.imageId ?? 'unknown'}`;
         return new ImageStackDisplaySet({
             displaySetId,
-            viewportTypes: options?.viewportTypes ?? ['stack', 'volume', 'volume3d'],
             instances,
             imageIds: options?.imageIds,
         });

package/dist/esm/displayset/__fixtures__/scenarioInstances.d.ts

@@ -0,0 +1,12 @@
+import type { NaturalizedInstance } from '../types.js';
+export declare function geDiffusionSeries(): NaturalizedInstance[];
+export declare function t2SeriesWithZeroBValue(): NaturalizedInstance[];
+export declare function ctLocalizers(seriesUid: string): NaturalizedInstance[];
+export declare function ctSeriesWithScouts(): NaturalizedInstance[];
+export declare function usSweepsAndClips(): {
+    instances: NaturalizedInstance[];
+    sweeps: NaturalizedInstance[][];
+    clips: NaturalizedInstance[];
+};
+export declare function fourViewMammogram(): NaturalizedInstance[];
+export declare function uidsOf(instances: readonly NaturalizedInstance[]): unknown[];

package/dist/esm/displayset/__fixtures__/scenarioInstances.js

@@ -0,0 +1,210 @@
+const SOP_CLASS = {
+    CT: '1.2.840.10008.5.1.4.1.1.2',
+    MR: '1.2.840.10008.5.1.4.1.1.4',
+    US: '1.2.840.10008.5.1.4.1.1.6.1',
+    USMultiFrame: '1.2.840.10008.5.1.4.1.1.3.1',
+    MGForPresentation: '1.2.840.10008.5.1.4.1.1.1.2',
+};
+const EXPLICIT_VR_LITTLE_ENDIAN = '1.2.840.10008.1.2.1';
+const JPEG_BASELINE = '1.2.840.10008.1.2.4.50';
+const STUDY_UID = '1.2.826.0.1.3680043.8.498.10274110315161201';
+const AXIAL = [1, 0, 0, 0, 1, 0];
+const CORONAL = [1, 0, 0, 0, 0, -1];
+const SAGITTAL = [0, 1, 0, 0, 0, -1];
+let uidCounter = 0;
+function uid(seriesUid) {
+    uidCounter += 1;
+    return `${seriesUid}.${uidCounter}`;
+}
+function common(seriesUid, fields) {
+    return {
+        StudyInstanceUID: STUDY_UID,
+        SeriesInstanceUID: seriesUid,
+        SOPInstanceUID: uid(seriesUid),
+        TransferSyntaxUID: EXPLICIT_VR_LITTLE_ENDIAN,
+        ...fields,
+    };
+}
+export function geDiffusionSeries() {
+    const seriesUid = '1.2.840.113619.2.312.4120.14306937.11001';
+    const instances = [];
+    for (let position = 0; position < 32; position++) {
+        const z = -60 + position * 4;
+        for (const bValue of ['0', '1000']) {
+            instances.push(common(seriesUid, {
+                SOPClassUID: SOP_CLASS.MR,
+                Modality: 'MR',
+                Manufacturer: 'GE MEDICAL SYSTEMS',
+                SeriesDescription: 'DWI ASSET',
+                SeriesNumber: 5,
+                InstanceNumber: instances.length + 1,
+                ImageType: ['ORIGINAL', 'PRIMARY', 'AXIAL'],
+                ScanningSequence: 'EP',
+                SequenceVariant: ['SK', 'SS'],
+                Rows: 256,
+                Columns: 256,
+                PixelSpacing: [0.9375, 0.9375],
+                SliceThickness: 4,
+                ImageOrientationPatient: AXIAL,
+                ImagePositionPatient: [-120, -128.3, z],
+                SliceLocation: z,
+                EchoTime: 81.4,
+                RepetitionTime: 6000,
+                '00431039': [bValue, '8', '0', '0'],
+            }));
+        }
+    }
+    return instances;
+}
+export function t2SeriesWithZeroBValue() {
+    const seriesUid = '1.3.12.2.1107.5.2.43.66012.2026031510214587340112';
+    return Array.from({ length: 24 }, (_, index) => {
+        const z = -46 + index * 4;
+        return common(seriesUid, {
+            SOPClassUID: SOP_CLASS.MR,
+            Modality: 'MR',
+            SeriesDescription: 'AX T2 TSE',
+            SeriesNumber: 3,
+            InstanceNumber: index + 1,
+            ImageType: ['ORIGINAL', 'PRIMARY', 'M', 'NORM', 'DIS2D'],
+            ScanningSequence: 'SE',
+            Rows: 320,
+            Columns: 320,
+            PixelSpacing: [0.6875, 0.6875],
+            SliceThickness: 4,
+            ImageOrientationPatient: AXIAL,
+            ImagePositionPatient: [-110, -125.5, z],
+            SliceLocation: z,
+            DiffusionBValue: 0,
+        });
+    });
+}
+function ctImage(seriesUid, fields) {
+    return common(seriesUid, {
+        SOPClassUID: SOP_CLASS.CT,
+        Modality: 'CT',
+        SeriesDescription: 'CHEST W/O',
+        SeriesNumber: 2,
+        Rows: 512,
+        Columns: 512,
+        KVP: 120,
+        ...fields,
+    });
+}
+export function ctLocalizers(seriesUid) {
+    return [CORONAL, SAGITTAL].map((orientation, index) => ctImage(seriesUid, {
+        InstanceNumber: index + 1,
+        ImageType: ['ORIGINAL', 'PRIMARY', 'LOCALIZER'],
+        PixelSpacing: [0.976, 0.7],
+        ImageOrientationPatient: orientation,
+        ImagePositionPatient: [-250, 0, 120],
+    }));
+}
+export function ctSeriesWithScouts() {
+    const seriesUid = '1.2.392.200036.9116.2.6.1.48.1214833767.1612345678.112233';
+    const axial = Array.from({ length: 40 }, (_, index) => {
+        const z = 100 - index * 5;
+        return ctImage(seriesUid, {
+            InstanceNumber: index + 3,
+            ImageType: ['ORIGINAL', 'PRIMARY', 'AXIAL'],
+            PixelSpacing: [0.703, 0.703],
+            SliceThickness: 5,
+            ImageOrientationPatient: AXIAL,
+            ImagePositionPatient: [-180, -180, z],
+            SliceLocation: z,
+        });
+    });
+    return [...ctLocalizers(seriesUid), ...axial];
+}
+function usImage(seriesUid, time, fields) {
+    return common(seriesUid, {
+        Modality: 'US',
+        SeriesDescription: 'US ABDOMEN',
+        SeriesNumber: 1,
+        Rows: 600,
+        Columns: 800,
+        SamplesPerPixel: 3,
+        PhotometricInterpretation: 'YBR_FULL_422',
+        TransferSyntaxUID: JPEG_BASELINE,
+        AcquisitionDateTime: `20260315${time}.000000`,
+        SequenceOfUltrasoundRegions: [
+            {
+                RegionSpatialFormat: 1,
+                RegionDataType: 1,
+                PhysicalUnitsXDirection: 3,
+                PhysicalUnitsYDirection: 3,
+                PhysicalDeltaX: 0.0213,
+                PhysicalDeltaY: 0.0213,
+            },
+        ],
+        ...fields,
+    });
+}
+export function usSweepsAndClips() {
+    const seriesUid = '1.2.840.113663.1500.1.460388269.2.1.20260315.101500.123';
+    let instanceNumber = 0;
+    const still = (time) => usImage(seriesUid, time, {
+        SOPClassUID: SOP_CLASS.US,
+        InstanceNumber: ++instanceNumber,
+        ImageType: ['ORIGINAL', 'PRIMARY', 'ABDOMINAL', '0001'],
+    });
+    const clip = (time) => usImage(seriesUid, time, {
+        SOPClassUID: SOP_CLASS.USMultiFrame,
+        InstanceNumber: ++instanceNumber,
+        ImageType: ['ORIGINAL', 'PRIMARY', 'ABDOMINAL', '0011'],
+        NumberOfFrames: 120,
+        FrameTime: 33.33,
+        CineRate: 30,
+        FrameIncrementPointer: 0x00181063,
+    });
+    const sweep1 = ['101500', '101502', '101504', '101506', '101508'].map(still);
+    const clip1 = clip('101540');
+    const sweep2 = ['101630', '101632', '101634', '101636'].map(still);
+    const clip2 = clip('101720');
+    return {
+        instances: [...sweep1, clip1, ...sweep2, clip2],
+        sweeps: [sweep1, sweep2],
+        clips: [clip1, clip2],
+    };
+}
+const MAMMO_VIEW_CODES = {
+    CC: {
+        CodeValue: 'R-10242',
+        CodingSchemeDesignator: 'SRT',
+        CodeMeaning: 'cranio-caudal',
+    },
+    MLO: {
+        CodeValue: 'R-10226',
+        CodingSchemeDesignator: 'SRT',
+        CodeMeaning: 'medio-lateral oblique',
+    },
+};
+export function fourViewMammogram() {
+    const seriesUid = '1.2.840.113681.2863050711.1599.3770412345.71';
+    const views = [
+        ['R', 'CC', ['P', 'L']],
+        ['L', 'CC', ['A', 'R']],
+        ['R', 'MLO', ['P', 'FL']],
+        ['L', 'MLO', ['A', 'FR']],
+    ];
+    return views.map(([laterality, view, orientation], index) => common(seriesUid, {
+        SOPClassUID: SOP_CLASS.MGForPresentation,
+        Modality: 'MG',
+        SeriesDescription: 'Screening Mammography',
+        SeriesNumber: 71,
+        InstanceNumber: index + 1,
+        ImageType: ['ORIGINAL', 'PRIMARY'],
+        PresentationIntentType: 'FOR PRESENTATION',
+        Rows: 4096,
+        Columns: 3328,
+        ImagerPixelSpacing: [0.07, 0.07],
+        ImageLaterality: laterality,
+        PatientOrientation: orientation,
+        ViewCodeSequence: [
+            { ...MAMMO_VIEW_CODES[view], ViewModifierCodeSequence: [] },
+        ],
+    }));
+}
+export function uidsOf(instances) {
+    return instances.map((instance) => instance.SOPInstanceUID);
+}

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

@@ -0,0 +1,3 @@
+import type { CreateDisplaySetSplitRulesOptions, DisplaySetRules } from './displaySetRulesTypes.js';
+import type { SplitRuleSet } from './types.js';
+export declare function compileDisplaySetSplitRules(rules: DisplaySetRules, options?: CreateDisplaySetSplitRulesOptions): SplitRuleSet;

package/dist/esm/displayset/compileSplitRules.js

@@ -0,0 +1,197 @@
+import { asArrayFirst, toFiniteFirst } from '@cornerstonejs/utils';
+import { at, compileConditionAt, createSite, hasNoValue, invalidAt, isUnsafeKey, matchForm, parseTemplate, readOwn, safeFunctionCompilers, unrecognized, } from '../safeFunctions/index.js';
+import { ContextProgram, displaySetContextFor, isFixedValue, } from './displaySetContext.js';
+import { chainComparators } from './groupInstancesBySplitRules.js';
+import { getMetadataContextProgram } from './metadataContext.js';
+import { validateSplitRuleSetEntry } from './splitRuleSet.js';
+import { splitRuleSchema } from './splitRuleSchema.js';
+const DEFINITION = 'display set rules';
+function instanceReader(compile, name, site, place, field) {
+    const read = compile.program.readerAt(compile.layer, name, site, {
+        field,
+        place,
+    });
+    const { program } = compile;
+    return (instance, context) => read(program.runtimeFrom(context, instance), instance);
+}
+function compileName(value, site, compile) {
+    if (typeof value === 'function') {
+        return value;
+    }
+    if (typeof value !== 'string') {
+        return unrecognized(splitRuleSchema.name, value, site);
+    }
+    return instanceReader(compile, value, site, 'groupBy');
+}
+function compareSortValues(a, b) {
+    const x = toFiniteFirst(a);
+    const y = toFiniteFirst(b);
+    if (x !== undefined && y !== undefined) {
+        return x - y;
+    }
+    if (hasNoValue(a) || hasNoValue(b)) {
+        return Number(hasNoValue(a)) - Number(hasNoValue(b));
+    }
+    const aText = String(asArrayFirst(a));
+    const bText = String(asArrayFirst(b));
+    return aText < bText ? -1 : aText > bText ? 1 : 0;
+}
+function compileSortKey(value, site, compile) {
+    if (typeof value === 'function') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const read = compile.program.readerAt(compile.layer, value, site, {
+            place: 'sortBy',
+        });
+        const { program } = compile;
+        return (a, b, context) => {
+            const runtime = program.runtimeFrom(context, [a, b]);
+            return compareSortValues(read(runtime, a), read(runtime, b));
+        };
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return unrecognized(splitRuleSchema.sortKey, value, site);
+    }
+    matchForm(splitRuleSchema.sortKey, value, site);
+    const name = value.sortFunction;
+    const sortFunction = readOwn(compile.sortFunctions, name);
+    if (typeof sortFunction !== 'function') {
+        return invalidAt(at(site, 'sortFunction'), `unknown sort function "${name}"; known: ${Object.keys(compile.sortFunctions).join(', ') || '(none)'}`);
+    }
+    return sortFunction;
+}
+function compileAttributeValue(value, site, compile) {
+    const { program, layer } = compile;
+    if (typeof value === 'function') {
+        const scope = { key: `#attribute:${site.path}`, deps: new Map(), layer };
+        return (runtime, instances, extras) => value(instances, runtime.env(scope, instances[0], extras));
+    }
+    if (isFixedValue(value, false)) {
+        return () => value;
+    }
+    if (typeof value === 'string') {
+        const read = program.readerAt(layer, value, site, { place: 'attributes' });
+        return (runtime, instances, extras) => read(runtime, instances[0], extras);
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return unrecognized(splitRuleSchema.attributeValue, value, site);
+    }
+    const [form] = matchForm(splitRuleSchema.attributeValue, value, site);
+    const fields = value;
+    if (form === 'expression') {
+        return program.attributeExpression(layer, fields.expression, at(site, 'expression'));
+    }
+    const templateSite = at(site, 'template');
+    const parts = parseTemplate(fields.template, templateSite).map((segment) => 'literal' in segment
+        ? () => segment.literal
+        : program.readerAt(layer, segment.name, templateSite, {
+            field: segment.field,
+            place: 'attributes',
+        }));
+    return (runtime, instances, extras) => parts
+        .map((part) => {
+        const text = part(runtime, instances[0], extras);
+        return hasNoValue(text) ? '' : String(text);
+    })
+        .join('');
+}
+function compileAttributes(attributes, site, compile) {
+    if (typeof attributes === 'function') {
+        return attributes;
+    }
+    if (!attributes ||
+        typeof attributes !== 'object' ||
+        Array.isArray(attributes)) {
+        return invalidAt(site, 'expected an object of attribute values, keyed by attribute name, or a function (attributes, options) => Record<string, unknown>', attributes);
+    }
+    const readers = Object.entries(attributes).map(([key, value]) => {
+        const valueSite = at(site, key);
+        if (isUnsafeKey(key)) {
+            invalidAt(valueSite, `the key "${key}" is not allowed`);
+        }
+        return [key, compileAttributeValue(value, valueSite, compile)];
+    });
+    const { program } = compile;
+    return (engine, options) => {
+        const instances = options.instances ?? [];
+        const runtime = program.runtimeFrom({
+            series: options.series,
+            displaySet: displaySetContextFor(options.series, instances),
+        }, instances);
+        const extras = {
+            splitNumber: options.splitNumber,
+            sopClassUids: engine?.sopClassUids,
+        };
+        const result = {};
+        for (const [key, read] of readers) {
+            result[key] = instances.length
+                ? read(runtime, instances, extras)
+                : undefined;
+        }
+        return result;
+    };
+}
+function compileList(value, site, compileEntry) {
+    if (!Array.isArray(value)) {
+        return invalidAt(site, 'expected an array', value);
+    }
+    return value.map((entry, index) => compileEntry(entry, at(site, index)));
+}
+function compileRule(id, rule, site, program, sortFunctions) {
+    matchForm(splitRuleSchema.rule, rule, site);
+    const layer = program.layer(id, rule.context, at(site, 'context'));
+    const compile = { site, program, layer, sortFunctions };
+    const compiled = { id, series: program.seriesHook };
+    if (rule.groupId !== undefined) {
+        compiled.groupId = rule.groupId;
+    }
+    if (rule.viewportTypes !== undefined) {
+        compiled.viewportTypes = rule.viewportTypes;
+    }
+    if (rule.handler !== undefined) {
+        compiled.handler = rule.handler;
+    }
+    if (rule.matches !== undefined) {
+        const matchesSite = {
+            ...at(site, 'matches'),
+            readName: (name, nameSite, field) => instanceReader(compile, name, nameSite, 'matches', field),
+        };
+        compiled.matches = compileConditionAt(rule.matches, matchesSite);
+    }
+    if (rule.groupBy !== undefined) {
+        const groupBy = compileList(rule.groupBy, at(site, 'groupBy'), (entry, s) => compileName(entry, s, compile));
+        if (groupBy.length) {
+            compiled.groupBy = groupBy;
+        }
+    }
+    if (rule.sortBy !== undefined) {
+        const comparators = compileList(rule.sortBy, at(site, 'sortBy'), (entry, s) => compileSortKey(entry, s, compile));
+        if (comparators.length) {
+            compiled.compareInstances = chainComparators(comparators);
+        }
+    }
+    if (rule.attributes !== undefined) {
+        compiled.customAttributes = compileAttributes(rule.attributes, at(site, 'attributes'), compile);
+    }
+    return compiled;
+}
+export function compileDisplaySetSplitRules(rules, options = {}) {
+    if (!rules || typeof rules !== 'object' || Array.isArray(rules)) {
+        throw new Error(`Invalid ${DEFINITION}: the rules must be an object keyed by rule id: ${JSON.stringify(rules)}`);
+    }
+    const program = getMetadataContextProgram(options.context, {
+        seriesFunctions: options.seriesFunctions,
+        deniedNames: options.deniedNames,
+        definition: DEFINITION,
+    });
+    const sortFunctions = options.sortFunctions ?? {};
+    const compiledSet = {};
+    for (const [id, rule] of Object.entries(rules)) {
+        validateSplitRuleSetEntry(id, rule);
+        const site = createSite({ definition: DEFINITION, path: `rule '${id}'` }, splitRuleSchema, safeFunctionCompilers);
+        const { id: _id, ...compiledRule } = compileRule(id, rule, site, program, sortFunctions);
+        compiledSet[id] = { ...compiledRule, priority: rule.priority };
+    }
+    return compiledSet;
+}

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

@@ -0,0 +1,3 @@
+import type { SplitRuleSet } from './types.js';
+export declare const compiledDisplaySetRules: SplitRuleSet;
+export declare const defaultDisplaySetSplitRules: SplitRuleSet;

package/dist/esm/displayset/compiledDisplaySetRules.js

@@ -0,0 +1,3 @@
+import { createDisplaySetSplitRules, displaySetRules } from './displaySetRules.js';
+export const compiledDisplaySetRules = createDisplaySetSplitRules(displaySetRules);
+export const defaultDisplaySetSplitRules = compiledDisplaySetRules;

package/dist/esm/displayset/createDisplaySetFromGroup.js

@@ -1,14 +1,17 @@
 import { BaseDisplaySet } from './BaseDisplaySet.js';
 import { ImageStackDisplaySet } from './ImageStackDisplaySet.js';
-import { isEcgInstance } from './isEcgInstance.js';
-import { isVideoInstance } from './isVideoInstance.js';
-import { isWsiInstance } from './isWsiInstance.js';
-import { getPreferredViewportType, getViewportTypesForGroup, } from './viewportTypes.js';
+import { isUnsafeKey } from '../safeFunctions/schema.js';
+import { isReconstructableInstances } from './isReconstructableInstances.js';
 const RESERVED_ATTRIBUTE_KEYS = new Set([
     'imageIds',
     'underlyingImageIds',
     'instances',
     'displaySetId',
+    'splitKey',
+    'splitRuleId',
+    'splitGroupId',
+    'handler',
+    'isDisplayable',
 ]);
 function isAssignable(target, key) {
     let obj = target;
@@ -24,36 +27,38 @@ function isAssignable(target, key) {
     }
     return true;
 }
-function applyCustomAttributes(displaySet, group, viewportTypes, options) {
+function runCustomAttributes(group, options) {
     const { instances, matchedRule } = group;
     const first = instances[0];
     if (!matchedRule.customAttributes || !first) {
-        return;
+        return undefined;
     }
     const sopClassUids = [
         ...new Set(instances.map((i) => i.SOPClassUID).filter(Boolean)),
     ];
     const isMultiFrame = Number(first.NumberOfFrames) > 1;
-    const attributes = matchedRule.customAttributes({ instance: first, isMultiFrame, sopClassUids, viewportTypes }, {
+    return (matchedRule.customAttributes({ instance: first, isMultiFrame, sopClassUids }, {
         instances,
         splitNumber: options.splitNumber,
         descriptionName: options.descriptionName,
-    });
+        series: group.series,
+    }) ?? undefined);
+}
+function applyCustomAttributes(displaySet, attributes) {
     if (!attributes) {
         return;
     }
     for (const [key, value] of Object.entries(attributes)) {
-        if (RESERVED_ATTRIBUTE_KEYS.has(key)) {
+        if (RESERVED_ATTRIBUTE_KEYS.has(key) || isUnsafeKey(key)) {
             continue;
         }
         if (isAssignable(displaySet, key)) {
             displaySet[key] = value;
         }
     }
-    displaySet.preferredViewportType = getPreferredViewportType(displaySet.viewportTypes);
 }
 export function createDisplaySetFromGroup(group, options = {}) {
-    const viewportTypes = getViewportTypesForGroup(group);
+    const attributes = runCustomAttributes(group, options);
     const { instances } = group;
     const baseDisplaySetId = instances[0]?.SeriesInstanceUID ??
         `display-set-${instances[0]?.imageId ?? 'unknown'}`;
@@ -62,25 +67,55 @@ export function createDisplaySetFromGroup(group, options = {}) {
             ? `${baseDisplaySetId}:${options.splitNumber}`
             : baseDisplaySetId);
     const first = instances[0];
+    const { handler } = group.matchedRule;
+    const underlyingImageIds = instances
+        .map((i) => i.imageId)
+        .filter(Boolean);
     let displaySet;
-    if (first &&
-        (isVideoInstance(first) || isEcgInstance(first) || isWsiInstance(first))) {
-        const imageIds = instances.map((i) => i.imageId).filter(Boolean);
+    if (handler === 'unsupported') {
+        displaySet = new BaseDisplaySet({
+            displaySetId,
+            instances,
+            imageIds: [],
+            underlyingImageIds,
+            isDisplayable: false,
+        });
+    }
+    else if (handler !== undefined && handler !== 'image') {
         displaySet = new BaseDisplaySet({
             displaySetId,
-            viewportTypes,
             instances,
-            imageIds: options.imageIds ?? imageIds,
-            underlyingImageIds: imageIds,
+            imageIds: options.imageIds ?? underlyingImageIds,
+            underlyingImageIds,
         });
     }
     else {
         displaySet = ImageStackDisplaySet.fromInstances(instances, {
             displaySetId,
-            viewportTypes,
             imageIds: options.imageIds,
         });
     }
-    applyCustomAttributes(displaySet, group, viewportTypes, options);
+    displaySet.splitKey = group.splitKey;
+    displaySet.splitRuleId = group.matchedRule.id;
+    displaySet.splitGroupId = group.matchedRule.groupId ?? group.matchedRule.id;
+    if (handler !== undefined) {
+        displaySet.handler = handler;
+    }
+    if (group.matchedRule.viewportTypes !== undefined) {
+        displaySet.viewportTypes = [...group.matchedRule.viewportTypes];
+    }
+    displaySet.sopClassUids = [
+        ...new Set(instances.map((i) => i.SOPClassUID).filter(Boolean)),
+    ];
+    if (options.splitNumber !== undefined) {
+        displaySet.splitNumber = options.splitNumber;
+    }
+    displaySet.isMultiFrame ??= Number(first?.NumberOfFrames) > 1;
+    applyCustomAttributes(displaySet, attributes);
+    if ((handler === undefined || handler === 'image') &&
+        typeof displaySet.isReconstructable !== 'boolean') {
+        displaySet.isReconstructable =
+            !displaySet.isClip && isReconstructableInstances(instances);
+    }
     return displaySet;
 }