@ohif/app 3.8.0-beta.8 → 3.8.0-beta.81

package/dist/335.bundle.8400aa5a88697a6b9d53.js

@@ -0,0 +1,2590 @@
+"use strict";
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[335],{
+
+/***/ 27335:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "default": () => (/* binding */ tmtv_src)
+});
+
+;// CONCATENATED MODULE: ../../../extensions/tmtv/package.json
+const package_namespaceObject = /*#__PURE__*/JSON.parse('{"UU":"@ohif/extension-tmtv"}');
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/id.js
+
+const id = package_namespaceObject.UU;
+
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/utils/hpViewports.ts
+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,
+      options: {
+        syncColormap: 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,
+      options: {
+        syncColormap: 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,
+      options: {
+        syncColormap: 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,
+      options: {
+        syncColormap: true
+      }
+    }, {
+      type: 'voi',
+      id: 'ptFusionWLSync',
+      source: true,
+      target: false,
+      options: {
+        syncInvertState: false
+      }
+    }]
+  },
+  displaySets: [{
+    options: {
+      voi: {
+        custom: 'getPTVOIRange'
+      },
+      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,
+      options: {
+        syncColormap: true
+      }
+    }, {
+      type: 'voi',
+      id: 'ptFusionWLSync',
+      source: true,
+      target: false,
+      options: {
+        syncInvertState: false
+      }
+    }]
+  },
+  displaySets: [{
+    options: {
+      voi: {
+        custom: 'getPTVOIRange'
+      },
+      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,
+      options: {
+        syncColormap: true
+      }
+    }, {
+      type: 'voi',
+      id: 'ptFusionWLSync',
+      source: true,
+      target: false,
+      options: {
+        syncInvertState: false
+      }
+    }]
+  },
+  displaySets: [{
+    options: {
+      voi: {
+        custom: 'getPTVOIRange'
+      },
+      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,
+      options: {
+        syncColormap: true
+      }
+    }, {
+      type: 'voi',
+      id: 'ptFusionWLSync',
+      source: false,
+      target: true,
+      options: {
+        syncInvertState: false
+      }
+    }]
+  },
+  displaySets: [{
+    id: 'ctDisplaySet'
+  }, {
+    id: 'ptDisplaySet',
+    options: {
+      colormap: {
+        name: 'hsv',
+        opacity: [{
+          value: 0,
+          opacity: 0
+        }, {
+          value: 0.1,
+          opacity: 0.9
+        }, {
+          value: 1,
+          opacity: 0.95
+        }]
+      },
+      voi: {
+        custom: 'getPTVOIRange'
+      }
+    }
+  }]
+};
+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,
+      options: {
+        syncColormap: true
+      }
+    }, {
+      type: 'voi',
+      id: 'ptFusionWLSync',
+      source: false,
+      target: true,
+      options: {
+        syncInvertState: false
+      }
+    }]
+  },
+  displaySets: [{
+    id: 'ctDisplaySet'
+  }, {
+    id: 'ptDisplaySet',
+    options: {
+      colormap: {
+        name: 'hsv',
+        opacity: [{
+          value: 0,
+          opacity: 0
+        }, {
+          value: 0.1,
+          opacity: 0.9
+        }, {
+          value: 1,
+          opacity: 0.95
+        }]
+      },
+      voi: {
+        custom: 'getPTVOIRange'
+      }
+    }
+  }]
+};
+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,
+      options: {
+        syncColormap: true
+      }
+    }, {
+      type: 'voi',
+      id: 'ptFusionWLSync',
+      source: false,
+      target: true,
+      options: {
+        syncInvertState: false
+      }
+    }]
+  },
+  displaySets: [{
+    id: 'ctDisplaySet'
+  }, {
+    id: 'ptDisplaySet',
+    options: {
+      colormap: {
+        name: 'hsv',
+        opacity: [{
+          value: 0,
+          opacity: 0
+        }, {
+          value: 0.1,
+          opacity: 0.9
+        }, {
+          value: 1,
+          opacity: 0.95
+        }]
+      },
+      voi: {
+        custom: 'getPTVOIRange'
+      }
+    }
+  }]
+};
+const mipSAGITTAL = {
+  viewportOptions: {
+    viewportId: 'mipSagittal',
+    viewportType: 'volume',
+    orientation: 'sagittal',
+    background: [1, 1, 1],
+    toolGroupId: 'mipToolGroup',
+    syncGroups: [{
+      type: 'voi',
+      id: 'ptWLSync',
+      source: true,
+      target: true,
+      options: {
+        syncColormap: true
+      }
+    }, {
+      type: 'voi',
+      id: 'ptFusionWLSync',
+      source: true,
+      target: false,
+      options: {
+        syncInvertState: 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: {
+        custom: 'getPTVOIRange'
+      },
+      voiInverted: true
+    },
+    id: 'ptDisplaySet'
+  }]
+};
+
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/getHangingProtocolModule.js
+
+
+/**
+ * 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,
+  name: 'Default',
+  createdDate: '2021-02-23T19:22:08.894Z',
+  modifiedDate: '2022-10-04T19:22:08.894Z',
+  availableTo: {},
+  editableBy: {},
+  imageLoadStrategy: 'interleaveTopToBottom',
+  // "default" , "interleaveTopToBottom",  "interleaveCenter"
+  protocolMatchingRules: [{
+    attribute: 'ModalitiesInStudy',
+    constraint: {
+      contains: ['CT', 'PT']
+    }
+  }, {
+    attribute: 'StudyDescription',
+    constraint: {
+      contains: 'PETCT'
+    }
+  }, {
+    attribute: 'StudyDescription',
+    constraint: {
+      contains: 'PET/CT'
+    }
+  }],
+  displaySetSelectors: {
+    ctDisplaySet: {
+      seriesMatchingRules: [{
+        attribute: 'Modality',
+        constraint: {
+          equals: {
+            value: 'CT'
+          }
+        },
+        required: true
+      }, {
+        attribute: 'isReconstructable',
+        constraint: {
+          equals: {
+            value: true
+          }
+        },
+        required: true
+      }, {
+        attribute: 'SeriesDescription',
+        constraint: {
+          contains: 'CT'
+        }
+      }, {
+        attribute: 'SeriesDescription',
+        constraint: {
+          contains: 'CT WB'
+        }
+      }]
+    },
+    ptDisplaySet: {
+      seriesMatchingRules: [{
+        attribute: 'Modality',
+        constraint: {
+          equals: 'PT'
+        },
+        required: true
+      }, {
+        attribute: 'isReconstructable',
+        constraint: {
+          equals: {
+            value: true
+          }
+        },
+        required: true
+      }, {
+        attribute: 'SeriesDescription',
+        constraint: {
+          contains: 'Corrected'
+        }
+      }, {
+        weight: 2,
+        attribute: 'SeriesDescription',
+        constraint: {
+          doesNotContain: {
+            value: 'Uncorrected'
+          }
+        }
+      }]
+    }
+  },
+  stages: [stage1, stage2, stage3, stage4],
+  numberOfPriorsReferenced: -1
+};
+function getHangingProtocolModule() {
+  return [{
+    name: ptCT.id,
+    protocol: ptCT
+  }];
+}
+/* harmony default export */ const src_getHangingProtocolModule = (getHangingProtocolModule);
+// EXTERNAL MODULE: ../../../node_modules/react/index.js
+var react = __webpack_require__(41766);
+// EXTERNAL MODULE: ../../../node_modules/prop-types/index.js
+var prop_types = __webpack_require__(11374);
+var prop_types_default = /*#__PURE__*/__webpack_require__.n(prop_types);
+// EXTERNAL MODULE: ../../ui/src/index.js + 785 modules
+var src = __webpack_require__(5085);
+// EXTERNAL MODULE: ../../core/src/index.ts + 70 modules
+var core_src = __webpack_require__(55411);
+// EXTERNAL MODULE: ../../../node_modules/react-i18next/dist/es/index.js + 15 modules
+var es = __webpack_require__(80619);
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/Panels/PanelPetSUV.tsx
+
+
+
+
+
+const DEFAULT_MEATADATA = {
+  PatientWeight: null,
+  PatientSex: null,
+  SeriesTime: null,
+  RadiopharmaceuticalInformationSequence: {
+    RadionuclideTotalDose: null,
+    RadionuclideHalfLife: null,
+    RadiopharmaceuticalStartTime: null
+  }
+};
+
+/*
+ * PETSUV panel enables the user to modify the patient related information, such as
+ * patient sex, patientWeight. This is allowed since
+ * sometimes these metadata are missing or wrong. By changing them
+ * @param param0
+ * @returns
+ */
+function PanelPetSUV({
+  servicesManager,
+  commandsManager
+}) {
+  const {
+    t
+  } = (0,es/* useTranslation */.Bd)('PanelSUV');
+  const {
+    displaySetService,
+    toolGroupService,
+    toolbarService,
+    hangingProtocolService
+  } = servicesManager.services;
+  const [metadata, setMetadata] = (0,react.useState)(DEFAULT_MEATADATA);
+  const [ptDisplaySet, setPtDisplaySet] = (0,react.useState)(null);
+  const handleMetadataChange = metadata => {
+    setMetadata(prevState => {
+      const newState = {
+        ...prevState
+      };
+      Object.keys(metadata).forEach(key => {
+        if (typeof metadata[key] === 'object') {
+          newState[key] = {
+            ...prevState[key],
+            ...metadata[key]
+          };
+        } else {
+          newState[key] = metadata[key];
+        }
+      });
+      return newState;
+    });
+  };
+  const getMatchingPTDisplaySet = viewportMatchDetails => {
+    const ptDisplaySet = commandsManager.runCommand('getMatchingPTDisplaySet', {
+      viewportMatchDetails
+    });
+    if (!ptDisplaySet) {
+      return;
+    }
+    const metadata = commandsManager.runCommand('getPTMetadata', {
+      ptDisplaySet
+    });
+    return {
+      ptDisplaySet,
+      metadata
+    };
+  };
+  (0,react.useEffect)(() => {
+    const displaySets = displaySetService.getActiveDisplaySets();
+    const {
+      viewportMatchDetails
+    } = hangingProtocolService.getMatchDetails();
+    if (!displaySets.length) {
+      return;
+    }
+    const displaySetInfo = getMatchingPTDisplaySet(viewportMatchDetails);
+    if (!displaySetInfo) {
+      return;
+    }
+    const {
+      ptDisplaySet,
+      metadata
+    } = displaySetInfo;
+    setPtDisplaySet(ptDisplaySet);
+    setMetadata(metadata);
+  }, []);
+
+  // get the patientMetadata from the StudyInstanceUIDs and update the state
+  (0,react.useEffect)(() => {
+    const {
+      unsubscribe
+    } = hangingProtocolService.subscribe(hangingProtocolService.EVENTS.PROTOCOL_CHANGED, ({
+      viewportMatchDetails
+    }) => {
+      const displaySetInfo = getMatchingPTDisplaySet(viewportMatchDetails);
+      if (!displaySetInfo) {
+        return;
+      }
+      const {
+        ptDisplaySet,
+        metadata
+      } = displaySetInfo;
+      setPtDisplaySet(ptDisplaySet);
+      setMetadata(metadata);
+    });
+    return () => {
+      unsubscribe();
+    };
+  }, []);
+  function updateMetadata() {
+    if (!ptDisplaySet) {
+      throw new Error('No ptDisplaySet found');
+    }
+
+    // metadata should be dcmjs naturalized
+    core_src.DicomMetadataStore.updateMetadataForSeries(ptDisplaySet.StudyInstanceUID, ptDisplaySet.SeriesInstanceUID, metadata);
+
+    // update the displaySets
+    displaySetService.setDisplaySetMetadataInvalidated(ptDisplaySet.displaySetInstanceUID);
+
+    // Crosshair position depends on the metadata values such as the positioning interaction
+    // between series, so when the metadata is updated, the crosshairs need to be reset.
+    setTimeout(() => {
+      commandsManager.runCommand('resetCrosshairs');
+    }, 0);
+  }
+  return /*#__PURE__*/react.createElement("div", {
+    className: "ohif-scrollbar flex min-h-0 flex-auto select-none flex-col justify-between overflow-auto"
+  }, /*#__PURE__*/react.createElement("div", {
+    className: "flex min-h-0 flex-1 flex-col bg-black text-[13px] font-[300]"
+  }, /*#__PURE__*/react.createElement(src/* PanelSection */.aU, {
+    title: t('Patient Information')
+  }, /*#__PURE__*/react.createElement("div", {
+    className: "flex flex-col"
+  }, /*#__PURE__*/react.createElement("div", {
+    className: "bg-primary-dark flex flex-col gap-4 p-2"
+  }, /*#__PURE__*/react.createElement(src/* Input */.pd, {
+    containerClassName: '!flex-row !justify-between items-center',
+    label: t('Patient Sex'),
+    labelClassName: "text-[13px] font-inter text-white",
+    className: "!m-0 !h-[26px] !w-[117px]",
+    value: metadata.PatientSex || '',
+    onChange: e => {
+      handleMetadataChange({
+        PatientSex: e.target.value
+      });
+    }
+  }), /*#__PURE__*/react.createElement(src/* Input */.pd, {
+    containerClassName: '!flex-row !justify-between items-center',
+    label: t('Weight'),
+    labelChildren: /*#__PURE__*/react.createElement("span", {
+      className: "text-aqua-pale"
+    }, " kg"),
+    labelClassName: "text-[13px] font-inter text-white",
+    className: "!m-0 !h-[26px] !w-[117px]",
+    value: metadata.PatientWeight || '',
+    onChange: e => {
+      handleMetadataChange({
+        PatientWeight: e.target.value
+      });
+    }
+  }), /*#__PURE__*/react.createElement(src/* Input */.pd, {
+    containerClassName: '!flex-row !justify-between items-center',
+    label: t('Total Dose'),
+    labelChildren: /*#__PURE__*/react.createElement("span", {
+      className: "text-aqua-pale"
+    }, " bq"),
+    labelClassName: "text-[13px] font-inter text-white",
+    className: "!m-0 !h-[26px] !w-[117px]",
+    value: metadata.RadiopharmaceuticalInformationSequence.RadionuclideTotalDose || '',
+    onChange: e => {
+      handleMetadataChange({
+        RadiopharmaceuticalInformationSequence: {
+          RadionuclideTotalDose: e.target.value
+        }
+      });
+    }
+  }), /*#__PURE__*/react.createElement(src/* Input */.pd, {
+    containerClassName: '!flex-row !justify-between items-center',
+    label: t('Half Life'),
+    labelChildren: /*#__PURE__*/react.createElement("span", {
+      className: "text-aqua-pale"
+    }, " s"),
+    labelClassName: "text-[13px] font-inter text-white",
+    className: "!m-0 !h-[26px] !w-[117px]",
+    value: metadata.RadiopharmaceuticalInformationSequence.RadionuclideHalfLife || '',
+    onChange: e => {
+      handleMetadataChange({
+        RadiopharmaceuticalInformationSequence: {
+          RadionuclideHalfLife: e.target.value
+        }
+      });
+    }
+  }), /*#__PURE__*/react.createElement(src/* Input */.pd, {
+    containerClassName: '!flex-row !justify-between items-center',
+    label: t('Injection Time'),
+    labelChildren: /*#__PURE__*/react.createElement("span", {
+      className: "text-aqua-pale"
+    }, " s"),
+    labelClassName: "text-[13px] font-inter text-white",
+    className: "!m-0 !h-[26px] !w-[117px]",
+    value: metadata.RadiopharmaceuticalInformationSequence.RadiopharmaceuticalStartTime || '',
+    onChange: e => {
+      handleMetadataChange({
+        RadiopharmaceuticalInformationSequence: {
+          RadiopharmaceuticalStartTime: e.target.value
+        }
+      });
+    }
+  }), /*#__PURE__*/react.createElement(src/* Input */.pd, {
+    containerClassName: '!flex-row !justify-between items-center',
+    label: t('Acquisition Time'),
+    labelChildren: /*#__PURE__*/react.createElement("span", {
+      className: "text-aqua-pale"
+    }, " s"),
+    labelClassName: "text-[13px] font-inter text-white",
+    className: "!m-0 !h-[26px] !w-[117px]",
+    value: metadata.SeriesTime || '',
+    onChange: () => {}
+  }), /*#__PURE__*/react.createElement(src/* Button */.$n, {
+    className: "!h-[26px] !w-[115px] self-end !p-0",
+    onClick: updateMetadata
+  }, "Reload Data"))))));
+}
+PanelPetSUV.propTypes = {
+  servicesManager: prop_types_default().shape({
+    services: prop_types_default().shape({
+      measurementService: prop_types_default().shape({
+        getMeasurements: (prop_types_default()).func.isRequired,
+        subscribe: (prop_types_default()).func.isRequired,
+        EVENTS: (prop_types_default()).object.isRequired,
+        VALUE_TYPES: (prop_types_default()).object.isRequired
+      }).isRequired
+    }).isRequired
+  }).isRequired
+};
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/Panels/PanelROIThresholdSegmentation/PanelROIThresholdExport.tsx
+
+
+
+
+function PanelRoiThresholdSegmentation({
+  servicesManager,
+  commandsManager
+}) {
+  const {
+    segmentationService,
+    uiNotificationService
+  } = servicesManager.services;
+  const {
+    t
+  } = (0,es/* useTranslation */.Bd)('PanelSUVExport');
+  const [segmentations, setSegmentations] = (0,react.useState)(() => segmentationService.getSegmentations());
+
+  /**
+   * Update UI based on segmentation changes (added, removed, updated)
+   */
+  (0,react.useEffect)(() => {
+    // ~~ Subscription
+    const added = segmentationService.EVENTS.SEGMENTATION_ADDED;
+    const updated = segmentationService.EVENTS.SEGMENTATION_UPDATED;
+    const removed = segmentationService.EVENTS.SEGMENTATION_REMOVED;
+    const subscriptions = [];
+    [added, updated, removed].forEach(evt => {
+      const {
+        unsubscribe
+      } = segmentationService.subscribe(evt, () => {
+        const segmentations = segmentationService.getSegmentations();
+        setSegmentations(segmentations);
+      });
+      subscriptions.push(unsubscribe);
+    });
+    return () => {
+      subscriptions.forEach(unsub => {
+        unsub();
+      });
+    };
+  }, []);
+  const tmtvValue = segmentations?.[0]?.cachedStats?.tmtv?.value || null;
+  const config = segmentations?.[0]?.cachedStats?.tmtv?.config || {};
+  segmentations.forEach(segmentation => {
+    const {
+      cachedStats
+    } = segmentation;
+    if (!cachedStats) {
+      return;
+    }
+
+    // segment 1
+    const suvPeak = cachedStats?.['1']?.suvPeak?.suvPeak;
+    if (Number.isNaN(suvPeak)) {
+      uiNotificationService.show({
+        title: 'SUV Peak',
+        message: 'Segmented volume does not allow SUV Peak calculation',
+        type: 'warning'
+      });
+    }
+  });
+  const actions = [{
+    label: 'Export CSV',
+    onClick: () => {
+      commandsManager.runCommand('exportTMTVReportCSV', {
+        segmentations,
+        tmtv: tmtvValue,
+        config
+      });
+    },
+    disabled: tmtvValue === null
+  }, {
+    label: 'Create RT Report',
+    onClick: () => {
+      commandsManager.runCommand('createTMTVRTReport');
+    },
+    disabled: tmtvValue === null
+  }];
+  return /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement("div", {
+    className: "mt-2 mb-10 flex flex-col"
+  }, /*#__PURE__*/react.createElement("div", {
+    className: "invisible-scrollbar overflow-y-auto overflow-x-hidden"
+  }, tmtvValue !== null ? /*#__PURE__*/react.createElement("div", {
+    className: "bg-secondary-dark mt-1 flex items-baseline justify-between px-2 py-1"
+  }, /*#__PURE__*/react.createElement("span", {
+    className: "text-base font-bold uppercase tracking-widest text-white"
+  }, 'TMTV:'), /*#__PURE__*/react.createElement("div", {
+    className: "text-white"
+  }, `${tmtvValue} mL`)) : null, /*#__PURE__*/react.createElement("div", {
+    className: "mt-2 flex justify-center"
+  }, /*#__PURE__*/react.createElement(src/* ActionButtons */.wr, {
+    actions: actions,
+    t: t
+  })))), /*#__PURE__*/react.createElement("div", {
+    className: "absolute bottom-1 flex cursor-pointer items-center justify-center text-blue-400 opacity-50 hover:opacity-80",
+    onClick: () => {
+      // navigate to a url in a new tab
+      window.open('https://github.com/OHIF/Viewers/blob/master/modes/tmtv/README.md', '_blank');
+    }
+  }, /*#__PURE__*/react.createElement(src/* Icon */.In, {
+    width: "15px",
+    height: "15px",
+    name: 'info',
+    className: 'text-primary-active ml-4 mr-3'
+  }), /*#__PURE__*/react.createElement("span", null, 'User Guide')));
+}
+PanelRoiThresholdSegmentation.propTypes = {
+  commandsManager: prop_types_default().shape({
+    runCommand: (prop_types_default()).func.isRequired
+  }),
+  servicesManager: prop_types_default().shape({
+    services: prop_types_default().shape({
+      segmentationService: prop_types_default().shape({
+        getSegmentation: (prop_types_default()).func.isRequired,
+        getSegmentations: (prop_types_default()).func.isRequired,
+        toggleSegmentationVisibility: (prop_types_default()).func.isRequired,
+        subscribe: (prop_types_default()).func.isRequired,
+        EVENTS: (prop_types_default()).object.isRequired
+      }).isRequired
+    }).isRequired
+  }).isRequired
+};
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/Panels/PanelROIThresholdSegmentation/index.ts
+
+/* harmony default export */ const PanelROIThresholdSegmentation = (PanelRoiThresholdSegmentation);
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/Panels/index.tsx
+
+
+
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/getPanelModule.tsx
+
+
+
+
+// TODO:
+// - No loading UI exists yet
+// - cancel promises when component is destroyed
+// - show errors in UI for thumbnails if promise fails
+
+function getPanelModule({
+  commandsManager,
+  extensionManager,
+  servicesManager
+}) {
+  const wrappedPanelPetSuv = () => {
+    return /*#__PURE__*/react.createElement(PanelPetSUV, {
+      commandsManager: commandsManager,
+      servicesManager: servicesManager
+    });
+  };
+  const wrappedROIThresholdToolbox = () => {
+    return /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement(src/* Toolbox */.OO, {
+      commandsManager: commandsManager,
+      servicesManager: servicesManager,
+      extensionManager: extensionManager,
+      buttonSectionId: "ROIThresholdToolbox",
+      title: "Threshold Tools"
+    }));
+  };
+  const wrappedROIThresholdExport = () => {
+    return /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement(PanelROIThresholdSegmentation, {
+      commandsManager: commandsManager,
+      servicesManager: servicesManager
+    }));
+  };
+  return [{
+    name: 'petSUV',
+    iconName: 'tab-patient-info',
+    iconLabel: 'Patient Info',
+    label: 'Patient Info',
+    component: wrappedPanelPetSuv
+  }, {
+    name: 'tmtvBox',
+    iconName: 'tab-segmentation',
+    iconLabel: 'Segmentation',
+    label: 'Segmentation Toolbox',
+    component: wrappedROIThresholdToolbox
+  }, {
+    name: 'tmtvExport',
+    iconName: 'tab-segmentation',
+    iconLabel: 'Segmentation',
+    label: 'Segmentation Export',
+    component: wrappedROIThresholdExport
+  }];
+}
+/* harmony default export */ const src_getPanelModule = (getPanelModule);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/index.js + 18 modules
+var esm = __webpack_require__(24542);
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/utils/measurementServiceMappings/constants/supportedTools.js
+/* harmony default export */ const supportedTools = (['RectangleROIStartEndThreshold']);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 327 modules
+var dist_esm = __webpack_require__(44656);
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/utils/measurementServiceMappings/utils/getSOPInstanceAttributes.js
+
+function getSOPInstanceAttributes(imageId) {
+  if (imageId) {
+    return _getUIDFromImageID(imageId);
+  }
+}
+function _getUIDFromImageID(imageId) {
+  const instance = dist_esm.metaData.get('instance', imageId);
+  return {
+    SOPInstanceUID: instance.SOPInstanceUID,
+    SeriesInstanceUID: instance.SeriesInstanceUID,
+    StudyInstanceUID: instance.StudyInstanceUID,
+    frameNumber: instance.frameNumber || 1
+  };
+}
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/utils/measurementServiceMappings/RectangleROIStartEndThreshold.js
+
+
+const RectangleROIStartEndThreshold = {
+  toAnnotation: (measurement, definition) => {},
+  /**
+   * Maps cornerstone annotation event data to measurement service format.
+   *
+   * @param {Object} cornerstone Cornerstone event data
+   * @return {Measurement} Measurement instance
+   */
+  toMeasurement: (csToolsEventDetail, displaySetService, cornerstoneViewportService) => {
+    const {
+      annotation,
+      viewportId
+    } = csToolsEventDetail;
+    const {
+      metadata,
+      data,
+      annotationUID
+    } = annotation;
+    if (!metadata || !data) {
+      console.warn('Length tool: Missing metadata or data');
+      return null;
+    }
+    const {
+      toolName,
+      referencedImageId,
+      FrameOfReferenceUID
+    } = metadata;
+    const validToolType = supportedTools.includes(toolName);
+    if (!validToolType) {
+      throw new Error('Tool not supported');
+    }
+    const {
+      SOPInstanceUID,
+      SeriesInstanceUID,
+      StudyInstanceUID
+    } = getSOPInstanceAttributes(referencedImageId, cornerstoneViewportService, viewportId);
+    let displaySet;
+    if (SOPInstanceUID) {
+      displaySet = displaySetService.getDisplaySetForSOPInstanceUID(SOPInstanceUID, SeriesInstanceUID);
+    } else {
+      displaySet = displaySetService.getDisplaySetsForSeries(SeriesInstanceUID);
+    }
+    return {
+      uid: annotationUID,
+      SOPInstanceUID,
+      FrameOfReferenceUID,
+      // points,
+      metadata,
+      referenceSeriesUID: SeriesInstanceUID,
+      referenceStudyUID: StudyInstanceUID,
+      toolName: metadata.toolName,
+      displaySetInstanceUID: displaySet.displaySetInstanceUID,
+      label: metadata.label,
+      data: data.cachedStats,
+      type: 'RectangleROIStartEndThreshold'
+    };
+  }
+};
+/* harmony default export */ const measurementServiceMappings_RectangleROIStartEndThreshold = (RectangleROIStartEndThreshold);
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/utils/measurementServiceMappings/measurementServiceMappingsFactory.js
+
+const measurementServiceMappingsFactory = (measurementService, displaySetService, cornerstoneViewportService) => {
+  return {
+    RectangleROIStartEndThreshold: {
+      toAnnotation: measurementServiceMappings_RectangleROIStartEndThreshold.toAnnotation,
+      toMeasurement: csToolsAnnotation => measurementServiceMappings_RectangleROIStartEndThreshold.toMeasurement(csToolsAnnotation, displaySetService, cornerstoneViewportService),
+      matchingCriteria: [{
+        valueType: measurementService.VALUE_TYPES.ROI_THRESHOLD_MANUAL
+      }]
+    }
+  };
+};
+/* harmony default export */ const measurementServiceMappings_measurementServiceMappingsFactory = (measurementServiceMappingsFactory);
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/init.js
+
+
+const CORNERSTONE_3D_TOOLS_SOURCE_NAME = 'Cornerstone3DTools';
+const CORNERSTONE_3D_TOOLS_SOURCE_VERSION = '0.1';
+/**
+ *
+ * @param {Object} servicesManager
+ * @param {Object} configuration
+ * @param {Object|Array} configuration.csToolsConfig
+ */
+function init({
+  servicesManager
+}) {
+  const {
+    measurementService,
+    displaySetService,
+    cornerstoneViewportService
+  } = servicesManager.services;
+  (0,esm.addTool)(esm.RectangleROIStartEndThresholdTool);
+  const {
+    RectangleROIStartEndThreshold
+  } = measurementServiceMappings_measurementServiceMappingsFactory(measurementService, displaySetService, cornerstoneViewportService);
+  const csTools3DVer1MeasurementSource = measurementService.getSource(CORNERSTONE_3D_TOOLS_SOURCE_NAME, CORNERSTONE_3D_TOOLS_SOURCE_VERSION);
+  measurementService.addMapping(csTools3DVer1MeasurementSource, 'RectangleROIStartEndThreshold', RectangleROIStartEndThreshold.matchingCriteria, RectangleROIStartEndThreshold.toAnnotation, RectangleROIStartEndThreshold.toMeasurement);
+}
+// EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
+var gl_matrix_esm = __webpack_require__(44753);
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/utils/getThresholdValue.ts
+
+function getRoiStats(referencedVolume, annotations) {
+  // roiStats
+  const {
+    imageData
+  } = referencedVolume;
+  const values = imageData.getPointData().getScalars().getData();
+
+  // Todo: add support for other strategies
+  const {
+    fn,
+    baseValue
+  } = _getStrategyFn('max');
+  let value = baseValue;
+  const boundsIJK = esm.utilities.rectangleROITool.getBoundsIJKFromRectangleAnnotations(annotations, referencedVolume);
+  const [[iMin, iMax], [jMin, jMax], [kMin, kMax]] = boundsIJK;
+  for (let i = iMin; i <= iMax; i++) {
+    for (let j = jMin; j <= jMax; j++) {
+      for (let k = kMin; k <= kMax; k++) {
+        const offset = imageData.computeOffsetIndex([i, j, k]);
+        value = fn(values[offset], value);
+      }
+    }
+  }
+  return value;
+}
+function getThresholdValues(annotationUIDs, referencedVolumes, config) {
+  if (config.strategy === 'range') {
+    return {
+      ptLower: Number(config.ptLower),
+      ptUpper: Number(config.ptUpper),
+      ctLower: Number(config.ctLower),
+      ctUpper: Number(config.ctUpper)
+    };
+  }
+  const {
+    weight
+  } = config;
+  const annotations = annotationUIDs.map(annotationUID => esm.annotation.state.getAnnotation(annotationUID));
+  const ptValue = getRoiStats(referencedVolumes[0], annotations);
+  return {
+    ctLower: -Infinity,
+    ctUpper: +Infinity,
+    ptLower: weight * ptValue,
+    ptUpper: +Infinity
+  };
+}
+function _getStrategyFn(statistic) {
+  const baseValue = -Infinity;
+  const fn = (number, maxValue) => {
+    if (number > maxValue) {
+      maxValue = number;
+    }
+    return maxValue;
+  };
+  return {
+    fn,
+    baseValue
+  };
+}
+/* harmony default export */ const getThresholdValue = (getThresholdValues);
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/utils/calculateSUVPeak.ts
+
+
+/**
+ * This method calculates the SUV peak on a segmented ROI from a reference PET
+ * volume. If a rectangle annotation is provided, the peak is calculated within that
+ * rectangle. Otherwise, the calculation is performed on the entire volume which
+ * will be slower but same result.
+ * @param viewport Viewport to use for the calculation
+ * @param labelmap Labelmap from which the mask is taken
+ * @param referenceVolume PET volume to use for SUV calculation
+ * @param toolData [Optional] list of toolData to use for SUV calculation
+ * @param segmentIndex The index of the segment to use for masking
+ * @returns
+ */
+function calculateSuvPeak(labelmap, referenceVolume, annotations, segmentIndex = 1) {
+  if (referenceVolume.metadata.Modality !== 'PT') {
+    return;
+  }
+  const labelmapData = labelmap.getScalarData();
+  const referenceVolumeData = referenceVolume.getScalarData();
+  if (labelmapData.length !== referenceVolumeData.length) {
+    throw new Error('labelmap and referenceVolume must have the same number of pixels');
+  }
+  const {
+    dimensions,
+    imageData: labelmapImageData
+  } = labelmap;
+  const {
+    imageData: referenceVolumeImageData
+  } = referenceVolume;
+  let boundsIJK;
+  // Todo: using the first annotation for now
+  if (annotations?.length && annotations[0].data?.cachedStats) {
+    const {
+      projectionPoints
+    } = annotations[0].data.cachedStats;
+    const pointsToUse = [].concat(...projectionPoints); // cannot use flat() because of typescript compiler right now
+
+    const rectangleCornersIJK = pointsToUse.map(world => {
+      const ijk = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(0, 0, 0);
+      referenceVolumeImageData.worldToIndex(world, ijk);
+      return ijk;
+    });
+    boundsIJK = esm.utilities.boundingBox.getBoundingBoxAroundShape(rectangleCornersIJK, dimensions);
+  }
+  let max = 0;
+  let maxIJK = [0, 0, 0];
+  let maxLPS = [0, 0, 0];
+  const callback = ({
+    pointIJK,
+    pointLPS
+  }) => {
+    const offset = referenceVolumeImageData.computeOffsetIndex(pointIJK);
+    const value = labelmapData[offset];
+    if (value !== segmentIndex) {
+      return;
+    }
+    const referenceValue = referenceVolumeData[offset];
+    if (referenceValue > max) {
+      max = referenceValue;
+      maxIJK = pointIJK;
+      maxLPS = pointLPS;
+    }
+  };
+  esm.utilities.pointInShapeCallback(labelmapImageData, () => true, callback, boundsIJK);
+  const direction = labelmapImageData.getDirection().slice(0, 3);
+
+  /**
+   * 2. Find the bottom and top of the great circle for the second sphere (1cc sphere)
+   * V = (4/3)πr3
+   */
+  const radius = Math.pow(1 / (4 / 3 * Math.PI), 1 / 3) * 10;
+  const diameter = radius * 2;
+  const secondaryCircleWorld = gl_matrix_esm/* vec3.create */.eR.create();
+  const bottomWorld = gl_matrix_esm/* vec3.create */.eR.create();
+  const topWorld = gl_matrix_esm/* vec3.create */.eR.create();
+  referenceVolumeImageData.indexToWorld(maxIJK, secondaryCircleWorld);
+  gl_matrix_esm/* vec3.scaleAndAdd */.eR.scaleAndAdd(bottomWorld, secondaryCircleWorld, direction, -diameter / 2);
+  gl_matrix_esm/* vec3.scaleAndAdd */.eR.scaleAndAdd(topWorld, secondaryCircleWorld, direction, diameter / 2);
+  const suvPeakCirclePoints = [bottomWorld, topWorld];
+
+  /**
+   * 3. Find the Mean and Max of the 1cc sphere centered on the suv Max of the previous
+   * sphere
+   */
+  let count = 0;
+  let acc = 0;
+  const suvPeakMeanCallback = ({
+    value
+  }) => {
+    acc += value;
+    count += 1;
+  };
+  esm.utilities.pointInSurroundingSphereCallback(referenceVolumeImageData, suvPeakCirclePoints, suvPeakMeanCallback);
+  const mean = acc / count;
+  return {
+    max,
+    maxIJK,
+    maxLPS,
+    mean
+  };
+}
+/* harmony default export */ const calculateSUVPeak = (calculateSuvPeak);
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/utils/calculateTMTV.ts
+
+
+/**
+ * Given a list of labelmaps (with the possibility of overlapping regions),
+ * and a referenceVolume, it calculates the total metabolic tumor volume (TMTV)
+ * by flattening and rasterizing each segment into a single labelmap and summing
+ * the total number of volume voxels. It should be noted that for this calculation
+ * we do not double count voxels that are part of multiple labelmaps.
+ * @param {} labelmaps
+ * @param {number} segmentIndex
+ * @returns {number} TMTV in ml
+ */
+function calculateTMTV(labelmaps, segmentIndex = 1) {
+  const volumeId = 'mergedLabelmap';
+  const mergedLabelmap = esm.utilities.segmentation.createMergedLabelmapForIndex(labelmaps, segmentIndex, volumeId);
+  const {
+    imageData,
+    spacing
+  } = mergedLabelmap;
+  const values = imageData.getPointData().getScalars().getData();
+
+  // count non-zero values inside the outputData, this would
+  // consider the overlapping regions to be only counted once
+  const numVoxels = values.reduce((acc, curr) => {
+    if (curr > 0) {
+      return acc + 1;
+    }
+    return acc;
+  }, 0);
+  return 1e-3 * numVoxels * spacing[0] * spacing[1] * spacing[2];
+}
+/* harmony default export */ const utils_calculateTMTV = (calculateTMTV);
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/utils/createAndDownloadTMTVReport.js
+function createAndDownloadTMTVReport(segReport, additionalReportRows, options = {}) {
+  const firstReport = segReport[Object.keys(segReport)[0]];
+  const columns = Object.keys(firstReport);
+  const csv = [columns.join(',')];
+  Object.values(segReport).forEach(segmentation => {
+    const row = [];
+    columns.forEach(column => {
+      // if it is array then we need to replace , with space to avoid csv parsing error
+      row.push(Array.isArray(segmentation[column]) ? segmentation[column].join(' ') : segmentation[column]);
+    });
+    csv.push(row.join(','));
+  });
+  csv.push('');
+  csv.push('');
+  csv.push('');
+  csv.push(`Patient ID,${firstReport.PatientID}`);
+  csv.push(`Study Date,${firstReport.StudyDate}`);
+  csv.push('');
+  additionalReportRows.forEach(({
+    key,
+    value: values
+  }) => {
+    const temp = [];
+    temp.push(`${key}`);
+    Object.keys(values).forEach(k => {
+      temp.push(`${k}`);
+      temp.push(`${values[k]}`);
+    });
+    csv.push(temp.join(','));
+  });
+  const blob = new Blob([csv.join('\n')], {
+    type: 'text/csv;charset=utf-8'
+  });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = options.filename ?? `${firstReport.PatientID}_tmtv.csv`;
+  a.click();
+}
+// EXTERNAL MODULE: ../../../node_modules/dcmjs/build/dcmjs.es.js
+var dcmjs_es = __webpack_require__(31426);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/adapters/dist/adapters.es.js
+var adapters_es = __webpack_require__(83342);
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/utils/dicomRTAnnotationExport/RTStructureSet/dicomRTAnnotationExport.js
+
+
+
+const {
+  datasetToBlob
+} = dcmjs_es/* default.data */.Ay.data;
+const metadataProvider = core_src.classes.MetadataProvider;
+function dicomRTAnnotationExport(annotations) {
+  const dataset = adapters_es/* adaptersRT */.f_.Cornerstone3D.RTSS.generateRTSSFromAnnotations(annotations, metadataProvider, core_src.DicomMetadataStore);
+  const reportBlob = datasetToBlob(dataset);
+
+  //Create a URL for the binary.
+  var objectUrl = URL.createObjectURL(reportBlob);
+  window.location.assign(objectUrl);
+}
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/utils/dicomRTAnnotationExport/RTStructureSet/index.js
+
+/* harmony default export */ const RTStructureSet = (dicomRTAnnotationExport);
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/commandsModule.js
+
+
+
+
+
+
+
+
+
+
+const commandsModule_metadataProvider = core_src.classes.MetadataProvider;
+const RECTANGLE_ROI_THRESHOLD_MANUAL_TOOL_IDS = ['RectangleROIStartEndThreshold', 'RectangleROIThreshold'];
+const LABELMAP = esm.Enums.SegmentationRepresentations.Labelmap;
+const commandsModule = ({
+  servicesManager,
+  commandsManager,
+  extensionManager
+}) => {
+  const {
+    viewportGridService,
+    uiNotificationService,
+    displaySetService,
+    hangingProtocolService,
+    toolGroupService,
+    cornerstoneViewportService,
+    segmentationService
+  } = servicesManager.services;
+  const utilityModule = extensionManager.getModuleEntry('@ohif/extension-cornerstone.utilityModule.common');
+  const {
+    getEnabledElement
+  } = utilityModule.exports;
+  function _getActiveViewportsEnabledElement() {
+    const {
+      activeViewportId
+    } = viewportGridService.getState();
+    const {
+      element
+    } = getEnabledElement(activeViewportId) || {};
+    const enabledElement = dist_esm.getEnabledElement(element);
+    return enabledElement;
+  }
+  function _getMatchedViewportsToolGroupIds() {
+    const {
+      viewportMatchDetails
+    } = hangingProtocolService.getMatchDetails();
+    const toolGroupIds = [];
+    viewportMatchDetails.forEach(viewport => {
+      const {
+        viewportOptions
+      } = viewport;
+      const {
+        toolGroupId
+      } = viewportOptions;
+      if (toolGroupIds.indexOf(toolGroupId) === -1) {
+        toolGroupIds.push(toolGroupId);
+      }
+    });
+    return toolGroupIds;
+  }
+  function _getAnnotationsSelectedByToolNames(toolNames) {
+    return toolNames.reduce((allAnnotationUIDs, toolName) => {
+      const annotationUIDs = esm.annotation.selection.getAnnotationsSelectedByToolName(toolName);
+      return allAnnotationUIDs.concat(annotationUIDs);
+    }, []);
+  }
+  const actions = {
+    getMatchingPTDisplaySet: ({
+      viewportMatchDetails
+    }) => {
+      // Todo: this is assuming that the hanging protocol has successfully matched
+      // the correct PT. For future, we should have a way to filter out the PTs
+      // that are in the viewer layout (but then we have the problem of the attenuation
+      // corrected PT vs the non-attenuation correct PT)
+
+      let ptDisplaySet = null;
+      for (const [viewportId, viewportDetails] of viewportMatchDetails) {
+        const {
+          displaySetsInfo
+        } = viewportDetails;
+        const displaySets = displaySetsInfo.map(({
+          displaySetInstanceUID
+        }) => displaySetService.getDisplaySetByUID(displaySetInstanceUID));
+        if (!displaySets || displaySets.length === 0) {
+          continue;
+        }
+        ptDisplaySet = displaySets.find(displaySet => displaySet.Modality === 'PT');
+        if (ptDisplaySet) {
+          break;
+        }
+      }
+      return ptDisplaySet;
+    },
+    getPTMetadata: ({
+      ptDisplaySet
+    }) => {
+      const dataSource = extensionManager.getDataSources()[0];
+      const imageIds = dataSource.getImageIdsForDisplaySet(ptDisplaySet);
+      const firstImageId = imageIds[0];
+      const instance = commandsModule_metadataProvider.get('instance', firstImageId);
+      if (instance.Modality !== 'PT') {
+        return;
+      }
+      const metadata = {
+        SeriesTime: instance.SeriesTime,
+        Modality: instance.Modality,
+        PatientSex: instance.PatientSex,
+        PatientWeight: instance.PatientWeight,
+        RadiopharmaceuticalInformationSequence: {
+          RadionuclideTotalDose: instance.RadiopharmaceuticalInformationSequence[0].RadionuclideTotalDose,
+          RadionuclideHalfLife: instance.RadiopharmaceuticalInformationSequence[0].RadionuclideHalfLife,
+          RadiopharmaceuticalStartTime: instance.RadiopharmaceuticalInformationSequence[0].RadiopharmaceuticalStartTime,
+          RadiopharmaceuticalStartDateTime: instance.RadiopharmaceuticalInformationSequence[0].RadiopharmaceuticalStartDateTime
+        }
+      };
+      return metadata;
+    },
+    createNewLabelmapFromPT: async ({
+      label
+    }) => {
+      // Create a segmentation of the same resolution as the source data
+      // using volumeLoader.createAndCacheDerivedVolume.
+      const {
+        viewportMatchDetails
+      } = hangingProtocolService.getMatchDetails();
+      const ptDisplaySet = actions.getMatchingPTDisplaySet({
+        viewportMatchDetails
+      });
+      if (!ptDisplaySet) {
+        uiNotificationService.error('No matching PT display set found');
+        return;
+      }
+      const currentSegmentations = segmentationService.getSegmentations();
+      const segmentationId = await segmentationService.createSegmentationForDisplaySet(ptDisplaySet.displaySetInstanceUID, {
+        label: `Segmentation ${currentSegmentations.length + 1}`
+      });
+
+      // Add Segmentation to all toolGroupIds in the viewer
+      const toolGroupIds = _getMatchedViewportsToolGroupIds();
+      const representationType = LABELMAP;
+      for (const toolGroupId of toolGroupIds) {
+        const hydrateSegmentation = true;
+        await segmentationService.addSegmentationRepresentationToToolGroup(toolGroupId, segmentationId, hydrateSegmentation, representationType);
+        segmentationService.setActiveSegmentationForToolGroup(segmentationId, toolGroupId);
+      }
+      segmentationService.addSegment(segmentationId, {
+        segmentIndex: 1,
+        properties: {
+          label: 'Segment 1'
+        }
+      });
+      return segmentationId;
+    },
+    setSegmentationActiveForToolGroups: ({
+      segmentationId
+    }) => {
+      const toolGroupIds = _getMatchedViewportsToolGroupIds();
+      toolGroupIds.forEach(toolGroupId => {
+        segmentationService.setActiveSegmentationForToolGroup(segmentationId, toolGroupId);
+      });
+    },
+    thresholdSegmentationByRectangleROITool: ({
+      segmentationId,
+      config,
+      segmentIndex
+    }) => {
+      const segmentation = esm.segmentation.state.getSegmentation(segmentationId);
+      const {
+        representationData
+      } = segmentation;
+      const {
+        displaySetMatchDetails: matchDetails
+      } = hangingProtocolService.getMatchDetails();
+      const volumeLoaderScheme = 'cornerstoneStreamingImageVolume'; // Loader id which defines which volume loader to use
+
+      const ctDisplaySet = matchDetails.get('ctDisplaySet');
+      const ctVolumeId = `${volumeLoaderScheme}:${ctDisplaySet.displaySetInstanceUID}`; // VolumeId with loader id + volume id
+
+      const {
+        volumeId: segVolumeId
+      } = representationData[LABELMAP];
+      const {
+        referencedVolumeId
+      } = dist_esm.cache.getVolume(segVolumeId);
+      const annotationUIDs = _getAnnotationsSelectedByToolNames(RECTANGLE_ROI_THRESHOLD_MANUAL_TOOL_IDS);
+      if (annotationUIDs.length === 0) {
+        uiNotificationService.show({
+          title: 'Commands Module',
+          message: 'No ROIThreshold Tool is Selected',
+          type: 'error'
+        });
+        return;
+      }
+      const labelmapVolume = dist_esm.cache.getVolume(segmentationId);
+      let referencedVolume = dist_esm.cache.getVolume(referencedVolumeId);
+      const ctReferencedVolume = dist_esm.cache.getVolume(ctVolumeId);
+
+      // check if viewport is
+
+      if (!referencedVolume) {
+        throw new Error('No Reference volume found');
+      }
+      if (!labelmapVolume) {
+        throw new Error('No Reference labelmap found');
+      }
+      const annotation = esm.annotation.state.getAnnotation(annotationUIDs[0]);
+      const {
+        metadata: {
+          enabledElement: {
+            viewport
+          }
+        }
+      } = annotation;
+      const showingReferenceVolume = viewport.hasVolumeId(referencedVolumeId);
+      if (!showingReferenceVolume) {
+        // if the reference volume is not being displayed, we can't
+        // rely on it for thresholding, we have couple of options here
+        // 1. We choose whatever volume is being displayed
+        // 2. We check if it is a fusion viewport, we pick the volume
+        // that matches the size and dimensions of the labelmap. This might
+        // happen if the 4D PT is converted to a computed volume and displayed
+        // and wants to threshold the labelmap
+        // 3. We throw an error
+        const displaySetInstanceUIDs = viewportGridService.getDisplaySetsUIDsForViewport(viewport.id);
+        displaySetInstanceUIDs.forEach(displaySetInstanceUID => {
+          const volume = dist_esm.cache.getVolumes().find(volume => volume.volumeId.includes(displaySetInstanceUID));
+          if (dist_esm.utilities.isEqual(volume.dimensions, labelmapVolume.dimensions) && dist_esm.utilities.isEqual(volume.spacing, labelmapVolume.spacing)) {
+            referencedVolume = volume;
+          }
+        });
+      }
+      const {
+        ptLower,
+        ptUpper,
+        ctLower,
+        ctUpper
+      } = getThresholdValue(annotationUIDs, [referencedVolume, ctReferencedVolume], config);
+      return esm.utilities.segmentation.rectangleROIThresholdVolumeByRange(annotationUIDs, labelmapVolume, [{
+        volume: referencedVolume,
+        lower: ptLower,
+        upper: ptUpper
+      }, {
+        volume: ctReferencedVolume,
+        lower: ctLower,
+        upper: ctUpper
+      }], {
+        overwrite: true,
+        segmentIndex
+      });
+    },
+    calculateSuvPeak: ({
+      labelmap,
+      segmentIndex
+    }) => {
+      const {
+        referencedVolumeId
+      } = labelmap;
+      const referencedVolume = dist_esm.cache.getVolume(referencedVolumeId);
+      const annotationUIDs = _getAnnotationsSelectedByToolNames(RECTANGLE_ROI_THRESHOLD_MANUAL_TOOL_IDS);
+      const annotations = annotationUIDs.map(annotationUID => esm.annotation.state.getAnnotation(annotationUID));
+      const suvPeak = calculateSUVPeak(labelmap, referencedVolume, annotations, segmentIndex);
+      return {
+        suvPeak: suvPeak.mean,
+        suvMax: suvPeak.max,
+        suvMaxIJK: suvPeak.maxIJK,
+        suvMaxLPS: suvPeak.maxLPS
+      };
+    },
+    getLesionStats: ({
+      labelmap,
+      segmentIndex = 1
+    }) => {
+      const {
+        scalarData,
+        spacing
+      } = labelmap;
+      const referencedScalarData = dist_esm.cache.getVolume(labelmap.referencedVolumeId).getScalarData();
+      let segmentationMax = -Infinity;
+      let segmentationMin = Infinity;
+      let segmentationValues = [];
+      let voxelCount = 0;
+      for (let i = 0; i < scalarData.length; i++) {
+        if (scalarData[i] === segmentIndex) {
+          const value = referencedScalarData[i];
+          segmentationValues.push(value);
+          if (value > segmentationMax) {
+            segmentationMax = value;
+          }
+          if (value < segmentationMin) {
+            segmentationMin = value;
+          }
+          voxelCount++;
+        }
+      }
+      const stats = {
+        minValue: segmentationMin,
+        maxValue: segmentationMax,
+        meanValue: segmentationValues.reduce((a, b) => a + b, 0) / voxelCount,
+        stdValue: Math.sqrt(segmentationValues.reduce((a, b) => a + b * b, 0) / voxelCount - segmentationValues.reduce((a, b) => a + b, 0) / voxelCount ** 2),
+        volume: voxelCount * spacing[0] * spacing[1] * spacing[2] * 1e-3
+      };
+      return stats;
+    },
+    calculateLesionGlycolysis: ({
+      lesionStats
+    }) => {
+      const {
+        meanValue,
+        volume
+      } = lesionStats;
+      return {
+        lesionGlyoclysisStats: volume * meanValue
+      };
+    },
+    calculateTMTV: ({
+      segmentations
+    }) => {
+      const labelmaps = segmentations.map(s => segmentationService.getLabelmapVolume(s.id));
+      if (!labelmaps.length) {
+        return;
+      }
+      return utils_calculateTMTV(labelmaps);
+    },
+    exportTMTVReportCSV: ({
+      segmentations,
+      tmtv,
+      config,
+      options
+    }) => {
+      const segReport = commandsManager.runCommand('getSegmentationCSVReport', {
+        segmentations
+      });
+      const tlg = actions.getTotalLesionGlycolysis({
+        segmentations
+      });
+      const additionalReportRows = [{
+        key: 'Total Lesion Glycolysis',
+        value: {
+          tlg: tlg.toFixed(4)
+        }
+      }, {
+        key: 'Threshold Configuration',
+        value: {
+          ...config
+        }
+      }];
+      if (tmtv !== undefined) {
+        additionalReportRows.unshift({
+          key: 'Total Metabolic Tumor Volume',
+          value: {
+            tmtv
+          }
+        });
+      }
+      createAndDownloadTMTVReport(segReport, additionalReportRows, options);
+    },
+    getTotalLesionGlycolysis: ({
+      segmentations
+    }) => {
+      const labelmapVolumes = segmentations.map(s => segmentationService.getLabelmapVolume(s.id));
+      let mergedLabelmap;
+      // merge labelmap will through an error if labels maps are not the same size
+      // or same direction or ....
+      try {
+        mergedLabelmap = esm.utilities.segmentation.createMergedLabelmapForIndex(labelmapVolumes);
+      } catch (e) {
+        console.error('commandsModule::getTotalLesionGlycolysis', e);
+        return;
+      }
+
+      // grabbing the first labelmap referenceVolume since it will be the same for all
+      const {
+        referencedVolumeId,
+        spacing
+      } = labelmapVolumes[0];
+      if (!referencedVolumeId) {
+        console.error('commandsModule::getTotalLesionGlycolysis:No referencedVolumeId found');
+      }
+      const ptVolume = dist_esm.cache.getVolume(referencedVolumeId);
+      const mergedLabelData = mergedLabelmap.getScalarData();
+      if (mergedLabelData.length !== ptVolume.getScalarData().length) {
+        console.error('commandsModule::getTotalLesionGlycolysis:Labelmap and ptVolume are not the same size');
+      }
+      let suv = 0;
+      let totalLesionVoxelCount = 0;
+      for (let i = 0; i < mergedLabelData.length; i++) {
+        // if not background
+        if (mergedLabelData[i] !== 0) {
+          suv += ptVolume.getScalarData()[i];
+          totalLesionVoxelCount += 1;
+        }
+      }
+
+      // Average SUV for the merged labelmap
+      const averageSuv = suv / totalLesionVoxelCount;
+
+      // total Lesion Glycolysis [suv * ml]
+      return averageSuv * totalLesionVoxelCount * spacing[0] * spacing[1] * spacing[2] * 1e-3;
+    },
+    setStartSliceForROIThresholdTool: () => {
+      const {
+        viewport
+      } = _getActiveViewportsEnabledElement();
+      const {
+        focalPoint,
+        viewPlaneNormal
+      } = viewport.getCamera();
+      const selectedAnnotationUIDs = _getAnnotationsSelectedByToolNames(RECTANGLE_ROI_THRESHOLD_MANUAL_TOOL_IDS);
+      const annotationUID = selectedAnnotationUIDs[0];
+      const annotation = esm.annotation.state.getAnnotation(annotationUID);
+      const {
+        handles
+      } = annotation.data;
+      const {
+        points
+      } = handles;
+
+      // get the current slice Index
+      const sliceIndex = viewport.getCurrentImageIdIndex();
+      annotation.data.startSlice = sliceIndex;
+
+      // distance between camera focal point and each point on the rectangle
+      const newPoints = points.map(point => {
+        const distance = gl_matrix_esm/* vec3.create */.eR.create();
+        gl_matrix_esm/* vec3.subtract */.eR.subtract(distance, focalPoint, point);
+        // distance in the direction of the viewPlaneNormal
+        const distanceInViewPlane = gl_matrix_esm/* vec3.dot */.eR.dot(distance, viewPlaneNormal);
+        // new point is current point minus distanceInViewPlane
+        const newPoint = gl_matrix_esm/* vec3.create */.eR.create();
+        gl_matrix_esm/* vec3.scaleAndAdd */.eR.scaleAndAdd(newPoint, point, viewPlaneNormal, distanceInViewPlane);
+        return newPoint;
+        //
+      });
+      handles.points = newPoints;
+      // IMPORTANT: invalidate the toolData for the cached stat to get updated
+      // and re-calculate the projection points
+      annotation.invalidated = true;
+      viewport.render();
+    },
+    setEndSliceForROIThresholdTool: () => {
+      const {
+        viewport
+      } = _getActiveViewportsEnabledElement();
+      const selectedAnnotationUIDs = _getAnnotationsSelectedByToolNames(RECTANGLE_ROI_THRESHOLD_MANUAL_TOOL_IDS);
+      const annotationUID = selectedAnnotationUIDs[0];
+      const annotation = esm.annotation.state.getAnnotation(annotationUID);
+
+      // get the current slice Index
+      const sliceIndex = viewport.getCurrentImageIdIndex();
+      annotation.data.endSlice = sliceIndex;
+
+      // IMPORTANT: invalidate the toolData for the cached stat to get updated
+      // and re-calculate the projection points
+      annotation.invalidated = true;
+      viewport.render();
+    },
+    createTMTVRTReport: () => {
+      // get all Rectangle ROI annotation
+      const stateManager = esm.annotation.state.getAnnotationManager();
+      const annotations = [];
+      Object.keys(stateManager.annotations).forEach(frameOfReferenceUID => {
+        const forAnnotations = stateManager.annotations[frameOfReferenceUID];
+        const ROIAnnotations = RECTANGLE_ROI_THRESHOLD_MANUAL_TOOL_IDS.reduce((annotations, toolName) => [...annotations, ...(forAnnotations[toolName] ?? [])], []);
+        annotations.push(...ROIAnnotations);
+      });
+      commandsManager.runCommand('exportRTReportForAnnotations', {
+        annotations
+      });
+    },
+    getSegmentationCSVReport: ({
+      segmentations
+    }) => {
+      if (!segmentations || !segmentations.length) {
+        segmentations = segmentationService.getSegmentations();
+      }
+      let report = {};
+      for (const segmentation of segmentations) {
+        const {
+          id,
+          label,
+          cachedStats: data
+        } = segmentation;
+        const segReport = {
+          id,
+          label
+        };
+        if (!data) {
+          report[id] = segReport;
+          continue;
+        }
+        Object.keys(data).forEach(key => {
+          if (typeof data[key] !== 'object') {
+            segReport[key] = data[key];
+          } else {
+            Object.keys(data[key]).forEach(subKey => {
+              const newKey = `${key}_${subKey}`;
+              segReport[newKey] = data[key][subKey];
+            });
+          }
+        });
+        const labelmapVolume = segmentationService.getLabelmapVolume(id);
+        if (!labelmapVolume) {
+          report[id] = segReport;
+          continue;
+        }
+        const referencedVolumeId = labelmapVolume.referencedVolumeId;
+        segReport.referencedVolumeId = referencedVolumeId;
+        const referencedVolume = segmentationService.getLabelmapVolume(referencedVolumeId);
+        if (!referencedVolume) {
+          report[id] = segReport;
+          continue;
+        }
+        if (!referencedVolume.imageIds || !referencedVolume.imageIds.length) {
+          report[id] = segReport;
+          continue;
+        }
+        const firstImageId = referencedVolume.imageIds[0];
+        const instance = core_src/* default.classes */.Ay.classes.MetadataProvider.get('instance', firstImageId);
+        if (!instance) {
+          report[id] = segReport;
+          continue;
+        }
+        report[id] = {
+          ...segReport,
+          PatientID: instance.PatientID ?? '000000',
+          PatientName: instance.PatientName.Alphabetic,
+          StudyInstanceUID: instance.StudyInstanceUID,
+          SeriesInstanceUID: instance.SeriesInstanceUID,
+          StudyDate: instance.StudyDate
+        };
+      }
+      return report;
+    },
+    exportRTReportForAnnotations: ({
+      annotations
+    }) => {
+      RTStructureSet(annotations);
+    },
+    setFusionPTColormap: ({
+      toolGroupId,
+      colormap
+    }) => {
+      const toolGroup = toolGroupService.getToolGroup(toolGroupId);
+      const {
+        viewportMatchDetails
+      } = hangingProtocolService.getMatchDetails();
+      const ptDisplaySet = actions.getMatchingPTDisplaySet({
+        viewportMatchDetails
+      });
+      if (!ptDisplaySet) {
+        return;
+      }
+      const fusionViewportIds = toolGroup.getViewportIds();
+      let viewports = [];
+      fusionViewportIds.forEach(viewportId => {
+        commandsManager.runCommand('setViewportColormap', {
+          viewportId,
+          displaySetInstanceUID: ptDisplaySet.displaySetInstanceUID,
+          colormap: {
+            name: colormap
+          }
+        });
+        viewports.push(cornerstoneViewportService.getCornerstoneViewport(viewportId));
+      });
+      viewports.forEach(viewport => {
+        viewport.render();
+      });
+    }
+  };
+  const definitions = {
+    setEndSliceForROIThresholdTool: {
+      commandFn: actions.setEndSliceForROIThresholdTool
+    },
+    setStartSliceForROIThresholdTool: {
+      commandFn: actions.setStartSliceForROIThresholdTool
+    },
+    getMatchingPTDisplaySet: {
+      commandFn: actions.getMatchingPTDisplaySet
+    },
+    getPTMetadata: {
+      commandFn: actions.getPTMetadata
+    },
+    createNewLabelmapFromPT: {
+      commandFn: actions.createNewLabelmapFromPT
+    },
+    setSegmentationActiveForToolGroups: {
+      commandFn: actions.setSegmentationActiveForToolGroups
+    },
+    thresholdSegmentationByRectangleROITool: {
+      commandFn: actions.thresholdSegmentationByRectangleROITool
+    },
+    getTotalLesionGlycolysis: {
+      commandFn: actions.getTotalLesionGlycolysis
+    },
+    calculateSuvPeak: {
+      commandFn: actions.calculateSuvPeak
+    },
+    getLesionStats: {
+      commandFn: actions.getLesionStats
+    },
+    calculateTMTV: {
+      commandFn: actions.calculateTMTV
+    },
+    exportTMTVReportCSV: {
+      commandFn: actions.exportTMTVReportCSV
+    },
+    createTMTVRTReport: {
+      commandFn: actions.createTMTVRTReport
+    },
+    getSegmentationCSVReport: {
+      commandFn: actions.getSegmentationCSVReport
+    },
+    exportRTReportForAnnotations: {
+      commandFn: actions.exportRTReportForAnnotations
+    },
+    setFusionPTColormap: {
+      commandFn: actions.setFusionPTColormap
+    }
+  };
+  return {
+    actions,
+    definitions,
+    defaultContext: 'TMTV:CORNERSTONE'
+  };
+};
+/* harmony default export */ const src_commandsModule = (commandsModule);
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/Panels/PanelROIThresholdSegmentation/ROIThresholdConfiguration.tsx
+
+
+
+const ROI_STAT = 'roi_stat';
+const RANGE = 'range';
+const options = [{
+  value: ROI_STAT,
+  label: 'Max',
+  placeHolder: 'Max'
+}, {
+  value: RANGE,
+  label: 'Range',
+  placeHolder: 'Range'
+}];
+function ROIThresholdConfiguration({
+  config,
+  dispatch,
+  runCommand
+}) {
+  const {
+    t
+  } = (0,es/* useTranslation */.Bd)('ROIThresholdConfiguration');
+  return /*#__PURE__*/react.createElement("div", {
+    className: "bg-primary-dark flex flex-col space-y-4"
+  }, /*#__PURE__*/react.createElement("div", {
+    className: "flex items-end space-x-2"
+  }, /*#__PURE__*/react.createElement("div", {
+    className: "flex w-1/2 flex-col"
+  }, /*#__PURE__*/react.createElement(src/* Select */.l6, {
+    label: t('Strategy'),
+    closeMenuOnSelect: true,
+    className: "border-primary-main mr-2 bg-black text-white ",
+    options: options,
+    placeholder: options.find(option => option.value === config.strategy).placeHolder,
+    value: config.strategy,
+    onChange: ({
+      value
+    }) => {
+      dispatch({
+        type: 'setStrategy',
+        payload: {
+          strategy: value
+        }
+      });
+    }
+  })), /*#__PURE__*/react.createElement("div", {
+    className: "w-1/2"
+  }, /*#__PURE__*/react.createElement(src/* LegacyButtonGroup */.xA, null, /*#__PURE__*/react.createElement(src/* LegacyButton */._H, {
+    size: "initial",
+    className: "px-2 py-2 text-base text-white",
+    color: "primaryLight",
+    variant: "outlined",
+    onClick: () => runCommand('setStartSliceForROIThresholdTool')
+  }, t('Start')), /*#__PURE__*/react.createElement(src/* LegacyButton */._H, {
+    size: "initial",
+    color: "primaryLight",
+    variant: "outlined",
+    className: "px-2 py-2 text-base text-white",
+    onClick: () => runCommand('setEndSliceForROIThresholdTool')
+  }, t('End'))))), config.strategy === ROI_STAT && /*#__PURE__*/react.createElement(src/* Input */.pd, {
+    label: t('Percentage of Max SUV'),
+    labelClassName: "text-[13px] font-inter text-white",
+    className: "border-primary-main bg-black",
+    type: "text",
+    containerClassName: "mr-2",
+    value: config.weight,
+    onChange: e => {
+      dispatch({
+        type: 'setWeight',
+        payload: {
+          weight: e.target.value
+        }
+      });
+    }
+  }), config.strategy !== ROI_STAT && /*#__PURE__*/react.createElement("div", {
+    className: "mr-2 text-sm"
+  }, /*#__PURE__*/react.createElement("table", null, /*#__PURE__*/react.createElement("tbody", null, /*#__PURE__*/react.createElement("tr", {
+    className: "mt-2"
+  }, /*#__PURE__*/react.createElement("td", {
+    className: "pr-4",
+    colSpan: "3"
+  }, /*#__PURE__*/react.createElement(src/* Label */.JU, {
+    className: "font-inter text-[13px] text-white",
+    text: "Lower & Upper Ranges"
+  }))), /*#__PURE__*/react.createElement("tr", {
+    className: "mt-2"
+  }, /*#__PURE__*/react.createElement("td", {
+    className: "pr-4 pt-2 text-center"
+  }, /*#__PURE__*/react.createElement(src/* Label */.JU, {
+    className: "text-white",
+    text: "CT"
+  })), /*#__PURE__*/react.createElement("td", null, /*#__PURE__*/react.createElement("div", {
+    className: "flex justify-between"
+  }, /*#__PURE__*/react.createElement(src/* Input */.pd, {
+    label: t(''),
+    labelClassName: "text-white",
+    className: "border-primary-main mt-2 bg-black",
+    type: "text",
+    containerClassName: "mr-2",
+    value: config.ctLower,
+    onChange: e => {
+      dispatch({
+        type: 'setThreshold',
+        payload: {
+          ctLower: e.target.value
+        }
+      });
+    }
+  }), /*#__PURE__*/react.createElement(src/* Input */.pd, {
+    label: t(''),
+    labelClassName: "text-white",
+    className: "border-primary-main mt-2 bg-black",
+    type: "text",
+    containerClassName: "mr-2",
+    value: config.ctUpper,
+    onChange: e => {
+      dispatch({
+        type: 'setThreshold',
+        payload: {
+          ctUpper: e.target.value
+        }
+      });
+    }
+  })))), /*#__PURE__*/react.createElement("tr", null, /*#__PURE__*/react.createElement("td", {
+    className: "pr-4 pt-2 text-center"
+  }, /*#__PURE__*/react.createElement(src/* Label */.JU, {
+    className: "text-white",
+    text: "PT"
+  })), /*#__PURE__*/react.createElement("td", null, /*#__PURE__*/react.createElement("div", {
+    className: "flex justify-between"
+  }, /*#__PURE__*/react.createElement(src/* Input */.pd, {
+    label: t(''),
+    labelClassName: "text-white",
+    className: "border-primary-main mt-2 bg-black",
+    type: "text",
+    containerClassName: "mr-2",
+    value: config.ptLower,
+    onChange: e => {
+      dispatch({
+        type: 'setThreshold',
+        payload: {
+          ptLower: e.target.value
+        }
+      });
+    }
+  }), /*#__PURE__*/react.createElement(src/* Input */.pd, {
+    label: t(''),
+    labelClassName: "text-white",
+    className: "border-primary-main mt-2 bg-black",
+    type: "text",
+    containerClassName: "mr-2",
+    value: config.ptUpper,
+    onChange: e => {
+      dispatch({
+        type: 'setThreshold',
+        payload: {
+          ptUpper: e.target.value
+        }
+      });
+    }
+  }))))))));
+}
+/* harmony default export */ const PanelROIThresholdSegmentation_ROIThresholdConfiguration = (ROIThresholdConfiguration);
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/Panels/RectangleROIOptions.tsx
+
+
+
+
+const LOWER_CT_THRESHOLD_DEFAULT = -1024;
+const UPPER_CT_THRESHOLD_DEFAULT = 1024;
+const LOWER_PT_THRESHOLD_DEFAULT = 2.5;
+const UPPER_PT_THRESHOLD_DEFAULT = 100;
+const WEIGHT_DEFAULT = 0.41; // a default weight for suv max often used in the literature
+const DEFAULT_STRATEGY = ROI_STAT;
+function reducer(state, action) {
+  const {
+    payload
+  } = action;
+  const {
+    strategy,
+    ctLower,
+    ctUpper,
+    ptLower,
+    ptUpper,
+    weight
+  } = payload;
+  switch (action.type) {
+    case 'setStrategy':
+      return {
+        ...state,
+        strategy
+      };
+    case 'setThreshold':
+      return {
+        ...state,
+        ctLower: ctLower ? ctLower : state.ctLower,
+        ctUpper: ctUpper ? ctUpper : state.ctUpper,
+        ptLower: ptLower ? ptLower : state.ptLower,
+        ptUpper: ptUpper ? ptUpper : state.ptUpper
+      };
+    case 'setWeight':
+      return {
+        ...state,
+        weight
+      };
+    default:
+      return state;
+  }
+}
+function RectangleROIOptions({
+  servicesManager,
+  commandsManager
+}) {
+  const {
+    segmentationService
+  } = servicesManager.services;
+  const [selectedSegmentationId, setSelectedSegmentationId] = (0,react.useState)(null);
+  const runCommand = (0,react.useCallback)((commandName, commandOptions = {}) => {
+    return commandsManager.runCommand(commandName, commandOptions);
+  }, [commandsManager]);
+  const [config, dispatch] = (0,react.useReducer)(reducer, {
+    strategy: DEFAULT_STRATEGY,
+    ctLower: LOWER_CT_THRESHOLD_DEFAULT,
+    ctUpper: UPPER_CT_THRESHOLD_DEFAULT,
+    ptLower: LOWER_PT_THRESHOLD_DEFAULT,
+    ptUpper: UPPER_PT_THRESHOLD_DEFAULT,
+    weight: WEIGHT_DEFAULT
+  });
+  const handleROIThresholding = (0,react.useCallback)(() => {
+    const segmentationId = selectedSegmentationId;
+    const segmentation = segmentationService.getSegmentation(segmentationId);
+    const activeSegmentIndex = esm.segmentation.segmentIndex.getActiveSegmentIndex(segmentationId);
+
+    // run the threshold based on the active segment index
+    // Todo: later find a way to associate each rectangle with a segment (e.g., maybe with color?)
+    const labelmap = runCommand('thresholdSegmentationByRectangleROITool', {
+      segmentationId,
+      config,
+      segmentIndex: activeSegmentIndex
+    });
+
+    // re-calculating the cached stats for the active segmentation
+    const updatedPerSegmentCachedStats = {};
+    segmentation.segments = segmentation.segments.map(segment => {
+      if (!segment || !segment.segmentIndex) {
+        return segment;
+      }
+      const segmentIndex = segment.segmentIndex;
+      const lesionStats = runCommand('getLesionStats', {
+        labelmap,
+        segmentIndex
+      });
+      const suvPeak = runCommand('calculateSuvPeak', {
+        labelmap,
+        segmentIndex
+      });
+      const lesionGlyoclysisStats = lesionStats.volume * lesionStats.meanValue;
+
+      // update segDetails with the suv peak for the active segmentation
+      const cachedStats = {
+        lesionStats,
+        suvPeak,
+        lesionGlyoclysisStats
+      };
+      segment.cachedStats = cachedStats;
+      segment.displayText = [`SUV Peak: ${suvPeak.suvPeak.toFixed(2)}`, `Volume: ${lesionStats.volume.toFixed(2)} mm3`];
+      updatedPerSegmentCachedStats[segmentIndex] = cachedStats;
+      return segment;
+    });
+    const notYetUpdatedAtSource = true;
+    const segmentations = segmentationService.getSegmentations();
+    const tmtv = runCommand('calculateTMTV', {
+      segmentations
+    });
+    segmentation.cachedStats = Object.assign(segmentation.cachedStats, updatedPerSegmentCachedStats, {
+      tmtv: {
+        value: tmtv.toFixed(3),
+        config: {
+          ...config
+        }
+      }
+    });
+    segmentationService.addOrUpdateSegmentation({
+      ...segmentation
+    }, false,
+    // don't suppress events
+    notYetUpdatedAtSource);
+  }, [selectedSegmentationId, config]);
+  (0,react.useEffect)(() => {
+    const segmentations = segmentationService.getSegmentations();
+    if (!segmentations.length) {
+      return;
+    }
+    const isActive = segmentations.find(seg => seg.isActive);
+    setSelectedSegmentationId(isActive.id);
+  }, []);
+
+  /**
+   * Update UI based on segmentation changes (added, removed, updated)
+   */
+  (0,react.useEffect)(() => {
+    // ~~ Subscription
+    const added = segmentationService.EVENTS.SEGMENTATION_ADDED;
+    const updated = segmentationService.EVENTS.SEGMENTATION_UPDATED;
+    const subscriptions = [];
+    [added, updated].forEach(evt => {
+      const {
+        unsubscribe
+      } = segmentationService.subscribe(evt, () => {
+        const segmentations = segmentationService.getSegmentations();
+        if (!segmentations.length) {
+          return;
+        }
+        const isActive = segmentations.find(seg => seg.isActive);
+        setSelectedSegmentationId(isActive.id);
+      });
+      subscriptions.push(unsubscribe);
+    });
+    return () => {
+      subscriptions.forEach(unsub => {
+        unsub();
+      });
+    };
+  }, []);
+  (0,react.useEffect)(() => {
+    const {
+      unsubscribe
+    } = segmentationService.subscribe(segmentationService.EVENTS.SEGMENTATION_REMOVED, () => {
+      const segmentations = segmentationService.getSegmentations();
+      if (segmentations.length > 0) {
+        setSelectedSegmentationId(segmentations[0].id);
+        handleROIThresholding();
+      } else {
+        setSelectedSegmentationId(null);
+        handleROIThresholding();
+      }
+    });
+    return () => {
+      unsubscribe();
+    };
+  }, []);
+  return /*#__PURE__*/react.createElement("div", {
+    className: "invisible-scrollbar mb-2 flex flex-col overflow-y-auto overflow-x-hidden"
+  }, /*#__PURE__*/react.createElement(PanelROIThresholdSegmentation_ROIThresholdConfiguration, {
+    config: config,
+    dispatch: dispatch,
+    runCommand: runCommand
+  }), selectedSegmentationId !== null && /*#__PURE__*/react.createElement(src/* Button */.$n, {
+    className: "mt-2 !h-[26px] !w-[75px]",
+    onClick: handleROIThresholding
+  }, "Run"));
+}
+/* harmony default export */ const Panels_RectangleROIOptions = (RectangleROIOptions);
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/getToolbarModule.tsx
+
+function getToolbarModule({
+  commandsManager,
+  servicesManager
+}) {
+  return [{
+    name: 'tmtv.RectangleROIThresholdOptions',
+    defaultComponent: () => Panels_RectangleROIOptions({
+      commandsManager,
+      servicesManager
+    })
+  }];
+}
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/index.tsx
+
+
+
+
+
+
+
+/**
+ *
+ */
+const tmtvExtension = {
+  /**
+   * Only required property. Should be a unique value across all extensions.
+   */
+  id: id,
+  preRegistration({
+    servicesManager,
+    commandsManager,
+    extensionManager,
+    configuration = {}
+  }) {
+    init({
+      servicesManager,
+      commandsManager,
+      extensionManager,
+      configuration
+    });
+  },
+  getToolbarModule: getToolbarModule,
+  getPanelModule: src_getPanelModule,
+  getHangingProtocolModule: src_getHangingProtocolModule,
+  getCommandsModule({
+    servicesManager,
+    commandsManager,
+    extensionManager
+  }) {
+    return src_commandsModule({
+      servicesManager,
+      commandsManager,
+      extensionManager
+    });
+  }
+};
+/* harmony default export */ const tmtv_src = (tmtvExtension);
+
+/***/ })
+
+}]);