{displayStudySummary.key && (
@@ -253,6 +262,7 @@ function PanelMeasurementTableTracking({ servicesManager, extensionManager }) {
:`
+ * That allows extracting the DICOM attributes from the designator/value, and
+ * allows for passing around the simple string.
+ * The additional attributes contained in the object include:
+ * * text - this is the coding scheme text display value, and may be language specific
+ * * type - this defines a named type, typically 'site'. Different names can be used
+ * to allow setting different findingSites values in order to define a hierarchy.
+ * * color - used to apply annotation color
+ * It is also possible to define additional attributes here, used by custom
+ * extensions.
+ *
+ * See https://dicom.nema.org/medical/dicom/current/output/html/part16.html
+ * for definitions of SCT and other code values.
+ */
+const codingValues = {
+ id: 'codingValues',
+
+ // Sites
+ 'SCT:69536005': {
+ text: 'Head',
+ type: 'site',
+ },
+ 'SCT:45048000': {
+ text: 'Neck',
+ type: 'site',
+ },
+ 'SCT:818981001': {
+ text: 'Abdomen',
+ type: 'site',
+ },
+ 'SCT:816092008': {
+ text: 'Pelvis',
+ type: 'site',
+ },
+
+ // Findings
+ 'SCT:371861004': {
+ text: 'Mild intimal coronary irregularities',
+ color: 'green',
+ },
+ 'SCT:194983005': {
+ text: 'Aortic insufficiency',
+ color: 'darkred',
+ },
+ 'SCT:399232001': {
+ text: '2-chamber',
+ },
+ 'SCT:103340004': {
+ text: 'SAX',
+ },
+ 'SCT:91134007': {
+ text: 'MV',
+ },
+ 'SCT:122972007': {
+ text: 'PV',
+ },
+
+ // Orientations
+ 'SCT:24422004': {
+ text: 'Axial',
+ color: '#000000',
+ type: 'orientation',
+ },
+ 'SCT:81654009': {
+ text: 'Coronal',
+ color: '#000000',
+ type: 'orientation',
+ },
+ 'SCT:30730003': {
+ text: 'Sagittal',
+ color: '#000000',
+ type: 'orientation',
+ },
+};
+
+export default codingValues;
diff --git a/extensions/test-extension/src/custom-context-menu/contextMenuCodeItem.ts b/extensions/test-extension/src/custom-context-menu/contextMenuCodeItem.ts
new file mode 100644
index 000000000..aa13c27ee
--- /dev/null
+++ b/extensions/test-extension/src/custom-context-menu/contextMenuCodeItem.ts
@@ -0,0 +1,24 @@
+const codeMenuItem = {
+ id: '@ohif/contextMenuAnnotationCode',
+
+ /** Applies the code value setup for this item */
+ transform: function (customizationService) {
+ const { code: codeRef } = this;
+ if (!codeRef) throw new Error(`item ${this} has no code ref`);
+ const codingValues = customizationService.get('codingValues');
+ const code = codingValues[codeRef];
+ return {
+ ...this,
+ codeRef,
+ code: { ref: codeRef, ...code },
+ label: code.text,
+ commands: [
+ {
+ commandName: 'updateMeasurement',
+ },
+ ],
+ };
+ },
+};
+
+export default codeMenuItem;
diff --git a/extensions/test-extension/src/custom-context-menu/findingsContextMenu.ts b/extensions/test-extension/src/custom-context-menu/findingsContextMenu.ts
new file mode 100644
index 000000000..ebdd32eef
--- /dev/null
+++ b/extensions/test-extension/src/custom-context-menu/findingsContextMenu.ts
@@ -0,0 +1,100 @@
+const findingsContextMenu = {
+ id: 'measurementsContextMenu',
+ customizationType: 'ohif.contextMenu',
+ menus: [
+ {
+ id: 'forExistingMeasurement',
+ // selector restricts context menu to when there is nearbyToolData
+ selector: ({ nearbyToolData }) => !!nearbyToolData,
+ items: [
+ {
+ customizationType: 'ohif.contextSubMenu',
+ label: 'Site',
+ actionType: 'ShowSubMenu',
+ subMenu: 'siteSelectionSubMenu',
+ },
+ {
+ customizationType: 'ohif.contextSubMenu',
+ label: 'Finding',
+ actionType: 'ShowSubMenu',
+ subMenu: 'findingSelectionSubMenu',
+ },
+ {
+ // customizationType is implicit here in the configuration setup
+ label: 'Delete Measurement',
+ commands: [
+ {
+ commandName: 'deleteMeasurement',
+ },
+ ],
+ },
+ {
+ label: 'Add Label',
+ commands: [
+ {
+ commandName: 'setMeasurementLabel',
+ },
+ ],
+ },
+
+ // The example below shows how to include a delegating sub-menu,
+ // Only available on the @ohif/hp-extension.mn hanging protocol
+ // To demonstrate, select the 3x1 layout from the protocol menu
+ // and right click on a measurement.
+ {
+ label: 'IncludeSubMenu',
+ selector: ({ protocol }) => protocol?.id === '@ohif/hp-extension.mn',
+ delegating: true,
+ subMenu: 'orientationSelectionSubMenu',
+ },
+ ],
+ },
+
+ {
+ id: 'orientationSelectionSubMenu',
+ selector: ({ nearbyToolData }) => false,
+ items: [
+ {
+ customizationType: '@ohif/contextMenuAnnotationCode',
+ code: 'SCT:24422004',
+ },
+ {
+ customizationType: '@ohif/contextMenuAnnotationCode',
+ code: 'SCT:81654009',
+ },
+ ],
+ },
+
+ {
+ id: 'findingSelectionSubMenu',
+ selector: ({ nearbyToolData }) => false,
+ items: [
+ {
+ customizationType: '@ohif/contextMenuAnnotationCode',
+ code: 'SCT:371861004',
+ },
+ {
+ customizationType: '@ohif/contextMenuAnnotationCode',
+ code: 'SCT:194983005',
+ },
+ ],
+ },
+
+ {
+ id: 'siteSelectionSubMenu',
+ selector: ({ nearbyToolData }) => !!nearbyToolData,
+ items: [
+ {
+ customizationType: '@ohif/contextMenuAnnotationCode',
+ code: 'SCT:69536005',
+ },
+ {
+ customizationType: '@ohif/contextMenuAnnotationCode',
+ code: 'SCT:45048000',
+ },
+ ],
+ },
+ ],
+};
+
+export default findingsContextMenu;
diff --git a/extensions/test-extension/src/custom-context-menu/index.ts b/extensions/test-extension/src/custom-context-menu/index.ts
new file mode 100644
index 000000000..800e31f06
--- /dev/null
+++ b/extensions/test-extension/src/custom-context-menu/index.ts
@@ -0,0 +1,5 @@
+import codingValues from './codingValues';
+import contextMenuCodeItem from './contextMenuCodeItem';
+import findingsContextMenu from './findingsContextMenu';
+
+export { codingValues, contextMenuCodeItem, findingsContextMenu };
diff --git a/extensions/test-extension/src/getCustomizationModule.ts b/extensions/test-extension/src/getCustomizationModule.ts
new file mode 100644
index 000000000..03df13ed0
--- /dev/null
+++ b/extensions/test-extension/src/getCustomizationModule.ts
@@ -0,0 +1,14 @@
+import {
+ codingValues,
+ contextMenuCodeItem,
+ findingsContextMenu,
+} from './custom-context-menu';
+
+export default function getCustomizationModule() {
+ return [
+ {
+ name: 'custom-context-menu',
+ value: [codingValues, contextMenuCodeItem, findingsContextMenu],
+ },
+ ];
+}
diff --git a/extensions/test-extension/src/hp/hpMN.ts b/extensions/test-extension/src/hp/hpMN.ts
new file mode 100644
index 000000000..fc8fe4538
--- /dev/null
+++ b/extensions/test-extension/src/hp/hpMN.ts
@@ -0,0 +1,257 @@
+import { Types } from '@ohif/core';
+
+/**
+ * This hanging protocol has multiple stages, which are enabled when
+ * there are enough display sets with images to fill the stage, and
+ * are passive when there is at least one display set.
+ * Enabled display sets are navigated to by default, while passive ones
+ * are navigated to manually using the ctrl+end keyboard shortcut.
+ */
+const hpMN: Types.HangingProtocol.Protocol = {
+ hasUpdatedPriorsInformation: false,
+ id: '@ohif/hp-extension.mn',
+ description: 'Has various hanging protocol layouts for use in testing',
+ name: '2x2',
+ protocolMatchingRules: [
+ {
+ id: 'OneOrMoreSeries',
+ weight: 1,
+ attribute: 'numberOfDisplaySetsWithImages',
+ constraint: {
+ greaterThan: 1,
+ },
+ },
+ ],
+ toolGroupIds: ['default'],
+ displaySetSelectors: {
+ defaultDisplaySetId: {
+ seriesMatchingRules: [
+ {
+ attribute: 'numImageFrames',
+ constraint: {
+ greaterThan: { value: 0 },
+ },
+ },
+ ],
+ },
+ },
+ defaultViewport: {
+ viewportOptions: {
+ viewportType: 'stack',
+ toolGroupId: 'default',
+ allowUnmatchedView: true,
+ },
+ displaySets: [
+ {
+ id: 'defaultDisplaySetId',
+ matchedDisplaySetsIndex: -1,
+ },
+ ],
+ },
+ stages: [
+ {
+ id: '2x2',
+ stageActivation: {
+ enabled: {
+ minViewportsMatched: 4,
+ },
+ },
+ viewportStructure: {
+ layoutType: 'grid',
+ properties: {
+ rows: 2,
+ columns: 2,
+ },
+ },
+ viewports: [
+ {
+ viewportOptions: {
+ toolGroupId: 'default',
+ allowUnmatchedView: true,
+ },
+ displaySets: [
+ {
+ id: 'defaultDisplaySetId',
+ },
+ ],
+ },
+ {
+ viewportOptions: {
+ toolGroupId: 'default',
+ allowUnmatchedView: true,
+ },
+ displaySets: [
+ {
+ matchedDisplaySetsIndex: 1,
+ id: 'defaultDisplaySetId',
+ },
+ ],
+ },
+ {
+ viewportOptions: {
+ toolGroupId: 'default',
+ allowUnmatchedView: true,
+ },
+ displaySets: [
+ {
+ matchedDisplaySetsIndex: 2,
+ id: 'defaultDisplaySetId',
+ },
+ ],
+ },
+ {
+ viewportOptions: {
+ toolGroupId: 'default',
+ allowUnmatchedView: true,
+ },
+ displaySets: [
+ {
+ matchedDisplaySetsIndex: 3,
+ id: 'defaultDisplaySetId',
+ },
+ ],
+ },
+ ],
+ },
+
+ // 3x1 stage
+ {
+ id: '3x1',
+ // Obsolete settings:
+ requiredViewports: 1,
+ preferredViewports: 3,
+ // New equivalent:
+ stageActivation: {
+ enabled: {
+ minViewportsMatched: 3,
+ },
+ },
+ viewportStructure: {
+ layoutType: 'grid',
+ properties: {
+ rows: 1,
+ columns: 3,
+ },
+ },
+ viewports: [
+ {
+ viewportOptions: {
+ toolGroupId: 'default',
+ allowUnmatchedView: true,
+ },
+ displaySets: [
+ {
+ id: 'defaultDisplaySetId',
+ reuseId: '0-0',
+ },
+ ],
+ },
+ {
+ viewportOptions: {
+ toolGroupId: 'default',
+ allowUnmatchedView: true,
+ },
+ displaySets: [
+ {
+ matchedDisplaySetsIndex: 1,
+ id: 'defaultDisplaySetId',
+ reuseId: '1-0',
+ },
+ ],
+ },
+ {
+ viewportOptions: {
+ toolGroupId: 'default',
+ allowUnmatchedView: true,
+ },
+ displaySets: [
+ {
+ matchedDisplaySetsIndex: 2,
+ id: 'defaultDisplaySetId',
+ reuseId: '0-1',
+ },
+ ],
+ },
+ ],
+ },
+
+ // A 2x1 stage
+ {
+ id: '2x1',
+ requiredViewports: 1,
+ preferredViewports: 2,
+ stageActivation: {
+ enabled: {
+ minViewportsMatched: 2,
+ },
+ },
+ viewportStructure: {
+ layoutType: 'grid',
+ properties: {
+ rows: 1,
+ columns: 2,
+ },
+ },
+ viewports: [
+ {
+ viewportOptions: {
+ toolGroupId: 'default',
+ allowUnmatchedView: true,
+ },
+ displaySets: [
+ {
+ id: 'defaultDisplaySetId',
+ },
+ ],
+ },
+ {
+ viewportOptions: {
+ toolGroupId: 'default',
+ allowUnmatchedView: true,
+ },
+ displaySets: [
+ {
+ matchedDisplaySetsIndex: 1,
+ id: 'defaultDisplaySetId',
+ },
+ ],
+ },
+ ],
+ },
+
+ // A 1x1 stage - should be automatically activated if there is only 1 viewable instance
+ {
+ id: '1x1',
+ requiredViewports: 1,
+ preferredViewports: 1,
+ stageActivation: {
+ enabled: {
+ minViewportsMatched: 1,
+ },
+ },
+ viewportStructure: {
+ layoutType: 'grid',
+ properties: {
+ rows: 1,
+ columns: 1,
+ },
+ },
+ viewports: [
+ {
+ viewportOptions: {
+ toolGroupId: 'default',
+ allowUnmatchedView: true,
+ },
+ displaySets: [
+ {
+ id: 'defaultDisplaySetId',
+ },
+ ],
+ },
+ ],
+ },
+ ],
+ numberOfPriorsReferenced: -1,
+};
+
+export default hpMN;
diff --git a/extensions/test-extension/src/hp/index.ts b/extensions/test-extension/src/hp/index.ts
new file mode 100644
index 000000000..a1b0c22c2
--- /dev/null
+++ b/extensions/test-extension/src/hp/index.ts
@@ -0,0 +1,17 @@
+import hpMN from './hpMN';
+
+const hangingProtocols = [
+ {
+ name: '@ohif/hp-extension.mn',
+ protocol: hpMN,
+ },
+];
+
+/**
+ * Registers a single study hanging protocol which can be referenced as
+ * `@ohif/hp-exgtension.mn`, that has initial layouts which show images
+ * only display sets, up to a 2x2 view.
+ */
+export default function getHangingProtocolModule() {
+ return hangingProtocols;
+}
diff --git a/extensions/test-extension/src/index.tsx b/extensions/test-extension/src/index.tsx
index 5c07074c3..589d87ca5 100644
--- a/extensions/test-extension/src/index.tsx
+++ b/extensions/test-extension/src/index.tsx
@@ -1,17 +1,68 @@
-import { id } from './id';
import { Types } from '@ohif/core';
+import { id } from './id';
+
+import getHangingProtocolModule from './hp';
+import getCustomizationModule from './getCustomizationModule';
+// import {setViewportZoomPan, storeViewportZoomPan } from './custom-viewport/setViewportZoomPan';
+import sameAs from './custom-attribute/sameAs';
+import numberOfDisplaySets from './custom-attribute/numberOfDisplaySets';
+import numberOfDisplaySetsWithImages from './custom-attribute/numberOfDisplaySetsWithImages';
+import maxNumImageFrames from './custom-attribute/maxNumImageFrames';
+import seriesDescriptionsFromDisplaySets from './custom-attribute/seriesDescriptionsFromDisplaySets';
+
/**
- *
+ * The test extension provides additional behaviour for testing various
+ * customizations and settings for OHIF.
*/
const testExtension: Types.Extensions.Extension = {
/**
* Only required property. Should be a unique value across all extensions.
*/
id,
- preRegistration() {
- console.debug('hello from test-extension init.js');
+
+ /** Register additional behaviour:
+ * * HP custom attribute seriesDescriptions to retrieve an array of all series descriptions
+ * * HP custom attribute numberOfDisplaySets to retrieve the number of display sets
+ * * HP custom attribute numberOfDisplaySetsWithImages to retrieve the number of display sets containing images
+ * * HP custom attribute to return a boolean true, when the attribute sameAttribute has the same
+ * value as another series description in an already matched display set selector named with the value
+ * in `sameDisplaySetId`
+ */
+ preRegistration: ({ servicesManager }: Types.Extensions.ExtensionParams) => {
+ const { hangingProtocolService } = servicesManager.services;
+ hangingProtocolService.addCustomAttribute(
+ 'seriesDescriptions',
+ 'Series Descriptions',
+ seriesDescriptionsFromDisplaySets
+ );
+ hangingProtocolService.addCustomAttribute(
+ 'numberOfDisplaySets',
+ 'Number of displays sets',
+ numberOfDisplaySets
+ );
+ hangingProtocolService.addCustomAttribute(
+ 'numberOfDisplaySetsWithImages',
+ 'Number of displays sets with images',
+ numberOfDisplaySetsWithImages
+ );
+ hangingProtocolService.addCustomAttribute(
+ 'maxNumImageFrames',
+ 'Maximum of number of image frames',
+ maxNumImageFrames
+ );
+ hangingProtocolService.addCustomAttribute(
+ 'sameAs',
+ 'Match an attribute in an existing display set',
+ sameAs
+ );
},
+
+ /** Registers some additional hanging protocols. See hp/index.tsx for more details */
+ getHangingProtocolModule,
+
+ /** Registers some customizations */
+ getCustomizationModule,
};
export default testExtension;
diff --git a/extensions/tmtv/src/getHangingProtocolModule.js b/extensions/tmtv/src/getHangingProtocolModule.js
index 34a28489e..45720c10d 100644
--- a/extensions/tmtv/src/getHangingProtocolModule.js
+++ b/extensions/tmtv/src/getHangingProtocolModule.js
@@ -1,3 +1,219 @@
+import {
+ ctAXIAL,
+ ctCORONAL,
+ ctSAGITTAL,
+ fusionAXIAL,
+ fusionCORONAL,
+ fusionSAGITTAL,
+ mipSAGITTAL,
+ ptAXIAL,
+ ptCORONAL,
+ ptSAGITTAL,
+} from './utils/hpViewports';
+
+/**
+ * represents a 3x4 viewport layout configuration. The layout displays CT axial, sagittal, and coronal
+ * images in the first row, PT axial, sagittal, and coronal images in the second row, and fusion axial,
+ * sagittal, and coronal images in the third row. The fourth column is fully spanned by a MIP sagittal
+ * image, covering all three rows. It has synchronizers for windowLevel for all CT and PT images, and
+ * also camera synchronizer for each orientation
+ */
+const stage1 = {
+ name: 'default',
+ viewportStructure: {
+ layoutType: 'grid',
+ properties: {
+ rows: 3,
+ columns: 4,
+ layoutOptions: [
+ {
+ x: 0,
+ y: 0,
+ width: 1 / 4,
+ height: 1 / 3,
+ },
+ {
+ x: 1 / 4,
+ y: 0,
+ width: 1 / 4,
+ height: 1 / 3,
+ },
+ {
+ x: 2 / 4,
+ y: 0,
+ width: 1 / 4,
+ height: 1 / 3,
+ },
+ {
+ x: 0,
+ y: 1 / 3,
+ width: 1 / 4,
+ height: 1 / 3,
+ },
+ {
+ x: 1 / 4,
+ y: 1 / 3,
+ width: 1 / 4,
+ height: 1 / 3,
+ },
+ {
+ x: 2 / 4,
+ y: 1 / 3,
+ width: 1 / 4,
+ height: 1 / 3,
+ },
+ {
+ x: 0,
+ y: 2 / 3,
+ width: 1 / 4,
+ height: 1 / 3,
+ },
+ {
+ x: 1 / 4,
+ y: 2 / 3,
+ width: 1 / 4,
+ height: 1 / 3,
+ },
+ {
+ x: 2 / 4,
+ y: 2 / 3,
+ width: 1 / 4,
+ height: 1 / 3,
+ },
+ {
+ x: 3 / 4,
+ y: 0,
+ width: 1 / 4,
+ height: 1,
+ },
+ ],
+ },
+ },
+ viewports: [
+ ctAXIAL,
+ ctSAGITTAL,
+ ctCORONAL,
+ ptAXIAL,
+ ptSAGITTAL,
+ ptCORONAL,
+ fusionAXIAL,
+ fusionSAGITTAL,
+ fusionCORONAL,
+ mipSAGITTAL,
+ ],
+ createdDate: '2021-02-23T18:32:42.850Z',
+};
+
+/**
+ * The layout displays CT axial image in the top-left viewport, fusion axial image
+ * in the top-right viewport, PT axial image in the bottom-left viewport, and MIP
+ * sagittal image in the bottom-right viewport. The layout follows a simple grid
+ * pattern with 2 rows and 2 columns. It includes synchronizers as well.
+ */
+const stage2 = {
+ name: 'Fusion 2x2',
+ viewportStructure: {
+ layoutType: 'grid',
+ properties: {
+ rows: 2,
+ columns: 2,
+ },
+ },
+ viewports: [ctAXIAL, fusionAXIAL, ptAXIAL, mipSAGITTAL],
+};
+
+/**
+ * The top row displays CT images in axial, sagittal, and coronal orientations from
+ * left to right, respectively. The bottom row displays PT images in axial, sagittal,
+ * and coronal orientations from left to right, respectively.
+ * The layout follows a simple grid pattern with 2 rows and 3 columns.
+ * It includes synchronizers as well.
+ */
+const stage3 = {
+ name: '2x3-layout',
+ viewportStructure: {
+ layoutType: 'grid',
+ properties: {
+ rows: 2,
+ columns: 3,
+ },
+ },
+ viewports: [ctAXIAL, ctSAGITTAL, ctCORONAL, ptAXIAL, ptSAGITTAL, ptCORONAL],
+};
+
+/**
+ * In this layout, the top row displays PT images in coronal, sagittal, and axial
+ * orientations from left to right, respectively, followed by a MIP sagittal image
+ * that spans both rows on the rightmost side. The bottom row displays fusion images
+ * in coronal, sagittal, and axial orientations from left to right, respectively.
+ * There is no viewport in the bottom row's rightmost position, as the MIP sagittal viewport
+ * from the top row spans the full height of both rows.
+ * It includes synchronizers as well.
+ */
+const stage4 = {
+ name: '2x4-layout',
+ viewportStructure: {
+ layoutType: 'grid',
+ properties: {
+ rows: 2,
+ columns: 4,
+ layoutOptions: [
+ {
+ x: 0,
+ y: 0,
+ width: 1 / 4,
+ height: 1 / 2,
+ },
+ {
+ x: 1 / 4,
+ y: 0,
+ width: 1 / 4,
+ height: 1 / 2,
+ },
+ {
+ x: 2 / 4,
+ y: 0,
+ width: 1 / 4,
+ height: 1 / 2,
+ },
+ {
+ x: 3 / 4,
+ y: 0,
+ width: 1 / 4,
+ height: 1,
+ },
+ {
+ x: 0,
+ y: 1 / 2,
+ width: 1 / 4,
+ height: 1 / 2,
+ },
+ {
+ x: 1 / 4,
+ y: 1 / 2,
+ width: 1 / 4,
+ height: 1 / 2,
+ },
+ {
+ x: 2 / 4,
+ y: 1 / 2,
+ width: 1 / 4,
+ height: 1 / 2,
+ },
+ ],
+ },
+ },
+ viewports: [
+ ptCORONAL,
+ ptSAGITTAL,
+ ptAXIAL,
+ mipSAGITTAL,
+ fusionCORONAL,
+ fusionSAGITTAL,
+ fusionAXIAL,
+ ],
+};
+
const ptCT = {
id: '@ohif/extension-tmtv.hangingProtocolModule.ptCT',
locked: true,
@@ -32,7 +248,6 @@ const ptCT = {
ctDisplaySet: {
seriesMatchingRules: [
{
- weight: 1,
attribute: 'Modality',
constraint: {
equals: {
@@ -42,7 +257,6 @@ const ptCT = {
required: true,
},
{
- weight: 1,
attribute: 'isReconstructable',
constraint: {
equals: {
@@ -75,7 +289,6 @@ const ptCT = {
required: true,
},
{
- weight: 1,
attribute: 'isReconstructable',
constraint: {
equals: {
@@ -103,508 +316,14 @@ const ptCT = {
},
},
- stages: [
- {
- id: 'hYbmMy3b7pz7GLiaT',
- name: 'default',
- viewportStructure: {
- layoutType: 'grid',
- properties: {
- rows: 3,
- columns: 4,
- layoutOptions: [
- {
- x: 0,
- y: 0,
- width: 1 / 4,
- height: 1 / 3,
- },
- {
- x: 1 / 4,
- y: 0,
- width: 1 / 4,
- height: 1 / 3,
- },
- {
- x: 2 / 4,
- y: 0,
- width: 1 / 4,
- height: 1 / 3,
- },
- {
- x: 0,
- y: 1 / 3,
- width: 1 / 4,
- height: 1 / 3,
- },
- {
- x: 1 / 4,
- y: 1 / 3,
- width: 1 / 4,
- height: 1 / 3,
- },
- {
- x: 2 / 4,
- y: 1 / 3,
- width: 1 / 4,
- height: 1 / 3,
- },
- {
- x: 0,
- y: 2 / 3,
- width: 1 / 4,
- height: 1 / 3,
- },
- {
- x: 1 / 4,
- y: 2 / 3,
- width: 1 / 4,
- height: 1 / 3,
- },
- {
- x: 2 / 4,
- y: 2 / 3,
- width: 1 / 4,
- height: 1 / 3,
- },
- {
- x: 3 / 4,
- y: 0,
- width: 1 / 4,
- height: 1,
- },
- ],
- },
- },
- viewports: [
- {
- viewportOptions: {
- viewportId: 'ctAXIAL',
- viewportType: 'volume',
- orientation: 'axial',
- toolGroupId: 'ctToolGroup',
- initialImageOptions: {
- // index: 5,
- preset: 'first', // 'first', 'last', 'middle'
- },
- syncGroups: [
- {
- type: 'cameraPosition',
- id: 'axialSync',
- source: true,
- target: true,
- },
- {
- type: 'voi',
- id: 'ctWLSync',
- source: true,
- target: true,
- },
- ],
- },
- displaySets: [
- {
- id: 'ctDisplaySet',
- },
- ],
- },
- {
- viewportOptions: {
- viewportId: 'ctSAGITTAL',
- viewportType: 'volume',
- orientation: 'sagittal',
- toolGroupId: 'ctToolGroup',
- syncGroups: [
- {
- type: 'cameraPosition',
- id: 'sagittalSync',
- source: true,
- target: true,
- },
- {
- type: 'voi',
- id: 'ctWLSync',
- source: true,
- target: true,
- },
- ],
- },
- displaySets: [
- {
- id: 'ctDisplaySet',
- },
- ],
- },
- {
- viewportOptions: {
- viewportId: 'ctCORONAL',
- viewportType: 'volume',
- orientation: 'coronal',
- toolGroupId: 'ctToolGroup',
- syncGroups: [
- {
- type: 'cameraPosition',
- id: 'coronalSync',
- source: true,
- target: true,
- },
- {
- type: 'voi',
- id: 'ctWLSync',
- source: true,
- target: true,
- },
- ],
- },
- displaySets: [
- {
- id: 'ctDisplaySet',
- },
- ],
- },
- {
- viewportOptions: {
- viewportId: 'ptAXIAL',
- viewportType: 'volume',
- background: [1, 1, 1],
- orientation: 'axial',
- toolGroupId: 'ptToolGroup',
- initialImageOptions: {
- // index: 5,
- preset: 'first', // 'first', 'last', 'middle'
- },
- syncGroups: [
- {
- type: 'cameraPosition',
- id: 'axialSync',
- source: true,
- target: true,
- },
- {
- type: 'voi',
- id: 'ptWLSync',
- source: true,
- target: true,
- },
- {
- type: 'voi',
- id: 'ptFusionWLSync',
- source: true,
- target: false,
- },
- ],
- },
- displaySets: [
- {
- options: {
- voi: {
- windowWidth: 5,
- windowCenter: 2.5,
- },
- voiInverted: true,
- },
- id: 'ptDisplaySet',
- },
- ],
- },
- {
- viewportOptions: {
- viewportId: 'ptSAGITTAL',
- viewportType: 'volume',
- orientation: 'sagittal',
- background: [1, 1, 1],
- toolGroupId: 'ptToolGroup',
- syncGroups: [
- {
- type: 'cameraPosition',
- id: 'sagittalSync',
- source: true,
- target: true,
- },
- {
- type: 'voi',
- id: 'ptWLSync',
- source: true,
- target: true,
- },
- {
- type: 'voi',
- id: 'ptFusionWLSync',
- source: true,
- target: false,
- },
- ],
- },
- displaySets: [
- {
- options: {
- voi: {
- windowWidth: 5,
- windowCenter: 2.5,
- },
- voiInverted: true,
- },
- id: 'ptDisplaySet',
- },
- ],
- },
- {
- viewportOptions: {
- viewportId: 'ptCORONAL',
- viewportType: 'volume',
- orientation: 'coronal',
- background: [1, 1, 1],
- toolGroupId: 'ptToolGroup',
- syncGroups: [
- {
- type: 'cameraPosition',
- id: 'coronalSync',
- source: true,
- target: true,
- },
- {
- type: 'voi',
- id: 'ptWLSync',
- source: true,
- target: true,
- },
- {
- type: 'voi',
- id: 'ptFusionWLSync',
- source: true,
- target: false,
- },
- ],
- },
- displaySets: [
- {
- options: {
- voi: {
- windowWidth: 5,
- windowCenter: 2.5,
- },
- voiInverted: true,
- },
- id: 'ptDisplaySet',
- },
- ],
- },
- {
- viewportOptions: {
- viewportId: 'fusionAXIAL',
- viewportType: 'volume',
- orientation: 'axial',
- toolGroupId: 'fusionToolGroup',
- initialImageOptions: {
- // index: 5,
- preset: 'first', // 'first', 'last', 'middle'
- },
- syncGroups: [
- {
- type: 'cameraPosition',
- id: 'axialSync',
- source: true,
- target: true,
- },
- {
- type: 'voi',
- id: 'ctWLSync',
- source: false,
- target: true,
- },
- {
- type: 'voi',
- id: 'fusionWLSync',
- source: true,
- target: true,
- },
- {
- type: 'voi',
- id: 'ptFusionWLSync',
- source: false,
- target: true,
- },
- ],
- },
- displaySets: [
- {
- id: 'ctDisplaySet',
- },
- {
- options: {
- colormap: 'hsv',
- voi: {
- windowWidth: 5,
- windowCenter: 2.5,
- },
- },
- id: 'ptDisplaySet',
- },
- ],
- },
- {
- viewportOptions: {
- viewportId: 'fusionSAGITTAL',
- viewportType: 'volume',
- orientation: 'sagittal',
- toolGroupId: 'fusionToolGroup',
- // initialImageOptions: {
- // index: 180,
- // preset: 'middle', // 'first', 'last', 'middle'
- // },
- syncGroups: [
- {
- type: 'cameraPosition',
- id: 'sagittalSync',
- source: true,
- target: true,
- },
- {
- type: 'voi',
- id: 'ctWLSync',
- source: false,
- target: true,
- },
- {
- type: 'voi',
- id: 'fusionWLSync',
- source: true,
- target: true,
- },
- {
- type: 'voi',
- id: 'ptFusionWLSync',
- source: false,
- target: true,
- },
- ],
- },
- displaySets: [
- {
- id: 'ctDisplaySet',
- },
- {
- options: {
- colormap: 'hsv',
- voi: {
- windowWidth: 5,
- windowCenter: 2.5,
- },
- },
- id: 'ptDisplaySet',
- },
- ],
- },
- {
- viewportOptions: {
- viewportId: 'fusionCoronal',
- viewportType: 'volume',
- orientation: 'coronal',
- toolGroupId: 'fusionToolGroup',
- // initialImageOptions: {
- // index: 180,
- // preset: 'middle', // 'first', 'last', 'middle'
- // },
- syncGroups: [
- {
- type: 'cameraPosition',
- id: 'coronalSync',
- source: true,
- target: true,
- },
- {
- type: 'voi',
- id: 'ctWLSync',
- source: false,
- target: true,
- },
- {
- type: 'voi',
- id: 'fusionWLSync',
- source: true,
- target: true,
- },
- {
- type: 'voi',
- id: 'ptFusionWLSync',
- source: false,
- target: true,
- },
- ],
- },
- displaySets: [
- {
- id: 'ctDisplaySet',
- },
- {
- options: {
- colormap: 'hsv',
- voi: {
- windowWidth: 5,
- windowCenter: 2.5,
- },
- },
- id: 'ptDisplaySet',
- },
- ],
- },
- {
- viewportOptions: {
- viewportId: 'mipSagittal',
- viewportType: 'volume',
- orientation: 'sagittal',
- background: [1, 1, 1],
- toolGroupId: 'mipToolGroup',
- syncGroups: [
- {
- type: 'voi',
- id: 'ptWLSync',
- source: true,
- target: true,
- },
- {
- type: 'voi',
- id: 'ptFusionWLSync',
- source: true,
- target: false,
- },
- ],
-
- // Custom props can be used to set custom properties which extensions
- // can react on.
- customViewportProps: {
- // We use viewportDisplay to filter the viewports which are displayed
- // in mip and we set the scrollbar according to their rotation index
- // in the cornerstone extension.
- hideOverlays: true,
- },
- },
- displaySets: [
- {
- options: {
- blendMode: 'MIP',
- slabThickness: 'fullVolume',
- voi: {
- windowWidth: 5,
- windowCenter: 2.5,
- },
- voiInverted: true,
- },
- id: 'ptDisplaySet',
- },
- ],
- },
- ],
- createdDate: '2021-02-23T18:32:42.850Z',
- },
- ],
+ stages: [stage1, stage2, stage3, stage4],
numberOfPriorsReferenced: -1,
};
function getHangingProtocolModule() {
return [
{
- id: ptCT.id,
+ name: ptCT.id,
protocol: ptCT,
},
];
diff --git a/extensions/tmtv/src/utils/hpViewports.ts b/extensions/tmtv/src/utils/hpViewports.ts
new file mode 100644
index 000000000..0efc354ec
--- /dev/null
+++ b/extensions/tmtv/src/utils/hpViewports.ts
@@ -0,0 +1,438 @@
+const ctAXIAL = {
+ viewportOptions: {
+ viewportId: 'ctAXIAL',
+ viewportType: 'volume',
+ orientation: 'axial',
+ toolGroupId: 'ctToolGroup',
+ initialImageOptions: {
+ // index: 5,
+ preset: 'first', // 'first', 'last', 'middle'
+ },
+ syncGroups: [
+ {
+ type: 'cameraPosition',
+ id: 'axialSync',
+ source: true,
+ target: true,
+ },
+ {
+ type: 'voi',
+ id: 'ctWLSync',
+ source: true,
+ target: true,
+ },
+ ],
+ },
+ displaySets: [
+ {
+ id: 'ctDisplaySet',
+ },
+ ],
+};
+
+const ctSAGITTAL = {
+ viewportOptions: {
+ viewportId: 'ctSAGITTAL',
+ viewportType: 'volume',
+ orientation: 'sagittal',
+ toolGroupId: 'ctToolGroup',
+ syncGroups: [
+ {
+ type: 'cameraPosition',
+ id: 'sagittalSync',
+ source: true,
+ target: true,
+ },
+ {
+ type: 'voi',
+ id: 'ctWLSync',
+ source: true,
+ target: true,
+ },
+ ],
+ },
+ displaySets: [
+ {
+ id: 'ctDisplaySet',
+ },
+ ],
+};
+const ctCORONAL = {
+ viewportOptions: {
+ viewportId: 'ctCORONAL',
+ viewportType: 'volume',
+ orientation: 'coronal',
+ toolGroupId: 'ctToolGroup',
+ syncGroups: [
+ {
+ type: 'cameraPosition',
+ id: 'coronalSync',
+ source: true,
+ target: true,
+ },
+ {
+ type: 'voi',
+ id: 'ctWLSync',
+ source: true,
+ target: true,
+ },
+ ],
+ },
+ displaySets: [
+ {
+ id: 'ctDisplaySet',
+ },
+ ],
+};
+
+const ptAXIAL = {
+ viewportOptions: {
+ viewportId: 'ptAXIAL',
+ viewportType: 'volume',
+ background: [1, 1, 1],
+ orientation: 'axial',
+ toolGroupId: 'ptToolGroup',
+ initialImageOptions: {
+ // index: 5,
+ preset: 'first', // 'first', 'last', 'middle'
+ },
+ syncGroups: [
+ {
+ type: 'cameraPosition',
+ id: 'axialSync',
+ source: true,
+ target: true,
+ },
+ {
+ type: 'voi',
+ id: 'ptWLSync',
+ source: true,
+ target: true,
+ },
+ {
+ type: 'voi',
+ id: 'ptFusionWLSync',
+ source: true,
+ target: false,
+ },
+ ],
+ },
+ displaySets: [
+ {
+ options: {
+ voi: {
+ windowWidth: 5,
+ windowCenter: 2.5,
+ },
+ voiInverted: true,
+ },
+ id: 'ptDisplaySet',
+ },
+ ],
+};
+
+const ptSAGITTAL = {
+ viewportOptions: {
+ viewportId: 'ptSAGITTAL',
+ viewportType: 'volume',
+ orientation: 'sagittal',
+ background: [1, 1, 1],
+ toolGroupId: 'ptToolGroup',
+ syncGroups: [
+ {
+ type: 'cameraPosition',
+ id: 'sagittalSync',
+ source: true,
+ target: true,
+ },
+ {
+ type: 'voi',
+ id: 'ptWLSync',
+ source: true,
+ target: true,
+ },
+ {
+ type: 'voi',
+ id: 'ptFusionWLSync',
+ source: true,
+ target: false,
+ },
+ ],
+ },
+ displaySets: [
+ {
+ options: {
+ voi: {
+ windowWidth: 5,
+ windowCenter: 2.5,
+ },
+ voiInverted: true,
+ },
+ id: 'ptDisplaySet',
+ },
+ ],
+};
+
+const ptCORONAL = {
+ viewportOptions: {
+ viewportId: 'ptCORONAL',
+ viewportType: 'volume',
+ orientation: 'coronal',
+ background: [1, 1, 1],
+ toolGroupId: 'ptToolGroup',
+ syncGroups: [
+ {
+ type: 'cameraPosition',
+ id: 'coronalSync',
+ source: true,
+ target: true,
+ },
+ {
+ type: 'voi',
+ id: 'ptWLSync',
+ source: true,
+ target: true,
+ },
+ {
+ type: 'voi',
+ id: 'ptFusionWLSync',
+ source: true,
+ target: false,
+ },
+ ],
+ },
+ displaySets: [
+ {
+ options: {
+ voi: {
+ windowWidth: 5,
+ windowCenter: 2.5,
+ },
+ voiInverted: true,
+ },
+ id: 'ptDisplaySet',
+ },
+ ],
+};
+
+const fusionAXIAL = {
+ viewportOptions: {
+ viewportId: 'fusionAXIAL',
+ viewportType: 'volume',
+ orientation: 'axial',
+ toolGroupId: 'fusionToolGroup',
+ initialImageOptions: {
+ // index: 5,
+ preset: 'first', // 'first', 'last', 'middle'
+ },
+ syncGroups: [
+ {
+ type: 'cameraPosition',
+ id: 'axialSync',
+ source: true,
+ target: true,
+ },
+ {
+ type: 'voi',
+ id: 'ctWLSync',
+ source: false,
+ target: true,
+ },
+ {
+ type: 'voi',
+ id: 'fusionWLSync',
+ source: true,
+ target: true,
+ },
+ {
+ type: 'voi',
+ id: 'ptFusionWLSync',
+ source: false,
+ target: true,
+ },
+ ],
+ },
+ displaySets: [
+ {
+ id: 'ctDisplaySet',
+ },
+ {
+ options: {
+ colormap: 'hsv',
+ voi: {
+ windowWidth: 5,
+ windowCenter: 2.5,
+ },
+ },
+ id: 'ptDisplaySet',
+ },
+ ],
+};
+
+const fusionSAGITTAL = {
+ viewportOptions: {
+ viewportId: 'fusionSAGITTAL',
+ viewportType: 'volume',
+ orientation: 'sagittal',
+ toolGroupId: 'fusionToolGroup',
+ // initialImageOptions: {
+ // index: 180,
+ // preset: 'middle', // 'first', 'last', 'middle'
+ // },
+ syncGroups: [
+ {
+ type: 'cameraPosition',
+ id: 'sagittalSync',
+ source: true,
+ target: true,
+ },
+ {
+ type: 'voi',
+ id: 'ctWLSync',
+ source: false,
+ target: true,
+ },
+ {
+ type: 'voi',
+ id: 'fusionWLSync',
+ source: true,
+ target: true,
+ },
+ {
+ type: 'voi',
+ id: 'ptFusionWLSync',
+ source: false,
+ target: true,
+ },
+ ],
+ },
+ displaySets: [
+ {
+ id: 'ctDisplaySet',
+ },
+ {
+ options: {
+ colormap: 'hsv',
+ voi: {
+ windowWidth: 5,
+ windowCenter: 2.5,
+ },
+ },
+ id: 'ptDisplaySet',
+ },
+ ],
+};
+
+const fusionCORONAL = {
+ viewportOptions: {
+ viewportId: 'fusionCoronal',
+ viewportType: 'volume',
+ orientation: 'coronal',
+ toolGroupId: 'fusionToolGroup',
+ // initialImageOptions: {
+ // index: 180,
+ // preset: 'middle', // 'first', 'last', 'middle'
+ // },
+ syncGroups: [
+ {
+ type: 'cameraPosition',
+ id: 'coronalSync',
+ source: true,
+ target: true,
+ },
+ {
+ type: 'voi',
+ id: 'ctWLSync',
+ source: false,
+ target: true,
+ },
+ {
+ type: 'voi',
+ id: 'fusionWLSync',
+ source: true,
+ target: true,
+ },
+ {
+ type: 'voi',
+ id: 'ptFusionWLSync',
+ source: false,
+ target: true,
+ },
+ ],
+ },
+ displaySets: [
+ {
+ id: 'ctDisplaySet',
+ },
+ {
+ options: {
+ colormap: 'hsv',
+ voi: {
+ windowWidth: 5,
+ windowCenter: 2.5,
+ },
+ },
+ id: 'ptDisplaySet',
+ },
+ ],
+};
+
+const mipSAGITTAL = {
+ viewportOptions: {
+ viewportId: 'mipSagittal',
+ viewportType: 'volume',
+ orientation: 'sagittal',
+ background: [1, 1, 1],
+ toolGroupId: 'mipToolGroup',
+ syncGroups: [
+ {
+ type: 'voi',
+ id: 'ptWLSync',
+ source: true,
+ target: true,
+ },
+ {
+ type: 'voi',
+ id: 'ptFusionWLSync',
+ source: true,
+ target: false,
+ },
+ ],
+
+ // Custom props can be used to set custom properties which extensions
+ // can react on.
+ customViewportProps: {
+ // We use viewportDisplay to filter the viewports which are displayed
+ // in mip and we set the scrollbar according to their rotation index
+ // in the cornerstone extension.
+ hideOverlays: true,
+ },
+ },
+ displaySets: [
+ {
+ options: {
+ blendMode: 'MIP',
+ slabThickness: 'fullVolume',
+ voi: {
+ windowWidth: 5,
+ windowCenter: 2.5,
+ },
+ voiInverted: true,
+ },
+ id: 'ptDisplaySet',
+ },
+ ],
+};
+
+export {
+ ctAXIAL,
+ ctSAGITTAL,
+ ctCORONAL,
+ ptAXIAL,
+ ptSAGITTAL,
+ ptCORONAL,
+ fusionAXIAL,
+ fusionSAGITTAL,
+ fusionCORONAL,
+ mipSAGITTAL,
+};
diff --git a/modes/basic-dev-mode/src/index.js b/modes/basic-dev-mode/src/index.js
index f3368e412..d74ee60a4 100644
--- a/modes/basic-dev-mode/src/index.js
+++ b/modes/basic-dev-mode/src/index.js
@@ -140,7 +140,6 @@ function modeFactory({ modeConfiguration }) {
toolbarService,
} = servicesManager.services;
- toolbarService.reset();
toolGroupService.destroy();
},
validationTags: {
diff --git a/modes/basic-test-mode/src/index.js b/modes/basic-test-mode/src/index.js
index 129aa6834..11e06ec24 100644
--- a/modes/basic-test-mode/src/index.js
+++ b/modes/basic-test-mode/src/index.js
@@ -72,6 +72,7 @@ function modeFactory() {
measurementService,
toolbarService,
toolGroupService,
+ customizationService,
} = servicesManager.services;
measurementService.clearMeasurements();
@@ -79,6 +80,11 @@ function modeFactory() {
// Init Default and SR ToolGroups
initToolGroups(extensionManager, toolGroupService, commandsManager);
+ // init customizations
+ customizationService.addModeCustomizations([
+ '@ohif/extension-test.customizationModule.custom-context-menu',
+ ]);
+
let unsubscribe;
const activateTool = () => {
@@ -132,7 +138,6 @@ function modeFactory() {
cornerstoneViewportService,
} = servicesManager.services;
- toolbarService.reset();
toolGroupService.destroy();
syncGroupService.destroy();
segmentationService.destroy();
@@ -205,7 +210,12 @@ function modeFactory() {
dicompdf.sopClassHandler,
dicomsr.sopClassHandler,
],
- hotkeys: [...hotkeys.defaults.hotkeyBindings],
+ hotkeys: {
+ // Don't store the hotkeys for basic-test-mode under the same key
+ // because they get customized by tests
+ name: 'basic-test-hotkeys',
+ hotkeys: [...hotkeys.defaults.hotkeyBindings],
+ },
};
}
diff --git a/modes/basic-test-mode/src/toolbarButtons.js b/modes/basic-test-mode/src/toolbarButtons.js
index a8c8a8535..9a04581c5 100644
--- a/modes/basic-test-mode/src/toolbarButtons.js
+++ b/modes/basic-test-mode/src/toolbarButtons.js
@@ -297,10 +297,96 @@ const toolbarButtons = [
},
{
id: 'Layout',
- type: 'ohif.layoutSelector',
+ type: 'ohif.splitButton',
props: {
- rows: 3,
- columns: 3,
+ groupId: 'LayoutTools',
+ isRadio: false,
+ primary: {
+ id: 'Layout',
+ type: 'action',
+ uiType: 'ohif.layoutSelector',
+ icon: 'tool-layout',
+ label: 'Grid Layout',
+ props: {
+ rows: 4,
+ columns: 4,
+ commands: [
+ {
+ commandName: 'setLayout',
+ commandOptions: {},
+ context: 'CORNERSTONE',
+ },
+ ],
+ },
+ },
+ secondary: {
+ icon: 'chevron-down',
+ label: '',
+ isActive: true,
+ tooltip: 'Hanging Protocols',
+ },
+ items: [
+ {
+ id: '2x2',
+ type: 'action',
+ label: '2x2',
+ commands: [
+ {
+ commandName: 'setHangingProtocol',
+ commandOptions: {
+ protocolId: '@ohif/hp-extension.mn',
+ stageId: '2x2',
+ },
+ context: 'DEFAULT',
+ },
+ ],
+ },
+ {
+ id: '3x1',
+ type: 'action',
+ label: '3x1',
+ commands: [
+ {
+ commandName: 'setHangingProtocol',
+ commandOptions: {
+ protocolId: '@ohif/hp-extension.mn',
+ stageId: '3x1',
+ },
+ context: 'DEFAULT',
+ },
+ ],
+ },
+ {
+ id: '2x1',
+ type: 'action',
+ label: '2x1',
+ commands: [
+ {
+ commandName: 'setHangingProtocol',
+ commandOptions: {
+ protocolId: '@ohif/hp-extension.mn',
+ stageId: '2x1',
+ },
+ context: 'DEFAULT',
+ },
+ ],
+ },
+ {
+ id: '1x1',
+ type: 'action',
+ label: '1x1',
+ commands: [
+ {
+ commandName: 'setHangingProtocol',
+ commandOptions: {
+ protocolId: '@ohif/hp-extension.mn',
+ stageId: '1x1',
+ },
+ context: 'DEFAULT',
+ },
+ ],
+ },
+ ],
},
},
{
@@ -312,9 +398,11 @@ const toolbarButtons = [
label: 'MPR',
commands: [
{
- commandName: 'toggleMPR',
- commandOptions: {},
- context: 'CORNERSTONE',
+ commandName: 'toggleHangingProtocol',
+ commandOptions: {
+ protocolId: 'mpr',
+ },
+ context: 'DEFAULT',
},
],
},
diff --git a/modes/longitudinal/src/index.js b/modes/longitudinal/src/index.js
index ab6887420..6e2d8a2da 100644
--- a/modes/longitudinal/src/index.js
+++ b/modes/longitudinal/src/index.js
@@ -159,7 +159,6 @@ function modeFactory() {
_activatePanelTriggersSubscriptions.forEach(sub => sub.unsubscribe());
_activatePanelTriggersSubscriptions = [];
- toolbarService.reset();
toolGroupService.destroy();
syncGroupService.destroy();
segmentationService.destroy();
diff --git a/modes/longitudinal/src/initToolGroups.js b/modes/longitudinal/src/initToolGroups.js
index fe77aa52f..6bbe668d2 100644
--- a/modes/longitudinal/src/initToolGroups.js
+++ b/modes/longitudinal/src/initToolGroups.js
@@ -215,6 +215,32 @@ function initMPRToolGroup(extensionManager, toolGroupService, commandsManager) {
toolGroupService.createToolGroupAndAddTools('mpr', tools, toolsConfig);
}
+function initVolume3DToolGroup(extensionManager, toolGroupService) {
+ const utilityModule = extensionManager.getModuleEntry(
+ '@ohif/extension-cornerstone.utilityModule.tools'
+ );
+
+ const { toolNames, Enums } = utilityModule.exports;
+
+ const tools = {
+ active: [
+ {
+ toolName: toolNames.TrackballRotateTool,
+ bindings: [{ mouseButton: Enums.MouseBindings.Primary }],
+ },
+ {
+ toolName: toolNames.Zoom,
+ bindings: [{ mouseButton: Enums.MouseBindings.Secondary }],
+ },
+ {
+ toolName: toolNames.Pan,
+ bindings: [{ mouseButton: Enums.MouseBindings.Auxiliary }],
+ },
+ ],
+ };
+
+ toolGroupService.createToolGroupAndAddTools('volume3d', tools);
+}
function initToolGroups(extensionManager, toolGroupService, commandsManager) {
initDefaultToolGroup(
@@ -225,6 +251,7 @@ function initToolGroups(extensionManager, toolGroupService, commandsManager) {
);
initSRToolGroup(extensionManager, toolGroupService, commandsManager);
initMPRToolGroup(extensionManager, toolGroupService, commandsManager);
+ initVolume3DToolGroup(extensionManager, toolGroupService);
}
export default initToolGroups;
diff --git a/modes/longitudinal/src/toolbarButtons.js b/modes/longitudinal/src/toolbarButtons.js
index 3addb750b..a2b72cbf1 100644
--- a/modes/longitudinal/src/toolbarButtons.js
+++ b/modes/longitudinal/src/toolbarButtons.js
@@ -27,18 +27,6 @@ function _createButton(type, id, icon, label, commands, tooltip, uiType) {
};
}
-function _createCommands(commandName, toolName, toolGroupIds) {
- return toolGroupIds.map(toolGroupId => ({
- /* It's a command that is being run when the button is clicked. */
- commandName,
- commandOptions: {
- toolName,
- toolGroupId,
- },
- context: 'CORNERSTONE',
- }));
-}
-
const _createActionButton = _createButton.bind(null, 'action');
const _createToggleButton = _createButton.bind(null, 'toggle');
const _createToolButton = _createButton.bind(null, 'tool');
@@ -67,6 +55,26 @@ function _createWwwcPreset(preset, title, subtitle) {
};
}
+const toolGroupIds = ['default', 'mpr', 'SRToolGroup'];
+
+/**
+ * Creates an array of 'setToolActive' commands for the given toolName - one for
+ * each toolGroupId specified in toolGroupIds.
+ * @param {string} toolName
+ * @returns {Array} an array of 'setToolActive' commands
+ */
+function _createSetToolActiveCommands(toolName) {
+ const temp = toolGroupIds.map(toolGroupId => ({
+ commandName: 'setToolActive',
+ commandOptions: {
+ toolGroupId,
+ toolName,
+ },
+ context: 'CORNERSTONE',
+ }));
+ return temp;
+}
+
const toolbarButtons = [
// Measurement
{
@@ -211,15 +219,7 @@ const toolbarButtons = [
type: 'tool',
icon: 'tool-zoom',
label: 'Zoom',
- commands: [
- {
- commandName: 'setToolActive',
- commandOptions: {
- toolName: 'Zoom',
- },
- context: 'CORNERSTONE',
- },
- ],
+ commands: _createSetToolActiveCommands('Zoom'),
},
},
// Window Level + Presets...
@@ -268,15 +268,7 @@ const toolbarButtons = [
type: 'tool',
icon: 'tool-move',
label: 'Pan',
- commands: [
- {
- commandName: 'setToolActive',
- commandOptions: {
- toolName: 'Pan',
- },
- context: 'CORNERSTONE',
- },
- ],
+ commands: _createSetToolActiveCommands('Pan'),
},
},
{
@@ -312,9 +304,11 @@ const toolbarButtons = [
label: 'MPR',
commands: [
{
- commandName: 'toggleMPR',
- commandOptions: {},
- context: 'CORNERSTONE',
+ commandName: 'toggleHangingProtocol',
+ commandOptions: {
+ protocolId: 'mpr',
+ },
+ context: 'DEFAULT',
},
],
},
@@ -330,8 +324,8 @@ const toolbarButtons = [
{
commandName: 'setToolActive',
commandOptions: {
- toolGroupId: 'mpr',
toolName: 'Crosshairs',
+ toolGroupId: 'mpr',
},
context: 'CORNERSTONE',
},
diff --git a/modes/tmtv/src/index.js b/modes/tmtv/src/index.js
index d9a4e885a..c0f8659ae 100644
--- a/modes/tmtv/src/index.js
+++ b/modes/tmtv/src/index.js
@@ -136,13 +136,11 @@ function modeFactory({ modeConfiguration }) {
const {
toolGroupService,
syncGroupService,
- toolbarService,
segmentationService,
cornerstoneViewportService,
} = servicesManager.services;
unsubscriptions.forEach(unsubscribe => unsubscribe());
- toolbarService.reset();
toolGroupService.destroy();
syncGroupService.destroy();
segmentationService.destroy();
diff --git a/modes/tmtv/src/toolbarButtons.js b/modes/tmtv/src/toolbarButtons.js
index 890ff0416..8fd347737 100644
--- a/modes/tmtv/src/toolbarButtons.js
+++ b/modes/tmtv/src/toolbarButtons.js
@@ -203,9 +203,11 @@ const toolbarButtons = [
label: 'MPR',
commands: [
{
- commandName: 'toggleMPR',
- commandOptions: {},
- context: 'CORNERSTONE',
+ commandName: 'toggleHangingProtocol',
+ commandOptions: {
+ protocolId: 'mpr',
+ },
+ context: 'DEFAULT',
},
],
},
diff --git a/package.json b/package.json
index 3b5918b6f..c5287de03 100644
--- a/package.json
+++ b/package.json
@@ -79,7 +79,7 @@
"@types/jest": "^27.5.0",
"@typescript-eslint/eslint-plugin": "^4.19.0",
"@typescript-eslint/parser": "^4.19.0",
- "autoprefixer": "10.4.4",
+ "autoprefixer": "^10.4.4",
"babel-eslint": "9.x",
"babel-loader": "^8.2.4",
"babel-plugin-inline-react-svg": "1.1.0",
diff --git a/platform/core/package.json b/platform/core/package.json
index f2b11412d..42c973065 100644
--- a/platform/core/package.json
+++ b/platform/core/package.json
@@ -31,7 +31,7 @@
},
"peerDependencies": {
"cornerstone-math": "0.1.9",
- "cornerstone-wado-image-loader": "^4.2.1",
+ "cornerstone-wado-image-loader": "^4.13.0",
"dicom-parser": "^1.8.9",
"@ohif/ui": "^2.0.0"
},
diff --git a/platform/core/src/classes/CommandsManager.ts b/platform/core/src/classes/CommandsManager.ts
index 2ff961230..34a825c4d 100644
--- a/platform/core/src/classes/CommandsManager.ts
+++ b/platform/core/src/classes/CommandsManager.ts
@@ -1,4 +1,5 @@
import log from '../log.js';
+import { Command, Commands } from '../types/Command';
/**
* The definition of a command
@@ -105,8 +106,8 @@ export class CommandsManager {
* @param {String} commandName - Command to find
* @param {String} [contextName] - Specific command to look in. Defaults to current activeContexts
*/
- getCommand = (commandName, contextName) => {
- let contexts = [];
+ getCommand = (commandName: string, contextName?: string) => {
+ const contexts = [];
if (contextName) {
const context = this.getContext(contextName);
@@ -140,7 +141,7 @@ export class CommandsManager {
* @param {Object} [options={}] - Extra options to pass the command. Like a mousedown event
* @param {String} [contextName]
*/
- runCommand(commandName, options = {}, contextName) {
+ public runCommand(commandName: string, options = {}, contextName?: string) {
const definition = this.getCommand(commandName, contextName);
if (!definition) {
log.warn(`Command "${commandName}" not found in current context`);
@@ -161,6 +162,50 @@ export class CommandsManager {
return commandFn(commandParams);
}
}
+
+ /**
+ * Run one or more commands with specified extra options.
+ * Returns the result of the last command run.
+ *
+ * @param toRun - A specification of one or more commands
+ * @param options - to include in the commands run beyond
+ * the commandOptions specified in the base.
+ */
+ public run(
+ toRun: Command | Commands | Command[] | undefined,
+ options?: Record
+ ): unknown {
+ if (!toRun) return;
+ const commands =
+ (Array.isArray(toRun) && toRun) ||
+ ((toRun as Command).commandName && [toRun]) ||
+ (Array.isArray((toRun as Commands).commands) &&
+ (toRun as Commands).commands);
+ if (!commands) {
+ console.log("Command isn't runnable", toRun);
+ return;
+ }
+
+ let result;
+ (commands as Command[]).forEach(
+ ({ commandName, commandOptions, context }) => {
+ if (commandName) {
+ result = this.runCommand(
+ commandName,
+ {
+ ...commandOptions,
+ ...options,
+ },
+ context
+ );
+ } else {
+ console.warn('No command name supplied in', toRun);
+ }
+ }
+ );
+
+ return result;
+ }
}
export default CommandsManager;
diff --git a/platform/core/src/classes/HotkeysManager.ts b/platform/core/src/classes/HotkeysManager.ts
index ddb2757ec..50ccc0fe5 100644
--- a/platform/core/src/classes/HotkeysManager.ts
+++ b/platform/core/src/classes/HotkeysManager.ts
@@ -64,19 +64,17 @@ export class HotkeysManager {
*
* @param {HotkeyDefinition[] | Object} [hotkeyDefinitions=[]] Contains hotkeys definitions
*/
- setHotkeys(hotkeyDefinitions = [], key = 'hotkey-definitions') {
+ setHotkeys(hotkeyDefinitions = [], name = 'hotkey-definitions') {
try {
const definitions = this.getValidDefinitions(hotkeyDefinitions);
if (isequal(definitions, this.hotkeyDefaults)) {
- console.log('hotkeys REMOVING unused definition', key);
- localStorage.removeItem(key);
+ localStorage.removeItem(name);
} else {
- console.log('hotkeys setting local storage', key);
- localStorage.setItem(key, JSON.stringify(definitions));
+ localStorage.setItem(name, JSON.stringify(definitions));
}
definitions.forEach(definition => this.registerHotkeys(definition));
} catch (error) {
- const { uiNotificationService, } = this._servicesManager.services;
+ const { uiNotificationService } = this._servicesManager.services;
uiNotificationService.show({
title: 'Hotkeys Manager',
message: 'Error while setting hotkeys',
diff --git a/platform/core/src/classes/MetadataProvider.js b/platform/core/src/classes/MetadataProvider.js
index fc17ac294..32f482e74 100644
--- a/platform/core/src/classes/MetadataProvider.js
+++ b/platform/core/src/classes/MetadataProvider.js
@@ -412,6 +412,34 @@ class MetadataProvider {
return metadata;
}
+ /**
+ * Retrieves the frameNumber information, depending on the url style
+ * wadors /frames/1
+ * wadouri &frame=1
+ * @param {*} imageId
+ * @returns
+ */
+ getFrameInformationFromURL(imageId) {
+ function getInformationFromURL(informationString, separator) {
+ let result = '';
+ const splittedStr = imageId.split(informationString)[1];
+ if (splittedStr.includes(separator)) {
+ result = splittedStr.split(separator)[0];
+ } else {
+ result = splittedStr;
+ }
+ return result;
+ }
+
+ if (imageId.includes('/frames')) {
+ return getInformationFromURL('/frames', '/');
+ }
+ if (imageId.includes('&frame=')) {
+ return getInformationFromURL('&frame=', '&');
+ }
+ return;
+ }
+
getUIDsFromImageID(imageId) {
// TODO: adding csiv here is not really correct. Probably need to use
// metadataProvider.addImageIdToUIDs(imageId, {
@@ -445,7 +473,7 @@ class MetadataProvider {
// check if the imageId starts with http:// or https:// using regex
// Todo: handle non http imageIds
let imageURI;
- const urlRegex = /^(http|https):\/\//;
+ const urlRegex = /^(http|https|dicomfile):\/\//;
if (urlRegex.test(imageId)) {
imageURI = imageId;
} else {
@@ -453,7 +481,7 @@ class MetadataProvider {
}
const uids = this.imageURIToUIDs.get(imageURI);
- const frameNumber = imageId.split(/\/frames\//)[1];
+ let frameNumber = this.getFrameInformationFromURL(imageId) || '1';
if (uids && frameNumber !== undefined) {
return { ...uids, frameNumber };
diff --git a/platform/core/src/defaults/hotkeyBindings.js b/platform/core/src/defaults/hotkeyBindings.js
index cd38c43c5..75023247c 100644
--- a/platform/core/src/defaults/hotkeyBindings.js
+++ b/platform/core/src/defaults/hotkeyBindings.js
@@ -88,6 +88,20 @@ const bindings = [
// keys: ['pagedown'],
// isEditable: true,
// },
+ {
+ commandName: 'nextStage',
+ context: 'DEFAULT',
+ label: 'Next Stage',
+ keys: ['.'],
+ isEditable: true,
+ },
+ {
+ commandName: 'previousStage',
+ context: 'DEFAULT',
+ label: 'Previous Stage',
+ keys: [','],
+ isEditable: true,
+ },
{
commandName: 'nextImage',
label: 'Next Image',
diff --git a/platform/core/src/extensions/ExtensionManager.test.js b/platform/core/src/extensions/ExtensionManager.test.js
index 4177deab7..2af3ce52a 100644
--- a/platform/core/src/extensions/ExtensionManager.test.js
+++ b/platform/core/src/extensions/ExtensionManager.test.js
@@ -206,40 +206,40 @@ describe('ExtensionManager.ts', () => {
const extension = {
id: 'hello-world',
getViewportModule: () => {
- return [{}];
+ return [{ name: 'test' }];
},
getSopClassHandlerModule: () => {
- return [{}];
+ return [{ name: 'test' }];
},
getPanelModule: () => {
- return [{}];
+ return [{ name: 'test' }];
},
getToolbarModule: () => {
- return [{}];
+ return [{ name: 'test' }];
},
getCommandsModule: () => {
- return [{}];
+ return [{ name: 'test' }];
},
getLayoutTemplateModule: () => {
- return [{}];
+ return [{ name: 'test' }];
},
getDataSourcesModule: () => {
- return [{}];
+ return [{ name: 'test' }];
},
getHangingProtocolModule: () => {
- return [{}];
+ return [{ name: 'test' }];
},
getContextModule: () => {
- return [{}];
+ return [{ name: 'test' }];
},
getUtilityModule: () => {
- return [{}];
+ return [{ name: 'test' }];
},
getCustomizationModule: () => {
- return [{}];
+ return [{ name: 'test' }];
},
getStateSyncModule: () => {
- return [{}];
+ return [{ name: 'test' }];
},
};
diff --git a/platform/core/src/extensions/ExtensionManager.ts b/platform/core/src/extensions/ExtensionManager.ts
index ca05871af..188da5add 100644
--- a/platform/core/src/extensions/ExtensionManager.ts
+++ b/platform/core/src/extensions/ExtensionManager.ts
@@ -36,7 +36,10 @@ export interface ExtensionParams extends ExtensionConstructor {
*/
export interface Extension {
id: string;
- preRegistration?: (p: ExtensionParams) => void;
+ preRegistration?: (p: ExtensionParams) => Promise | void;
+ onModeExit?: () => void;
+ getHangingProtocolModule?: (p: ExtensionParams) => unknown;
+ getCommandsModule?: (p: ExtensionParams) => CommandsModule;
}
export type ExtensionRegister = {
@@ -44,6 +47,12 @@ export type ExtensionRegister = {
create: (p: ExtensionParams) => Extension;
};
+export type CommandsModule = {
+ actions: Record;
+ definitions: Record;
+ defaultContext?: string;
+};
+
export default class ExtensionManager {
private _commandsManager: CommandsManager;
private _servicesManager: ServicesManager;
@@ -274,6 +283,11 @@ export default class ExtensionManager {
// Default for most extension points,
// Just adds each entry ready for consumption by mode.
extensionModule.forEach(element => {
+ if (!element.name) {
+ throw new Error(
+ `Extension ID ${extensionId} module ${moduleType} element has no name`
+ );
+ }
const id = `${extensionId}.${moduleType}.${element.name}`;
element.id = id;
this.modulesMap[id] = element;
@@ -331,7 +345,7 @@ export default class ExtensionManager {
}
try {
- const extensionModule = getModuleFn({
+ const extensionModule = extension[getModuleFnName]({
appConfig: this._appConfig,
commandsManager: this._commandsManager,
servicesManager: this._servicesManager,
@@ -348,6 +362,7 @@ export default class ExtensionManager {
return extensionModule;
} catch (ex) {
+ console.log(ex);
throw new Error(
`Exception thrown while trying to call ${getModuleFnName} for the ${extensionId} extension`
);
@@ -356,10 +371,10 @@ export default class ExtensionManager {
_initHangingProtocolsModule = (extensionModule, extensionId) => {
const { hangingProtocolService } = this._servicesManager.services;
- extensionModule.forEach(({ id, protocol }) => {
+ extensionModule.forEach(({ name, protocol }) => {
if (protocol) {
// Only auto-register if protocol specified, otherwise let mode register
- hangingProtocolService.addProtocol(id, protocol);
+ hangingProtocolService.addProtocol(name, protocol);
}
});
};
diff --git a/platform/core/src/extensions/MODULE_TYPES.js b/platform/core/src/extensions/MODULE_TYPES.js
index c96c3f1fb..8260f77a1 100644
--- a/platform/core/src/extensions/MODULE_TYPES.js
+++ b/platform/core/src/extensions/MODULE_TYPES.js
@@ -1,6 +1,7 @@
export default {
COMMANDS: 'commandsModule',
CUSTOMIZATION: 'customizationModule',
+ STATE_SYNC: 'stateSyncModule',
DATA_SOURCE: 'dataSourcesModule',
PANEL: 'panelModule',
SOP_CLASS_HANDLER: 'sopClassHandlerModule',
diff --git a/platform/core/src/index.test.js b/platform/core/src/index.test.js
index 3c058f961..3a62a5141 100644
--- a/platform/core/src/index.test.js
+++ b/platform/core/src/index.test.js
@@ -25,6 +25,7 @@ describe('Top level exports', () => {
//
'CineService',
'CustomizationService',
+ 'StateSyncService',
'UIDialogService',
'UIModalService',
'UINotificationService',
diff --git a/platform/core/src/index.ts b/platform/core/src/index.ts
index 5732d33f3..458c7a3ab 100644
--- a/platform/core/src/index.ts
+++ b/platform/core/src/index.ts
@@ -29,6 +29,7 @@ import {
PubSubService,
UserAuthenticationService,
CustomizationService,
+ StateSyncService,
PanelService,
} from './services';
@@ -61,6 +62,7 @@ const OHIF = {
//
CineService,
CustomizationService,
+ StateSyncService,
UIDialogService,
UIModalService,
UINotificationService,
@@ -99,6 +101,7 @@ export {
//
CineService,
CustomizationService,
+ StateSyncService,
UIDialogService,
UIModalService,
UINotificationService,
diff --git a/platform/core/src/services/CustomizationService/CustomizationService.ts b/platform/core/src/services/CustomizationService/CustomizationService.ts
index a133cfdb5..91353a59c 100644
--- a/platform/core/src/services/CustomizationService/CustomizationService.ts
+++ b/platform/core/src/services/CustomizationService/CustomizationService.ts
@@ -63,7 +63,7 @@ export default class CustomizationService extends PubSubService {
modeCustomizations: Record = {};
globalCustomizations: Record = {};
- configuration: UICustomizationConfiguration;
+ configuration: CustomizationConfiguration;
constructor({ configuration, commandsManager }) {
super(EVENTS);
@@ -97,36 +97,6 @@ export default class CustomizationService extends PubSubService {
this.modeCustomizations = {};
}
- /**
- *
- * @param {*} interaction - can be undefined to run nothing
- * @param {*} extraOptions to include in the commands run
- */
- recordInteraction(
- interaction: Customization | void,
- extraOptions?: Record
- ): void {
- if (!interaction) return;
- const commandsManager = this.commandsManager;
- const { commands = [] } = interaction;
-
- commands.forEach(({ commandName, commandOptions, context }) => {
- if (commandName) {
- commandsManager.runCommand(
- commandName,
- {
- interaction,
- ...commandOptions,
- ...extraOptions,
- },
- context
- );
- } else {
- console.warn('No command name supplied in', interaction);
- }
- });
- }
-
public getModeCustomizations(): Record {
return this.modeCustomizations;
}
@@ -145,6 +115,23 @@ export default class CustomizationService extends PubSubService {
});
}
+ /** This is the preferred getter for all customizations,
+ * getting mode customizations first and otherwise global customizations.
+ *
+ * @param customizationId - the customization id to look for
+ * @param defaultValue - is the default value to return. Note this value
+ * may have been extended with any customizationType extensions provided,
+ * so you cannot just use `|| defaultValue`
+ * @return A customization to use if one is found, or the default customization,
+ * both enhanced with any customizationType inheritance (see transform)
+ */
+ public getCustomization(
+ customizationId: string,
+ defaultValue?: Customization
+ ): Customization | void {
+ return this.getModeCustomization(customizationId, defaultValue);
+ }
+
/** Mode customizations are changes to the behaviour of the extensions
* when running in a given mode. Reset clears mode customizations.
* Note that global customizations over-ride mode customizations.
@@ -158,7 +145,7 @@ export default class CustomizationService extends PubSubService {
this.globalCustomizations[customizationId] ??
this.modeCustomizations[customizationId] ??
defaultValue;
- return this.applyType(customization);
+ return this.transform(customization);
}
public hasModeCustomization(customizationId: string) {
@@ -167,16 +154,33 @@ export default class CustomizationService extends PubSubService {
this.modeCustomizations[customizationId]
);
}
+ /**
+ * get is an alias for getModeCustomization, as it is the generic getter
+ * which will return both mode and global customizations, and should be
+ * used generally.
+ * Note that the second parameter, defaultValue, will be expanded to include
+ * any customizationType values defined in it, so it is not the same as doing:
+ * `customizationService.get('key') || defaultValue`
+ * unless the defaultValue does not contain any customizationType definitions.
+ */
+ public get = this.getModeCustomization;
- /** Applies any inheritance due to UI Type customization */
- public applyType(customization: Customization): Customization {
+ /**
+ * Applies any inheritance due to UI Type customization.
+ * This will look for customizationType in the customization object
+ * and if that is found, will assign all iterable values from that
+ * type into the new type, allowing default behaviour to be configured.
+ */
+ public transform(customization: Customization): Customization {
if (!customization) return customization;
const { customizationType } = customization;
if (!customizationType) return customization;
- const parent = this.getModeCustomization(customizationType);
- return parent
+ const parent = this.getCustomization(customizationType);
+ const result = parent
? Object.assign(Object.create(parent), customization)
: customization;
+ // Execute an nested type information
+ return result.transform?.(this) || result;
}
public addModeCustomizations(modeCustomizations): void {
@@ -203,7 +207,7 @@ export default class CustomizationService extends PubSubService {
id: string,
defaultValue?: Customization
): Customization | void {
- return this.applyType(this.globalCustomizations[id] ?? defaultValue);
+ return this.transform(this.globalCustomizations[id] ?? defaultValue);
}
setGlobalCustomization(id: string, value: Customization): void {
@@ -243,7 +247,7 @@ export default class CustomizationService extends PubSubService {
const extensionValue = this.findExtensionValue(value);
// The child of a reference is only a set of references when an array,
// so call the addReference direct. It could be a secondary reference perhaps
- this.addReference(extensionValue);
+ this.addReference(extensionValue.value, isGlobal, extensionValue.name);
} else if (Array.isArray(value)) {
this.addReferences(value, isGlobal);
} else {
diff --git a/platform/core/src/services/DicomMetadataStore/DicomMetadataStore.ts b/platform/core/src/services/DicomMetadataStore/DicomMetadataStore.ts
index bf1aab1b6..f90dd2039 100644
--- a/platform/core/src/services/DicomMetadataStore/DicomMetadataStore.ts
+++ b/platform/core/src/services/DicomMetadataStore/DicomMetadataStore.ts
@@ -84,9 +84,9 @@ function _getInstance(StudyInstanceUID, SeriesInstanceUID, SOPInstanceUID) {
}
function _getInstanceByImageId(imageId) {
- for (let study of _model.studies) {
- for (let series of study.series) {
- for (let instance of series.instances) {
+ for (const study of _model.studies) {
+ for (const series of study.series) {
+ for (const instance of series.instances) {
if (instance.imageId === imageId) {
return instance;
}
@@ -236,7 +236,7 @@ const BaseImplementation = {
addStudy(study) {
const { StudyInstanceUID } = study;
- let existingStudy = _model.studies.find(
+ const existingStudy = _model.studies.find(
study => study.StudyInstanceUID === StudyInstanceUID
);
diff --git a/platform/core/src/services/HangingProtocolService/HPMatcher.js b/platform/core/src/services/HangingProtocolService/HPMatcher.js
index 854dab807..a369f2460 100644
--- a/platform/core/src/services/HangingProtocolService/HPMatcher.js
+++ b/platform/core/src/services/HangingProtocolService/HPMatcher.js
@@ -29,27 +29,31 @@ const match = (
let requiredFailed = false;
let score = 0;
+ // Allow for matching against current or prior specifically
+ const prior = options?.studies?.[1];
+ const current = options?.studies?.[0];
+ const instance = (metadataInstance.images || metadataInstance.others)?.[0];
+ const fromSrc = {
+ prior,
+ current,
+ instance,
+ ...options,
+ options,
+ metadataInstance,
+ };
+
rules.forEach(rule => {
- const { attribute } = rule;
+ const { attribute, from = 'metadataInstance' } = rule;
// Do not use the custom attribute from the metadataInstance since it is subject to change
if (customAttributeRetrievalCallbacks.hasOwnProperty(attribute)) {
readValues[attribute] = customAttributeRetrievalCallbacks[
attribute
- ].callback(metadataInstance, options);
+ ].callback.call(rule, metadataInstance, options);
} else {
readValues[attribute] =
- metadataInstance[attribute] ??
- ((metadataInstance.images || metadataInstance.others || [])[0] || {})[
- attribute
- ];
+ fromSrc[from]?.[attribute] ?? instance?.[attribute];
}
- console.log(
- 'Test',
- attribute,
- readValues[attribute],
- JSON.stringify(rule.constraint)
- );
// Format the constraint as required by Validate.js
const testConstraint = {
[attribute]: rule.constraint,
@@ -70,6 +74,14 @@ const match = (
errorMessages = ['Something went wrong during validation.', e];
}
+ console.log(
+ 'Test',
+ `${from}.${attribute}`,
+ readValues[attribute],
+ JSON.stringify(rule.constraint),
+ !errorMessages
+ );
+
if (!errorMessages) {
// If no errorMessages were returned, then validation passed.
diff --git a/platform/core/src/services/HangingProtocolService/HangingProtocolService.test.js b/platform/core/src/services/HangingProtocolService/HangingProtocolService.test.js
index 19fbf8906..1af19950b 100644
--- a/platform/core/src/services/HangingProtocolService/HangingProtocolService.test.js
+++ b/platform/core/src/services/HangingProtocolService/HangingProtocolService.test.js
@@ -117,8 +117,7 @@ const studyMatchDisplaySets = [displaySet3, displaySet2, displaySet1];
function checkHpsBestMatch(hps) {
hps.run({ studies: [studyMatch], displaySets: studyMatchDisplaySets });
- const { hpAlreadyApplied, viewportMatchDetails } = hps.getMatchDetails();
- expect(hpAlreadyApplied).toMatchObject(new Map([[0, false]]));
+ const { viewportMatchDetails } = hps.getMatchDetails();
expect(viewportMatchDetails.size).toBe(1);
expect(viewportMatchDetails.get(0)).toMatchObject({
viewportOptions: {
@@ -131,9 +130,11 @@ function checkHpsBestMatch(hps) {
// ds2 fails to match required and ds3 fails to match an optional.
displaySetsInfo: [
{
- SeriesInstanceUID: 'ds1',
displaySetInstanceUID: 'displaySet1',
- displaySetOptions: {},
+ displaySetOptions: {
+ id: 'displaySetSelector',
+ options: {},
+ },
},
],
});
@@ -191,14 +192,6 @@ describe('HangingProtocolService', () => {
it('matches best image match', () => {
checkHpsBestMatch(hangingProtocolService);
});
-
- it('uses services manager', () => {
- hangingProtocolService.run({
- studies: [studyMatch],
- displaySets: studyMatchDisplaySets,
- });
- expect(mockedFunction).toHaveBeenCalledTimes(1);
});
});
});
-});
diff --git a/platform/core/src/services/HangingProtocolService/HangingProtocolService.ts b/platform/core/src/services/HangingProtocolService/HangingProtocolService.ts
index f85ea5905..b366450d9 100644
--- a/platform/core/src/services/HangingProtocolService/HangingProtocolService.ts
+++ b/platform/core/src/services/HangingProtocolService/HangingProtocolService.ts
@@ -1,24 +1,37 @@
-import uuidv4 from '../../utils/uuidv4';
-import pubSubServiceInterface from '../_shared/pubSubServiceInterface';
+import { PubSubService } from '../_shared/pubSubServiceInterface';
import sortBy from '../../utils/sortBy';
import ProtocolEngine from './ProtocolEngine';
-import StudyMetadata from '../../types/StudyMetadata';
+import { StudyMetadata } from '../../types/StudyMetadata';
import IDisplaySet from '../DisplaySetService/IDisplaySet';
-import { HangingProtocol } from '../../types';
-
-const EVENTS = {
- STAGE_CHANGE: 'event::hanging_protocol_stage_change',
- PROTOCOL_CHANGED: 'event::hanging_protocol_changed',
- NEW_LAYOUT: 'event::hanging_protocol_new_layout',
- CUSTOM_IMAGE_LOAD_PERFORMED:
- 'event::hanging_protocol_custom_image_load_performed',
- HANGING_PROTOCOL_APPLIED_FOR_VIEWPORT:
- 'event::hanging_protocol_applied_for_viewport',
-};
+import { CommandsManager } from '../../classes';
+import ServicesManager from '../ServicesManager';
+import * as HangingProtocol from '../../types/HangingProtocol';
type Protocol = HangingProtocol.Protocol | HangingProtocol.ProtocolGenerator;
-class HangingProtocolService {
+const DEFAULT_VIEWPORT_OPTIONS: HangingProtocol.ViewportOptions = {
+ toolGroupId: 'default',
+ viewportType: 'stack',
+};
+
+export default class HangingProtocolService extends PubSubService {
+ static EVENTS = {
+ // The PROTOCOL_CHANGED event is fired when the protocol changes
+ // and should be immediately applied
+ PROTOCOL_CHANGED: 'event::hanging_protocol_changed',
+ // The PROTOCOL_RESTORED event is fired instead of a changed event to indicate
+ // that an earlier state has been restored as part of a state update, but
+ // is not being directly re-applied, but just restored.
+ PROTOCOL_RESTORED: 'event::hanging_protocol_restore',
+ // The layout has been decided for the hanging protocol - deprecated
+ NEW_LAYOUT: 'event::hanging_protocol_new_layout',
+ // Fired when the stages within the current protocol are known to have
+ // the status set - that is, they are activated (or deactivated).
+ STAGE_ACTIVATION: 'event::hanging_protocol_stage_activation',
+ CUSTOM_IMAGE_LOAD_PERFORMED:
+ 'event::hanging_protocol_custom_image_load_performed',
+ };
+
public static REGISTRATION = {
name: 'hangingProtocolService',
altName: 'HangingProtocolService',
@@ -34,15 +47,14 @@ class HangingProtocolService {
activeProtocolIds: string[];
// the current protocol that is being applied to the viewports in object format
protocol: HangingProtocol.Protocol;
- stage: number;
- _commandsManager: Record;
- _servicesManager: Record;
+ stageIndex = 0;
+ _commandsManager: CommandsManager;
+ _servicesManager: ServicesManager;
protocolEngine: ProtocolEngine;
customViewportSettings = [];
displaySets: IDisplaySet[] = [];
- activeStudy: Record;
+ activeStudy: StudyMetadata;
debugLogging: false;
- EVENTS: { [key: string]: string };
customAttributeRetrievalCallbacks = {
NumberOfStudyRelatedSeries: {
@@ -75,12 +87,6 @@ class HangingProtocolService {
activeImageLoadStrategyName = null;
customImageLoadPerformed = false;
- /**
- * Whether the hanging protocol is applied for the given viewport index,
- * applying means that the displayset(s) is set for the viewport to be shown
- */
- hpAlreadyApplied: Map = new Map();
-
/**
* displaySetMatchDetails =
* DisplaySetId is the id defined in the hangingProtocol object itself
@@ -100,57 +106,90 @@ class HangingProtocolService {
HangingProtocol.ViewportMatchDetails
> = new Map();
- constructor(commandsManager, servicesManager) {
+ constructor(commandsManager: CommandsManager, servicesManager) {
+ super(HangingProtocolService.EVENTS);
this._commandsManager = commandsManager;
this._servicesManager = servicesManager;
this.protocols = new Map();
this.protocolEngine = undefined;
this.protocol = undefined;
- this.stage = undefined;
+ this.stageIndex = undefined;
this.studies = [];
- Object.defineProperty(this, 'EVENTS', {
- value: EVENTS,
- writable: false,
- enumerable: true,
- configurable: false,
- });
- Object.assign(this, pubSubServiceInterface);
}
- public destroy() {
+ public destroy(): void {
this.reset();
this.protocols = new Map();
}
- public reset() {
+ public reset(): void {
this.studies = [];
- this.hpAlreadyApplied = new Map();
this.viewportMatchDetails = new Map();
this.displaySetMatchDetails = new Map();
}
/** Leave the hanging protocol in the initialized state */
- public onModeExit() {
+ public onModeEnter(): void {
this.reset();
}
+ /**
+ * Gets the active protocol information directly, including the direct
+ * protocol, stage and active study objects.
+ * Should NOT be stored longer term as the protocol
+ * object can change internally or be regenerated.
+ * Can be used to store the state to recover from exceptions.
+ *
+ * @returns protocol, stage, activeStudy
+ */
public getActiveProtocol(): {
protocol: HangingProtocol.Protocol;
- stage: number;
+ stage: HangingProtocol.ProtocolStage;
+ stageIndex: number;
+ activeStudy?: StudyMetadata;
+ viewportMatchDetails: Map;
+ displaySetMatchDetails: Map;
+ activeImageLoadStrategyName: string;
} {
- return { protocol: this.protocol, stage: this.stage };
+ return {
+ protocol: this.protocol,
+ stage: this.protocol?.stages?.[this.stageIndex],
+ stageIndex: this.stageIndex,
+ activeStudy: this.activeStudy,
+ viewportMatchDetails: this.viewportMatchDetails,
+ displaySetMatchDetails: this.displaySetMatchDetails,
+ activeImageLoadStrategyName: this.activeImageLoadStrategyName,
+ };
}
+ /** Gets the hanging protocol state information, which is a storable
+ * state information for the hanging protocol consisting of the:
+ * protocolId, stageIndex, stageId and activeStudyUID
+ */
+ public getState(): HangingProtocol.HPInfo {
+ if (!this.protocol) return;
+ return {
+ protocolId: this.protocol.id,
+ stageIndex: this.stageIndex,
+ stageId: this.protocol.stages[this.stageIndex].id,
+ activeStudyUID: this.activeStudy?.StudyInstanceUID,
+ };
+ }
+
+ /** Gets the protocol with id 'default' */
public getDefaultProtocol(): HangingProtocol.Protocol {
return this.getProtocolById('default');
}
+ /** Gets the viewport match details.
+ * @deprecated because this method is expected to go away as the HP service
+ * becomes more stateless.
+ */
public getMatchDetails(): HangingProtocol.HangingProtocolMatchDetails {
return {
viewportMatchDetails: this.viewportMatchDetails,
displaySetMatchDetails: this.displaySetMatchDetails,
- hpAlreadyApplied: this.hpAlreadyApplied,
};
}
@@ -185,13 +224,14 @@ class HangingProtocolService {
* @param protocolId - the id of the protocol
* @returns protocol - the protocol with the given id
*/
- public getProtocolById(id: string): HangingProtocol.Protocol | undefined {
- if (!id) {
- return;
+ public getProtocolById(protocolId: string): HangingProtocol.Protocol {
+ if (!protocolId) return;
+ if (protocolId === this.protocol?.id) return this.protocol;
+ const protocol = this.protocols.get(protocolId);
+ if (!protocol) {
+ throw new Error(`No protocol ${protocolId} found`);
}
- const protocol = this.protocols.get(id);
-
if (protocol instanceof Function) {
try {
const { protocol: generatedProtocol } = this._getProtocolFromGenerator(
@@ -201,7 +241,7 @@ class HangingProtocolService {
return generatedProtocol;
} catch (error) {
console.warn(
- `Error while executing protocol generator for protocol ${id}: ${error}`
+ `Error while executing protocol generator for protocol ${protocolId}: ${error}`
);
}
} else {
@@ -264,23 +304,40 @@ class HangingProtocolService {
this.activeProtocolIds = [...protocolId];
}
+ /**
+ * Sets the active study.
+ * This is the study that the hanging protocol will consider active and
+ * may or may not be the study that is being shown by the protocol currently,
+ * for example, a prior view hanging protocol will NOT show the active study
+ * specifically, but will show another study instead.
+ */
+ public setActiveStudyUID(activeStudyUID: string): void {
+ this.activeStudy = this.studies.find(
+ it => it.StudyInstanceUID === activeStudyUID
+ );
+ }
+
/**
* Run the hanging protocol decisions tree on the active study,
- * studies list and display sets, firing a hanging protocol event when
- * complete to indicate the hanging protocol is ready.
+ * studies list and display sets, firing a PROTOCOL_CHANGED event when
+ * complete to indicate the hanging protocol is ready, and which stage
+ * got applied/activated.
+ *
+ * Also fires a STAGES_ACTIVE event to indicate which stages are able to be
+ * activated.
*
* @param params is the dataset to run the hanging protocol on.
* @param params.activeStudy is the "primary" study to hang This may or may
* not be displayed by the actual viewports.
- * @param params.studies is the list of studies to hang
+ * @param params.studies is the list of studies to hang. If absent, will re-use the previous set.
* @param params.displaySets is the list of display sets associated with
* the studies to display in viewports.
* @param protocol is a specific protocol to apply.
*/
public run({ studies, displaySets, activeStudy }, protocolId) {
- this.studies = [...studies];
+ this.studies = [...(studies || this.studies)];
this.displaySets = displaySets;
- this.activeStudy = activeStudy || studies[0];
+ this.setActiveStudyUID((activeStudy || studies[0])?.StudyInstanceUID);
this.protocolEngine = new ProtocolEngine(
this.getProtocols(),
@@ -330,23 +387,6 @@ class HangingProtocolService {
}
}
- setHangingProtocolAppliedForViewport(i, status, suppressEvent = false) {
- this.hpAlreadyApplied.set(i, status);
-
- const numberOfViewports = this.viewportMatchDetails.size;
- const numberOfViewportsApplied = Array.from(
- this.hpAlreadyApplied.values()
- ).filter(applied => applied).length;
-
- const progress = Math.round(
- (numberOfViewportsApplied / numberOfViewports) * 100
- );
-
- this._broadcastChange(this.EVENTS.HANGING_PROTOCOL_APPLIED_FOR_VIEWPORT, {
- progress: progress,
- });
- }
-
/**
* Adds a custom attribute to be used in the HangingProtocol UI and matching rules, including a
* callback that will be used to calculate the attribute value.
@@ -359,8 +399,11 @@ class HangingProtocolService {
public addCustomAttribute(
attributeId: string,
attributeName: string,
- callback: (metadata: any) => any,
- options: Record = {}
+ callback: (
+ metadata: Record,
+ extraData?: Record
+ ) => unknown,
+ options: Record = {}
): void {
this.customAttributeRetrievalCallbacks[attributeId] = {
...options,
@@ -370,33 +413,11 @@ class HangingProtocolService {
};
}
- /**
- * Switches to the next protocol stage in the display set sequence
- */
- public nextProtocolStage(): void {
- console.log('ProtocolEngine::nextProtocolStage');
-
- if (!this._setCurrentProtocolStage(1)) {
- console.log('ProtocolEngine::nextProtocolStage failed');
- }
- }
-
- /**
- * Switches to the previous protocol stage in the display set sequence
- */
- public previousProtocolStage(): void {
- console.log('ProtocolEngine::previousProtocolStage');
-
- if (!this._setCurrentProtocolStage(-1)) {
- console.log('ProtocolEngine::previousProtocolStage failed');
- }
- }
-
/**
* Executes the callback function for the custom loading strategy for the images
* if no strategy is set, the default strategy is used
*/
- runImageLoadStrategy(data): void {
+ runImageLoadStrategy(data): boolean {
const loader = this.registeredImageLoadStrategies[
this.activeImageLoadStrategyName
];
@@ -409,11 +430,13 @@ class HangingProtocolService {
// if loader successfully re-arranged the data with the custom strategy
// and returned the new props, then broadcast them
if (!loadedData) {
- return;
+ console.warn('Not able to load data with custom strategy');
+ return false;
}
this.customImageLoadPerformed = true;
- this._broadcastChange(this.EVENTS.CUSTOM_IMAGE_LOAD_PERFORMED, loadedData);
+ this._broadcastEvent(this.EVENTS.CUSTOM_IMAGE_LOAD_PERFORMED, loadedData);
+ return true;
}
_validateProtocol(
@@ -429,9 +452,25 @@ class HangingProtocolService {
protocol.name = protocol.name || protocol.id;
const { stages } = protocol;
+ if (!stages) {
+ console.warn('Protocol has not stages:', protocol.id, protocol);
+ return;
+ }
+
+ for (const id of Object.keys(protocol.displaySetSelectors)) {
+ const selector = protocol.displaySetSelectors[id];
+ selector.id = id;
+ const { seriesMatchingRules } = selector;
+ if (!seriesMatchingRules) {
+ console.warn('Selector has no series matching rules', protocol.id, id);
+ return;
+ }
+ }
+
// Generate viewports automatically as required.
stages.forEach(stage => {
if (!stage.viewports) {
+ stage.name = stage.name || stage.id;
stage.viewports = [];
const { rows, columns } = stage.viewportStructure.properties;
@@ -479,7 +518,7 @@ class HangingProtocolService {
getViewportsRequireUpdate(viewportIndex, displaySetInstanceUID) {
const newDisplaySetInstanceUID = displaySetInstanceUID;
const protocol = this.protocol;
- const protocolStage = protocol.stages[this.stage];
+ const protocolStage = protocol.stages[this.stageIndex];
const protocolViewports = protocolStage.viewports;
const protocolViewport = protocolViewports[viewportIndex];
@@ -518,7 +557,10 @@ class HangingProtocolService {
// if the viewport is not empty, then we check the displaySets it is showing
// currently, which means we need to check if the requested updated displaySet
// follow the same rules as the current displaySets
- const displaySetSelectorId = protocolViewport.displaySets[0].id;
+ const {
+ id: displaySetSelectorId,
+ matchedDisplaySetsIndex = 0,
+ } = protocolViewport.displaySets[0];
const displaySetSelector =
protocol.displaySetSelectors[displaySetSelectorId];
@@ -558,7 +600,10 @@ class HangingProtocolService {
protocolViewports.forEach((viewport, index) => {
let viewportNeedsUpdate;
for (const displaySet of viewport.displaySets) {
- if (displaySet.id === displaySetSelectorId) {
+ if (
+ displaySet.id === displaySetSelectorId &&
+ (displaySet.matchedDisplaySetsIndex || 0) === matchedDisplaySetsIndex
+ ) {
viewportNeedsUpdate = true;
break;
}
@@ -573,7 +618,7 @@ class HangingProtocolService {
displaySetOptions,
} = viewport.displaySets.reduce(
(acc, displaySet) => {
- const { id, options } = displaySet;
+ const { id } = displaySet;
let {
displaySetInstanceUID: displaySetInstanceUIDToUse,
@@ -584,7 +629,7 @@ class HangingProtocolService {
}
acc.displaySetInstanceUIDs.push(displaySetInstanceUIDToUse);
- acc.displaySetOptions.push(options);
+ acc.displaySetOptions.push(displaySet);
return acc;
},
@@ -630,16 +675,16 @@ class HangingProtocolService {
return;
}
- const protocol = this._validateProtocol(foundProtocol);
-
- if (options) {
- this._validateOptions(options);
- }
-
try {
+ const protocol = this._validateProtocol(foundProtocol);
+
+ if (options) {
+ this._validateOptions(options);
+ }
+
this._setProtocol(protocol, options);
} catch (error) {
- console.error(error);
+ console.log(error);
if (errorCallback) {
errorCallback(error);
@@ -649,38 +694,171 @@ class HangingProtocolService {
}
}
+ protected matchActivation(
+ matchedViewports: number,
+ activation: HangingProtocol.StageActivation = {},
+ minViewportsMatched: number
+ ): boolean {
+ const { displaySetSelectors } = this.protocol;
+
+ const { displaySetSelectorsMatched = [] } = activation;
+ for (const dsName of displaySetSelectorsMatched) {
+ const displaySetSelector = displaySetSelectors[dsName];
+ if (!displaySetSelector) {
+ console.warn('No display set selector for', dsName);
+ return false;
+ }
+ const { bestMatch } = this._matchImages(displaySetSelector);
+ if (!bestMatch) {
+ return false;
+ }
+ }
+ const min = activation.minViewportsMatched ?? minViewportsMatched;
+
+ return matchedViewports >= min;
+ }
+ /**
+ * Updates the stage activation, setting the stageActivation values to
+ * 'disabled', 'active', 'passive' where:
+ * * disabled means there are insufficient viewports filled to show this
+ * * passive means there aren't enough preferred viewports filled to show
+ * this stage by default, but it can be manually selected
+ * * enabled means there are enough viewports to select this viewport by default
+ *
+ * The logic is currently simple, just count how many viewports would be
+ * filled, and compare to the required/preferred count, but the intent is
+ * to allow more complex rules in the future as required.
+ *
+ * @returns the stage number to apply initially, given the options.
+ */
+ private _updateStageStatus(
+ options = null as HangingProtocol.SetProtocolOptions
+ ) {
+ const stages = this.protocol.stages;
+ for (let i = 0; i < stages.length; i++) {
+ const stage = stages[i];
+
+ const { matchedViewports } = this._matchAllViewports(
+ stage,
+ options,
+ new Map()
+ );
+ const activation = stage.stageActivation || {};
+ if (this.matchActivation(matchedViewports, activation.passive, 0)) {
+ if (this.matchActivation(matchedViewports, activation.enabled, 1)) {
+ stage.status = 'enabled';
+ } else {
+ stage.status = 'passive';
+ }
+ } else {
+ stage.status = 'disabled';
+ }
+ }
+
+ this._broadcastEvent(this.EVENTS.STAGE_ACTIVATION, {
+ protocol: this.protocol,
+ stages: this.protocol.stages,
+ });
+ }
+
+ private _findStageIndex(
+ options = null as HangingProtocol.SetProtocolOptions
+ ): number | void {
+ const stageId = options?.stageId;
+ const protocol = this.protocol;
+ const stages = protocol.stages;
+
+ if (stageId) {
+ for (let i = 0; i < stages.length; i++) {
+ const stage = stages[i];
+ if (stage.id === stageId && stage.status !== 'disabled') return i;
+ }
+ return;
+ }
+
+ const stageIndex = options?.stageIndex;
+ if (stageIndex !== undefined) {
+ return stages[stageIndex]?.status !== 'disabled' ? stageIndex : undefined;
+ }
+
+ let firstNotDisabled: number;
+
+ for (let i = 0; i < stages.length; i++) {
+ if (stages[i].status === 'enabled') return i;
+ if (firstNotDisabled === undefined && stages[i].status !== 'disabled') {
+ firstNotDisabled = i;
+ }
+ }
+
+ return firstNotDisabled;
+ }
+
private _setProtocol(
protocol: HangingProtocol.Protocol,
options = null as HangingProtocol.SetProtocolOptions
): void {
- this.stage = 0;
- const oldProtocol = this.protocol;
- this.protocol = this._copyProtocol(protocol);
-
- const { imageLoadStrategy } = protocol;
- if (imageLoadStrategy) {
- // check if the imageLoadStrategy is a valid strategy
- if (
- this.registeredImageLoadStrategies[imageLoadStrategy] instanceof
- Function
- ) {
- this.activeImageLoadStrategyName = imageLoadStrategy;
- }
- }
+ const old = this.getActiveProtocol();
try {
+ if (!this.protocol || this.protocol.id !== protocol.id) {
+ this.stageIndex = options?.stageIndex || 0;
+ this.protocol = this._copyProtocol(protocol);
+
+ const { imageLoadStrategy } = protocol;
+ if (imageLoadStrategy) {
+ // check if the imageLoadStrategy is a valid strategy
+ if (
+ this.registeredImageLoadStrategies[imageLoadStrategy] instanceof
+ Function
+ ) {
+ this.activeImageLoadStrategyName = imageLoadStrategy;
+ }
+ }
+
+ this._updateStageStatus(options);
+ }
+
+ const stage = this._findStageIndex(options);
+ if (stage === undefined) {
+ throw new Error(
+ `Can't find applicable stage ${protocol.id} ${options?.stageIndex}`
+ );
+ }
+ this.stageIndex = stage as number;
this._updateViewports(options);
} catch (error) {
- this.protocol = oldProtocol;
+ console.log(error);
+ Object.assign(this, old);
throw new Error(error);
}
- this._broadcastChange(this.EVENTS.PROTOCOL_CHANGED, {
- viewportMatchDetails: this.viewportMatchDetails,
- displaySetMatchDetails: this.displaySetMatchDetails,
- hpAlreadyApplied: this.hpAlreadyApplied,
- protocol: this.protocol,
- });
+ if (options?.restoreProtocol !== true) {
+ this._broadcastEvent(HangingProtocolService.EVENTS.PROTOCOL_CHANGED, {
+ viewportMatchDetails: this.viewportMatchDetails,
+ displaySetMatchDetails: this.displaySetMatchDetails,
+ protocol: this.protocol,
+ stageIdx: this.stageIndex,
+ stage: this.protocol.stages[this.stageIndex],
+ activeStudyUID: this.activeStudy?.StudyInstanceUID,
+ });
+ } else {
+ this._broadcastEvent(HangingProtocolService.EVENTS.PROTOCOL_RESTORED, {
+ protocol: this.protocol,
+ stageIdx: this.stageIndex,
+ stage: this.protocol.stages[this.stageIndex],
+ activeStudyUID: this.activeStudy?.StudyInstanceUID,
+ });
+ }
+ }
+
+ public getStageIndex(protocolId: string, options): number {
+ const protocol = this.getProtocolById(protocolId);
+ const { stageId, stageIndex } = options;
+ if (stageId !== undefined) {
+ return protocol.stages.findIndex(it => it.id === stageId);
+ }
+ if (stageIndex !== undefined) return stageIndex;
+ return 0;
}
/**
@@ -705,7 +883,35 @@ class HangingProtocolService {
* @returns {*} The Stage model for the currently displayed Stage
*/
_getCurrentStageModel() {
- return this.protocol.stages[this.stage];
+ return this.protocol.stages[this.stageIndex];
+ }
+
+ /**
+ * Gets a new viewport object for missing viewports. Used to fill
+ * new viewports.
+ * Looks first for the stage, to see if there is a missingViewport defined,
+ * and secondly looks to the overall protocol.
+ *
+ * Returns a matchInfo object, which can be used to create the actual
+ * viewport object (which this class knows nothing about).
+ */
+ public getMissingViewport(
+ protocolId: string,
+ stageIdx: number,
+ options
+ ): HangingProtocol.ViewportMatchDetails {
+ if (this.protocol.id !== protocolId) {
+ throw new Error(
+ `Currently applied protocol ${this.protocol.id} is different from ${protocolId}`
+ );
+ }
+ const protocol = this.protocol;
+ const stage = protocol.stages[stageIdx];
+ const defaultViewport = stage.defaultViewport || protocol.defaultViewport;
+ if (!defaultViewport) return;
+
+ const useViewport = { ...defaultViewport };
+ return this._matchViewport(useViewport, options);
}
/**
@@ -719,35 +925,10 @@ class HangingProtocolService {
// each time we are updating the viewports, we need to reset the
// matching applied
- // Todo: we can have more intelligent invalidation of the hpAlreadyApplied
- // since sometimes we are just updating some viewports and the rest are
- // already applied (e.g. when we are using the drag and drop)
- this.hpAlreadyApplied = new Map();
this.viewportMatchDetails = new Map();
this.displaySetMatchDetails = new Map();
this.customImageLoadPerformed = false;
- if (options) {
- // if the options are defined, we can fill in the displaySetMatchDetails
- // but we need to also check that any displaySetInstanceUIDs that are
- // provided either at viewport level or at the protocol level SATISFIES
- // the required seriesMatching criteria species in the protocol. Otherwise
- // we need to throw an error. This way protocols become more strict and
- // for instance don't allow drag and drop of displaySets that don't match
- // (in MPR protocol we specify in the displaysetSelector that the displaySet
- // to be used should be reconstructable. Or you can specify that the displaySet
- // should be a localizer only for a protocol)
-
- // options can be either an object with { displaySetInstanceUIDs, viewportOptions, displaySetOptions }
- // options (global options), or an object of objects with viewportIndex
- // as the key and the { displaySetInstanceUIDs, viewportOptions, displaySetOptions } as the value
-
- // The following function will update the displaySetMatchDetails in place
- this._updateMatchByOptions(this.protocol, options);
- }
-
- const { displaySetSelectors = {} } = this.protocol;
-
// Retrieve the current stage
const stageModel = this._getCurrentStageModel();
@@ -774,234 +955,200 @@ class HangingProtocolService {
const { columns: numCols, rows: numRows, layoutOptions = [] } = layoutProps;
- this._broadcastChange(this.EVENTS.NEW_LAYOUT, {
+ this._broadcastEvent(this.EVENTS.NEW_LAYOUT, {
layoutType,
numRows,
numCols,
layoutOptions,
});
- // Matching the displaySets
- for (
- let viewportIndex = 0;
- viewportIndex < numCols * numRows;
- viewportIndex++
- ) {
- if (viewportIndex >= stageModel.viewports.length) {
- // If we have more viewports than display sets, stop here.
- break;
+ // Loop through each viewport
+ this._matchAllViewports(this.protocol.stages[this.stageIndex], options);
+ }
+
+ private _matchAllViewports(
+ stageModel: HangingProtocol.ProtocolStage,
+ options?: HangingProtocol.SetProtocolOptions,
+ viewportMatchDetails = this.viewportMatchDetails,
+ displaySetMatchDetails = this.displaySetMatchDetails
+ ): {
+ matchedViewports: number;
+ viewportMatchDetails: Map;
+ displaySetMatchDetails: Map;
+ } {
+ let matchedViewports = 0;
+ stageModel.viewports.forEach((viewport, viewportIndex) => {
+ const matchDetails = this._matchViewport(
+ viewport,
+ options,
+ viewportMatchDetails,
+ displaySetMatchDetails
+ );
+ if (matchDetails) {
+ if (
+ matchDetails.displaySetsInfo?.length &&
+ matchDetails.displaySetsInfo[0].displaySetInstanceUID
+ ) {
+ matchedViewports++;
+ } else {
+ console.log(
+ 'Adding an empty set of display sets for mapping purposes'
+ );
+ matchDetails.displaySetsInfo = viewport.displaySets.map(it => ({
+ displaySetOptions: it,
+ }));
+ }
+ viewportMatchDetails.set(viewportIndex, matchDetails);
}
+ });
+ return { matchedViewports, viewportMatchDetails, displaySetMatchDetails };
+ }
- const viewport = stageModel.viewports[viewportIndex];
-
- for (const displaySet of viewport.displaySets) {
- const { id: displaySetId } = displaySet;
- // skip matching if already matched (e.g. by options above)
- if (this.displaySetMatchDetails.has(displaySetId)) {
- continue;
+ protected findDeduplicatedMatchDetails(
+ matchDetails: HangingProtocol.DisplaySetMatchDetails,
+ offset: number,
+ options: HangingProtocol.SetProtocolOptions = {}
+ ): HangingProtocol.DisplaySetMatchDetails {
+ if (!matchDetails) return;
+ if (offset === 0) return matchDetails;
+ const { matchingScores = [] } = matchDetails;
+ if (offset === -1) {
+ const { inDisplay } = options;
+ if (!inDisplay) return matchDetails;
+ for (let i = 0; i < matchDetails.matchingScores.length; i++) {
+ if (
+ inDisplay.indexOf(
+ matchDetails.matchingScores[i].displaySetInstanceUID
+ ) === -1
+ ) {
+ const match = matchDetails.matchingScores[i];
+ return match.matchingScore > 0
+ ? { matchingScores, ...matchDetails.matchingScores[i] }
+ : null;
}
- const displaySetSelector = displaySetSelectors[displaySetId];
+ }
+ return;
+ }
+ const matchFound = matchingScores[offset];
+ return matchFound ? { ...matchFound, matchingScores } : undefined;
+ }
- if (!displaySetSelector) {
- console.warn('No display set selector for', displaySetId);
- continue;
- }
- const { bestMatch, matchingScores } = this._matchImages(
- displaySetSelector
- );
- this.displaySetMatchDetails.set(displaySetId, bestMatch);
+ protected validateDisplaySetSelectMatch(
+ match: HangingProtocol.DisplaySetMatchDetails,
+ id: string,
+ displaySetUID: string
+ ): void {
+ if (match.displaySetInstanceUID === displaySetUID) return;
+ if (!match.matchingScores) {
+ throw new Error('No matchingScores found in ' + match);
+ }
+ for (const subMatch of match.matchingScores) {
+ if (subMatch.displaySetInstanceUID === displaySetUID) return;
+ }
+ throw new Error(
+ `Reused viewport details ${id} with ds ${displaySetUID} not valid`
+ );
+ }
- if (bestMatch) {
- bestMatch.matchingScores = matchingScores;
- }
+ protected _matchViewport(
+ viewport: HangingProtocol.Viewport,
+ options: HangingProtocol.SetProtocolOptions,
+ viewportMatchDetails = this.viewportMatchDetails,
+ displaySetMatchDetails = this.displaySetMatchDetails
+ ): HangingProtocol.ViewportMatchDetails {
+ const displaySetSelectorMap = options?.displaySetSelectorMap || {};
+ const { displaySetSelectors = {} } = this.protocol;
+
+ // Matching the displaySets
+ for (const displaySet of viewport.displaySets) {
+ const { id: displaySetId } = displaySet;
+
+ const displaySetSelector = displaySetSelectors[displaySetId];
+
+ if (!displaySetSelector) {
+ console.warn('No display set selector for', displaySetId);
+ continue;
+ }
+ const { bestMatch, matchingScores } = this._matchImages(
+ displaySetSelector
+ );
+ displaySetMatchDetails.set(displaySetId, bestMatch);
+
+ if (bestMatch) {
+ bestMatch.matchingScores = matchingScores;
}
}
// Loop through each viewport
- stageModel.viewports.forEach((viewport, viewportIndex) => {
- const { viewportOptions = {} } = viewport;
- this.hpAlreadyApplied.set(viewportIndex, false);
- // DisplaySets for the viewport, Note: this is not the actual displaySet,
- // but it is a info to locate the displaySet from the displaySetService
- const displaySetsInfo = [];
- viewport.displaySets.forEach(
- ({ id, displaySetIndex = 0, options: displaySetOptions }) => {
- const viewportDisplaySetMain = this.displaySetMatchDetails.get(id);
- // Use the display set index to allow getting the "next" match, eg
- // matching all display sets, and get the displaySetIndex'th item
- const viewportDisplaySet =
- !viewportDisplaySetMain || displaySetIndex === 0
- ? viewportDisplaySetMain
- : viewportDisplaySetMain.matchingScores[displaySetIndex];
+ const { viewportOptions = DEFAULT_VIEWPORT_OPTIONS } = viewport;
+ // DisplaySets for the viewport, Note: this is not the actual displaySet,
+ // but it is a info to locate the displaySet from the displaySetService
+ const displaySetsInfo = [];
+ const { StudyInstanceUID: activeStudyUID } = this.activeStudy;
+ viewport.displaySets.forEach(displaySetOptions => {
+ const { id, matchedDisplaySetsIndex = 0 } = displaySetOptions;
+ const reuseDisplaySetUID =
+ id &&
+ displaySetSelectorMap[
+ `${activeStudyUID}:${id}:${matchedDisplaySetsIndex || 0}`
+ ];
+ const viewportDisplaySetMain = this.displaySetMatchDetails.get(id);
- if (viewportDisplaySet) {
- const {
- SeriesInstanceUID,
- displaySetInstanceUID,
- } = viewportDisplaySet;
+ const viewportDisplaySet = this.findDeduplicatedMatchDetails(
+ viewportDisplaySetMain,
+ matchedDisplaySetsIndex,
+ options
+ );
- const displaySetInfo: HangingProtocol.DisplaySetInfo = {
- SeriesInstanceUID,
- displaySetInstanceUID,
- displaySetOptions,
- };
+ // Use the display set provided instead
+ if (reuseDisplaySetUID) {
+ if (viewportOptions.allowUnmatchedView !== true) {
+ this.validateDisplaySetSelectMatch(
+ viewportDisplaySet,
+ id,
+ reuseDisplaySetUID
+ );
+ }
+ const displaySetInfo: HangingProtocol.DisplaySetInfo = {
+ displaySetInstanceUID: reuseDisplaySetUID,
+ displaySetOptions,
+ };
- displaySetsInfo.push(displaySetInfo);
- } else {
- console.warn(
- `
+ displaySetsInfo.push(displaySetInfo);
+ return;
+ }
+
+ // Use the display set index to allow getting the "next" match, eg
+ // matching all display sets, and get the matchedDisplaySetsIndex'th item
+ if (viewportDisplaySet) {
+ const { displaySetInstanceUID } = viewportDisplaySet;
+
+ const displaySetInfo: HangingProtocol.DisplaySetInfo = {
+ displaySetInstanceUID,
+ displaySetOptions,
+ };
+
+ displaySetsInfo.push(displaySetInfo);
+ } else {
+ console.warn(
+ `
The hanging protocol viewport is requesting to display ${id} displaySet that is not
matched based on the provided criteria (e.g. matching rules).
`
- );
- }
- }
- );
-
- this.viewportMatchDetails.set(viewportIndex, {
- viewportOptions,
- displaySetsInfo,
- });
- });
- }
-
- _updateMatchByOptions(
- protocol: Protocol,
- options: HangingProtocol.SetProtocolOptions
- ) {
- const { displaySetService } = this._servicesManager.services;
-
- if (options.displaySetInstanceUIDs) {
- this._updateGlobalMatchByOptions(
- options as HangingProtocol.GlobalProtocolOptions,
- protocol,
- displaySetService
- );
- return;
- }
-
- // Todo: I don't think we need the following anymore, since the drag and
- // drop has been reworked to ask HangingProtocolService to check
- // which viewports need to be updated. I don't think there is other use cases
- // other than drag and drop and thumbnails double click that will specify
- // options at viewport level. if there are the following code will need to be
- // uncommented and tested.
- this._updateViewportSpecificMatchByOptions(
- options as HangingProtocol.ViewportSpecificProtocolOptions,
- protocol
- );
- }
-
- private _updateViewportSpecificMatchByOptions(
- options: HangingProtocol.ViewportSpecificProtocolOptions,
- protocol: HangingProtocol.Protocol
- ) {
- const { displaySetService } = this._servicesManager.services;
- const { displaySetSelectors = {} } = protocol;
- const protocolViewports = protocol.stages[this.stage].viewports;
-
- // if we get here, we can fill in the displaySetMatchDetails
- for (const viewportIndex in options) {
- const displaySetAndViewportOptions = options[viewportIndex];
-
- const protocolViewport = protocolViewports[viewportIndex];
- // if the protocol already has the viewport
- if (protocolViewport) {
- // if the protocol has a viewport with specific displaySets, we need to check if the
- // displaySetInstanceUIDs are allowed by the protocol
- this._validateViewportSpecificMatch(
- displaySetAndViewportOptions,
- protocolViewport,
- displaySetSelectors
);
-
- displaySetAndViewportOptions.displaySetInstanceUIDs.forEach(
- (displaySetInstanceUID, index) => {
- const displaySet = displaySetService.getDisplaySetByUID(
- displaySetInstanceUID
- );
-
- const displaySetId = protocolViewport.displaySets[index].id;
-
- // since we are setting the displaySetMatchDetails for each viewport
- // directly, a side effect is that any other viewport that is referencing
- // the same displaySetId will also be updated with the new
- // displaySetMatchDetails, but sometimes this is not a desired behavior
- // which is why we are using the syncDataForViewports to determine if
- // we should update the displaySetMatchDetails for all the viewports
- // that are affected by the syncDataForViewports
- if (protocol.syncDataForViewports) {
- this.displaySetMatchDetails.set(displaySetId, {
- SeriesInstanceUID: displaySet.SeriesInstanceUID,
- StudyInstanceUID: displaySet.StudyInstanceUID,
- displaySetInstanceUID: displaySet.displaySetInstanceUID,
- matchDetails: {},
- matchingScores: [],
- sortingInfo: {},
- });
- } else {
- // if the protocol does not have the syncDataForViewports, we need to
- // update the displaySetMatchDetails by introducing the displaySetIndex
- // to the displaySetMatchDetails. This way we can match the displaySetInstanceUIDs
- // for the viewportIndex, but also for the other viewports that are affected
- // by the syncDataForViewports
-
- const displaySetSelectorId = `${displaySetId}_${uuidv4()}`;
-
- // update the displaySetId at the viewport
- protocolViewport.displaySets[index].id = displaySetSelectorId;
-
- this.displaySetMatchDetails.set(displaySetSelectorId, {
- SeriesInstanceUID: displaySet.SeriesInstanceUID,
- StudyInstanceUID: displaySet.StudyInstanceUID,
- displaySetInstanceUID: displaySet.displaySetInstanceUID,
- matchDetails: {},
- matchingScores: [],
- sortingInfo: {},
- });
- }
- }
- );
- } else {
- // if the protocol does not have the viewport, we need to create it
- const newViewport = {
- displaySets: [],
- viewportOptions: {},
- };
-
- displaySetAndViewportOptions?.displaySetInstanceUIDs?.forEach(
- (displaySetInstanceUID, index) => {
- const displaySet = displaySetService.getDisplaySetByUID(
- displaySetInstanceUID
- );
-
- const displaySetId = `viewport_${viewportIndex}_displaySet_${index}`;
-
- newViewport.displaySets.push({
- id: displaySetId,
- });
-
- this.displaySetMatchDetails.set(displaySetId, {
- SeriesInstanceUID: displaySet.SeriesInstanceUID,
- StudyInstanceUID: displaySet.StudyInstanceUID,
- displaySetInstanceUID: displaySet.displaySetInstanceUID,
- matchDetails: {},
- matchingScores: [],
- sortingInfo: {},
- });
- }
- );
-
- protocolViewports[viewportIndex] = newViewport;
}
- }
+ });
+ return {
+ viewportOptions,
+ displaySetsInfo,
+ };
}
private _validateViewportSpecificMatch(
displaySetAndViewportOptions: HangingProtocol.DisplaySetAndViewportOptions,
protocolViewport: HangingProtocol.Viewport,
displaySetSelectors: Record
- ) {
+ ): void {
const { displaySetService } = this._servicesManager.services;
const protocolViewportDisplaySets = protocolViewport.displaySets;
const numDisplaySetsToSet =
@@ -1036,110 +1183,6 @@ class HangingProtocolService {
);
}
- private _updateGlobalMatchByOptions(
- options: HangingProtocol.GlobalProtocolOptions,
- protocol: Protocol,
- displaySetService: any
- ) {
- const { displaySetSelectors = {} } = protocol;
- const protocolViewports = protocol.stages[this.stage].viewports;
-
- options = options as HangingProtocol.GlobalProtocolOptions;
- // we need to check each displaySetInstanceUIDs to see if it satisfies the
- // seriesMatching criteria
- options.displaySetInstanceUIDs.forEach(displaySetInstanceUID => {
- const displaySet = displaySetService.getDisplaySetByUID(
- displaySetInstanceUID
- );
-
- // match against all the displaySetSelectors defined in the protocol
- for (const displaySetId in displaySetSelectors) {
- const displaySetSelector = displaySetSelectors[displaySetId];
- this._validateRequiredSelectors(displaySetSelector, displaySet);
- }
- });
-
- // if we get here, we can fill in the displaySetMatchDetails
- // however, there might be a case where we are asked to
- // render multiple displaySets for a single viewport
- // so we need to go back to viewports and start from there
- const newDisplaySetIds: Set = new Set();
-
- // Todo: this currently work for current stage only
- protocolViewports.forEach(viewport => {
- viewport.displaySets.forEach(displaySetInfo => {
- const { id: displaySetId } = displaySetInfo;
- if (!this.displaySetMatchDetails.has(displaySetId)) {
- newDisplaySetIds.add(displaySetId);
- }
- });
- });
-
- // Todo: handle override of the viewport and displaySet options
- Array.from(newDisplaySetIds).forEach((displaySetId, index) => {
- const displaySetInstanceUID = options.displaySetInstanceUIDs[index];
-
- const displaySet = displaySetService.getDisplaySetByUID(
- displaySetInstanceUID
- );
-
- this.displaySetMatchDetails.set(displaySetId, {
- SeriesInstanceUID: displaySet.SeriesInstanceUID,
- StudyInstanceUID: displaySet.StudyInstanceUID,
- displaySetInstanceUID: displaySet.displaySetInstanceUID,
- matchDetails: {},
- matchingScores: [],
- sortingInfo: {},
- });
- });
-
- /*
- Todo: make it work for the case where the number of displaySets
- to set is not equal to the number of displaySets in the protocol, we can modify
- the protocol to have the same number of displaySets for each viewport
-
- if (newDisplaySetIds.size !== numberOfDisplaySetsToSet) {
- // the remaining ones to set
- const remainingDisplaySetMatches = options.slice(
- newDisplaySetIds.size,
- numberOfDisplaySetsToSet
- );
-
- protocol[this.stage].viewports.forEach(viewport => {
- const { displaySets } = viewport;
-
- // push the displaySetsToSet to the end of the displaySets array
-
- remainingDisplaySetMatches.forEach(({ displaySetInstanceUID }) => {
- displaySets.push({
- id: displaySetInstanceUID,
- });
- });
- });
-
- remainingDisplaySetMatches.forEach(({ displaySetInstanceUID }) => {
- const displaySet = displaySetService.getDisplaySetByUID(
- displaySetInstanceUID
- );
-
- this.displaySetMatchDetails.set(displaySetInstanceUID, {
- SeriesInstanceUID: displaySet.SeriesInstanceUID,
- StudyInstanceUID: displaySet.StudyInstanceUID,
- displaySetInstanceUID: displaySet.displaySetInstanceUID,
- matchDetails: {},
- matchingScores: [],
- sortingInfo: {},
- });
- });
- }
-
- // Todo: this has a bug where if the protocol defines only one displaySet,
- // but renders a fusion, it cannot go back to one displaySet since its
- // viewport.displaySets.length is 2 and it should remove the second one
- // later
- */
- }
-
private _validateRequiredSelectors(
displaySetSelector: HangingProtocol.DisplaySetSelector,
displaySet: any
@@ -1159,36 +1202,39 @@ class HangingProtocolService {
}
}
- _validateOptions(options: HangingProtocol.SetProtocolOptions) {
+ _validateOptions(options: HangingProtocol.SetProtocolOptions): void {
const { displaySetService } = this._servicesManager.services;
-
- if (options.displaySetInstanceUIDs) {
- options = options as HangingProtocol.GlobalProtocolOptions;
-
- options.displaySetInstanceUIDs.forEach(displaySetInstanceUID => {
- const displaySet = displaySetService.getDisplaySetByUID(
- displaySetInstanceUID
- );
-
- if (!displaySet) {
- throw new Error(
- `The displaySetInstanceUID ${displaySetInstanceUID} is not found in the displaySetService`
+ const { displaySetSelectorMap } = options;
+ if (displaySetSelectorMap) {
+ Object.entries(displaySetSelectorMap).forEach(
+ ([key, displaySetInstanceUID]) => {
+ const displaySet = displaySetService.getDisplaySetByUID(
+ displaySetInstanceUID
);
+
+ if (!displaySet) {
+ throw new Error(
+ `The displaySetInstanceUID ${displaySetInstanceUID} is not found in the displaySetService`
+ );
+ }
}
- });
+ );
}
}
// Match images given a list of Studies and a Viewport's image matching reqs
- _matchImages(displaySetRules) {
+ protected _matchImages(displaySetRules) {
// TODO: matching is applied on study and series level, instance
// level matching needs to be added in future
// Todo: handle fusion viewports by not taking the first displaySet rule for the viewport
- const { studyMatchingRules = [], seriesMatchingRules } = displaySetRules;
+ const {
+ id,
+ studyMatchingRules = [],
+ seriesMatchingRules,
+ } = displaySetRules;
const matchingScores = [];
- let highestStudyMatchingScore = 0;
let highestSeriesMatchingScore = 0;
console.log(
@@ -1196,7 +1242,10 @@ class HangingProtocolService {
studyMatchingRules,
seriesMatchingRules
);
+ const matchActiveOnly = this.protocol.numberOfPriorsReferenced === -1;
this.studies.forEach(study => {
+ // Skip non-active if active only
+ if (matchActiveOnly && this.activeStudy !== study) return;
const studyDisplaySets = this.displaySets.filter(
it => it.StudyInstanceUID === study.StudyInstanceUID
);
@@ -1211,21 +1260,18 @@ class HangingProtocolService {
return;
}
- highestStudyMatchingScore = studyMatchDetails.score;
-
this.debug(
'study',
study.StudyInstanceUID,
'display sets #',
- this.displaySets.length
+ studyDisplaySets.length
);
- this.displaySets.forEach(displaySet => {
+ studyDisplaySets.forEach(displaySet => {
const {
StudyInstanceUID,
SeriesInstanceUID,
displaySetInstanceUID,
} = displaySet;
- if (StudyInstanceUID !== study.StudyInstanceUID) return;
const seriesMatchDetails = this.protocolEngine.findMatch(
displaySet,
seriesMatchingRules,
@@ -1290,7 +1336,7 @@ class HangingProtocolService {
});
if (matchingScores.length === 0) {
- console.log('No match found');
+ console.log('No match found', id);
}
// Sort the matchingScores
@@ -1332,7 +1378,7 @@ class HangingProtocolService {
_isNextStageAvailable() {
const numberOfStages = this._getNumProtocolStages();
- return this.stage + 1 < numberOfStages;
+ return this.stageIndex + 1 < numberOfStages;
}
/**
@@ -1340,7 +1386,7 @@ class HangingProtocolService {
* @return {Boolean} True if previous stage is available or false otherwise
*/
_isPreviousStageAvailable(): boolean {
- return this.stage - 1 >= 0;
+ return this.stageIndex - 1 >= 0;
}
/**
@@ -1350,31 +1396,45 @@ class HangingProtocolService {
* @param {Integer} stageAction An integer value specifying whether next (1) or previous (-1) stage
* @return {Boolean} True if new stage has set or false, otherwise
*/
- _setCurrentProtocolStage(stageAction): boolean {
- //resetting the applied protocols
- this.hpAlreadyApplied = new Map();
+ _setCurrentProtocolStage(
+ stageAction: number,
+ options: HangingProtocol.SetProtocolOptions
+ ): boolean {
// Check if previous or next stage is available
- if (stageAction === -1 && !this._isPreviousStageAvailable()) {
- return false;
- } else if (stageAction === 1 && !this._isNextStageAvailable()) {
+ let i;
+ for (
+ i = this.stageIndex + stageAction;
+ i >= 0 && i < this.protocol.stages.length;
+ i += stageAction
+ ) {
+ if (this.protocol.stages[i].status !== 'disabled') {
+ break;
+ }
+ }
+ if (i < 0 || i >= this.protocol.stages.length) {
return false;
}
// Sets the new stage
- this.stage += stageAction;
+ this.stageIndex = i;
// Log the new stage
- this.debug(`ProtocolEngine::setCurrentProtocolStage stage = ${this.stage}`);
+ this.debug(
+ `ProtocolEngine::setCurrentProtocolStage stage = ${this.stageIndex}`
+ );
// Since stage has changed, we need to update the viewports
// and redo matchings
- this._updateViewports();
+ this._updateViewports(options);
- // Everything went well
- this._broadcastChange(this.EVENTS.STAGE_CHANGE, {
+ // Everything went well, broadcast the update, exactly identical to
+ // HP applied
+ this._broadcastEvent(this.EVENTS.PROTOCOL_CHANGED, {
viewportMatchDetails: this.viewportMatchDetails,
- hpAlreadyApplied: this.hpAlreadyApplied,
displaySetMatchDetails: this.displaySetMatchDetails,
+ protocol: this.protocol,
+ stageIdx: this.stageIndex,
+ stage: this.protocol.stages[this.stageIndex],
});
return true;
}
@@ -1388,164 +1448,7 @@ class HangingProtocolService {
}
}
- /**
- * Broadcasts hanging protocols changes.
- *
- * @param {string} eventName The event name.add
- * @param {object} eventData.source The measurement source.
- * @param {object} eventData.measurement The measurement.
- * @param {boolean} eventData.notYetUpdatedAtSource True if the measurement was edited
- * within the measurement service and the source needs to update.
- * @return void
- */
- // Todo: why do we have a separate broadcastChange function here?
- _broadcastChange(eventName, eventData) {
- const hasListeners = Object.keys(this.listeners).length > 0;
- const hasCallbacks = Array.isArray(this.listeners[eventName]);
-
- if (hasListeners && hasCallbacks) {
- this.listeners[eventName].forEach(listener => {
- listener.callback(eventData);
- });
- }
- }
-
_copyProtocol(protocol: Protocol) {
return JSON.parse(JSON.stringify(protocol));
}
-
- /**
- _setProtocolLayoutOptions(protocol: Protocol, { numRows, numCols }) {
- const layoutOptions = [];
- const protocolStage = protocol.stages[this.stage];
- const numViewports = protocolStage.viewports.length;
-
- for (let i = 0; i < numViewports; i++) {
- const { row, col } = unravelIndex(i, numRows, numCols);
- const w = 1 / numCols;
- const h = 1 / numRows;
- const xPos = col * w;
- const yPos = row * h;
-
- layoutOptions[i] = {
- width: w,
- height: h,
- x: xPos,
- y: yPos,
- };
- }
-
- // Todo: handle the case where the viewportStructure is not a grid
- protocolStage.viewportStructure.properties.rows = numRows;
- protocolStage.viewportStructure.properties.columns = numCols;
- protocolStage.viewportStructure.properties.layoutOptions = {
- ...layoutOptions,
- };
- }
-
- _getUpdatedProtocol({
- numRows,
- numCols,
- protocol: oldProtocol,
- }: {
- numRows: number;
- numCols: number;
- protocol: Protocol;
- }): Protocol {
- let newProtocol = this._copyProtocol(oldProtocol);
-
- const protocolStage = newProtocol.stages[this.stage];
-
- // The following commented code is a potential improvements to the
- // hanging protocols to intelligently switch between number of rows
- // and columns based on the old state of the protocol. For instance,
- // changing from 2x2 to 2x3 (adding a column) right now reorders the viewports
- // as well, however, it should just add one empty column to the right
- // and leave the rest of the viewports in place. This sounds amazing,
- // but comes at a cost (which we need to tackle later). The cost is that
- // the viewportIndex will change during this smart change of layout. In
- // the example above the viewport at index (2) bottom left, will now be
- // at index (3) bottom left, and since react will re-render the viewport
- // it will reset the viewport's state such as (zoom, pan, windowLevel, imageIndex)
- // and the user will lose their current state. In addition, all our viewportIds
- // are dependent on the viewportIndex, so we will need to update all the viewportIds
- // as well, and you can see how this can get out of hand. Later, we should
- // tackle this problem and make the smart change of layout work.
-
- // const { rows: oldNumRows, columns: oldNumCols } = newProtocol.stages[
- // this.stage
- // ].viewportStructure.properties;
-
- // const oldToNewViewportIndices = getGridMapping(
- // {
- // numRows: oldNumRows,
- // numCols: oldNumCols,
- // },
- // {
- // numRows,
- // numCols,
- // }
- // );
-
- const protocolViewports = protocolStage.viewports;
-
- if (protocolViewports.length < numRows * numCols) {
- const newViewports = [];
-
- for (let i = protocolViewports.length; i < numRows * numCols; i++) {
- newViewports.push({
- viewportOptions: {
- toolGroupId: 'default',
- viewportType: 'stack',
- },
- displaySets: [
- {
- id: `viewport-${i}`,
- },
- ],
- });
- }
-
- protocolStage.viewports = [...protocolViewports, ...newViewports];
- } else if (protocolViewports.length > numRows * numCols) {
- // remove viewports that are not needed
- protocolStage.viewports = protocolViewports.slice(0, numRows * numCols);
- }
-
- // update the displaySetMatchDetails to reflect the new viewports
- const toRemove = [];
- this.displaySetMatchDetails.forEach(
- (displaySetMatchDetail, displaySetId) => {
- // if the displaySetId is not referenced in the protocolStage viewports
- // we can remove it
- const found = protocolStage.viewports.find(viewport => {
- return viewport.displaySets.find(displaySet => {
- return displaySet.id === displaySetId;
- });
- });
-
- if (!found) {
- toRemove.push(displaySetId);
- }
- }
- );
-
- toRemove.forEach(displaySetId => {
- this.displaySetMatchDetails.delete(displaySetId);
- });
-
- this._setProtocolLayoutOptions(newProtocol, { numRows, numCols });
- newProtocol = this._validateProtocol(newProtocol);
-
- // Todo: not sure if we need to reset here, or we can smartly update the
- // viewportMatchDetails and hpAlreadyApplied maps
- this.hpAlreadyApplied = new Map();
- this.viewportMatchDetails = new Map();
-
- return newProtocol;
- }
- */
}
-
-export default HangingProtocolService;
-export { EVENTS };
diff --git a/platform/core/src/services/HangingProtocolService/ProtocolEngine.js b/platform/core/src/services/HangingProtocolService/ProtocolEngine.js
index 5cfdf1264..b3c18ab40 100644
--- a/platform/core/src/services/HangingProtocolService/ProtocolEngine.js
+++ b/platform/core/src/services/HangingProtocolService/ProtocolEngine.js
@@ -81,6 +81,16 @@ export default class ProtocolEngine {
});
}
+ /**
+ * finds the match results against the given display set or
+ * study instance by testing the given rules against this, and using
+ * the provided options for testing.
+ *
+ * @param {*} metaData to match against as primary value
+ * @param {*} rules to apply
+ * @param {*} options are additional values that can be used for matching
+ * @returns
+ */
findMatch(metaData, rules, options) {
return HPMatcher.match(
metaData,
@@ -109,7 +119,7 @@ export default class ProtocolEngine {
let rules = protocol.protocolMatchingRules.slice();
if (!rules || !rules.length) {
console.warn(
- 'ProtocolEngine::findMatchByStudy no matching rules - specify protocolMatchingRules',
+ 'ProtocolEngine::findMatchByStudy no matching rules - specify protocolMatchingRules for',
protocol.id
);
return;
diff --git a/platform/core/src/services/HangingProtocolService/lib/validator.js b/platform/core/src/services/HangingProtocolService/lib/validator.js
index 711ff01b9..498ae3201 100644
--- a/platform/core/src/services/HangingProtocolService/lib/validator.js
+++ b/platform/core/src/services/HangingProtocolService/lib/validator.js
@@ -14,6 +14,41 @@ validate.validators.doesNotEqual = function(value, options, key) {
}
};
+// Ignore case contains.
+// options testValue MUST be in lower case already, otherwise it won't match
+validate.validators.containsI = function (value, options, key) {
+ const testValue = options?.value ?? options;
+ if (Array.isArray(value)) {
+ if (
+ value.some(
+ item => !validate.validators.containsI(item.toLowerCase(), options, key)
+ )
+ ) {
+ return undefined;
+ }
+ return `No item of ${value.join(',')} contains ${JSON.stringify(
+ testValue
+ )}`;
+ }
+ if (Array.isArray(testValue)) {
+ if (
+ testValue.some(
+ subTest => !validate.validators.containsI(value, subTest, key)
+ )
+ ) {
+ return;
+ }
+ return `${key} must contain at least one of ${testValue.join(',')}`;
+ }
+ if (
+ testValue &&
+ value.indexOf &&
+ value.toLowerCase().indexOf(testValue) === -1
+ ) {
+ return key + 'must contain any case of' + testValue;
+ }
+};
+
validate.validators.contains = function(value, options, key) {
const testValue = options?.value ?? options;
if (Array.isArray(value)) {
diff --git a/platform/core/src/services/HangingProtocolService/lib/validator.test.js b/platform/core/src/services/HangingProtocolService/lib/validator.test.js
index 5566e97a7..67b7ac52e 100644
--- a/platform/core/src/services/HangingProtocolService/lib/validator.test.js
+++ b/platform/core/src/services/HangingProtocolService/lib/validator.test.js
@@ -3,9 +3,10 @@ import validate from './validator.js';
describe('validator', () => {
const attributeMap = {
str: 'string',
+ upper: 'UPPER',
num: 3,
nullValue: null,
- list: ['abc', 'def'],
+ list: ['abc', 'def', 'GHI'],
};
const options = {
@@ -35,6 +36,37 @@ describe('validator', () => {
});
});
+ describe('containsI', () => {
+ it('returns match any list contains case insensitive', () => {
+ expect(
+ validate(attributeMap, { upper: { containsI: ['bye', 'pre'] } }, [
+ options,
+ ])
+ ).not.toBeUndefined();
+ expect(
+ validate(attributeMap, { list: { containsI: 'hi' } }, [options])
+ ).toBeUndefined();
+ expect(
+ validate(attributeMap, { list: { containsI: ['hi', 'bye'] } }, [
+ options,
+ ])
+ ).toBeUndefined();
+ expect(
+ validate(attributeMap, { list: { containsI: ['bye', 'hi'] } }, [
+ options,
+ ])
+ ).toBeUndefined();
+ expect(
+ validate(attributeMap, { list: { containsI: ['ig', 'hi'] } }, [options])
+ ).toBeUndefined();
+ expect(
+ validate(attributeMap, { upper: { containsI: ['bye', 'per'] } }, [
+ options,
+ ])
+ ).toBeUndefined();
+ });
+ });
+
describe('equals', () => {
it('returned undefined on equals', () => {
expect(
diff --git a/platform/core/src/services/MeasurementService/MeasurementService.ts b/platform/core/src/services/MeasurementService/MeasurementService.ts
index 1fb9550f2..3a89d2094 100644
--- a/platform/core/src/services/MeasurementService/MeasurementService.ts
+++ b/platform/core/src/services/MeasurementService/MeasurementService.ts
@@ -459,7 +459,12 @@ class MeasurementService extends PubSubService {
log.warn(`Measurement ID not found. Generating UID: ${internalUID}`);
}
+ const annotationData = data.annotation.data;
+
const newMeasurement = {
+ finding: annotationData.finding,
+ findingSites: annotationData.findingSites,
+ site: annotationData.findingSites?.[0],
...measurement,
modifiedTimestamp: Math.floor(Date.now() / 1000),
uid: internalUID,
@@ -472,7 +477,7 @@ class MeasurementService extends PubSubService {
measurement: newMeasurement,
});
} else {
- log.info(`Measurement added.`, newMeasurement);
+ log.info('Measurement added', newMeasurement);
this.measurements[internalUID] = newMeasurement;
this._broadcastEvent(this.EVENTS.RAW_MEASUREMENT_ADDED, {
source,
@@ -519,9 +524,14 @@ class MeasurementService extends PubSubService {
let measurement = {};
try {
const sourceMappings = this.mappings[source.uid];
- const { toMeasurementSchema } = sourceMappings.find(
+ const sourceMapping = sourceMappings.find(
mapping => mapping.annotationType === annotationType
);
+ if (!sourceMapping) {
+ console.log('No source mapping', source);
+ return;
+ }
+ const { toMeasurementSchema } = sourceMapping;
/* Convert measurement */
measurement = toMeasurementSchema(sourceAnnotationDetail);
@@ -548,26 +558,27 @@ class MeasurementService extends PubSubService {
);
}
+ const oldMeasurement = this.measurements[internalUID];
+
const newMeasurement = {
+ ...oldMeasurement,
...measurement,
modifiedTimestamp: Math.floor(Date.now() / 1000),
uid: internalUID,
};
- if (this.measurements[internalUID]) {
+ if (oldMeasurement) {
// TODO: Ultimately, each annotation should have a selected flag right from the soure.
// For now, it is just added in OHIF here and in setMeasurementSelected.
- newMeasurement.selected = this.measurements[internalUID].selected;
this.measurements[internalUID] = newMeasurement;
if (isUpdate) {
- this._broadcastEvent(this.EVENTS.MEASUREMENT_UPDATED, {
+ this._broadcastEvent(this.EVENTS.MEASUREMENT_UPDATED, {
source,
measurement: newMeasurement,
notYetUpdatedAtSource: false,
});
} else {
log.info('Measurement added.', newMeasurement);
- this.measurements[internalUID] = newMeasurement;
this._broadcastEvent(this.EVENTS.MEASUREMENT_ADDED, {
source,
measurement: newMeasurement,
diff --git a/platform/core/src/services/ServicesManager.ts b/platform/core/src/services/ServicesManager.ts
index ab6b34728..3d2843dbf 100644
--- a/platform/core/src/services/ServicesManager.ts
+++ b/platform/core/src/services/ServicesManager.ts
@@ -1,10 +1,11 @@
import log from './../log.js';
import Services from '../types/Services';
+import CommandsManager from '../classes/CommandsManager';
export default class ServicesManager {
public services: Services = {};
- constructor(commandsManager) {
+ constructor(commandsManager: CommandsManager) {
this._commandsManager = commandsManager;
this.services = {};
this.registeredServiceNames = [];
diff --git a/platform/core/src/services/StateSyncService/StateSyncService.test.js b/platform/core/src/services/StateSyncService/StateSyncService.test.js
new file mode 100644
index 000000000..77c23069a
--- /dev/null
+++ b/platform/core/src/services/StateSyncService/StateSyncService.test.js
@@ -0,0 +1,31 @@
+import StateSyncService from './StateSyncService';
+import log from '../../log';
+
+jest.mock('../../log.js', () => ({
+ info: jest.fn(),
+ warn: jest.fn(),
+ error: jest.fn(),
+}));
+
+const extensionManager = {};
+
+describe('StateSyncService.ts', () => {
+ let stateSyncService;
+
+ let configuration;
+
+ beforeEach(() => {
+ log.warn.mockClear();
+ jest.clearAllMocks();
+ configuration = {};
+ stateSyncService = new StateSyncService({
+ configuration,
+ });
+ });
+
+ describe('init', () => {
+ it('init succeeds', () => {
+ stateSyncService.init(extensionManager);
+ });
+ });
+});
diff --git a/platform/core/src/services/StateSyncService/StateSyncService.ts b/platform/core/src/services/StateSyncService/StateSyncService.ts
new file mode 100644
index 000000000..5a28bc041
--- /dev/null
+++ b/platform/core/src/services/StateSyncService/StateSyncService.ts
@@ -0,0 +1,86 @@
+import { PubSubService } from '../_shared/pubSubServiceInterface';
+import { ExtensionManager } from '../../extensions';
+
+const EVENTS = {};
+
+type Obj = Record;
+
+type StateConfig = {
+ /** clearOnModeExit defines state configuraion that is cleared automatically on
+ * exiting a mode. This clearing occurs after the mode onModeExit,
+ * so it is possible to preserve desired state during exit to be restored
+ * later.
+ */
+ clearOnModeExit?: boolean;
+};
+
+type States = {
+ [key: string]: Obj;
+};
+
+/**
+ */
+export default class StateSyncService extends PubSubService {
+ public static REGISTRATION = {
+ name: 'stateSyncService',
+ create: ({ configuration = {}, commandsManager }) => {
+ return new StateSyncService({ configuration, commandsManager });
+ },
+ };
+
+ extensionManager: ExtensionManager;
+ configuration: Obj;
+ registeredStateSets: {
+ [id: string]: StateConfig;
+ } = {};
+ state: States = {};
+
+ constructor({ configuration }) {
+ super(EVENTS);
+ this.configuration = configuration || {};
+ }
+
+ public init(extensionManager: ExtensionManager): void { }
+
+ /** Registers a new sync store called `id`. The state
+ * defines how the state is stored, and any default clearing of the
+ * state.
+ * A default store has the lifetime of the application.
+ * The other available store is cleared `onModeExit`
+ */
+ public register(id: string, config: StateConfig): void {
+ this.registeredStateSets[id] = config;
+ this.store({ [id]: {} });
+ }
+
+ public getState(): Record {
+ // TODO - return a proxy to this which is not writable in dev mode
+ return this.state;
+ }
+
+ /**
+ * Stores all the new state values contained in states.
+ *
+ * @param states - is an object containing replacement values to store
+ * @returns
+ */
+ public store(states: States): States {
+ Object.keys(states).forEach(stateKey => {
+ if (!this.registeredStateSets[stateKey]) {
+ throw new Error(`No state ${stateKey} registered`);
+ }
+ });
+ this.state = { ...this.state, ...states };
+ return states;
+ }
+
+ public onModeExit(): void {
+ const toReduce = {};
+ for (const [key, value] of Object.entries(this.registeredStateSets)) {
+ if (value.clearOnModeExit) {
+ toReduce[key] = {};
+ }
+ }
+ this.store(toReduce);
+ }
+}
diff --git a/platform/core/src/services/StateSyncService/index.ts b/platform/core/src/services/StateSyncService/index.ts
new file mode 100644
index 000000000..91cc430e5
--- /dev/null
+++ b/platform/core/src/services/StateSyncService/index.ts
@@ -0,0 +1,3 @@
+import StateSyncService from './StateSyncService';
+
+export default StateSyncService;
diff --git a/platform/core/src/services/ToolBarService/ToolbarService.ts b/platform/core/src/services/ToolBarService/ToolbarService.ts
index e9df3ccfa..4a3cf2429 100644
--- a/platform/core/src/services/ToolBarService/ToolbarService.ts
+++ b/platform/core/src/services/ToolBarService/ToolbarService.ts
@@ -1,4 +1,6 @@
import merge from 'lodash.merge';
+import { CommandsManager } from '../../classes';
+import { ExtensionManager } from '../../extensions';
import { PubSubService } from '../_shared/pubSubServiceInterface';
const EVENTS = {
@@ -16,37 +18,31 @@ export default class ToolbarService extends PubSubService {
},
};
- constructor(commandsManager) {
+ buttons: Record = {};
+ state: {
+ primaryToolId: string;
+ toggles: Record;
+ groups: Record;
+ } = { primaryToolId: 'WindowLevel', toggles: {}, groups: {} };
+ buttonSections: Record = {
+ /**
+ * primary: ['Zoom', 'Wwwc'],
+ * secondary: ['Length', 'RectangleRoi']
+ */
+ };
+ _commandsManager: CommandsManager;
+ extensionManager: ExtensionManager;
+
+ constructor(commandsManager: CommandsManager) {
super(EVENTS);
this._commandsManager = commandsManager;
- //
- this.buttons = {};
- this.unsubscriptions = []; // if tools need to unsubscribe from events
- this.buttonSections = {
- /**
- * primary: ['Zoom', 'Wwwc'],
- * secondary: ['Length', 'RectangleRoi']
- */
- };
-
- // TODO: Do we need to track per context? Or do we allow for a mixed
- // definition that adapts based on context?
- this.state = {
- primaryToolId: 'WindowLevel',
- toggles: {
- /* id: true/false */
- },
- groups: {
- /* track most recent click per group...? */
- },
- };
}
- init(extensionManager) {
+ public init(extensionManager: ExtensionManager): void {
this.extensionManager = extensionManager;
}
- reset() {
+ public reset(): void {
this.unsubscriptions.forEach(unsub => unsub());
this.state = {
primaryToolId: 'WindowLevel',
@@ -69,7 +65,7 @@ export default class ToolbarService extends PubSubService {
* used for calling the specified interaction. That is, the command is
* called with {...commandOptions,...options}
*/
- recordInteraction(interaction, options) {
+ recordInteraction(interaction, options?: Record) {
if (!interaction) return;
const commandsManager = this._commandsManager;
const { groupId, itemId, interactionType, commands } = interaction;
@@ -181,6 +177,15 @@ export default class ToolbarService extends PubSubService {
return [this.state.primaryToolId, ...Object.keys(this.state.toggles)];
}
+ /** Sets the toggle state of a button to the isActive state */
+ public setActive(id: string, isActive: boolean): void {
+ if (isActive) {
+ this.state.toggles[id] = true;
+ } else {
+ delete this.state.toggles[id];
+ }
+ }
+
setButton(id, button) {
if (this.buttons[id]) {
this.buttons[id] = merge(this.buttons[id], button);
diff --git a/platform/core/src/services/ViewportGridService/ViewportGridService.ts b/platform/core/src/services/ViewportGridService/ViewportGridService.ts
index c35cc34c3..239db4f88 100644
--- a/platform/core/src/services/ViewportGridService/ViewportGridService.ts
+++ b/platform/core/src/services/ViewportGridService/ViewportGridService.ts
@@ -2,6 +2,8 @@ import { PubSubService } from '../_shared/pubSubServiceInterface';
const EVENTS = {
ACTIVE_VIEWPORT_INDEX_CHANGED: 'event::activeviewportindexchanged',
+ LAYOUT_CHANGED: 'event::layoutChanged',
+ GRID_STATE_CHANGED: 'event::gridStateChanged',
};
class ViewportGridService extends PubSubService {
@@ -12,6 +14,7 @@ class ViewportGridService extends PubSubService {
return new ViewportGridService();
},
};
+ public static EVENTS = EVENTS;
serviceImplementation = {};
@@ -23,10 +26,7 @@ class ViewportGridService extends PubSubService {
public setServiceImplementation({
getState: getStateImplementation,
setActiveViewportIndex: setActiveViewportIndexImplementation,
- setDisplaySetsForViewport: setDisplaySetsForViewportImplementation,
setDisplaySetsForViewports: setDisplaySetsForViewportsImplementation,
- setCachedLayout: setCachedLayoutImplementation,
- restoreCachedLayout: restoreCachedLayoutImplementation,
setLayout: setLayoutImplementation,
reset: resetImplementation,
onModeExit: onModeExitImplementation,
@@ -39,9 +39,6 @@ class ViewportGridService extends PubSubService {
if (setActiveViewportIndexImplementation) {
this.serviceImplementation._setActiveViewportIndex = setActiveViewportIndexImplementation;
}
- if (setDisplaySetsForViewportImplementation) {
- this.serviceImplementation._setDisplaySetsForViewport = setDisplaySetsForViewportImplementation;
- }
if (setDisplaySetsForViewportsImplementation) {
this.serviceImplementation._setDisplaySetsForViewports = setDisplaySetsForViewportsImplementation;
}
@@ -51,12 +48,6 @@ class ViewportGridService extends PubSubService {
if (resetImplementation) {
this.serviceImplementation._reset = resetImplementation;
}
- if (setCachedLayoutImplementation) {
- this.serviceImplementation._setCachedLayout = setCachedLayoutImplementation;
- }
- if (restoreCachedLayoutImplementation) {
- this.serviceImplementation._restoreCachedLayout = restoreCachedLayoutImplementation;
- }
if (onModeExitImplementation) {
this.serviceImplementation._onModeExit = onModeExitImplementation;
}
@@ -70,8 +61,11 @@ class ViewportGridService extends PubSubService {
public setActiveViewportIndex(index) {
this.serviceImplementation._setActiveViewportIndex(index);
+ const state = this.getState();
+ const viewportId = state.viewports[index]?.viewportOptions?.viewportId;
this._broadcastEvent(this.EVENTS.ACTIVE_VIEWPORT_INDEX_CHANGED, {
viewportIndex: index,
+ viewportId,
});
}
@@ -79,26 +73,43 @@ class ViewportGridService extends PubSubService {
return this.serviceImplementation._getState();
}
- public setDisplaySetsForViewport({
- viewportIndex,
- displaySetInstanceUIDs,
- viewportOptions,
- displaySetOptions,
+ public setDisplaySetsForViewport(props) {
+ // Just update a single viewport, but use the multi-viewport update for it.
+ this.serviceImplementation._setDisplaySetsForViewports([props]);
+ }
+
+ public setDisplaySetsForViewports(props) {
+ this.serviceImplementation._setDisplaySetsForViewports(props);
+ }
+
+ /**
+ *
+ * @param numCols, numRows - the number of columns and rows to apply
+ * @param findOrCreateViewport is a function which takes the
+ * index position of the viewport, the position id, and a set of
+ * options that is initially provided as {} (eg to store intermediate state)
+ * The function returns a viewport object to use at the given position.
+ */
+ public setLayout({
+ numCols,
+ numRows,
+ layoutOptions,
+ layoutType = 'grid',
+ activeViewportIndex = undefined,
+ findOrCreateViewport = undefined,
}) {
- this.serviceImplementation._setDisplaySetsForViewport({
- viewportIndex,
- displaySetInstanceUIDs,
- viewportOptions,
- displaySetOptions,
+ this.serviceImplementation._setLayout({
+ numCols,
+ numRows,
+ layoutOptions,
+ layoutType,
+ activeViewportIndex,
+ findOrCreateViewport,
+ });
+ this._broadcastEvent(this.EVENTS.LAYOUT_CHANGED, {
+ numCols,
+ numRows,
});
- }
-
- public setDisplaySetsForViewports(viewports) {
- this.serviceImplementation._setDisplaySetsForViewports(viewports);
- }
-
- public setLayout({ numCols, numRows }) {
- this.serviceImplementation._setLayout({ numCols, numRows });
}
public reset() {
@@ -115,21 +126,27 @@ class ViewportGridService extends PubSubService {
this.serviceImplementation._onModeExit();
}
- public setCachedLayout({ cacheId, cachedLayout }) {
- this.serviceImplementation._setCachedLayout({ cacheId, cachedLayout });
- }
-
- public restoreCachedLayout(cacheId) {
- this.serviceImplementation._restoreCachedLayout(cacheId);
- }
-
public set(state) {
this.serviceImplementation._set(state);
+ this._broadcastEvent(this.EVENTS.GRID_STATE_CHANGED, {
+ state,
+ });
}
public getNumViewportPanes() {
return this.serviceImplementation._getNumViewportPanes();
}
+
+ public getLayoutOptionsFromState(state) {
+ return state.viewports.map(viewport => {
+ return {
+ x: viewport.x,
+ y: viewport.y,
+ width: viewport.width,
+ height: viewport.height,
+ };
+ });
+ }
}
export default ViewportGridService;
diff --git a/platform/core/src/services/index.ts b/platform/core/src/services/index.ts
index 6a3507992..b34e028d8 100644
--- a/platform/core/src/services/index.ts
+++ b/platform/core/src/services/index.ts
@@ -17,6 +17,7 @@ import UserAuthenticationService from './UserAuthenticationService';
import CustomizationService from './CustomizationService';
import Services from '../types/Services';
+import StateSyncService from './StateSyncService';
import PanelService from './PanelService';
export {
@@ -24,6 +25,7 @@ export {
MeasurementService,
ServicesManager,
CustomizationService,
+ StateSyncService,
UIDialogService,
UIModalService,
UINotificationService,
diff --git a/platform/core/src/types/Command.ts b/platform/core/src/types/Command.ts
index 83c774379..837c83590 100644
--- a/platform/core/src/types/Command.ts
+++ b/platform/core/src/types/Command.ts
@@ -3,3 +3,8 @@ export interface Command {
commandOptions?: Record;
context?: string;
}
+
+/** A set of commands, typically contained in a tool item or other configuration */
+export interface Commands {
+ commands: Command[];
+}
diff --git a/platform/core/src/types/HangingProtocol.ts b/platform/core/src/types/HangingProtocol.ts
index a513e308e..5cb26e20c 100644
--- a/platform/core/src/types/HangingProtocol.ts
+++ b/platform/core/src/types/HangingProtocol.ts
@@ -1,68 +1,112 @@
-type DisplaySetInfo = {
- SeriesInstanceUID: string;
- displaySetInstanceUID: string;
- displaySetOptions: Record;
+import { Command } from './Command';
+
+export type DisplaySetInfo = {
+ displaySetInstanceUID?: string;
+ displaySetOptions: DisplaySetOptions;
};
-type ViewportMatchDetails = {
+export type ViewportMatchDetails = {
viewportOptions: ViewportOptions;
displaySetsInfo: DisplaySetInfo[];
};
-type DisplaySetMatchDetails = {
- SeriesInstanceUID: string;
- StudyInstanceUID: string;
+export type DisplaySetMatchDetails = {
+ StudyInstanceUID?: string;
displaySetInstanceUID: string;
matchDetails?: any;
- matchingScores?: any[];
+ matchingScores?: DisplaySetMatchDetails[];
sortingInfo?: any;
};
-
-type DisplaySetAndViewportOptions = {
+export type DisplaySetAndViewportOptions = {
displaySetInstanceUIDs: string[];
viewportOptions: ViewportOptions;
displaySetOptions: DisplaySetOptions;
-}
+};
-type ViewportSpecificProtocolOptions = {
- [viewportIndex: string]: DisplaySetAndViewportOptions
-}
+export type SetProtocolOptions = {
+ /** Used to provide a mapping of what keys are provided for which viewport.
+ * For example, a Chest XRay might use have the display set selector id of
+ * "ChestXRay", then the user might drag an alternate chest xray from the initially chosen one,
+ * and then navigate to another stage or protocol. If that new stage/protocol
+ * uses the name "ChestXRay", then that selection will be used instead of
+ * matching the display set selectors. That allows remembering the
+ * user selected views by name.
+ * Note the keys are not simple display set selector values, but are:
+ * `${activeStudyUID}:${displaySetSelectorId}:${matchingDisplaySetIndex || 0}`
+ * This is normally transparent to the user of this, but in order to specify
+ * specific instances, they can be added like that.
+ */
+ displaySetSelectorMap?: Record;
-type GlobalProtocolOptions = DisplaySetAndViewportOptions
+ /** Used to define the display sets already in view, in order to allow
+ * filling empty viewports with other instances.
+ * Only used when the -1 value for matchedDisplaySetsIndex is provided.
+ * List of display set instance UID's already displayed.
+ */
+ inDisplay?: string[];
+ /** Select the given stage, either by ID or position.
+ * Don't forget that name is used as the ID if ID not provided.
+ */
+ stageId?: string;
+ stageIndex?: number;
-type SetProtocolOptions =
- ViewportSpecificProtocolOptions | GlobalProtocolOptions;
+ /** Indicates to setup the protocol and fire the PROTOCOL_RESTORED event
+ * but don't fire the protocol changed event. Used to restore the
+ * HP service to a previous state.
+ */
+ restoreProtocol?: boolean;
+};
-
-type HangingProtocolMatchDetails = {
+export type HangingProtocolMatchDetails = {
displaySetMatchDetails: Map;
viewportMatchDetails: Map;
- hpAlreadyApplied: Map;
};
-type MatchingRule = {
- id: string;
- weight: number;
+export type ConstraintValue =
+ | string
+ | number
+ | boolean
+ | []
+ | {
+ value: string | number | boolean | [];
+ };
+
+export type Constraint = {
+ // This value exactly
+ equals?: ConstraintValue;
+ notEquals?: ConstraintValue;
+ // A caseless contains
+ containsI?: string;
+ contains?: ConstraintValue;
+ greaterThan?: ConstraintValue;
+};
+
+export type MatchingRule = {
+ // No real use for the id
+ id?: string;
+ // Defaults to 1
+ weight?: number;
attribute: string;
- constraint: Record;
- required: boolean;
+ constraint: Constraint;
+ // Not required by default
+ required?: boolean;
};
-type ViewportLayoutOptions = {
+export type ViewportLayoutOptions = {
x: number;
y: number;
width: number;
height: number;
};
-type ViewportStructure = {
+export type ViewportStructure = {
layoutType: string;
properties: {
rows: number;
columns: number;
- layoutOptions: ViewportLayoutOptions[];
+ layoutOptions?: ViewportLayoutOptions[];
};
};
@@ -74,7 +118,8 @@ type ViewportStructure = {
* The matches are done lazily, so if a stage doesn't need a given match,
* it won't be selected.
*/
-type DisplaySetSelector = {
+export type DisplaySetSelector = {
+ id?: string;
// The image matching rule (not currently implemented) selects which image to
// display initially, only for stack views.
imageMatchingRules?: MatchingRule[];
@@ -83,58 +128,137 @@ type DisplaySetSelector = {
studyMatchingRules?: MatchingRule[];
};
-type SyncGroup = {
+export type SyncGroup = {
type: string;
id: string;
- source?: boolean
- target?: boolean
-}
+ source?: boolean;
+ target?: boolean;
+};
-type initialImageOptions = {
+export type initialImageOptions = {
index?: number;
- preset? : string; // todo: type more
-}
+ preset?: string; // todo: type more
+};
-type ViewportOptions = {
- toolGroupId: string;
- viewportType: string;
+export type ViewportOptions = {
+ toolGroupId?: string;
+ viewportType?: string;
id?: string;
orientation?: string;
viewportId?: string;
initialImageOptions?: initialImageOptions;
syncGroups?: SyncGroup[];
customViewportProps?: Record;
+ // Set to true to allow non-matching drag and drop or options provided
+ // from options.displaySetSelectorsMap
+ allowUnmatchedView?: boolean;
};
-type DisplaySetOptions = {
+// The options here includes both the display set selector and matching index
+// as well as actual options to apply to the individual viewports.
+export type DisplaySetOptions = {
// The id is used to choose which display set selector to apply here
id: string;
- // An offset to allow display secondary series, for example
- // to display the second matching series (displaySetIndex==1)
- // This cannot easily be done with the matching rules directly.
- displaySetIndex?: number;
+ /** The offset to allow display secondary series, for example
+ * to display the second matching series, use `matchedDisplaySetsIndex==1` */
+ matchedDisplaySetsIndex?: number;
+
// The options to apply to the display set.
options?: Record;
};
-type Viewport = {
+export type Viewport = {
viewportOptions: ViewportOptions;
displaySets: DisplaySetOptions[];
};
-type ProtocolStage = {
- id: string;
+/**
+ * disabled stages are missing display sets required in order to view them.
+ * enabled stages have all the requiredDisplaySets and at least preferredViewports
+ * filled.
+ * passive stages have the requiredDisplaySets and at least requiredViewports filled.
+ */
+export type StageStatus = 'disabled' | 'enabled' | 'passive';
+
+/** Controls whether a stage is activated or not, at the given level, by
+ * controlling the status of the stage.
+ */
+export type StageActivation = {
+ // The minimum number of viewports to be NON-blank to activate this level of the stage
+ minViewportsMatched?: number;
+ // The required set of display set selectors to have at least 1 match to activate
+ displaySetSelectorsMatched?: string[];
+};
+
+/**
+ * Protocol stages are a set of different views which can be applied, for
+ * example, a 2x1 and a 1x1 view might be both applied (see default extension
+ * for this example).
+ */
+export type ProtocolStage = {
+ /** The id defaults to the name of the protocol if not otherwise specified */
+ id?: string;
+ /**
+ * The display name used for this stage when shown to the user. This can
+ * differ from the id, for example, to use the same name for different
+ * stages, only one of which ends up being active.
+ */
name: string;
+ /** Indicate if the stage can be applied or not */
+ status?: StageStatus;
+
viewportStructure: ViewportStructure;
+ stageActivation?: {
+ // The enabled activation is provided for fully active stages,
+ // participating in automatic stage selection and navigation
+ enabled?: StageActivation;
+ // The passive activation is provided to allow stages to manually
+ // be activated, but not navigated to by default, or used on initial view
+ passive?: StageActivation;
+ };
+
+ /** A viewport definition used for to fill in manually selected viewports.
+ * This allows changing the layout definition for additional viewports without
+ * needing to define layouts for each of the 1x1, 2x2 etc modes.
+ */
+ defaultViewport?: Viewport;
+
viewports: Viewport[];
+
+ // Unused.
createdDate?: string;
};
-type Protocol = {
+// Add notifications for various types of events.
+export type ProtocolNotifications = {
+ // This set of commands is executed after the protocol is exited and the new one applied
+ onProtocolExit?: Command[];
+
+ // This set of commands is executed after the protocol is entered and applied
+ onProtocolEnter?: Command[];
+
+ // This set of commands is executed before the layout change is started.
+ // If it returns false, the layout change will be aborted.
+ // The numRows and numCols is included in the command params, so it is possible
+ // to apply a specific hanging protocol
+ onLayoutChange?: Command[];
+};
+
+/**
+ * A protocol is the top level definition for a hanging protocol.
+ * It is a set of rules about when the protocol can be applied at all,
+ * as well as a set of stages that represent indivividual views.
+ * Additionally, the display set selectors are used to choose from the existing
+ * display sets. The hanging protcol definition here does NOT allow
+ * redefining the display sets to use, but only selects the views to show.
+ */
+export type Protocol = {
// Mandatory
id: string;
- // Selects which display sets are given a specific name.
+ /** Maps ids to display set selectors to choose display sets */
displaySetSelectors: Record;
+ /** A default viewport to use for any stage to select new viewport layouts. */
+ defaultViewport?: Viewport;
stages: ProtocolStage[];
// Optional
locked?: boolean;
@@ -145,35 +269,34 @@ type Protocol = {
availableTo?: Record;
editableBy?: Record;
toolGroupIds?: string[];
+ // A set of callbacks relevant to entering and exiting the protocol
+ callbacks?: ProtocolNotifications;
imageLoadStrategy?: string; // Todo: this should be types specifically
protocolMatchingRules?: MatchingRule[];
+ /* The number of priors required for this hanging protocol.
+ * -1 means that NO priors are referenced, and thus this HP matches
+ * only the active study, whereas 0 means that an unknown number of
+ * priors is matched.
+ */
numberOfPriorsReferenced?: number;
syncDataForViewports?: boolean;
};
-type ProtocolGenerator = ({ servicesManager: any, commandsManager: any }) => {
+/** Used to dynamically generate protocols.
+ * Try to avoid this as it is difficult to provide active/disabled settings
+ * to the GUI when this is used, and it can be expensive to apply.
+ * Alternatives include using the custom attributes where possible.
+ */
+export type ProtocolGenerator = ({
+ servicesManager: any,
+ commandsManager: any,
+}) => {
protocol: Protocol;
};
-export type {
- SetProtocolOptions,
- ViewportOptions,
- ViewportMatchDetails,
- DisplaySetMatchDetails,
- HangingProtocolMatchDetails,
- Protocol,
- ProtocolStage,
- Viewport,
- DisplaySetSelector,
- ViewportStructure,
- ViewportLayoutOptions,
- DisplaySetOptions,
- MatchingRule,
- SyncGroup,
- initialImageOptions,
- DisplaySetInfo,
- GlobalProtocolOptions,
- ViewportSpecificProtocolOptions,
- DisplaySetAndViewportOptions,
- ProtocolGenerator,
+export type HPInfo = {
+ protocolId: string;
+ stageId: string;
+ stageIndex: number;
+ activeStudyUID: string;
};
diff --git a/platform/core/src/types/Services.ts b/platform/core/src/types/Services.ts
index ab58b0ddd..ca73361ca 100644
--- a/platform/core/src/types/Services.ts
+++ b/platform/core/src/types/Services.ts
@@ -5,6 +5,7 @@ import {
ViewportGridService,
ToolbarService,
DisplaySetService,
+ StateSyncService,
} from '../services';
/**
@@ -28,5 +29,6 @@ export default interface Services {
syncGroupService?: Record;
cornerstoneCacheService?: Record;
segmentationService?: Record;
+ stateSyncService?: StateSyncService;
panelService?: Record;
}
diff --git a/platform/core/src/utils/combineFrameInstance.ts b/platform/core/src/utils/combineFrameInstance.ts
index b5678a2d6..933437a24 100644
--- a/platform/core/src/utils/combineFrameInstance.ts
+++ b/platform/core/src/utils/combineFrameInstance.ts
@@ -30,12 +30,35 @@ const combineFrameInstance = (frame, instance) => {
.map(it => it[0])
.filter(it => it !== undefined && typeof it === 'object');
- return Object.assign(
- { frameNumber: frameNumber },
- instance,
- ...Object.values(shared),
- ...Object.values(perFrame)
- );
+ // this is to fix NM multiframe datasets with position and orientation
+ // information inside DetectorInformationSequence
+ if (
+ !instance.ImageOrientationPatient &&
+ instance.DetectorInformationSequence
+ ) {
+ instance.ImageOrientationPatient =
+ instance.DetectorInformationSequence[0].ImageOrientationPatient;
+ }
+ if (
+ !instance.ImagePositionPatient &&
+ instance.DetectorInformationSequence
+ ) {
+ instance.ImagePositionPatient =
+ instance.DetectorInformationSequence[0].ImagePositionPatient;
+ }
+
+ const newInstance = Object.assign(instance, { frameNumber: frameNumber });
+
+ // merge the shared first then the per frame to override
+ [...shared, ...perFrame].forEach(item => {
+ Object.entries(item).forEach(([key, value]) => {
+ newInstance[key] = value;
+ });
+ });
+
+ // Todo: we should cache this combined instance somewhere, maybe add it
+ // back to the dicomMetaStore so we don't have to do this again.
+ return newInstance;
} else {
return instance;
}
diff --git a/platform/core/src/utils/index.js b/platform/core/src/utils/index.js
index d428a6648..4c54c32ef 100644
--- a/platform/core/src/utils/index.js
+++ b/platform/core/src/utils/index.js
@@ -32,6 +32,7 @@ import {
sortingCriteria,
seriesSortCriteria,
} from './sortStudy';
+import { subscribeToNextViewportGridChange } from './subscribeToNextViewportGridChange';
// Commented out unused functionality.
// Need to implement new mechanism for derived displaySets using the displaySetManager.
@@ -69,6 +70,7 @@ const utils = {
debounce,
roundNumber,
downloadCSVReport,
+ subscribeToNextViewportGridChange,
};
export {
diff --git a/platform/core/src/utils/index.test.js b/platform/core/src/utils/index.test.js
index 9b83f8db5..cae769191 100644
--- a/platform/core/src/utils/index.test.js
+++ b/platform/core/src/utils/index.test.js
@@ -35,6 +35,7 @@ describe('Top level exports', () => {
'resolveObjectPath',
'hierarchicalListUtils',
'progressTrackingUtils',
+ 'subscribeToNextViewportGridChange',
].sort();
const exports = Object.keys(utils.default).sort();
diff --git a/platform/core/src/utils/isDisplaySetReconstructable.js b/platform/core/src/utils/isDisplaySetReconstructable.js
index 6ab7bf2fd..373da994a 100644
--- a/platform/core/src/utils/isDisplaySetReconstructable.js
+++ b/platform/core/src/utils/isDisplaySetReconstructable.js
@@ -30,62 +30,98 @@ export default function isDisplaySetReconstructable(instances) {
}
// Can't reconstruct if all instances don't have the ImagePositionPatient.
- if (!instances.every(instance => !!instance.ImagePositionPatient)) {
+ if (
+ !isMultiframe &&
+ !instances.every(instance => instance.ImagePositionPatient)
+ ) {
return { value: false };
}
const sortedInstances = sortInstancesByPosition(instances);
- if (isMultiframe) {
- return processMultiframe(sortedInstances[0]);
- } else {
- return processSingleframe(sortedInstances);
- }
+ return isMultiframe
+ ? processMultiframe(sortedInstances[0])
+ : processSingleframe(sortedInstances);
+}
+
+function hasPixelMeasurements(multiFrameInstance) {
+ const perFrameSequence =
+ multiFrameInstance.PerFrameFunctionalGroupsSequence?.[0];
+ const sharedSequence = multiFrameInstance.SharedFunctionalGroupsSequence;
+
+ return (
+ Boolean(perFrameSequence?.PixelMeasuresSequence) ||
+ Boolean(sharedSequence?.PixelMeasuresSequence) ||
+ Boolean(
+ multiFrameInstance.PixelSpacing &&
+ (multiFrameInstance.SliceThickness ||
+ multiFrameInstance.SpacingBetweenFrames)
+ )
+ );
+}
+
+function hasOrientation(multiFrameInstance) {
+ const sharedSequence = multiFrameInstance.SharedFunctionalGroupsSequence;
+ const perFrameSequence =
+ multiFrameInstance.PerFrameFunctionalGroupsSequence?.[0];
+
+ return (
+ Boolean(sharedSequence?.PlaneOrientationSequence) ||
+ Boolean(perFrameSequence?.PlaneOrientationSequence) ||
+ Boolean(
+ multiFrameInstance.ImageOrientationPatient ||
+ multiFrameInstance.DetectorInformationSequence?.[0]
+ ?.ImageOrientationPatient
+ )
+ );
+}
+
+function hasPosition(multiFrameInstance) {
+ const perFrameSequence =
+ multiFrameInstance.PerFrameFunctionalGroupsSequence?.[0];
+
+ return (
+ Boolean(perFrameSequence?.PlanePositionSequence) ||
+ Boolean(perFrameSequence?.CTPositionSequence) ||
+ Boolean(
+ multiFrameInstance.ImagePositionPatient ||
+ multiFrameInstance.DetectorInformationSequence?.[0]
+ ?.ImagePositionPatient
+ )
+ );
+}
+
+function isNMReconstructable(multiFrameInstance) {
+ const imageSubType = multiFrameInstance.ImageType?.[2];
+ return imageSubType === 'RECON TOMO' || imageSubType === 'RECON GATED TOMO';
}
function processMultiframe(multiFrameInstance) {
- const {
- PerFrameFunctionalGroupsSequence,
- SharedFunctionalGroupsSequence,
- } = multiFrameInstance;
-
// If we don't have the PixelMeasuresSequence, then the pixel spacing and
// slice thickness isn't specified or is changing and we can't reconstruct
// the dataset.
+ if (!hasPixelMeasurements(multiFrameInstance)) {
+ return { value: false };
+ }
+
+ if (!hasOrientation(multiFrameInstance)) {
+ console.log('No image orientation information, not reconstructable');
+ return { value: false };
+ }
+
+ if (!hasPosition(multiFrameInstance)) {
+ console.log('No image position information, not reconstructable');
+ return { value: false };
+ }
+
if (
- !SharedFunctionalGroupsSequence ||
- !SharedFunctionalGroupsSequence[0].PixelMeasuresSequence
+ multiFrameInstance.Modality.includes('NM') &&
+ !isNMReconstructable(multiFrameInstance)
) {
return { value: false };
}
- // Check that the orientation is either shared or with the allowed
- // difference amount
- const {
- PlaneOrientationSequence: sharedOrientation,
- } = SharedFunctionalGroupsSequence;
-
- if (!sharedOrientation) {
- const {
- PlaneOrientationSequence: firstOrientation,
- } = PerFrameFunctionalGroupsSequence[0];
-
- if (!firstOrientation) {
- console.log('No orientation information');
- return { value: false };
- }
- // TODO - check orientation consistency
- }
-
- const frame0 = PerFrameFunctionalGroupsSequence[0];
- const firstPosition =
- frame0.PlanePositionSequence || frame0.CTPositionSequence;
- if (!firstPosition) {
- console.log('No image position information, not reconstructable');
- return { value: false };
- }
// TODO - check spacing consistency
-
return { value: true };
}
diff --git a/platform/core/src/utils/subscribeToNextViewportGridChange.ts b/platform/core/src/utils/subscribeToNextViewportGridChange.ts
new file mode 100644
index 000000000..e6c72d048
--- /dev/null
+++ b/platform/core/src/utils/subscribeToNextViewportGridChange.ts
@@ -0,0 +1,37 @@
+import { ViewportGridService } from '../services';
+
+/**
+ * Subscribes to the very next LAYOUT_CHANGED or GRID_STATE_CHANGED event that
+ * is not currently on the event queue. The subscriptions are made on a 'zero'
+ * timeout so as to avoid responding to any of those events currently on the event queue.
+ * The subscription persists only for a single invocation of either event.
+ * Once either event is fired, the subscriptions are unsubscribed.
+ * @param viewportGridService the viewport grid service to subscribe to
+ * @param gridChangeCallback the callback
+ */
+function subscribeToNextViewportGridChange(
+ viewportGridService: ViewportGridService,
+ gridChangeCallback: (arg: unknown) => void
+): void {
+ const subscriber = () => {
+ const callback = (callbackProps: unknown) => {
+ subscriptions.forEach(subscription => subscription.unsubscribe());
+ gridChangeCallback(callbackProps);
+ };
+
+ const subscriptions = [
+ viewportGridService.subscribe(
+ viewportGridService.EVENTS.LAYOUT_CHANGED,
+ callback
+ ),
+ viewportGridService.subscribe(
+ viewportGridService.EVENTS.GRID_STATE_CHANGED,
+ callback
+ ),
+ ];
+ };
+
+ window.setTimeout(subscriber, 0);
+}
+
+export { subscribeToNextViewportGridChange };
diff --git a/platform/docs/docs/platform/extensions/modules/sop-class-handler.md b/platform/docs/docs/platform/extensions/modules/sop-class-handler.md
index eb1b7a464..607ac00e2 100644
--- a/platform/docs/docs/platform/extensions/modules/sop-class-handler.md
+++ b/platform/docs/docs/platform/extensions/modules/sop-class-handler.md
@@ -53,7 +53,7 @@ const sopClassDictionary = {
const sopClassUids = [
sopClassDictionary.CTImageStorage,
sopClassDictionary.MRImageStorage,
-;
+];
const makeDisplaySet = (instances) => {
const instance = instances[0];
diff --git a/platform/docs/docs/platform/modes/index.md b/platform/docs/docs/platform/modes/index.md
index 44a58fde1..aa3f0cb0d 100644
--- a/platform/docs/docs/platform/modes/index.md
+++ b/platform/docs/docs/platform/modes/index.md
@@ -315,7 +315,9 @@ handles creation of the displaySets.
### Hotkeys
`hotkeys` is another property in the configuration of a mode that can be defined
-to add the specific hotkeys to the viewer at all routes.
+to add the specific hotkeys to the viewer on the mode route. Additionally, the
+name under which the hotkeys are stored can be configured as `hotkeyName`.
+This allows user customization of the mode specific hotkeys.
```js
// default hotkeys
@@ -347,7 +349,13 @@ function modeFactory() {
/*
...
*/
- hotkeys: [..hotkeys.defaults.hotkeyBindings, ...myHotkeys],
+ hotkeys: {
+ // The name in preferences to use for this set of hotkeys
+ // Allows defining different sets for different modes
+ name: 'custom-hotkey-name',
+ // And the actual custom values here.
+ hotkeys:[..hotkeys.defaults.hotkeyBindings, ...myHotkeys]
+ },
}
}
diff --git a/platform/docs/docs/platform/services/data/HangingProtocolService.md b/platform/docs/docs/platform/services/data/HangingProtocolService.md
index c43fd6fd8..71dc86f49 100644
--- a/platform/docs/docs/platform/services/data/HangingProtocolService.md
+++ b/platform/docs/docs/platform/services/data/HangingProtocolService.md
@@ -27,6 +27,27 @@ registered automatically to the HangingProtocolService.
All protocols are stored in the `HangingProtocolService` using their `id` as the key, and the protocol itself as the value.
+## Protocol Definition
+Protocols are defined in a getHangingProtocolModule inside an extension. As such,
+they are defined with a module structure that starts with an id, and has field protocol
+that is the actual protocol definition. This setup allows defining more than
+one protocol within a module, each one needing it's own definition file.
+
+```javascript
+import MyProtocol from './MyProtocol';
+export default function getHangingProtocolModule() {
+ return [
+ {
+ id: MyProtocol.id,
+ protocol: MyProtocol,
+ },
+ ];
+}
+```
+
+Within the protocol itself, the structure is layed out as described in the HangingProtocol.ts
+type definition, starting with `Protocol`. See the type definition for more details.
+
## Events
There are two events that get publish in `HangingProtocolService`:
@@ -34,31 +55,101 @@ There are two events that get publish in `HangingProtocolService`:
| Event | Description |
| ------------ | -------------------------------------------------------------------- |
| NEW_LAYOUT | Fires when a new layout is requested by the `HangingProtocolService` |
-| STAGE_CHANGE | Fires when the the stage is changed in the hanging protocols |
-| PROTOCOL_CHANGED | Fires when the the protocol is changed in the hanging protocols |
-| HANGING_PROTOCOL_APPLIED_FOR_VIEWPORT | Fires when the hanging protocol applies for a viewport (sets its displaySets) |
+| PROTOCOL_CHANGED | Fires when the the protocol is changed in the hanging protocols, or when the applied stage is changed. |
+| RESTORE_PROTOCOL | Fires when the protocol or stage is restored, for example, after turning off MPR mode |
+| STAGE_ACTIVATION | Fires when the stages are known to have stage.status set. |
+## Stage Activation and Status
+Sometimes a hanging protocol can be applicable generally, but not all stages
+should be shown by default, or should be shown at all. This can be handled by
+using the stage activation to control whether the stage is shown by default (`enabled`),
+whether it can be navigated to (`passive`) or whether it should not be shown
+at all (`disabled`).
+The `stage.status` is used to control this, and the status is controlled by
+the stage activate. The status values are:
+
+* enabled - meaning that the stage is fully applicable
+* passive - meaning that the stage can be applied, but might be missing details
+* disabled - meaning that the study has insuffient information for this stage
+
+The default values for no `stageActivation` are to assume that `enabled` has `minViewports` of 1,
+and `passive` has `minViewports=0`. That is, enable the stage if at least one
+viewport is filled, and make it passive if no viewports are filled.
+
+The setting for these are controlled by the stageActivation property, for example
+the following:
+
+```javascript
+stageActivation: {
+ // The enabled activation specifies requirements to enable the stage, that is,
+ // make it preferred.
+ enabled: {
+ // The default value here is 1, and indicates how many non-blank viewports
+ // are required.
+ minViewportsMatched: 3,
+ // This enables specifying cross cutting concerns, such as having a stage
+ // only apply to males or females, and is a list of display set selector ids
+ displaySetSelectorsMatched: ['dsMale'],
+ },
+ // The passive check is performed first. If it fails, the enabled is NOT
+ // checked, but the status set to disabled. The default passive check
+ // should always be passed, so it is fine to just define enabled if desired.
+ passive: {
+ // The default is 0, which means allow the stage even if no viewports are
+ // filled. This allows dragging and dropping into the viewports to
+ // make matches manually, which can then be re-used for other stages.
+ minViewportsMatched: 0,
+ displaySetSelectorsMatched: [...],
+ },
+}
+```
## API
+- `destroy`: Destroys the HP service
+
+- `reset` and `onModeEnter`: Resets the HP service to not have any active
+ hanging protocols
+
+- `getActiveProtocol`: Returns an object of the internal state of the HP service,
+ useful for storing said state, as well as for getting direct access to the
+ protocol and stage objects. Users of this should count on it being not completely
+ stable as to exactly what this returns, as internal details can change.
+
+- `getState`: Returns the currently applied protocol ID, stage index and active study UID.
+ This information is storable/useable as state information to be used elsewhere.
+
+- `getDefaultProtocol`: Returns the default protocol to apply.
+
- `getMatchDetails`: returns an object which contains the details of the
matching for the viewports, displaySets and whether the protocol is
- applied to the viewport or not yet.
+ applied to the viewport or not yet. This is deprecated as it is expected
+ to be communicated by events instead.
+
+- `getProtocols`: Returns a list of the currently active protocols.
+
+- `getProtocolById`: Gets the protocol with the given id.
- `addProtocol`: adds provided protocol to the list of registered protocols
- for matching
+ for matching. Will replacing any protocol with the same id, allowing, for example,
+ to replace the default protocol.
- `setActiveProtocols`: Choose the protocols which are active. Can take a
single protocol id or a list. When a single one is provided, that one will be
applied whether or not the required rules match. Called automatically on mode
init.
+- `setActiveStudyUID`: Sets the given study UID as active, which has significance
+ in terms of the matching rules being able to match against the active study.
+
- `run({studies, activeStudy, displaySets }, protocolId)`: runs the HPService with the provided
studyMetaData and optional protocolId. If protocol is not given, HP Matching
engine will search all the registered protocols for the best matching one
based on the constraints.
+- `registerImageLoadStrategy`: Adds a custom image load strategy.
+
- `addCustomAttribute`: adding a custom attribute for matching. (see below)
- `setProtocol`: applies a protocol to the current studies, it can be used for instance to apply a
@@ -68,6 +159,12 @@ init.
used for the protocol. If no options are provided, all displaySets will
be used to match the protocol.
+- `getStageIndex`: Finds the stage index for a given set of match keys. Currently
+ only works on the currently active protocol, but is supposed to be able to work
+ with other protocols as well.
+
+- `getMissingViewport`: Returns a viewport object to be used as the missing
+ viewport instance. This is used to fill out new viewports.
Default initialization of the modes handles running the `HangingProtocolService`
@@ -78,7 +175,7 @@ do not overlap, with the suggested id being `${moduleId}.${simpleName}`. The
'default' name is used as the hanging protocol id when no other protocol applies,
and can be set as the last module listed containing 'default'.
-A hanging protocol can also be defined with a generator.
+A hanging protocol can also be defined with a generator.
A generator is a function we can write this way:
```ts
@@ -93,6 +190,33 @@ function protocolGenerator({ servicesManager, commandsManager }) {
See the typescript definitions for more details on the structure of protocols.
+## Additional viewports for layout - `defaultViewport`
+Sometimes the user manually selects a layout of a given size, say `2x3`. The
+hanging protocol can define what viewport options to use for this viewport by
+defining an extra viewport option in `defaultViewport`. For example:
+
+```javascript
+ defaultViewport: {
+ viewportOptions: {
+ viewportType: 'stack',
+ toolGroupId: 'default',
+ allowUnmatchedView: true,
+ },
+ displaySets: [
+ {
+ id: 'defaultDisplaySetId',
+ matchedDisplaySetsIndex: -1,
+ },
+ ],
+ },
+```
+
+This allows defining the type of additional viewports, what tool group etc they
+are allowed in, and which display set is used to fill them. In the above case,
+the display set is the same as the other viewports, but the
+`matchedDisplaySetsIndex=-1`, so that means find the next matching display set
+from the display set selector which isn't already filling a view.
+
## Custom Attribute
In some situations, you might want to match based on a custom attribute and not the DICOM tags. For instance,
if you have assigned a `timepointId` to each study, and you want to match based on it.
@@ -102,7 +226,7 @@ There are various ways that you can let `HangingProtocolService` know of you
custom attribute. We will show how to add it inside the mode configuration.
```js
-const deafultProtocol = {
+const defaultProtocol = {
id: 'defaultProtocol',
/** ... **/
protocolMatchingRules: [
diff --git a/platform/docs/docs/platform/services/data/StateSyncService.md b/platform/docs/docs/platform/services/data/StateSyncService.md
new file mode 100644
index 000000000..4e6964d17
--- /dev/null
+++ b/platform/docs/docs/platform/services/data/StateSyncService.md
@@ -0,0 +1,77 @@
+---
+sidebar_position: 8
+sidebar_label: State Sync Service
+---
+
+# State Sync Service
+
+## Overview
+The state sync service is designed to allow short and long term memory of things such as
+annotations applied, last annotation state, hanging protocol viewport state,
+window level etc. This allows for better interaction with things like navigation
+between hanging protocols, ensuring that the previously displayed layouts
+can be redisplayed after returning to a given hanging protocol.
+
+Currently, all the state sync service configurations have one of the following two
+lifetimes. See the mode description for general information on the mode lifetime.
+
+* Application load - when the application is restarted, the state is lost
+* `clearOnModeExit` - which stores state until the mode onModeExit is called, and then throws away the remaining state. This is useful for mode specific information.
+
+### TODO work - add more storage locations
+It is expected to add a few more storage locations, which will store to various
+locations on updates:
+
+* User specific server store - to store things between application restarts at the user level
+* Browser state store - to store things in the browser local state, to recover after crashing.
+* Study specific server store - to store things relevant to a given study between application restarts, on the server.
+
+## Events
+
+Currently the service does not fire events.
+
+## API
+
+- `register`: to create a new named state storage
+- `reduce`: to apply a set of changes to several states at once
+- `getState`: to retrieve the current state
+- `onModeExit`: clears the states configured as clearOnModeExit states
+
+### register
+The register call is typically added to an extension to create a new
+syncable state. A typical call is shown below, registering the viewport
+grid store state as a modal state.
+
+```javascript
+ stateSyncService.register('viewportGridStore', { clearOnModeExit: true });
+```
+
+### getState
+The `getState` call returns an object containing all of the reigstered states,
+by id. The values can be read directly, but should not be modified.
+
+### reduce
+The `reduce` call is used to apply a set of updates to various states. The
+updates are performed for every state as a simply "set" call.
+
+### onModeExit
+When the Mode is exited, the onModeExit is called on the sync state, and this
+clears all states registered with `clearOnModeExit: true`.
+To avoid clearing the state, the mode definition should store any transient
+state in the mode onModeExit and recover it in the `mode.onModeEnter`.
+
+## OHIF Registered State Sync Stores
+There are a number of defined stores here. It is recommended to update this
+list as state stores are added:
+
+### Default Extension Stores
+
+* `viewportGridStore` has viewport grid restore information for returning to an earlier grid layout.
+* `reuseIdMap` has a map of names to display sets for preserving user changes to hp display set selections.
+* `hanging` has a map of the hanging protocol stage information applied (HPInfo)
+* `toggleHangingProtocol` has the previously applied hanging protocol, to toggle an HP off.
+
+### Cornerstone Extension Stores
+
+* `lutPresentationStore` has the cornerstone LUT (window level) presentation state information
+* `positionPresentationStore` has the cornerstone viewport position (camera, initial image) information
diff --git a/platform/docs/docs/platform/services/data/ToolbarService.md b/platform/docs/docs/platform/services/data/ToolbarService.md
index 18e7b7afb..f92cc385f 100644
--- a/platform/docs/docs/platform/services/data/ToolbarService.md
+++ b/platform/docs/docs/platform/services/data/ToolbarService.md
@@ -33,6 +33,7 @@ button is clicked by the user.
presets.
- `commandName`: if tool has a command attached to run
- `commandOptions`: arguments for the command.
+ - `setActive`: Sets a given tool active (not as primary but as secondary)
- `reset`: reset the state of the toolbarService, set the primary tool to be
`Wwwc` and unsubscribe tools that have registered their functions.
diff --git a/platform/docs/docs/platform/services/data/index.md b/platform/docs/docs/platform/services/data/index.md
index ee3ac507e..cdeb44c77 100644
--- a/platform/docs/docs/platform/services/data/index.md
+++ b/platform/docs/docs/platform/services/data/index.md
@@ -19,7 +19,8 @@ We maintain the following non-ui Services:
- [Hanging Protocol Service](../data/HangingProtocolService.md)
- [Toolbar Service](../data/ToolBarService.md)
- [Measurement Service](../data/MeasurementService.md)
-- [Customization Service](customization-service.md)
+- [Customization Service](../data/customization-service.md)
+- [State Sync Service](../data/StateSyncService.md)
- [Panel Service](../data/PanelService.md)
## Service Architecture
diff --git a/platform/docs/docs/platform/services/ui/customization-service.md b/platform/docs/docs/platform/services/ui/customization-service.md
index 996f11b93..b59bf10d9 100644
--- a/platform/docs/docs/platform/services/ui/customization-service.md
+++ b/platform/docs/docs/platform/services/ui/customization-service.md
@@ -210,8 +210,8 @@ example (this example comes from the context menu customizations as that one
uses commands lists):
```ts
- cornerstoneContextMenu = uiConfigurationService.getModeCustomization("cornerstoneContextMenu", defaultMenu);
- uiConfigurationService.recordInteraction(cornerstoneContextMenu, extraProps);
+ cornerstoneContextMenu = uiConfigurationService.get("cornerstoneContextMenu", defaultMenu);
+ commandsManager.run(cornerstoneContextMenu, extraProps);
```
### Global Customizations
@@ -229,7 +229,7 @@ This allows for having strong typing when declaring customizations, for example:
```ts
import { Types } from '@ohif/ui';
-const customContextMenu: Types.UIContextMenu =
+const customContextMenu: Types.ContextMenu.Menu =
{
id: 'cornerstoneContextMenu',
customizationType: 'ohif.contextMenu',
@@ -260,7 +260,7 @@ getCustomizationModule = () => ([
```
defines an overlay item which has a React content object as the render value.
-This can then be used by specifying a customizationType of `ohif.overlayItem`, for example:
+This can then be used by specifying a `customizationType` of `ohif.overlayItem`, for example:
```js
const overlayItem: Types.UIOverlayItem = {
@@ -275,7 +275,6 @@ const overlayItem: Types.UIOverlayItem = {
This section can be used to specify various customization capabilities.
-
## Text color for StudyBrowser tabs
This is the recommended pattern for deep customization of class attributes,
@@ -478,6 +477,29 @@ window.config = {
+## Context Menus
+
+Context menus can be created by defining the menu structure and click
+interaction, as defined in the `ContextMenu/types`. There are examples
+below specific to the cornerstone context, because the actual click
+handler and attributes used to decide when and how to display the menu
+are specific to the context used for where the menu is displayed.
+
+## Cornerstone Context Menu
+
+The default cornerstone context menu can be customized by setting the
+`cornerstoneContextMenu`. For a full example, see `findingsContextMenu`.
+
+## Customizeable Cornerstone Viewport Click Behaviour
+
+The behaviour on clicking on the cornerstone viewport can be customized
+by setting the `cornerstoneViewportClickCommands`. This is intended to
+support both the cornerstone 3D internal commands as well as things like
+context menus. Currently it supports buttons 1-3, as well as modifier keys
+by associating a commands list with the button to click. See `initContextMenu`
+for more details.
+
+## Please add additional customizations above this section
> 3rd Party implementers may be added to this table via pull requests.
+## Context Menus
+
+Context menus can be created by defining the menu structure and click
+interaction, as defined in the `ContextMenu/types`. There are examples
+below specific to the cornerstone context, because the actual click
+handler and attributes used to decide when and how to display the menu
+are specific to the context used for where the menu is displayed.
+
+## Cornerstone Context Menu
+
+The default cornerstone context menu can be customized by setting the
+`cornerstoneContextMenu`. For a full example, see `findingsContextMenu`.
+
+## Customizeable Cornerstone Viewport Click Behaviour
+
+The behaviour on clicking on the cornerstone viewport can be customized
+by setting the `cornerstoneViewportClickCommands`. This is intended to
+support both the cornerstone 3D internal commands as well as things like
+context menus. Currently it supports buttons 1-3, as well as modifier keys
+by associating a commands list with the button to click. See `initContextMenu`
+for more details.
+
+## Please add additional customizations above this section
> 3rd Party implementers may be added to this table via pull requests.