Merge remote-tracking branch 'origin/master'

xyc

2024-05-09 7b02e5ed98cab7df7c52949c5bba298d1060329b

Merge remote-tracking branch 'origin/master'

 web/src/views/modules/taskReliability/RBD-edit-img.vue

@@ -1,14 +1,14 @@
<template>
  <div>
    <el-row :gutter="[8,8]">
      <el-col :span="4">
      <el-col :span="3">
        <div :style="'height:' +left_p+'px'">
          <div style="height: 100%">
            <div id="stencilImg"></div>
          </div>
        </div>
      </el-col>
      <el-col :span="20">
      <el-col :span="21">
        <div class="fa-card-a">
          <el-form :inline="true">
            <el-form-item>
@@ -60,6 +60,7 @@
  import {removeCurrentTabHandle} from '@/commonJS/common'
  import {setHartBeat} from '@/commonJS/common';
  import Cookies from 'js-cookie'
  import {getUUID} from '../../../../packages/utils'

  export default {
    name: 'RBD-edit-img',
@@ -87,6 +88,7 @@
    },
    data() {
      return {
        isFirstLoad: true,
        hasMoveNode: false,
        hasMoveSingleNode: null,
        nodeAdded: false,
@@ -96,26 +98,26 @@
        modelType: '',
        timer: null,
        imagesList: [
          {imgPath: 'start', imgName: 'start', nodeType: 'start', imgWidth: 60, imgHeight: 60, imgId: '1', data: {}},
          {imgPath: 'end', imgName: 'end', nodeType: 'end', imgWidth: 60, imgHeight: 60, imgId: '2', data: {}},
          {
            imgPath: 'connect',
            imgName: 'connect',
            nodeType: 'connect',
            imgWidth: 30,
            imgHeight: 30,
            imgId: '3',
            data: {}
          },
          {
            imgPath: 'switch',
            imgName: 'switch',
            nodeType: 'switch',
            imgWidth: 60,
            imgHeight: 60,
            imgId: '5',
            data: {}
          },
          // {imgPath: 'start', imgName: 'start', nodeType: 'start', imgWidth: 60, imgHeight: 60, imgId: '1', data: {}},
          // {imgPath: 'end', imgName: 'end', nodeType: 'end', imgWidth: 60, imgHeight: 60, imgId: '2', data: {}},
          // {
          //   imgPath: 'connect',
          //   imgName: 'connect',
          //   nodeType: 'connect',
          //   imgWidth: 30,
          //   imgHeight: 30,
          //   imgId: '3',
          //   data: {}
          // },
          // {
          //   imgPath: 'connect',
          //   imgName: 'bridge',
          //   nodeType: 'bridge',
          //   imgWidth: 50,
          //   imgHeight: 50,
          //   imgId: '12',
          //   data: {}
          // },
          {
            imgPath: 'parallel',
            imgName: 'parallel',
@@ -127,12 +129,12 @@
          },
          {imgPath: 'vote', imgName: 'vote', nodeType: 'vote', imgWidth: 60, imgHeight: 60, imgId: '6', data: {}},
          {
            imgPath: 'dashedBox',
            imgName: 'dashedBox',
            nodeType: 'dashedBox',
            imgPath: 'switch',
            imgName: 'switch',
            nodeType: 'switch',
            imgWidth: 60,
            imgHeight: 60,
            imgId: '9',
            imgId: '5',
            data: {}
          },
          {
@@ -141,7 +143,16 @@
            nodeType: 'bridgeConnection',
            imgWidth: 60,
            imgHeight: 60,
            imgId: '9',
            imgId: '10',
            data: {}
          },
          {
            imgPath: 'dashedBox',
            imgName: 'dashedBox',
            nodeType: 'dashedBox',
            imgWidth: 60,
            imgHeight: 60,
            imgId: '10000',
            data: {}
          },
        ],
@@ -346,6 +357,7 @@
        console.log(this.dataForm, 'init(row){')
      },
      async getDiagram(modelId) {
        this.isFirstLoad = true;
        let params = {
          modelId: modelId,
          urlPref: window.SITE_CONFIG['apiURL'],
@@ -360,6 +372,7 @@
          }else {
            this.initCells()
          }
          this.isFirstLoad = false;
          console.log(this.diagramJson.cells.length, 'this.diagramJson.cells.length')

          this.graph.positionContent('left')
@@ -444,7 +457,7 @@
                  line: {
                    stroke: '#A2B1C3',
                    strokeWidth: 2,
                    targetMarker: 'classic'
                    targetMarker: {fill: 'none'}
                  }
                },
                labels: [{
@@ -471,7 +484,7 @@
                    attrs: {fill: '#666'},
                  },
                },
                zIndex: 0,
                zIndex: -100,
              })
            },
            validateConnection({targetMagnet}) {
@@ -507,7 +520,7 @@
          getDropNode: (node) => {
            const { width, height } = node.size()
            if(node.getData().type && node.getData().nodeType === 'dashedBox'){
              return node.clone().size(170, 90)
              return node.clone().size(100, 80)
            }
            if (node.getData().type && node.getData().type === 'imageNodes2') {
              return node.clone({keepId: true})
@@ -533,7 +546,7 @@
            {
              title: '运算符号',
              name: 'group1',
              graphHeight: 360,
              graphHeight: 260,
            },
            {
              title: '设备节点',
@@ -556,9 +569,12 @@
            // imageUrl: require('/public/modelImg/' + item.imgPath + '.png'),
            width: item.imgWidth,
            height: item.imgHeight,
            id: item.imgId,
            data: {
              type: 'imageNodes',
              dataId: '',
              startNodeId: '',
              endNodeId: '20000',
              nodeType: item.nodeType,
              nodeTypeExt: '',
              voteNum: ''
@@ -703,23 +719,83 @@
//delete
        this.graph.bindKey('delete', () => {
          const cells = this.graph.getSelectedCells()
          if (cells.length) {
          console.log(cells, 'cells')
          if (cells.length === 1) {
            let node = cells[0]
            if (!node.isNode()) {
              this.$message({message: '请选中节点', type: 'warning'})
              return false; // 取消操作
            }
            let nodeType = node.getData().nodeType
            let deleteType = 0
            if (nodeType === 'node' || nodeType === 'dashedBox') {
              deleteType = 1
            } else if ('parallel,switch,vote,bridge'.indexOf(nodeType) > -1) {
              deleteType = 2
            }
            let canDelete = false
            if (nodeType === 'start' || nodeType === 'end') {
              this.$message({message: '无法删除起始和结束节点', type: 'warning'})
              return false; // 取消操作
            }
            if (deleteType > 0) {
              let startNode = null
              if (deleteType === 1) {
                startNode = node
              } else if (deleteType === 2) {
                startNode = this.graph.getCellById(node.getData().startNodeId)
              }
              let isSeriesNode = this.isSeriesNode(startNode, node)
              if (isSeriesNode) {
                let inLine = this.getInLinesOfNode(startNode)
                let outLine = this.getOutLinesOfNode(node)
                let inLineIsToLine = this.hasOtherLineToMyLine(inLine[0].id)
                let inNode = isSeriesNode.inNode
                let outNode = isSeriesNode.outNode
                console.log(inLine, outLine, 'inLine,outLine')
                console.log(inNode, outNode, 'inNode,outNode')
                if (inLineIsToLine) {
                  inLine[0].target = {cell: outNode.id, port: 'left1'}
                } else {
                  outLine[0].source = {cell: inNode.id, port: 'right1'}
                }
                //提示是否要删除
            this.$confirm('是否删除该节点?', '提示', {
              confirmButtonText: '确定',
              cancelButtonText: '取消',
              type: 'warning'
            }).then(() => {
                  if (deleteType === 1){
                    node.remove()
                  }
                  else{
                    this.deleteCombination(node)
                  }
              this.$message({
                type: 'success',
                message: '删除成功!'
              })
              this.graph.removeCells(cells)
            }).catch(() => {
              this.$message({
                type: 'info',
                message: '已取消删除'
              })
            })
              }
              if (this.isMultipleBrach(node)) {
                //提示是否要删除
                if (deleteType === 1)
                  node.remove()
                else
                  this.deleteCombination(node)
                return
              }
            }
            //提示不能删除
          } else {
            //提示不能删除
            this.$message({message: '只能选中一个节点', type: 'warning'})
            return false; // 取消操作
          }
        })
// zoom
@@ -745,79 +821,48 @@
        })
        // 监听节点添加事件
        this.graph.on('node:added', ({node}) => {
          const nodeId = node.id; // 获取节点的唯一 ID
          if (this.isFirstLoad) {
            return
          }
          if (node.getData().isSelfCreated) {
            return
          }
          const nodeType = node.getData().nodeType; // 获取节点的类型
          const nodeObj = node
          const intersectNodes = [];
          // 检查除当前节点之外的所有节点的包围框是否相交
          for (const otherNode of this.graph.getNodes()) {
            if (otherNode === node) continue;
            const bbox1 = node.getBBox();
            const bbox2 = otherNode.getBBox();
            if (this.isIntersect(bbox1, bbox2)) {
              intersectNodes.push(otherNode);
          console.log(123)
          let intersectNode = this.findIntersectsNode(node)
          if (intersectNode) { // 当有节点相交 ==>并行
            this.addBranch(intersectNode, nodeObj)
            return
          } else {
            let isSelfCreated = null
            try {
              isSelfCreated = node.getData().isSelfCreated
            } catch (e) {
            }
            if (!isSelfCreated) {
              let intersectEdge = this.findIntersectsEdge(this.graph, node)
              if (intersectEdge) { // 当有边相交 ==>串联
                this.addNodeAndInsertEdge(intersectEdge, nodeObj)
                return
              } else {
                //提示
            }
          }
          if (intersectNodes.length > 0) {
            // console.log('Nodes intersect with node:', node.id);
            console.log('Intersecting nodes:', intersectNodes.map(n => n)); // 相交节点的对象
            intersectNodes.map(node => {
              this.addNodeAndConnect(node, nodeObj);
            })
          }
          node.remove()

          /*//如果节点与节点相交
          console.log(node.position().x, node.position().x, 'node.position().x')
          if (nodeType === 'bridgeConnection') {
            this.getBridgeConnection()
          }*/
        });
        // 监听节点位置改变事件
        this.graph.on('node:change:position', ({node}) => {
          this.hasMoveNode = true
          this.hasMoveSingleNode = node
        });
        // 抬起
        this.graph.on('node:mouseup', ({e,x,y,node}) => {

          if (this.hasMoveNode) {
            const selectionNodes = this.graph.getSelectedCells().filter(node => node.isNode() )
            if (selectionNodes.length == 0){
              selectionNodes.push(this.hasMoveSingleNode)
            }
            //let selectionNodes = []
            console.log('横坐标：',x,'纵坐标：'+y)
            // let allNodes = this.graph.getNodes()
            //
            // for(let node of allNodes){
            //    if (this.graph.isSelected(node)){
            //      selectionNodes.push(node)
            //    }
            //
            // }
            // 获取包含指定坐标点的节点
            const nodes = this.graph.getNodes();
            let hasNodes = []
            for (let i = 0; i < nodes.length; i++) {
              const node = nodes[i];
              const bbox = node.getBBox();
              if (x>=bbox.x && x <= bbox.x + bbox.width && y>=bbox.y && y <= bbox.y + bbox.height) {
                if ( selectionNodes.indexOf(node)===-1) {
                  hasNodes.push(node);
                }
              }
            }
            if(hasNodes){}
            console.log('获取包含指定坐标点的节点集合',hasNodes)
            console.log('选中的节点集合：',selectionNodes)

            // if (selectionNodes.length>2)
            //   this.graph.addEdge({
            //     source: {cell: selectionNodes[0], port: 'left1'},
            //     target: {cell: selectionNodes[selectionNodes.length-1], port: 'right1'},
            //     router: {name: 'manhattan'},
            //     connector: {name: 'rounded'}
            //   })
            this.hasMoveNode = false
            this.hasMoveSingleNode = null


            // console.log('移动过节点（多个）再抬起鼠标后得到的节点',selectedNodes);
          }
        });
        // this.graph.on('node:change:position', ({node}) => {
        //   this.hasMoveNode = true
        //   this.hasMoveSingleNode = node
        // });
        this.graph.on('cell:click', ({cell}) => {
          // this.type.value = cell.isNode() ? "node" : "edge"
          this.type = cell.isNode() ? 'node' : 'edge'
@@ -1080,144 +1125,156 @@
        }
      },
      // 定义函数来检查两个包围框是否相交
      isIntersect(bbox1, bbox2) {
        return (
          bbox1.x < bbox2.x + bbox2.width &&
      findIntersectsNode(node) {
        const nodes = this.graph.getNodes()
        let intersectNodes = []
        const bbox1 = node.getBBox();
        // 检查除当前节点之外的所有节点的包围框是否相交
        for (const otherNode of nodes) {
          if (otherNode === node) continue;
          let nodeType = otherNode.getData().nodeType
          if (nodeType === "parallel" || nodeType === "switch" || nodeType === "vote" || nodeType === "dashedBox") {
            const bbox2 = otherNode.getBBox();
            if (bbox1.x < bbox2.x + bbox2.width &&
          bbox1.x + bbox1.width > bbox2.x &&
          bbox1.y < bbox2.y + bbox2.height &&
          bbox1.y + bbox1.height > bbox2.y
        )
      },
      addNodeAndConnect(node, nodeObj) { // node是画布原有的节点。nodeObj是当前拖拽的节点
        const nodeType = node.getData().nodeType  // 获取画布原有的节点类型
        const nodeObjType = nodeObj.getData().nodeType  // 获取当前拖拽的节点类型
        const edges = this.graph.getConnectedEdges(node); // 获取与原节点相关联的所有连接线
        let TopSum = 0 // 在原节点上方
        let BottomSum = 0 // 在原节点下方
        const edgesSum = edges.length
        if ((nodeType === 'end'|| nodeType === 'vote' || nodeType === 'switch' || nodeType === 'parallel') && nodeObjType === 'node') {
          if (edges.length === 0) {
            if (!this.nodeAdded) {
              // 添加节点的操作
              this.connectNode = this.graph.addNode({
                shape: 'image',
                // imageUrl: require('/public/modelImg/' + item.imgPath + '.png'),
                width: 30,
                height: 30,
                data: {
                  type: 'imageNodes',
                  dataId: '',
                  signId:node.id,
                  nodeType: 'connect',
                  nodeTypeExt: '',
                  voteNum: ''
                },
                attrs: {
                  image: {
                    'xlink:href': '/modelImg/connect.svg',
                  },
                  text: {
                    text: 'connect',
                    fontSize: 14,
                    refX: 0.5,
                    refY: '100%',
                    refY2: 4,
                    textAnchor: 'middle',
                    textVerticalAnchor: 'top',
                  },
                },
                ports: {...this.ports},
              })
              // 设置标记为 true，表示已经添加过节点
              this.nodeAdded = true;
              bbox1.y + bbox1.height > bbox2.y) {
              intersectNodes.push(otherNode);
            }
            nodeObj.position(node.position().x - 120, node.position().y - (120 * edgesSum));
            this.connectNode.position(node.position().x - 240, node.position().y + (node.size().height - this.connectNode.size().height) / 2);
          } else if (edges.length === 1) {
            // 将节点移动到指定的位置
            nodeObj.position(node.position().x - 120, node.position().y - (120 * edgesSum));
          }
        }
        if (intersectNodes.length === 1) {
          //console.log('Intersecting nodes:', intersectNodes.map(n => n)); // 相交节点的对象
          return intersectNodes[0]
          } else {
            for (const edge of edges) {
              const sourcePointY = edge.getSourcePoint().y; // 获取连接线的起始点y坐标
              const targetPointY = edge.getTargetPoint().y; // 获取连接线的结束点y坐标
              console.log('原节点Y坐标' + node.position().y, '连接线起始Y坐标' + sourcePointY)
              if (targetPointY > sourcePointY) {
                TopSum++
              } else if (targetPointY < sourcePointY) {
                BottomSum++
          //提示用户只能拖到一个有效的节点上
          return null
              }
            }
            console.log('在原节点上方的连接线数量:' + TopSum, '在原节点下方的连接线数量:' + BottomSum)
            if (TopSum > BottomSum) {
              nodeObj.position(node.position().x - 120, node.position().y + (120 + (120 * BottomSum)))
            } else {
              nodeObj.position(node.position().x - 120, node.position().y - (120 + (120 * TopSum)));
            }
          }
          this.graph.addEdge({
            source: {cell: nodeObj, port: 'right1'},
            target: {cell: node, port: 'left1'},
            router: {name: 'manhattan'},
            connector: {name: 'rounded'}
          })
          if (this.nodeAdded) {
            console.log(this.connectNode, 'connectNode')
            this.graph.addEdge({
              source: {cell: this.connectNode, port: 'right1'},
              target: {cell: nodeObj, port: 'left1'},
              router: {name: 'manhattan'},
              connector: {name: 'rounded'}
            })
          }
        }
        if (nodeType === 'node' || (nodeType === 'dashedBox' && nodeObjType === 'dashedBox')) {
          // 遍历所有连接线并删除与给定节点对象相关的连接线
          console.log(edges, '所有有关联的连接线 edge')
          if (edges.length === 0) {
            this.graph.addEdge({
              source: {cell: node, port: 'right1'},
              target: {cell: nodeObj, port: 'left1'},
              router: {name: 'manhattan'},
              connector: {name: 'rounded'}
            })
            return nodeObj.position(node.position().x + node.getBBox().width + 50, node.position().y);
          } else {
            for (const edge of edges) {
              console.log(edge, '所有有关联的连接线 edge')
              if (edge.source.cell === node.id) { // 如果连接线的起始节点等于当前画布目标节点的ID
                const sourceNode = this.graph.getCellById(edge.source.cell); // 获取连接线的源节点对象
                const targetNode = this.graph.getCellById(edge.target.cell) // 获取连接线的目标节点对象
                console.log(sourceNode, targetNode, 'targetNode 目标节点对象')
                // edge.remove(); // 从图中删除该连接线
                nodeObj.position(node.position().x + node.getBBox().width + 50, node.position().y + (node.size().height - nodeObj.size().height) / 2);
                // edge.source = {cell: node, port: 'right1'}
                edge.target = {cell: nodeObj, port: 'left1'}
                // targetNode.position(nodeObj.position().x +nodeObj.getBBox().width+50, node.position().y);
                // this.graph.addEdge({
                //   source: {cell: node, port: 'right1'},
                //   target: {cell: nodeObj, port: 'left1'},
                //   router: {name: 'manhattan'},
                //   connector: {name: 'rounded'}
                // })
                this.graph.addEdge({
                  source: {cell: nodeObj, port: 'right1'},
                  target: {cell: targetNode, port: 'left1'},
                  router: {name: 'manhattan'},
                  connector: {name: 'rounded'}
                })
              } else {
                this.graph.addEdge({
                  source: {cell: node, port: 'right1'},
                  target: {cell: nodeObj, port: 'left1'},
                  router: {name: 'manhattan'},
                  connector: {name: 'rounded'}
                })
                nodeObj.position(node.position().x + node.getBBox().width + 50, node.position().y);
              }
            }
          }
      },
      // 相交的节点
      addBranch(graphNode, dragNode) { // graphCell是画布上原有的节点。dragNode是当前拖拽的节点
        let graphNodeType = graphNode.getData().nodeType

        let dragNodeType = dragNode.getData().nodeType
        let offHeight = 60
        if (dragNodeType === 'node') {
          offHeight = 60
        } else if (dragNodeType === 'bridgeConnection') {
          offHeight = 230
        } else {
          offHeight = 70
        }
        if (graphNodeType === 'dashedBox') { //虚框
          const edges = this.graph.getConnectedEdges(graphNode); // 获取画布上原有的节点所有进来的线
          let inEdges = edges.filter(edge => edge.target.cell === graphNode.id)
          let startNode = null
          let endNode = null
          if (inEdges.length === 1) {
            let startNodeId = inEdges[0].source.cell
            startNode = this.graph.getCellById(startNodeId)
          }
          let outEdges = edges.filter(edge => edge.source.cell === graphNode.id)
          if (outEdges.length === 1) {
            let endNodeId = outEdges[0].target.cell
            endNode = this.graph.getCellById(endNodeId)
          }
          if (startNode && endNode) {
            let centerY = graphNode.position().y
            let result = this.addNodeAndConnect(startNode, endNode, dragNode, dragNode.position().x, centerY)
            inEdges[0].target = {cell: result.newStartNode.id, port: 'left1'}
            outEdges[0].source = {cell: result.newEndNode.id, port: 'right1'}
            graphNode.remove()
          }
        } else { //并行结构
          const graphNodeStartNodeId = graphNode.getData().startNodeId  // 获取画布上原有节点的开始ID
          const graphNodeStartNode = this.graph.getCellById(graphNodeStartNodeId) // 通过开始ID得到初始节点对象
          let graphNodeY = graphNode.position().y - graphNode.getBBox().height / 2 // 获取画布原有节点的y坐标
          let minY = graphNode.position().y
          let maxY = graphNode.position().y + graphNode.getBBox().height

          const edges = this.graph.getConnectedEdges(graphNode); // 获取画布上原有的节点所有进来的线
          let inEdges = edges.filter(edge => edge.target.cell === graphNode.id)
          //遍历这个组合里面所有节点， 修改minY，maxY

          let pointXY = {minY: minY, maxY: maxY}
          console.log(pointXY, 'old')
          this.getYRange(inEdges, graphNodeStartNode, pointXY)
          console.log(pointXY, 'new')

          let minX = graphNodeStartNode.position().x + graphNodeStartNode.getBBox().width
          let maxX = graphNode.position().x
          let centerX = minX + (maxX - minX) / 2
          let centerY = graphNodeY - pointXY.minY > pointXY.maxY - graphNodeY ? pointXY.maxY + 30 : pointXY.minY - offHeight - 30

          let result = this.addNodeAndConnect(graphNodeStartNode, graphNode, dragNode, minX, centerY)
          this.graph.addEdge({
            source: {cell: graphNodeStartNode, port: 'right1'},
            target: {cell: result.newStartNode, port: 'left1'},
            router: {name: 'manhattan'},
            connector: {name: 'rounded'}
          })
          this.graph.addEdge({
            source: {cell: result.newEndNode, port: 'right1'},
            target: {cell: graphNode, port: 'left1'},
            router: {name: 'manhattan'},
            connector: {name: 'rounded'}
          })
        }
      },
      addNodeAndConnect(startNode, endNode, dragNode, leftX, centerY) { // graphCell是画布上原有的节点。dragNode是当前拖拽的节点
        let dragNodeType = dragNode.getData().nodeType
        if (dragNodeType === 'node' || dragNodeType === 'dashedBox') {
          dragNode.position(leftX + 50, centerY);
          return {newStartNode: dragNode, newEndNode: dragNode}
        } else if (dragNodeType === 'bridgeConnection') {
          return this.createBridgeConnection(leftX, centerY, startNode, endNode, dragNode)
        } else {
          return this.createParallelBrach(leftX, centerY, startNode, endNode, dragNode)
        }
      },
      // 相交的边
      addNodeAndInsertEdge(graphEdge, dragNode) {
        let startNodeId = graphEdge.source.cell
        let startNode = this.graph.getCellById(startNodeId)
        let endNodeId = graphEdge.target.cell
        let endNode = this.graph.getCellById(endNodeId)
        if (startNode && endNode) {
          let centerY = dragNode.position().y
          let isRight = true;
          let startPort = 'right1'
          let endPort = 'left1'
          if (this.isTopBottom(graphEdge)) {
            startPort = 'bottom1'
            endPort = 'top1'
          }
          if (this.hasOtherLineToMyLine(graphEdge.id)) {
            let leftX = startNode.position().x + startNode.getBBox().width
            let rightX = endNode.position().x
            let centerX = dragNode.position().x + dragNode.getBBox().width / 2
            if (centerX - leftX < rightX - centerX) {
              isRight = false
            }
          }
          let result = this.addNodeAndConnect(startNode, endNode, dragNode, dragNode.position().x, centerY)
          if (isRight) {
            graphEdge.target = {cell: result.newStartNode.id, port: endPort}
            this.graph.addEdge({
              source: {cell: result.newEndNode, port: startPort},
              target: {cell: endNode, port: endPort},
              router: {name: 'manhattan'},
              connector: {name: 'rounded'}
            })

          } else {
            this.graph.addEdge({
              source: {cell: startNode, port: startPort},
              target: {cell: result.newStartNode, port: endPort},
              router: {name: 'manhattan'},
              connector: {name: 'rounded'}
            })
            graphEdge.source = {cell: result.newEndNode.id, port: startPort}
          }
          // graphEdge.remove()
        }
      },
      initCells(){
@@ -1226,8 +1283,10 @@
          // imageUrl: require('/public/modelImg/' + item.imgPath + '.png'),
          width: 60,
          height: 60,
          id: '10000',
          data: {
            type: 'imageNodes',
            endNodeId: '20000',
            dataId: '',
            nodeType: 'start',
            nodeTypeExt: '',
@@ -1252,8 +1311,9 @@
        const dashedBox = this.graph.addNode({
          shape: 'image',
          // imageUrl: require('/public/modelImg/' + item.imgPath + '.png'),
          width: 170,
          height: 90,
          width: 100,
          height: 80,
          id: 15000,
          data: {
            type: 'imageNodes',
            dataId: '',
@@ -1281,8 +1341,10 @@
          shape: 'image',
          width: 60,
          height: 60,
          id: '20000',
          data: {
            type: 'imageNodes',
            startNodeId: '10000',
            dataId: '',
            nodeType: 'end',
            nodeTypeExt: '',
@@ -1320,8 +1382,394 @@
          connector: {name: 'rounded'}
        })
      },
      findIntersectsEdge(graph, node) {
        const edges = graph.getEdges()
        const bbox = node.getBBox();
        const lines = [bbox.leftLine, bbox.rightLine, bbox.topLine, bbox.bottomLine];
        let res = [];
        edges.forEach((edge) => {
          const view = graph.findViewByCell(edge);
          lines.forEach((line) => {
            if (view) {
              if (view.path.intersectsWithLine(line)) {
                res.push(edge);
              }
            }
          })
        })
        const uniqueArr = res.filter((insEdge, index) =>
          res.findIndex(i => i.id === insEdge.id) === index);
        console.log(uniqueArr, 'uniqueArr')
        if (uniqueArr.length === 1) {
          return uniqueArr[0]
        } else {
          return false
        }
    },
      createParallelBrach(x, y, startNode, endNode, dragNode) {
        dragNode.position(x + 320, y - dragNode.size().height / 2)
        const connectNode = this.createConnectNode(x + 50, y)
        const dashedBox = this.createDashedBox(x + 150, y)
        dragNode.setData({startNodeId: connectNode.id})

        this.graph.addEdge({
          source: {cell: connectNode, port: 'right1'},
          target: {cell: dashedBox, port: 'left1'},
          router: {name: 'manhattan'},
          connector: {name: 'rounded'}
        })
        this.graph.addEdge({
          source: {cell: dashedBox, port: 'right1'},
          target: {cell: dragNode, port: 'left1'},
          router: {name: 'manhattan'},
          connector: {name: 'rounded'}
        })
        return {newStartNode: connectNode, newEndNode: dragNode}
        /*        this.graph.addEdge({
                  source: {cell: startNode, port: 'right1'},
                  target: {cell: connectNode, port: 'left1'},
                  router: {name: 'manhattan'},
                  connector: {name: 'rounded'}
                })
                this.graph.addEdge({
                  source: {cell: dragNode, port: 'right1'},
                  target: {cell: endNode, port: 'left1'},
                  router: {name: 'manhattan'},
                  connector: {name: 'rounded'}
                })*/
      },
      createBridgeConnection(x, y, startNode, endNode, dragNode) {
        const leftTopDashedBox = this.createDashedBox(x + 120, y)
        const rightTopDashedBox = this.createDashedBox(x + 400, y)

        const leftConnectNode = this.createConnectNode(x + 50, y + 80)
        const alignCenterDashedBox = this.createDashedBox(x + 260, y + 80)
        const rightConnectNode = this.createBridgeNode(x + 550, y + 80)

        const leftBottomDashedBox = this.createDashedBox(x + 120, y + 160)
        const rightBottomDashedBox = this.createDashedBox(x + 400, y + 160)

        rightConnectNode.setData({startNodeId: leftConnectNode.id})
        leftConnectNode.setData({endNodeId: rightConnectNode.id})
        /*        this.graph.addEdge({
                  source: {cell: startNode, port: 'right1'},
                  target: {cell: leftConnectNode, port: 'left1'},
                  router: {name: 'manhattan'},
                  connector: {name: 'rounded'},
                })
                this.graph.addEdge({
                  source: {cell: rightConnectNode, port: 'right1'},
                  target: {cell: endNode, port: 'left1'},
                  router: {name: 'manhattan'},
                  connector: {name: 'rounded'}
                })*/
        this.graph.addEdge({
          source: {cell: leftConnectNode, port: 'right1'},
          target: {cell: leftTopDashedBox, port: 'left1'},
          router: {name: 'manhattan'},
          connector: {name: 'rounded'}
        })
        this.graph.addEdge({
          source: {cell: leftConnectNode, port: 'right1'},
          target: {cell: leftBottomDashedBox, port: 'left1'},
          router: {name: 'manhattan'},
          connector: {name: 'rounded'}
        })

        let edgeTop = this.graph.addEdge({
          source: {cell: leftTopDashedBox, port: 'right1'},
          target: {cell: rightTopDashedBox, port: 'left1'},
          router: {name: 'manhattan'},
          connector: {name: 'rounded'}
        })
        let edgeBottom = this.graph.addEdge({
          source: {cell: leftBottomDashedBox, port: 'right1'},
          target: {cell: rightBottomDashedBox, port: 'left1'},
          router: {name: 'manhattan'},
          connector: {name: 'rounded'}
        })

        this.graph.addEdge({
          source: {cell: rightTopDashedBox, port: 'right1'},
          target: {cell: rightConnectNode, port: 'left1'},
          router: {name: 'manhattan'},
          connector: {name: 'rounded'}
        })
        this.graph.addEdge({
          source: {cell: rightBottomDashedBox, port: 'right1'},
          target: {cell: rightConnectNode, port: 'left1'},
          router: {name: 'manhattan'},
          connector: {name: 'rounded'}
        })

        this.graph.addEdge({
          source: {cell: edgeTop},
          target: {cell: alignCenterDashedBox, port: 'top1'},
          router: {name: 'manhattan'},
          connector: {name: 'rounded'},
        })
        this.graph.addEdge({
          source: {cell: alignCenterDashedBox, port: 'bottom1'},
          target: {cell: edgeBottom},
          router: {name: 'manhattan'},
          connector: {name: 'rounded'},
        })
        dragNode.remove()
        return {newStartNode: leftConnectNode, newEndNode: rightConnectNode}
      },
      createDashedBox(x, y) {
        const dashId = getUUID().toString()
        let dashedBox = this.graph.addNode({
          shape: 'image',
          // imageUrl: require('/public/modelImg/' + item.imgPath + '.png'),
          width: 100,
          height: 60,
          id: dashId,
          data: {
            isSelfCreated: true,
            type: 'imageNodes',
            dataId: '',
            nodeType: 'dashedBox',
            nodeTypeExt: '',
            voteNum: ''
          },
          attrs: {
            image: {
              'xlink:href': '/modelImg/dashedBox.svg',
            },
            text: {
              text: 'dashedBox',
              fontSize: 14,
              refX: 0.5,
              refY: '100%',
              refY2: 4,
              textAnchor: 'middle',
              textVerticalAnchor: 'top',
            },
          },
          ports: {...this.ports},
        })
        dashedBox.position(x, y - dashedBox.size().height / 2)
        return dashedBox
      },
      createConnectNode(x, y) {
        const connectId = getUUID().toString()
        const dragNodeId = getUUID().toString()
        let connectNode = this.graph.addNode({
          shape: 'image',
          // imageUrl: require('/public/modelImg/' + item.imgPath + '.png'),
          width: 30,
          height: 30,
          id: connectId,
          data: {
            isSelfCreated: true,
            type: 'imageNodes',
            endNodeId: dragNodeId,
            dataId: '',
            nodeType: 'connect',
            nodeTypeExt: '',
            voteNum: ''
          },
          attrs: {
            image: {
              'xlink:href': '/modelImg/connect.svg',
            },
            text: {
              text: 'connect',
              fontSize: 14,
              refX: 0.5,
              refY: '100%',
              refY2: 4,
              textAnchor: 'middle',
              textVerticalAnchor: 'top',
            },
          },
          ports: {...this.ports},
        })
        connectNode.position(x, y - connectNode.size().height / 2)
        return connectNode
      },
      createBridgeNode(x, y) {
        const connectId = getUUID().toString()
        const dragNodeId = getUUID().toString()
        let connectNode = this.graph.addNode({
          shape: 'image',
          width: 50,
          height: 50,
          id: connectId,
          data: {
            isSelfCreated: true,
            type: 'imageNodes',
            endNodeId: dragNodeId,
            dataId: '',
            nodeType: 'bridge',
            nodeTypeExt: '',
            voteNum: ''
          },
          attrs: {
            image: {
              'xlink:href': '/modelImg/connect.svg',
            },
            text: {
              text: 'bridge',
              fontSize: 14,
              refX: 0.5,
              refY: '100%',
              refY2: 4,
              textAnchor: 'middle',
              textVerticalAnchor: 'top',
            },
          },
          ports: {...this.ports},
        })
        connectNode.position(x, y - connectNode.size().height / 2)
        return connectNode
      },
      getYRange(inEdges, startNode, pointXY) {
        for (let inEdge of inEdges) {
          let nodeId = inEdge.source.cell
          let node = this.graph.getCellById(nodeId)
          if (node.position().y < pointXY.minY) {
            pointXY.minY = node.position().y
          }
          if (node.position().y + node.getBBox().height > pointXY.maxY) {
            pointXY.maxY = node.position().y + node.getBBox().height
          }
          if (node.id === startNode.id) {
            continue
          }
          const edges = this.graph.getConnectedEdges(node); // 获取画布上原有的节点所有进来的线
          let inEdgesPrev = edges.filter(edge => edge.target.cell === node.id)
          this.getYRange(inEdgesPrev, startNode, pointXY)
        }
      },
      isSeriesNode(startNode, endNode) {
        let result = false
        let inNode = null
        let outNode = null
        let inEdges = this.getInLinesOfNode(startNode)
        console.log(inEdges, 'inEdges')
        if (inEdges.length === 1) {
          let isMyLineToOtherLine = this.isMyLineToOtherLine(inEdges[0])
          let hasOtherLineToMyLine = this.hasOtherLineToMyLine(inEdges[0].id)
          let inNodeId = inEdges[0].source.cell
          inNode = this.graph.getCellById(inNodeId)
          if (!isMyLineToOtherLine && !hasOtherLineToMyLine) {
            let inNodeType = inNode.getData().nodeType
            console.log(inNodeType, 'inNodeType')
            if ('node,dashedBox,parallel,switch,vote,bridge'.indexOf(inNodeType) > -1) {
              result = true
            }
          }
        }
        let outEdges = this.getOutLinesOfNode(endNode)
        console.log(outEdges, 'outEdges')
        if (outEdges.length === 1) {
          let isMyLineToOtherLine = this.isMyLineToOtherLine(outEdges[0])
          let hasOtherLineToMyLine = this.hasOtherLineToMyLine(outEdges[0].id)
          let outNodeId = outEdges[0].target.cell
          outNode = this.graph.getCellById(outNodeId)
          if (!isMyLineToOtherLine && !hasOtherLineToMyLine) {
            let outNodeType = outNode.getData().nodeType
            if ('node,connect,dashedBox'.indexOf(outNodeType) > -1) {
              result = true
            }
          }
        }
        console.log(result, 'result')
        if (result && inNode && outNode) {
          console.log(inNode, outNode, 'inNode, outNode')
          return {inNode, outNode}
        } else {
          return false
        }
      },
      hasOtherLineToMyLine(edgeId) {
        for (let edge of this.graph.getEdges()) {
          if (edge.source.cell === edgeId || edge.target.cell === edgeId)
            return true
        }
        return false
      },
      isMyLineToOtherLine(myEdge) {
        for (let edge of this.graph.getEdges()) {
          if (myEdge.source.cell === edge.id || myEdge.target.cell === edge.id)
            return true
        }
        return false
      },
      isTopBottom(edge) {
        if (edge.source.port === 'top1' || edge.source.port === 'bottom1' || edge.target.port === 'top1' || edge.target.port === 'bottom1') {
          return true
        }
      },
      isMultipleBrach(node) {
        let outEdges = this.getOutLinesOfNode(node)
        let outNodeId = outEdges[0].target.cell
        if (this.isTopBottom(outEdges[0]))
          return false
        let outNode = this.graph.getCellById(outNodeId)
        if ('bridge,end'.indexOf(outNode.getData().nodeType) > -1) {
          return false
        }
        let inEdges = this.getInLinesOfNode(outNode)
        return inEdges.length > 1;
      },
      deleteCombination(node) {
        let startNode = this.graph.getCellById(node.getData().startNodeId)
        let allCombinationNodes = []
        console.log(startNode, 'startNode')
        this.getAllCombinationNodes(startNode.id, node, allCombinationNodes)
        console.log(allCombinationNodes, 'allCombinationNodes')
        this.graph.removeCells(allCombinationNodes)
      },
      getAllCombinationNodes(startNodeId, node, allCombinationNodes) {
        allCombinationNodes.push(node)
        if (node.id == startNodeId || node.isEdge()) {
          return
        }
        let inEdges = this.getInLinesOfNode(node) // 如果？？？
        for (let inEdge of inEdges) {
          let lineNode = this.getNodeOfConectLine(inEdge)
          if (lineNode) {
            this.getAllCombinationNodes(startNodeId, lineNode, allCombinationNodes)
          }
          let inNodeId = inEdge.source.cell
          let inNode = this.graph.getCellById(inNodeId)
          if (inNode.isEdge())
            continue
          this.getAllCombinationNodes(startNodeId, inNode, allCombinationNodes)
        }
      },
      getNodeOfConectLine(paramEdge) {
        for (let edge of this.graph.getEdges()) {
          let nodeId = null
          /*          if (edge.source.cell === paramEdge.id){
                      nodeId = edge.target.cell
                    }*/
          if (edge.target.cell === paramEdge.id) {
            nodeId = edge.source.cell
          }
          if (nodeId) {
            let node = this.graph.getCellById(nodeId)
            if (node.isNode())
              return node
          }
        }
        return null
      },
      getInLinesOfNode(node) {
        const edges = this.graph.getConnectedEdges(node); // 获取画布上原有的节点所有进来的线
        console.log(edges, '获取画布上开始节点所有的线 edges')
        return edges.filter(edge => edge.target.cell === node.id)
      },
      getOutLinesOfNode(node) {
        console.log(node, '获取画布上的结束节点 node')
        const edges = this.graph.getConnectedEdges(node); // 获取画布上原有的节点所有进来的线
        console.log(edges, '获取画布上的结束节点所有的线 edges')
        return edges.filter(edge => edge.source.cell === node.id)
      },
    },
  }
</script>