融合页面工具优化

src/views/trials/trials-panel/reading/dicoms/components/Fusion/PetCt.vue

@@ -179,17 +179,18 @@
         <Viewport ref="CT_AXIAL" :index="1" :active-index="activeIndex"
           :is-reading-show-subject-info="isReadingShowSubjectInfo" :series-info="ctSeries"
           :rendering-engine-id="renderingEngineId" viewport-id="CT_AXIAL" :volume="ctVolume"
-          :measure-datas="measureDatas" :style="1 === activeIndex ? viewportStyle : {}" />
+          :measure-datas="measureDatas" :style="1 === activeIndex ? viewportStyle : {}"
+          @fusionSlicePointChange="handleFusionSlicePointChange" />
         <Viewport ref="PT_AXIAL" :index="2" :active-index="activeIndex"
           :is-reading-show-subject-info="isReadingShowSubjectInfo" :series-info="petSeries"
           :rendering-engine-id="renderingEngineId" viewport-id="PT_AXIAL" :volume="ptVolume"
           :measure-datas="measureDatas" :style="2 === activeIndex ? viewportStyle : {}"
-          @upperRangeChange="upperRangeChange" />
+          @upperRangeChange="upperRangeChange" @fusionSlicePointChange="handleFusionSlicePointChange" />
         <Viewport ref="FUSION_AXIAL" :index="3" :active-index="activeIndex"
           :is-reading-show-subject-info="isReadingShowSubjectInfo" :series-info="petSeries" :ct-series-info="ctSeries"
           :rendering-engine-id="renderingEngineId" viewport-id="FUSION_AXIAL" :volume="ptVolume"
           :measure-datas="measureDatas" :rgb-preset-name="rgbPresetName" :style="3 === activeIndex ? viewportStyle : {}"
-          @upperRangeChange="upperRangeChange" />
+          @upperRangeChange="upperRangeChange" @fusionSlicePointChange="handleFusionSlicePointChange" />
         <Viewport ref="PET_MIP_CORONAL" :index="4" :active-index="activeIndex"
           :is-reading-show-subject-info="isReadingShowSubjectInfo" :series-info="petSeries"
           :rendering-engine-id="renderingEngineId" viewport-id="PET_MIP_CORONAL" :measure-datas="measureDatas"
@@ -259,7 +260,7 @@ import CustomWwwcForm from './../CustomWwwcForm'
 import FusionForm from './FusionForm.vue'
 import { getTableAnswerRowInfoList, getDicomSeriesInfo } from '@/api/trials'
 import FusionEvent from './FusionEvent'
-import FusionJumpToPointTool from '../../../dicoms3D/components/tools/FusionJumpToPointTool'
+import FusionJumpToPointTool from '../../../dicoms3D/components/tools/FusionJumpToPointTool'
 // import { ColorMaps } from '@kitware/vtk.js/Common/Core/ColorMaps'
 import vtkColorMaps from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps'
 import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction'
@@ -425,12 +426,12 @@ export default {
       fusion: { visible: false }, // 历史记录融合调窗
       screenshotWindow: null,
       hasVoiChanged: false,
-      lastUpper: null,
+      lastUpper: null,
-      fusionCrosshairStyle: {
+      fusionCrosshairStyle: {
-        lineWidth: 2,
+        lineWidth: 2,
-        lineLength: 20,
+        lineLength: 20,
-        centerHoleSize: 20,
+        centerHoleSize: 20,
-      }
+      }
       // initFirstAnnotation:false
     }
   },
@@ -628,7 +629,7 @@ export default {
       this.setUpToolGroups()
 
       this.setUpSynchronizers()
-      this.dispatchFusionCenterPoint()
+      this.dispatchFusionCenterPoint()
       // this.$refs['CT_AXIAL'].scroll(0)
       // this.$refs['PT_AXIAL'].scroll(0)
       // this.$refs['FUSION_AXIAL'].scroll(0)
@@ -980,7 +981,7 @@ export default {
       cornerstoneTools.addTool(WindowLevelTool)
       cornerstoneTools.addTool(ZoomTool)
       cornerstoneTools.addTool(StackScrollTool)
-      cornerstoneTools.addTool(FusionJumpToPointTool)
+      cornerstoneTools.addTool(FusionJumpToPointTool)
       cornerstoneTools.addTool(VolumeRotateTool)
       cornerstoneTools.addTool(EllipticalROITool)
       cornerstoneTools.addTool(CircleROITool)
@@ -1012,7 +1013,7 @@ export default {
         toolGroup.addTool(ProbeTool.toolName)
         toolGroup.addTool(ScaleOverlayTool.toolName)
         toolGroup.addTool(OrientationMarkerTool.toolName)
-        toolGroup.addTool(FusionJumpToPointTool.toolName, this.getFusionJumpToolConfiguration())
+        toolGroup.addTool(FusionJumpToPointTool.toolName, this.getFusionJumpToolConfiguration())
       })
 
       fusionToolGroup.addTool(PanTool.toolName)
@@ -1028,7 +1029,7 @@ export default {
       fusionToolGroup.addTool(ProbeTool.toolName)
       fusionToolGroup.addTool(ScaleOverlayTool.toolName)
       fusionToolGroup.addTool(OrientationMarkerTool.toolName)
-      fusionToolGroup.addTool(FusionJumpToPointTool.toolName, this.getFusionJumpToolConfiguration())
+      fusionToolGroup.addTool(FusionJumpToPointTool.toolName, this.getFusionJumpToolConfiguration())
       // Here is the difference in the toolGroups used, that we need to specify the
       // volume to use for the WindowLevelTool for the fusion viewports
 
@@ -1080,13 +1081,13 @@ export default {
           true // overwrite
         )
         toolGroup.setToolEnabled(ScaleOverlayTool.toolName)
-        toolGroup.setToolActive(FusionJumpToPointTool.toolName, {
+        toolGroup.setToolActive(FusionJumpToPointTool.toolName, {
-          bindings: [
+          bindings: [
-            {
+            {
-              mouseButton: MouseBindings.Primary // Left Click
+              mouseButton: MouseBindings.Primary // Left Click
-            }
+            }
-          ]
+          ]
-        })
+        })
         // toolGroup.setToolConfiguration(OrientationMarkerTool.toolName, {
         //   orientationWidget: {
         //     enabled: true,
@@ -1138,11 +1139,11 @@ export default {
       mipToolGroup.setToolActive(VolumeRotateTool.toolName, {
         bindings: [{ mouseButton: MouseBindings.Wheel }],
       });
-      mipToolGroup.addTool(FusionJumpToPointTool.toolName, this.getFusionJumpToolConfiguration())
+      mipToolGroup.addTool(FusionJumpToPointTool.toolName, this.getFusionJumpToolConfiguration())
 
       // Set the initial state of the tools, here we set one tool active on left click.
       // This means left click will draw that tool.
-      mipToolGroup.setToolActive(FusionJumpToPointTool.toolName, {
+      mipToolGroup.setToolActive(FusionJumpToPointTool.toolName, {
         bindings: [
           {
             mouseButton: MouseBindings.Primary // Left ClickR
@@ -1156,81 +1157,111 @@ export default {
       // mipToolGroup.setToolActive(OrientationMarkerTool.toolName)
       mipToolGroup.addViewport(viewportIds.PETMIP.CORONAL, renderingEngineId)
     },
-    getFusionJumpToolConfiguration() {
+    getFusionJumpToolConfiguration() {
-      return {
+      return {
-        targetViewportIds: [
+        targetViewportIds: [
-          viewportIds.CT.AXIAL,
+          viewportIds.CT.AXIAL,
-          viewportIds.PT.AXIAL,
+          viewportIds.PT.AXIAL,
-          viewportIds.FUSION.AXIAL,
+          viewportIds.FUSION.AXIAL,
-          viewportIds.PETMIP.CORONAL
+          viewportIds.PETMIP.CORONAL
-        ],
+        ],
-        useBrightestPoint: true,
+        useBrightestPoint: true,
-        jumpToTargetViewports: true,
+        jumpToTargetViewports: true,
-        dispatchEventName: 'fusion-mip-point-selected',
+        dispatchEventName: 'fusion-mip-point-selected',
-        getReferenceLineColor: this.setFusionCrosshairsToolLineColor,
+        getReferenceLineColor: this.setFusionCrosshairsToolLineColor,
-        style: this.fusionCrosshairStyle,
+        style: this.fusionCrosshairStyle,
-        referenceLinesCenterGapRadius: this.fusionCrosshairStyle.centerHoleSize,
+        referenceLinesCenterGapRadius: this.fusionCrosshairStyle.centerHoleSize,
-        minimal: {
+        minimal: {
-          enabled: true,
+          enabled: true,
-          lineLengthInPx: this.fusionCrosshairStyle.lineLength,
+          lineLengthInPx: this.fusionCrosshairStyle.lineLength,
-        },
+        },
-        mipViewportIds: [viewportIds.PETMIP.CORONAL]
+        mipViewportIds: [viewportIds.PETMIP.CORONAL]
-      }
+      }
-    },
+    },
-    setFusionCrosshairsToolLineColor(viewportId) {
+    setFusionCrosshairsToolLineColor(viewportId) {
-      const colors = {
+      const colors = {
-        [viewportIds.CT.AXIAL]: '#0000ff',
+        [viewportIds.CT.AXIAL]: '#0000ff',
-        [viewportIds.PT.AXIAL]: '#0000ff',
+        [viewportIds.PT.AXIAL]: '#0000ff',
-        [viewportIds.FUSION.AXIAL]: '#0000ff',
+        [viewportIds.FUSION.AXIAL]: '#0000ff',
-        [viewportIds.PETMIP.CORONAL]: '#ff0000'
+        [viewportIds.PETMIP.CORONAL]: '#ff0000'
-      }
+      }
-      return colors[viewportId] || '#0000ff'
+      return colors[viewportId] || '#0000ff'
-    },
+    },
-    dispatchFusionCenterPoint(retryCount = 0) {
+    handleFusionSlicePointChange({ viewportId, worldPoint }) {
-      const renderEngine = getRenderingEngine(renderingEngineId)
+      if (!this.isFusion) return
-      if (!renderEngine) return
+      if (!viewportId || !Array.isArray(worldPoint) || worldPoint.length < 3) return
-      const toolGroupCandidates = [fusionToolGroupId, mipToolGroupUID, ptToolGroupId, ctToolGroupId]
+      if (viewportId === viewportIds.PETMIP.CORONAL) return
-      let instance = null
+
-      for (const toolGroupId of toolGroupCandidates) {
+      const activeViewportId = this.activeIndex === 1
-        const toolGroup = ToolGroupManager.getToolGroup(toolGroupId)
+        ? viewportIds.CT.AXIAL
-        instance = toolGroup?.getToolInstance?.(FusionJumpToPointTool.toolName)
+        : this.activeIndex === 2
-        if (instance?.setPoint) break
+          ? viewportIds.PT.AXIAL
-      }
+          : this.activeIndex === 3
-      if (!instance?.setPoint) {
+            ? viewportIds.FUSION.AXIAL
-        if (retryCount < 10) {
+            : viewportIds.PETMIP.CORONAL
-          setTimeout(() => {
+      if (viewportId !== activeViewportId) return
-            this.dispatchFusionCenterPoint(retryCount + 1)
+
-          }, 120)
+      const renderEngine = getRenderingEngine(renderingEngineId)
-        }
+      if (!renderEngine) return
-        return
+      const toolGroupCandidates = [fusionToolGroupId, mipToolGroupUID, ptToolGroupId, ctToolGroupId]
-      }
+      let instance = null
-
+      for (const toolGroupId of toolGroupCandidates) {
-      const candidates = [viewportIds.FUSION.AXIAL, viewportIds.PT.AXIAL, viewportIds.CT.AXIAL]
+        const toolGroup = ToolGroupManager.getToolGroup(toolGroupId)
-      for (const viewportId of candidates) {
+        instance = toolGroup.getToolInstance(FusionJumpToPointTool.toolName)
-        const viewport = renderEngine.getViewport(viewportId)
+        if (instance.setPoint) break
-        if (!viewport) continue
+      }
-        const width = viewport.element?.clientWidth
+      if (!instance.setPoint) return
-        const height = viewport.element?.clientHeight
+
-        let worldPoint = null
+      instance.setPoint(worldPoint, viewportId, renderEngine.id, {
-        if (width && height && viewport.canvasToWorld) {
+        jumpToTargetViewports: false,
-          worldPoint = viewport.canvasToWorld([width / 2, height / 2])
+        dispatchEvent: false,
-        }
+      })
-        if ((!worldPoint || worldPoint.length < 3) && viewport.getCamera) {
+    },
-          worldPoint = viewport.getCamera()?.focalPoint
+    dispatchFusionCenterPoint(retryCount = 0) {
-        }
+      const renderEngine = getRenderingEngine(renderingEngineId)
-        if (!worldPoint || worldPoint.length < 3) continue
+      if (!renderEngine) return
-        instance.setPoint(worldPoint, viewportId, renderEngine.id, {
+      const toolGroupCandidates = [fusionToolGroupId, mipToolGroupUID, ptToolGroupId, ctToolGroupId]
-          jumpToTargetViewports: true,
+      let instance = null
-          dispatchEvent: false,
+      for (const toolGroupId of toolGroupCandidates) {
-        })
+        const toolGroup = ToolGroupManager.getToolGroup(toolGroupId)
-        return
+        instance = toolGroup?.getToolInstance?.(FusionJumpToPointTool.toolName)
-      }
+        if (instance?.setPoint) break
-      if (retryCount < 10) {
+      }
-        setTimeout(() => {
+      if (!instance?.setPoint) {
-          this.dispatchFusionCenterPoint(retryCount + 1)
+        if (retryCount < 10) {
-        }, 120)
+          setTimeout(() => {
-      }
+            this.dispatchFusionCenterPoint(retryCount + 1)
-    },
+          }, 120)
+        }
+        return
+      }
+
+      const candidates = [viewportIds.FUSION.AXIAL, viewportIds.PT.AXIAL, viewportIds.CT.AXIAL]
+      for (const viewportId of candidates) {
+        const viewport = renderEngine.getViewport(viewportId)
+        if (!viewport) continue
+        const width = viewport.element?.clientWidth
+        const height = viewport.element?.clientHeight
+        let worldPoint = null
+        if (width && height && viewport.canvasToWorld) {
+          worldPoint = viewport.canvasToWorld([width / 2, height / 2])
+        }
+        if ((!worldPoint || worldPoint.length < 3) && viewport.getCamera) {
+          worldPoint = viewport.getCamera()?.focalPoint
+        }
+        if (!worldPoint || worldPoint.length < 3) continue
+        instance.setPoint(worldPoint, viewportId, renderEngine.id, {
+          jumpToTargetViewports: true,
+          dispatchEvent: false,
+        })
+        return
+      }
+      if (retryCount < 10) {
+        setTimeout(() => {
+          this.dispatchFusionCenterPoint(retryCount + 1)
+        }, 120)
+      }
+    },
     getTextLines(data, targetId) {
       const cachedVolumeStats = data.cachedStats[targetId]
       const {

src/views/trials/trials-panel/reading/dicoms/components/Fusion/Viewport.vue

@@ -272,6 +272,24 @@ export default {
           this.renderColorBar(this.presetName)
         }
       }
+
+      if (this.index !== 4 && viewport) {
+        const width = viewport.element.clientWidth
+        const height = viewport.element.clientHeight
+        let worldPoint = null
+        if (width && height && viewport.canvasToWorld) {
+          worldPoint = viewport.canvasToWorld([width / 2, height / 2])
+        }
+        if ((!worldPoint || worldPoint.length < 3) && viewport.getCamera) {
+          worldPoint = viewport.getCamera()?.focalPoint
+        }
+        if (Array.isArray(worldPoint) && worldPoint.length >= 3) {
+          this.$emit('fusionSlicePointChange', {
+            viewportId: this.viewportId,
+            worldPoint: [...worldPoint]
+          })
+        }
+      }
     },
     getOrientationMarker() {
       // eslint-disable-next-line no-unused-vars

src/views/trials/trials-panel/reading/dicoms3D/components/PetCtViewport.vue

@@ -270,6 +270,24 @@ export default {
         }
       }
 
+      if (!this.isMip && viewport) {
+        const width = this.element?.clientWidth
+        const height = this.element?.clientHeight
+        let worldPoint = null
+        if (width && height && viewport.canvasToWorld) {
+          worldPoint = viewport.canvasToWorld([width / 2, height / 2])
+        }
+        if ((!worldPoint || worldPoint.length < 3) && viewport.getCamera) {
+          worldPoint = viewport.getCamera()?.focalPoint
+        }
+        if (Array.isArray(worldPoint) && worldPoint.length >= 3) {
+          this.$emit('fusionSlicePointChange', {
+            viewportId: this.viewportId,
+            worldPoint: [...worldPoint],
+          })
+        }
+      }
+
     },
     setFullScreen(index) {
       setTimeout(() => {

src/views/trials/trials-panel/reading/dicoms3D/components/ReadPage.vue

@@ -362,7 +362,7 @@
                     :viewport-index="index" :active-tool="activeTool" @activeViewport="activeViewport"
                     @toggleTaskByViewport="toggleTaskByViewport" @previewCD="previewCD"
                     @renderAnnotations="renderAnnotations" @upperRangeChange="upperRangeChange"
-                    @contentMouseup="contentMouseup" />
+                    @contentMouseup="contentMouseup" @fusionSlicePointChange="handleFusionSlicePointChange" />
                 </div>
               </div>
               <div v-if="readingTool === 2" class="fusion-hidden-viewports">
@@ -2634,6 +2634,25 @@ export default {
       if (this.isFusion) return [this.fusionToolGroupId]
       return [`${this.viewportKey}-0`, `${this.viewportKey}-1`, `${this.viewportKey}-2`, `${this.viewportKey}-3`]
     },
+    handleFusionSlicePointChange({ viewportId, worldPoint }) {
+      if (!this.isFusion) return
+      if (!viewportId || !Array.isArray(worldPoint) || worldPoint.length < 3) return
+
+      const activeFusionViewportId = `viewport-fusion-${this.activeViewportIndex}`
+      if (viewportId !== activeFusionViewportId) return
+      if (viewportId === 'viewport-fusion-3') return
+
+      const renderingEngine = getRenderingEngine(renderingEngineId)
+      if (!renderingEngine) return
+      const toolGroup = ToolGroupManager.getToolGroup(this.fusionToolGroupId)
+      const instance = toolGroup.getToolInstance(FusionJumpToPointTool.toolName)
+      if (!instance.setPoint) return
+
+      instance.setPoint(worldPoint, viewportId, renderingEngine.id, {
+        jumpToTargetViewports: false,
+        dispatchEvent: false,
+      })
+    },
     setFusionMipJumpEnabled(enabled) {
       if (!this.isFusion) return
       const toolGroup = ToolGroupManager.getToolGroup(this.fusionToolGroupId)