Custom hanging protocols for projects

function setViews(views: View[]) {
 //...
}
function setDimensions(numColumns: number, numRows: number) {
 // ...
}
function setWindowing(seriesIndex: number, level: number, width: number){
 // ...
}
function setThresholding(seriesIndex: number, min: number, max: number) {
 // ...
}
function setLabelSettings(labelSettings: LabelSetting) {
 // ...
}
function setLabelMirroring(viewIndex: number) {
  // ...
}

function nextTab()

function disableViewType(seriesIndex: number, typeName: 'AXIAL' | 'SAGITTAL' | 'CORONAL' | '3D' | 'MIP') { }


// this function has been replaced by the Tool Settings page of Project Settings
function setSegmentationSettings(
  [
    {
      toolName: ToolOptions;
      enabled: boolean;
      modes?: ToolModes[];
      defaultMode?: ToolModes;
      defaultTool?: boolean;
    }
  ]
);

// When a user uploads a Task and enables Hanging Protocols,
// the hangingProtocol() function takes Series[] and the following parameters as input
interface Series {
  seriesIndex: number;
  is2DImage: boolean;
  isVideo: boolean;
  numFrames: number;
  name: string; // User defined name if available, else "A", "B", ...
  imagingAxis: 'AXIAL' | 'SAGITTAL' | 'CORONAL';
}

interface View {
  plane: 'AXIAL' | 'SAGITTAL' | 'CORONAL' | '3D' | 'MIP';
  seriesIndex: number;
  flippedHorizontally?: boolean;
  flippedVertically?: boolean;
  synchronized?: boolean;
  expanded?: boolean; // Only applicable to a single view in a given Layout Tab
}

interface LabelSetting {
  opacity?: number;
  masking?: {
    editableArea?: 'EVERYWHERE' | 'INSIDE_ALL_SEGMENTS';
    modifyOtherSegments?: 'OVERLAP' | 'OVERWRITE_UNLOCKED_SEGMENTS';
  };
}

function hangingProtocol(allSeries: Series[]) {
  // This is the default layout script
  if (allSeries.length > 1) {
    setMultiSeries();
  } else if (allSeries[0].is2DImage) {
    setSingleView();
  } else {
    setMPR();
  }
}

function setSingleView(seriesIndex = 0) {
  setDimensions(1, 1);
  setViews([
    {
      plane: allSeries[seriesIndex].imagingAxis,
      seriesIndex: seriesIndex,
    },
  ]);
}

function setMultiSeries() {
  function singleSeries(series_, index) {
    return {
      plane: series_.imagingAxis,
      seriesIndex: index,
    };
  }
  let views = allSeries.map(singleSeries);

  setViews(views.slice(0, 9));
}

function setMPR(seriesIndex = 0) {
  let targetSeries = allSeries[seriesIndex];
  setDimensions(2, 2);
  setViews([
    {
      plane: "SAGITTAL",
      seriesIndex: seriesIndex,
      expanded: targetSeries.imagingAxis === "SAGITTAL",
    },
    {
      plane: "CORONAL",
      seriesIndex: seriesIndex,
      expanded: targetSeries.imagingAxis === "CORONAL",
    },
    {
      plane: "AXIAL",
      seriesIndex: seriesIndex,
      expanded: targetSeries.imagingAxis === "AXIAL",
    },
    {
      plane: "3D",
      seriesIndex: seriesIndex,
    },
  ]);
}

if (allSeries.length === 4) { // executes when there are 4 total Series in a Task
   setDimensions(2, 1); // set 2x1 layout for Layout Tab 1
   setViews( // adding the first and second image/volume to Layout Tab 1
   [
      {
         seriesIndex: 0,
         plane: 'SAGITTAL'
      },
      {
         seriesIndex: 1,
         plane: 'SAGITTAL'
      }
   ]
);
   nextTab(); // create and configure Layout Tab 2
   setDimensions(2, 1); // set 2x1 layout for Layout Tab 2
   setViews( // add third and fourth image/volume to Layout Tab 2
   [
      {
         seriesIndex: 2,
         plane: 'SAGITTAL'
      },
      {
         seriesIndex: 3,
         plane: 'SAGITTAL'
      }
   ]
 )

allSeries.forEach((series) => {
  disableViewType(series.seriesIndex, "3D");
});

[
  {
    seriesIndex: 0,
    is2DImage: false,
    isVideo: false,
    numFrames: 1,
    name: "T1",
    imagingAxis: "SAGITTAL",
  },
  {
    seriesIndex: 1,
    is2DImage: false,
    isVideo: false,
    numFrames: 1,
    name: "T2",
    imagingAxis: "SAGITTAL",
  },
  {
    seriesIndex: 2,
    is2DImage: false,
    isVideo: false,
    numFrames: 1,
    name: "T1CE",
    imagingAxis: "SAGITTAL",
  },
  {
    seriesIndex: 3,
    is2DImage: false,
    isVideo: false,
    numFrames: 1,
    name: "Flair",
    imagingAxis: "SAGITTAL",
  },
];

// sort series by Name
let priorities = ["t1", "t1ce", "t2", "flair"];
allSeries.sort(
  (a, b) => priorities.indexOf(a.name.toLowerCase()) - priorities.indexOf(b.name.toLowerCase()),
);

// display Series along the imaging axis
let imagingAxis = allSeries[0].imagingAxis;

// filter out views that were imaged in a different axis
let eligibleSeries = allSeries.filter((series) => series.imagingAxis === imagingAxis);

// Configure viewports
setViews(
  eligibleSeries.map((series) => {
    return {
      seriesIndex: series.seriesIndex,
      plane: series.imagingAxis,
      synchronized: true,
    };
  }),
);