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'
 
 

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

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


let player,
    skyBoxTight,
    meshGroup,
    ray = new THREE.Raycaster(),
    groundPlane = new THREE.Plane()
let groundY, safeBound //安全区域应该在扣除每种类型柜子大概的长宽的一半
let hue = 0
let boxes = []
let standards = {
    cabinet: { 
        widthNormal: { min: 0.6, max: 0.7 }, //widthNormal是不计宽还是厚度的平均宽度
        height:{min: 0.7, max:2.5, standard:2},  
    },
    air: {
        widthNormal: { min: 0.35, max: 0.7 },
        width: { min: 0.6, max: 0.75 },
        thick: { min: 0.3, max: 0.4 },
        height: {min:1.4, max:1.95,   standard: 1.8}, //standard是通常出现的最高高度
       
    },
    '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}, 
        bottom: { min: 0.8, max: 2.0 },  // 不绝对，大部分
    },
    battery: {
        widthNormal: { min: 0.4, max: 1.2},
        width: { min: 0.7, max: 1.4 },
        thick: { min: 0.35, max: 0.5 }, 
        height:{min:0.3, max:1.3, standard:1.1  }, //maxHeight
        //有的电池很小。考虑是否追加battery-little 并且限制大电池的长宽高比例
    },
    rowBigBox: {
        widthNormal: { min: 0.5, max: Infinity },
        height: {min: 0.7, max:2.4, standard:2}, 
    },
}

let addLabel = (pos, text, { bgcolor, a } = {}) => {
    
    if(version != 'vision')return
    
    
    bgcolor = bgcolor ? new THREE.Color(bgcolor) : { r: 1, g: 1, b: 1 }
    let textMesh = new TextSprite({
        text: text || 'aaaaaa',
        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.8 },
        margin: { x: 5, y: 5 },
        borderRadius: 0,
        player: player,
    })
    textMesh.position.copy(pos)
    textMesh.scale.set(0.3, 0.3, 0.3)
    meshGroup.add(textMesh)
    return textMesh
}

let getBoxPos = info => {
    return (info.preDealRes && info.preDealRes.position) || info.center || (info.type == 'air-hanging' ? info.posAtWall : info.btmPosPredict) || info.posAtWall
}

let updateBoxType = info => {
    let type = info.category || info.box0.category
    
    if(info.sid == "pano0-2"){
        console.log(3)
    } 
    
    if (type == 'air') {
        let btm = info.btmPos || info.btmPosPredict   //btmPosAtWall
        if(!btm){  
            btm = getBoxBottom(info.box0 ? info : {box0:info})
        }  
        if (!btm) return
        
        /* let top = info.topPos 
        if(!top){
            top = getBoxTop(info.box0 ? info : {box0:info})
        } */
        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 = (player.model.boundingBox.max.y - center.y) /(player.model.size.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 = /* info.box0.type = */ type
        //info.box1 && (info.box1.type = type) //因为box0和box1不一定匹配，所以不能直接赋值
    } else {
        info.type = type
    }
}

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

    matchInfo.boxType || updateBoxType(matchInfo)

    let minWidth = standards[matchInfo.boxType].widthNormal.min
    let needGetPose

    if (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')
        updateBoxType(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))
        })
    }

    //-----------------
    /* if(matchInfo.name == "pano0-4&pano2-1"){
        console.log(4)
    } */
    
    let xProp, yProp
    if (matchInfo.boxType == 'battery' || matchInfo.boxType == 'air-hanging' || matchInfo.boxType == 'air') {
        //根据比例判断
        /* 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
        } */
        //根据距离判断
        if(matchInfo.name == 'pano16-3&pano14-6'){
            console.log(5)
        } 
        let bound = player.model.boundingBox
        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)
         
        if(!math.closeTo(minXDiff,minYDiff, 0.3) && (minXDiff < 0.8 || minYDiff < 0.8)){
            if(minXDiff<minYDiff){
                ;(xProp = 'thick'), (yProp = 'width') //贴附y（竖）墙
            }else{
                ;(xProp = 'width'), (yProp = 'thick') //贴附x（横）墙
            }
            matchInfo.xProp = xProp
            matchInfo.yProp = yProp
        }
    }
}

let getPoseScore = (boxposes, isSingle) => {
    let score = 0
    boxposes.forEach(pose => {
        if (pose.projectWidth > pose.maxProjectWidth) {
            score += Math.pow((pose.projectWidth - pose.maxProjectWidth) * 8, 2)
        } else if (/* isSingle &&  */pose.projectWidth < pose.minProjectWidth) {
            score += Math.pow((pose.minProjectWidth - pose.projectWidth) * 20, 2)
        }
    }) 
    score = Math.min(score,600)   //压低一点，因为得的宽度可能不准
    return -score
}

let getBoxSize = info => {
    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.
    //由于盒子的对角线有四个可选方向,(类似四个象限)  则需要能使投影距离最长的一个对角线向量。
    //如，当k<0,m>0时，要使xk+ym 最大，必有x<0,y>0.  故 x = -x'， y = y', 故 投影距离:x'k+y'm = x(-k)+ym 。
    //故无论km的符号如何，只要变为正数，再去联立方程即可得xy。
    
    //注：但是因为无法获取准确的投影距离(角平分线左右两边的端点到角平分线的距离不相等，垂足也无法确定)，所以所算的误差非常大。
    
    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, //Math.max(minProjectWidth1, this.boxposes[0].projectWidth),
                w2 = info.boxposes[1].projectWidth //Math.max(minProjectWidth2, this.boxposes[1].projectWidth)
            //如果识别到柜门上，（柜体被遮住了），整体中心就会在柜门上，且厚度小于真实值。

            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
            x = oriX = info.boxposes[0].maxX //姑且取最大值
            y = oriY = info.boxposes[0].maxY
        }
        
        let o = restrictSize(x, y, info)
        ;(x = o.x), (y = o.y)
        //按正常来说，得到的x,y都应>0,但是由于箱子会被遮挡，导致投影宽度比真实的小，算出的也不准，可能是负数
        //所以手动将过小的宽度矫正
    }
    
    /* if(info.name == "pano2-6"){
        console.log(7)
    } */
    let height
    if (info.boxType == 'air-hanging') {
        //挂式空调最好把长宽固定。 不过极少出错
        //center.y -= 0.1 //很可能过高 
        height = standards[info.boxType].height.standard  
        getBoxBottom(info)
        let d = center.y - info.btmPos.y
        center.y -= THREE.MathUtils.clamp((d - height/2)/2,-0.1,0.1) //如果中心点到底部的距离和height的一半不同，中心点移动差值的一半
        
    } else {
        if (!info.topPos) getBoxTop(info)
        let {min,max} = standards[info.boxType].height 
        height = THREE.MathUtils.clamp(info.topPos.y - groundY, min, max)  
    }
  
    info.size = new THREE.Vector3(x, height, y)

 

    info.sizeAdjust = Math.pow(x - oriX, 2) + Math.pow(y - oriY, 2) //计算得到的值和标准值之间的差距，可以反映该info的匹配分值
     
    if (info.sizeAdjust) info.score = (info.score || 0) - Math.min(info.sizeAdjust * 200, 800)
    info.size.oriX = oriX, info.size.oriY = oriY
    /* if (info.name == 'pano6-0&pano4-4') {
        console.log(6)
    } */ 

    ;(info.exStr = exStr), (info.warnStr = warnStr)
}

let restrictSize = (x, y, info) => {
    let s
    if (info.boxType == 'battery' || info.boxType == 'air-hanging' ||  info.boxType == 'air') {
        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]
            y = THREE.MathUtils.clamp(y, min, max)
            s = true
        } 
    } 
    if(!s){
        var { min, max } = standards[info.boxType].widthNormal
        x = THREE.MathUtils.clamp(x, min, max)
        y = THREE.MathUtils.clamp(y, min, max)
        
        if(info.boxposes){
            x = Math.min(x, ...info.boxposes.map(e=>e.maxX))
            y = Math.min(y, ...info.boxposes.map(e=>e.maxY))  
        } 
        
    }
    return { x, y }
}

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
}



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)]


class Box {//结果
    constructor(info) {
        //preDealBox(info)
        this.setFromInfo(info)
       
        if(version == 'vision')  this.draw()
        
        boxes.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.name = this.boxType + '-' + this.name  
         
        let position
        let center = getBoxPos(this)
        if (this.boxType == 'air-hanging') {
            position = center
        } else {
            position = center.clone().setY(groundY + this.size.y / 2) //使着地
        }
        this.position = position
        let bound = new THREE.Box3()
        bound.expandByPoint(position)
        bound.expandByVector(new THREE.Vector3(this.size.x / 2, this.size.y / 2, this.size.z / 2))
        this.bound = bound
        
        
        
        
    }

    draw() {
        hue += 0.06
        var color = new THREE.Color().setHSL(hue, 1, 0.75)

        
 
        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.name, { bgcolor: color })

        meshGroup.add(this.boxHelper)
    }

    dispose() {
        let index = boxes.indexOf(this)
        if (index > -1) {
            boxes.splice(index, 1)
            if(version == 'vision'){
                this.label.sprite.material.opacity = 0.2
                this.boxHelper.material.opacity = 0.1
            }
        }
    }
    
    toJson(){  
        let json = {
            points: axises.map(axis=>new THREE.Vector3().addVectors(this.position,this.size.clone().multiply(axis).multiplyScalar(0.5)).toArray()),
            category:this.boxType,
            sid: this.name
        }
        return json
    }
}

class cabinet extends Box {
    constructor() {
        super()
    }
}

// 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)

    if(box.sid == 'pano0-6'){
        console.log(5)
    }


    if (!box.btmPosPredict) {
        ray.set(box.pano.position, box.centerBtmDir)
        /*box.btmPosPredict = ray.ray.intersectPlane(groundPlane, new THREE.Vector3()) //没有的话就在空中 (部分air-hanging也会有)
         
        
         if(box.btmPosPredict){
            const depth = 0.4  
            let dir2d = new THREE.Vector2(box.centerBtmDir.x, box.centerBtmDir.z).normalize().multiplyScalar(depth)
            
            box.btmPosPredict.x += dir2d.x
            box.btmPosPredict.z += dir2d.y   
            box.btmPosPredict.clamp(safeBound.min, safeBound.max) 
        }  */ 
        //if(box.category == 'air'){ 
            let o = ray.intersectObjects([skyBoxTight])  //如果skybound有问题，位置就会错
            box.btmPosPredict/* btmPosAtWall */ = o[0].point 
        
            const depth = Math.abs(o[0].face.normal.y) > 0.9  ?  0.4  : -0.4 
            //前进距离。交点在地面上的话, btm往往相比中心更靠近pano；而在墙上则需要移近
            let dir2d = new THREE.Vector2(box.centerBtmDir.x, box.centerBtmDir.z).normalize().multiplyScalar(depth)
            
            box.btmPosPredict.x += dir2d.x
            box.btmPosPredict.z += dir2d.y 
        //} 
         
        //box.pano.id == '4' && addLabel(box.btmPosPredict, 'btmPre:' + box.sid,  { bgcolor: '#e00', a:0.4 })

        /* if (box.sid == "pano10-6"|| box.sid == "pano8-1") {
            console.log(1)
            let color = '#fe1'
            var line1 = LineDraw.createLine([box.pano.position, box.pano.position.clone().add(box.centerBtmDir.clone().multiplyScalar(40))], { color })
            meshGroup.add(line1) 
            addLabel(box.btmPosPredict, 'btmPre')
        }  */  
    }

    if (!box.posAtWall && (box.category == 'battery' || box.category == 'air')) {
        const shrink = 0.4
        ray.set(box.pano.position, box.centerDir)
        let o = ray.intersectObjects([skyBoxTight])
        box.posAtWall = new THREE.Vector3().addVectors(box.pano.position, box.centerDir.clone().multiplyScalar(o[0].distance - shrink))
        
        //因墙壁不准确，所以还是尽量不用墙的位置
        /* if(box.btmPosPredict){
            let wallRatio = 0.5;
            if(new THREE.Vector3().subVectors(box.btmPosPredict,  box.posAtWall).setY(0).length() > 1  )wallRatio = 0.2 //可能墙壁位置不准，靠后了
            box.predictCenter = new THREE.Vector3().addVectors(box.btmPosPredict.clone().multiplyScalar(1-wallRatio), box.posAtWall.clone().multiplyScalar(wallRatio))
            //box.predictCenter = new THREE.Vector3().addVectors(box.posAtWall, box.btmPosPredict).multiplyScalar(0.5) //也许能当中心点？ 虽然y会低一些
            addLabel(box.predictCenter, box.sid+'-preC')
        } */
        
    }
        
    

    updateBoxType(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 => {
    getUVs(box)
    getCenterDir(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 getBoxPoseByPos = (box, centerPos, addDis = 0) => {
    //当得知box的大概位置时，求box在这个角度上的宽度、朝向
    //在这个方向看的box的宽度

    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)

    let maxWidth = standards[box.type].widthNormal.max
    let minWidth = standards[box.type].widthNormal.min
    let maxProjectWidth = (camTangent.x + camTangent.y) * maxWidth //该角度下该类型允许的最大投影距离
    let minProjectWidth = (camTangent.x + camTangent.y) * minWidth
    let maxX = projectWidth / camTangent.x //可得x的最大值
    let maxY = projectWidth / camTangent.y //可得y的最大值

    return { projectWidth, camTangent, maxProjectWidth, minProjectWidth, maxX, maxY }
}
let getBoxTop = info => {
    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  
    }else{
        //取btm上方对应的位置 ( 因为和skybox的交点会因离墙远而偏上或偏下)
        let btm = info.box0.btmPosPredict || info.btmPos //top.x
        if(!btm){ 
            btm = getBoxBottom(info)
        } 
        info.topPos = btm.clone() //xz同btm，要求y 
        let xDelta = btm.x - info.box0.pano.position.x
        let yDelta = xDelta * info.box0.centerTopDir.y / info.box0.centerTopDir.x
        info.topPos.y = yDelta + info.box0.pano.position.y 
        
    }
    return info.topPos
}

let getBoxBottom = 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
    } else {
        ray.set(info.box0.pano.position, info.box0.centerBtmDir)
        let o = ray.intersectObjects([skyBoxTight])
        info.btmPos = o[0].point.clone()
    }
    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 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)
        }
    }
}

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,
    }
}

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)
        skyBoxTight = new BoundingMesh(player.model.boundingBox, undefined, 0)
        skyBoxTight.material.side = 2
        skyBoxTight.material.wireframe = true
        skyBoxTight.visible = false  
        skyBoxTight.updateMatrixWorld()//不update的话raycaster是错的
        
        
        this.skyBoxTight = skyBoxTight
        
        
        
        this.compute(dataList)
        
    }

    async compute(dataList) {
        this.datas = {}
        this.boxes = boxes

        let compu = 0
        let beginCompute = () => {
            //获取匹配分数
            let getMatchScore = (box0, box1, { isSingle, center, onlyGet, dontCheckDis } = {}) => {
                let name = box0.sid + '&' + box1.sid
                let matchInfo = this.matchScoreMap[box1.category][name]
                if (onlyGet) return matchInfo
                if (!matchInfo) {
                    matchInfo = { name, box0, box1, center }
                    this.matchScoreMap[box1.category][name] = matchInfo
                }else{
                    return matchInfo
                }
                if (name == 'pano0-3&pano4-4') {
                    console.log(1)
                }
                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 (name == 'pano2-1&pano4-2') {
                    console.log(1)
                    var line1 = LineDraw.createLine([A, A.clone().add(box0.centerDir.clone().multiplyScalar(40))])
                    var line2 = LineDraw.createLine([B, B.clone().add(box1.centerDir.clone().multiplyScalar(40))])
                    meshGroup.add(line1)
                    meshGroup.add(line2)
                }  

                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)
                    if (isSingle) {
                        //单个匹配单个，而非多个匹配多个，所以可以直接寻找最优角度
                        score += Math.sin(THREE.MathUtils.degToRad(matchInfo.minAng)) * 500
                    }
                }

                if(!dontCheckDis){
                    
                    if(box0.type != 'air-hanging' && box0.btmPosPredict && box1.btmPosPredict) { //注：挂空调不应使用btmPosPredict
                        let d = box0.btmPosPredict.distanceToSquared(box1.btmPosPredict)
                        matchInfo.btmPosPreDis = d
                        score -= d * 2000
                    } else if (box0.posAtWall && box1.posAtWall) { 
                        let d = box0.posAtWall.distanceToSquared(box1.posAtWall)
                        matchInfo.wallPosPreDis = d
                        score -= d * 500 //墙面不准所以分低
                    }
                }

                //检查从两处看高度是否一致
                getBoxTop(matchInfo)
                score -= Math.pow(matchInfo.diffHeight * 10, 2) // 0.1处是1

                //检查高度的一半（从 顶部到中心 与 中心到地板 的距离是否差别太大）
                /*  let diffHalfHeight
                if (box0.type == 'air-hanging') {
                    //diffHalfHeight = 0
                    //if(matchInfo.topPos.y - center.y > 0.5)score -= Math.pow((matchInfo.topPos.y - center.y )*5, 4)
                } else {
                    diffHalfHeight = Math.abs(matchInfo.topPos.y - matchInfo.center.y - (matchInfo.center.y - groundY))
                    score -= Math.pow(diffHalfHeight * 3, 4)
                } */

                if (!matchInfo.center) {
                    let o = getIntersect2(A, box0.centerDir, B, box1.centerDir)
                    matchInfo.center = o.pos3d.clone()
                    //addLabel(matchInfo.center, matchInfo.name + '-c')
                    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.9
                    score -= (2 - sum) * 5000
                    if (wrongDir) {
                        str.push('wrongDir')
                        return Object.assign(matchInfo, { score: score - 5000, str })
                    }
                    //靠墙的有这些属性 可以帮助预测中心点
                    let predict0 = box0.type != 'air-hanging' && box0.btmPosPredict || matchInfo.topPos  
                    let predict1 = box1.type != 'air-hanging' && box1.btmPosPredict || matchInfo.topPos
                    if (predict0 && predict1) {
                        matchInfo.center
                            .add(predict0)
                            .add(predict1)
                            .multiplyScalar(1 / 3)
                            .setY(o.pos3d.y)
                    }
                    //addLabel(matchInfo.center, matchInfo.name + '-c')
                }

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


                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
                }

                /* if (name == 'pano6-rowBigBox-3,2&pano2-0') {
                    addLabel(matchInfo.center, 'center')
                    addLabel(matchInfo.topPos, 'topCenter')
                } */

                /* if (name == 'pano2-rowBigBox-5,1,8&pano6-rowBigBox-4') {
                    console.log(1)
                    let color = '#fe1'
                    var line1 = LineDraw.createLine([A, A.clone().add(box0.centerTopDir.clone().multiplyScalar(40))], { color })
                    var line2 = LineDraw.createLine([B, B.clone().add(box1.centerTopDir.clone().multiplyScalar(40))], { color })
                    meshGroup.add(line1)
                    meshGroup.add(line2)
                    addLabel(matchInfo.topPos, 'topPos')
                }  */

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

                /* let overMaxs = boxposes.filter(e => e.projectWidth > e.maxProjectWidth)
                if (
                    // matchInfo.dirAngleXZ > 160 &&  
                    (overMaxs.length == 1 && Math.abs(boxposes[0].maxProjectWidth - boxposes[0].projectWidth - (boxposes[1].maxProjectWidth - boxposes[1].projectWidth)) > 0.8) ||
                    (matchInfo.dirAngleXZ < 20 && overMaxs.length == 2)
                ) {
                    //一大一小
                    //中心偏向一点，如果能移回一些就好了，现在暂时先用topPos的xz。 因为向上的话，侧面角度大，水平角度差影响会小。但如果有一边不准也是不准。
                    ;(matchInfo.center.x = matchInfo.topPos.x), (matchInfo.center.z = matchInfo.topPos.z) //y要变吗
                    //console.log('修改中心')
                     checkWidth()
                }*/

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

                compu++

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

                /* preDealBox(matchInfo)
                getBoxSize(matchInfo)  */
            }
  
            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: 'rowBigBox',
                    type: '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.type != box0.type ) continue //类型不同
                         
                        let [left1, right1] = [box1.bbox2[0], box1.bbox2[2]]

                        let atEdge = (left1 < 0.00025 && right0 > 0.9997) || (left0 < 0.00025 && right1 > 0.9997) //在全景图的边界必会分两半
                        
                        if (reason == 'mix' && box0.category == 'cabinet' && !atEdge) continue //柜子容易并排，尽量不融合

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

                        /* if(box0.sid == "pano10-1"){
                            console.log(9)
                        }   */ 
                        const min = reason == 'mix' ? 0.004 : 0.003 //mix代表寻找分裂的重新融合到一起
                        if ((d1 <= min && d2 >= min) || (d3 <= min && d2 <= min)) { //边框交接
                            const { min, max } = standards[box0.btmPosPredict ? category : 'air-hanging'].widthNormal
                            const w = (min + max) / 2
                            const tolerate = w * w * (reason == 'mix' ? 0.8 : 2.1)

                            let p0 = getBoxPos(box0)
                            let p1 = getBoxPos(box1)
                            let dis = p0.distanceToSquared(p1) 
                            let disY
                            
                            if (reason == 'mix'){
                                if(atEdge) {
                                    dis -= tolerate * 0.8 //给many优势
                                }else{
                                    disY = (Math.abs(box0.bbox2[3] - box1.bbox2[3]) + Math.abs(box0.bbox2[1] - box1.bbox2[1])) * 5  //边框纵向差异越大越不可能融合（虽然是可能有包含的情况啦，留到最后再combine。因为在侧面看，近处的box很容易嵌套远处的box，但它们不该融合）
                                    if (disY > 0.6) continue
                                    dis += disY  
                                    let atEdgeMight = (left1 < 0.001 && right0 > 0.999) ? [left1,right0] : (left0 < 0.001 && right1 > 0.999) ?  [left0,right1]  : null //有在全景图的边界的可能性
                                    let atEdgePossib = atEdgeMight?  0.0003/ (atEdgeMight[0] + (1-atEdgeMight[1])) : 0 // 两条线越接近越可能融合
                                    dis -= atEdgePossib   //给点点优势
                                } 
                            }
                              
                            /* if(box0.sid == "pano2-0"){
                                console.log('dis',dis,'tolerate',tolerate,[box0, box1],disY)
                            }  */

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

                /* rows.slice(0).forEach(boxes => { 
                    //有的其实是分离的但也在边缘连上了，可以根据底部的差来判断，过大的很可能是分离的
                    if (boxes.length >= 2) {
                        let diffs = []
                        for (let i = 0, j = boxes.length; i < j - 1; i++) {
                            let box0 = boxes[i],
                                box1 = boxes[i + 1]
                            let p0 = box0.predictCenter || box0.btmPosPredict ||  box0.posAtWall 
                            let p1 = box1.predictCenter || box1.btmPosPredict ||  box1.posAtWall 
                            diffs.push(p0.distanceToSquared(p1)) 
                        } 
                        let minW = standards[category].widthNormal.min     
                        if(!boxes[0].btmPosPredict)minW = standards['air-hanging'].widthNormal.min  
                            
                        let mid = minW * minW
                        let removes = []
                        diffs.forEach((e, i) => {
                            if (e > mid * 2) {
                                removes.push([boxes[i], boxes[i + 1]])
                            }
                        }) 
                        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 btmY = boxes.slice().sort((a, b) => a.bbox2[3] - b.bbox2[3])[0].bbox2[3]
                    let topY = boxes.slice().sort((a, b) => b.bbox2[1] - a.bbox2[1])[0].bbox2[1]
  
                    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){//多条链
                        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)
                    }
                })

                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(bigBox.boxes[0].type == 'air-hanging'){
                        bigBox.btmPosAtWall = bigBox.boxes.reduce((w, c) => w.add(c.btmPosAtWall), new THREE.Vector3()).multiplyScalar(1 / bigBox.boxes.length)
                    }else  */if (bigBox.boxes[0].btmPosPredict) {
                        bigBox.btmPosPredict = bigBox.boxes.reduce((w, c) => w.add(c.btmPosPredict), 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)
                    }
                     
                })

                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].btmPosPredict.distanceToSquared(lefts[1].btmPosPredict)
                let dis1 = rights[0].btmPosPredict.distanceToSquared(rights[1].btmPosPredict)
                let dis2 = lefts[0].btmPosPredict.distanceToSquared(rights[1].btmPosPredict)
                let dis3 = rights[0].btmPosPredict.distanceToSquared(lefts[1].btmPosPredict)
                let posLeft2, posRight2
                if (dis0 + dis1 > dis2 + dis3) {//距离近的代表是同一端
                    reversed = true
                    posLeft2 = new THREE.Vector3().addVectors(lefts[0].btmPosPredict, rights[1].btmPosPredict).multiplyScalar(0.5)
                    posRight2 = new THREE.Vector3().addVectors(rights[0].btmPosPredict, lefts[1].btmPosPredict).multiplyScalar(0.5)
                } else {
                    posLeft2 = new THREE.Vector3().addVectors(lefts[0].btmPosPredict, lefts[1].btmPosPredict).multiplyScalar(0.5)
                    posRight2 = new THREE.Vector3().addVectors(rights[0].btmPosPredict, rights[1].btmPosPredict).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 getCenter = (rowBigBox0, rowBigBox1, ignoreCountMatch) => {//获取row间的匹配信息
                    //获取bigBox位置。由于一排的盒子比较长，中心方向误差大，所以采用先获取两边位置，再求中点的方法
                    //if (rowBigBox0.boxes.length != rowBigBox1.boxes.length && !ignoreCountMatch) return //太难了，不算不一样的情况了

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

                    /*if (rowBigBox0.sid == 'pano6-rowBigBox-4,6' && rowBigBox1.sid == 'pano14-rowBigBox-0,1,4,8') {
                        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) return console.error('overLen> 1', overLen, rowBigBox0.sid, '和', rowBigBox1.sid)

                        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 //漫游点重合、>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)) {
                            return console.error('请检查！info2.k > 1 && k < 1 || info2.k < 1 && k > 1', rowBigBox0.sid, '和', rowBigBox1.sid) //绘制的方向错误，尺寸错误
                        }

                        /*
                        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) */

                        let center = new THREE.Vector3().addVectors(posLeft, posRight).multiplyScalar(0.5)

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

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

                        if (match.score + overLen * 1000 + leftInfo.score + rightInfo.score < -5000) {
                            return console.log('放弃，匹配分过低，可能不是一组', rowBigBox0.sid, '和', rowBigBox1.sid)
                        }
                        //console.log('getcenter', rowBigBox0.sid, '和', rowBigBox1.sid,   overLen, match.score + overLen * 1000 + leftInfo.score + rightInfo.score)
                        rowInfo = {
                            rowBigBox0,
                            rowBigBox1,
                            match,
                            k,
                            posLeft,
                            posRight,
                            score: 500 + match.score,
                            reversed: info2.reversed,
                        }
                    } else {
                        if (rowBigBox0.boxes.length == 1 && rowBigBox1.boxes.length == 1) { 
                            rowInfo = getMatchScore(rowBigBox0.boxes[0], rowBigBox1.boxes[0] /* , { isSingle: true  } */) //直接匹配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 }) //一对多
                            /* if(rowInfo.name == "pano12-row-3&pano0-row-3,1,0"){
                                console.log(5)
                            } */
                            
                            rowInfo.k = mulBoxRow.k
                            if(rowInfo.center){
                                rowInfo.center.add(getBoxPos(mulBoxRow)).multiplyScalar(0.5) 
                            }
                            rowInfo.predictSize = rowInfo.k > 1 ? {x : mulBoxRow.predictLen, y: 0.6} : {y : mulBoxRow.predictLen, x: 0.6}
                            //单个的应该和多个的其中一端一样
                            let dis0 = getBoxPos(mulBoxRow.left).distanceToSquared(getBoxPos(singleBox))
                            let dis1 = getBoxPos(mulBoxRow.right).distanceToSquared(getBoxPos(singleBox))
                            let dis = Math.min(dis0, dis1)
                            rowInfo.score -= dis * 1000
                        }
                    }

                    rowInfos.push(rowInfo)
                    rowInfos[rowBigBox0.sid + '&' + rowBigBox1.sid] = 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

                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 : getCenter(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 > -2000 ? e.score : 0) //只考虑组成功的分数
                                }, 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 > -2000) {
                                    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.35 })
                        addLabel(right, 'Right' + index, { bgcolor: '#F00', a: 0.35 })
                        let center = new THREE.Vector3().addVectors(left, right).multiplyScalar(0.5)
                        addLabel(center, 'center' + index, { bgcolor: '#F00', a: 0.4 })
                        ;(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 { center1, size } = getAve(bigBoxes)
                        //console.log(center1, size)
                        let getScores = (center, size) => {
                            //获得相对于center,size的差别分数
                            bigBoxes.forEach(box => {
                                box.sc = -box.center.distanceToSquared(center1) - size.distanceToSquared(box.size) * 0.5
                            })
                        }
                        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) => {
                        let boxCounts = []
                        infos.forEach(e => {
                            boxCounts.push(...e.group.map(bigBox => bigBox.boxes.length))
                        }) 
                        /* infos.forEach(e => {
                            boxCounts.push(...e.group.relationships.map(pair => 
                            Math.max(pair[0].predictBoxCount || pair[0].boxes.length,  pair[1].predictBoxCount || pair[1].boxes.length)))
                        }) //根据匹配到的来得个数  */

                        /* infos.forEach(e => {
                            e.group.relationships.forEach(pair => {
                                let counts = pair.map(e => e.boxes.length)
                                if (counts.filter(e => e == 1).length == 1) {
                                    //如果是1和其他数字匹配，取数字大的。如1和3的话是3个箱子。
                                    let c = counts.find(e => e != 1)
                                    boxCounts.push(c)
                                } else {
                                    boxCounts.push(...counts) //否则两个数字都取
                                }
                            })
                        }) //根据匹配到的来得个数 */

                        boxCounts.sort((a, b) => a - b)
                        /*let midCounts = [] //这一排的箱子个数中位数
                         midCounts.push(boxCounts[Math.floor(boxCounts.length / 2)])
                        if (boxCounts.length % 2 == 0) {
                            let a = boxCounts[Math.floor(boxCounts.length / 2) - 1]
                            let b = midCounts[0]
                            let c = b - 1
                            while (c >= a) {
                                midCounts.push(c)
                                c--
                            }
                            //加入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 //两排之间最小距离
                    /* let getBoxLen = (group)=>{
                        if( group.bigBoxes.length == 0) return  0
                        let max = 0
                        group.bigBoxes.forEach(e=>{
                            max = Math.max(max, e.box0.boxes ? e.box0.boxes.length : 1  , e.box1.boxes ? e.box1.boxes.length : 1 ) 
                        })
                        return max
                    } */
                    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(group0.k == 5.135329840006164 && group1.k ==4.494597962707433 || group0.k ==4.494597962707433 && group1.k == 5.135329840006164){
                                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)) &&
                                //getBoxLen(group0) != 1 && getBoxLen(group1) != 1  )continue  //且没有其中一个是单个的box
                                //(group0.k > maxR || group0.k < 1/maxR ) && (group1.k > maxR || group1.k < 1/maxR )) continue //如果是方块状的无视k
                                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.6).areaMix

                            if (areaMixExpand / area0 < 0.5 && areaMixExpand / area1 < 0.5) 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)

                        const k = infos.reduce((w, c) => (w += c.k), 0) / infos.length

                        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 => {
                                        /* if (e.boxes.length == count) */ return e.boxes.slice()
                                        /* return e.bestChain.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)
                                        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=>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]
                        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])

                        let min = 0.005
                        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
                }

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

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

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

                        let remainChild = true
                        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) {
                    datas[id] = this.datas[id].shapes.filter(e => e.category == type)
                    datas[id].length && panoIds.push(id)
                    //对data预处理
                    
                    //(之后如果还出现不同类型重叠在一起的，需要先识别摘除下。 )4GqaqNdyjGf
                    
                    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)
                                })
                                console.log('因融合而删除', bigBox.boxes) 
                                datas[id].push(bigBox)
                                bigBox.index = datas[id].length>1 ? datas[id][datas[id].length-2].index+1 : 0
                                bigBox.category = type //更正
                            }
                        })
                    }
                }
                if (panoIds.length == 0) 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) {
                    //只有一个全景里有数据
                    group0.forEach(e => createSinglePano(e))
                    return  combines(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)
 
                    //根据分数重排序，前两个已匹配的pano放在第一第二（之后会被跳过），获得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])
  
                    if (match.score > -100) {
                        getBoxSize(match) 
                        if (match.score > 0 && match.sizeAdjust < 0.1) {
                            new Box(matchScoreMap[list[0]])
                            waitFindRest.push({type, args:[groups2]} )  //等待最后检查遗漏
                            return
                        }
                    }
                    //继续match 
                    reMatchLowScores([match], groups2)
                    waitFindRest.push({type, args:[groups2]} ) //等待最后检查遗漏
                    return
                }

                if (type == 'cabinet') {
                    //转化为分组  
                    if (searchByRow(groups, datas)){ 
                        waitFindRest.push({type, args:[groups,0]} ) //等待最后检查遗漏
                        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 nums = Object.keys(counts)
                    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)
                                    return w + c.pano.position.distanceToSquared(pos)
                                }, 0)
                            })
                            groups_.sort((a, b) => a.disSc - b.disSc)
                        }

                        groups.push(...groups_)
                    })

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

                
                let group1 = groups[1],
                    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)

                    //if(infos[0].score < -1000){
                    //score -= infos[0].score
                    //}

                    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 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 < -2000) {
                            lowScores.push(info)
                            return
                        }
                        preDealBox(info)
                        getBoxSize(info)

                        if (info.sizeAdjust > 0.1) {
                            lowScores.push(info)
                            return
                        }

                        let box = new Box(info)
                    })
                }

              
                if (noMatches.length) {
                    reMatchLowScores(
                        noMatches.map(e => {
                            return { box0: e }
                        }),
                        groups
                    )
                }
                
                 
                
                reMatchLowScores(lowScores, groups)
                waitFindRest.push({type, args:[groups]}  ) 
                //combines(type)
            }
            
            function findRest(groups/* ,startIndex=2  */){ 
                //查找是否有遗漏。
                //1 可能有距离较远的box不在头两个pano的附近导致被漏掉。(概率很小)
                //2 被剩余的
                for(let i=0;i<groups.length;i++){
                    groups[i].forEach(box=>{
                        if(!used(box)){
                            //如果和现有的box的距离都很远，很可能是漏掉的
                            let near = boxes.find(solidBox =>{ 
                                if(solidBox.boxType != box.type && (solidBox.boxType == 'air-hanging' || box.type == '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[solidBox.boxType].widthNormal.max
                                if(solidBox.boxType != box.type){
                                    maxWidth = Math.min(standards[box.type].widthNormal.max, maxWidth)
                                }
                                
                                /* let r = solidBox.boxType == box.type ? 1.2 : 1  //种类不同的话要更严格，所以数值更小
                                return p1.distanceToSquared(p2) < maxWidth * maxWidth * r
                                 */   

                                let dis = solidBox.bound.distanceToPoint(p2)
                                let ra = solidBox.boxType == box.type ? 0.9 : 0.6  
                                let rb = solidBox.boxType == box.type ? 0.4 : 0.3
                                let a = maxWidth * maxWidth * ra - p1_.distanceToSquared(p2_)
                                let b = maxWidth * rb - dis
                                 
                                
                                let c =  a + b
                                if(c>0){
                                    console.log(1)
                                }
                                return c>0
                            })
                            if(!near){  
                                reMatchLowScores([{box0:box, log:"findRest"}], groups,0 ) 
                            }else{
                                //console.log('find near', near.name, box.sid)
                            }  
                        }
                    })
                }
                  
            }
            
            
            
            function used(box){
                let has = (e)=>{
                    return e.box0 == box || e.box1 == box
                }
                return /* matched.includes(box) || */ boxes.some(e => /* e.boxType == box.type && */ has(e) || (e.list && e.list.some(a => has(a))) 
                    || e.infos && e.infos.some(u=>u.group.some(r=> r.boxes.some(b=>b==box) )) //row
                  )
            }
            function reMatchLowScores(lowScores, groups, startIndex=2 ) {
                let matched = [],
                    tooLows = []

                
                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 < -2000) 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)

                    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){
                                    let r1 = getMatchScore(box01, box1, { isSingle: true, restMatch: true })
                                    r1.score > -4000 && scores0.push(r1)
                                }
                                if (box02 && box1.pano != box02.pano) {
                                    let r2 = getMatchScore(box02, box1, { isSingle: true, restMatch: true })
                                    r2.score > -4000 && 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 createSinglePano(box01)
                        }

                        if (goodList2[0].score > -1000) {
                            goodList2 = goodList2.filter(e => e.score > -1000)
                        } else {
                            goodList2 = [goodList2[0]] // 最高分已经过小
                            if (goodList2[0].score < -1200) {
                                if (!box02) return createSinglePano(box01)
                                console.warn('分数过低,是否有匹配错误？', goodList2[0])
                                return tooLows.push(goodList2[0])
                            }
                        }

                        if (goodList2.length) {
                            //需要确认两两之间是配对的，也就是都对应同一个box
                            let subGroups = []
                            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)
                                //}
                            }
                            subGroups.forEach(pair => {
                                mixMatchBox(pair)
                            })

                            //console.log('lowScores getBox  ', box,  goodList2)
                        }
                    })
                    
                    //改为之后 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) {
                let center = new THREE.Vector3(),
                    size = new THREE.Vector3(),
                    name
                list.forEach(e => {
                    center.add(getBoxPos(e))
                    size.add(e.size)
                    //matched.push(e.box1)
                })
                center.multiplyScalar(1 / list.length)
                size.multiplyScalar(1 / list.length)

                let box = new Box({
                    name: 'low:' + list.map(e => e.name),
                    boxType: list[0].boxType,
                    center,
                    size,
                    list,
                    xProp: list[0].xProp,
                    yProp: list[0].yProp,
                })
            }

            function combines(type) {
                //合并boxSolids .  battery经常嵌套
                if (type == 'battery') { 

                    const group = []
                    /* let airs = boxes.filter(e => e.boxType == 'air')
                    let hangings = boxes.filter(e => e.boxType == 'air-hanging') */
                    let batterys = boxes.filter(e => e.boxType == 'battery')
                    ;[batterys].forEach(boxes => {
                        if (boxes.length > 1) {
                            const 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]
                                for (let j = i + 1; j < len; j++) {
                                    let box1 = boxes[j]
                                    let bound = box0.bound.clone().union(box1.bound) 
                                    let size = bound.getSize(new THREE.Vector3())
                                    let intersect = box0.bound.intersectsBox(box1.bound)
                                    
                                    let minX = min,
                                        minZ = min,
                                        maxX = max,
                                        maxZ = max
                                    
                                    let xProp = box1.xProp || box0.xProp
                                    let yProp = box1.yProp || box0.yProp
                                    if (xProp) {
                                        if (box0.xProp && box1.xProp && box0.xProp != box1.xProp) continue
                                        maxX = standards[boxType][xProp].max
                                        maxZ = standards[boxType][yProp].max
                                    }
                                    maxX = Math.max(maxX,  box0.size.x,  box1.size.x)  //必须大于各自的size,否则无法去除本身就oversize的box中包含的
                                    maxZ = Math.max(maxZ,  box0.size.z,  box1.size.z)
                                    
                                    let r = intersect ? 1.3 : 1.1       //如果是没有交集，限制更大些
                                    if (size.x < maxX * r && size.z < maxZ * r ) {
                                        common.pushToGroupAuto([box0, box1], group)
                                    }
                                }
                            }

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

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


            let createSinglePano = box => {
                //仅用一个pano中的data来创建
                
                 
                getBoxBase(box)

                let center = getBoxPos(box)
                
                 
                let info = {
                    name: box.sid,
                    box0: box,
                    center, 
                }
                //getBoxTop(info)
                preDealBox(info) 
                
                let a = getPoseScore(info.boxposes,true)
                let failed = a < -50
            
                console.log('createSinglePano',  failed?'失败':'成功' , 'pose score:',a,   box  )
                if(failed)return
                
                addLabel(center, 'center', { a: 0.3 })
                info.topPos && addLabel(info.topPos, 'topPos', { a: 0.3 })

                getBoxSize(info)
                new Box(info)
            }




            Search('cabinet') 
            Search('air')
            Search('battery')
            
            
            console.log('----FindRest----')
            waitFindRest.forEach((e)=>{
                findRest(...e.args)
                combines(e.type)
            })
            
            
        }

        /* let getSid = (function(){
            let sid = 0
            return function(){
                return sid++
            }
        })() */
        let done = ()=>{
            
            for(let panoId in this.datas){  
                this.datas[panoId].shapes = this.datas[panoId].shapes.map((shape, i) => {
                    return Object.assign(
                        {
                            sid: 'pano' + panoId + '-' + i,
                            pano: player.model.panos.index[panoId],
                            index: i,
                        },
                        shape
                    )
                })   
            } 
            
            groundY = player.model.boundingBox.min.y
            groundPlane.setFromNormalAndCoplanarPoint(new THREE.Vector3(0, 1, 0), new THREE.Vector3(0, groundY, 0))

            const w = 0.5  //这一版的模型bound常常太小，把箱子当墙面，所以扩展一个箱子宽度
            safeBound = player.model.boundingBox.clone().expandByVector(new THREE.Vector3(w, w, w))

            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()
            }
        }
        let panosCount = 0
        if(!dataList){ 
            player.model.panos.list.forEach(e => {
                if (!e.isAligned()) return
                panosCount++
                load.bind(this)(e.id)
            })
        }else{ //when  version == 'output'
            dataList.forEach(e=>{
                let panoId = e.imagePath.split('.jpg')[0]
                this.datas[panoId] = e
            }) 
            done()
        }
    }

    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()
        })

        player.on(PlayerEvents.FlyingEnded, () => {
            // 点位跳转后加载线框
            if (player.mode != Viewmode.PANORAMA) return // 只有PANORAMA模式下需要加载
            this.load(player.currentPano.id)
        })
        
        window.panoWireframe = this
        if(this.ifAnalyze   ){
            setTimeout(() => {
                {
                    let btn = document.createElement('button')
                    btn.innerHTML = '点击切换box显示'

                    btn.onclick = () => {
                        this.boxes.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
     */
    /* async  */ load(panoId) {
        // fetch(texture.getImageURL('images/points/' + panoId + '.json'))
        //     .then(data => data.json())
        //     .then(data => {
        //let data = await http.post('/service/scene/sceneMarkShape/getInfo', { num: player.$app.config.num, imagePath: panoId + '.jpg' })
        // console.error(data)

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

        let { shapes, imageHeight, imageWidth } = data //data.data

        shapes.forEach((shape, i) => {
            // 填充色和线框色
            // 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]

            this.showSignalFrom2d(
                `${i} : ${shape.category}`,
                shape.bbox,
                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: line_color[3] / 255,
                    },
                },
                shape.centerDir
            )
        })
        // })
        // .catch(err => console.log(`点位${panoId}无标记数据或数据出错：`, err))
    }

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

        // 2d坐标转3d坐标
        let transform2dTo3d = point => {
            // 计算方向向量
            let x = point[0],
                y = point[1]
            let yaw = (-x / w) * (Math.PI * 2)
            let pitch = Math.PI / 2 - (y / h) * Math.PI

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

            return dir
        }

        // // 计算矩形线框中点坐标（取x、y的平均值）
        // let center = [cornerArr.reduce((a, b) => [a[0] + b[0], 0])[0] / cornerArr.length, cornerArr.reduce((a, b) => [0, a[1] + b[1]])[1] / cornerArr.length]
        // let centerVec = transform2dTo3d(center) // 计算中点3d坐标

        // 根据四个顶点，填充中间点
        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(point => {
            let dir = transform2dTo3d(point)
            // 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: 0.4 },
            textColor: { r: 255, g: 255, b: 255, a: 1 },
            borderRadius: 15,
            renderOrder: wireframe.renderOrder + 1,
            player: player,
        })
        textMesh.position.copy(centerDir.clone().add(new THREE.Vector3(0, 0.1, 0)))
        textMesh.lookAt(0, 0, 0) // 看向相机
        textMesh.scale.set(0.12, 0.12, 0.12)

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