fix: Use @cornerstonejs/adapters (#3116)

Also update the sort series to be consistent, using a single version of the series sort, and fix an issue with longitudinal mode export.

platform/core/src/utils/index.js

@@ -2,7 +2,6 @@ import ObjectPath from './objectPath';
 import absoluteUrl from './absoluteUrl';
 import guid from './guid';
 import sortBy from './sortBy.js';
-import sortBySeriesDate from './sortBySeriesDate.js';
 import writeScript from './writeScript.js';
 import b64toBlob from './b64toBlob.js';
 //import loadAndCacheDerivedDisplaySets from './loadAndCacheDerivedDisplaySets.js';
@@ -26,6 +25,13 @@ import debounce from './debounce';
 import roundNumber from './roundNumber';
 import downloadCSVReport from './downloadCSVReport';
 import isEqualWithin from './isEqualWithin';
+import {
+  sortStudy,
+  sortStudySeries,
+  sortStudyInstances,
+  sortingCriteria,
+  seriesSortCriteria,
+} from './sortStudy';
 
 // Commented out unused functionality.
 // Need to implement new mechanism for derived displaySets using the displaySetManager.
@@ -35,7 +41,12 @@ const utils = {
   ObjectPath,
   absoluteUrl,
   sortBy,
-  sortBySeriesDate,
+  sortBySeriesDate: sortStudySeries,
+  sortStudy,
+  sortStudySeries,
+  sortStudyInstances,
+  sortingCriteria,
+  seriesSortCriteria,
   writeScript,
   formatDate,
   formatPN,

platform/core/src/utils/index.test.js

@@ -6,8 +6,13 @@ describe('Top level exports', () => {
       'guid',
       'ObjectPath',
       'absoluteUrl',
+      'seriesSortCriteria',
       'sortBy',
+      'sortStudy',
       'sortBySeriesDate',
+      'sortStudyInstances',
+      'sortStudySeries',
+      'sortingCriteria',
       'isLowPriorityModality',
       'writeScript',
       'debounce',

platform/core/src/utils/isLowPriorityModality.ts

@@ -0,0 +1,5 @@
+const LOW_PRIORITY_MODALITIES = Object.freeze(['SEG', 'KO', 'PR', 'SR', 'RTSTRUCT']);
+
+export default function isLowPriorityModality(Modality) {
+  return LOW_PRIORITY_MODALITIES.includes(Modality);
+}

platform/core/src/utils/sortBySeriesDate.js

@@ -1,17 +0,0 @@
-/*
- * Sorting function
- * Sorts an array by seriesDate and seriesNumber if equal
- */
-const sortBySeriesDate = array =>
-  array.sort((a, b) => {
-    if (a.seriesNumber !== b.seriesNumber) {
-      return a.seriesNumber - b.seriesNumber;
-    }
-
-    const seriesDateA = Date.parse(a.seriesDate);
-    const seriesDateB = Date.parse(b.seriesDate);
-
-    return seriesDateA - seriesDateB;
-  });
-
-export default sortBySeriesDate;

platform/core/src/utils/sortStudy.ts

@@ -0,0 +1,126 @@
+import isLowPriorityModality from './isLowPriorityModality';
+
+const compareSeriesDateTime = (a, b) => {
+  const seriesDateA = Date.parse(
+    `${a.seriesDate ?? a.SeriesDate} ${a.seriesTime ?? a.SeriesTime}`
+  );
+  const seriesDateB = Date.parse(
+    `${a.seriesDate ?? a.SeriesDate} ${a.seriesTime ?? a.SeriesTime}`
+  );
+  return seriesDateA - seriesDateB;
+};
+
+const defaultSeriesSort = (a, b) => {
+  const seriesNumberA = a.SeriesNumber ?? a.seriesNumber;
+  const seriesNumberB = b.SeriesNumber ?? b.seriesNumber;
+  if (seriesNumberA === seriesNumberB) return compareSeriesDateTime(a, b);
+  return seriesNumberA - seriesNumberB;
+};
+
+/**
+ * Series sorting criteria: series considered low priority are moved to the end
+ * of the list and series number is used to break ties
+ * @param {Object} firstSeries
+ * @param {Object} secondSeries
+ */
+function seriesInfoSortingCriteria(firstSeries, secondSeries) {
+  const aLowPriority = isLowPriorityModality(
+    firstSeries.Modality ?? firstSeries.modality
+  );
+  const bLowPriority = isLowPriorityModality(
+    secondSeries.Modality ?? secondSeries.modality
+  );
+
+  if (aLowPriority) {
+    return bLowPriority ? defaultSeriesSort(secondSeries, firstSeries) : 1;
+  } else if (bLowPriority) {
+    return -1;
+  }
+
+  return defaultSeriesSort(firstSeries, secondSeries);
+}
+
+const seriesSortCriteria = {
+  default: seriesInfoSortingCriteria,
+  seriesInfoSortingCriteria,
+};
+
+const instancesSortCriteria = {
+  default: (a, b) => parseInt(a.InstanceNumber) - parseInt(b.InstanceNumber),
+};
+
+const sortingCriteria = {
+  seriesSortCriteria,
+  instancesSortCriteria,
+};
+
+/**
+ * Sorts given series (given param is modified)
+ * The default criteria is based on series number in ascending order.
+ *
+ * @param {Array} series List of series
+ * @param {function} seriesSortingCriteria method for sorting
+ * @returns {Array} sorted series object
+ */
+const sortStudySeries = (
+  series,
+  seriesSortingCriteria = seriesSortCriteria.default,
+  sortFunction = null
+) => {
+  if (typeof sortFunction === 'function') return sortFunction(series);
+  else return series.sort(seriesSortingCriteria);
+};
+
+/**
+ * Sorts given instancesList (given param is modified)
+ * The default criteria is based on instance number in ascending order.
+ *
+ * @param {Array} instancesList List of series
+ * @param {function} instancesSortingCriteria method for sorting
+ * @returns {Array} sorted instancesList object
+ */
+const sortStudyInstances = (
+  instancesList,
+  instancesSortingCriteria = instancesSortCriteria.default
+) => {
+  return instancesList.sort(instancesSortingCriteria);
+};
+
+/**
+ * Sorts the series and instances (by default) inside a study instance based on sortingCriteria (given param is modified)
+ * The default criteria is based on series and instance numbers in ascending order.
+ *
+ * @param {Object} study The study instance
+ * @param {boolean} [deepSort = true] to sort instance also
+ * @param {function} [seriesSortingCriteria = seriesSortCriteria.default] method for sorting series
+ * @param {function} [instancesSortingCriteria = instancesSortCriteria.default] method for sorting instances
+ * @returns {Object} sorted study object
+ */
+export default function sortStudy(
+  study,
+  deepSort = true,
+  seriesSortingCriteria = seriesSortCriteria.default,
+  instancesSortingCriteria = instancesSortCriteria.default
+) {
+  if (!study || !study.series) {
+    throw new Error('Insufficient study data was provided to sortStudy');
+  }
+
+  sortStudySeries(study.series, seriesSortingCriteria);
+
+  if (deepSort) {
+    study.series.forEach(series => {
+      sortStudyInstances(series.instances, instancesSortingCriteria);
+    });
+  }
+
+  return study;
+}
+
+export {
+  sortStudy,
+  sortStudySeries,
+  sortStudyInstances,
+  sortingCriteria,
+  seriesSortCriteria,
+};