three-dimensional-covert/service/PanoBoxFrame.js

import * as THREE from 'three'
import math from './util/math.js'
import common from './util/common.js' 
import BoundingMesh from './util/BoundingMesh.js'
import Vectors from './util/Vectors.js'
 
const version = 'output'
 
const convertTool = {
    getQuaByAim: function (aim, center=new THREE.Vector3, forward=new THREE.Vector3(0, 0, -1)){ //z朝上的坐标系是  forward = new THREE.Vector3(0, 1, 0)
        let qua1 = new THREE.Quaternion().setFromUnitVectors(forward, aim.clone().sub(center).normalize())
        //或var _ = (new THREE.Matrix4).lookAt(pano.position, aim, new THREE.Vector3(0,1,0));  aimQua = (new THREE.Quaternion).setFromRotationMatrix(_);
        return qua1
    },
}

//----------------------复制以下内容--------------------------------- 

let player,
    skyBoxTight,
    meshGroup,
    modelBound = new THREE.Box3(),
    ray = new THREE.Raycaster(),
    groundPlane = new THREE.Plane()
let groundY, safeBound, boundConfirmed //安全区域应该在扣除每种类型柜子大概的长宽的一半
let hue = 0,
    startTime
const MinBoxInitialScore = 0.68 //找不到匹配时，若box分数低于该值，不createSinglePano
let boxesSolid = []
  

let standards = {
    cabinet: {
        widthNormal: { min: 0.55, max: 0.65 }, //widthNormal是不计宽还是厚度的平均宽度  //个别场景如S9yepREK8Jl 宽0.8米
        height: { min: 0.3, max: 2.5, standard: 2 },
        closeRatio: 0.7, //数值越小越容易findRest。一般在墙上的位置不准要设置大些，扎堆放置的设置小些
    },
    fire: {
        widthNormal: { min: 0.12, max: 0.16 },
        height: { min: 0.4, max: 0.58 },
        widthSame: true, //长宽相等
        closeRatio: 4,
        tinyXZ: true, //可以通过它近似确定地面高度
    },
    air: {
        widthNormal: { min: 0.35, max: 0.7 },
        width: { min: 0.48, max: 0.75 }, //因为总是斜着放所以范围较大
        thick: { min: 0.33, max: 0.5 },
        height: { min: 1.2, max: 2.2, standard: 1.8 },
        atWall: 0.8,
        closeRatio: 1.1,
    },
    airSmart: {
        widthNormal: { min: 0.35, max: 0.7 },
        width: { min: 0.48, max: 0.75 }, //因为总是斜着放所以范围较大
        thick: { min: 0.33, max: 0.5 },
        height: { min: 1.2, max: 2.2, standard: 1.8 },
        atWall: 0.8,
        closeRatio: 1.1,
    },

    'air-hanging': {
        widthNormal: { min: 0.3, max: 1 },
        width: { min: 0.8, max: 1.1 },
        thick: { min: 0.2, max: 0.3 },
        height: { min: 0.3, max: 0.5, standard: 0.4 }, //standard是通常出现的最高高度. 有这个值的在离地的时候直接使用该高度
        bottom: { min: 0.8, max: 2.0 }, // 不绝对，大部分
        atWall: 1, //在墙壁的可能性
        closeRatio: 1.5,
    },

    battery: {
        widthNormal: { min: 0.45, max: 1.35 },
        width: { min: 0.7, max: 1.4 },
        thick: { min: 0.35, max: 0.5 },
        height: { min: 0.3, max: 2.5 }, //maxHeight
        //有的电池很小。考虑是否追加battery-little 并且限制大电池的长宽高比例
        atWall: 0.9,
        closeRatio: 0.9,
    },

    groundBar: {
        widthNormal: { min: 0.06, max: 0.4 },
        width: { min: 0.3, max: 0.5 },
        thick: { min: 0.05, max: 0.08 },
        height: { min: 0.1, max: 0.2 },
        bottom: { min: 1.2, max: 3 },
        atWall: 1,
        closeRatio: 2,
    },
    hlkcWindow: {
        widthNormal: { min: 0.08, max: 0.5 },
        width: { min: 0.35, max: 0.5 },
        thick: { min: 0.03, max: 0.06 },
        height: { min: 0.35, max: 0.5 },
        bottom: { min: 1.2, max: 3 },
        atWall: 1,
        closeRatio: 2,
    },
    electric: {
        widthNormal: { min: 0.2, max: 0.7 },
        width: { min: 0.5, max: 0.65 },
        thick: { min: 0.2, max: 0.3 },
        height: { min: 0.5, max: 1 }, //maxHeight   4GqaqNdyjGf一米高
        bottom: { min: 0.8, max: 1.8 },
        atWall: 1,
        closeRatio: 2,
    },
    monitor: {
        widthNormal: { min: 0.08, max: 0.11 },
        height: { min: 0.1, max: 0.2, standard: 0.15 }, //maxHeight
        bottom: { min: 1.2, max: 3 },
        atWall: 1,
        closeRatio: 4,
        tiny: true, //因为较小且无方向，所以近似一个点，用射线算出的位置比墙面还准，所以其最终位置可用于expandModelBound
    },
    rowBigBox: {
        widthNormal: { min: 0.55, max: Infinity },
        height: { min: 0.7, max: 2.4, standard: 2 },
    },
    /*"cabling-wall":{ 
    },
     "cabling-ceil":{ 
        atCeil:1
    } */
}

/* const typeNames = { 
    cabinet : 'cabinet',  //标准机柜 
    air : 'air',                   //普通空调柜式 
    battery : 'battery',    //蓄电池组 
}
 */
const typeNames = {
    fire: 'extinguisher', //灭火器
    monitor: 'surveillance_camera', //监控摄像机  放第一个，用于继续确定边界
    hlkcWindow: 'hlkc', //馈线窗
    groundBar: 'grounding_bar', //接地排

    cabinet: 'equipment_cabinet', //标准机柜
    battery: 'accumulator', //蓄电池组
    /* ac : 'ac_switchboard',          //交流配电柜         //这两种合并，因为差别太小了，见QlJau21WP8G的，在全景图两侧识别的竟然一个ac一个dc
    dc : 'dc_distribution',      //直流配电设备 */

    electric: ['ac_switchboard', 'dc_distribution'],

    air: 'sdkt', //普通空调柜式
    airSmart: 'ventilation_installation', //智能通风设备

    //cabling : 'cabling_rack',   //单层走线架    因为在天花板的走线有点复杂，经常断开，无法确定方向所以放弃
}
/* const typeNamesReverse = {} //为了方便访问
for(let i in typeNames){
    typeNamesReverse[typeNames[i]] = i
} 
 */

let addLine = (origin, dir, len, color) => {
    if (version != 'vision') return
    var line1 = LineDraw.createLine([origin, origin.clone().add(dir.clone().multiplyScalar(len || 1))], { color })
    //console.log(origin.toArray(), dir.toArray())
    meshGroup.add(line1)
    return line1
}

let addLabel = (pos, text, { bgcolor, a } = {}) => {
    if (version != 'vision') return
    let shift = new THREE.Vector3(0, -0.2, 0)
    bgcolor = bgcolor ? new THREE.Color(bgcolor) : { r: 1, g: 1, b: 1 }
    //let endPos = new THREE.Vector3().addVectors(pos,shift);
    text instanceof Array || (text = [text])

    let lineCount = Math.round(Math.random() * 6) + 1
    let lines = []
    while (lineCount-- > 0) {
        lines.push('|')
    }
    text = [...text, ...lines, 'o']

    let textMesh = new TextSprite({
        text,
        textColor: { r: 0, g: 0, b: 0, a: 1 },
        backgroundColor: { r: bgcolor.r * 255, g: bgcolor.g * 255, b: bgcolor.b * 250, a: a || 0 },
        textBorderColor: { r: bgcolor.r * 255, g: bgcolor.g * 255, b: bgcolor.b * 250, a: a || 0.9 },
        textBorderThick: 2,
        margin: { x: 0, y: 0 },
        borderRadius: 0,
        player: player,
        sizeInfo: { minSize: 90, maxSize: 300, nearBound: 1, farBound: 7 },
    })
    textMesh.position.copy(pos)
    //textMesh.scale.set(0.3, 0.3, 0.3)
    meshGroup.add(textMesh)
    textMesh.sprite.position.y += textMesh.sprite.scale.y * 0.4

    return textMesh
}

let getBoxFinalPos = info => {
    //创建solidbox时的position
    let position
    let center = getBoxPos(info)
    if (standards[info.boxType].bottom) {
        //悬挂
        position = center
    } else {
        position = center.clone().setY(groundY + info.size.y / 2) //使着地
    }
    return position
}

const axises = [
    new THREE.Vector3(-1, 1, -1),
    new THREE.Vector3(1, 1, -1),
    new THREE.Vector3(1, 1, 1),
    new THREE.Vector3(-1, 1, 1),
    new THREE.Vector3(-1, -1, -1),
    new THREE.Vector3(1, -1, -1),
    new THREE.Vector3(1, -1, 1),
    new THREE.Vector3(-1, -1, 1),
]

let traverse = (info, fun) => {
    //忽略.infos的row 的信息
    fun(info)
    info.list && info.list.forEach(a => traverse(a, fun))
    info.mixedFrom && info.mixedFrom.forEach(a => traverse(a, fun))
}

class Box {
    //结果
    constructor(info) {
        //preDealBox(info)
        this.setFromInfo(info)
        this.name = this.boxType + '-' + this.name
        if (version == 'vision' && boundConfirmed) this.draw()

        boxesSolid.push(this)
    }

    setFromInfo(info) {
        for (let i in info) {
            this[i] = info[i]
        }

        /* let h = info.size.y
        let standardH = standards[info.boxType].height.standard
        if (h > standardH) {
            h = standardH + Math.log(1 + (h - standardH) / 2) //Math.log2: 以2为底的对数  ,Math.log:自然对数
            info.size.y = h
        } */

        this.position = getBoxFinalPos(this)
        let bound = new THREE.Box3().setFromCenterAndSize(this.position, this.size)
        this.bound = bound
        
        
        
        
        
        
        
    }

    draw() {
        hue += 0.23
        var color = new THREE.Color().setHSL(hue, 0.9, 0.85)

        this.boxHelper = new THREE.Box3Helper(this.bound, color)
        this.boxHelper.material.depthTest = false
        this.boxHelper.material.transparent = true
        this.boxHelper.renderOrder = 30

        /*  let { warnStr, exStr } = this
        warnStr && (exStr += `【${warnStr}】`) */

        this.label = addLabel(this.position, /* exStr ? [this.name, exStr] :  */ this.score ? [this.name, this.score.toFixed(1)] : this.name, { bgcolor: color })

        meshGroup.add(this.boxHelper)
    }

    dispose() {
        let index = boxesSolid.indexOf(this)
        if (index > -1) {
            boxesSolid.splice(index, 1)
            if (version == 'vision' && boundConfirmed) {
                this.label.sprite.material.opacity = 0.3
                this.boxHelper.material.opacity = 0.2
            }
        }
    }

    traversePair(fun) {
        traverse(this, fun)
    }


    getDirection(){//获得正面朝向。  需要全部box都创建完再调用
           
        let xProp = this.xProp
        let dir 
        //哪边pano多朝哪边
        
        
        if(this.boxType == 'cabinet' && this.name.includes('row')){
            if(this.infos.box.length>1){
                let k = this.infos.reduce((w,c)=>{return w+c.k},0)
                xProp = k>1 ? 'width' : 'thick' 
            }else{ //直接使用别的多box的row的方向 ，大多数都相同(会有例外，无所谓了)
                let rows = boxesSolid.filter(e=>e.boxType == 'cabinet' && e.name.includes('row'))
                rows.sort((a,b)=>b.infos.box.length - a.infos.box.length) 
                let box = rows[0] 
                if(box){
                    return  this.dirQua = box.dirQua 
                } 
            }
        }
        
        if(!xProp){//根据房间的长宽 散落的cabinet。   fire monitor
        
            let {xWidthPossible, yWidthPossible} = getBoxDirProp(this,true)
            xProp = this.xProp
            /* if(Math.abs(xWidthPossible - yWidthPossible) < 0.3){
                let size = new THREE.Vector3()
                safeBound.getSize(size)
                
                xWidthPossible += (size.x - size.z) * 0.5
                 
                if(xWidthPossible > yWidthPossible){ 
                    xProp = 'width'
                }
            } */
            
            
        }
        
        if(xProp){
            
            if(!this.panosDir)  getPanosDir(this)
            
            if(xProp == 'width'){
                 
                if (Math.abs(this.panosDir['z+']) < Math.abs(this.panosDir['z-'])) {//朝-z//也就是新坐标系的y
                    //this.dirQua='下' 
                    dir = new THREE.Vector3(0,1,0)
                }else{//朝+z
                    //this.dirQua='上' 
                    dir = new THREE.Vector3(0,-1,0)
                }
            }else{
                if (Math.abs(this.panosDir['x+']) < Math.abs(this.panosDir['x-'])) {//朝-x
                    //this.dirQua='右' 
                    dir = new THREE.Vector3(-1,0,0)
                }else{//朝+x
                     //this.dirQua='左' 
                     dir = new THREE.Vector3(1,0,0)
                }
            }
        } 
        //addLabel(this.position, this.dirQua)
          
            
        this.dirQua = convertTool.getQuaByAim(dir, new THREE.Vector3, new THREE.Vector3(0,1,0)) 
        return   this.dirQua 
        
        
      /*飞到俯视图查看（不旋转视图，x朝右，z朝下）。以下四个qua是四个墙壁每个墙壁上的dirQua。 
      
                                     _x: 0, _y: -0, _z: 1, _w: 0 
    

        _x: 0, _y: 0, _z: -0.707, _w: 0.707                    _x: 0, _y: -0, _z: 0.707, _w: 0.707


                                    x: 0, _y: 0, _z: 0, _w: 1
                             
     */
        
    }

    toJson() {//转出的坐标系是z朝上的
        let category = typeNames[this.boxType]
        if (category instanceof Array) {
            let scoreMap = new Map()
            category = category.slice(0)
            category.forEach(e => scoreMap.set(e, 0)) //初始化
            //判断boxType: 寻找所使用的box总分最高的boxType
            let add = box => {
                if (!box) return
                let score = scoreMap.get(box.category) + box.score
                scoreMap.set(box.category, score)
            }
            this.traversePair(e => {
                add(e.box0)
                add(e.box1)
            })
            category = category.sort((a, b) => {
                return scoreMap.get(b) - scoreMap.get(a)
            })
            category = category[0] //最高分
        }
         
        this.getDirection()

        let json = {
            points: axises.map(axis => math.invertVisionVector(new THREE.Vector3().addVectors(this.position, this.size.clone().multiply(axis).multiplyScalar(0.5))).toArray()),
            category,
            type: this.boxType,
            sid: this.name,
            quaternion:this.dirQua.toArray()
        }
        return json
    }
}

// 2d坐标转3d坐标
let getDirByUV = (uv, pano) => {
    // 计算方向向量

    let yaw = -uv.x * (Math.PI * 2)
    let pitch = Math.PI / 2 - uv.y * Math.PI

    let dir = new THREE.Vector3()
    dir.copy(Vectors.RIGHT).applyAxisAngle(Vectors.BACK, pitch).applyAxisAngle(Vectors.UP, yaw).applyQuaternion(pano.quaternion)

    return dir
}
let getCenterDir = box => {
    if (box.centerDir) return

    //假设不存在在box中间拍摄的情况，所以y不会横跨两边
    let bbox = box.bbox2
    let center = { x: getBbox2center(bbox[0], bbox[2]), y: (bbox[1] + bbox[3]) / 2 }
    box.bbox2CenterX = center.x

    let dir = getDirByUV(center, box.pano)
    box.centerDir = dir

    let centerTop = { x: center.x, y: bbox[1] }
    box.centerTopDir = getDirByUV(centerTop, box.pano)

    let centerBtm = { x: center.x, y: bbox[3] }
    box.centerBtmDir = getDirByUV(centerBtm, box.pano)

    let leftBtm = { x: bbox[0], y: bbox[3] }
    box.leftBtmDir = getDirByUV(leftBtm, box.pano)
    let rightBtm = { x: bbox[2], y: bbox[3] }
    box.rightBtmDir = getDirByUV(rightBtm, box.pano)
}

let getOtherPos = box => {
    if (!box.boxType) return

    let config = standards[box.boxType]
    if (!boundConfirmed) {
        if (!config.bottom) {
            ray.set(box.pano.position, box.centerBtmDir)
            box.btmPosPredict = ray.ray.intersectPlane(groundPlane, new THREE.Vector3()) //没有的话就在空中 (部分air-hanging也会有)。 fire的这个值会较大误差，因为groundY还不确定，但不影响，因只用它射线交点的位置。

            if (box.btmPosPredict) {
                let dir2d = new THREE.Vector2(box.centerBtmDir.x, box.centerBtmDir.z).normalize()
                let { min, max } = standards[box.boxType].widthNormal
                min = min * 0.4
                max = max * 0.4

                let minA = Math.min(Math.abs(dir2d.x), Math.abs(dir2d.y))
                const depth = math.linearClamp(minA, 0, 1, min, max)

                /* const depth = box.category == typeNames.cabinet ? 0.5 : 0.4
                 */
                dir2d = dir2d.clone().multiplyScalar(depth)

                box.btmPosPredict.x += dir2d.x
                box.btmPosPredict.z += dir2d.y
                //addLabel(box.btmPosPredict,'b_'+box.category+"_"+box.sid, {bgcolor:'#6ff',a:0.1})
                //box.btmPosPredict.clamp(safeBound.min, safeBound.max)
            }
        }
        return
    }

    if (!box.posAtWall && config.atWall > 0) {
        //console.log(box.sid, 'getPosWall')
        const shrink = config.thick ? config.thick.min : config.widthNormal.min
        ray.set(box.pano.position, box.centerDir)
        let o = ray.intersectObjects([skyBoxTight])
        if (o[0]) box.posAtWall = new THREE.Vector3().addVectors(box.pano.position, box.centerDir.clone().multiplyScalar(o[0].distance - shrink))

        //因墙壁不准确，所以还是尽量不用墙的位置
        /* if(box.btmPos){
            let wallRatio = 0.5;
            if(new THREE.Vector3().subVectors(box.btmPos,  box.posAtWall).setY(0).length() > 1  )wallRatio = 0.2 //可能墙壁位置不准，靠后了
            box.predictCenter = new THREE.Vector3().addVectors(box.btmPos.clone().multiplyScalar(1-wallRatio), box.posAtWall.clone().multiplyScalar(wallRatio))
            //box.predictCenter = new THREE.Vector3().addVectors(box.posAtWall, box.btmPos).multiplyScalar(0.5) //也许能当中心点？ 虽然y会低一些
            addLabel(box.predictCenter, box.sid+'-preC')
        } */
    }

    if (!box.btmPos) {
        getBoxBtm(box)
    }

    if (!box.topPos) {
        getBoxTop(box)
    }
}

let getUVs = box => {
    if (box.bbox2) return
    let uvs = []
    box.bbox2 = box.bbox.map((e, i) => {
        return i % 2 == 0 ? e / 4096 /*   + 0.25 */ : e / 2048
    })
}

let getBoxBase = box => {
    getBoxType(box)
    getUVs(box)
    getCenterDir(box)
    getOtherPos(box)
}
let getBbox2Diff = (x1, x2) => {
    //获取x1-x2，如果x1在x2右边则为正
    if (Math.abs(x1 - x2) < 0.5) return x1 - x2
    else {
        if (x1 > x2) x1 -= 1
        else x2 -= 1
        return x1 - x2
    }
}

let getBbox2center = (x1, x2) => {
    //找中间位置
    if (Math.abs(x1 - x2) > 0.5) {
        //永远找小于180度的那一边
        return (x1 + x2 + 1) / 2 //另外半边
    } else {
        return (x1 + x2) / 2
    }
}

let getBoxTop = info => {
    /* if(info.sid == 'pano0-11(mix4,8)'){
        console.log(5)
    } */

    if (info.box1) {
        let o2 = getIntersect2(info.box0.pano.position, info.box0.centerTopDir, info.box1.pano.position, info.box1.centerTopDir)
        info.topPos = o2.pos3d
        info.diffHeight = o2.mid2 ? o2.mid2.distanceTo(o2.mid1) : 1

        if (info.box0.topPos && info.box1.topPos) {
            info.topPos.y = (info.box0.topPos.y + info.box1.topPos.y) / 2 //原先的不准
        }
    } else {
        //取btm上方对应的位置 ( 因为和skybox的交点会因离墙远而偏上或偏下)
        let box = info.box0 || info

        let btm = box.btmPos
        if (!btm) {
            btm = getBoxBtm(info)
        }
        box.topPos = btm.clone() //xz同btm，要求y

        let xDelta = btm.x - box.pano.position.x
        let zDelta = btm.z - box.pano.position.z
        let yDelta
        //因为pano有旋转所以btm和top的xz其实是不一样的，所以会有误差。 故这里选择delta较大的
        if (Math.abs(xDelta) < Math.abs(zDelta)) {
            yDelta = (zDelta * box.centerTopDir.y) / box.centerTopDir.z
            /*  console.log('use z', box)
            if(Math.abs(xDelta)<0.1)console.error('!!!!!!!!!!!!!!!!!!!!!!! xDelta',xDelta, box.sid  ) */
        } else {
            yDelta = (xDelta * box.centerTopDir.y) / box.centerTopDir.x
            // console.log('use x', box)
        }

        box.topPos.y = yDelta + box.pano.position.y
        let minHeight = /* info.boxType ? standards[info.boxType].height.min : box.category == typeNames.air ? 0.5 : */ standards[getBoxType(box)].height.min
        let diffH = Math.max(box.topPos.y - btm.y, minHeight)
        box.topPos.y = btm.y + diffH
        info.topPos = box.topPos
        /* if (box.sid == 'pano2-1') {
            addLabel(box.topPos,'t_'+box.sid,{bgcolor:'#ff4399'})
            addLine(box.pano.position,box.centerTopDir, 20)
        }   */
    }
    return info.topPos
}

let getBoxBtm = info => {
    if (info.box1) {
        let o2 = getIntersect2(info.box0.pano.position, info.box0.centerBtmDir, info.box1.pano.position, info.box1.centerBtmDir)
        info.btmPos = o2.pos3d
        //info.btmPos.y = (info.box0.btmPos.y + info.box1.btmPos.y)/2   //原先的不准
    } else {
        let box = info.box0 || info
        if (!box.btmPos) {
            if (box.sid == 'pano0-7') {
                console.log(3)
                addLine(box.pano.position, box.centerBtmDir, 20)
            }
            if (!boundConfirmed) {
                return box.btmPosPredict
            }
            ray.set(box.pano.position, box.centerBtmDir)
            let o = ray.intersectObjects([skyBoxTight]) //如果skybound有问题，位置就会错
            box.btmPosOri = o[0].point.clone()

            let depth //缩进 //let depth = Math.abs(o[0].face.normal.y) > 0.9 ? 0.4 : -0.4
            getBoxType(box)

            let dir2d = new THREE.Vector2(box.centerBtmDir.x, box.centerBtmDir.z).normalize()

            if (standards[box.boxType].thick && standards[box.boxType].atWall /* box.boxType == 'battery' */) {
                //平贴于墙上，且厚度和宽度相差较大
                //注：air-hanging主要用的是posAtWall

                let { min, max } = standards[box.boxType].widthNormal
                min = min * 0.3
                max = max * 0.5

                if (!box.xProp) getBoxDirProp(box)
                if (box.xProp == 'width') {
                    depth = math.linearClamp(Math.abs(dir2d.x), 0, 1, min, max)
                } else {
                    depth = math.linearClamp(Math.abs(dir2d.y), 0, 1, min, max)
                }
            } else {
                let w = standards[box.boxType].thick || standards[box.boxType].widthNormal
                let w0 = (w.min + w.max) / 2
                let min = w0 * 0.5,
                    max = w0 * 0.8

                let minA = Math.min(Math.abs(box.centerBtmDir.x), Math.abs(box.centerBtmDir.z))
                depth = math.linearClamp(minA, 0, 0.707, min /* 0.3 */, max /* 0.5 */) //在45度时需要最长的距离。主要针对cabinet
            }

            if (Math.abs(o[0].face.normal.y) < 0.9) {
                if (standards[box.boxType].atWall || o[0].point.y - groundY > 0.3) {
                    //battery的识别框比较乱，有可能一个电池被识别出好几个，所以
                    depth *= -1 //at wall
                }
            }

            let dir2d1 = dir2d.clone().multiplyScalar(depth)
            box.btmPos = o[0].point.clone()
            box.btmPos.x += dir2d1.x
            box.btmPos.z += dir2d1.y

            //addLabel(box.btmPos,'b_'+box.sid,{bgcolor:'#ff4399'})
        }
        info.btmPos = box.btmPos
    }
    return info.btmPos
}

let getIntersect = (pano0Pos, dir0, pano1Pos, dir1) => {
    let pos0 = new THREE.Vector3().addVectors(pano0Pos, dir0)
    let pos1 = new THREE.Vector3().addVectors(pano1Pos, dir1)
    /* var {pos3d, mid1, mid2, behind} = math.getLineIntersect({ A: pano0Pos.clone(), B: pano1Pos.clone(), p1: pos0, p2: pos1 })
     */ //三维线若接近平行，算出的交点可能很近，不是实际应该无交点才对
    var pos2d = math.isLineIntersect(
        [
            { x: pano0Pos.x, y: pano0Pos.z },
            { x: pos0.x, y: pos0.z },
        ],
        [
            { x: pano1Pos.x, y: pano1Pos.z },
            { x: pos1.x, y: pos1.z },
        ],
        true
    ) //优先考虑水平面方向的交点
    if (pos2d) {
        let y0 = ((pos2d.x - pano0Pos.x) * dir0.y) / dir0.x + pano0Pos.y
        let y1 = ((pos2d.x - pano1Pos.x) * dir1.y) / dir1.x + pano1Pos.y
        //console.log(y1-y0)
        let pos3d = new THREE.Vector3(pos2d.x, (y0 + y1) / 2, pos2d.y)
        return { pos3d, diffHeight: Math.abs(y0 - y1) } //diffHeight越小越好
    }
}

//究竟哪个比较准 - - 可能两个都判断？
let getIntersect2 = (pano0Pos, dir0, pano1Pos, dir1) => {
    let pos0 = new THREE.Vector3().addVectors(pano0Pos, dir0)
    let pos1 = new THREE.Vector3().addVectors(pano1Pos, dir1)
    let o = math.getLineIntersect2({ A: pano0Pos.clone(), B: pano1Pos.clone(), p1: pos0, p2: pos1, dir0, dir1 }) //不用getLineIntersect，因为这个针对热点写的，当无交点时选用的点不是想要的
    if (!o.pos3d) {
        console.error('getIntersect2 no result? ?')
    }
    return o
}

let getBoxPos = info => {
    let boxType = getBoxType(info)
    return (
        (info.preDealRes && info.preDealRes.position) ||
        info.center ||
        (boxType && (standards[boxType].atWall > 0.5 && standards[boxType].bottom ? info.posAtWall : info.btmPos || info.btmPosPredict)) ||
        info.posAtWall
    )
}

let isType = (box, type) => {
    return typeNames[type] instanceof Array ? typeNames[type].includes(box.category) : typeNames[type] == box.category
}

let getBoxType = info => {
    if (info.boxType) return info.boxType

    let category = info.category || info.box0.category
    if (category == 'rowBigBox') info.boxType = 'rowBigBox'
    else {
        let type
        if (category == 'ac_switchboard') {
            console.log(1)
        }
        for (let i in typeNames) {
            if (typeNames[i] instanceof Array ? typeNames[i].includes(category) : typeNames[i] == category) {
                type = i
                break //type = typeNamesReverse[type]
            }
        }
        /* if(type == 'ac' || type == 'dc'){
            type = 'electric'  //合并
        }  */

        info.boxType = type
    }
    return info.boxType
}
/* let getBoxType = info => {
    let type = info.category || info.box0.category
 

    if (type == 'air') {
        let btm = info.btmPos || info.btmPos //btmPosAtWall
        if (!btm) {
            btm = getBoxBtm(info)
        }
        if (!btm) return

        let center = info.posAtWall || (info.preDealRes && info.preDealRes.position) || info.center
        const s = standards['air-hanging']

        if (btm.y - groundY > s.bottom.min) {
            let h0 = btm.y - groundY
            let h1 = (modelBound.max.y - center.y) / (modelBound.max.y - modelBound.min.y)
            let h2 = center.y - btm.y
            let score = h0 * 2 - h1 * 3 - h2 * 3
            if (score > 0) {
                type = 'air-hanging'
            }
            //console.error( score,  h0,h1,h2, info.sid||info.name)
        } //注意：如果air被遮住底部，露出的部分只有一点，还是有可能被识别成air-hanging。只能希望
        //console.error( type,  info.sid||info.name)
    }
    if (info.box0) {
        info.boxType = type
        //info.box1 && (info.box1.type = type) //因为box0和box1不一定匹配，所以不能直接赋值
    } else {
        info.type = type
    }
} */
let getPanosDir = (info, center) =>{
    center = center || getBoxPos(info)
    let dirs = { 'x+': 0, 'x-': 0, 'z+': 0, 'z-': 0, got: false }
    let getDirs = () => {
        //靠墙的在它到墙之间是不会有漫游点的
        if (dirs.got || !center) return
        player.model.panos.list.forEach(pano => {
            let dir = new THREE.Vector3().subVectors(pano.position, center)
            if (dir.x > 0) {
                dirs['x+'] += dir.x
            } else {
                dirs['x-'] += dir.x
            }
            if (dir.z > 0) {
                dirs['z+'] += dir.z
            } else {
                dirs['z-'] += dir.z
            }
        })
        dirs.got = true
    }
    getDirs()
    if(info.panosDir){
        console.error('already has dir')
    }
    
    info.panosDir = dirs
    
        
    return dirs
    
}
let getBoxDirProp = (info, force) => {
    //仅适用于方形单个房间房间，不可以是多边形、两个房间
    let xProp, yProp

    if (info.name == 'pano10-8&pano12-6') {
        console.log(4)
    }

    //if (info.boxType == 'battery' || info.boxType == 'air-hanging' || info.boxType == 'air' || info.category == 'battery' || info.category == 'air') {
    if (standards[info.boxType].atWall && standards[info.boxType].thick || force ) {
        //根据比例判断
        /* let r1 = Math.abs((center.x - skyBoxTight.position.x) / (center.z - skyBoxTight.position.z))
        let r2 = player.model.size.x / player.model.size.z 
        if(!math.closeTo(r1,r2, 0.05)){
            if (r1<r2) { 
                ;(xProp = 'width'), (yProp = 'thick') //贴附x（横）墙
            } else {
                ;(xProp = 'thick'), (yProp = 'width') //贴附y（竖）墙
            } 
            matchInfo.xProp = xProp
            matchInfo.yProp = yProp
        } */
        //根据距离判断

        let center = getBoxPos(info)
        let bound = safeBound
        let minXDiff = Math.min(center.x - bound.min.x, bound.max.x - center.x)
        let minYDiff = Math.min(center.z - bound.min.z, bound.max.z - center.z)
        
        let dirs = getPanosDir(info, center)
        
        let noX = dirs['x+'] == 0 || dirs['x-'] == 0,
            noZ = dirs['z+'] == 0 || dirs['z-'] == 0

        //yi6dsPTWwFM klkcWindow pano0-1&pano2-0
        if (dirs['x+'] == 0 && dirs['x-'] != 0) {
            minXDiff = bound.max.x - center.x
        } else if (dirs['x-'] == 0 && dirs['x+'] != 0) {
            minXDiff = center.x - bound.min.x
        }
        if (dirs['z+'] == 0 && dirs['z-'] != 0) {
            minYDiff = bound.max.z - center.z
        } else if (dirs['z-'] == 0 && dirs['z+'] != 0) {
            minYDiff = center.z - bound.min.z
        }
        

        let xWidthPossible = noZ ? 1 : 0,
            yWidthPossible = noX ? 1 : 0
        xWidthPossible += minXDiff - minYDiff

        if (!math.closeTo(xWidthPossible, yWidthPossible, 0.2) && (minXDiff < 0.7 || minYDiff < 0.7)) {
            if (xWidthPossible < yWidthPossible) {
                ;(xProp = 'thick'), (yProp = 'width') //贴附y（竖）墙
            } else {
                ;(xProp = 'width'), (yProp = 'thick') //贴附x（横）墙
            }
        }

        if (!xProp) { 
            if(!force){//force的话是fire等无方向的类型
                if (info.category) {
                    //是box
                    info.pose || (info.pose = getBoxPoseByPos(info, center))
                    xWidthPossible += info.pose.xWidthPossible
                    yWidthPossible += info.pose.yWidthPossible
                } else {
                    traverse(info, info => {
                        if (info.boxposes) {
                            //是matchInfo
                            info.boxposes.forEach(e => {
                                xWidthPossible += e.xWidthPossible
                                yWidthPossible += e.yWidthPossible
                            })
                        }
                    })
                }

            }
            /* if(noX!=noZ){
                if(noX)xWidthPossible
            } */

            if (xWidthPossible > yWidthPossible) {
                ;(xProp = 'width'), (yProp = 'thick') //贴附x（横）墙
            } else {
                ;(xProp = 'thick'), (yProp = 'width') //贴附y（竖）墙
            }
        }

        xProp && ((info.xProp = xProp), (info.yProp = yProp))
        
         
        return {xWidthPossible, yWidthPossible}
         
           
        
    }
}

let preDealBox = matchInfo => {
    if (matchInfo.preDealRes || !matchInfo.center) return
    matchInfo.preDealRes = {}

    matchInfo.boxType || getBoxType(matchInfo)
    let config = standards[matchInfo.boxType]
    let minWidth = config.widthNormal.min
    let needGetPose
    let dis = safeBound.distanceToPoint(matchInfo.center)
    if (matchInfo.name == 'pano2-5') {
        console.log(4)
    }
    if (dis > 0.3 && !config.tiny && !config.tinyXZ) {
        //Tmo1vLp9Q13: hlkcWindow超出才准确
        //tiny的位置优先级高于bound，因为他们可以确定bound

        /* matchInfo.str && matchInfo.str.includes('outsideBound') */
        //const shrink = minWidth * 0.85
        //addLabel(matchInfo.center, '原')
        let finalPos = matchInfo.center.clone().clamp(safeBound.min, safeBound.max)
        matchInfo.preDealRes.position = finalPos
        //addLabel(finalPos, 'finalPos')
        getBoxType(matchInfo)

        needGetPose = true
    }
    let center = getBoxPos(matchInfo)
    if (needGetPose || !matchInfo.boxposes) {
        matchInfo.boxposes = []
        ;[matchInfo.box0, matchInfo.box1].forEach(box => {
            box && matchInfo.boxposes.push(getBoxPoseByPos(box, center))
        })
    }

    //-----------------

    getBoxDirProp(matchInfo)
}

let getBoxPoseByPos = (box, centerPos, addDis = 0) => {
    //当得知box的大概位置时，求box在这个角度上的宽度、朝向
    //在这个方向看的box的宽度
    let config = standards[box.boxType]
    let angle = getBbox2Diff(box.bbox2[2], box.bbox2[0]) * Math.PI //角度的一半
    let dis = new THREE.Vector3().subVectors(box.pano.position, centerPos).setY(0).length() + addDis
    let projectWidth = 2 * Math.tan(angle) * dis //投影宽度  （准确的投影宽度无法求得，只能近似）

    let camDir = /* new THREE.Vector2(centerPos.x-box.pano.position.x, centerPos.z-box.pano.position.z).normalize() */ box.centerDir.clone().setY(0).normalize()
    let camTangent = math.getNormal({
        points: [
            { x: 0, y: 0 },
            /* camDir */ { x: camDir.x, y: camDir.z },
        ],
    }) //视线切线方向

    camTangent.x = Math.abs(camTangent.x)
    camTangent.y = Math.abs(camTangent.y)

    if (box.sid == 'pano4-6') {
        console.log(7)
    }

    const maxWidth = config.widthNormal.max
    const minWidth = config.widthNormal.min

    let minProjectWidth //= (camTangent.x + camTangent.y) * minWidth
    let maxProjectWidth //= (camTangent.x + camTangent.y) * maxWidth
    let maxX, maxY, minX, minY
    if (!standards[box.boxType].thick) {
        minProjectWidth = (camTangent.x + camTangent.y) * minWidth
        maxProjectWidth = (camTangent.x + camTangent.y) * maxWidth //该角度下该类型允许的最大投影距离

        maxX = THREE.MathUtils.clamp((projectWidth - minWidth * camTangent.y) / camTangent.x, minWidth, maxWidth) //可得x的最大值(假设y为最小值)
        maxY = THREE.MathUtils.clamp((projectWidth - minWidth * camTangent.x) / camTangent.y, minWidth, maxWidth) //可得y的最大值(假设x为最小值)
        minX = THREE.MathUtils.clamp((projectWidth - maxWidth * camTangent.y) / camTangent.x, minWidth, maxWidth) //可得x的最小值(假设y为最大值)
        minY = THREE.MathUtils.clamp((projectWidth - maxWidth * camTangent.x) / camTangent.y, minWidth, maxWidth) //可得y的最小值(假设x为最大值)
    } else {
        const minThick_ = config.thick.min
        const minWidth_ = config.width.min
        const maxThick_ = config.thick.max
        const maxWidth_ = config.width.max
        let maxProjectWidth1 = camTangent.x * maxWidth_ + camTangent.y * maxThick_
        let maxProjectWidth2 = camTangent.x * maxThick_ + camTangent.y * maxWidth_
        let minProjectWidth1 = camTangent.x * minWidth_ + camTangent.y * minThick_
        let minProjectWidth2 = camTangent.x * minThick_ + camTangent.y * minWidth_

        minProjectWidth = Math.min(minProjectWidth1, minProjectWidth2)
        maxProjectWidth = Math.max(maxProjectWidth1, maxProjectWidth2)

        let a = (camTangent.x + camTangent.y) * maxWidth
        //console.log('diffaaaaaa',maxProjectWidth,a, box.sid)
        maxX = THREE.MathUtils.clamp((projectWidth - minThick_ * camTangent.y) / camTangent.x, minThick_, maxWidth_) //可得x的最大值(假设y为最小值)
        maxY = THREE.MathUtils.clamp((projectWidth - minThick_ * camTangent.x) / camTangent.y, minThick_, maxWidth_) //可得y的最大值(假设x为最小值)
        minX = THREE.MathUtils.clamp((projectWidth - maxWidth_ * camTangent.y) / camTangent.x, minThick_, maxWidth_)
        minY = THREE.MathUtils.clamp((projectWidth - maxWidth_ * camTangent.x) / camTangent.y, minThick_, maxWidth_)
    }

    /* 
    let maxX = projectWidth / camTangent.x //可得x的最大值(假设y为0)
    let maxY = projectWidth / camTangent.y //可得y的最大值(假设x为0)
     */

    //判断方向
    let o = { box, projectWidth, camTangent, maxProjectWidth, minProjectWidth, dis, maxX, maxY, minX, minY }
    if (config.atWall > 0 /* isType(box,battery) || isType(box,air)   */) {
        //为了获取朝向
        o.xWidthPossible = -Math.abs(projectWidth - camTangent.x * maxWidth - camTangent.y * minWidth)
        o.yWidthPossible = -Math.abs(projectWidth - camTangent.x * minWidth - camTangent.y * maxWidth)
        //在接近45度时容易不准。另外如果被遮住一部分更会错，因此尽量不让被遮住的匹配
    }
    return o
}

let getPoseScore = (boxposes, boxType) => {
    let score = 0
    const minDis = 1.5
    /* if (boxposes[0].box.sid == 'pano12-13' && boxposes[1].box.sid == 'pano8-6') {
        console.log(4)
    }  */
    boxposes.forEach(pose => {
        //pose.lowR = pose.dis < minDis ? Math.pow(THREE.MathUtils.smoothstep(pose.dis / minDis, 0, 1),2) : 1 //太近的话误差大
        pose.lowR = pose.dis < minDis ? Math.pow(pose.dis / minDis, 1.4) : 1 //太近的话误差大

        if (pose.projectWidth > pose.maxProjectWidth) {
            score += Math.pow((pose.projectWidth / pose.maxProjectWidth - 1) * pose.lowR, 2) * 500 //超过的话数字较大所以乘的数小一些
        } else if (/* isSingle &&  */ pose.projectWidth < pose.minProjectWidth) {
            score += Math.pow((pose.minProjectWidth / pose.projectWidth - 1) * pose.lowR, 2) * 500
        }

        let { min, max } = standards[boxType].widthNormal
        if ((standards[boxType].atWall == 1 && min < 0.3) || (boxposes.length == 2 && boxType == 'battery')) {
            let { min, max } = standards[boxType].widthNormal
            //let r = Math.max(0.001, (pose.projectWidth - min) / (max - min))
            let diff = max - min
            let r = math.linearClamp(pose.projectWidth, min, min + diff * 0.5, 600, 0)

            //if(boxposes.length == 2 && boxType == 'battery'){//由于battery经常出现遮挡，导致方向出错，因此尽量不匹配projectWidth较短的，尽管这本有可能是对的
            score += r
            //}
            /* if (min < 0.3 && r < 0.5) {
                //从贴近墙面的位置看侧面的话，容易被挡住，不准，尤其是电箱
                score += ((max - min) / r / min) * 5
            } */
        }
    })
    score = Math.min(score, 1300) //压低一点，因为得的宽度可能不准

    if (boxposes.length == 2) {
        //每一个方向对应有四个方向（每个象限一个）看到的projectWidth应该接近。

        //先把camTangent转化为第一个象限的
        let camTangent0 = new THREE.Vector2(Math.abs(boxposes[0].camTangent.x), Math.abs(boxposes[0].camTangent.y))
        let camTangent1 = new THREE.Vector2(Math.abs(boxposes[1].camTangent.x), Math.abs(boxposes[1].camTangent.y))

        let a = camTangent0.dot(camTangent1)
        if (a > 0.8) {
            //WcLVXvmV9AU
            //0.9:   25度之内.  0.8:   36.8度之内
            let diff = Math.abs(boxposes[0].projectWidth - boxposes[1].projectWidth)
            boxposes.score2 = a * diff * 1300 * boxposes[0].lowR * boxposes[1].lowR
            score += boxposes.score2
            //console.warn('在同一个方向看到的projectWidth应该接近。 ', diff)
        }
        boxposes.camTangentCos = a
    }
    //要不要加上minX等的差距？

    score = Math.min(score, 1200)
    return -score
}

let getBoxSize = info => {
    if (info.boxType == 'groundBar') {
        console.log(1)
    }

    if (info.size) return
    //console.warn('开始算 ' + info.name)
    let exStr = '',
        warnStr = ''
    let x, y //求对角线的向量 x>0,y>0
    //假设盒子的长宽为x,y (x>0,y>0)，视线切线单位向量为(k,m)，投影距离:x'k+y'm.（x'是正负x，y'是正负y）
    //由于盒子的对角线有四个可选方向,(类似四个象限)  则需要能使投影距离最长的一个对角线向量。
    //如，当k<0,m>0时，要使xk+ym 最大，必有x<0,y>0.  故 x = -x'， y = y', 故 投影距离:x'k+y'm = x(-k)+ym 。
    //故无论km的符号如何，只要变为正数，再去联立方程即可得xy。(相当于切线转到第一象限)

    //注：但是因为无法获取准确的投影距离(角平分线左右两边的端点到角平分线的距离不相等，垂足也无法确定)，所以所算的误差非常大。
    if (info.name == 'pano6-13&pano4-13') {
        console.log(6)
    }
    let center = getBoxPos(info)
    let oriX, oriY

    if (info.predictSize) {
        ;(x = oriX = info.predictSize.x), (y = oriY = info.predictSize.y)
    } else {
        if (info.box1) {
            let x1 = info.boxposes[0].camTangent.x,
                x2 = info.boxposes[1].camTangent.x,
                y1 = info.boxposes[0].camTangent.y,
                y2 = info.boxposes[1].camTangent.y,
                w1 = /* info.boxposes[0].projectWidth, */ THREE.MathUtils.clamp(info.boxposes[0].projectWidth, info.boxposes[0].minProjectWidth, info.boxposes[0].maxProjectWidth * 1.1), //校准。如果projectwidth不准那算出来更不准. 但XswQxwmn2ZC的里侧电池是前者更准
                w2 = /* info.boxposes[1].projectWidth */ THREE.MathUtils.clamp(info.boxposes[1].projectWidth, info.boxposes[1].minProjectWidth, info.boxposes[1].maxProjectWidth * 1.1)
            //如果识别到柜门上，（柜体被遮住了），整体中心就会在柜门上，且厚度小于真实值。

            if (x1 == 0) {
                y = w1
                x = (w2 - y2 * y) / x2
            } else {
                //联立方程得：

                y = (w2 - (x2 / x1) * w1) / (y2 - (x2 / x1) * y1)
                x = (w1 - y1 * y) / x1
            }

            //console.log('xy', { x, y })
            ;(x < 0.3 || x > 1.4) && (exStr += ' x:' + math.toPrecision(x, 2))
            ;(y < 0.3 || y > 1.4) && (exStr += ' y:' + math.toPrecision(y, 2))

            if (y < 0 || x < 0) {
                //console.log('<0 ?????????')
                warnStr = x < 0 ? 'x<0！' : 'y<0！'
            }
            ;(oriX = x), (oriY = y)
        } else {
            //single pano data
            //将maxX maxY 限定在标准范围内
            if (info.xProp) {
                let widthValue = standards[info.boxType].width
                let thickValue = standards[info.boxType].thick
                let maxX, maxY, minX, minY
                if (info.xProp == 'width') {
                    /*  x = oriX = THREE.MathUtils.clamp(info.boxposes[0].maxX, widthValue.min, widthValue.max)
                    y = oriY = THREE.MathUtils.clamp(info.boxposes[0].maxY, thickValue.min, thickValue.max)
                     */
                    maxX = THREE.MathUtils.clamp(info.boxposes[0].maxX, widthValue.min, widthValue.max) //AG0bi2fhb3 需要将得到的minX等这四项都clamp后再平均
                    maxY = THREE.MathUtils.clamp(info.boxposes[0].maxY, thickValue.min, thickValue.max)
                    minX = THREE.MathUtils.clamp(info.boxposes[0].minX, widthValue.min, widthValue.max)
                    minY = THREE.MathUtils.clamp(info.boxposes[0].minY, thickValue.min, thickValue.max)
                } else {
                    /*  x = oriX = THREE.MathUtils.clamp(info.boxposes[0].maxX, thickValue.min, thickValue.max)
                    y = oriY = THREE.MathUtils.clamp(info.boxposes[0].maxY, widthValue.min, widthValue.max)
                    */
                    maxX = THREE.MathUtils.clamp(info.boxposes[0].maxX, thickValue.min, thickValue.max)
                    maxY = THREE.MathUtils.clamp(info.boxposes[0].maxY, widthValue.min, widthValue.max)
                    minX = THREE.MathUtils.clamp(info.boxposes[0].minX, thickValue.min, thickValue.max)
                    minY = THREE.MathUtils.clamp(info.boxposes[0].minY, widthValue.min, widthValue.max)
                }
                x = oriX = (maxX + minX) / 2
                y = oriY = (maxY + minY) / 2
            } else {
                //x = oriX = y = oriY = (min+max)/2
                let standard = standards[info.boxType].widthNormal
                x = oriX = THREE.MathUtils.clamp(info.boxposes[0].maxX, standard.min, standard.max)
                y = oriY = THREE.MathUtils.clamp(info.boxposes[0].maxY, standard.min, standard.max)
            }
        }

        //按正常来说，得到的x,y都应>0,但是由于箱子会被遮挡，导致投影宽度比真实的小，算出的也不准，可能是负数
        //所以手动将过小的宽度矫正
    }

    /* if(info.name == "pano2-6"){
        console.log(7)
    } */

    let height
    if (standards[info.boxType].bottom) {
        //悬挂的
        //挂式空调最好把长宽固定。 不过极少出错
        //center.y -= 0.1 //很可能过高
        height = standards[info.boxType].height.standard
        getBoxBtm(info)
        if (height) {
            let d = center.y - info.btmPos.y
            center.y -= THREE.MathUtils.clamp((d - height / 2) / 2, -0.1, 0.1) //如果中心点到底部的距离和height的一半不同，中心点移动差值的一半
        } else {
            let btmY = info.btmPos.y
            /* let ys = [info.btmPos.y]//info.btmPos.y蛮不准的
            if(info.box0){
                ys.push(info.box0.btmPos.y)
            }
            if(info.box1){
                ys.push(info.box1.btmPos.y)
            }
            btmY = ys.reduce((w,c)=>{return w+c},0)
            btmY/=ys.length //平均 */

            height = (center.y - btmY) * 2
        }
    } else {
        if (!info.topPos) getBoxTop(info)

        height = info.topPos.y - groundY
    }

    let o = restrictSize(x, height, y, info)
    ;(x = o.x), (height = o.y), (y = o.z)

    if (standards[info.boxType].widthSame) {
        x = y = (x + y) / 2
    }

    info.size = new THREE.Vector3(x, height, y)

    info.sizeAdjust = Math.pow(Math.abs(x - oriX), 1.3) + Math.pow(Math.abs(y - oriY), 1.3) //计算得到的值和标准值之间的差距，可以反映该info的匹配分值

    if (info.sizeAdjust) info.score = (info.score || 0) - Math.min(info.sizeAdjust * 100, 400)
    ;(info.size.oriX = oriX), (info.size.oriY = oriY)
    ;(info.exStr = exStr), (info.warnStr = warnStr)
}

let restrictSize = (x, y, z, info) => {
    let s

    let { xProp, yProp } = info
    if (xProp != void 0) {
        var { min, max } = standards[info.boxType][xProp]
        x = THREE.MathUtils.clamp(x, min, max)
        var { min, max } = standards[info.boxType][yProp]
        z = THREE.MathUtils.clamp(z, min, max)
        s = true
    }

    if (!s) {
        var { min, max } = standards[info.boxType].widthNormal
        x = THREE.MathUtils.clamp(x, min, max)
        z = THREE.MathUtils.clamp(z, min, max)
    }

    var { min, max } = standards[info.boxType].height
    y = THREE.MathUtils.clamp(y, min, max)

    return { x, y, z }
}

let getMixBox = (box0, box1) => {
    //重叠部分
    let box = new THREE.Box2()
    box.min.set(Math.max(box0.min.x, box1.min.x), Math.max(box0.min.y, box1.min.y))
    box.max.set(Math.min(box0.max.x, box1.max.x), Math.min(box0.max.y, box1.max.y))
    return box
}

let getLeftRight = boxArr => {
    //获取pano的boxes中最左和最右的bbox.x
    let lefts = boxArr.map(e => e.bbox2[0])
    let rights = boxArr.map(e => e.bbox2[2])
    lefts.sort((a, b) => getBbox2Diff(a, b))
    rights.sort((a, b) => getBbox2Diff(b, a))
    let leftX = lefts[0] //最左
    let rightX = rights[0] //最右
    return {
        leftX,
        rightX,
    }
}

let searchPair = (beginItem, group0_, group1_, parentPairs, resultPairs) => {
    let pair = [] //只能是来自group0的
    if (parentPairs) {
        //元结点裂变出多个，来装新的pair
        let i = resultPairs.indexOf(parentPairs)
        resultPairs.splice(i, 1)
    }

    for (let j = 0; j < group1_.length; j++) {
        pair = [beginItem, group1_[j]]
        let newPairs //用来存放该组pair
        if (parentPairs) {
            newPairs = parentPairs.slice(0) //复制
            newPairs.push(pair)
        } else {
            newPairs = [pair] //新的容器
        }
        resultPairs.push(newPairs)

        let newGroup0 = group0_.slice(0)
        let newGroup1 = group1_.slice(0)
        let index = newGroup0.indexOf(pair[0])
        newGroup0.splice(index, 1)
        index = newGroup1.indexOf(pair[1])
        newGroup1.splice(index, 1)

        if (newGroup0.length > 0 && newGroup1.length > 0) {
            searchPair(newGroup0[0], newGroup0, newGroup1, newPairs, resultPairs)
        }
    }
}

export default class PanoBoxFrame extends THREE.Group {
    constructor(player_, ifAnalyze, dataList) {
        super()
        player = player_
        player.model.add(this)
        this.ifAnalyze = ifAnalyze
        this.wireframes = new THREE.Object3D()
        this.wireframes.name = 'wireframes'
        this.add(this.wireframes)
        this.matchScoreMap = {}
        this.bindEvents()

        meshGroup = new THREE.Object3D()
        meshGroup.name = 'testBox'
        this.add(meshGroup)

        this.compute(dataList)
    }

    async compute(dataList) {
        startTime = Date.now()
        this.datas = {}
        this.datasMixed = {}
        this.boxesSolid = boxesSolid

        let compu = 0
        let beginCompute = () => {
            //获取匹配分数
            let getMatchScore = (box0, box1, { isSingle, center, onlyGet, dontCheckDis } = {}) => {
                let name0 = box0.sid + '&' + box1.sid
                let name1 = box1.sid + '&' + box0.sid
                let boxType = getBoxType(box0)
                let matchInfo0 = this.matchScoreMap[boxType][name0]
                let matchInfo1 = this.matchScoreMap[boxType][name1]
                let matchInfo = matchInfo0 || matchInfo1
                if (onlyGet) return matchInfo
                let name
                if (!matchInfo) {
                    name = name0
                    matchInfo = { name, box0, box1, center }
                    this.matchScoreMap[boxType][name] = matchInfo
                } else {
                    return matchInfo
                }
                if (name == 'pano6-9&pano8-4') {
                    console.log(5)
                }
                getBoxBase(box0)
                getBoxBase(box1)

                let A = box0.pano.position.clone()
                let B = box1.pano.position.clone()
                let AB = new THREE.Vector3().subVectors(B, A)
                let AB2d = new THREE.Vector2(AB.x, AB.z).normalize()

                let AP12d = center ? new THREE.Vector2(center.x - A.x, center.z - A.z).normalize() : new THREE.Vector2(box0.centerDir.x, box0.centerDir.z).normalize()
                let BP22d = center ? new THREE.Vector2(center.x - B.x, center.z - B.z).normalize() : new THREE.Vector2(box1.centerDir.x, box1.centerDir.z).normalize()
                let angleA = Math.acos(AB2d.dot(AP12d))
                let angleB = Math.PI - Math.acos(AB2d.dot(BP22d))
                let score = 100,
                    str = []

                if (angleA + angleB > Math.PI + 0.2) {
                    //无交点（比180大是因为中心角度有误差，所以给一定的容错）
                    //console.log(`${panoId0}的第${box0.index}个与${panoId1}的第${box1.index}个因角度大于180度 不匹配`)
                    return Object.assign(matchInfo, { score: -5000, str: ['angle>180'] })
                }
                if (box0.type != box1.type) {
                    return Object.assign(matchInfo, { score: -5000, str: ['typeNotSame'] })
                }
                if (matchInfo.dirAngleXZ == void 0) {
                    matchInfo.dirAngleXZ = THREE.MathUtils.radToDeg(Math.acos(AP12d.dot(BP22d))) //需要尽量接近90度算出来的交点会比较准
                    matchInfo.minAng = Math.min(180 - matchInfo.dirAngleXZ, matchInfo.dirAngleXZ) //角度小的getIntersect2容易算不准
                    if (isSingle) {
                        let bestDisSquared = 2
                        //单个匹配单个，而非多个匹配多个(没有固定到两个漫游点)，所以可以直接寻找最优角度
                        score += Math.sin(THREE.MathUtils.degToRad(matchInfo.dirAngleXZ)) * 300
                        score += matchInfo.dirAngleXZ //另外角度越大越不容易偏向一边
                        score -= Math.abs(getBoxPos(box0).distanceToSquared(box0.pano.position) - bestDisSquared) * 10
                        score -= Math.abs(getBoxPos(box1).distanceToSquared(box1.pano.position) - bestDisSquared) * 10
                    }
                }

                let shinkRatio = 1
                let btmPos0 = box0.btmPos || box0.btmPosPredict //fire类型先用btmPosPredict，测定groundY后才有btmPos
                let btmPos1 = box1.btmPos || box1.btmPosPredict

                if (!dontCheckDis) {
                    //let r = box0.boxType == 'air' ? 1 : box0.boxType == 'cabinet' ? 0.9 : 0.7 //随着宽度增加而降低
                    let r = THREE.MathUtils.clamp(0.8 / standards[boxType].widthNormal.max, 0.6, 2) //随着宽度增加而降低  UWrshepp0G5的fire

                    if (!standards[boxType].bottom && btmPos0 && btmPos1) {
                        //注：挂空调不应使用btmPosPredict
                        let d = btmPos0.distanceToSquared(btmPos1)
                        matchInfo.btmPosPreDis = d
                        score -= d * 1300 * r * shinkRatio

                        if (box1.topPos) {
                            let a = box0.topPos.distanceToSquared(box1.topPos)
                            matchInfo.topPosPreDis = a
                            let u = a * 700 * r * shinkRatio

                            let AP0 = new THREE.Vector2(btmPos0.x - A.x, btmPos0.z - A.z).lengthSq()
                            let AP1 = new THREE.Vector2(btmPos1.x - B.x, btmPos1.z - B.z).lengthSq()
                            if (AP0 < 0.4 || AP1 < 0.4) u *= 0.3 //太近
                            score -= u
                        }
                    } else if (box0.posAtWall && box1.posAtWall) {
                        //
                        let d = box0.posAtWall.distanceToSquared(box1.posAtWall)
                        matchInfo.wallPosPreDis = d
                        score -= d * 200 * r //墙面不准所以分低 ftMTQIrs79

                        d = box0.btmPosOri.distanceToSquared(box1.btmPosOri) //还是加一下
                        matchInfo.btmPosPreDis = d
                        score -= d * 200 * r * shinkRatio

                        /* let h0 = box0.topPos.y - box0.btmPos.y 
                        let h1 = box1.topPos.y - box1.btmPos.y 
                        score -= Math.abs(h0-h1) * 3000 * r * shinkRatio //高度差  倾斜角度大的不准
                         */
                    }
                }

                if (!matchInfo.center) {
                    let o = getIntersect2(A, box0.centerDir, B, box1.centerDir)
                    matchInfo.center = o.pos3d.clone()
                    /* let o2 = math.getLineIntersect({ A, B,  p1: A.clone().add(box0.centerDir), p2:B.clone().add(box1.centerDir) })
                    matchInfo.center2 = o2.pos3d.clone() */
                    /* if (name == "pano16-4&pano18-5") {
                        addLine(A, box0.centerBtmDir, 10), addLine(B, box1.centerBtmDir, 10)
                    } */

                    //验证是否漫游点到中心点的方向和centerDir一样
                    let dir0 = new THREE.Vector3().subVectors(o.pos3d, A).normalize()
                    let dir1 = new THREE.Vector3().subVectors(o.pos3d, B).normalize()
                    let sum = dir0.dot(box0.centerDir) + dir1.dot(box1.centerDir)
                    let wrongDir = sum < 1.95
                    score -= (2 - sum) * 10000
                    if (wrongDir) {
                        str.push('wrongDir')
                        return Object.assign(matchInfo, { score: score - 5000, str })
                    }

                    if (!dontCheckDis && !standards[boxType].bottom && box0.btmPos && box1.btmPos) {
                        //墙壁位置不准所以不用 KK-ftMTQIrs79
                        let p0 = new THREE.Vector2(box0.btmPos.x, box0.btmPos.z)
                        let p1 = new THREE.Vector2(box1.btmPos.x, box1.btmPos.z)
                        let p = new THREE.Vector2(matchInfo.center.x, matchInfo.center.z)
                        let dis = p0.distanceToSquared(p) + p1.distanceToSquared(p)
                        let s = math.linearClamp(matchInfo.minAng, 0, 20, 0, 1)
                        score -= dis * 1500 * s //如果距离较远就说明算的center误差大，不可信。可能有一个框不准确
                        matchInfo.centerDrift = dis
                    }

                    getBoxBtm(matchInfo)
                    let cr //getIntersect2结果的权重
                    if (standards[box0.boxType].atWall == 1) {
                        cr = math.linearClamp(matchInfo.minAng, 2, 15, 0, 1) //墙壁误差大，所以尽量完全依赖cIntersect。。。后期如果该墙壁校准了可以调整
                    } else {
                        cr = math.linearClamp(matchInfo.minAng, 2, 20, 0, 0.4)
                    }

                    let predict0 = (!standards[boxType].bottom && box0.btmPos) || box0.posAtWall || matchInfo.topPos //在墙上的除非角度小，否则不考虑cIntersect
                    let predict1 = (!standards[boxType].bottom && box1.btmPos) || box1.posAtWall || matchInfo.topPos

                    //相对来说btmPos要比center准一点？因为center有在两个维度上的误差
                    const btmRatio = 0.5
                    let cIntersect = new THREE.Vector3().addVectors(matchInfo.center.clone().multiplyScalar(1 - btmRatio), matchInfo.btmPos.clone().multiplyScalar(btmRatio)).setY(o.pos3d.y)

                    if (predict0 && predict1) {
                        matchInfo.center = new THREE.Vector3()
                            .addVectors(
                                cIntersect.clone().multiplyScalar(cr),
                                predict0
                                    .clone()
                                    .add(predict1)
                                    .multiplyScalar((1 / 2) * (1 - cr))
                            )
                            .setY(o.pos3d.y)
                    } else {
                        matchInfo.center = cIntersect
                    }

                    matchInfo.cIntersect = cIntersect

                    //addLabel(matchInfo.center, matchInfo.name + '-c')
                }

                getBoxType(matchInfo)
                /* if (matchInfo.boxType != box0.type || matchInfo.boxType != box1.type) {
                    ;(score -= 1000), str.push('typeNotSame2')
                } */

                {
                    let vec0 = new THREE.Vector3().subVectors(box0.pano.position, matchInfo.center)
                    let vec1 = new THREE.Vector3().subVectors(box1.pano.position, matchInfo.center)
                    if (vec0.x * vec1.x > 0 && vec0.z * vec1.z > 0) {
                        //同一个象限（center会偏向一侧）
                        score -= 200
                    }
                }

                if (!safeBound.containsPoint(matchInfo.center)) {
                    let dis = safeBound.distanceToPoint(matchInfo.center)
                    //console.log(`${panoId0}的第${box0.index}个与${panoId1}的第${box1.index}个因中心点在bounding外不匹配`, center, 'dis: ' + dis)
                    ;(score -= 1000 * dis * dis), str.push('outsideBound')
                    Object.assign(matchInfo, { score, str, center: matchInfo.center, disToBound: dis })
                    if (dis > 0.5) return matchInfo
                }

                //检查宽度
                let boxposes
                let checkWidth = () => {
                    boxposes = []
                    ;[box0, box1].forEach(box => {
                        let pose = getBoxPoseByPos(box, matchInfo.center)
                        boxposes.push(pose)
                        //如果超出标准，基本上这二者不匹配；但过小的话，有可能是被遮挡所以残缺，因此不予过滤
                    })
                }
                checkWidth()

                score += getPoseScore(boxposes, boxType /* isSingle */) //根据投影信息预测的长度再得匹配分数

                compu++

                return Object.assign(matchInfo, { score: score, str, /* diffHalfHeight, */ boxposes })
            }

            this.rows = {}
            /* let getchainNext = (left, end, chain, boxes) => {
                chain.push(left)
                if (left == end) return boxes.chains.push(chain)

                let nodes = boxes.relationships.filter(pair => pair.includes(left))
                let rights = nodes.map(pair => pair.find(e => e != left))
                rights = rights.filter(e => !chain.includes(e) && boxes.indexOf(e) > boxes.indexOf(left))

                rights.forEach(right => {
                    getchainNext(right, end, chain.slice(), boxes)
                })
            } */

            let getPanoBigRowBox = (panoBoxes, { reason = 'row' } = {}) => {
                //将一个pano中的所有boxes分组，识别哪些是一排的。也可用于识别融合
                let pano = panoBoxes[0].pano
                const category = panoBoxes[0].category
                let type = category + '|' + reason
                this.rows[type] || (this.rows[type] = {})
                if (this.rows[type][pano.id]) return this.rows[type][pano.id]

                let bigBoxes
                let bigBox = {
                    sid: 'pano' + pano.id + (reason == 'mix' ? '-mix' : '-row'),
                    pano,
                    category: reason == 'mix' ? category : 'rowBigBox',
                    boxType: reason == 'mix' ? panoBoxes[0].boxType : 'rowBigBox',
                }

                let rows = []
                for (let i = 0; i < panoBoxes.length; i++) {
                    let box0 = panoBoxes[i]
                    getBoxBase(box0)
                    let [left0, right0] = [box0.bbox2[0], box0.bbox2[2]]
                    for (let j = i + 1; j < panoBoxes.length; j++) {
                        let box1 = panoBoxes[j]
                        getBoxBase(box1)
                        if (box0.boxType != box0.boxType) continue //类型不同

                        let [left1, right1] = [box1.bbox2[0], box1.bbox2[2]]

                        let d1 = getBbox2Diff(left1, right0),
                            d2 = getBbox2Diff(left1, left0),
                            d3 = getBbox2Diff(left0, right1)

                        if (box0.sid == 'pano2-4' && box1.sid == 'pano2-5') {
                            console.log(9)
                        }
                        const min = reason == 'mix' ? 0.004 : 0.003 //mix代表寻找分裂的重新融合到一起
                        if ((d1 <= min && d2 >= min) || (d3 <= min && d2 <= min)) {
                            //边框交接

                            let atEdgeMight = left1 < 0.002 && right0 > 0.998 ? [left1, right0] : left0 < 0.002 && right1 > 0.998 ? [left0, right1] : null //有在全景图的边界的可能性
                            //if (reason == 'mix' && box0.category == typeNames.cabinet && !atEdgeMight) continue //柜子容易并排，尽量不融合  //再看，啥意思，没懂
                            if (reason == 'mix' && !atEdgeMight) continue //不在边缘

                            const { max } = standards[box0.boxType].widthNormal //standards[box0.btmPos ? category : 'air-hanging'].widthNormal
                            const tolerate = max * max * (reason == 'mix' ? 0.7 : 1.8) //yDCiaTQvRYn:row不能低于1.5

                            let p0 = standards[box0.boxType].atWall == 1 ? box0.posAtWall : reason == 'mix' ? box0.btmPosOri || box0.btmPosPredict : box0.btmPos
                            let p1 = standards[box1.boxType].atWall == 1 ? box1.posAtWall : reason == 'mix' ? box1.btmPosOri || box1.btmPosPredict : box1.btmPos
                            //let p0 = box0.type == 'air-hanging' ? box0.posAtWall : reason == 'mix' ? box0.btmPosOri : box0.btmPos
                            //let p1 = box1.type == 'air-hanging' ? box1.posAtWall : reason == 'mix' ? box1.btmPosOri : box1.btmPos
                            let dis = p0.distanceToSquared(p1)

                            if (reason == 'mix') {
                                let allY = box0.bbox2[3] - box0.bbox2[1] + (box1.bbox2[3] - box1.bbox2[1]) //各自高度和
                                let wholeY = Math.max(box0.bbox2[3], box1.bbox2[3]) - Math.min(box0.bbox2[1], box1.bbox2[1]) //总跨越高度
                                let coverY = allY - wholeY //重合区域的y高度,可为负数
                                let disY = (1 - coverY / wholeY + (wholeY - coverY) * 3) * 4 * tolerate //既要考虑占比也要考虑差值
                                dis += disY //SGyhEzZNGP9案例：虽然是atEdge但并不应该融合，便通过disY来阻挡 ; MW6MEeCOy9Y:pano16-15
                                //console.log('disY',disY,  box0.sid, box1.sid  )
                                let atEdgePossib = atEdgeMight ? 0.002 / (atEdgeMight[0] + (1 - atEdgeMight[1])) : 0 // 两条线越接近越可能融合
                                atEdgePossib = Math.min(6, atEdgePossib) //原本计算得 min:1, max:Infinity
                                dis -= atEdgePossib * tolerate //给点点优势
                            }

                            /* if(box0.sid == "pano2-0"){
                                console.log('dis',dis,'tolerate',tolerate,[box0, box1],disY)
                            }  
                            if (box0.sid == 'pano2-1' && box1.sid == 'pano2-4') {
                                reason == 'mix' && console.log(dis, tolerate, box0.sid, box1.sid)
                            }*/
                            if (dis < tolerate) {
                                //reason == 'mix' && console.log('-------------------')
                                common.pushToGroupAuto([box0, box1], rows)
                            }
                        }
                    }
                }
                //一排箱子的角度范围不可超过180度，因为不可能站在箱子上拍，所以超过的话肯定有边缘的不在这一排中。
                //可判断边缘箱子的是否角度偏大，一般中间的被遮挡所以偏小

                rows.forEach(boxes => {
                    //从左到右排序
                    boxes.sort((a, b) => {
                        //但因有的box跨越到别的box区域，所以这个顺序不准确
                        return getBbox2Diff(a.bbox2CenterX, b.bbox2CenterX)
                    })
                })

                //去除不在一条直线上的连接.  当bound超出后就断开
                if (reason == 'row') {
                    rows.slice(0).forEach(boxes => {
                        if (boxes.length >= 2) {
                            let removes = [],
                                bound = new THREE.Box2(),
                                size = new THREE.Vector2(),
                                maxW = 0.6

                            for (let i = 0, j = boxes.length; i < j; i++) {
                                let box = boxes[i]
                                let pos2d = new THREE.Vector2(box.btmPos.x, box.btmPos.z)
                                bound.expandByPoint(pos2d)
                                bound.getSize(size)
                                let min = Math.min(size.x, size.y)
                                if (min > maxW) {
                                    removes.push([boxes[i], boxes[i - 1]])
                                    bound = new THREE.Box2()
                                    bound.expandByPoint(pos2d)
                                    console.log('removes', size)
                                }
                                //console.log('removes',k, box1.sid)
                            }

                            if (removes.length) {
                                console.log(
                                    '去除错误row连接',
                                    removes.map(e => e.map(a => a.sid))
                                )
                                let { newGroups } = common.disconnectGroup(removes, rows)
                                //if(newGroups.length>1){//分裂成多组了，重新计算
                                //     console.log(newGroups)
                                //}
                            }
                        }
                    })

                    rows.forEach(boxes => {
                        //从左到右重新排序
                        boxes.sort((a, b) => {
                            //但因有的box跨越到别的box区域，所以这个顺序不准确
                            return getBbox2Diff(a.bbox2CenterX, b.bbox2CenterX)
                        })
                    })
                }

                rows.sort((a, b) => {
                    return b.length - a.length
                }) //箱子数量从大到小排序

                bigBoxes = rows.map((boxes, i) => {
                    let { leftX, rightX } = getLeftRight(boxes) //最左
                    let topY = boxes.slice().sort((a, b) => a.bbox2[1] - b.bbox2[1])[0].bbox2[1]
                    let btmY = boxes.slice().sort((a, b) => b.bbox2[3] - a.bbox2[3])[0].bbox2[3]

                    let rowBigBox = Object.assign({}, bigBox, {
                        boxes,
                        bbox2: [leftX, topY, rightX, btmY], //整排的bbox
                        left: boxes.find(e => e.bbox2[0] == leftX),
                        right: boxes.find(e => e.bbox2[2] == rightX),
                    })
                    let p0 = getBoxPos(rowBigBox.left)
                    let p1 = getBoxPos(rowBigBox.right)
                    let vec = new THREE.Vector2(p0.x - p1.x, p0.z - p1.z)
                    rowBigBox.k = Math.abs(vec.x / vec.y)
                    rowBigBox.predictLen = (rowBigBox.k > 1 ? Math.abs(vec.x) : Math.abs(vec.y)) + 0.6 //加入一个宽度

                    /* if(boxes.length <= boxes.relationships.length){//多条链（为了识别一个box嵌套多个的情况。不过后来在开头时处理了一部分）
                        boxes.chains = []  
                        getchainNext(left,right,[], boxes )
                          
                        let aveAngle = (getBbox2Diff(left.bbox2[2], left.bbox2[0]) + getBbox2Diff(right.bbox2[2], right.bbox2[0]) ) / 2 -0.01  //首尾的angle平均数。但如果这两个不准那就导致整体出错了
                        let middleAngle = getBbox2Diff(right.bbox2[0], left.bbox2[2])
                        let counts = boxes.chains.map(e=>e.length)
                        counts.sort((a,b)=>a-b)
                        let min = counts[0],max = counts[counts.length-1]
                        let r = [], cur = min;
                        while(cur<=max){
                            r.push({cur, diff:Math.abs((middleAngle  / (cur-2) - aveAngle)}) //加 0.01是因为增加边缘
                            cur++
                        }
                        r.sort((a,b)=>a.diff-b.diff)
                        rowBigBox.predictBoxCount = r[0].cur
                        //---------
                        
                        let goodCountChains = boxes.chains.filter(e=>e.length == rowBigBox.predictBoxCount)
                        if(goodCountChains.length == 1) rowBigBox.bestChain = goodCountChains[0] 
                        else{
                            goodCountChains = goodCountChains.map((chain,i)=>{
                                let j = 1, diff=0 //中间的box的angle的方差
                                while(j<rowBigBox.predictBoxCount){
                                    let angle = getBbox2Diff(chain[j].bbox2[2], chain[j].bbox2[0])  
                                    diff += Math.pow(angle - aveAngle, 2)
                                    j++; 
                                }
                                return {diff, chain}
                            })
                            goodCountChains.sort((a,b)=>a.diff-b.diff)
                            rowBigBox.bestChain = goodCountChains[0].chain
                        }
                        console.log('getChains',boxes.chains, 'predictBoxCount',rowBigBox.predictBoxCount, r)
                    } */

                    return rowBigBox
                })

                if (reason != 'mix') {
                    panoBoxes.forEach(box => {
                        //加入单个的
                        if (!rows.some(row => row.includes(box))) {
                            let boxBig = Object.assign({}, bigBox, {
                                bbox2: box.bbox2,
                                boxes: [box],
                                left: box,
                                right: box,
                            })
                            bigBoxes.push(boxBig)
                        }
                    })
                }
                //mix的之前的btm因pose错误而延伸了不对的depth所以不准
                bigBoxes.forEach(bigBox => {
                    bigBox.sid += '-' + bigBox.boxes.map(e => e.index).join(',')
                    /* if (bigBox.sid == 'pano0-rowBigBox-1,0,2,4') {
                        console.log(3)
                    } */
                    if (reason == 'row') {
                        //取平均值
                        if (bigBox.boxes[0].btmPos) {
                            bigBox.btmPos = bigBox.boxes.reduce((w, c) => w.add(c.btmPos), new THREE.Vector3()).multiplyScalar(1 / bigBox.boxes.length)
                            //addLabel(bigBox.btmPos,'b_'+bigBox.sid, {bgcolor:'#f93',a:0.4})
                        }
                        if (bigBox.boxes[0].topPos) {
                            bigBox.topPos = bigBox.boxes.reduce((w, c) => w.add(c.topPos), new THREE.Vector3()).multiplyScalar(1 / bigBox.boxes.length)
                        }
                        if (bigBox.boxes[0].posAtWall) {
                            bigBox.posAtWall = bigBox.boxes.reduce((w, c) => w.add(c.posAtWall), new THREE.Vector3()).multiplyScalar(1 / bigBox.boxes.length)
                        }
                    }
                    //mix的需要合并后计算才准确
                })

                this.rows[type][pano.id] = bigBoxes //当前pano的所有row
                return bigBoxes
            }

            /* let getPanoBoxAngleTrend = rowBox => {
                //顺时针方向该pano的box角度范围是越来越大还是越来越小
                let diffs = []
                let angles = rowBox.boxes.map(box => getBbox2Diff(box.bbox2[2], box.bbox2[0]))

                for (let i = 0, j = angles.length; i < j - 1; i++) {
                    //得所有相邻之间的差
                    let a0 = angles[i],
                        a1 = angles[i + 1]
                    diffs.push(a1 - a0)
                }
                diffs.sort((a, b) => a - b)
                return diffs[Math.floor(diffs.length / 2)] //中位数
            } */

            /* let getBoxCount = (rowBigBox)=>{
                return rowBigBox.predictBoxCount || rowBigBox.boxes.length
            } */

            let getReverseInfo = (rowBigBox0, rowBigBox1) => {
                //两个row的方向对应
                let reversed = false
                let lefts = [rowBigBox0.left, rowBigBox1.left]
                let rights = [rowBigBox0.right, rowBigBox1.right]
                let dis0 = lefts[0].btmPos.distanceToSquared(lefts[1].btmPos)
                let dis1 = rights[0].btmPos.distanceToSquared(rights[1].btmPos)
                let dis2 = lefts[0].btmPos.distanceToSquared(rights[1].btmPos)
                let dis3 = rights[0].btmPos.distanceToSquared(lefts[1].btmPos)
                let posLeft2, posRight2
                if (dis0 + dis1 > dis2 + dis3) {
                    //距离近的代表是同一端
                    reversed = true
                    posLeft2 = new THREE.Vector3().addVectors(lefts[0].btmPos, rights[1].btmPos).multiplyScalar(0.5)
                    posRight2 = new THREE.Vector3().addVectors(rights[0].btmPos, lefts[1].btmPos).multiplyScalar(0.5)
                } else {
                    posLeft2 = new THREE.Vector3().addVectors(lefts[0].btmPos, lefts[1].btmPos).multiplyScalar(0.5)
                    posRight2 = new THREE.Vector3().addVectors(rights[0].btmPos, rights[1].btmPos).multiplyScalar(0.5)
                }
                let vec = new THREE.Vector2(posLeft2.x - posRight2.x, posLeft2.z - posRight2.z)
                let k = Math.abs(vec.x / vec.y) //这个算斜率更准，但位置容易偏向一侧(可能用边缘的bbox算会好些？)

                return { reversed, k }
            }

            let searchByRow = (groups, datas) => {
                //先查找row，匹配row，再slice row的方法

                this.matchScoreMap['rowBigBox'] = {}

                let rowInfos = []

                let getRowMatchInfo = (rowBigBox0, rowBigBox1, ignoreCountMatch) => {
                    //获取row间的匹配信息
                    //获取bigBox位置。由于一排的盒子比较长，中心方向误差大，所以采用先获取两边位置，再求中点的方法
                    //if (rowBigBox0.boxes.length != rowBigBox1.boxes.length && !ignoreCountMatch) return //太难了，不算不一样的情况了

                    let name = rowBigBox0.sid + '&' + rowBigBox1.sid
                    if (name in rowInfos) {
                        return rowInfos[name]
                    }

                    if (name == 'pano4-row-2,11,10,8,6&pano6-row-2,5,8,11') {
                        console.log(3)
                    }

                    if (rowBigBox0.boxes.length != rowBigBox1.boxes.length && !ignoreCountMatch) return
                    //if (getBoxCount(rowBigBox0) != getBoxCount(rowBigBox1) && getBoxCount(rowBigBox0) != 1 && getBoxCount(rowBigBox1) != 1)return

                    /* if (rowBigBox0.sid == 'pano0-row-1,2,6' && rowBigBox1.sid == 'pano2-row-0,2,6') {
                        console.log(4)
                    } */

                    let rowInfo
                    if (rowBigBox0.boxes.length > 1 && rowBigBox1.boxes.length > 1) {
                        //多对多，可以求两端的位置

                        let lefts = [rowBigBox0.left, rowBigBox1.left]
                        let rights = [rowBigBox0.right, rowBigBox1.right]
                        let leftInfo
                        let rightInfo
                        let info2 = getReverseInfo(rowBigBox0, rowBigBox1)
                        let len0 = rowBigBox0.predictLen, //长度应该接近
                            len1 = rowBigBox1.predictLen
                        let overLen = Math.abs(len0 - len1) /* /  (rowBigBox0.boxes.length + rowBigBox1.boxes.length) * 5 */
                        if (overLen > 1) {
                            //console.warn('overLen> 1', overLen, rowBigBox0.sid, '和', rowBigBox1.sid)
                            return done()
                        }

                        if (info2.reversed) {
                            leftInfo = getMatchScore(lefts[0], rights[1], { isSingle: true })
                            rightInfo = getMatchScore(rights[0], lefts[1], { isSingle: true })
                        } else {
                            leftInfo = getMatchScore(lefts[0], lefts[1], { isSingle: true })
                            rightInfo = getMatchScore(rights[0], rights[1], { isSingle: true })
                        }
                        let posLeft = getBoxPos(leftInfo)
                        let posRight = getBoxPos(rightInfo)

                        if (!posLeft || !posRight || leftInfo.score < -4000 || rightInfo.score < -4000) {
                            return done() //漫游点重合、>180度会导致此问题
                        }
                        preDealBox(leftInfo)
                        //getBoxSize(leftInfo)
                        preDealBox(rightInfo)
                        //getBoxSize(rightInfo)
                        posLeft = getBoxPos(leftInfo)
                        posRight = getBoxPos(rightInfo)
                        //验证是否是垂直或水平
                        let vec = new THREE.Vector2(posLeft.x - posRight.x, posLeft.z - posRight.z)
                        let k = Math.abs(vec.x / vec.y)

                        if ((info2.k > 1 && k < 1) || (info2.k < 1 && k > 1)) {
                            console.error('请检查！info2.k > 1 && k < 1 || info2.k < 1 && k > 1', rowBigBox0.sid, '和', rowBigBox1.sid) //绘制的方向错误，尺寸错误
                            return done()
                        }

                        let wrongK = 0
                        if ((rowBigBox0.k > 1 && rowBigBox1.k < 1) || (rowBigBox0.k < 1 && rowBigBox1.k > 1)) {
                            wrongK = rowBigBox0.k / rowBigBox1.k
                            if (wrongK < 1) wrongK = 1 / wrongK
                        }

                        /*
                        let trend0 = getPanoBoxAngleTrend(rowBigBox0)
                        let trend1 = getPanoBoxAngleTrend(rowBigBox1)

                        let judgeReverse = () => {  //这个方法有时不准
                            let disLeftSquared0 = new THREE.Vector2(posLeft.x - rowBigBox0.pano.position.x, posLeft.z - rowBigBox0.pano.position.z).lengthSq()
                            let disRightSquared0 = new THREE.Vector2(posRight.x - rowBigBox0.pano.position.x, posRight.z - rowBigBox0.pano.position.z).lengthSq()
                            let a = trend0 * (disLeftSquared0 - disRightSquared0)
                            if (a < 0 && Math.abs(a) > 0.1) return true

                            let posLeft2 = reversed ? posRight : posLeft, //反向过的对第二个漫游点来说左右是反的
                                posRight2 = reversed ? posLeft : posRight

                            let disLeftSquared1 = new THREE.Vector2(posLeft2.x - rowBigBox1.pano.position.x, posLeft2.z - rowBigBox1.pano.position.z).lengthSq()
                            let disRightSquared1 = new THREE.Vector2(posRight2.x - rowBigBox1.pano.position.x, posRight2.z - rowBigBox1.pano.position.z).lengthSq()
                            let b = trend1 * (disLeftSquared1 - disRightSquared1)
                            if (b < 0 && Math.abs(b) > 0.1) return true
                        } 
                        if (leftInfo.score < -2000 || rightInfo.score < -2000 || judgeReverse()) {
                            //反向试试
                            leftInfo = getMatchScore(lefts[0], rights[1], { isSingle: true })
                            rightInfo = getMatchScore(rights[0], lefts[1], { isSingle: true })
                            posLeft = getBoxPos(leftInfo)
                            posRight = getBoxPos(rightInfo)
                            reversed = true //rowBigBox1 反向了
                        }

                        if (leftInfo.score < -2000 || rightInfo.score < -2000 || judgeReverse()) {
                            return console.log('getCenter ；两个方向都不符合', rowBigBox0.sid, rowBigBox1.sid)
                        } */

                        /*const maxK = Math.max(0.6 / Math.sqrt(rowBigBox0.boxes.length), 0.2) // 最大斜率
                         if (k < maxK && k > 1 / maxK) {
                            return //console.log('放弃,斜率', k)
                        }  */

                        //横的话，按x从小到大，竖的按z从小到大
                        if ((k < 1 && posLeft.z > posRight.z) || (k > 1 && posLeft.x > posRight.x)) {
                            let temp = posRight
                            ;(posRight = posLeft), (posLeft = temp)
                        }
                        //addLabel(posLeft, 'left-' + rowBigBox0.pano.id + '&' + rowBigBox1.pano.id, { a: 0.1 })
                        //addLabel(posRight, 'right-' + rowBigBox0.pano.id + '&' + rowBigBox1.pano.id, { a: 0.1 })

                        /* if (rowBigBox0.pano.id + '&' + rowBigBox1.pano.id == '22&26') {
                            console.log(777)
                        } */

                        /* var line1 = LineDraw.createLine([posLeft, posRight]) 
                        meshGroup.add(line1) */
                        //根据btmPos矫正一下中心位置, 否则容易偏漫游点这一侧
                        let center = new THREE.Vector3().addVectors(posLeft, posRight).multiplyScalar(0.5)
                        center
                            .add(rowBigBox0.btmPos)
                            .add(rowBigBox1.btmPos)
                            .multiplyScalar(1 / 3)
                        let axis = k > 1 ? 'z' : 'x'
                        //posLeft[axis] = center[axis],  posRight[axis] = center[axis]

                        let match = getMatchScore(rowBigBox0, rowBigBox1, { isSingle: true, center }) //是否预先传送center ？
                        //rowInfo.minAngs = [leftInfo.minAng , rightInfo.minAng]

                        /* if (match.name == 'pano4-row-6,4,1,3&pano0-row-0,1,4,5') {
                            console.log(8)
                        } */

                        let sc = match.score - overLen * 1000 - wrongK * 100 + leftInfo.score + rightInfo.score
                        if (sc < -4000) {
                            //console.log('放弃，匹配分过低，可能不是一组', rowBigBox0.sid, '和', rowBigBox1.sid, sc)
                            return done()
                        }

                        //console.log('getcenter', rowBigBox0.sid, '和', rowBigBox1.sid,   overLen, match.score + overLen * 1000 + leftInfo.score + rightInfo.score)
                        rowInfo = {
                            rowBigBox0,
                            rowBigBox1,
                            match,
                            k,
                            posLeft,
                            posRight,
                            score: sc / 3 + 500, //700 + match.score*0.7 + (leftInfo.score + rightInfo.score)*0.3 ,
                            reversed: info2.reversed,
                        }
                    } else {
                        if (rowBigBox0.boxes.length == 1 && rowBigBox1.boxes.length == 1) {
                            rowInfo = getMatchScore(rowBigBox0.boxes[0], rowBigBox1.boxes[0]) //直接匹配box
                        } else {
                            //一对多。getMatchScore计算误差大（长度越长中心误差越大、宽度计算也误差大）所以再写点限制。直接使用btm来预测长度和位置似乎更准
                            let mulBoxRow = rowBigBox0.boxes.length > 1 ? rowBigBox0 : rowBigBox1
                            let singleBox = rowBigBox0.boxes.length == 1 ? rowBigBox0 : rowBigBox1
                            /* if(rowBigBox0.sid == "pano12-row-3" && rowBigBox1.sid == "pano0-row-3,1,0" ){
                                console.log(5)
                            } */

                            rowInfo = getMatchScore(rowBigBox0, rowBigBox1, { dontCheckDis: true }) //一对多 也可以根据方向检查距离，如仅检查z

                            rowInfo.k = mulBoxRow.k
                            if (rowInfo.center) {
                                rowInfo.center.add(getBoxPos(mulBoxRow)).multiplyScalar(0.5)
                            }
                            if (rowInfo.name == 'pano0-row-14&pano4-row-8,11') {
                                addLabel(rowInfo.center, 'c')
                            }

                            rowInfo.predictSize = rowInfo.k > 1 ? { x: mulBoxRow.predictLen, y: 0.6 } : { y: mulBoxRow.predictLen, x: 0.6 }

                            //单个的应该和多个的其中一端一样，且是离单个漫游点近的那端(也就是要走到箱子一端看不见其他箱子才行)
                            let dis0 = getBoxPos(mulBoxRow.left).distanceToSquared(singleBox.pano.position)
                            let dis1 = getBoxPos(mulBoxRow.right).distanceToSquared(singleBox.pano.position)
                            let near = dis0 < dis1 ? mulBoxRow.left : mulBoxRow.right
                            let p0 = getBoxPos(singleBox)
                            let dis = getBoxPos(near).distanceToSquared(p0)
                            rowInfo.score -= dis * 1000

                            let p1 = getBoxPos(mulBoxRow)
                            let vec1 = new THREE.Vector2(p1.x - singleBox.pano.position.x, p1.z - singleBox.pano.position.z).normalize() //看向中心的方向
                            let vec2 = new THREE.Vector2(singleBox.centerDir.x, singleBox.centerDir.z).normalize()
                            rowInfo.score += (vec1.dot(vec2) - 1) * 1000 //同一个方向是最好
                        }
                    }

                    function done(rowInfo) {
                        rowInfo && rowInfos.push(rowInfo)
                        rowInfos[name] = rowInfo
                    }
                    done(rowInfo)

                    return rowInfo
                }

                let matchGroups = []
                let allRelations = []

                let getK = info => {
                    let k
                    if (info.left) {
                        let vec = new THREE.Vector2(info.left.x - info.right.x, info.left.z - info.right.z)
                        k = Math.abs(vec.x / vec.y)
                    } else {
                        k = Math.abs(Math.max(info.size.x, 0.6) / Math.max(info.size.z, 0.6))
                    }
                    return k
                }

                let ignoreCountMatch = groups.filter(e => e.length > 1).length == 1 //是否不同数量box的row也能匹配
                let minScore = boundConfirmed ? -2000 : -800

                let match = searchType => {
                    if (searchType == 'second') ignoreCountMatch = true

                    for (let i = 0; i < groups.length - 1; i++) {
                        let rowBigBoxes_0 = getPanoBigRowBox(groups[i])
                        let pano0 = groups[i][0].pano

                        if (searchType == 'second') rowBigBoxes_0 = rowBigBoxes_0.filter(e => !matchGroups.some(u => u.includes(e)))

                        for (let j = i + 1; j < groups.length; j++) {
                            let rowBigBoxes_1 = getPanoBigRowBox(groups[j])
                            if (searchType == 'second') rowBigBoxes_1 = rowBigBoxes_1.filter(e => !matchGroups.some(u => u.includes(e)))

                            let pano1 = groups[j][0].pano

                            let resultPairs = []
                            let bigBoxes_0, bigBoxes_1
                            if (rowBigBoxes_0.length < rowBigBoxes_1.length) {
                                bigBoxes_0 = rowBigBoxes_1.slice()
                                bigBoxes_1 = rowBigBoxes_0.slice()
                            } else {
                                bigBoxes_0 = rowBigBoxes_0.slice()
                                bigBoxes_1 = rowBigBoxes_1.slice()
                            }

                            while (bigBoxes_1.length < bigBoxes_0.length) {
                                bigBoxes_1.push({ sid: 'void' }) //为了使排列正确，补个空，使左右两边个数相等，过后和void匹配的不会计算box
                            }

                            if (!bigBoxes_0[0]) continue

                            searchPair(bigBoxes_0[0], bigBoxes_0, bigBoxes_1, null, resultPairs)

                            resultPairs = resultPairs.map(pairs => {
                                let infos = pairs.map(pair => (pair.some(e => e.sid == 'void') ? null : getRowMatchInfo(pair[0], pair[1], ignoreCountMatch)))

                                //infos.sort((a,b)=>{return a.score-b.score});

                                let score = infos.reduce((s, e) => {
                                    return s + (e && e.score > minScore ? e.score : minScore / 2) //只考虑组成功的分数
                                }, 0)

                                return {
                                    pairs,
                                    infos,
                                    score,
                                    name: pairs.map(pair => pair.map(item => item.sid).join(' & ')),
                                }
                            })
                            resultPairs.sort((a, b) => b.score - a.score)
                            /* if (resultPairs[0].name[0].includes('pano8') && resultPairs[0].name[0].includes('pano0')) {
                                console.log(111)
                            } */

                            resultPairs[0].pairs.forEach((pair, i) => {
                                let info = resultPairs[0].infos[i]
                                if (info && info.score > minScore) {
                                    allRelations.push(info)
                                    let items = pair.filter(e => e.sid != 'void')
                                    common.pushToGroupAuto(items, matchGroups, null, atGroup => {
                                        //需要朝向一致才行
                                        if (!info.k) return true //（box识别的宽高识别不准所以不需要）
                                        let onePair = atGroup.relationships[0]
                                        let name = onePair[0].sid + '&' + onePair[1].sid
                                        if (!rowInfos[name].k) return true //不过不应该有这种情况，否则匹配不到一起才对

                                        if ((rowInfos[name].k < 1 && info.k < 1) || (rowInfos[name].k > 1 && info.k > 1)) {
                                            return true
                                        } else {
                                            console.log('k不一致无法匹配', info, atGroup)
                                        }
                                    })
                                    //根据目前的规则应该是有端点的和有端点的匹配，box和box匹配
                                }
                            })

                            //console.log(resultPairs[0])
                        }
                    }
                }
                match()
                ignoreCountMatch || match('second') //再次将剩余的匹配一下，这次允许个数不同的row匹配

                console.log('matchGroups', matchGroups)
                //识别出来的多组，可能有重复的，因为box个数不同所以才没到一组

                //整理一下，每个组整理出一个info，同时重新检查一下，挑去每组中和其他成员非常不同的
                let groupInfo = []
                let getGroupInfo = group => {
                    let left = new THREE.Vector3(),
                        right = new THREE.Vector3(),
                        pointsLen = 0
                    let bigBoxes = []
                    let info = {}
                    group.relationships.forEach(pair => {
                        let name = pair[0].sid + '&' + pair[1].sid

                        let matchInfo = rowInfos[name] //this.matchScoreMap["rowBigBox"][name] || this.matchScoreMap["cabinet"][name];
                        if (matchInfo.posLeft) {
                            left.add(matchInfo.posLeft), right.add(matchInfo.posRight), pointsLen++
                        } else {
                            bigBoxes.push(matchInfo)
                            preDealBox(matchInfo)
                            getBoxSize(matchInfo)
                        }
                    })
                    let index = groupInfo.length
                    if (pointsLen > 0) {
                        left.multiplyScalar(1 / pointsLen)
                        right.multiplyScalar(1 / pointsLen)
                        //addLabel(left, 'Left' + index, { bgcolor: '#F00', a: 0.2 })
                        //addLabel(right, 'Right' + index, { bgcolor: '#F00', a: 0.2 })
                        let center = new THREE.Vector3().addVectors(left, right).multiplyScalar(0.5)
                        //addLabel(center, 'center' + index, { bgcolor: '#F00', a: 0.3 })
                        ;(info.left = left), (info.right = right), (info.center = center)
                        info.pointsLen = pointsLen
                    }

                    if (bigBoxes.length > 0) {
                        let getAve = bigBoxes => {
                            let center1 = new THREE.Vector3(),
                                size = new THREE.Vector3()
                            bigBoxes.forEach(box => {
                                let center0 = getBoxPos(box)
                                center1.add(center0)
                                size.add(box.size)
                            })
                            if (pointsLen > 0) {
                                let size0 = new THREE.Vector3(Math.abs(left.x - right.x), size.y, Math.abs(left.z - right.z))
                                size.add(size0.multiplyScalar(pointsLen)).multiplyScalar(1 / (pointsLen + bigBoxes.length))
                                center1.add(info.center.clone().multiplyScalar(pointsLen)).multiplyScalar(1 / (pointsLen + bigBoxes.length))
                            } else {
                                size.multiplyScalar(1 / bigBoxes.length)
                                center1.multiplyScalar(1 / bigBoxes.length)
                            }

                            return { center1, size }
                        }
                        let getScores = (center, size) => {
                            //获得相对于center,size的差别分数
                            bigBoxes.forEach(box => {
                                box.sc = -box.center.distanceToSquared(center1) - size.distanceToSquared(box.size) * 0.5
                            })
                        }

                        let { center1, size } = getAve(bigBoxes)
                        //console.log(center1, size)

                        getScores(center1, size)
                        bigBoxes.sort((a, b) => b.sc - a.sc)

                        let midItem = bigBoxes[Math.floor(bigBoxes.length / 2)] //中位数
                        getScores(midItem.center, midItem.size)

                        const minScore = -8

                        let removes = bigBoxes.filter(e => {
                            return e.sc < minScore
                        })

                        if (removes.length) {
                            let { newGroups } = common.disconnectGroup(
                                removes.map(e => [e.box0, e.box1]),
                                matchGroups
                            )
                            console.log('去除错误数据', removes)

                            if (newGroups.length > 1) {
                                //分裂成多组了，重新计算
                                newGroups.forEach(e => {
                                    getGroupInfo(e)
                                })
                                return
                            }
                            bigBoxes = bigBoxes.filter(e => {
                                return e.sc >= minScore
                            })
                        }
                        if (bigBoxes.length) {
                            let o = getAve(bigBoxes) //again
                            ;(info.center = o.center1), (info.size = o.size)
                        }
                    }

                    info.k = getK(info)
                    info.bigBoxes = bigBoxes
                    info.group = group
                    groupInfo.push(info)
                }

                matchGroups.slice(0).forEach(group => {
                    getGroupInfo(group)
                })

                let getLength = c => {
                    //获取bigbox长度
                    return c.size ? (c.k > 1 ? c.size.x : c.size.z) : c.k > 1 ? c.right.x - c.left.x : c.right.z - c.left.z + 0.6
                }
                let getLeft = (group, k) => {
                    let dirAxis = (k || group.k) > 1 ? 'x' : 'z'
                    return group.left ? group.left[dirAxis] - 0.3 : group.center[dirAxis] - group.size[dirAxis] / 2 //left和right加减半个宽度
                }
                let getRight = (group, k) => {
                    let dirAxis = (k || group.k) > 1 ? 'x' : 'z'
                    return group.right ? group.right[dirAxis] + 0.3 : group.center[dirAxis] + group.size[dirAxis] / 2
                }
                //识别是否group之间有一样的， 去重
                {
                    let realGroups = []

                    let getAveWidth = (infos, len) => {
                        //获取这些infos最合适的箱子平均宽度和个数
                        let boxCounts = []
                        infos.forEach(e => {
                            boxCounts.push(...e.group.map(bigBox => bigBox.boxes.length))
                        })
                        boxCounts.sort((a, b) => a - b)

                        let midCounts = []
                        let r0 = 0.3,
                            r1 = 0.7 //取中间这部分的算最适合的个数，结果不一定是中位数
                        boxCounts.slice(Math.floor(boxCounts.length * r0), Math.floor(boxCounts.length * r1) + 1).forEach(c => {
                            if (!midCounts.includes(c)) midCounts.push(c)
                        })

                        let { min, max } = standards.cabinet.widthNormal
                        let standardW = (min + max) / 2
                        let aveWs = midCounts.map(e => {
                            return { aveW: len / e, count: e }
                        })
                        aveWs.sort((a, b) => Math.abs(a.aveW - standardW) - Math.abs(b.aveW - standardW))
                        let aveW = aveWs[0].aveW
                        let count = aveWs[0].count

                        if (aveW > max || aveW < min) {
                            let w = THREE.MathUtils.clamp(aveW, min, max)
                            //console.warn(`box aveW宽度不太对，从${aveW}修改到${w}`)
                            aveW = w
                        }

                        return { aveW, count }
                    }

                    let getBox2 = (center, len, thick, k) => {
                        let box2 = new THREE.Box2()
                        box2.expandByPoint(new THREE.Vector2(center.x, center.z))
                        let sizeVec = k > 1 ? new THREE.Vector2(len / 2, thick / 2) : new THREE.Vector2(thick / 2, len / 2)
                        box2.expandByVector(sizeVec)
                        return box2
                    }

                    const standardW = 0.6 //两排之间最小距离

                    for (let m = 0; m < groupInfo.length - 1; m++) {
                        let group0 = groupInfo[m]

                        for (let n = m + 1; n < groupInfo.length; n++) {
                            let group1 = groupInfo[n]
                            if (group1.bigBoxes[0]?.name == 'pano4-row-4&pano6-row-5,1' && group0.bigBoxes[0]?.name == 'pano4-row-2,5&pano6-row-3') {
                                console.log(4)
                            }
                            /* if (group0.k == 4.242560016595383 || group1.k == 0.8571428571428572) {
                                console.log(2)
                            } */
                            const maxR = 2.3
                            if (((group0.k > 1 && group1.k < 1) || (group0.k < 1 && group1.k > 1)) && getLength(group0) > 1.5 && getLength(group1) > 1.5) continue //如果是方块状的无视k

                            //间距
                            let spaceAxis = (group0.k + group1.k) / 2 > 1 ? 'z' : 'x'
                            let spaceDis = Math.abs(group0.center[spaceAxis] - group1.center[spaceAxis])
                            if (spaceDis > standardW * 1.5) continue

                            let o0 = getAveWidth([group0], getLength(group0)) //因为有可能长度和箱子个数不匹配，所以需要得到限制后的宽度再比较
                            let o1 = getAveWidth([group1], getLength(group1))
                            let len0 = (group0.predictLen = o0.aveW * o0.count)
                            let len1 = (group1.predictLen = o1.aveW * o1.count)

                            const minR = 0.5 //不可限制太死，因为有的框个数识别少了，导致len短。但可通过重叠面积来判断
                            // if( len0 / len1 < minR || len0 / len1 > 1/minR) continue

                            let area0 = (group0.area = len0 * o0.aveW)
                            let area1 = (group1.area = len1 * o1.aveW)
                            let getBoxMixArea = (expandRatio1, expandRatio2) => {
                                let box0 = getBox2(group0.center, len0 + expandRatio1, o0.aveW + expandRatio2, group0.k)
                                let box1 = getBox2(group1.center, len1 + expandRatio1, o1.aveW + expandRatio2, group1.k)
                                let mixBox = getMixBox(box0, box1) //重叠部分
                                let s = mixBox.getSize(new THREE.Vector2())
                                return { box0, box1, areaMix: Math.max(0, s.x) * Math.max(0, s.y) } //可能是0
                            }
                            let areaMixExpand = getBoxMixArea(0.1, 0.3).areaMix

                            if (areaMixExpand / area0 < 0.65 && areaMixExpand / area1 < 0.65) continue //包含的可以通过

                            /*let areaMix = getBoxMixArea(0, 0).areaMix //实际重合面积

                            group0.contains = group0.contains || []
                            group1.contains = group1.contains || []

                            group0.contains.push({ group: group1, selfPercent: areaMix / area0, percent2: areaMix / area1, areaMix })
                            group1.contains.push({ group: group0, selfPercent: areaMix / area1, percent2: areaMix / area0, areaMix })
                            */
                            //console.log('两个合并', group0, group1)
                            common.pushToGroupAuto([group0, group1], realGroups)
                            //包含的直接合并吧 - - ，这样会使结果偏移，不过没办法了，多个重叠面积太难算了
                        }
                    }

                    //但没合并前样本数量少，包含关系可能有错  - -

                    /*for(let m=0; m<groupInfo.length;m++){
                        let group = groupInfo[m]
                        let contains = group.contains.filter(e=> e.percent2 > 0.8) //所有包含的
                        contains.reduce   
                    } */

                    groupInfo.forEach(info => {
                        //加入单个的
                        if (!realGroups.some(groups => groups.includes(info))) {
                            realGroups.push([info])
                        }
                    })

                    console.log('realGroups', realGroups)

                    //get boxes
                    realGroups.forEach((infos, i) => {
                        const sampleCount = infos.reduce((w, c) => {
                            return (w += c.pointsLen || c.bigBoxes.length)
                        }, 0)

                        let k
                        /* {
                            //const k = infos.reduce((w, c) => (w += c.k), 0) / infos.length
                            let ks = infos.map(e => e.k)
                            ks.sort((a, b) => a - b)
                            let min = ks[0],
                                max = ks[ks.length - 1]
                            if (min < 1 && max > 1) {
                                //比较最小和最大，选取更极端的那个
                                let min_ = 1 / min
                                if (min_ < max) k = max
                                else k = min
                            } else k = (min + max) / 2
                        } */
                        {
                            //看>1的和<1的平均数哪个多用哪个
                            let ks = { '<1': { count: 0, sum: 0 }, '>1': { count: 0, sum: 0 } }
                            infos.forEach(e => {
                                if (e.k < 1) {
                                    ks['<1'].count++, (ks['<1'].sum += 1 / e.k)
                                } else {
                                    ks['>1'].count++, (ks['>1'].sum += e.k)
                                }
                            })
                            ks['<1'].count && (ks['<1'].ave = ks['<1'].sum / ks['<1'].count)
                            ks['>1'].count && (ks['>1'].ave = ks['>1'].sum / ks['>1'].count)
                            if (ks['<1'].ave > ks['>1'].ave) {
                                k = 1 / ks['<1'].ave
                            } else {
                                k = ks['>1'].ave
                            }
                        }

                        let centerPos = infos
                            .reduce((w, c) => {
                                return w.add(c.center.clone().multiplyScalar(c.pointsLen || c.bigBoxes.length))
                            }, new THREE.Vector3())
                            .multiplyScalar(1 / sampleCount) //预得中心点
                        //获取左右端点（需要排除可能的误差，所以采用最靠近端点的三个点。但无法排除前三个点中万一含有包含box的、或者误差大的端点）
                        let lefts = infos
                            .map(e => getLeft(e, k))
                            .sort((a, b) => a - b)
                            .filter(a => a < centerPos[k > 1 ? 'x' : 'z'])
                            .slice(0, 3)
                        let rights = infos
                            .map(e => getRight(e, k))
                            .sort((a, b) => b - a)
                            .filter(a => a > centerPos[k > 1 ? 'x' : 'z'])
                            .slice(0, 3)

                        let left = 0,
                            right = 0

                        let c0 = ((lefts.length + 1) * lefts.length) / 2
                        lefts.forEach((e, i) => {
                            //越靠近最外侧权重越高。
                            left += e * ((lefts.length - i) / c0)
                        })

                        c0 = ((rights.length + 1) * rights.length) / 2
                        rights.forEach((e, i) => {
                            right += e * ((rights.length - i) / c0)
                        })

                        centerPos[k > 1 ? 'x' : 'z'] = (left + right) / 2
                        let len = right - left //加一点值是因为之前计算长度，用的是最外box的中心点，会少box一半宽度

                        let infos2 = infos.filter(e => {
                            return !e.predictLen || e.predictLen / len > 0.7
                        })
                        if (infos2.length == 0) {
                            infos2 = infos.sort((a, b) => b.predictLen - a.predictLen).slice(0, 1)
                        }
                        let { aveW, count } = getAveWidth(infos2, len)

                        //长宽比中心点的误差更大，尤其是box类型的、或样本少的

                        //获取高度
                        let heights = []
                        {
                            let pairs = [],
                                heightss

                            /* infos.forEach(e => {
                                pairs.push(...e.group.relationships.filter(pair => pair[0].boxes.length == count && pair[1].boxes.length == count))
                            })

                            if (pairs.length) {
                                heightss = pairs.map(pair => {
                                    let boxes = pair.map(e => {
                                        return e.boxes.slice() 
                                    })
                                    let match = rowInfos[pair[0].sid + '&' + pair[1].sid]
                                    let ifReverse = match.reversed
                                    if (match.reversed == void 0 && pair[0].boxes.length > 1 && pair[1].boxes.length > 1) {
                                        let { reversed } = getReverseInfo(pair[0], pair[1])
                                        ifReverse = reversed
                                    }

                                    if (ifReverse) {
                                        boxes[1].reverse()
                                    }

                                    let heights1 = []
                                    let topPoss = []
                                    for (let i = 0; i < count; i++) {
                                        let match1 = getMatchScore(boxes[0][i], boxes[1][i], { onlyGet: true })
                                        let topPos = match1 && match1.topPos
                                        if (!topPos) {
                                            topPos = getBoxTop({ box0: boxes[0][i], box1: boxes[1][i] })
                                        }
                                        heights1.push(topPos.y - groundY)

                                        if (topPos.y - groundY < 0) {
                                            console.log('?')
                                        }

                                        topPoss.push(topPos)
                                    }
                                    if ((k < 1 && topPoss[0].z > topPoss[count - 1].z) || (k > 1 && topPoss[0].x > topPoss[count - 1].x)) {
                                        heights1.reverse()
                                    }
                                    return heights1
                                })
                            } else { */
                            let bigBoxes = []
                            infos.forEach(e => {
                                bigBoxes.push(...e.group.filter(e => !bigBoxes.includes(e) && e.boxes.length == count))
                            })
                            heightss = bigBoxes.map(bigBox => {
                                let topPoss = bigBox.boxes.map(box => {
                                    let a = { box0: box }
                                    getBoxTop(a)
                                    return a.topPos
                                })
                                if ((k < 1 && topPoss[0].z > topPoss[count - 1].z) || (k > 1 && topPoss[0].x > topPoss[count - 1].x)) {
                                    topPoss.reverse()
                                }
                                let heights1 = topPoss.map(topPos => topPos.y - groundY)

                                return heights1
                            })
                            //}
                            heightss.forEach(arr => {
                                for (let i = 0; i < count; i++) {
                                    heights[i] = (heights[i] || 0) + arr[i]
                                }
                            })
                            heights = heights.map(e => {
                                let h = e / heightss.length
                                return h
                            })
                            //console.log('heightss',heightss, pairs, heights)
                        }

                        //拆分成小box

                        let size = new THREE.Vector3(aveW, 2, aveW)
                        let c = 0
                        infos.box = []
                        while (c < count) {
                            let center
                            if (k > 1) {
                                let startX = centerPos.x - ((count - 1) / 2) * aveW
                                center = new THREE.Vector3(startX + c * aveW, centerPos.y, centerPos.z)
                            } else {
                                let startZ = centerPos.z - ((count - 1) / 2) * aveW
                                center = new THREE.Vector3(centerPos.x, centerPos.y, startZ + c * aveW)
                            }
                            let size1 = heights[c] ? size.clone().setY(heights[c]) : size //如1*3的是得不到height的

                            let box = new Box({ name: 'row' + i + '-' + c, center, size: size1, boxType: 'cabinet', infos })
                            c++
                            infos.box.push(box)
                        }
                    })

                    return realGroups.length > 0
                }
            }

            let removeContain = arr => {
                //去除嵌套
                let len = arr.length

                if (len < 2) return

                for (let i = 0; i < len - 1; i++) {
                    let box0 = arr[i]
                    getBoxBase(box0)
                    box0.contains = box0.contains || []
                    for (let j = i + 1; j < len; j++) {
                        let box1 = arr[j]
                        if (box0.sid == 'pano2-1' && box1.sid == 'pano2-7') {
                            console.log(6)
                        }
                        getBoxBase(box1)
                        box1.contains = box1.contains || []

                        let d3 = Math.abs(box1.bbox2CenterX - box0.bbox2CenterX) //限制d3是因为在相差180度两端可能也符合
                        //d4 = Math.abs(box1.bbox2[3] - box0.bbox2[3])

                        if (d3 > 0.4 /*  || d4 > 0.01 */) continue

                        let d0 = getBbox2Diff(box1.bbox2[0], box0.bbox2[0]),
                            d1 = getBbox2Diff(box0.bbox2[2], box1.bbox2[2]),
                            w0 = getBbox2Diff(box0.bbox2[2], box0.bbox2[0]),
                            w1 = getBbox2Diff(box1.bbox2[2], box1.bbox2[0])

                        let min = Math.min(0.005, Math.min(w0, w1) * 0.2) //如果本身w0,w1宽度就小，差距更要小

                        if ((d1 >= 0 && Math.abs(d0) < min) || (d0 >= 0 && Math.abs(d1) < min) || (d1 >= 0 && d0 >= 0)) {
                            box0.contains.push(box1)
                        } else if ((d0 <= 0 && Math.abs(d1) < min) || (d1 <= 0 && Math.abs(d0) < min) || (d1 <= 0 && d0 <= 0)) {
                            box1.contains.push(box0)
                        }
                    }
                }

                let getWidthScore = (box, type) => {
                    const addDis = 0.1 //因为用的是btm的pos，比中心点近了一些，所以加上一段距离
                    let o = getBoxPoseByPos(box, getBoxPos(box), addDis)
                    let boxPjW = o.projectWidth
                    let standardPjW = (o.maxProjectWidth + o.minProjectWidth) / 2
                    let s = type == 'out' ? boxPjW - standardPjW : standardPjW - boxPjW
                    return -Math.pow(s, 2) * 10
                }

                let minChildCount = arr[0].boxType == 'battery' ? 1 : 2

                arr.slice().forEach(box => {
                    if (box.contains.length >= minChildCount) {
                        //假设不存在第二层嵌套， 假设每个只能被一个嵌套
                        //决定留大还是留小
                        //先只去掉包含两个以上的，且角度范围一致
                        //尽量保留内层，除非内层太小

                        let { leftX, rightX } = getLeftRight(box.contains)

                        if (box.contains.length > 1 && (Math.abs(getBbox2Diff(box.bbox2[0], leftX)) > 0.005 || Math.abs(getBbox2Diff(box.bbox2[2], rightX)) > 0.005)) return //范围不一致

                        let remainChild = true
                        if (box.contains.length == 1) {
                            //cdi6xzNiNdS 电池包含单个   感觉一般都是留大
                            remainChild = false
                        } else {
                            let outScore = getWidthScore(box, 'out')
                            let childrenScores = box.contains.map(e => getWidthScore(e, 'in'))
                            let childAve = childrenScores.reduce((w, c) => w + c, 0) / childrenScores.length
                            if (childAve < -4) {
                                //let outScore = getWidthScore(box, 'out')
                                remainChild = childAve > outScore
                            }
                        }
                        if (!remainChild) {
                            box.contains.forEach(e => {
                                ;(e.state = '因被嵌套被删除'), (e.containBy = box)
                                arr.splice(arr.indexOf(e), 1)
                                console.log('因被嵌套被删除', ...box.contains)
                            })
                        } else {
                            box.state = '因嵌套其他被删除'
                            console.log('因嵌套其他被删除', box)
                            arr.splice(arr.indexOf(box), 1)
                        }
                    }
                })
            }

            let waitFindRest = []
            let Search = type => {
                console.error('开始search', type)
                let matchScoreMap = (this.matchScoreMap[type] = {})
                let datas = {}
                let panoIds = []
                for (let id in this.datas) {
                    if(!this.datas[id])continue
                    datas[id] = this.datas[id].shapes.filter(e => isType(e, type))
                    datas[id].length && panoIds.push(id)
                }

                for (let id in this.datas) {
                    //对data预处理
                    //(之后如果还出现不同类型重叠在一起的，需要先识别摘除下。 )4GqaqNdyjGf
                    if(!this.datas[id])continue
                    removeContain(datas[id]) //去除线框中的嵌套，主要是一个嵌套两个的。案例：KK-1Zjm9Rbl47

                    if (datas[id].length) {
                        //融合。很多box被一分为二了，基本都是在全景图左右边界处。
                        let bigBoxes = getPanoBigRowBox(datas[id], { reason: 'mix' })
                        bigBoxes.forEach(bigBox => {
                            if (bigBox.boxes.length > 1) {
                                bigBox.boxes.forEach(box => {
                                    ;(box.state = '被删除'), (box.mixTo = bigBox)
                                    let i = datas[id].indexOf(box)
                                    datas[id].splice(i, 1)
                                    if (version == 'vision') {
                                        i = this.datasMixed[id].shapes.findIndex(e => e.sid == box.sid)
                                        this.datasMixed[id].shapes.splice(i, 1)
                                    }
                                })
                                //console.log('因融合而删除', bigBox.boxes)
                                datas[id].push(bigBox)
                                if (version == 'vision') {
                                    this.datasMixed[id].shapes.push(bigBox)
                                }
                                let shapes = this.datas[id].shapes
                                bigBox.index = shapes.length > 1 ? shapes[shapes.length - 2].index + 1 : 0
                                {
                                    let a = bigBox.sid.split('mix-')
                                    bigBox.sid = a[0] + bigBox.index + '(mix' + a[1] + ')' //"pano20-mix-1,2"
                                }
                            }
                        })
                    }
                }

                if (panoIds.length == 0) {
                    if (standards[type].tinyXZ) {
                        //fire 调试：nZrBdvRaDuC
                        this.expandModelBound()
                    }
                    return
                }
                panoIds.sort((a, b) => {
                    return datas[b].length - datas[a].length
                })
                let groups = panoIds.map(e => datas[e])
                console.log('按box个数排序:', groups.slice())

                let group0 = groups[0],
                    len0 = group0.length
                if (groups.length == 1) {
                    //只有一个全景里有数据

                    if (standards[type].tinyXZ) {
                        //fire. 无法match以获取groundY, 就取消。 调试： eGhyf5QdVHA
                        this.expandModelBound(type)
                    }

                    group0.forEach(e => createSinglePano(e))
                    return combines(type)
                }
                let finish = groups => {
                    waitFindRest.push({ type, args: [groups] }) //等待最后检查遗漏
                    if (standards[type].tinyXZ) {
                        //fire 调试：nZrBdvRaDuC
                        this.confirmGroundY(type)
                    }
                    if (standards[type].tiny) {
                        //monitor 调试：S9yepREK8Jl
                        this.expandModelBound2(type)
                    }
                }
                if (len0 == 1) {
                    //最多的也只有一个box。此情况大部分是空调
                    panoIds.forEach(e => getBoxBase(datas[e][0]))
                    let maxAngle
                    //找出centerDir夹角最大的两个pano
                    for (let i = 0; i < panoIds.length; i++) {
                        let box0 = datas[panoIds[i]][0]
                        for (let j = i + 1; j < panoIds.length; j++) {
                            let box1 = datas[panoIds[j]][0]

                            getMatchScore(box0, box1, { isSingle: true })
                        }
                    }
                    let list = Object.keys(matchScoreMap)
                    list.sort((a, b) => {
                        return matchScoreMap[b].score - matchScoreMap[a].score
                    })
                    let match = matchScoreMap[list[0]]
                    preDealBox(match)

                    if (match.score > -100) {
                        getBoxSize(match)
                        if (match.score > 0 && match.sizeAdjust < 0.1) {
                            new Box(matchScoreMap[list[0]])
                            //waitFindRest.push({ type, args: [groups] }) //等待最后检查遗漏
                            finish(groups)
                            return
                        }
                    }

                    //根据分数重排序，前两个已匹配的pano放在第一第二（reMatchLowScores会跳过），获得groups2
                    let panoIds2 = []
                    list.forEach(e => {
                        let info = matchScoreMap[e]
                        if (!panoIds2.includes(info.box0.pano.id)) panoIds2.push(info.box0.pano.id)
                        if (!panoIds2.includes(info.box1.pano.id)) panoIds2.push(info.box1.pano.id)
                    })
                    let groups2 = panoIds2.map(e => datas[e])
                    //继续match
                    reMatchLowScores([match], groups2)

                    finish(groups2)
                    return
                }

                {
                    //重新根据距离排序，挑选离所有box距离最近的两个pano （远的可能看不到box，或者得到的线框计算的位置不准。不过其实太近也不准-，-）
                    let counts = {}
                    groups.forEach(e => {
                        e.forEach(a => getBoxBase(a))
                        counts[e.length] || (counts[e.length] = [])
                        counts[e.length].push(e)
                    })
                    groups = []
                    let atWall = standards[type].atWall
                    let nums = Object.keys(counts)
                    let bestDisSquared = 2
                    nums.reverse()
                    nums.forEach(count => {
                        let groups_ = counts[count]
                        if (groups_.length > 1) {
                            groups_.forEach(e => {
                                e.disSc = e.reduce((w, c) => {
                                    let pos = getBoxPos(c)
                                    //let s = atWall ? Math.pow(Math.abs(c.centerDir.y), 3)*100 : 0   //在墙上的话尽量平视
                                    //console.log(c.sid,s)
                                    return w + Math.abs(c.pano.position.distanceToSquared(pos) - bestDisSquared) //+ s
                                }, 0)
                            })
                            groups_.sort((a, b) => a.disSc - b.disSc)
                        }

                        groups.push(...groups_)
                    })

                    console.log('按距离和个数排序:', groups)
                    group0 = groups[0]
                    len0 = group0.length
                }

                if (type == 'cabinet') {
                    //转化为分组
                    if (searchByRow(groups, datas)) {
                        waitFindRest.push({ type, args: [groups, 0] }) //等待最后检查遗漏
                        return
                    }
                }

                //零散匹配。
                let match2Group = (group0, group1, { fake }) => {
                    let len0 = group0.length,
                        len1 = group1.length

                    for (let i = 0; i < len0; i++) {
                        //复杂度：n的平方次
                        for (let j = 0; j < len1; j++) {
                            let box1 = group0[i]
                            let box2 = group1[j]
                            let result = getMatchScore(box1, box2)
                        }
                    }

                    //寻找最佳配对     n!种组合（是否要限制个数多的情况？） 超过8个就很恐怖
                    //仅先查找选中的两个pano配对
                    let resultPairs = []

                    let newGroup0 = group0.slice(0)
                    let newGroup1 = group1.slice(0)
                    while (newGroup1.length < newGroup0.length) {
                        newGroup1.push({ sid: 'void' }) //为了使排列正确，补个空，使左右两边个数相等，过后和void匹配的不会计算box
                    }

                    searchPair(group0[0], newGroup0, newGroup1, null, resultPairs)

                    /* console.log(
                        'resultPairs',
                        resultPairs.map(pairs => pairs.map(pair => pair.map(item => item.sid).join(' & ')))
                    ) */

                    resultPairs = resultPairs.map(pairs => {
                        let infos = pairs.map(pair => matchScoreMap[pair[0].sid + '&' + pair[1].sid])

                        let score = infos.reduce((s, e) => {
                            return s + (e ? e.score : 0)
                        }, 0)
                        let o = {
                            infos,
                            score,
                            pairs,
                            name: pairs.map(pair => pair.map(item => item.sid).join(' & ')),
                        }
                        return o
                    })
                    //console.log('resultPairs', resultPairs.slice())
                    console.log(
                        'resultPairs按分数高低',
                        resultPairs.sort((a, b) => b.score - a.score)
                    )

                    //console.log('compu',compu)
                    let minScore = boundConfirmed ? -2000 : -800
                    let noMatches = [] //和void匹配的，需要和其他pano的重新匹配
                    let mayHaventMatched = []
                    let lowScores = []
                    if (resultPairs[0]) {
                        resultPairs[0].infos.forEach((info, i) => {
                            if (!info) {
                                noMatches.push(resultPairs[0].pairs[i].find(e => e.sid != 'void'))
                                return //match with void
                            }
                            if (info.score < minScore || (standards[info.boxType].bottom && info.minAng < 5)) {
                                lowScores.push(info)
                                return
                            }
                            preDealBox(info)
                            getBoxSize(info)

                            if ((info.sizeAdjust && standards[info.boxType].tiny) || info.sizeAdjust > 0.2) {
                                //或者识别下悬挂的且线的角度较小
                                lowScores.push(info)
                                return
                            }

                            if (info.box0.category == typeNames.battery && info.size.x < 1 && info.size.z < 1) {
                                //宽度较小
                                let vec0 = new THREE.Vector3().subVectors(info.box0.pano.position, getBoxPos(info))
                                let vec1 = new THREE.Vector3().subVectors(info.box1.pano.position, getBoxPos(info))
                                /* let k0 = Math.abs(vec0.x / vec0.z), k1 = Math.abs(vec1.x / vec1.z), maxR = 6
                                if(info.name == '') */

                                if (vec0.x * vec1.x > 0 && vec0.z * vec1.z > 0 /*  || k0/k1 > maxR ||  k0/k1 < 1/maxR  */) {
                                    //同一个象限 或 偏向一侧
                                    lowScores.push(info)
                                    return
                                }
                            }
                            info.fake = fake
                            let box = new Box(info)
                        })
                    }

                    if (noMatches.length) {
                        reMatchLowScores(
                            noMatches.map(e => {
                                return { box0: e }
                            }),
                            groups,
                            { fake }
                        )
                    }

                    reMatchLowScores(lowScores, groups, { fake })
                }

                {
                    for (let i = 0; i < groups.length - 1; i++) {
                        match2Group(groups[i], groups[i + 1], { fake: i > 0 })
                        if (!standards[type].tinyXZ /* && !browser.urlHasValue('many') */ || groups[i + 1].length < 2) {
                            break
                        }
                    }
                }

                finish(groups)
            }

            function blocked(box) {
                //该box是否被实体box遮挡
                //WcLVXvmV9AU:pano2-2 和 pano12-4  ;  5yhlMduTHL8:pano2-10

                /* if (box.sid == 'pano6-7') {
                    console.log(1)
                    addLine(box.pano.position, box.centerBtmDir, 20)
                } */

                if (!standards[box.boxType].bottom) {
                    //当底部每个方向都有遮挡物时，其位置很可能不准。但若是部分遮住，还是有可能识别对的
                    if (!box.blocked) {
                        box.blocked = {
                            centerBtmDir: null,
                            leftBtmDir: null,
                            rightBtmDir: null,
                        }
                    }

                    for (let dir in box.blocked) {
                        if (!box.blocked[dir]) {
                            let block = boxesSolid.find(boxSolid => {
                                ray.set(box.pano.position, box[dir])
                                let o = ray.ray.intersectsBox(boxSolid.bound)
                                if (o) {
                                    // 遮挡
                                    return true
                                }
                            })

                            if (block) {
                                //若不存在，即都遮挡了，就算真的遮挡
                                box.blocked[dir] = block
                            } else {
                                box.blocked[dir] = false
                                return false //找到一个方向无遮挡则可返回
                            }
                        }
                    }
                    return true
                    //暂定，若某个方向已得到遮挡了，就不计算。但若没有，就再搜一遍（如果会重复搜之后再增加一个stamp啥的，比如记录下当前所有solidBoxes的name，如果改变了就重新搜下）
                } else {
                    //若中心方向已经有同类型的box，很可能它就是自身（因为挂墙的预测位置很不准，所以需要这一步。越tiny的越能通过此来筛选）

                    let block = boxesSolid.find(boxSolid => {
                        if (boxSolid.boxType != box.boxType) return
                        ray.set(box.pano.position, box.centerDir)
                        let o = ray.ray.intersectsBox(boxSolid.bound)
                        if (o) {
                            // 遮挡
                            return true
                        }
                    })
                    if (block) {
                        box.blocked = block
                        return true
                    }
                }
            }

            //调试 O540aEVF3b7 jQUQlER160 n4z0yd5tQaF WcLVXvmV9AU 8czlwsbSe5 NlUM8yGve9
            function findRest(groups /* ,startIndex=2  */) {
                //查找是否有遗漏。
                //1 可能有距离较远的box不在头两个pano的附近导致被漏掉。(概率很小)
                //2 被剩余的 (包括低分匹配中放弃的，这种需要的距离识别度高)

                const tolerateWidth = { min: 0.1, max: 0.5 }
                let boxes = [],
                    scores = new Map(),
                    bestDisSquared = 2

                groups.forEach(g => {
                    boxes.push(...g)
                })
                boxes = boxes.filter(box => !used(box))

                boxes.forEach(box => {
                    getBoxBase(box)
                    let p1 = new THREE.Vector2(box.pano.position.x, box.pano.position.z)
                    let p2 = new THREE.Vector2(box.btmPos.x, box.btmPos.z)
                    let dis = p1.distanceToSquared(p2)
                    let s1 = -Math.abs(dis - bestDisSquared) //将距离最佳的排前面，距离远的得到的位置不准确，也容易被遮

                    if (!box.pose) box.pose = getBoxPoseByPos(box, getBoxPos(box))
                    let s2 = getPoseScore([box.pose], box.boxType) + THREE.MathUtils.clamp(box.pose.projectWidth, box.pose.minProjectWidth, box.pose.maxProjectWidth) * 7 //projectWidth长的更安全
                    scores.set(box, { s1, s2, sum: s1 + s2 })
                })
                //console.log(boxes[0].boxType,scores)
                boxes = boxes.sort((a, b) => {
                    return scores.get(b).sum - scores.get(a).sum
                }) //FXcq5PI9QGv
                //console.log(boxes)

                boxes.forEach(box => {
                    if (box.sid == 'pano0-4') {
                        console.log(3)
                    }
                    if (!used(box) && !blocked(box)) {
                        //如果和现有的box的距离都很远，很可能是漏掉的
                        let near = boxesSolid.find(solidBox => {
                            if (solidBox.name == 'air-pano16-7&pano14-13') {
                                console.log(3)
                            }

                            if (solidBox.boxType != box.boxType && (solidBox.boxType == 'air-hanging' || box.boxType == 'air-hanging')) return //挂空调一般不会撞到地面上的
                            let p1 = getBoxPos(solidBox)
                            let p2 = getBoxPos(box)
                            let p1_ = new THREE.Vector2(p1.x, p1.z)
                            let p2_ = new THREE.Vector2(p2.x, p2.z)

                            let maxWidth = standards[box.boxType].widthNormal.max / 2
                            maxWidth = THREE.MathUtils.clamp(maxWidth, tolerateWidth.min, tolerateWidth.max) //因为场景精度存在较大误差，所以maxWidth不能过小，否则像灭火器摄像头都容易findRest多个

                            let dis = solidBox.bound.distanceToPoint(p2)

                            //let r0 = solidBox.boxType == 'air' ? 2 : solidBox.boxType == 'battery' ? 1.1 : 1 //空调最不容易扎堆放置，所以范围设置广一些
                            let r0 = standards[box.boxType].closeRatio

                            let r1 = math.linearClamp(box.pano.position.distanceTo(p2), 3, 8, 1, 2) //距离远的话识别、计算都会更不准确，给一定的容错. 远的尽量不findRest，即尽量>0

                            let ra = (solidBox.boxType == box.boxType ? 1 : 0.5) * r0 * r1 //数字越小限制越大

                            /* let a = maxWidth * maxWidth * ra - p1_.distanceToSquared(p2_)
                            let b = -dis * dis * 0.7  
                            let c = a + b*/

                            let c = maxWidth * ra - dis * 1.3

                            if (c > 0) {
                                //太近 不创建
                                console.log(1)
                            }
                            return c > 0
                        })
                        if (!near) {
                            reMatchLowScores([{ box0: box, log: 'findRest' }], groups, { startIndex: 0 })
                        } else {
                            //console.log('find near', near.name, box.sid)
                        }
                    }
                })
            }

            function used(box) {
                //是否已经使用过
                let has = e => {
                    return e.box0 == box || e.box1 == box
                }
                let traverse = e => {
                    return (
                        has(e) ||
                        (e.list && e.list.some(a => traverse(a))) ||
                        (e.mixedFrom && e.mixedFrom.some(a => traverse(a))) ||
                        (e.infos && e.infos.some(u => u.group.some(r => r.boxes.some(b => b == box))))
                    ) //row
                }
                return boxesSolid.some(e => traverse(e))
            }
            function reMatchLowScores(lowScores, groups, { startIndex = 2, fake } = {}) {
                let matched = [],
                    tooLows = []
                let minScore = boundConfirmed ? -2000 : -800
                let isSameMatch = (match0, match1) => {
                    //是否对应同一个box实体（不一定准），通过两两box之间是否都match来判断
                    //如果是相同pano但不同的box肯定不是对应同一个box实体
                    let ifWrong = (box0, box1) => {
                        if (box0 == box1) return
                        if (box0.pano == box1.pano) return true
                        let match2 = getMatchScore(box0, box1, { isSingle: true, restMatch: true })
                        if (match2.score < minScore) return true
                    }
                    if (ifWrong(match0.box0, match1.box0) || ifWrong(match0.box1, match1.box1) || ifWrong(match0.box0, match1.box1) || ifWrong(match0.box1, match1.box0)) return
                    return true
                }
                if (lowScores.length) {
                    console.warn(lowScores[0].log || (lowScores[0].box1 ? '低分重新匹配' : '剩余匹配'), lowScores[0].box0.boxType, ...lowScores)

                    if (lowScores[0].box1) {
                        lowScores.sort((a, b) => {
                            //低分优先
                            return a.score - b.score
                        })
                    }

                    lowScores.forEach(info => {
                        //info中的box0和box1分别向后寻找其他的配对。选择分数高的配对。 但box0和box1可能是错误配对，会导致找到了替代的也可能遗漏。
                        /* if (info.name == 'pano0-3&pano2-3') {
                            console.log(1)
                        } */

                        let box01 = info.box0
                        let box02 = info.box1
                        let bigGroup = []
                        box02 && bigGroup.push(info)

                        let got
                        for (let cur = startIndex; cur < groups.length; cur++) {
                            let thirdGroup = groups[cur]
                            let scores0 = [],
                                scores1 = []

                            thirdGroup.forEach(box1 => {
                                //if (matched.includes(box1.sid)) return
                                if (used(box1)) return //会不会太严格？
                                if (box1.pano != box01.pano && box1 != box02) {
                                    let r1 = getMatchScore(box01, box1, { isSingle: true, restMatch: true })
                                    r1.score > minScore * 1.5 && scores0.push(r1)
                                }
                                if (box02 && box1.pano != box02.pano && box1 != box01) {
                                    let r2 = getMatchScore(box02, box1, { isSingle: true, restMatch: true })
                                    r2.score > minScore * 1.5 && scores1.push(r2)
                                }
                            })
                            scores0.sort((a, b) => {
                                return b.score - a.score
                            })
                            scores1.sort((a, b) => {
                                return b.score - a.score
                            })
                            scores0[0] && bigGroup.push(scores0[0])
                            scores1[0] && bigGroup.push(scores1[0])
                        }

                        bigGroup.sort((a, b) => {
                            return b.score - a.score
                        })

                        let goodList = bigGroup.slice(0, 10).map(e => {
                            if (!getBoxPos(e)) return e
                            preDealBox(e)
                            getBoxSize(e)

                            return e
                        })

                        let goodList2 = goodList
                            .sort((a, b) => {
                                return b.score - a.score
                            })
                            .slice(0, 3)

                        if (goodList2.length == 0) {
                            return fake || createSinglePano(box01, 0.6) //minScorePercent原因：剩余匹配时位置不太好的案例： AhMgXXjM15
                        }

                        if (goodList2[0].score > minScore * 0.65) {
                            goodList2 = goodList2.filter(e => e.score > minScore * 0.65)
                        } else {
                            /* goodList2 = [goodList2[0]] // 最高分已经过小
                            if (goodList2[0].score < -1500) { */
                            if (!box02) {
                                if (info.log == 'findRest' || getBoxPos(box01).distanceTo(box01.pano.position) < 2.5) {
                                    //远距离不准，留到过后findRest
                                    fake || createSinglePano(box01)
                                }
                                return
                            }
                            //console.warn('分数过低,是否有匹配错误？', goodList2[0])
                            return tooLows.push(goodList2[0])
                            //}
                        }

                        if (goodList2.length) {
                            //需要确认两两之间是配对的，也就是都对应同一个box
                            let subGroups = [],
                                boxes = []
                            for (let i = 0, len = goodList2.length; i < len; i++) {
                                //向后选择队友
                                let match0 = goodList2[i]
                                if (subGroups.some(e => e.includes(match0))) continue //被挑选了的没有选择权

                                let gr = [match0]
                                for (let j = i + 1; j < len; j++) {
                                    let match1 = goodList2[j]
                                    if (isSameMatch(match0, match1)) {
                                        //可能不是同一个，所以需要检验
                                        gr.push(match1)
                                    }
                                }
                                //if(gr.length>1){
                                subGroups.push(gr)
                                //}
                            }
                            //console.log('lowScores subGroups', subGroups)
                            subGroups.forEach(pair => {
                                boxes.push(mixMatchBox(pair, lowScores[0].log, fake))
                            })
                            fake || combineBoxes(boxes) //很可能其实还是同一个，需要检验是否要融合
                        }
                    })

                    //改为之后 findRest, 因为两者都single的可能性低

                    /* let judge = box => {
                        if (!used(box)) {
                            matched.push(box)
                            createSinglePano(box)
                        }
                    }
                    tooLows.forEach(e => {
                        judge(e.box0)
                        judge(e.box1)
                    }) */
                }
            }

            function mixMatchBox(list, log, fake) {
                let center = new THREE.Vector3(),
                    size = new THREE.Vector3(),
                    name,
                    bound = new THREE.Box3()

                list.forEach(e => {
                    let _bound = new THREE.Box3().setFromCenterAndSize(getBoxFinalPos(e), e.size)
                    bound.union(_bound)
                })
                //bound.getCenter(center) //这两种获得center的方法哪个准？
                bound.getSize(size)

                list.forEach(e => center.add(getBoxPos(e)))
                center.multiplyScalar(1 / list.length)

                let { xProp, yProp } = list.find(e => e.xProp) || {}
                if (xProp && list.find(e => e.xProp && e.xProp != xProp)) {
                    //如果有不同的话
                    xProp = yProp = null
                }
                let prefix = log == 'findRest' ? 'rest:' : 'low:'
                let object = {
                    name: prefix + list.map(e => e.name),
                    boxType: list[0].boxType,
                    center,
                    size,
                    list,
                    xProp,
                    yProp,
                }
                xProp || getBoxDirProp(object)
                let o = restrictSize(size.x, size.y, size.z, object)
                size.x = o.x
                size.y = o.y
                size.z = o.z
                object.fake = fake
                let box = new Box(object)
                //console.log('mixMatchBox', box)
                return box
            }

            function combineBoxes(boxes, typeCount) {
                //调试  tY4ot33f8vT  UWrshepp0G5的一高一低的电箱
                //判断这些实体boxes是否需要合并  主要用于重复识别（重叠面积较大）  电池还可能是拼接
                const group = []
                if (boxes.length > 1) {
                    let boxType = boxes[0].boxType
                    let { min, max } = standards[boxType].widthNormal

                    for (let i = 0, len = boxes.length; i < len - 1; i++) {
                        let box0 = boxes[i]
                        if (box0.fake) continue
                        for (let j = i + 1; j < len; j++) {
                            let box1 = boxes[j]
                            if (box1.fake) continue
                            let bound = box0.bound.clone().union(box1.bound)
                            let size = bound.getSize(new THREE.Vector3())
                            let intersect = box0.bound.intersectsBox(box1.bound)

                            if (box0.boxType == 'electric') {
                                console.log(1)
                            }
                            let minX = min,
                                minZ = min,
                                maxX = max,
                                maxZ = max,
                                maxY = standards[boxType].height.max

                            if (box0.xProp && box1.xProp && box0.xProp == box1.xProp) {
                                maxX = standards[boxType][box0.xProp].max
                                maxZ = standards[boxType][box0.yProp].max
                                /* minX = standards[boxType][box0.xProp].min
                                minZ = standards[boxType][box0.yProp].min */
                                if (box0.boxType != box1.boxType) {
                                    //air & airSmart
                                    maxX = Math.max(maxX, standards[box1.boxType][box1.xProp].max)
                                    maxZ = Math.max(maxZ, standards[box1.boxType][box1.yProp].max)
                                    /* minX = Math.min(minX, standards[box1.boxType][box1.xProp].min)
                                    minZ = Math.min(minZ, standards[box1.boxType][box1.yProp].min) */
                                }
                            }

                            maxX = Math.max(maxX, box0.size.x, box1.size.x) //必须大于各自的size,否则无法去除本身就oversize的box中包含的
                            maxZ = Math.max(maxZ, box0.size.z, box1.size.z)
                            maxY = Math.max(maxY, box0.size.y, box1.size.y)

                            let r = intersect ? 1.5 : 1.3 /*  / standards[box1.boxType].closeRatio */ //如果是没有交集，限制更大些

                            //若需要更精确的结果，可以getMixBox算出重叠面积，重叠少，且各自都不太小，就不合并。但考虑到电池边界很模糊，合并了也无大碍。
                            if (box0.boxType == 'battery') {
                                r *= 1.3 //比较可能扎堆
                            }

                            let maxDiff = 0.4,
                                maxDiffX = maxDiff,
                                maxDiffZ = maxDiff,
                                rx = r,
                                rz = r
                            if (standards[box0.boxType].atWall == 1) {
                                //在墙面上不可能叠放，所以厚度限制可放宽
                                let s = 4
                                if (box0.yProp == 'width') {
                                    maxDiffX *= s
                                    rx *= s
                                } else if (box0.xProp == 'width') {
                                    maxDiffZ *= s
                                    rz *= s
                                }
                            }

                            //如果某个点位含有类似和这俩相近的box:  A9rCPzp2UD9两个fire合并了。好难写，算了
                            /* if(box0.boxType){
                                this.datasMixed
                                rx = rz = 1.1 
                            } */

                            if (size.x - maxX < maxDiffX && size.x < maxX * rx && size.z < maxZ * rz && size.z - maxZ < maxDiffZ && size.y < maxY * r && size.y - maxY < maxDiff) {
                                //总size不会太大
                                common.pushToGroupAuto([box0, box1], group)
                            }
                        }
                    }

                    if (group.length) {
                        //虽然如果三个以上可能会超出maxWidth。 不过3个的概率很低，且可以限制宽度
                        group.forEach(pair => {
                            let boxTypes = []
                            let bound = new THREE.Box3()
                            pair.forEach(e => {
                                bound.union(e.bound)
                                e.dispose()

                                if (typeCount > 1) {
                                    //判断boxType: 寻找所使用的box总分最高的boxType
                                    let a = boxTypes.find(a => a.boxType == e.boxType)
                                    let score = 0
                                    let add = box => {
                                        box && (score += box.score)
                                    }
                                    e.traversePair(e => {
                                        add(e.box0)
                                        add(e.box1)
                                    })
                                    if (a) {
                                        a.score += score
                                    } else {
                                        boxTypes.push({ score, boxType: e.boxType })
                                    }
                                }
                            })
                            if (typeCount > 1) {
                                boxTypes.sort((a, b) => {
                                    return b.score - a.score
                                })
                                boxType = boxTypes[0].boxType
                            }
                            let size = bound.getSize(new THREE.Vector3())
                            let center = bound.getCenter(new THREE.Vector3())
                            let { xProp, yProp } = pair.find(e => e.xProp) || {}

                            if (xProp && pair.find(e => e.xProp && e.xProp != xProp)) {
                                //如果有不同的话
                                xProp = yProp = null
                            }

                            let info = {
                                name: 'mix:' + pair.map(e => ' ' + e.name),
                                mixedFrom: pair,
                                boxType,
                                center,
                                size,
                                xProp,
                                yProp,
                            }
                            xProp || getBoxDirProp(info)
                            let o = restrictSize(size.x, size.y, size.z, info)
                            size.x = o.x
                            size.y = o.y
                            size.z = o.z
                            let box = new Box(info)
                            console.error('混合', boxType, pair, box)
                        })
                    }
                }
            }

            function combines(types) {
                //合并boxSolids .  battery经常嵌套
                if (!(types instanceof Array)) types = [types]
                let boxes = boxesSolid.filter(e => types.includes(e.boxType))
                combineBoxes(boxes, types.length)
            }

            let createSinglePano = (box, minScorePercent = 1) => {
                //仅用一个pano中的data来创建。  悬挂于墙上的准确性依赖于墙的准确性。

                if (box.score < MinBoxInitialScore) {
                    //如Xszq2fv03b的电池pano8-0其实是纸箱、 WZQoMbNmNTu的pano14-0分数0.649
                    return console.error('取消createSinglePano： 线框识别分数低，可能错误', box)
                }

                getBoxBase(box)

                let center = getBoxPos(box)
                if (safeBound.distanceToPoint(center) > 0.5) {
                    return console.log('取消createSinglePano：超出safebound', box) //可能是错误的线框，如H7pg1tO9oeJ pano8-1
                }

                let info = {
                    name: box.sid,
                    box0: box,
                    center,
                    topPos: box.topPos,
                    btmPos: box.btmPos,
                }

                preDealBox(info)
                const minScore = -500 * minScorePercent //调试 3MnIWabM6ne Tmo1vLp9Q13
                let a = getPoseScore(info.boxposes, box.boxType /* true */)
                if (!standards[box.boxType].bottom && box.btmPos) {
                    a -= (box.btmPos.y - groundY) * 3000 //底部被遮住一部分
                }
                let failed = a < minScore

                console.log('createSinglePano', failed ? '失败' : '成功', 'pose score:', a, box.sid, box)
                if (failed) return

                //addLabel(center, 'center', { a: 0.3 })
                //info.topPos && addLabel(info.topPos, 'topPos', { a: 0.3 })
                info.score = a
                getBoxSize(info)
                new Box(info)
            }

            //去除挨得很近的漫游点，因为两个接近的点match出的值误差很大
            {
                this.removedDatas = {}
                let panoIds = Object.keys(this.datas)
                let len = panoIds.length
                for (let i = 0; i < len; i++) {
                    let pano0 = player.model.panos.index[panoIds[i]]
                    for (let j = i + 1; j < len; j++) {
                        let pano1 = player.model.panos.index[panoIds[j]]
                        if (pano0.position.distanceToSquared(pano1.position) < 0.01) {
                            //离的很近。保留shape多的那个data
                            let remove
                            if (this.datas[panoIds[i]].shapes.length > this.datas[panoIds[j]].shapes.length) {
                                remove = panoIds[j]
                            } else {
                                remove = panoIds[i]
                            }
                            console.log(`删除pano${remove}的data，因pano${panoIds[i]}和pano${panoIds[j]}很近`)
                            this.removedDatas[remove] = this.datas[remove]
                            delete this.datas[remove]
                        }
                    }
                }
            }

            //this.expandModelBound()

            // if (version == 'vision') this.datasMixed = common.CloneObject(this.datas, null, [player.model.panos.list[0].constructor])
            if (version == 'vision')
                this.datasMixed = common.CloneObject(this.datas, null, undefined, data => {
                    return data['category']
                })

            /* Search('cabinet')
            Search('air')
            Search('battery') */

            for (let i in typeNames) {
                Search(i)
            }

            console.log('----FindRest----')
            waitFindRest.forEach(e => {
                findRest(...e.args)
                if (e.type != 'air' && e.type != 'airSmart' && e.type != 'cabinet') combines(e.type)
            })
            combines(['air', 'airSmart']) //这两种合在一起combine，因为太像了容易识别出多个 nZrBdvRaDuC

            console.log('cost:', Date.now() - startTime, 'ms,  boxSolid:', this.boxesSolid)
        }

        /* let getSid = (function(){
            let sid = 0
            return function(){
                return sid++
            }
        })() */
        let done = () => {
            for (let panoId in this.datas) {
                if(!this.datas[panoId])continue
                this.datas[panoId].shapes = this.datas[panoId].shapes.map((shape, i) => {
                    return Object.assign(
                        {
                            sid: 'pano' + panoId + '-' + i,
                            category: shape.category, //提前 便于调试
                            pano: player.model.panos.index[panoId],
                            index: i,
                        },
                        shape
                    )
                })
            }
            this.panoBound = new THREE.Box3()
            player.model.chunks.forEach(e => {
                modelBound.union(e.geometry.boundingBox) //注：不用model.boundingBox是 因为union了pano的position的
            })
            //针对部分模型错误，只有底面的，union一下pano.position

            let minY = Infinity,
                minYs = []
            let panos = player.model.panos.list.filter(e => e.isAligned())
            panos.forEach(e => {
                let bound = new THREE.Box3().setFromCenterAndSize(e.position, new THREE.Vector3(0.1, 0.1, 0.1))
                modelBound.union(bound)
                this.panoBound.union(bound)
                minY = Math.min(e.floorPosition.y, minY)
                //avePanoFY += e.floorPosition.y
                minYs.push(e.floorPosition.y)
            })

            groundY = modelBound.min.y
            minYs.sort((a, b) => {
                return a - b
            })
            console.log(minYs)

            let midFloorY = minYs[Math.floor(minYs.length / 2)]
            console.error('minY', minY, 'midFloorY', midFloorY, '原groundY', groundY)
            this.minY = minY

            //部分模型底部高度错误
            /* if (minY > groundY) {
                console.error('minY > groundY', minY, groundY)
                groundY = modelBound.min.y = midFloorY //案例nZrBdvRaDuC
            } else {
                if (groundY - minY > 0.05) console.warn('minY', minY, 'groundY', groundY)
                groundY = modelBound.min.y = midFloorY   , document.title += ' new' //修改以后未必更好所以暂时不修改  变更好的：eGhyf5QdVHA
            } */
            groundY = modelBound.min.y = midFloorY //这个y可能不准。需要通过fire的btmPos.y来确定
            safeBound = this.safeBound = modelBound

            groundPlane.setFromNormalAndCoplanarPoint(new THREE.Vector3(0, 1, 0), new THREE.Vector3(0, groundY, 0))

            this.ifAnalyze && beginCompute()
            if (version == 'vision') this.load(player.currentPano.id)
        }
        async function load(panoId) {
            let data = await http.post('/service/scene/sceneMarkShape/getInfo', { num: player.$app.config.num, imagePath: panoId + '.jpg' })
            // console.error(data)
            if (!data.data || !data.success) return (this.datas[panoId] = null)
            this.datas[panoId] = data.data

            if (Object.keys(this.datas).length == panosCount && !player.model.panos.list.some(e => e.isAligned() && !(panoId in this.datas))) {
                done()
            }
        }
        async function loadAll() {
            let data = await http.post('/service/shapes/sceneMarkShape/getInfos', { num: player.$app.config.num })
            console.error(data)
            if (!data.data || !data.success) return
            data.data.forEach(e => {
                let panoId = e.imagePath.split('.jpg')[0]
                this.datas[panoId] = e
            })
            done()
        }

        let panosCount = 0
        if (!dataList) {
            /* player.model.panos.list.forEach(e => {
                if (!e.isAligned()) return
                panosCount++
                load.bind(this)(e.id)
            }) */
            
            loadAll.bind(this)() //测试环境
        } else {
            //when  version == 'output'
            dataList.forEach(e => {
                let panoId = e.imagePath.split('.jpg')[0]
                this.datas[panoId] = e
            })
            done()
        }
    }

    expandModelBound() {
        //有的模型太窄，容易将一排的柜体当做墙壁。所以可以根据box位置扩展bound.  （如果因为点位太少，导致内部的电池远超模型范围，就不管了。R7xZsmm9FsG）
        const maxDis0 = 1, //最终位置不会超过这个距离
            maxDis1 = 3 //搜寻范围。不可扩展太宽，否则不准确的框会飘很远，甚至多画多个box，如R7xZsmm9FsG
        let newBound = modelBound.clone()

        let list = []

        for (let panoId in this.datas) {
            if(!this.datas[panoId])continue
            this.datas[panoId].shapes.forEach(box => {
                getBoxBase(box)
                if (box.sid == 'pano2-10') {
                    console.log(4)
                }
                if (box.btmPosPredict) {
                    let far = box.pano.position.distanceToSquared(box.btmPosPredict)
                    if (far > 20) return //太远不准
                    let dis = modelBound.distanceToPoint(box.btmPosPredict)
                    if (dis > 0 && dis < maxDis1) {
                        //maxDis1用来防air-hanging和一些错误的框
                        list.push({ box, dis })
                    }
                }
            })
        }

        list.sort((a, b) => a.dis - b.dis)
        //let mid = list[Math.floor(list.length/2)]
        let mid = list.length //  /2
        for (let i = 0; i < mid; i++) {
            let box = list[i].box
            let pos = box.btmPosPredict
            if (list[i].dis > maxDis0) {
                let p1 = pos.clone().clamp(modelBound.min, modelBound.max)
                let vec = new THREE.Vector3().subVectors(pos, p1).normalize().multiplyScalar(maxDis0)
                pos = new THREE.Vector3().addVectors(p1, vec)
            }
            let marginBound = new THREE.Box3().setFromCenterAndSize(pos, new THREE.Vector3(0.2, 0, 0.2))
            newBound.union(marginBound)
        }

        skyBoxTight = new BoundingMesh(
            newBound,
            new THREE.MeshBasicMaterial({
                side: THREE.DoubleSide,
                wireframe: true,
                transparent: true,
                opacity: 0.05,
            }),
            0
        )
        //skyBoxTight.visible = false
        skyBoxTight.updateMatrixWorld() //不update的话raycaster是错的
        meshGroup.add(skyBoxTight)

        this.skyBoxTight = skyBoxTight
        this.safeBound = this.safeBoundFirstVer = safeBound = newBound
        boundConfirmed = true
        console.log('bound1:', this.safeBound.min.toArray(), this.safeBound.max.toArray())
    }

    expandModelBound2(type) {
        let material = skyBoxTight.material
        skyBoxTight.geometry.dispose()

        boxesSolid.forEach(e => {
            if (e.boxType != type) return
            this.safeBound.union(e.bound)
        })

        skyBoxTight = new BoundingMesh(this.safeBound, material, 0)
        //skyBoxTight.visible = false
        skyBoxTight.updateMatrixWorld() //不update的话raycaster是错的
        meshGroup.add(skyBoxTight)

        this.skyBoxTight = skyBoxTight
        console.log('bound2:', this.safeBound.min.toArray(), this.safeBound.max.toArray())
    }

    /* adjustModelBound(type){
        if(standards[type].atWall != 1)return //必须是挂墙的
        
        this.lastSafeBound = this.safeBound.clone()
        let list = []
        let add = e => {
            if (e.btmPos && e.box1 && e.minAng>10  ) {
                //有 box1才能确定是getIntersect得到的pos  
                list.includes(e) || e.push(e)
            }
        }
        this.boxesSolid.forEach((solidBox)=>{
            if(solidBox.boxType != type)return
            solidBox.traversePair(add)
        })
        let wallSides = {'x+': 0, 'x-': 0, 'z+': 0, 'z-': 0}
        let getBoxSide = (e)=>{  
            for(let i in e.panosDir){
                if(e.panosDir[i] != 0){
                    wallSides[i] += 1 
                }
            } 
        }
        
        if(list.length){
            this.safeBound = this.panoBound.clone()
            list.forEach((e)=>{ 
                this.safeBound.union(e.bound)//还是说使用cIntersect来expand？
                getBoxSide() 
            })
        }
        
        
        skyBoxTight = new BoundingMesh(this.safeBound, material, 0)
        //skyBoxTight.visible = false
        skyBoxTight.updateMatrixWorld() //不update的话raycaster是错的
        meshGroup.add(skyBoxTight)

        this.skyBoxTight = skyBoxTight
        
        //主要目的，针对那些模型比room大得多的情况，比如多了门外的部分，造成墙面不准。
        //monitor的可以完全决定位置。其他的只能收缩（但是不能收缩超过panos和第一次expand的那些btm的bound里）
        //太麻烦了，且考虑到即使墙面完全准确也可能反倒把它变的不准的风险。
        
    } */

    /* 最低点使用fire的吗
    MW6MEeCOy9Y  只有最近三个点和fire接近
    3MnIWabM6ne   fire combine了

    ov5NTEImzhW fire多个   
    n4z0yd5tQaF fire多两个错位离谱的。。   位置和显示的不一样。。

    5BaiXkK6Ag1 fire算的不太准 低了0.1 样本数仅两个  

 */

    confirmGroundY(type) {
        //利用fire来确定地面高度(会稍低于地板，但box框不打滑且xz更准，估计因box框比box大)。调试：3MnIWabM6ne up9PPZkx1px 4GqaqNdyjGfs GFbQi1LiSij
        if (boundConfirmed) return
        let btmYs = [],
            pairs = [],
            needCount = 5,
            maxDis = 3,
            btmY = 0

        let add = e => {
            if (e.btmPos && e.box1 /* && e.score >= minScore */) {
                //有 box1才能确定是getIntersect得到的pos
                pairs.push(e)
            }
        }
        boxesSolid.forEach(e => {
            if (e.boxType != type) return
            e.traversePair(add)
        })

        let usePairs = pairs
        if (pairs.length > needCount) {
            //调试：Y8czF2Z3h9m
            let disMap = new Map()
            pairs.forEach(e => {
                disMap.set(e, Math.max(e.box0.pano.position.distanceTo(e.box0.btmPosPredict), e.box1.pano.position.distanceTo(e.box1.btmPosPredict)))
            })
            pairs.sort((a, b) => {
                return disMap.get(a) - disMap.get(b)
            }) //距离从近到远 . 远处的高度可能偏离严重，就不管了，而且框也不一定准
            usePairs = pairs.slice(0, needCount)
            for (let i = needCount; i < pairs.length; i++) {
                if (disMap.get(pairs[i]) < maxDis) {
                    usePairs.push(pairs[i])
                }
            }
        }
        usePairs.forEach(e => {
            //有 box1才能确定是getIntersect得到的pos
            let btmY_ = e.btmPos.y
            const width = e.size.x / 2
            let h0 = width / Math.tan(Math.acos(-e.box0.centerBtmDir.y)) //|centerBtmDir.y| 即俯视角度的cos
            let h1 = width / Math.tan(Math.acos(-e.box1.centerBtmDir.y))
            let h = Math.min(h0, h1) //选个小的吧，因浅的会更快接触到中心，虽然交点是两条射线最近点 不一定在fire中心
            //如果毫无误差，且centerBtmDir.y相同，只要两条线centerBtmDir的xz相同，交点就是和地面的交点，而只要不同，交点就是和地面的交点，而只要不同，交点必然是在fire中心之下。随着minAng和centerBtmDir.y 交点在这中间变化
            let r = math.linearClamp(e.minAng, 0, 90, 0, 1)
            btmY_ += h * r
            btmYs.push(btmY_)
            btmY += btmY_
        })
        btmY /= btmYs.length
        if (btmYs.length) {
            console.error(
                'confirmGroundY',
                btmY,
                /* '样本数', btmYs.length,  */ btmYs,
                usePairs.map(e => e.name),
                pairs
            )
            /* if(btmYs.length == 1 && pairs[0].minAngle<12 &&  ){
                
            } */

            groundY = this.safeBound.min.y = this.panoBound.min.y = btmY //   = -1.1
            groundPlane.setFromNormalAndCoplanarPoint(new THREE.Vector3(0, 1, 0), new THREE.Vector3(0, groundY, 0))
        }

        let { min, max } = standards[type].height
        boxesSolid.slice().forEach(e => {
            if (e.boxType != type) return

            if (e.fake) {
                e.dispose()
                return
            }

            let topY = e.topPos
                ? e.topPos.y
                : e.list.reduce((w, c) => {
                      return w + c.topPos.y
                  }, 0) / e.list.length

            e.size.y = THREE.MathUtils.clamp(topY - groundY, min, max)
            e.setFromInfo(e)
            if (version == 'vision') e.draw()
        })
        this.panoBound
        this.expandModelBound()
    }

    bindEvents() {
        if (version != 'vision') return

        player.on(PlayerEvents.FlyingStarted, e => {
            //if(e.mode == 'dollhouse')return
            // 点位跳转前清除已有线框
            this.traverse(obj => {
                if (obj.isMesh) {
                    obj.geometry.dispose()
                    obj.material.dispose()
                }
            })
            this.wireframes.clear()
            this.currentId = null
        })

        player.on(PlayerEvents.FlyingEnded, () => {
            // 点位跳转后加载线框
            if (player.mode != Viewmode.PANORAMA) return // 只有PANORAMA模式下需要加载
            this.load(player.currentPano.id)
        })

        window.boxFrame = this
        if (this.ifAnalyze) {
            setTimeout(() => {
                {
                    let btn = document.createElement('button')
                    btn.innerHTML = '点击切换box显示'

                    btn.onclick = () => {
                        this.boxesSolid.forEach(e => ((e.boxHelper.visible = !e.boxHelper.visible), (e.label.visible = !e.label.visible)))
                    }
                    document.querySelector('#app').appendChild(btn)
                    btn.id = 'boxWire'
                    btn.style.position = 'fixed'
                    btn.style['z-index'] = '100'
                    btn.style.background = '#e00472'
                    btn.style.padding = '10px'
                    btn.style.bottom = '80px'
                }

                {
                    let btn = document.createElement('button')
                    btn.innerHTML = '点击切换矩形框显示'

                    btn.onclick = () => {
                        this.wireframes.visible = !this.wireframes.visible
                    }
                    document.querySelector('#app').appendChild(btn)
                    btn.id = 'wireframes'
                    btn.style.position = 'fixed'
                    btn.style['z-index'] = '100'
                    btn.style.background = '#419aff'
                    btn.style.padding = '10px'
                    btn.style.bottom = '130px'
                }
            }, 1000)
        }
    }

    /**
     * 加载点位标记数据
     * @param {*} panoId
     */
    load(panoId) {
        let data = this.datasMixed[panoId] || this.datas[panoId]
        if (!data) {
            if (!(panoId in this.datas))
                setTimeout(() => {
                    this.load(panoId)
                }, 100) //否则无数据
            return
        }
        if (player.currentPano.id != panoId || player.flying || this.currentId == panoId) return // 防止连续跳转点位时，clear后才load好上一点位的数据，导致出现之前的标记

        this.currentId = panoId

        let { shapes, imageHeight, imageWidth } = data //data.data
        let allShapes = shapes.slice()
        shapes.forEach(e => {
            if (e.boxes) allShapes.push(...e.boxes)
        })
        let fireIndex = 0
        allShapes.forEach(shape => {
            // 填充色和线框色
            // let { fill_color, line_color } = shape

            getUVs(shape)
            getCenterDir(shape, player.currentPano)

            let { fill_color, color = [56, 56, 255] } = shape
            let line_color = [...color, 255]

            if (!fill_color) fill_color = [255, 255, 255, 0]
            if (!line_color) line_color = [255, 0, 0, 255]
            if (shape.boxes) {
                line_color = [20, 205, 255, 255]
            }

            let pos = getBoxPos(shape)
            let dis = pos ? shape.pano.position.distanceTo(getBoxPos(shape)) : 1
            let labelShift = (shape.boxType == 'fire' ? 0 : -0.2) / dis

            this.showSignalFrom2d(
                shape.category + '-' + shape.sid,
                shape.bbox2,
                imageWidth,
                imageHeight,
                {
                    fill: {
                        color: new THREE.Color().setRGB(fill_color[0] / 255, fill_color[1] / 255, fill_color[2] / 255),
                        opacity: fill_color[3] / 255,
                    },
                    line: {
                        color: new THREE.Color().setRGB(line_color[0] / 255, line_color[1] / 255, line_color[2] / 255),
                        opacity: shape.category == 'cabling_rack' ? 0.4 : line_color[3] / 255, //走线架太绕，扰乱视线
                    },
                },
                shape.centerDir,
                labelShift,
                shape.state == '被删除'
            )
        })
        // })
        // .catch(err => console.log(`点位${panoId}无标记数据或数据出错：`, err))
    }

    /**
     * 根据坐标标记全景图
     *
     * 存在的问题：如果要准确复现全景图上的线框，上下边框会变为弧形。而按顶点连直线的话，180度以上会出bug。
     * 解决方式：目前150度以下只画出4个顶点然后连直线，150度以上准确画出全景图线框。
     */
    showSignalFrom2d(name, rect, w, h, options, centerDir, labelShift, removed) {
        // 目前rect给的是矩形对角的两个点坐标，将它扩展成四个顶点
        let cornerArr = [new THREE.Vector2(rect[0], rect[1]), new THREE.Vector2(rect[2], rect[1]), new THREE.Vector2(rect[2], rect[3]), new THREE.Vector2(rect[0], rect[3])]

        // 根据四个顶点，填充中间点
        let pointArr = []
        for (let i = 0; i < cornerArr.length; i++) {
            let corner1 = cornerArr[i]
            let corner2 = cornerArr[(i + 1) % cornerArr.length]
            pointArr.push(corner1)

            /* // 横向角度超过150度时，3d中边框的弧线已经不太明显，准确画出全景图线框
            if ((rect[2] - rect[0]) / w < 5 / 12 && i % 2 == 0) continue

            const vec = [corner2[0] - corner1[0], corner2[1] - corner1[1]]
            let length = Math.sqrt(vec[0] * vec[0] + vec[1] * vec[1])
            let num = length / 150

            for (let j = 1; j <= num; j++) {
                pointArr.push([corner1[0] + (vec[0] / num) * j, corner1[1] + (vec[1] / num) * j])
            } */
        }

        //pointArr.push(cornerArr[0], cornerArr[2], cornerArr[1], cornerArr[3]) //对角线

        let points = []
        pointArr.forEach(uv => {
            let dir = getDirByUV(uv, player.currentPano)
            // points.push(dir.sub(centerVec))  // 计算其他点相对于中点的坐标，方便旋转平移等
            points.push(dir)
        })

        // 线框
        const lineGeometry = new THREE.BufferGeometry().setFromPoints(points)
        const lineMaterial = new THREE.LineBasicMaterial({ color: options.line.color, opacity: options.line.opacity, transparent: true, depthTest: false })
        const wireframe = new THREE.LineLoop(lineGeometry, lineMaterial)
        // wireframe.position.copy(centerVec)  // 将中点作为线框坐标
        wireframe.renderOrder = 100

        // 填充颜色
        const fillGeometry = lineGeometry.clone().setIndex(new THREE.BufferAttribute(new Uint16Array([0, 1, 3, 2, 3, 1]), 1))
        const fillMaterial = new THREE.MeshBasicMaterial({ color: options.fill.color, opacity: options.fill.opacity, transparent: true, side: THREE.DoubleSide, depthTest: false })
        const plane = new THREE.Mesh(fillGeometry, fillMaterial)
        plane.renderOrder = wireframe.renderOrder - 1
        wireframe.add(plane)

        // 名称
        const textMesh = new TextSprite({
            text: name,
            backgroundColor: { r: options.line.color.r * 255, g: options.line.color.g * 255, b: options.line.color.b * 255, a: options.line.opacity * 0.5 },
            textColor: { r: 255, g: 255, b: 255, a: options.line.opacity * 1.1 },
            borderRadius: 15,
            renderOrder: wireframe.renderOrder + 1,
            player: player,
        })
        //const shift = new THREE.Vector3(0, labelShift , 0)
        textMesh.position.copy(centerDir /* .clone().add(shift).normalize() */)
        textMesh.lookAt(0, 0, 0) // 看向相机
        textMesh.scale.set(0.12, 0.12, 0.12)
        /* let line = addLine(centerDir, shift, null, options.line.color)
        line.material.opacity = options.line.opacity */

        let group = new THREE.Group()
        group.position.copy(player.currentPano.position)
        group.add(wireframe)
        group.add(textMesh)
        //group.add(line)
        this.wireframes.add(group)

        if (removed) {
            textMesh.sprite.material.opacity = 0.4
            lineMaterial.opacity *= 0.6
            lineMaterial.color.set('#efe')
        }
    }
}