feat: .

src/views/draw-file/board/editCAD/Controls/MoveSymbol.js

@@ -1,181 +0,0 @@
-import { stateService } from '../Service/StateService'
-import { symbolService } from '../Service/SymbolService'
-import { floorplanService } from '../Service/FloorplanService'
-import { wallService } from '../Service/WallService.js'
-import { mathUtil } from '../MathUtil.js'
-import { coordinate } from '../Coordinate'
-import Constant from '../Constant'
-import SelectState from '../enum/SelectState'
-
-export default class MoveSymbol {
-    constructor() {
-        this.symbol = null
-    }
-
-    //拖拽symbol
-    moveFullSymbol(point, symbolId, nearestWallId) {
-        const symbol = floorplanService.getSymbol(symbolId)
-        const wall = floorplanService.getWall(nearestWallId)
-        if (!wall) {
-            return null
-        }
-        const wallLine = wallService.getLine(wall)
-        const vSymbolLine = mathUtil.getVerticalLine(wallLine, point)
-        let distance = symbol.len
-        if (distance == null) {
-            distance = mathUtil.getDistance(symbol.startPoint, symbol.endPoint)
-        }
-        /*
-        const twoParallels = mathUtil.getParallelLineForDistance(vSymbolLine, distance / 2)
-        let point1 = mathUtil.getIntersectionPoint(twoParallels.line1, wallLine)
-        let point2 = mathUtil.getIntersectionPoint(twoParallels.line2, wallLine)
-
-        //墙比较短
-        if (mathUtil.getDistance(point1, point2) < Constant.minSymbolLen) {
-            return null
-        }
-        //调整
-        const startPoint = floorplanService.getPoint(wall.start)
-        const endPoint = floorplanService.getPoint(wall.end)
-        let dx, dy
-
-        let _point1 = {}
-        let _point2 = {}
-        if (!wallService.isContain(wall, point1)) {
-            dx = startPoint.x - point1.x
-            dy = startPoint.y - point1.y
-            _point2.x = point2.x + dx
-            _point2.y = point2.y + dy
-            if (!wallService.isContain(wall, _point2)) {
-                dx = endPoint.x - point1.x
-                dy = endPoint.y - point1.y
-
-                point2.x += dx
-                point2.y += dy
-                mathUtil.clonePoint(point1, endPoint)
-            } else {
-                point2.x += dx
-                point2.y += dy
-                mathUtil.clonePoint(point1, startPoint)
-            }
-        } else if (!wallService.isContain(wall, point2)) {
-            dx = startPoint.x - point2.x
-            dy = startPoint.y - point2.y
-            _point1.x = point1.x + dx
-            _point1.y = point1.y + dy
-            if (!wallService.isContain(wall, _point1)) {
-                dx = endPoint.x - point2.x
-                dy = endPoint.y - point2.y
-
-                point1.x += dx
-                point1.y += dy
-                mathUtil.clonePoint(point2, endPoint)
-            } else {
-                point1.x += dx
-                point1.y += dy
-                mathUtil.clonePoint(point2, startPoint)
-            }
-        }
-        const newPositions = symbolService.getNewForContainSymbols(point1, point2, nearestWallId, symbolId)
-        */
-        let _point = mathUtil.getIntersectionPoint(vSymbolLine, wallLine)
-        const newPositions = symbolService.getNewPosForSymbol(_point, nearestWallId, symbolId)
-        // // 和其他symbol相交
-        // if (newPositions == null) {
-        //     return null
-        // } else if (newPositions.collision) {
-        //     mathUtil.clonePoint(point1, newPositions.position1)
-        //     mathUtil.clonePoint(point2, newPositions.position2)
-        // }
-        if (newPositions != null && newPositions.state) {
-            let dir = mathUtil.dotPoints(symbol.startPoint, symbol.endPoint, newPositions.position1, newPositions.position2)
-            if (dir > 0) {
-                mathUtil.clonePoint(symbol.startPoint, newPositions.position1)
-                mathUtil.clonePoint(symbol.endPoint, newPositions.position2)
-            } else {
-                mathUtil.clonePoint(symbol.endPoint, newPositions.position1)
-                mathUtil.clonePoint(symbol.startPoint, newPositions.position2)
-            }
-
-            //换墙
-            if (symbol.parent != nearestWallId) {
-                symbolService.changeSymbolForBelong(symbolId, nearestWallId)
-            }
-
-            symbol.setOpenSide(point)
-            symbol.setPoints2d()
-        }
-
-        // if (mathUtil.getDistance(point1, symbol.startPoint) < mathUtil.getDistance(point1, symbol.endPoint)) {
-        //     symbol.setSymbolPosition(point1, 'start')
-        //     symbol.setSymbolPosition(point2, 'end')
-        // } else {
-        //     symbol.setSymbolPosition(point2, 'start')
-        //     symbol.setSymbolPosition(point1, 'end')
-        // }
-    }
-
-    // 拖拽symbol的端点
-    moveSymbolPoint(targetPosition, symbolId, selectState) {
-        const newInfo = symbolService.moveSymbolSinglePoint(targetPosition, symbolId, selectState)
-        // symbol的start和end位置交换了
-        if (newInfo == null) {
-            return null
-        }
-        const symbol = floorplanService.getSymbol(symbolId)
-        const midPoint = {
-            x: (symbol.startPoint.x + symbol.endPoint.x) / 2,
-            y: (symbol.startPoint.y + symbol.endPoint.y) / 2,
-        }
-        const distance = mathUtil.getDistance(midPoint, newInfo.position)
-        // 太短了
-        if (distance < Constant.minSymbolLen) {
-            return null
-        }
-
-        const wall = floorplanService.getWall(symbol.parent)
-        const startPoint = floorplanService.getPoint(wall.start)
-        const endPoint = floorplanService.getPoint(wall.end)
-
-        if (selectState == SelectState.Start) {
-            // 与其他symbol重合
-            const newPositions = symbolService.getNewForContainSymbols(symbol.endPoint, newInfo.position, symbol.parent, symbolId)
-            if (newPositions == null || newPositions.collision) {
-                return null
-            }
-
-            // 在wall内
-            if (wallService.isContain(wall, newInfo.position)) {
-                symbolService.setPosition(symbol, newInfo.position, 'start')
-            }
-            // 离wall的start近还是end近
-            else {
-                if (mathUtil.getDistance(symbol.startPoint, startPoint) < mathUtil.getDistance(symbol.startPoint, endPoint)) {
-                    symbolService.setPosition(symbol, startPoint, 'start')
-                } else {
-                    symbolService.setPosition(symbol, endPoint, 'start')
-                }
-            }
-        } else {
-            // 与其他symbol重合
-            const newPositions = symbolService.getNewForContainSymbols(symbol.startPoint, newInfo.position, symbol.parent, symbolId)
-            if (newPositions == null || newPositions.collision) {
-                return null
-            }
-
-            if (wallService.isContain(wall, newInfo.position)) {
-                symbolService.setPosition(symbol, newInfo.position, 'end')
-            } else {
-                if (mathUtil.getDistance(symbol.endPoint, startPoint) < mathUtil.getDistance(symbol.endPoint, endPoint)) {
-                    symbolService.setPosition(symbol, startPoint, 'end')
-                } else {
-                    symbolService.setPosition(symbol, endPoint, 'end')
-                }
-            }
-        }
-        symbol.setPoints2d()
-    }
-}
-
-const moveSymbol = new MoveSymbol()
-export { moveSymbol }

src/views/draw-file/board/editCAD/Geometry/BayWindow.js

@@ -1,162 +0,0 @@
-import VectorType from '../enum/VectorType.js'
-import Geometry from './Geometry'
-import { coordinate } from '../Coordinate'
-import { mathUtil } from '../MathUtil.js'
-import SelectState from '../enum/SelectState.js'
-import Constant from '../Constant.js'
-
-export default class BayWindow extends Geometry {
-    constructor(startPoint, endPoint, vectorId, floor) {
-        super()
-        this.startPoint = startPoint
-        this.endPoint = endPoint
-        this.floor = floor
-        this.openSide = 'LEFT' // LEFT或者RIGHT
-        this.parent = null
-
-        // 渲染用的
-        this.points2d = []
-        this.name = '飘窗'
-        this.geoType = VectorType.BayWindow
-        this.setId(vectorId)
-    }
-
-    setPoints2d() {
-        const line = mathUtil.createLine1(this.startPoint, this.endPoint)
-        const len1 = mathUtil.getDistance(this.startPoint, this.endPoint) / 2
-        const len2 = 4 / coordinate.res + len1
-
-        const midPoint = {
-            x: (this.startPoint.x + this.endPoint.x) / 2,
-            y: (this.startPoint.y + this.endPoint.y) / 2,
-        }
-
-        const vertline = mathUtil.getVerticalLine(line, midPoint)
-        let vStartLine1, vStartLine2, vEndLine1, vEndLine2
-
-        //垂直
-        const lines1 = mathUtil.getParallelLineForDistance(vertline, len1)
-        const lines2 = mathUtil.getParallelLineForDistance(vertline, len2)
-        let dis1 = mathUtil.getDisForPoinLine(this.startPoint, lines1.line1)
-        let dis2 = mathUtil.getDisForPoinLine(this.startPoint, lines1.line2)
-        if (dis1 > dis2) {
-            vStartLine1 = lines1.line2
-            vStartLine2 = lines2.line2
-
-            vEndLine1 = lines1.line1
-            vEndLine2 = lines2.line1
-        } else {
-            vStartLine1 = lines1.line1
-            vStartLine2 = lines2.line1
-
-            vEndLine1 = lines1.line2
-            vEndLine2 = lines2.line2
-        }
-
-        //平行
-        const lines3 = mathUtil.getParallelLineForDistance(line, 2 / coordinate.res)
-        const lines4 = mathUtil.getParallelLineForDistance(line, 24 / coordinate.res)
-        const lines5 = mathUtil.getParallelLineForDistance(line, 28 / coordinate.res)
-
-        let pLine1 = lines3.line1
-        let pLine2 = lines3.line2
-        let pLine3 = lines4.line2
-        let pLine4 = lines5.line2
-
-        let pLine5 = lines3.line2
-        let pLine6 = lines3.line1
-        let pLine7 = lines4.line1
-        let pLine8 = lines5.line1
-
-        let point1 = mathUtil.getIntersectionPoint(vStartLine1, pLine1)
-        let point2 = mathUtil.getIntersectionPoint(vEndLine1, pLine1)
-        let point3 = mathUtil.getIntersectionPoint(vEndLine1, pLine3)
-        let point4 = mathUtil.getIntersectionPoint(vStartLine1, pLine3)
-
-        let point5 = mathUtil.getIntersectionPoint(vStartLine2, pLine2)
-        let point6 = mathUtil.getIntersectionPoint(vEndLine2, pLine2)
-        let point7 = mathUtil.getIntersectionPoint(vEndLine2, pLine4)
-        let point8 = mathUtil.getIntersectionPoint(vStartLine2, pLine4)
-
-        let point9 = mathUtil.getIntersectionPoint(vStartLine1, pLine5)
-        let point10 = mathUtil.getIntersectionPoint(vEndLine1, pLine5)
-        let point11 = mathUtil.getIntersectionPoint(vEndLine1, pLine7)
-        let point12 = mathUtil.getIntersectionPoint(vStartLine1, pLine7)
-
-        let point13 = mathUtil.getIntersectionPoint(vStartLine2, pLine6)
-        let point14 = mathUtil.getIntersectionPoint(vEndLine2, pLine6)
-        let point15 = mathUtil.getIntersectionPoint(vEndLine2, pLine8)
-        let point16 = mathUtil.getIntersectionPoint(vStartLine2, pLine8)
-
-        this.points2d = []
-
-        this.points2d.push(point1)
-        this.points2d.push(point2)
-        this.points2d.push(point3)
-        this.points2d.push(point4)
-
-        if (this.openSide == 'LEFT') {
-            //逆时针
-            if (mathUtil.isClockwise(this.points2d)) {
-                this.points2d.push(point5)
-                this.points2d.push(point6)
-                this.points2d.push(point7)
-                this.points2d.push(point8)
-            } else {
-                this.points2d = []
-                this.points2d.push(point9)
-                this.points2d.push(point10)
-                this.points2d.push(point11)
-                this.points2d.push(point12)
-                this.points2d.push(point13)
-                this.points2d.push(point14)
-                this.points2d.push(point15)
-                this.points2d.push(point16)
-            }
-        } else if (this.openSide == 'RIGHT') {
-            //逆时针
-            if (mathUtil.isClockwise(this.points2d)) {
-                this.points2d = []
-                this.points2d.push(point9)
-                this.points2d.push(point10)
-                this.points2d.push(point11)
-                this.points2d.push(point12)
-                this.points2d.push(point13)
-                this.points2d.push(point14)
-                this.points2d.push(point15)
-                this.points2d.push(point16)
-            } else {
-                this.points2d.push(point5)
-                this.points2d.push(point6)
-                this.points2d.push(point7)
-                this.points2d.push(point8)
-            }
-        }
-    }
-
-    isContain(position) {
-        const dis1 = mathUtil.getDistance(position, this.startPoint)
-        const dis2 = mathUtil.getDistance(position, this.endPoint)
-        if (dis1 < Constant.minAdsorb) {
-            return SelectState.Start
-        } else if (dis2 < Constant.minAdsorb) {
-            return SelectState.End
-        }
-        let flag = mathUtil.isContainForSegment(position, this.startPoint, this.endPoint)
-        if (flag) {
-            return SelectState.Select
-        } else {
-            let points = []
-            points[0] = this.points2d[4]
-            points[1] = this.points2d[5]
-            points[2] = this.points2d[6]
-            points[3] = this.points2d[7]
-            flag = mathUtil.isPointInPoly(position, points)
-            if (flag) {
-                return SelectState.Select
-            } else {
-                return null
-            }
-        }
-    }
-}

src/views/draw-file/board/editCAD/Geometry/Corridor.js

@@ -1,470 +0,0 @@
-import Geometry from './Geometry'
-import VectorType from '../enum/VectorType.js'
-import { mathUtil } from '../MathUtil.js'
-import { coordinate } from '../Coordinate'
-import Constant from '../Constant.js'
-
-//不靠墙
-export default class Corridor extends Geometry {
-    constructor(center, vectorId) {
-        super()
-        this.center = center
-        this.angle = 0 //逆时针为正，顺时针为负。单位是：°
-        this.points2d = []
-
-        this.sideWidth = 0.65
-        this.sideThickness = 0.65
-
-        this.name = '楼道'
-        this.geoType = VectorType.Corridor
-        this.setId(vectorId)
-    }
-
-    isContain(position) {
-        let points = []
-        points.push(this.points2d[0])
-        points.push(this.points2d[1])
-        points.push(this.points2d[2])
-        points.push(this.points2d[3])
-        return mathUtil.isPointInPoly(position, points)
-    }
-
-    setPoints2d() {
-        this.points2d = []
-        let minX = this.center.x - this.sideWidth / 2
-        let minY = this.center.y - this.sideThickness / 2
-        let maxX = this.center.x + this.sideWidth / 2
-        let maxY = this.center.y + this.sideThickness / 2
-
-        const point1 = this.rotatePoint(
-            {
-                x: minX,
-                y: maxY,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point2 = this.rotatePoint(
-            {
-                x: maxX,
-                y: maxY,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point3 = this.rotatePoint(
-            {
-                x: maxX,
-                y: minY,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point4 = this.rotatePoint(
-            {
-                x: minX,
-                y: minY,
-            },
-            this.center,
-            this.angle
-        )
-
-        this.points2d.push(point1)
-        this.points2d.push(point2)
-        this.points2d.push(point3)
-        this.points2d.push(point4)
-
-        const leftX = this.center.x - 2 / coordinate.res
-        const rightX = this.center.x + 2 / coordinate.res
-        //const dy = (maxY - minY) / 9
-        const dy = 3 / coordinate.res
-        const point5 = this.rotatePoint(
-            {
-                x: leftX,
-                y: maxY,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point6 = this.rotatePoint(
-            {
-                x: leftX,
-                y: minY,
-            },
-            this.center,
-            this.angle
-        )
-
-        this.points2d.push(point5)
-        this.points2d.push(point6)
-
-        const point7 = this.rotatePoint(
-            {
-                x: rightX,
-                y: maxY,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point8 = this.rotatePoint(
-            {
-                x: rightX,
-                y: minY,
-            },
-            this.center,
-            this.angle
-        )
-
-        this.points2d.push(point7)
-        this.points2d.push(point8)
-
-        const num = Math.floor((this.sideThickness * coordinate.res) / 3)
-        for (let i = 0; i < num - 2; ++i) {
-            const point9 = this.rotatePoint(
-                {
-                    x: minX,
-                    y: maxY - (i + 2) * dy,
-                },
-                this.center,
-                this.angle
-            )
-
-            const point10 = this.rotatePoint(
-                {
-                    x: leftX,
-                    y: maxY - (i + 2) * dy,
-                },
-                this.center,
-                this.angle
-            )
-
-            this.points2d.push(point9)
-            this.points2d.push(point10)
-
-            // if(i!= num-2)
-            // {
-            const point11 = this.rotatePoint(
-                {
-                    x: rightX,
-                    y: maxY - (i + 1) * dy,
-                },
-                this.center,
-                this.angle
-            )
-
-            const point12 = this.rotatePoint(
-                {
-                    x: maxX,
-                    y: maxY - (i + 1) * dy,
-                },
-                this.center,
-                this.angle
-            )
-
-            this.points2d.push(point11)
-            this.points2d.push(point12)
-            // }
-        }
-
-        /*
-        const point9 = this.rotatePoint(
-            {
-                x: minX,
-                y: maxY - 2 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point10 = this.rotatePoint(
-            {
-                x: leftX,
-                y: maxY - 2 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        this.points2d.push(point9)
-        this.points2d.push(point10)
-
-        const point11 = this.rotatePoint(
-            {
-                x: minX,
-                y: maxY - 3 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point12 = this.rotatePoint(
-            {
-                x: leftX,
-                y: maxY - 3 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        this.points2d.push(point11)
-        this.points2d.push(point12)
-
-        const point13 = this.rotatePoint(
-            {
-                x: minX,
-                y: maxY - 4 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point14 = this.rotatePoint(
-            {
-                x: leftX,
-                y: maxY - 4 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        this.points2d.push(point13)
-        this.points2d.push(point14)
-
-        const point15 = this.rotatePoint(
-            {
-                x: minX,
-                y: maxY - 5 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point16 = this.rotatePoint(
-            {
-                x: leftX,
-                y: maxY - 5 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        this.points2d.push(point15)
-        this.points2d.push(point16)
-
-        const point17 = this.rotatePoint(
-            {
-                x: minX,
-                y: maxY - 6 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point18 = this.rotatePoint(
-            {
-                x: leftX,
-                y: maxY - 6 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        this.points2d.push(point17)
-        this.points2d.push(point18)
-
-        const point19 = this.rotatePoint(
-            {
-                x: minX,
-                y: maxY - 7 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point20 = this.rotatePoint(
-            {
-                x: leftX,
-                y: maxY - 7 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        this.points2d.push(point19)
-        this.points2d.push(point20)
-
-        const point21 = this.rotatePoint(
-            {
-                x: minX,
-                y: maxY - 8 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point22 = this.rotatePoint(
-            {
-                x: leftX,
-                y: maxY - 8 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        this.points2d.push(point21)
-        this.points2d.push(point22)
-
-        const point23 = this.rotatePoint(
-            {
-                x: rightX,
-                y: maxY - dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point24 = this.rotatePoint(
-            {
-                x: maxX,
-                y: maxY - dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        this.points2d.push(point23)
-        this.points2d.push(point24)
-
-        const point25 = this.rotatePoint(
-            {
-                x: rightX,
-                y: maxY - 2 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point26 = this.rotatePoint(
-            {
-                x: maxX,
-                y: maxY - 2 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        this.points2d.push(point25)
-        this.points2d.push(point26)
-
-        const point27 = this.rotatePoint(
-            {
-                x: rightX,
-                y: maxY - 3 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point28 = this.rotatePoint(
-            {
-                x: maxX,
-                y: maxY - 3 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        this.points2d.push(point27)
-        this.points2d.push(point28)
-
-        const point29 = this.rotatePoint(
-            {
-                x: rightX,
-                y: maxY - 4 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point30 = this.rotatePoint(
-            {
-                x: maxX,
-                y: maxY - 4 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        this.points2d.push(point29)
-        this.points2d.push(point30)
-
-        const point31 = this.rotatePoint(
-            {
-                x: rightX,
-                y: maxY - 5 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point32 = this.rotatePoint(
-            {
-                x: maxX,
-                y: maxY - 5 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        this.points2d.push(point31)
-        this.points2d.push(point32)
-
-        const point33 = this.rotatePoint(
-            {
-                x: rightX,
-                y: maxY - 6 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point34 = this.rotatePoint(
-            {
-                x: maxX,
-                y: maxY - 6 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        this.points2d.push(point33)
-        this.points2d.push(point34)
-
-        const point35 = this.rotatePoint(
-            {
-                x: rightX,
-                y: maxY - 7 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point36 = this.rotatePoint(
-            {
-                x: maxX,
-                y: maxY - 7 * dy,
-            },
-            this.center,
-            this.angle
-        )
-
-        this.points2d.push(point35)
-        this.points2d.push(point36)
-        */
-    }
-}

src/views/draw-file/board/editCAD/Geometry/DoubleDoor.js

@@ -1,137 +0,0 @@
-import VectorType from '../enum/VectorType.js'
-import Geometry from './Geometry'
-import SelectState from '../enum/SelectState.js'
-import { mathUtil } from '../MathUtil.js'
-import Constant from '../Constant.js'
-import SymbolEvents from '../enum/SymbolEvents.js'
-
-export default class DoubleDoor extends Geometry {
-    constructor(startPoint, endPoint, vectorId, floor) {
-        super()
-        this.startPoint = startPoint
-        this.endPoint = endPoint
-        this.floor = floor
-        this.openSide = null // LEFT或者RIGHT
-        this.parent = null
-        this.enter = null // LEFT或者RIGHT
-        // 渲染用的，四元素，0是start,1是end
-        this.points2d = []
-        this.name = '双开门'
-        this.geoType = VectorType.DoubleDoor
-        this.setId(vectorId)
-    }
-
-    setPoints2d() {
-        const line = mathUtil.createLine1(this.startPoint, this.endPoint)
-        const len = mathUtil.getDistance(this.startPoint, this.endPoint)
-        const lines = mathUtil.getParallelLineForDistance(line, len / 2)
-        const vertline1 = mathUtil.getVerticalLine(line, this.startPoint)
-        const vertline2 = mathUtil.getVerticalLine(line, this.endPoint)
-
-        const midPoint = {
-            x: (this.startPoint.x + this.endPoint.x) / 2,
-            y: (this.startPoint.y + this.endPoint.y) / 2,
-        }
-        const vertline = mathUtil.getVerticalLine(line, midPoint)
-
-        let startJoin1 = mathUtil.getIntersectionPoint(lines.line1, vertline1)
-        let startJoin2 = mathUtil.getIntersectionPoint(lines.line2, vertline1)
-
-        let endJoin1 = mathUtil.getIntersectionPoint(lines.line1, vertline2)
-        let endJoin2 = mathUtil.getIntersectionPoint(lines.line2, vertline2)
-
-        let midJoin1 = mathUtil.getIntersectionPoint(lines.line1, vertline)
-        let midJoin2 = mathUtil.getIntersectionPoint(lines.line2, vertline)
-
-        this.points2d = []
-        this.points2d.push(this.startPoint)
-        this.points2d.push(midPoint)
-        this.points2d.push(this.endPoint)
-        this.points2d.push(endJoin1)
-        this.points2d.push(midJoin1)
-        this.points2d.push(startJoin1)
-
-        //逆时针
-        if (this.openSide == SymbolEvents.Left) {
-            if (mathUtil.isClockwise(this.points2d)) {
-                return
-            } else {
-                this.points2d = []
-                this.points2d.push(this.startPoint)
-                this.points2d.push(midPoint)
-                this.points2d.push(this.endPoint)
-                this.points2d.push(endJoin2)
-                this.points2d.push(midJoin2)
-                this.points2d.push(startJoin2)
-            }
-        } else if (this.openSide == SymbolEvents.Right) {
-            if (mathUtil.isClockwise(this.points2d)) {
-                this.points2d = []
-                this.points2d.push(this.startPoint)
-                this.points2d.push(midPoint)
-                this.points2d.push(this.endPoint)
-                this.points2d.push(endJoin2)
-                this.points2d.push(midJoin2)
-                this.points2d.push(startJoin2)
-            } else {
-                return
-            }
-        }
-    }
-
-    isContain(position) {
-        const dis1 = mathUtil.getDistance(position, this.startPoint)
-        const dis2 = mathUtil.getDistance(position, this.endPoint)
-        if (dis1 < Constant.minAdsorb) {
-            return SelectState.Start
-        } else if (dis2 < Constant.minAdsorb) {
-            return SelectState.End
-        }
-
-        let flag = mathUtil.isContainForSegment(position, this.startPoint, this.endPoint)
-        if (flag) {
-            return SelectState.Select
-        }
-
-        let points = []
-        points.push(this.startPoint)
-        points.push(this.endPoint)
-        points.push(position)
-        if (this.openSide == SymbolEvents.Left) {
-            if (!mathUtil.isClockwise(points)) {
-                return null
-            }
-        } else if (this.openSide == SymbolEvents.Right) {
-            if (mathUtil.isClockwise(points)) {
-                return null
-            }
-        }
-
-        const midPoint = {
-            x: (this.points2d[0].x + this.points2d[1].x) / 2,
-            y: (this.points2d[0].y + this.points2d[1].y) / 2,
-        }
-
-        // 两个扇形
-        const radius = mathUtil.getDistance(this.points2d[1], this.points2d[2])
-
-        let len = mathUtil.getDistance(position, this.points2d[0])
-        if (len < radius) {
-            const angle1 = mathUtil.Angle(this.points2d[0], position, this.points2d[5])
-            const angle2 = mathUtil.Angle(this.points2d[0], position, midPoint)
-            if (angle1 < Math.PI / 2 && angle2 < Math.PI / 2) {
-                return SelectState.Select
-            }
-        }
-        len = mathUtil.getDistance(position, this.points2d[2])
-        if (len < radius) {
-            const angle1 = mathUtil.Angle(this.points2d[2], position, this.points2d[3])
-            const angle2 = mathUtil.Angle(this.points2d[2], position, midPoint)
-            if (angle1 < Math.PI / 2 && angle2 < Math.PI / 2) {
-                return SelectState.Select
-            }
-        }
-
-        return null
-    }
-}

src/views/draw-file/board/editCAD/Geometry/Flue.js

@@ -1,133 +0,0 @@
-import VectorType from '../enum/VectorType.js'
-import SelectState from '../enum/SelectState.js'
-import Geometry from './Geometry'
-import { mathUtil } from '../MathUtil.js'
-import Constant from '../Constant.js'
-import { coordinate } from '../Coordinate'
-
-//不靠墙
-export default class Flue extends Geometry {
-    constructor(center, vectorId) {
-        super()
-        this.center = center
-        this.angle = 0 //逆时针为正，顺时针为负。单位是：°
-        this.points2d = []
-
-        this.sideWidth = 0.65
-        this.sideThickness = 0.65
-
-        this.name = '烟道'
-        this.geoType = VectorType.Flue
-        this.setId(vectorId)
-    }
-
-    isContain(position) {
-        let points = []
-        points.push(this.points2d[0])
-        points.push(this.points2d[1])
-        points.push(this.points2d[2])
-        points.push(this.points2d[3])
-        return mathUtil.isPointInPoly(position, points)
-    }
-
-    setPoints2d() {
-        this.points2d = []
-        let minX = this.center.x - this.sideWidth / 2
-        let minY = this.center.y - this.sideThickness / 2
-        let maxX = this.center.x + this.sideWidth / 2
-        let maxY = this.center.y + this.sideThickness / 2
-
-        const point1 = this.rotatePoint(
-            {
-                x: minX,
-                y: maxY,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point2 = this.rotatePoint(
-            {
-                x: maxX,
-                y: maxY,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point3 = this.rotatePoint(
-            {
-                x: maxX,
-                y: minY,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point4 = this.rotatePoint(
-            {
-                x: minX,
-                y: minY,
-            },
-            this.center,
-            this.angle
-        )
-
-        this.points2d.push(point1)
-        this.points2d.push(point2)
-        this.points2d.push(point3)
-        this.points2d.push(point4)
-
-        minX = this.center.x - (this.sideWidth - 0.1) / 2
-        minY = this.center.y - (this.sideThickness - 0.1) / 2
-        maxX = this.center.x + (this.sideWidth - 0.1) / 2
-        maxY = this.center.y + (this.sideThickness - 0.1) / 2
-
-        const point5 = this.rotatePoint(
-            {
-                x: minX,
-                y: maxY,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point6 = this.rotatePoint(
-            {
-                x: maxX,
-                y: maxY,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point7 = this.rotatePoint(
-            {
-                x: maxX,
-                y: minY,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point8 = this.rotatePoint(
-            {
-                x: minX,
-                y: minY,
-            },
-            this.center,
-            this.angle
-        )
-
-        const point9 = {
-            x: (this.center.x + point6.x) / 2,
-            y: (this.center.y + point6.y) / 2,
-        }
-
-        this.points2d.push(point5)
-        this.points2d.push(point6)
-        this.points2d.push(point7)
-        this.points2d.push(point8)
-        this.points2d.push(point9)
-    }
-}

src/views/draw-file/board/editCAD/Geometry/FrenchWindow.js

@@ -1,72 +0,0 @@
-import VectorType from '../enum/VectorType.js'
-import Geometry from './Geometry'
-import { coordinate } from '../Coordinate'
-import { mathUtil } from '../MathUtil.js'
-import SelectState from '../enum/SelectState.js'
-import Constant from '../Constant.js'
-
-export default class FrenchWindow extends Geometry {
-    constructor(startPoint, endPoint, vectorId, floor) {
-        super()
-        this.startPoint = startPoint
-        this.endPoint = endPoint
-        this.floor = floor
-        //this.openSide = null;        // LEFT或者RIGHT
-        this.parent = null
-
-        // 渲染用的
-        this.points2d = []
-        this.name = '落地窗'
-        this.geoType = VectorType.FrenchWindow
-        this.setId(vectorId)
-    }
-
-    setPoints2d() {
-        const len = 4 / coordinate.res
-        const line = mathUtil.createLine1(this.startPoint, this.endPoint)
-        const lines = mathUtil.getParallelLineForDistance(line, len)
-        const vertline1 = mathUtil.getVerticalLine(line, this.startPoint)
-        const vertline2 = mathUtil.getVerticalLine(line, this.endPoint)
-
-        this.points2d = []
-        this.points2d.push(this.startPoint)
-        this.points2d.push(this.endPoint)
-
-        const midPoint = {
-            x: (this.startPoint.x + this.endPoint.x) / 2,
-            y: (this.startPoint.y + this.endPoint.y) / 2,
-        }
-        const vertline = mathUtil.getVerticalLine(line, midPoint)
-
-        const startJoin1 = mathUtil.getIntersectionPoint(vertline1, lines.line1)
-        const endJoin1 = mathUtil.getIntersectionPoint(vertline2, lines.line1)
-        this.points2d.push(startJoin1)
-        this.points2d.push(endJoin1)
-
-        const startJoin2 = mathUtil.getIntersectionPoint(vertline1, lines.line2)
-        const endJoin2 = mathUtil.getIntersectionPoint(vertline2, lines.line2)
-        this.points2d.push(startJoin2)
-        this.points2d.push(endJoin2)
-
-        const midJoin1 = mathUtil.getIntersectionPoint(vertline, lines.line1)
-        const midJoin2 = mathUtil.getIntersectionPoint(vertline, lines.line2)
-        this.points2d.push(midJoin1)
-        this.points2d.push(midJoin2)
-    }
-
-    isContain(position) {
-        const dis1 = mathUtil.getDistance(position, this.startPoint)
-        const dis2 = mathUtil.getDistance(position, this.endPoint)
-        if (dis1 < Constant.minAdsorb) {
-            return SelectState.Start
-        } else if (dis2 < Constant.minAdsorb) {
-            return SelectState.End
-        }
-        let flag = mathUtil.isContainForSegment(position, this.startPoint, this.endPoint)
-        if (flag) {
-            return SelectState.Select
-        } else {
-            return null
-        }
-    }
-}

src/views/draw-file/board/editCAD/Geometry/Pass.js

@@ -1,71 +0,0 @@
-import VectorType from '../enum/VectorType.js'
-import Geometry from './Geometry'
-import { coordinate } from '../Coordinate'
-import { mathUtil } from '../MathUtil.js'
-import SelectState from '../enum/SelectState.js'
-import Constant from '../Constant.js'
-
-export default class Pass extends Geometry {
-    constructor(startPoint, endPoint, vectorId, floor) {
-        super()
-        this.startPoint = startPoint
-        this.endPoint = endPoint
-        this.floor = floor
-        //this.openSide = null;        // LEFT或者RIGHT
-        this.parent = null
-        // 渲染用的
-        this.points2d = []
-        this.name = '垭口'
-        this.geoType = VectorType.Pass
-        this.setId(vectorId)
-    }
-
-    setPoints2d() {
-        this.points2d = []
-
-        let len = 5 / coordinate.res
-        let line = mathUtil.createLine1(this.startPoint, this.endPoint)
-        let lines = mathUtil.getParallelLineForDistance(line, len)
-        let vertline1 = mathUtil.getVerticalLine(line, this.startPoint)
-        let vertline2 = mathUtil.getVerticalLine(line, this.endPoint)
-
-        const point1 = mathUtil.getIntersectionPoint(vertline1, lines.line1)
-        const point2 = mathUtil.getIntersectionPoint(vertline2, lines.line1)
-        const point3 = mathUtil.getIntersectionPoint(vertline2, lines.line2)
-        const point4 = mathUtil.getIntersectionPoint(vertline1, lines.line2)
-
-        this.points2d.push(point1)
-        this.points2d.push(point2)
-        this.points2d.push(point3)
-        this.points2d.push(point4)
-
-        len = 2 / coordinate.res
-        lines = mathUtil.getParallelLineForDistance(line, len)
-
-        const point5 = mathUtil.getIntersectionPoint(vertline1, lines.line1)
-        const point6 = mathUtil.getIntersectionPoint(vertline2, lines.line1)
-        const point7 = mathUtil.getIntersectionPoint(vertline2, lines.line2)
-        const point8 = mathUtil.getIntersectionPoint(vertline1, lines.line2)
-
-        this.points2d.push(point5)
-        this.points2d.push(point6)
-        this.points2d.push(point7)
-        this.points2d.push(point8)
-    }
-
-    isContain(position) {
-        const dis1 = mathUtil.getDistance(position, this.startPoint)
-        const dis2 = mathUtil.getDistance(position, this.endPoint)
-        if (dis1 < Constant.minAdsorb) {
-            return SelectState.Start
-        } else if (dis2 < Constant.minAdsorb) {
-            return SelectState.End
-        }
-        let flag = mathUtil.isContainForSegment(position, this.startPoint, this.endPoint)
-        if (flag) {
-            return SelectState.Select
-        } else {
-            return null
-        }
-    }
-}

src/views/draw-file/board/editCAD/Geometry/SingleDoor.js

@@ -1,94 +0,0 @@
-import VectorType from '../enum/VectorType.js'
-import SelectState from '../enum/SelectState.js'
-import Geometry from './Geometry'
-import { mathUtil } from '../MathUtil.js'
-import Constant from '../Constant.js'
-import SymbolEvents from '../enum/SymbolEvents.js'
-
-export default class SingleDoor extends Geometry {
-    constructor(startPoint, endPoint, vectorId, floor) {
-        super()
-        this.startPoint = startPoint
-        this.endPoint = endPoint
-        this.floor = floor
-        this.openSide = null // LEFT或者RIGHT
-        this.parent = null
-        this.enter = null // LEFT或者RIGHT
-        // 渲染用的，四元素，0是start,1是end
-        this.points2d = []
-        this.name = '单开门'
-        this.geoType = VectorType.SingleDoor
-        this.setId(vectorId)
-    }
-
-    setPoints2d() {
-        const line = mathUtil.createLine1(this.startPoint, this.endPoint)
-        const len = mathUtil.getDistance(this.startPoint, this.endPoint)
-        const lines = mathUtil.getParallelLineForDistance(line, len)
-        const vertline1 = mathUtil.getVerticalLine(line, this.startPoint)
-        const vertline2 = mathUtil.getVerticalLine(line, this.endPoint)
-        let startJoin1 = mathUtil.getIntersectionPoint(lines.line1, vertline1)
-        let startJoin2 = mathUtil.getIntersectionPoint(lines.line2, vertline1)
-
-        let endJoin1 = mathUtil.getIntersectionPoint(lines.line1, vertline2)
-        let endJoin2 = mathUtil.getIntersectionPoint(lines.line2, vertline2)
-
-        this.points2d = []
-        this.points2d.push(this.startPoint)
-        this.points2d.push(this.endPoint)
-        this.points2d.push(endJoin1)
-        this.points2d.push(startJoin1)
-
-        //逆时针
-        if (this.openSide == SymbolEvents.Left) {
-            if (mathUtil.isClockwise(this.points2d)) {
-                return
-            } else {
-                this.points2d = []
-                this.points2d.push(this.startPoint)
-                this.points2d.push(this.endPoint)
-                this.points2d.push(endJoin2)
-                this.points2d.push(startJoin2)
-            }
-        } else if (this.openSide == SymbolEvents.Right) {
-            if (mathUtil.isClockwise(this.points2d)) {
-                this.points2d = []
-                this.points2d.push(this.startPoint)
-                this.points2d.push(this.endPoint)
-                this.points2d.push(endJoin2)
-                this.points2d.push(startJoin2)
-            } else {
-                return
-            }
-        }
-    }
-
-    isContain(position) {
-        const dis1 = mathUtil.getDistance(position, this.startPoint)
-        const dis2 = mathUtil.getDistance(position, this.endPoint)
-        if (dis1 < Constant.minAdsorb) {
-            return SelectState.Start
-        } else if (dis2 < Constant.minAdsorb) {
-            return SelectState.End
-        }
-
-        let flag = mathUtil.isContainForSegment(position, this.startPoint, this.endPoint)
-        if (flag) {
-            return SelectState.Select
-        }
-
-        // 是否在扇形(this.points里第0个元素是圆心，1-3是扇形的两个顶点)
-        const radius = mathUtil.getDistance(this.points2d[0], this.points2d[1])
-        const len = mathUtil.getDistance(position, this.points2d[0])
-        if (len > radius) {
-            return null
-        } else {
-            const angle1 = mathUtil.Angle(this.points2d[0], position, this.points2d[1])
-            const angle2 = mathUtil.Angle(this.points2d[0], position, this.points2d[3])
-            if (angle1 < Math.PI / 2 && angle2 < Math.PI / 2) {
-                return SelectState.Select
-            }
-        }
-        return null
-    }
-}

src/views/draw-file/board/editCAD/Geometry/SingleWindow.js

@@ -1,61 +0,0 @@
-import VectorType from '../enum/VectorType.js'
-import Geometry from './Geometry'
-import SelectState from '../enum/SelectState.js'
-import { mathUtil } from '../MathUtil.js'
-import Constant from '../Constant.js'
-import { coordinate } from '../Coordinate'
-
-export default class SingleWindow extends Geometry {
-    constructor(startPoint, endPoint, vectorId, floor) {
-        super()
-        this.startPoint = startPoint
-        this.endPoint = endPoint
-        this.floor = floor
-        //this.openSide = null;        // LEFT或者RIGHT
-        this.parent = null
-
-        // 渲染用的
-        this.points2d = []
-        this.name = '单开窗'
-        this.geoType = VectorType.SingleWindow
-        this.setId(vectorId)
-    }
-
-    setPoints2d() {
-        this.points2d = []
-        this.points2d.push(this.startPoint)
-        this.points2d.push(this.endPoint)
-
-        const len = 4 / coordinate.res
-        const line = mathUtil.createLine1(this.startPoint, this.endPoint)
-        const lines = mathUtil.getParallelLineForDistance(line, len)
-        const vertline1 = mathUtil.getVerticalLine(line, this.startPoint)
-        const vertline2 = mathUtil.getVerticalLine(line, this.endPoint)
-
-        const point1 = mathUtil.getIntersectionPoint(vertline1, lines.line1)
-        const point2 = mathUtil.getIntersectionPoint(vertline2, lines.line1)
-        const point3 = mathUtil.getIntersectionPoint(vertline2, lines.line2)
-        const point4 = mathUtil.getIntersectionPoint(vertline1, lines.line2)
-
-        this.points2d.push(point1)
-        this.points2d.push(point2)
-        this.points2d.push(point3)
-        this.points2d.push(point4)
-    }
-
-    isContain(position) {
-        const dis1 = mathUtil.getDistance(position, this.startPoint)
-        const dis2 = mathUtil.getDistance(position, this.endPoint)
-        if (dis1 < Constant.minAdsorb) {
-            return SelectState.Start
-        } else if (dis2 < Constant.minAdsorb) {
-            return SelectState.End
-        }
-        let flag = mathUtil.isContainForSegment(position, this.startPoint, this.endPoint)
-        if (flag) {
-            return SelectState.Select
-        } else {
-            return null
-        }
-    }
-}

src/views/draw-file/board/editCAD/Geometry/SlideDoor.js

@@ -1,94 +0,0 @@
-import VectorType from '../enum/VectorType.js'
-import Geometry from './Geometry'
-import { coordinate } from '../Coordinate'
-import { mathUtil } from '../MathUtil.js'
-import SelectState from '../enum/SelectState.js'
-import Constant from '../Constant.js'
-
-export default class SlideDoor extends Geometry {
-    constructor(startPoint, endPoint, vectorId, floor) {
-        super()
-        this.startPoint = startPoint
-        this.endPoint = endPoint
-        this.floor = floor
-        //this.openSide = null;        // LEFT或者RIGHT
-        this.parent = null
-        this.enter = null // LEFT或者RIGHT
-        // 渲染用的
-        this.points2d = []
-        this.name = '滑动门'
-        this.geoType = VectorType.SlideDoor
-        this.setId(vectorId)
-    }
-
-    setPoints2d() {
-        const line = mathUtil.createLine1(this.startPoint, this.endPoint)
-        const len = 2 / coordinate.res
-        const lines1 = mathUtil.getParallelLineForDistance(line, len)
-        if (this.startPoint.x > this.endPoint.x) {
-            let temp = lines1.line1
-            lines1.line1 = lines1.line2
-            lines1.line2 = temp
-        }
-        const vertline1 = mathUtil.getVerticalLine(line, this.startPoint)
-        const vertline2 = mathUtil.getVerticalLine(line, this.endPoint)
-        const startJoin = mathUtil.getIntersectionPoint(lines1.line1, vertline1)
-        const endJoin = mathUtil.getIntersectionPoint(lines1.line2, vertline2)
-
-        const midPoint = {
-            x: (this.startPoint.x + this.endPoint.x) / 2,
-            y: (this.startPoint.y + this.endPoint.y) / 2,
-        }
-        this.points2d = []
-        this.points2d.push(this.startPoint)
-
-        const width = 4 / coordinate.res
-        const vertline = mathUtil.getVerticalLine(line, midPoint)
-        const lines2 = mathUtil.getParallelLineForDistance(vertline, width)
-
-        let join1 = mathUtil.getIntersectionPoint(lines1.line1, lines2.line1)
-        let join2 = mathUtil.getIntersectionPoint(lines1.line1, lines2.line2)
-
-        let join3 = mathUtil.getIntersectionPoint(lines1.line2, lines2.line1)
-        let join4 = mathUtil.getIntersectionPoint(lines1.line2, lines2.line2)
-
-        let join5 = mathUtil.getIntersectionPoint(line, lines2.line1)
-        let join6 = mathUtil.getIntersectionPoint(line, lines2.line2)
-
-        if (mathUtil.getDistance(this.startPoint, join5) < mathUtil.getDistance(this.startPoint, join6)) {
-            this.points2d.push(join6)
-            this.points2d.push(join2)
-            this.points2d.push(startJoin)
-
-            this.points2d.push(this.endPoint)
-            this.points2d.push(join5)
-            this.points2d.push(join3)
-            this.points2d.push(endJoin)
-        } else {
-            this.points2d.push(join5)
-            this.points2d.push(join1)
-            this.points2d.push(startJoin)
-
-            this.points2d.push(this.endPoint)
-            this.points2d.push(join6)
-            this.points2d.push(join4)
-            this.points2d.push(endJoin)
-        }
-    }
-
-    isContain(position) {
-        const dis1 = mathUtil.getDistance(position, this.startPoint)
-        const dis2 = mathUtil.getDistance(position, this.endPoint)
-        if (dis1 < Constant.minAdsorb) {
-            return SelectState.Start
-        } else if (dis2 < Constant.minAdsorb) {
-            return SelectState.End
-        }
-        let flag = mathUtil.isContainForSegment(position, this.startPoint, this.endPoint)
-        if (flag) {
-            return SelectState.Select
-        } else {
-            return null
-        }
-    }
-}

src/views/draw-file/board/editCAD/ListenLayer.js

@@ -18,11 +18,6 @@ export default class ListenLayer {
             state: null,
         }
 
-        this.symbolInfo = {
-            symbolId: null,
-            state: null, // start,end,all表示哪个部位。与前面的wallInfo和pointInfo不同，上面两个变量一直都有值，因为他们的意义是找到最近的，而symbolInfo是判断是否选中
-        }
-
         this.componentInfo = {
             componentId: null,
             state: null,
@@ -242,7 +237,6 @@ export default class ListenLayer {
         const result = {
             minPoint: min1,
             minWall: min2,
-            symbolInfo: {},
             componentInfo: {},
             tagInfo: {},
             furnitureInfo: {},
@@ -262,20 +256,6 @@ export default class ListenLayer {
             result.modifyPoint.y = modifyPoint.y
         }
 
-        //是否在门/窗 上
-        const symbols = floorplanService.getSymbols()
-        for (const symbolId in symbols) {
-            const symbol = floorplanService.getSymbol(symbolId)
-            const location = symbol.isContain(position)
-            if (location != null) {
-                result.symbolInfo = {
-                    symbolId: symbolId,
-                    state: location,
-                }
-                break
-            }
-        }
-
         const components = floorplanService.getComponents()
         for (const componentId in components) {
             const component = floorplanService.getComponent(componentId)
@@ -367,11 +347,11 @@ export default class ListenLayer {
             }
         }
         // symbols状态是否改变
-        const flag3 = this.isChanged(nearest.symbolInfo.symbolId, nearest.symbolInfo.state, 3)
-        this.symbolInfo = {
-            symbolId: nearest.symbolInfo.symbolId,
-            state: nearest.symbolInfo.state,
-        }
+        // const flag3 = this.isChanged(nearest.symbolInfo.symbolId, nearest.symbolInfo.state, 3)
+        // this.symbolInfo = {
+        //     symbolId: nearest.symbolInfo.symbolId,
+        //     state: nearest.symbolInfo.state,
+        // }
 
         const flag4 = this.isChanged(nearest.componentInfo.componentId, nearest.componentInfo.state, 4)
         this.componentInfo = {
@@ -413,15 +393,17 @@ export default class ListenLayer {
             } else {
                 flag = true
             }
-        } else if (type == 3) {
-            if (state == null && state == this.symbolInfo.state) {
-                flag = false
-            } else if (this.symbolInfo.symbolId == vectorId && state == this.symbolInfo.state) {
-                flag = false
-            } else {
-                flag = true
-            }
-        } else if (type == 4) {
+        } 
+        // else if (type == 3) {
+        //     if (state == null && state == this.symbolInfo.state) {
+        //         flag = false
+        //     } else if (this.symbolInfo.symbolId == vectorId && state == this.symbolInfo.state) {
+        //         flag = false
+        //     } else {
+        //         flag = true
+        //     }
+        // } 
+        else if (type == 4) {
             if (state == null && state == this.componentInfo.state) {
                 flag = false
             } else if (this.componentInfo.componentId == vectorId && state == this.componentInfo.state) {
@@ -460,9 +442,6 @@ export default class ListenLayer {
         } else if (this.furnitureInfo.furnitureId != null && this.furnitureInfo.state != null) {
             const furniture = floorplanService.getFurniture(this.furnitureInfo.furnitureId)
             stateService.setSelectItem(this.furnitureInfo.furnitureId, furniture.geoType, this.furnitureInfo.state)
-        } else if (this.symbolInfo.symbolId != null && this.symbolInfo.state != null) {
-            const symbol = floorplanService.getSymbol(this.symbolInfo.symbolId)
-            stateService.setSelectItem(this.symbolInfo.symbolId, symbol.geoType, this.symbolInfo.state)
         } else if (this.pointInfo.pointId != null && this.pointInfo.state != null) {
             stateService.setSelectItem(this.pointInfo.pointId, VectorType.WallCorner, SelectState.Select)
         } else if (this.wallInfo.wallId != null && this.wallInfo.state != null) {
@@ -483,11 +462,6 @@ export default class ListenLayer {
             state: null,
         }
 
-        this.symbolInfo = {
-            symbolId: null,
-            state: null,
-        }
-
         this.componentInfo = {
             componentId: null,
             state: null,