feat: .

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

@@ -71,24 +71,6 @@ export default class AddWall {
                 return false
             }
         }
-
-        //是否与symbol相交
-        if (listenLayer.symbolInfo.symbolId) {
-            return false
-        } else {
-            const symbols = floorplanService.getSymbols()
-            for (let key in symbols) {
-                let symbol = symbols[key]
-                if (symbol.geoType == VectorType.Pass) {
-                    continue
-                }
-                let join = mathUtil.getIntersectionPoint3(symbol.startPoint, symbol.endPoint, this.startInfo.position, endPt)
-                if (join != null) {
-                    return false
-                }
-            }
-        }
-
         return true
     }
 

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

@@ -1,166 +0,0 @@
-import { floorplanService } from '../Service/FloorplanService'
-import { mathUtil } from '../MathUtil.js'
-import Constant from '../Constant'
-
-export default class MoveComponent {
-    constructor() {}
-
-    moveFullComponent(position, componentId) {
-        let component = floorplanService.getComponent(componentId)
-        mathUtil.clonePoint(component.center, position)
-        const flag = this.getAdsorbInfo(component)
-
-        //未吸附
-        if (!flag) {
-            component.setPoints2d()
-        }
-        return flag
-    }
-
-    getAdsorbInfo(component) {
-        const midPoints = this.getMidPointsEdge(component)
-        const mins = this.getNearestPoints(midPoints, component.center)
-        let info = this.isAdsorb(mins.min0, midPoints[0], component.center)
-        if (info != null) {
-            component.center.x += info.dx
-            component.center.y += info.dy
-            component.setPoints2d()
-            return true
-        } else {
-            info = this.isAdsorb(mins.min1, midPoints[1], component.center)
-            if (info != null) {
-                component.center.x += info.dx
-                component.center.y += info.dy
-                component.setPoints2d()
-                return true
-            } else {
-                info = this.isAdsorb(mins.min2, midPoints[2], component.center)
-                if (info != null) {
-                    component.center.x += info.dx
-                    component.center.y += info.dy
-                    component.setPoints2d()
-                    return true
-                } else {
-                    info = this.isAdsorb(mins.min3, midPoints[3], component.center)
-                    if (info != null) {
-                        component.center.x += info.dx
-                        component.center.y += info.dy
-                        component.setPoints2d()
-                        return true
-                    }
-                }
-            }
-        }
-        return false
-    }
-
-    //获取上下左右四个点的坐标
-    getMidPointsEdge(component) {
-        let midPoints = []
-        midPoints.push({
-            x: (component.points2d[0].x + component.points2d[1].x) / 2,
-            y: (component.points2d[0].y + component.points2d[1].y) / 2,
-        })
-
-        midPoints.push({
-            x: (component.points2d[1].x + component.points2d[2].x) / 2,
-            y: (component.points2d[1].y + component.points2d[2].y) / 2,
-        })
-
-        midPoints.push({
-            x: (component.points2d[2].x + component.points2d[3].x) / 2,
-            y: (component.points2d[2].y + component.points2d[3].y) / 2,
-        })
-
-        midPoints.push({
-            x: (component.points2d[3].x + component.points2d[0].x) / 2,
-            y: (component.points2d[3].y + component.points2d[0].y) / 2,
-        })
-        return midPoints
-    }
-
-    getNearestPoints(midPoints, center) {
-        const walls = floorplanService.getWalls()
-        const line1 = mathUtil.createLine1(midPoints[0], midPoints[2])
-        const line2 = mathUtil.createLine1(midPoints[1], midPoints[3])
-
-        let min0 = null
-        let min1 = null
-        let min2 = null
-        let min3 = null
-
-        for (let key in walls) {
-            const wall = walls[key]
-            const startPoint = floorplanService.getPoint(wall.start)
-            const endPoint = floorplanService.getPoint(wall.end)
-
-            let join1 = mathUtil.getIntersectionPoint4(startPoint, endPoint, line1)
-            if (join1 != null) {
-                if (mathUtil.isContainForSegment(midPoints[0], join1, center)) {
-                    if (min0 == null || mathUtil.getDistance(midPoints[0], min0.position) > mathUtil.getDistance(midPoints[0], join1)) {
-                        min0 = {
-                            position: join1,
-                            wallId: key,
-                        }
-                    }
-                } else if (mathUtil.isContainForSegment(midPoints[2], join1, center)) {
-                    if (min2 == null || mathUtil.getDistance(midPoints[2], min2.position) > mathUtil.getDistance(midPoints[2], join1)) {
-                        min2 = {
-                            position: join1,
-                            wallId: key,
-                        }
-                    }
-                }
-            }
-
-            let join2 = mathUtil.getIntersectionPoint4(startPoint, endPoint, line2)
-            if (join2 != null) {
-                if (mathUtil.isContainForSegment(midPoints[1], join2, center)) {
-                    if (min1 == null || mathUtil.getDistance(midPoints[1], min1.position) > mathUtil.getDistance(midPoints[1], join2)) {
-                        min1 = {
-                            position: join2,
-                            wallId: key,
-                        }
-                    }
-                } else if (mathUtil.isContainForSegment(midPoints[3], join2, center)) {
-                    if (min3 == null || mathUtil.getDistance(midPoints[3], min3.position) > mathUtil.getDistance(midPoints[3], join2)) {
-                        min3 = {
-                            position: join2,
-                            wallId: key,
-                        }
-                    }
-                }
-            }
-        }
-
-        return {
-            min0: min0,
-            min1: min1,
-            min2: min2,
-            min3: min3,
-        }
-    }
-
-    isAdsorb(min, mid, center) {
-        if (min == null) {
-            return null
-        }
-        const wall = floorplanService.getWall(min.wallId)
-        const startPoint = floorplanService.getPoint(wall.start)
-        const endPoint = floorplanService.getPoint(wall.end)
-        const angle = mathUtil.Angle(min.position, center, startPoint)
-        //吸附
-        if (Math.abs(angle - Math.PI / 2) < 0.1 && mathUtil.getDistance(min.position, mid) < Constant.minAdsorb) {
-            let dx = min.position.x - mid.x
-            let dy = min.position.y - mid.y
-            return {
-                dx: dx,
-                dy: dy,
-            }
-        }
-        return null
-    }
-}
-
-const moveComponent = new MoveComponent()
-export { moveComponent }

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

@@ -13,11 +13,12 @@ import { tagService } from '../Service/TagService.js'
 import Constant from '../Constant'
 import { addWall } from '../Controls/AddWall'
 import { floorplanData } from '../FloorplanData.js'
-import { furnitureService } from '../Service/FurnitureService.js'
+import { signService } from '../Service/SignService.js'
 
 export default class UIControl {
     constructor(layer) {
         this.layer = layer
+        this.selectUI = null;
     }
 
     /**
@@ -31,20 +32,7 @@ export default class UIControl {
      * 设置选中要添加的UI
      */
     set selectUI(value) {
-        this.layer.updateEventNameForSelectUI()
-    }
-
-    /**
-     * 获取选中要操作的UI
-     */
-    get currentUI() {
-    }
-
-    /**
-     * 设置选中要操作的UI
-     */
-    set currentUI(value) {
-
+        this.updateEventNameForSelectUI()
     }
 
     /**
@@ -59,6 +47,61 @@ export default class UIControl {
     set currentFloor(value) {
     }
 
+    //点击左侧栏后，更新事件
+    updateEventNameForSelectUI() {
+        elementService.hideAll()
+        //正在添加tag的时候，需要先删除
+        const eventName = stateService.getEventName()
+        if (eventName == LayerEvents.AddTag) {
+            let item = stateService.getDraggingItem()
+            if (item && item.type == VectorType.Tag) {
+                floorplanService.deleteTag(item.vectorId)
+            }
+        }
+        stateService.clearItems()
+        if (this.selectUI == UIEvents.Wall || this.selectUI == UIEvents.OutWall) {
+            stateService.setEventName(LayerEvents.AddWall)
+        } else if (
+            this.selectUI == UIEvents.SingleDoor ||
+            this.selectUI == UIEvents.DoubleDoor ||
+            this.selectUI == UIEvents.SlideDoor ||
+            this.selectUI == UIEvents.SingleWindow ||
+            this.selectUI == UIEvents.BayWindow ||
+            this.selectUI == UIEvents.FrenchWindow ||
+            this.selectUI == UIEvents.Pass
+        ) {
+            stateService.setEventName(LayerEvents.AddSymbol)
+        } else if (this.selectUI == UIEvents.Beam || this.selectUI == UIEvents.Flue || this.selectUI == UIEvents.Corridor) {
+            stateService.setEventName(LayerEvents.AddComponent)
+        } else if (this.selectUI == UIEvents.Tag) {
+            stateService.setEventName(LayerEvents.AddTag)
+        } else if (
+            this.selectUI == UIEvents.TV ||
+            this.selectUI == UIEvents.CombinationSofa ||
+            this.selectUI == UIEvents.SingleSofa ||
+            this.selectUI == UIEvents.TeaTable ||
+            this.selectUI == UIEvents.Carpet ||
+            this.selectUI == UIEvents.Plant ||
+            this.selectUI == UIEvents.DiningTable ||
+            this.selectUI == UIEvents.DoubleBed ||
+            this.selectUI == UIEvents.SingleBed ||
+            this.selectUI == UIEvents.Wardrobe ||
+            this.selectUI == UIEvents.Dresser ||
+            this.selectUI == UIEvents.BedsideCupboard ||
+            this.selectUI == UIEvents.Pillow ||
+            this.selectUI == UIEvents.GasStove ||
+            this.selectUI == UIEvents.Cupboard ||
+            this.selectUI == UIEvents.Bathtub ||
+            this.selectUI == UIEvents.Closestool ||
+            this.selectUI == UIEvents.Washstand ||
+            this.selectUI == UIEvents.Desk ||
+            this.selectUI == UIEvents.BalconyChair ||
+            this.selectUI == UIEvents.Elevator
+        ) {
+            stateService.setEventName(LayerEvents.AddSign)
+        }
+    }
+
     /**
      * 设置部件属性
      * @param {*} type 部件类型
@@ -68,7 +111,6 @@ export default class UIControl {
     setAttributes(type, name, value) {
         console.log(name)
         let item = stateService.getFocusItem()
-        // 回写 this.layer.$xui.currentAttributes = {...}
         switch (name) {
             case 'remove':
                 if (type == VectorType.Wall || type == 'OutWall') {
@@ -83,12 +125,11 @@ export default class UIControl {
                     }
                 } else if (type == VectorType.WallCorner) {
                     wallService.deleteWallCorner(item.vectorId)
-                } else if (furnitureService.isFurniture(type)) {
-                    floorplanService.deleteFurniture(item.vectorId)
+                } else if (signService.isSign(type)) {
+                    floorplanService.deleteSign(item.vectorId)
                 }
                 stateService.clearItems()
                 stateService.clearEventName()
-                //this.layer.history.save()
                 this.layer.renderer.autoRedraw()
                 break
             case 'angle':
@@ -96,14 +137,10 @@ export default class UIControl {
                     let component = floorplanService.getComponent(item.vectorId)
                     component.angle = value
                     component.setPoints2d()
-
-                    //this.layer.history.save()
                     this.layer.renderer.autoRedraw()
-                } else if (furnitureService.isFurniture(type)) {
-                    let furniture = floorplanService.getFurniture(item.vectorId)
-                    furniture.angle = value
-
-                    //this.layer.history.save()
+                } else if (signService.isSign(type)) {
+                    let sign = floorplanService.getSign(item.vectorId)
+                    sign.angle = value
                     this.layer.renderer.autoRedraw()
                 }
                 break
@@ -113,15 +150,13 @@ export default class UIControl {
                     component.sideWidth = value
                     component.setPoints2d()
                 }
-                //this.layer.history.save()
                 this.layer.renderer.autoRedraw()
                 break
 
             case 'scale':
-                if (furnitureService.isFurniture(type)) {
-                    let furniture = floorplanService.getFurniture(item.vectorId)
-                    furniture.scale = value
-                    //this.layer.history.save()
+                if (signService.isSign(type)) {
+                    let sign = floorplanService.getSign(item.vectorId)
+                    sign.scale = value
                     this.layer.renderer.autoRedraw()
                 }
                 break
@@ -130,7 +165,6 @@ export default class UIControl {
                     let component = floorplanService.getComponent(item.vectorId)
                     component.sideThickness = value
                     component.setPoints2d()
-                    //this.layer.history.save()
                     this.layer.renderer.autoRedraw()
                 }
                 break
@@ -163,8 +197,6 @@ export default class UIControl {
                     } else if (mid.x == _mid.x && mid.y > _mid.y) {
                         stateService.setFocusItem(focusItem)
                     }
-                    //stateService.clearFocusItem()
-                    //this.layer.history.save()
                     this.layer.renderer.autoRedraw()
                 }
                 break
@@ -181,14 +213,6 @@ export default class UIControl {
                     this.layer.renderer.autoRedraw()
                 }
                 break
-            case 'area':
-                if (type == VectorType.Tag) {
-                    let tag = floorplanService.getTag(item.vectorId)
-                    tag.setDes(value)
-                    //this.layer.history.save()
-                    this.layer.renderer.autoRedraw()
-                }
-                break
             case 'default':
                 if (type == 'compass') {
                     floorplanService.setCompass(0)
@@ -206,55 +230,8 @@ export default class UIControl {
                         angle: 0,
                     }
                 }
-                //this.layer.history.save()
-                this.layer.renderer.autoRedraw()
-                break
-            case 'enter': //入户门
-                if (type == VectorType.SingleDoor || type == VectorType.DoubleDoor || type == VectorType.SlideDoor) {
-                    let symbol = floorplanService.getSymbol(item.vectorId)
-                    if (value) {
-                        symbol.enter = 'default'
-                    } else {
-                        symbol.enter = null
-                    }
-                    //this.layer.history.save()
-                    this.layer.renderer.autoRedraw()
-                }
-                break
-            case 'enterRotate': //入户门方向
-                if (type == VectorType.SingleDoor || type == VectorType.DoubleDoor || type == VectorType.SlideDoor) {
-                    let symbol = floorplanService.getSymbol(item.vectorId)
-                    if (symbol.enter == null) {
-                        symbol.enter = 'default'
-                    } else if (symbol.enter == 'default') {
-                        symbol.enter = 'reverse'
-                    } else if (symbol.enter == 'reverse') {
-                        symbol.enter = 'default'
-                    }
-                }
-                //this.layer.history.save()
                 this.layer.renderer.autoRedraw()
                 break
-            case 'important':
-                if (type == VectorType.Wall) {
-                    let wall = floorplanService.getWall(item.vectorId)
-                    wall.setImportant(value)
-                    //this.layer.history.save()
-                    this.layer.renderer.autoRedraw()
-                }
-                break
-            case 'wallType':
-                if (type == VectorType.Wall) {
-                    let wall = floorplanService.getWall(item.vectorId)
-                    if (value == 'OutWall') {
-                        wall.setOut(true)
-                    } else {
-                        wall.setOut(false)
-                    }
-                    //this.layer.history.save()
-                    this.layer.renderer.autoRedraw()
-                }
-                break
             case 'compass':
                 floorplanService.setCompass(parseFloat(value))
                 break
@@ -269,13 +246,6 @@ export default class UIControl {
     }
 
     showAttributes(type) {
-        if (type == 'compass') {
-            this.layer.$xui.currentAttributes = {
-                name: 'compass',
-                compass: floorplanService.getCompass(),
-            }
-            return
-        }
         let item = stateService.getFocusItem()
         if (item == null) {
             item = stateService.getDraggingItem()
@@ -304,13 +274,13 @@ export default class UIControl {
                 important: wall.important || wall.out,
                 wallType: wall.out ? 'OutWall' : item.type,
             }
-        } else if (furnitureService.isFurniture(item.type)) {
-            let furniture = floorplanService.getFurniture(item.vectorId)
-            let scale = furniture.scale
+        } else if (signService.isSign(item.type)) {
+            let sign = floorplanService.getSign(item.vectorId)
+            let scale = sign.scale
             this.layer.$xui.currentAttributes = {
                 name: item.type,
                 scale: scale,
-                angle: furniture.angle,
+                angle: sign.angle,
             }
         }
     }
@@ -329,49 +299,21 @@ export default class UIControl {
         }
     }
 
-    getFurnitureTypeForUI() {
-        if (this.selectUI == UIEvents.TV) {
-            return VectorType.TV
-        } else if (this.selectUI == UIEvents.CombinationSofa) {
-            return VectorType.CombinationSofa
-        } else if (this.selectUI == UIEvents.SingleSofa) {
-            return VectorType.SingleSofa
-        } else if (this.selectUI == UIEvents.TeaTable) {
-            return VectorType.TeaTable
-        } else if (this.selectUI == UIEvents.Carpet) {
-            return VectorType.Carpet
-        } else if (this.selectUI == UIEvents.Plant) {
-            return VectorType.Plant
-        } else if (this.selectUI == UIEvents.DiningTable) {
-            return VectorType.DiningTable
-        } else if (this.selectUI == UIEvents.DoubleBed) {
-            return VectorType.DoubleBed
-        } else if (this.selectUI == UIEvents.SingleBed) {
-            return VectorType.SingleBed
-        } else if (this.selectUI == UIEvents.Wardrobe) {
-            return VectorType.Wardrobe
-        } else if (this.selectUI == UIEvents.Dresser) {
-            return VectorType.Dresser
-        } else if (this.selectUI == UIEvents.BedsideCupboard) {
-            return VectorType.BedsideCupboard
-        } else if (this.selectUI == UIEvents.Pillow) {
-            return VectorType.Pillow
-        } else if (this.selectUI == UIEvents.GasStove) {
-            return VectorType.GasStove
-        } else if (this.selectUI == UIEvents.Cupboard) {
-            return VectorType.Cupboard
-        } else if (this.selectUI == UIEvents.Bathtub) {
-            return VectorType.Bathtub
-        } else if (this.selectUI == UIEvents.Closestool) {
-            return VectorType.Closestool
-        } else if (this.selectUI == UIEvents.Washstand) {
-            return VectorType.Washstand
-        } else if (this.selectUI == UIEvents.Desk) {
-            return VectorType.Desk
-        } else if (this.selectUI == UIEvents.BalconyChair) {
-            return VectorType.BalconyChair
-        } else if (this.selectUI == UIEvents.Elevator) {
-            return VectorType.Elevator
+    getSignTypeForUI() {
+        if (this.selectUI == UIEvents.Cigaret) {
+            return VectorType.Cigaret
+        } else if (this.selectUI == UIEvents.FirePoint) {
+            return VectorType.FirePoint
+        } else if (this.selectUI == UIEvents.FootPrint) {
+            return VectorType.FootPrint
+        } else if (this.selectUI == UIEvents.ShoePrint) {
+            return VectorType.ShoePrint
+        } else if (this.selectUI == UIEvents.FingerPrint) {
+            return VectorType.FingerPrint
+        } else if (this.selectUI == UIEvents.DeadBody) {
+            return VectorType.DeadBody
+        } else if (this.selectUI == UIEvents.BloodStain) {
+            return VectorType.BloodStain
         }
     }
 

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

@@ -1,72 +0,0 @@
-import Geometry from './Geometry'
-import { mathUtil } from '../MathUtil.js'
-import SelectState from '../enum/SelectState.js'
-import VectorType from '../enum/VectorType.js'
-
-export default class Furniture extends Geometry {
-    constructor(center, vectorId, type) {
-        super()
-        this.center = center
-        this.geoType = type
-        this.angle = 0 //逆时针为负，顺时针为正。单位是：°
-        this.scale = 1 //缩放比例
-        this.setId(vectorId)
-    }
-
-    isContain(position) {
-        const dis = mathUtil.getDistance(position, this.center)
-        let len = this.getLen() * this.scale
-        if (dis < len / 2) {
-            return SelectState.Select
-        } else {
-            return null
-        }
-    }
-
-    getLen() {
-        switch (this.geoType) {
-            case VectorType.TV: //电视
-                return 1.3
-            case VectorType.CombinationSofa: //组合沙发
-                return 3.4
-            case VectorType.SingleSofa: //单人沙发
-                return 1
-            case VectorType.TeaTable: //茶几
-                return 0.8
-            case VectorType.Carpet: //地毯
-                return 2
-            case VectorType.Plant: //植物
-                return 0.3
-            case VectorType.DiningTable: //餐桌
-                return 2.4
-            case VectorType.DoubleBed: //双人床
-                return 2
-            case VectorType.SingleBed: //单人床
-                return 2
-            case VectorType.Wardrobe: //衣柜
-                return 1.2
-            case VectorType.Dresser: //梳妆台
-                return 0.8
-            case VectorType.BedsideCupboard: //床头柜
-                return 0.4
-            case VectorType.Pillow: //抱枕
-                return 0.6
-            case VectorType.GasStove: //燃气灶
-                return 1
-            case VectorType.Cupboard: //橱柜
-                return 1.2
-            case VectorType.Bathtub: //浴缸
-                return 1.6
-            case VectorType.Closestool: //马桶
-                return 0.63
-            case VectorType.Washstand: //洗漱台
-                return 0.8
-            case VectorType.Desk: //书桌
-                return 1.2
-            case VectorType.BalconyChair: //阳台椅
-                return 2
-            case VectorType.Elevator: //电梯
-                return 1.5
-        }
-    }
-}

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

@@ -1,6 +1,5 @@
 import { floorplanService } from '../Service/FloorplanService'
 import { mathUtil } from '../MathUtil.js'
-import SymbolEvents from '../enum/SymbolEvents.js'
 
 export default class Geometry {
     constructor() {
@@ -37,22 +36,6 @@ export default class Geometry {
         this.parent[wallId] = dir
     }
 
-    setOpenSide(point) {
-        const points = []
-        points.push(this.startPoint)
-        points.push(this.endPoint)
-        points.push(point)
-
-        let openSide = null
-        // 逆时针
-        if (mathUtil.isClockwise(points)) {
-            openSide = SymbolEvents.Left
-        } else {
-            openSide = SymbolEvents.Right
-        }
-        this.openSide = openSide
-    }
-
     // ptSrc: 圆上某点(初始点);
     // ptRotationCenter: 圆心点;
     // angle: 旋转角度°  -- [angle * M_PI / 180]:将角度换算为弧度

src/views/draw-file/board/editCAD/History/Change.js

@@ -17,9 +17,7 @@ export default class Change {
         this.lastData.currentFloor = floorplanService.getCurrentFloor()
         this.lastData.points = JSON.parse(JSON.stringify(floorplanService.getPoints()))
         this.lastData.walls = JSON.parse(JSON.stringify(floorplanService.getWalls()))
-        this.lastData.symbols = JSON.parse(JSON.stringify(floorplanService.getSymbols()))
-        this.lastData.components = JSON.parse(JSON.stringify(floorplanService.getComponents()))
-        this.lastData.furnitures = JSON.parse(JSON.stringify(floorplanService.getFurnitures()))
+        this.lastData.signs = JSON.parse(JSON.stringify(floorplanService.getSigns()))
         this.lastData.tags = JSON.parse(JSON.stringify(floorplanService.getTags()))
         this.lastData.angle = floorplanService.getAngle()
         this.lastData.res = coordinate.res
@@ -35,7 +33,7 @@ export default class Change {
             this.compareWalls()
             this.compareComponents()
             this.compareTags()
-            this.compareFurnitures()
+            this.compareSigns()
         }
         //旋转了
         else {
@@ -49,7 +47,7 @@ export default class Change {
             this.elements.symbols.length == 0 &&
             this.elements.components.length == 0 &&
             this.elements.tags.length == 0 &&
-            this.elements.furnitures.length == 0
+            this.elements.signs.length == 0
         ) {
             this.saveCurrentInfo()
             return false
@@ -264,44 +262,44 @@ export default class Change {
         }
     }
 
-    compareFurnitures() {
+    compareSigns() {
         //const currentFloor = floorplanService.getCurrentFloorNum();
-        this.elements.furnitures = []
-        const furnitures = floorplanService.getFurnitures()
+        this.elements.signs = []
+        const signs = floorplanService.getSigns()
 
-        for (const key in furnitures) {
-            const furniture = furnitures[key]
-            const lastFurniture = this.lastData.furnitures[key]
+        for (const key in signs) {
+            const sign = signs[key]
+            const lastSign = this.lastData.signs[key]
 
             // 不存在意味着增加
-            if (!lastFurniture) {
+            if (!lastSign) {
                 const item = {
-                    handle: HistoryEvents.AddFurniture,
-                    furniture: historyUtil.getDataForFurniture(furniture),
+                    handle: HistoryEvents.AddSign,
+                    sign: historyUtil.getDataForSign(sign),
                 }
-                this.elements.furnitures.push(item)
+                this.elements.signs.push(item)
             } else {
-                if (!historyUtil.isDifferentForFurnitures(furniture, lastFurniture)) {
-                    delete this.lastData.furnitures[key]
+                if (!historyUtil.isDifferentForSigns(sign, lastSign)) {
+                    delete this.lastData.signs[key]
                     continue
                 } else {
                     const item = {
-                        handle: HistoryEvents.ModifyFurniture,
-                        preFurniture: historyUtil.getDataForFurniture(lastFurniture),
-                        curFurniture: historyUtil.getDataForFurniture(furniture),
+                        handle: HistoryEvents.ModifySign,
+                        preSign: historyUtil.getDataForSign(lastSign),
+                        curSign: historyUtil.getDataForSign(sign),
                     }
-                    this.elements.furnitures.push(item)
+                    this.elements.signs.push(item)
                 }
             }
-            delete this.lastData.furnitures[key]
+            delete this.lastData.signs[key]
         }
 
-        for (const key in this.lastData.furnitures) {
+        for (const key in this.lastData.signs) {
             const item = {
-                handle: HistoryEvents.DeleteFurniture,
-                furniture: historyUtil.getDataForFurniture(this.lastData.furnitures[key]),
+                handle: HistoryEvents.DeleteSign,
+                sign: historyUtil.getDataForSign(this.lastData.signs[key]),
             }
-            this.elements.furnitures.push(item)
+            this.elements.signs.push(item)
         }
     }
 

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

@@ -9,7 +9,7 @@ import { componentService } from '../Service/ComponentService'
 import { historyService } from '../Service/HistoryService'
 import { tagService } from '../Service/TagService'
 import { coordinate } from '../Coordinate'
-import { furnitureService } from '../Service/FurnitureService'
+import { signService } from '../Service/SignService'
 
 export default class History {
     constructor(layer) {
@@ -129,7 +129,7 @@ export default class History {
                 this.goPreForWalls(item.walls)
                 this.goPreForComponents(item.components)
                 this.goPreForTags(item.tags)
-                this.goPreForFurnitures(item.furnitures)
+                this.goPreForSigns(item.signs)
             }
 
             historyService.undoHistoryRecord()
@@ -198,18 +198,18 @@ export default class History {
         }
     }
 
-    goPreForFurnitures(itemForFurnitures) {
-        for (let i = 0; i < itemForFurnitures.length; ++i) {
-            const item = itemForFurnitures[i]
-            if (item.handle == HistoryEvents.AddFurniture) {
-                floorplanService.deleteFurniture(item.furniture.id)
-            } else if (item.handle == HistoryEvents.DeleteFurniture) {
-                let vFurniture = furnitureService.createFurniture(item.furniture.center, item.furniture.type, item.furniture.id)
-                historyUtil.assignFurnitureFromFurniture(vFurniture, item.furniture)
-            } else if (item.handle == HistoryEvents.ModifyFurniture) {
-                const preFurniture = item.preFurniture
-                let currentFurniture = floorplanService.getFurniture(item.curFurniture.id)
-                historyUtil.assignFurnitureFromFurniture(currentFurniture, preFurniture)
+    goPreForSigns(itemForSigns) {
+        for (let i = 0; i < itemForSigns.length; ++i) {
+            const item = itemForSigns[i]
+            if (item.handle == HistoryEvents.AddSign) {
+                floorplanService.deleteSign(item.sign.id)
+            } else if (item.handle == HistoryEvents.DeleteSign) {
+                let vSign = signService.createSign(item.sign.center, item.sign.type, item.sign.id)
+                historyUtil.assignSignFromSign(vSign, item.sign)
+            } else if (item.handle == HistoryEvents.ModifySign) {
+                const preSign = item.preSign
+                let currentSign = floorplanService.getSign(item.curSign.id)
+                historyUtil.assignSignFromSign(currentSign, preSign)
             }
         }
     }
@@ -314,18 +314,18 @@ export default class History {
         }
     }
 
-    goNextForFurnitures(itemForFurnitures) {
-        for (let i = 0; i < itemForFurnitures.length; ++i) {
-            const item = itemForFurnitures[i]
-            if (item.handle == HistoryEvents.AddFurniture) {
-                let vFurniture = furnitureService.createFurniture(item.furniture.center, item.furniture.type, item.furniture.id)
-                historyUtil.assignFurnitureFromFurniture(vFurniture, item.furniture)
-            } else if (item.handle == HistoryEvents.DeleteFurniture) {
-                floorplanService.deleteFurniture(item.furniture.id)
-            } else if (item.handle == HistoryEvents.ModifyFurniture) {
-                const currentFurniture = item.curFurniture
-                let preFurniture = floorplanService.getFurniture(item.curFurniture.id)
-                historyUtil.assignFurnitureFromFurniture(preFurniture, currentFurniture)
+    goNextForSigns(itemForSigns) {
+        for (let i = 0; i < itemForSigns.length; ++i) {
+            const item = itemForSigns[i]
+            if (item.handle == HistoryEvents.AddSign) {
+                let vSign = signService.createSign(item.sign.center, item.sign.type, item.sign.id)
+                historyUtil.assignSignFromSign(vSign, item.sign)
+            } else if (item.handle == HistoryEvents.DeleteSign) {
+                floorplanService.deleteSign(item.sign.id)
+            } else if (item.handle == HistoryEvents.ModifySign) {
+                const currentSign = item.curSign
+                let preSign = floorplanService.getSign(item.curSign.id)
+                historyUtil.assignSignFromSign(preSign, currentSign)
             }
         }
     }
@@ -368,7 +368,7 @@ export default class History {
                 this.goNextForWalls(item.walls)
                 this.goNextForComponents(item.components)
                 this.goNextForTags(item.tags)
-                this.goNextForFurnitures(item.furnitures)
+                this.goNextForSigns(item.signs)
             }
             change.saveCurrentInfo()
             this.setState()

src/views/draw-file/board/editCAD/History/HistoryUtil.js

@@ -1,7 +1,7 @@
 import { mathUtil } from '../MathUtil'
 import { componentService } from '../Service/ComponentService'
 import { floorplanService } from '../Service/FloorplanService'
-import { furnitureService } from '../Service/FurnitureService'
+import { signService } from '../Service/SignService'
 import { tagService } from '../Service/TagService'
 import { wallService } from '../Service/WallService'
 
@@ -42,8 +42,8 @@ export default class HistoryUtil {
             return true
         }
     }
-    isDifferentForFurnitures(furniture1, furniture2) {
-        if (furniture1.scale == furniture2.scale && JSON.stringify(furniture1.center) == JSON.stringify(furniture2.center) && furniture1.angle == furniture2.angle) {
+    isDifferentForSigns(sign1, sign2) {
+        if (sign1.scale == sign2.scale && JSON.stringify(sign1.center) == JSON.stringify(sign2.center) && sign1.angle == sign2.angle) {
             return false
         } else {
             return true
@@ -96,13 +96,13 @@ export default class HistoryUtil {
         tagInfo.adding = false
         tagService.setTagInfo(tagInfo)
     }
-    assignFurnitureFromFurniture(furniture1, furniture2) {
-        const furnitureInfo = {}
-        furnitureInfo.vectorId = furniture1.vectorId
-        furnitureInfo.angle = furniture2.angle
-        furnitureInfo.center = JSON.parse(JSON.stringify(furniture2.center))
-        furnitureInfo.scale = furniture2.scale
-        furnitureService.setFurnitureInfo(furnitureInfo)
+    assignSignFromSign(sign1, sign2) {
+        const SignInfo = {}
+        SignInfo.vectorId = sign1.vectorId
+        SignInfo.angle = sign2.angle
+        SignInfo.center = JSON.parse(JSON.stringify(sign2.center))
+        SignInfo.scale = sign2.scale
+        signService.setSignInfo(SignInfo)
     }
     deletePoint(pointId) {
         const point = floorplanService.getPoint(pointId)
@@ -154,13 +154,13 @@ export default class HistoryUtil {
         return data
     }
 
-    getDataForFurniture(furniture) {
+    getDataForSign(sign) {
         const data = {}
-        data.id = furniture.vectorId
-        data.type = furniture.geoType
-        data.center = JSON.parse(JSON.stringify(furniture.center))
-        data.scale = furniture.scale
-        data.angle = furniture.angle
+        data.id = sign.vectorId
+        data.type = sign.geoType
+        data.center = JSON.parse(JSON.stringify(sign.center))
+        data.scale = sign.scale
+        data.angle = sign.angle
         return data
     }
 

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

@@ -6,7 +6,6 @@ import { tagService } from './Service/TagService'
 import { historyService } from './Service/HistoryService'
 
 import UIControl from './Controls/UIControl'
-import { moveComponent } from './Controls/MoveComponent'
 import { moveTag } from './Controls/MoveTag'
 import { addWall } from './Controls/AddWall'
 import { moveWall } from './Controls/MoveWall'
@@ -26,7 +25,7 @@ import { wallService } from './Service/WallService'
 import { componentService } from './Service/ComponentService'
 import History from './History/History'
 import { compassService } from './Service/CompassService'
-import { furnitureService } from './Service/FurnitureService'
+import { signService } from './Service/SignService'
 
 export default class Layer {
     constructor() {
@@ -46,6 +45,7 @@ export default class Layer {
         coordinate.init(canvas)
         this.canvas = canvas;
         this.load.load(vectorData);
+        draw.initContext(this.canvas)
         this.bindEvents()
     }
 
@@ -97,7 +97,7 @@ export default class Layer {
                 return
             }
             if (addWall.canAdd) {
-                addWall.buildWall(this.uiControl.selectUI == UIEvents.OutWall)
+                addWall.buildWall()
                 this.history.save()
             } else {
                 return
@@ -266,26 +266,6 @@ export default class Layer {
                         stateService.setSelectItem(component.vectorId, componentType, SelectState.All)
                         stateService.setDraggingItem(stateService.selectItem)
                     }
-                } else {
-                    let flag = moveComponent.moveFullComponent(position, draggingItem.vectorId)
-                    if (flag) {
-                        this.lastX = X
-                        this.lastY = Y
-                        this.startX = X
-                        this.startY = Y
-                    }
-                }
-                break
-            case LayerEvents.MoveComponent:
-                needAutoRedraw = true
-                if (draggingItem != null && componentService.isComponent(draggingItem.type)) {
-                    let flag = moveComponent.moveFullComponent(position, draggingItem.vectorId)
-                    if (flag) {
-                        this.lastX = X
-                        this.lastY = Y
-                        this.startX = X
-                        this.startY = Y
-                    }
                 }
                 break
             case LayerEvents.AddTag:
@@ -306,24 +286,24 @@ export default class Layer {
                     moveTag.moveFullTag(position, draggingItem.vectorId)
                 }
                 break
-            case LayerEvents.AddFurniture:
+            case LayerEvents.AddSign:
                 needAutoRedraw = true
                 if (draggingItem == null) {
-                    const furnitureType = this.uiControl.getFurnitureTypeForUI()
-                    const furniture = furnitureService.createFurniture(position, furnitureType)
-                    if (furniture.vectorId) {
-                        stateService.setSelectItem(furniture.vectorId, furnitureType, SelectState.All)
+                    const signType = this.uiControl.getSignTypeForUI()
+                    const sign = signService.createSign(position, signType)
+                    if (sign.vectorId) {
+                        stateService.setSelectItem(sign.vectorId, signType, SelectState.All)
                         stateService.setDraggingItem(stateService.selectItem)
                     }
                 } else {
-                    const furniture = floorplanService.getFurniture(draggingItem.vectorId)
-                    mathUtil.clonePoint(furniture.center, position)
+                    const sign = floorplanService.getSign(draggingItem.vectorId)
+                    mathUtil.clonePoint(sign.center, position)
                 }
                 break
-            case LayerEvents.MoveFurniture:
+            case LayerEvents.MoveSign:
                 needAutoRedraw = true
-                const furniture = floorplanService.getFurniture(draggingItem.vectorId)
-                mathUtil.clonePoint(furniture.center, position)
+                const sign = floorplanService.getSign(draggingItem.vectorId)
+                mathUtil.clonePoint(sign.center, position)
                 break
         }
 
@@ -433,27 +413,6 @@ export default class Layer {
                 this.uiControl.currentUI = focusItem.type
                 this.history.save()
                 break
-            case LayerEvents.AddComponent:
-                focusItem = {
-                    vectorId: draggingItem.vectorId,
-                    type: draggingItem.type,
-                    cursor: { x: this.lastX, y: this.lastY },
-                }
-
-                stateService.setFocusItem(focusItem)
-                this.uiControl.showAttributes()
-                this.uiControl.currentUI = focusItem.type
-                this.history.save()
-                break
-            case LayerEvents.MoveComponent:
-                needAutoRedraw = true
-                if (focusItem != null && componentService.isComponent(focusItem.type)) {
-                    this.uiControl.currentUI = focusItem.type
-                    this.history.save()
-                } else {
-                    this.history.save()
-                }
-                break
             case LayerEvents.MoveTag:
                 needAutoRedraw = true
                 if (focusItem != null && focusItem.type == VectorType.Tag) {
@@ -476,7 +435,7 @@ export default class Layer {
                 this.history.save()
                 this.uiControl.currentUI = focusItem.type
                 break
-            case LayerEvents.AddFurniture:
+            case LayerEvents.AddSign:
                 focusItem = {
                     vectorId: draggingItem.vectorId,
                     type: draggingItem.type,
@@ -487,9 +446,9 @@ export default class Layer {
                 this.uiControl.currentUI = focusItem.type
                 this.history.save()
                 break
-            case LayerEvents.MoveFurniture:
+            case LayerEvents.MoveSign:
                 needAutoRedraw = true
-                if (focusItem != null && furnitureService.isFurniture(focusItem.type)) {
+                if (focusItem != null && signService.isSign(focusItem.type)) {
                     this.uiControl.currentUI = focusItem.type
                     this.history.save()
                 } else {
@@ -557,60 +516,7 @@ export default class Layer {
         }
     }
 
-    //点击左侧栏后，更新事件
-    updateEventNameForSelectUI() {
-        elementService.hideAll()
-        //正在添加tag的时候，需要先删除
-        const eventName = stateService.getEventName()
-        if (eventName == LayerEvents.AddTag) {
-            let item = stateService.getDraggingItem()
-            if (item && item.type == VectorType.Tag) {
-                floorplanService.deleteTag(item.vectorId)
-            }
-        }
-        stateService.clearItems()
-        if (this.uiControl.selectUI == UIEvents.Wall || this.uiControl.selectUI == UIEvents.OutWall) {
-            stateService.setEventName(LayerEvents.AddWall)
-        } else if (
-            this.uiControl.selectUI == UIEvents.SingleDoor ||
-            this.uiControl.selectUI == UIEvents.DoubleDoor ||
-            this.uiControl.selectUI == UIEvents.SlideDoor ||
-            this.uiControl.selectUI == UIEvents.SingleWindow ||
-            this.uiControl.selectUI == UIEvents.BayWindow ||
-            this.uiControl.selectUI == UIEvents.FrenchWindow ||
-            this.uiControl.selectUI == UIEvents.Pass
-        ) {
-            stateService.setEventName(LayerEvents.AddSymbol)
-        } else if (this.uiControl.selectUI == UIEvents.Beam || this.uiControl.selectUI == UIEvents.Flue || this.uiControl.selectUI == UIEvents.Corridor) {
-            stateService.setEventName(LayerEvents.AddComponent)
-        } else if (this.uiControl.selectUI == UIEvents.Tag) {
-            stateService.setEventName(LayerEvents.AddTag)
-        } else if (
-            this.uiControl.selectUI == UIEvents.TV ||
-            this.uiControl.selectUI == UIEvents.CombinationSofa ||
-            this.uiControl.selectUI == UIEvents.SingleSofa ||
-            this.uiControl.selectUI == UIEvents.TeaTable ||
-            this.uiControl.selectUI == UIEvents.Carpet ||
-            this.uiControl.selectUI == UIEvents.Plant ||
-            this.uiControl.selectUI == UIEvents.DiningTable ||
-            this.uiControl.selectUI == UIEvents.DoubleBed ||
-            this.uiControl.selectUI == UIEvents.SingleBed ||
-            this.uiControl.selectUI == UIEvents.Wardrobe ||
-            this.uiControl.selectUI == UIEvents.Dresser ||
-            this.uiControl.selectUI == UIEvents.BedsideCupboard ||
-            this.uiControl.selectUI == UIEvents.Pillow ||
-            this.uiControl.selectUI == UIEvents.GasStove ||
-            this.uiControl.selectUI == UIEvents.Cupboard ||
-            this.uiControl.selectUI == UIEvents.Bathtub ||
-            this.uiControl.selectUI == UIEvents.Closestool ||
-            this.uiControl.selectUI == UIEvents.Washstand ||
-            this.uiControl.selectUI == UIEvents.Desk ||
-            this.uiControl.selectUI == UIEvents.BalconyChair ||
-            this.uiControl.selectUI == UIEvents.Elevator
-        ) {
-            stateService.setEventName(LayerEvents.AddFurniture)
-        }
-    }
+    
 
     setEventName(eventType) {
         let eventName = stateService.getEventName()
@@ -624,12 +530,10 @@ export default class Layer {
                     stateService.setEventName(LayerEvents.MoveWall)
                 } else if (selectItem.type == VectorType.WallCorner) {
                     stateService.setEventName(LayerEvents.MoveWallPoint)
-                } else if (componentService.isComponent(selectItem.type)) {
-                    stateService.setEventName(LayerEvents.MoveComponent)
                 } else if (selectItem.type == VectorType.Tag) {
                     stateService.setEventName(LayerEvents.MoveTag)
-                } else if (furnitureService.isFurniture(selectItem.type)) {
-                    stateService.setEventName(LayerEvents.MoveFurniture)
+                } else if (signService.isSign(selectItem.type)) {
+                    stateService.setEventName(LayerEvents.MoveSign)
                 }
             } else if (eventName == LayerEvents.AddWall) {
                 stateService.setEventName(LayerEvents.AddingWall)
@@ -667,9 +571,9 @@ export default class Layer {
                     tagService.deleteTag(draggingItem.vectorId)
                     this.uiControl.currentUI = null
                 }
-            } else if (eventName == LayerEvents.AddFurniture) {
+            } else if (eventName == LayerEvents.AddSign) {
                 if (draggingItem && draggingItem.vectorId) {
-                    floorplanService.deleteFurniture(draggingItem.vectorId)
+                    floorplanService.deleteSign(draggingItem.vectorId)
                 }
             }
         } else {
@@ -681,9 +585,6 @@ export default class Layer {
     }
 
     setNewWallPoint(dir, position) {
-        if (listenLayer.symbolInfo.state == 'select') {
-            return false
-        }
         if (dir == 'start') {
             if (listenLayer.modifyPoint) {
                 addWall.setPointInfo(dir, listenLayer.modifyPoint)
@@ -711,8 +612,8 @@ export default class Layer {
                 floorplanService.deleteComponent(item.vectorId)
             } else if (item.type == VectorType.Tag) {
                 floorplanService.deleteTag(item.vectorId)
-            } else if (furnitureService.isFurniture(item.type)) {
-                floorplanService.deleteComponent(item.vectorId)
+            } else if (signService.isSign(item.type)) {
+                floorplanService.deleteSign(item.vectorId)
             } else if (item.type == VectorType.WallCorner) {
                 wallService.deleteWallCorner(item.vectorId)
             }

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

@@ -28,8 +28,8 @@ export default class ListenLayer {
             state: null,
         }
 
-        this.furnitureInfo = {
-            furnitureId: null,
+        this.signInfo = {
+            signsId: null,
             state: null,
         }
 
@@ -239,7 +239,7 @@ export default class ListenLayer {
             minWall: min2,
             componentInfo: {},
             tagInfo: {},
-            furnitureInfo: {},
+            signInfo: {},
         }
 
         if (_modifyPoint != null) {
@@ -282,13 +282,13 @@ export default class ListenLayer {
             }
         }
 
-        const furnitures = floorplanService.getFurnitures()
-        for (const furnitureId in furnitures) {
-            const furniture = floorplanService.getFurniture(furnitureId)
-            const location = furniture.isContain(position)
+        const signs = floorplanService.getSigns()
+        for (const signsId in signs) {
+            const sign = floorplanService.getSign(signsId)
+            const location = sign.isContain(position)
             if (location) {
-                result.furnitureInfo = {
-                    furnitureId: furnitureId,
+                result.signInfo = {
+                    signsId: signsId,
                     state: 'all',
                 }
                 break
@@ -365,16 +365,16 @@ export default class ListenLayer {
             state: nearest.tagInfo.state,
         }
 
-        const flag6 = this.isChanged(nearest.furnitureInfo.furnitureId, nearest.furnitureInfo.state, 6)
-        this.furnitureInfo = {
-            furnitureId: nearest.furnitureInfo.furnitureId,
-            state: nearest.furnitureInfo.state,
+        const flag6 = this.isChanged(nearest.signInfo.signsId, nearest.signInfo.state, 6)
+        this.signInfo = {
+            signsId: nearest.signInfo.signsId,
+            state: nearest.signInfo.state,
         }
 
-        return flag1 || flag2 || flag3 || flag4 || flag5 || flag6
+        return flag1 || flag2  || flag4 || flag5 || flag6
     }
 
-    // type是1表示点，2表示墙，3表示symbol，4表示component, 5表示tag，6表示furniture
+    // type是1表示点，2表示墙，3表示symbol，4表示component, 5表示tag，6表示sign
     isChanged(vectorId, state, type) {
         let flag = false
         if (type == 1) {
@@ -420,9 +420,9 @@ export default class ListenLayer {
                 flag = true
             }
         } else if (type == 6) {
-            if (state == null && state == this.furnitureInfo.state) {
+            if (state == null && state == this.signInfo.state) {
                 flag = false
-            } else if (this.furnitureInfo.furnitureId == vectorId && state == this.furnitureInfo.state) {
+            } else if (this.signInfo.signsId == vectorId && state == this.signInfo.state) {
                 flag = false
             } else {
                 flag = true
@@ -439,9 +439,9 @@ export default class ListenLayer {
         } else if (this.componentInfo.componentId != null && this.componentInfo.state != null) {
             const component = floorplanService.getComponent(this.componentInfo.componentId)
             stateService.setSelectItem(this.componentInfo.componentId, component.geoType, this.componentInfo.state)
-        } 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.signInfo.signsId != null && this.signInfo.state != null) {
+            const sign = floorplanService.getSign(this.signInfo.signsId)
+            stateService.setSelectItem(this.signInfo.signsId, sign.geoType, this.signInfo.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) {
@@ -467,8 +467,8 @@ export default class ListenLayer {
             state: null,
         }
 
-        this.furnitureInfo = {
-            furnitureId: null,
+        this.signInfo = {
+            signsId: null,
             state: null,
         }
 

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

@@ -2,7 +2,7 @@ import { floorplanService } from './Service/FloorplanService.js'
 import { wallService } from './Service/WallService.js'
 import { componentService } from './Service/ComponentService.js'
 import { tagService } from './Service/TagService'
-import { furnitureService } from './Service/FurnitureService'
+import { signService } from './Service/SignService'
 
 export default class Load {
     constructor(layer) {
@@ -15,7 +15,8 @@ export default class Load {
     }
 
     load(floorsData) {
-        if(!floorsData){
+        if(!floorsData||!floorsData.floors){
+            floorplanService.initFloor(0)
             return;
         }
         for (let i = 0; i < floorsData.length; ++i) {
@@ -47,9 +48,9 @@ export default class Load {
                 tag.setAdding(false)
             }
 
-            for (let key in floor.furnitures) {
-                let furniture = furnitureService.createFurniture(floor.furnitures[key].center, floor.furnitures[key].geoType, floor.furnitures[key].vectorId)
-                furniture.angle = floor.furnitures[key].angle
+            for (let key in floor.signs) {
+                let sign = signService.createSign(floor.signs[key].center, floor.signs[key].geoType, floor.signs[key].vectorId)
+                sign.angle = floor.signs[key].angle
             }
         }
     }

src/views/draw-file/board/editCAD/Renderer/Render.js

@@ -4,7 +4,7 @@ import { elementService } from '../Service/ElementService.js'
 import { coordinate } from '../Coordinate.js'
 import { draw } from './Draw.js'
 import { floorplanData } from '../FloorplanData.js'
-import { furnitureService } from '../Service/FurnitureService.js'
+import { signService } from '../Service/SignService.js'
 
 export default class Render {
     constructor(layer) {
@@ -60,8 +60,8 @@ export default class Render {
                 return
         }
 
-        if (furnitureService.isFurniture(vector.geoType)) {
-            draw.drawFurniture(vector)
+        if (signService.isSign(vector.geoType)) {
+            draw.drawSign(vector)
         }
     }
 
@@ -80,21 +80,6 @@ export default class Render {
         }
     }
 
-    drawPanos(panos) {
-        // const angle = floorplanService.getAngle()
-        // for (let i = 0; i < panos.length; ++i) {
-        //     let pano = JSON.parse(JSON.stringify(panos[i]))
-        //     //可能要旋转角度
-        //     pano = coordinate.getVectorForRotate(pano, angle)
-        //     draw.drawCircle(pano)
-        //     //draw.drawText(pano, pano.vectorId)
-        // }
-
-        for (let i = 0; i < panos.length; ++i) {
-            draw.drawCircle(panos[i])
-        }
-    }
-
     redrawElements() {
         if (elementService.vCheckLines.X && elementService.vCheckLines.X.display) {
             this.drawElement(elementService.vCheckLines.X)
@@ -158,9 +143,6 @@ export default class Render {
 
     autoRedraw() {
         draw.clear()
-        if (this.displayPanos) {
-            this.drawPanos(floorplanData.panos)
-        }
         let data = floorplanService.getFloorData()
         if (!data) {
             return
@@ -177,21 +159,9 @@ export default class Render {
 
         draw.drawSpecialPoint()
 
-        let symbols = data.symbols
-        for (let key in symbols) {
-            this.drawGeometry(symbols[key])
-            draw.drawSymbolPoint(symbols[key])
-        }
-        draw.drawSelectSymbolPoint()
-
-        let components = data.components
-        for (let key in components) {
-            this.drawGeometry(components[key])
-        }
-
-        let furnitures = data.furnitures
-        for (let key in furnitures) {
-            this.drawGeometry(furnitures[key])
+        let signs = data.signs
+        for (let key in signs) {
+            this.drawGeometry(signs[key])
         }
 
         let tags = data.tags
@@ -233,9 +203,9 @@ export default class Render {
             this.drawGeometry(components[key])
         }
 
-        let furnitures = data.furnitures
-        for (let key in furnitures) {
-            this.drawGeometry(furnitures[key])
+        let signs = data.signs
+        for (let key in signs) {
+            this.drawGeometry(signs[key])
         }
 
         let tags = data.tags
@@ -283,9 +253,9 @@ export default class Render {
             this.drawGeometry(components[key])
         }
 
-        let furnitures = data.furnitures
-        for (let key in furnitures) {
-            this.drawGeometry(furnitures[key])
+        let signs = data.signs
+        for (let key in signs) {
+            this.drawGeometry(signs[key])
         }
         let tags = data.tags
         for (let key in tags) {
@@ -323,9 +293,9 @@ export default class Render {
             this.drawGeometry(components[key])
         }
 
-        let furnitures = data.furnitures
-        for (let key in furnitures) {
-            this.drawGeometry(furnitures[key])
+        let signs = data.signs
+        for (let key in signs) {
+            this.drawGeometry(signs[key])
         }
     }
 

src/views/draw-file/board/editCAD/Service/AnalyService.js

@@ -25,7 +25,7 @@ export default class AnalyService {
             floorplanData.floors[floorNum].symbols = {}
             floorplanData.floors[floorNum].components = {}
             floorplanData.floors[floorNum].tags = {}
-            floorplanData.floors[floorNum].furnitures = {}
+            floorplanData.floors[floorNum].signs = {}
             floorplanData.floors[floorNum].boundingBox = {}
             floorplanData.floors[floorNum].rooms = []
             let minX = null,

src/views/draw-file/board/editCAD/Service/FloorplanService.js

@@ -273,11 +273,11 @@ export class FloorplanService {
         floorplanData.floors[floor].components[component.vectorId] = component
     }
 
-    addFurniture(furniture, floor) {
+    addSign(sign, floor) {
         if (floor == null || typeof floor == 'undefined') {
             floor = this.currentFloor
         }
-        floorplanData.floors[floor].furnitures[furniture.vectorId] = furniture
+        floorplanData.floors[floor].signs[sign.vectorId] = sign
     }
 
     deleteSymbol(symbolId, floor) {
@@ -305,20 +305,20 @@ export class FloorplanService {
         delete floorplanData.floors[floor].components[componentId]
     }
 
-    getFurniture(furnitureId, floor) {
+    getSign(signId, floor) {
         if (floor == null || typeof floor == 'undefined') {
             floor = this.currentFloor
         }
-        return floorplanData.floors[floor].furnitures[furnitureId]
+        return floorplanData.floors[floor].signs[signId]
     }
 
-    deleteFurniture(furnitureId, floor) {
+    deleteSign(signId, floor) {
         if (floor == null || typeof floor == 'undefined') {
             floor = this.currentFloor
         }
-        let furniture = this.getFurniture(furnitureId, floor)
-        furniture = null
-        delete floorplanData.floors[floor].furnitures[furnitureId]
+        let sign = this.getSign(signId, floor)
+        sign = null
+        delete floorplanData.floors[floor].signs[signId]
     }
 
     addTag(tag, floor) {
@@ -365,11 +365,11 @@ export class FloorplanService {
         return floorplanData.floors[floor].tags
     }
 
-    getFurnitures(floor) {
+    getSigns(floor) {
         if (floor == null || typeof floor == 'undefined') {
             floor = this.currentFloor
         }
-        return floorplanData.floors[floor].furnitures
+        return floorplanData.floors[floor].signs
     }
 
     getAllBoundingBox() {
@@ -466,7 +466,7 @@ export class FloorplanService {
             floorplanData.floors[this.currentFloor].symbols = {}
             floorplanData.floors[this.currentFloor].components = {}
             floorplanData.floors[this.currentFloor].tags = {}
-            floorplanData.floors[this.currentFloor].furnitures = {}
+            floorplanData.floors[this.currentFloor].signs = {}
             floorplanData.floors[this.currentFloor].boundingBox = {}
             floorplanData.floors[this.currentFloor].rooms = []
         }

src/views/draw-file/board/editCAD/Service/FurnitureService.js

@@ -1,170 +0,0 @@
-import VectorType from '../enum/VectorType.js'
-import Furniture from '../Geometry/Furniture.js'
-import { floorplanService } from './FloorplanService'
-import { Furnitures } from '../enum/UIEvents'
-
-export class FurnitureService {
-    constructor() {
-        this.$app = null
-        this.furnitures = null
-    }
-    fetchFurnitures() {
-        if (this.furnitures) {
-            return
-        }
-        this.furnitures = {}
-        for (let key in Furnitures) {
-            // 测试代码
-            if (key != Furnitures.TV) {
-                continue
-            }
-
-            this.$app.store
-                .getAppImage(`images/cad/furnitures/${Furnitures[key]}.svg`)
-                .then(img => {
-                    this.furnitures[Furnitures[key]] = img
-                    console.log(this.furnitures)
-                })
-                .catch(err => {
-                    console.error(err)
-                })
-        }
-    }
-
-    // 新建component
-    createFurniture(position, geoType, vectorId) {
-        let furniture = null
-        switch (geoType) {
-            case VectorType.TV:
-                furniture = new Furniture(position, vectorId, VectorType.TV)
-                break
-            case VectorType.CombinationSofa:
-                furniture = new Furniture(position, vectorId, VectorType.CombinationSofa)
-                break
-            case VectorType.SingleSofa:
-                furniture = new Furniture(position, vectorId, VectorType.SingleSofa)
-                break
-            case VectorType.TeaTable:
-                furniture = new Furniture(position, vectorId, VectorType.TeaTable)
-                break
-            case VectorType.Carpet:
-                furniture = new Furniture(position, vectorId, VectorType.Carpet)
-                break
-            case VectorType.Plant:
-                furniture = new Furniture(position, vectorId, VectorType.Plant)
-                break
-            case VectorType.DiningTable:
-                furniture = new Furniture(position, vectorId, VectorType.DiningTable)
-                break
-
-            case VectorType.DoubleBed:
-                furniture = new Furniture(position, vectorId, VectorType.DoubleBed)
-                break
-            case VectorType.SingleBed:
-                furniture = new Furniture(position, vectorId, VectorType.SingleBed)
-                break
-            case VectorType.Wardrobe:
-                furniture = new Furniture(position, vectorId, VectorType.Wardrobe)
-                break
-            case VectorType.Dresser:
-                furniture = new Furniture(position, vectorId, VectorType.Dresser)
-                break
-            case VectorType.BedsideCupboard:
-                furniture = new Furniture(position, vectorId, VectorType.BedsideCupboard)
-                break
-            case VectorType.Pillow:
-                furniture = new Furniture(position, vectorId, VectorType.Pillow)
-                break
-
-            case VectorType.GasStove:
-                furniture = new Furniture(position, vectorId, VectorType.GasStove)
-                break
-            case VectorType.Cupboard:
-                furniture = new Furniture(position, vectorId, VectorType.Cupboard)
-                break
-            case VectorType.Bathtub:
-                furniture = new Furniture(position, vectorId, VectorType.Bathtub)
-                break
-            case VectorType.Closestool:
-                furniture = new Furniture(position, vectorId, VectorType.Closestool)
-                break
-            case VectorType.Washstand:
-                furniture = new Furniture(position, vectorId, VectorType.Washstand)
-                break
-
-            case VectorType.Desk:
-                furniture = new Furniture(position, vectorId, VectorType.Desk)
-                break
-            case VectorType.BalconyChair:
-                furniture = new Furniture(position, vectorId, VectorType.BalconyChair)
-                break
-            case VectorType.Elevator:
-                furniture = new Furniture(position, vectorId, VectorType.Elevator)
-                break
-        }
-
-        floorplanService.addFurniture(furniture)
-        return furniture
-    }
-
-    isFurniture(geoType) {
-        switch (geoType) {
-            case VectorType.TV:
-                return true
-            case VectorType.CombinationSofa:
-                return true
-            case VectorType.SingleSofa:
-                return true
-            case VectorType.TeaTable:
-                return true
-            case VectorType.Carpet:
-                return true
-            case VectorType.Plant:
-                return true
-            case VectorType.DiningTable:
-                return true
-            case VectorType.DoubleBed:
-                return true
-            case VectorType.SingleBed:
-                return true
-            case VectorType.Wardrobe:
-                return true
-            case VectorType.Dresser:
-                return true
-            case VectorType.BedsideCupboard:
-                return true
-            case VectorType.Pillow:
-                return true
-            case VectorType.GasStove:
-                return true
-            case VectorType.Cupboard:
-                return true
-            case VectorType.Bathtub:
-                return true
-            case VectorType.Closestool:
-                return true
-            case VectorType.Washstand:
-                return true
-            case VectorType.Desk:
-                return true
-            case VectorType.BalconyChair:
-                return true
-            case VectorType.Elevator:
-                return true
-        }
-        return false
-    }
-
-    setFurnitureInfo(furnitureInfo) {
-        let furniture = floorplanService.getFurniture(furnitureInfo.vectorId)
-        furniture.vectorId = furnitureInfo.vectorId
-        furniture.angle = furnitureInfo.angle
-        furniture.center = JSON.parse(JSON.stringify(furnitureInfo.center))
-    }
-    getFurniture(name) {
-        return this.furnitures[name]
-    }
-}
-
-const furnitureService = new FurnitureService()
-export { furnitureService }

src/views/draw-file/board/editCAD/Service/StateService.js

@@ -1,7 +1,7 @@
 import VectorType from '../enum/VectorType.js'
 import SelectState from '../enum/SelectState.js'
 import { componentService } from './ComponentService.js'
-import { furnitureService } from './FurnitureService.js'
+import { signService } from './SignService.js'
 
 export default class StateService {
     constructor() {
@@ -39,7 +39,7 @@ export default class StateService {
             } else {
                 this.selectItem.selectIndex = state
             }
-        } else if (furnitureService.isFurniture(type)) {
+        } else if (signService.isSign(type)) {
             if (state == SelectState.Select) {
                 this.selectItem.selectIndex = SelectState.All
             }

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

@@ -18,13 +18,6 @@ const Style = {
         fillStyle: 'rgb(0, 200, 175)',
         radius: 4,
     },
-    Symbol: {
-        strokeStyle: 'rgba(255,255,255,1)',
-        fillStyle: 'rgba(255,255,255,0)',
-        lineWidth: 2,
-        //垭口
-        Pass: {},
-    },
     Component: {
         strokeStyle: 'rgba(255,255,255,1)',
         fillStyle: 'rgba(255,255,255,0)',
@@ -37,7 +30,7 @@ const Style = {
         fillStyle_adding: 'rgba(243, 255, 0, 0.8)',
         lineWidth: 1,
     },
-    Furniture: {
+    Sign: {
         strokeStyle: 'rgb(255,255,255,1)',
         fillStyle: 'rgba(0,0,0,0)',
         lineWidth: 1,
@@ -49,11 +42,6 @@ const Style = {
         Wall_out: {
             strokeStyle: 'rgba(243, 255, 0, 1)',
         },
-        Symbol: {
-            strokeStyle: 'rgba(243, 255, 0, 0.8)',
-            fillStyle: 'rgba(243, 255, 0, 0.5)',
-            lineWidth: 2,
-        },
         Component: {
             strokeStyle: 'rgba(243, 255, 0, 0.8)',
             fillStyle: 'rgba(243, 255, 0, 0.5)',
@@ -62,7 +50,7 @@ const Style = {
             strokeStyle: '#00C8AF',
             fillStyle: '#00C8AF',
         },
-        Furniture: {
+        Sign: {
             strokeStyle: 'rgba(243, 255, 0, 0.8)',
             fillStyle: 'rgba(243, 255, 0, 0.5)',
         },
@@ -77,13 +65,6 @@ const Style = {
         Wall: {
             strokeStyle: 'rgba(243, 255, 0, 1)',
         },
-        Wall_out: {
-            strokeStyle: 'rgba(162, 164, 124, 1)',
-        },
-        Symbol: {
-            strokeStyle: 'rgba(243, 255, 0, 0.8)',
-            fillStyle: 'rgba(243, 255, 0, 0.5)',
-        },
         Component: {
             strokeStyle: 'rgba(243, 255, 0, 0.8)',
             fillStyle: 'rgba(243, 255, 0, 0.5)',
@@ -92,7 +73,7 @@ const Style = {
             strokeStyle: '#00C8AF',
             fillStyle: '#00C8AF',
         },
-        Furniture: {
+        Sign: {
             strokeStyle: 'rgba(243, 255, 0, 0.8)',
             fillStyle: 'rgba(243, 255, 0, 0.5)',
         },
@@ -177,10 +158,6 @@ const Style = {
                     lineWidth: 6,
                 },
             },
-            Symbol: {
-                strokeStyle: '#666666',
-                lineWidth: 1,
-            },
             Component: {
                 strokeStyle: '#666666',
                 fillStyle: '#666666',
@@ -216,10 +193,6 @@ const Style = {
                     lineWidth: 6,
                 },
             },
-            Symbol: {
-                strokeStyle: '#FFFFFF',
-                lineWidth: 1,
-            },
             Component: {
                 strokeStyle: '#FFFFFF',
                 fillStyle: '#FFFFFF',
@@ -255,10 +228,6 @@ const Style = {
                     lineWidth: 6,
                 },
             },
-            Symbol: {
-                strokeStyle: '#666666',
-                lineWidth: 1,
-            },
             Component: {
                 strokeStyle: '#666666',
                 fillStyle: '#666666',
@@ -296,10 +265,6 @@ const Style = {
                     lineWidth: 6,
                 },
             },
-            Symbol: {
-                strokeStyle: '#FFFFFF',
-                lineWidth: 1,
-            },
             Component: {
                 strokeStyle: '#FFFFFF',
                 fillStyle: '#FFFFFF',

src/views/draw-file/board/editCAD/enum/HistoryEvents.js

@@ -7,21 +7,13 @@ const HistoryEvents = {
     DeleteWall: 'deleteWall',
     ModifyWall: 'modifyWall',
 
-    AddSymbol: 'addSymbol',
-    DeleteSymbol: 'deleteSymbol',
-    ModifySymbol: 'modifySymbol',
-
-    AddComponent: 'addComponent',
-    DeleteComponent: 'deleteComponent',
-    ModifyComponent: 'modifyComponent',
-
     AddTag: 'addTag',
     DeleteTag: 'deleteTag',
     ModifyTag: 'modifyTag',
 
-    AddFurniture: 'addFurniture',
-    DeleteFurniture: 'deleteFurniture',
-    ModifyFurniture: 'modifyFurniture',
+    AddSign: 'addSign',
+    DeleteSign: 'deleteSign',
+    ModifySign: 'modifySign',
 
     ModifyAngle: 'modifyAngle',
 }

src/views/draw-file/board/editCAD/enum/LayerEvents.js

@@ -5,28 +5,10 @@ const LayerEvents = {
     MoveWall: 'moveWall', //拖拽墙面
     MoveWallPoint: 'moveWallPoint', //拖拽墙角
 
-    AddComponent: 'addComponent',
-    MoveComponent: 'moveComponent',
-
     AddTag: 'addTag',
     MoveTag: 'moveTag',
 
-    // AddBeam: 'addBeam',
-    // AddFlue: 'addFlue',
-    // AddCorridor: 'addCorridor',
-
-    // MoveBeam: 'moveBeam',
-    // MoveFlue: 'moveFlue',
-    // MoveCorridor: 'moveCorridor',
-    // AddSingleDoor: 'addSingleDoor', //添加单开门
-    // MoveSingleDoor: 'moveSingleDoor', //移动单开门
-    // MoveSingleDoorPoint: 'moveSingleDoorPoint', //移动单开门的端点
-
-    // AddSingleWindow: 'addSingleWindow',
-    // MoveSingleWindow: 'moveSingleWindow',
-    // MoveSingleWindowPoint: 'moveSingleWindowPoint',
-
-    AddFurniture: 'addFurniture',
-    MoveFurniture: 'moveFurniture',
+    AddSign: 'addSign',
+    MoveSign: 'moveSign',
 }
 export default LayerEvents

src/views/draw-file/board/editCAD/enum/SelectState.js

@@ -3,23 +3,5 @@ const SelectState = {
     Start: 'start',
     End: 'end',
     Select: 'select',
-    /*,
-    focus: "focus",
-    selectArrow: "selectArrow", // beam,flue  focus后，选中下面的箭头
-    dragging: "dragging",
-    error: "error",
-    full: "full",
-    building: "building",
-    rotate: "rotate",
-    resize: "resize",
-    num1: 1,
-    num2: 2,
-    num3: 3,
-    num4: 4,
-    num5: 5,
-    num6: 6,
-    num7: 7,
-    num8: 8,
-    */
 }
 export default SelectState

src/views/draw-file/board/editCAD/enum/UIEvents.js

@@ -1,66 +1,21 @@
-const UIEvents = {
-    Wall: 'Wall',
-    OutWall: 'OutWall',
-    SingleDoor: 'SingleDoor',
-    DoubleDoor: 'DoubleDoor',
-    SlideDoor: 'SlideDoor',
-    SingleWindow: 'SingleWindow',
-    BayWindow: 'BayWindow',
-    FrenchWindow: 'FrenchWindow',
-    Pass: 'Pass',
-    Beam: 'Beam',
-    Flue: 'Flue',
-    Corridor: 'Corridor',
-    Tag: 'Tag', //这个是标注，暂时这样
-
-    TV: 'TV', //电视
-    CombinationSofa: 'CombinationSofa', //组合沙发
-    SingleSofa: 'SingleSofa', //单人沙发
-    TeaTable: 'TeaTable', //茶几
-    Carpet: 'Carpet', //地毯
-    Plant: 'Plant', //植物
-    DiningTable: 'DiningTable', //餐桌
-
-    DoubleBed: 'DoubleBed', //双人床
-    SingleBed: 'SingleBed', //单人床
-    Wardrobe: 'Wardrobe', //衣柜
-    Dresser: 'Dresser', //梳妆台
-    BedsideCupboard: 'BedsideCupboard', //床头柜
-    Pillow: 'Pillow', //抱枕
-
-    GasStove: 'GasStove', //燃气灶
-    Cupboard: 'Cupboard', //橱柜
-    Bathtub: 'Bathtub', //浴缸
-    Closestool: 'Closestool', //马桶
-    Washstand: 'Washstand', //洗漱台
-
-    Desk: 'Desk', //书桌
-    BalconyChair: 'BalconyChair', //阳台椅
-    Elevator: 'Elevator', //电梯
+const UIEvents = { 
+    Wall: 'Wall',           //折线
+    Tag: 'Tag',             //这个是标注，暂时这样
+    Table:'Table',          //表格
+    Rectangle:'Rectangle',
+    Circle:'Circle',
+    Arrow:'Arrow',
+    Icon:'Icon',
 }
 
-export const Furnitures = {
-    TV: UIEvents.TV, //电视
-    CombinationSofa: UIEvents.CombinationSofa, //组合沙发
-    SingleSofa: UIEvents.SingleSofa, //单人沙发
-    TeaTable: UIEvents.TeaTable, //茶几
-    Carpet: UIEvents.Carpet, //地毯
-    Plant: UIEvents.Plant, //植物
-    DiningTable: UIEvents.DiningTable, //餐桌
-    DoubleBed: UIEvents.DoubleBed, //双人床
-    SingleBed: UIEvents.SingleBed, //单人床
-    Wardrobe: UIEvents.Wardrobe, //衣柜
-    Dresser: UIEvents.Dresser, //梳妆台
-    BedsideCupboard: UIEvents.BedsideCupboard, //床头柜
-    Pillow: UIEvents.Pillow, //抱枕
-    GasStove: UIEvents.GasStove, //燃气灶
-    Cupboard: UIEvents.Cupboard, //橱柜
-    Bathtub: UIEvents.Bathtub, //浴缸
-    Closestool: UIEvents.Closestool, //马桶
-    Washstand: UIEvents.Washstand, //洗漱台
-    Desk: UIEvents.Desk, //书桌
-    BalconyChair: UIEvents.BalconyChair, //阳台椅
-    Elevator: UIEvents.Elevator, //电梯
+export const Signs = {
+    Cigaret: UIEvents.Cigaret,                  //烟头
+    FirePoint: UIEvents.FirePoint,              //起火点
+    FootPrint: UIEvents.FootPrint,              //脚印
+    ShoePrint: UIEvents.ShoePrint,              //鞋印
+    FingerPrint: UIEvents.FingerPrint,          //指纹
+    DeadBody: UIEvents.DeadBody,                //尸体
+    BloodStain: UIEvents.BloodStain,            //血迹
 }
 
 export default UIEvents

src/views/draw-file/board/editCAD/enum/VectorType.js

@@ -2,45 +2,13 @@ const VectorType = {
     Point: 'Point',
     WallCorner: 'WallCorner',
     Wall: 'Wall',
-    SingleDoor: 'SingleDoor',
-    DoubleDoor: 'DoubleDoor',
-    SlideDoor: 'SlideDoor',
-
-    SingleWindow: 'SingleWindow',
-    BayWindow: 'BayWindow',
-    FrenchWindow: 'FrenchWindow',
-    Pass: 'Pass',
-
-    Beam: 'Beam',
-    Flue: 'Flue',
-    Corridor: 'Corridor',
-    Line: 'Line',
-
     Tag: 'Tag',
-
-    TV: 'TV', //电视
-    CombinationSofa: 'CombinationSofa', //组合沙发
-    SingleSofa: 'SingleSofa', //单人沙发
-    TeaTable: 'TeaTable', //茶几
-    Carpet: 'Carpet', //地毯
-    Plant: 'Plant', //植物
-    DiningTable: 'DiningTable', //餐桌
-
-    DoubleBed: 'DoubleBed', //双人床
-    SingleBed: 'SingleBed', //单人床
-    Wardrobe: 'Wardrobe', //衣柜
-    Dresser: 'Dresser', //梳妆台
-    BedsideCupboard: 'BedsideCupboard', //床头柜
-    Pillow: 'Pillow', //抱枕
-
-    GasStove: 'GasStove', //燃气灶
-    Cupboard: 'Cupboard', //橱柜
-    Bathtub: 'Bathtub', //浴缸
-    Closestool: 'Closestool', //马桶
-    Washstand: 'Washstand', //洗漱台
-
-    Desk: 'Desk', //书桌
-    BalconyChair: 'BalconyChair', //阳台椅
-    Elevator: 'Elevator', //电梯
+    Cigaret: 'Cigaret',                  //烟头
+    FirePoint: 'FirePoint',              //起火点
+    FootPrint: 'FootPrint',              //脚印
+    ShoePrint: 'ShoePrint',              //鞋印
+    FingerPrint: 'FingerPrint',          //指纹
+    DeadBody: 'DeadBody',                //尸体
+    BloodStain: 'BloodStain',            //血迹
 }
 export default VectorType