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, modelBound = new THREE.Box3,
ray = new THREE.Raycaster(),
groundPlane = new THREE.Plane()
let groundY, safeBound, boundConfirmed  //安全区域应该在扣除每种类型柜子大概的长宽的一半
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.btmPos) || info.posAtWall
}

let updateBoxType = info => {
let type = info.category || info.box0.category

if(info.sid == "pano4-0"){
    console.log(3)
} 

if (type == 'air') {
    let btm = info.btmPos || info.btmPos   //btmPosAtWall
    if(!btm){  
        btm = getBoxBtm(info )
    }  
    if (!btm) return
     
    let center = info.posAtWall || (info.preDealRes && info.preDealRes.position) || info.center 
    const s = standards['air-hanging']

    if (btm.y - groundY > s.bottom.min){
        let h0 = btm.y - groundY
        let h1 = (modelBound.max.y - center.y) /(modelBound.max.y-modelBound.min.y)
        let h2 = center.y-btm.y
        let score = h0 * 2 -  h1*3 - h2 * 3
        if(score > 0){
            type = 'air-hanging' 
        }
        //console.error( score,  h0,h1,h2, info.sid||info.name)
    }  //注意：如果air被遮住底部，露出的部分只有一点，还是有可能被识别成air-hanging。只能希望
    //console.error( type,  info.sid||info.name)
    
}
if (info.box0) {
    info.boxType = /* 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 == 'pano2-1&pano4-0,pano0-2&pano2-1'){
        console.log(5)
    } 
    let bound = safeBound
    let minXDiff = Math.min(center.x - bound.min.x,  bound.max.x - center.x)
    let minYDiff = Math.min(center.z - bound.min.z,  bound.max.z - center.z)
     
    if(!math.closeTo(minXDiff,minYDiff, 0.16) && (minXDiff < 0.7 || minYDiff < 0.7)){
        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
const minDis = 1.5
  
boxposes.forEach(pose => { 
    pose.lowR = pose.dis < minDis ? pose.dis / minDis  :  1 //太近的话误差大
    
    if (pose.projectWidth > pose.maxProjectWidth) {
        score += Math.pow((pose.projectWidth - pose.maxProjectWidth) * pose.lowR * 5, 2) //超过的话数字较大所以乘的数小一些
    } else if (/* isSingle &&  */pose.projectWidth < pose.minProjectWidth) {
        score += Math.pow((pose.minProjectWidth - pose.projectWidth) * pose.lowR * 10, 2)
    }
}) 
score = Math.min(score,500)   //压低一点，因为得的宽度可能不准

if(boxposes.length == 2){
    //每一个方向对应有四个方向（每个象限一个）看到的projectWidth应该接近。  
     
    //先把camTangent转化为第一个象限的 
    let camTangent0 = new THREE.Vector2(Math.abs(boxposes[0].camTangent.x),  Math.abs(boxposes[0].camTangent.y))
    let camTangent1 = new THREE.Vector2(Math.abs(boxposes[1].camTangent.x),  Math.abs(boxposes[1].camTangent.y))
    
    let a = camTangent0.dot(camTangent1)   
    if(a>0.8){ //0.9:   25度之内.  0.8:   36.8度之内  
        let diff = Math.abs(boxposes[0].projectWidth - boxposes[1].projectWidth)
        boxposes.score2 = a * diff * 1000 * boxposes[0].lowR * boxposes[1].lowR
        score += boxposes.score2
        //console.warn('在同一个方向看到的projectWidth应该接近。 ', diff)
        
    } 
    boxposes.camTangentCos = a
}
score = Math.min(score,1000)    
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  
    getBoxBtm(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)


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

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

let restrictSize = (x, y, 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)

 

}

let getOtherPos = box=>{

if(!boundConfirmed){  
    ray.set(box.pano.position, box.centerBtmDir)
    box.btmPosPredict = ray.ray.intersectPlane(groundPlane, new THREE.Vector3()) //没有的话就在空中 (部分air-hanging也会有)
    
    if(box.btmPosPredict){
        const depth = box.category == 'cabinet' ? 0.5 : 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  
        //addLabel(box.btmPosPredict,'b_'+box.category+"_"+box.sid, {bgcolor:'#6ff',a:0.1})              
        //box.btmPosPredict.clamp(safeBound.min, safeBound.max) 
    }  
    return
}

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

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

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.btmPos){
        let wallRatio = 0.5;
        if(new THREE.Vector3().subVectors(box.btmPos,  box.posAtWall).setY(0).length() > 1  )wallRatio = 0.2 //可能墙壁位置不准，靠后了
        box.predictCenter = new THREE.Vector3().addVectors(box.btmPos.clone().multiplyScalar(1-wallRatio), box.posAtWall.clone().multiplyScalar(wallRatio))
        //box.predictCenter = new THREE.Vector3().addVectors(box.posAtWall, box.btmPos).multiplyScalar(0.5) //也许能当中心点？ 虽然y会低一些
        addLabel(box.predictCenter, box.sid+'-preC')
    } */ 
}
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)
getOtherPos(box)

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

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

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

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


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的最大值(假设y为0)
let maxY = projectWidth / camTangent.y //可得y的最大值(假设x为0)




return { projectWidth, camTangent, maxProjectWidth, minProjectWidth, maxX, maxY, dis}
}
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 box = info.box0 || info
    
    if(box.sid == 'pano2-2'){
        console.log(3)
    }
    let btm = box.btmPos 
    if(!btm){ 
        btm = getBoxBtm(info)
    } 
    box.topPos = btm.clone() //xz同btm，要求y 
    let xDelta = btm.x - box.pano.position.x
    let yDelta = xDelta * box.centerTopDir.y / box.centerTopDir.x
    box.topPos.y = yDelta + box.pano.position.y 
    let minHeight = info.boxType ? standards[info.boxType].height.min : box.category == 'air' ? 0.5 : standards[box.category].height.min
    let diffH = Math.max(box.topPos.y - btm.y,  minHeight)
    box.topPos.y = btm.y + diffH
    info.topPos = box.topPos
    
}
return info.topPos
}

let getBoxBtm = info => {
if (info.box1) {
    let o2 = getIntersect2(info.box0.pano.position, info.box0.centerBtmDir, info.box1.pano.position, info.box1.centerBtmDir)
    info.btmPos = o2.pos3d
} else {
    let box = info.box0 || info
    if(!box.btmPos){ 
        ray.set(box.pano.position, box.centerBtmDir)
        let o = ray.intersectObjects([skyBoxTight]) //如果skybound有问题，位置就会错
        box.btmPos = o[0].point.clone() 
        const depth = Math.abs(o[0].face.normal.y) > 0.9  ?  0.4  : -0.4 
        let dir2d = new THREE.Vector2(box.centerBtmDir.x, box.centerBtmDir.z).normalize().multiplyScalar(depth)
        box.btmPos.x += dir2d.x
        box.btmPos.z += dir2d.y  
        
        //addLabel(box.btmPos,'b_'+box.sid,{bgcolor:'#ff4399'}) 
    } 
    info.btmPos = box.btmPos
    
}
return info.btmPos
}

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

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

let 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)
    
    
     
    
    
    
    
    this.compute(dataList)
    
}

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

    let compu = 0
    let beginCompute = () => {
        //获取匹配分数
        let getMatchScore = (box0, box1, { isSingle, center, onlyGet, dontCheckDis } = {}) => {
            let name0 = box0.sid + '&' + box1.sid
            let name1 = box1.sid + '&' + box0.sid
            let matchInfo0 = this.matchScoreMap[box1.category][name0]
            let matchInfo1 = this.matchScoreMap[box1.category][name1]
            let matchInfo = matchInfo0 || matchInfo1
            if (onlyGet) return matchInfo
            let name 
            if (!matchInfo) {
                name = name0
                matchInfo = { name, box0, box1, center }
                this.matchScoreMap[box1.category][name] = matchInfo
            }else{
                return matchInfo
            }
            if (name == 'pano2-1&pano0-0') {
                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 (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.dirAngleXZ)) * 300
                    score += matchInfo.dirAngleXZ //另外角度越大越不容易偏向一边
                }
            }


            let shinkRatio = 1

            if(!dontCheckDis){
                let r = box0.type == 'air' ? 1  : box0.type == 'cabinet' ? 0.9 : 0.5 //随着宽度增加而降低
                
                
                if(box0.type != 'air-hanging' && box0.btmPos && box1.btmPos) { //注：挂空调不应使用btmPosPredict
                    let d = box0.btmPos.distanceToSquared(box1.btmPos)
                    /* if(d > 0.6) { 
                        if(box0.type == 'battery' || box0.predictLen > 0.7 || box1.predictLen > 0.7){ //如果是相对着的角度，距离可以比较远
                            shinkRatio = math.linearClamp(0.8 || (box0.predictLen+box1.predictLen)/2-0.6,  0.8,  4 ,    0.7,  0.4)
                        } 
                    } */ 
                    matchInfo.btmPosPreDis = d 
                    score -= d * 1500 * r * shinkRatio  
                     
                    let a = box0.topPos.distanceToSquared(box1.topPos) 
                    matchInfo.topPosPreDis = a
                    let u = a * 700 * r * shinkRatio 
                    
                    let AP0 = new THREE.Vector2(box0.btmPos.x - A.x, box0.btmPos.z - A.z).lengthSq()
                    let AP1 = new THREE.Vector2(box1.btmPos.x - B.x, box1.btmPos.z - B.z).lengthSq()
                    if(AP0<0.4 || AP1<0.4)u *= 0.3    //太近                      
                    score -= u
                } else if (box0.posAtWall && box1.posAtWall) { 
                    let d = box0.posAtWall.distanceToSquared(box1.posAtWall) 
                    matchInfo.wallPosPreDis = d
                    score -= d * 500 * r //墙面不准所以分低
                }
            }

            //检查从两处看高度是否一致
            /* 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()
                 
                /* if (name == 'pano0-1&pano2-0') {
                    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)
                    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) * 10000
                if (wrongDir) {
                    str.push('wrongDir')
                    return Object.assign(matchInfo, { score: score - 5000, str })
                } 
                
                let minAng = Math.min(180 - matchInfo.dirAngleXZ, matchInfo.dirAngleXZ)//角度小的getIntersect2容易算不准
                
                
                if(!dontCheckDis && box0.type != 'air-hanging' && box0.btmPos && box1.btmPos){
                    let p0 = new THREE.Vector2(box0.btmPos.x, box0.btmPos.z)
                    let p1 = new THREE.Vector2(box1.btmPos.x, box1.btmPos.z)
                    let p =  new THREE.Vector2(matchInfo.center.x,matchInfo.center.z)
                    let dis = p0.distanceToSquared(p) + p1.distanceToSquared(p) 
                    let s = math.linearClamp(minAng, 0, 10,   0, 1)
                    score -= dis * 1000 * s  //如果距离较远就说明算的center误差大，不可信。可能有一个框不准确
                    matchInfo.centerDrift = dis
                }
                
                
                
                getBoxBtm(matchInfo)
                //靠墙的有这些属性 可以帮助预测中心点
                let predict0 = box0.type != 'air-hanging' && box0.btmPos || matchInfo.topPos  
                let predict1 = box1.type != 'air-hanging' && box1.btmPos || matchInfo.topPos
                
                let cr = math.linearClamp(minAng, 0, 10,   0.05, 0.4) //getIntersect2结果的权重
                if (predict0 && predict1) {
                    matchInfo.center = new THREE.Vector3().addVectors(
                        matchInfo.center.clone().add(matchInfo.btmPos).multiplyScalar(1/2* cr),
                        predict0.clone().add(predict1).multiplyScalar(1/2 * (1-cr)) 
                    ).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 == 'pano20-3&pano18-5') {
                console.log(1)
                let color = '#fe1'
                var line1 = LineDraw.createLine([A, A.clone().add(box0.centerBtmDir.clone().multiplyScalar(40))], { color })
                var line2 = LineDraw.createLine([B, B.clone().add(box1.centerBtmDir.clone().multiplyScalar(40))], { color })
                meshGroup.add(line1)
                meshGroup.add(line2)
                addLabel(matchInfo.btmPos, 'btmPos')
            }  */ 

            //检查宽度
            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.btmPos ? 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)
                            /* let vec = new THREE.Vector3().subVectors(box0.btmPos,box1.btmPos)
                            let k = Math.abs(vec.x / vec.z)
                            console.log('pushToGroupAuto',k, box0.sid, box1.sid) */
                            common.pushToGroupAuto([box0, box1], rows)
                        }
                    }
                }
            }
            //一排箱子的角度范围不可超过180度，因为不可能站在箱子上拍，所以超过的话肯定有边缘的不在这一排中。
            //可判断边缘箱子的是否角度偏大，一般中间的被遮挡所以偏小

            rows.forEach(boxes => {
                //从左到右排序
                boxes.sort((a, b) => {
                    //但因有的box跨越到别的box区域，所以这个顺序不准确
                    return getBbox2Diff(a.bbox2CenterX, b.bbox2CenterX)
                })
            })
            
            
            
            //去除不在一条直线上的连接  
            rows.slice(0).forEach(boxes => { 
                if (boxes.length >= 2) {  
                    let removes = [],   bound = new THREE.Box2, size = new THREE.Vector2, maxW = 0.6
                    
                    
                    for (let i = 0, j = boxes.length; i < j; i++) {  
                        let box = boxes[i]  
                        let pos2d = new THREE.Vector2(box.btmPos.x, box.btmPos.z)
                        bound.expandByPoint(pos2d) 
                        bound.getSize(size)
                        let min = Math.min(size.x, size.y)
                        if(min>maxW){ 
                            removes.push([boxes[i], boxes[i - 1]])
                            bound = new THREE.Box2 
                            bound.expandByPoint(pos2d)    
                            console.log('removes',size)
                        } 
                        //console.log('removes',k, box1.sid)
                    }
                    
                    if (removes.length) {
                        console.log(
                            '去除错误row连接',
                            removes.map(e => e.map(a => a.sid))
                        )
                        let { newGroups } = common.disconnectGroup(removes, rows) 
                        //if(newGroups.length>1){//分裂成多组了，重新计算
                        //     console.log(newGroups)
                        //}    
                    }
                }
            
            })
            
            rows.forEach(boxes => {
                //从左到右重新排序
                boxes.sort((a, b) => {
                    //但因有的box跨越到别的box区域，所以这个顺序不准确
                    return getBbox2Diff(a.bbox2CenterX, b.bbox2CenterX)
                })
            })
            
            
            
            
            
            
            
            
            
            
            /* rows.slice(0).forEach(boxes => { 
                if (boxes.length >= 2) {
                    let removes = [], minDiff = 1, minDis = 0.4
                    let lastFirst = 0   
                    for (let i = 1, j = boxes.length; i < j-1; i++) {  
                        let box0 = boxes[lastFirst],
                            box1 = boxes[i] ,   
                            box2 = boxes[i+1]                                   
                        let vec0 = new THREE.Vector3().subVectors(box0.btmPos,box1.btmPos)
                        let vec1 = new THREE.Vector3().subVectors(box1.btmPos,box2.btmPos)
                        
                        let angle = vec0.angleTo(vec1) 
                        
                        if(angle>minDiff){ 
                            removes.push([boxes[i], boxes[i + 1]])
                            lastFirst = i
                            console.log('removes',   angle)
                        }
                        
                    }
                    
                    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.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.btmPos ||  box0.posAtWall 
                        let p1 = box1.predictCenter || box1.btmPos ||  box1.posAtWall 
                        diffs.push(p0.distanceToSquared(p1)) 
                    } 
                    let minW = standards[category].widthNormal.min     
                    if(!boxes[0].btmPos)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.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].btmPos) {
                    bigBox.btmPos = bigBox.boxes.reduce((w, c) => w.add(c.btmPos), new THREE.Vector3()).multiplyScalar(1 / bigBox.boxes.length)
                    //addLabel(bigBox.btmPos,'b_'+bigBox.sid, {bgcolor:'#f93',a:0.4})                        
                }
                if (bigBox.boxes[0].topPos) {
                    bigBox.topPos = bigBox.boxes.reduce((w, c) => w.add(c.topPos), new THREE.Vector3()).multiplyScalar(1 / bigBox.boxes.length)
                }
                if (bigBox.boxes[0].posAtWall) {
                    bigBox.posAtWall = bigBox.boxes.reduce((w, c) => w.add(c.posAtWall), new THREE.Vector3()).multiplyScalar(1 / bigBox.boxes.length)
                }
                 
            })

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

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

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

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

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

            return { reversed, k }
        }

        let searchByRow = (groups, datas) => { //先查找row，匹配row，再slice row的方法
        
            this.matchScoreMap['rowBigBox'] = {}

            let rowInfos = []

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

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

                let rowInfo
                if (rowBigBox0.boxes.length > 1 && rowBigBox1.boxes.length > 1) {//多对多，可以求两端的位置
                    
                    let lefts = [rowBigBox0.left, rowBigBox1.left]
                    let rights = [rowBigBox0.right, rowBigBox1.right]
                    let leftInfo
                    let rightInfo
                    let info2 = getReverseInfo(rowBigBox0, rowBigBox1)
                    let len0 = rowBigBox0.predictLen, //长度应该接近
                        len1 = rowBigBox1.predictLen
                    let overLen = Math.abs(len0 - len1) /* /  (rowBigBox0.boxes.length + rowBigBox1.boxes.length) * 5 */
                    if (overLen > 1){
                        console.error('overLen> 1', overLen, rowBigBox0.sid, '和', rowBigBox1.sid)
                        return done() 
                    }
                        
                    
                    if (info2.reversed) {
                        leftInfo = getMatchScore(lefts[0], rights[1], { isSingle: true })
                        rightInfo = getMatchScore(rights[0], lefts[1], { isSingle: true })
                    } else {
                        leftInfo = getMatchScore(lefts[0], lefts[1], { isSingle: true })
                        rightInfo = getMatchScore(rights[0], rights[1], { isSingle: true })
                    }
                    let posLeft = getBoxPos(leftInfo)
                    let posRight = getBoxPos(rightInfo)

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

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

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

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

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

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

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

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

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

                    /* var line1 = LineDraw.createLine([posLeft, posRight]) 
                    meshGroup.add(line1) */
                    //根据btmPos矫正一下中心位置, 否则容易偏漫游点这一侧
                    let center = new THREE.Vector3().addVectors(posLeft, posRight).multiplyScalar(0.5)
                    center.add(rowBigBox0.btmPos).add(rowBigBox1.btmPos).multiplyScalar(1/3)   
                    let axis = k > 1 ? 'z' : 'x'
                    //posLeft[axis] = center[axis],  posRight[axis] = center[axis]
                     
                    let match = getMatchScore(rowBigBox0, rowBigBox1, { isSingle: true, center }) //是否预先传送center ？
                    //rowInfo.minAngs = [leftInfo.minAng , rightInfo.minAng]

                    if(match.name == 'pano20-row-8,10&pano16-row-6,0'){
                        console.log(8)
                    }  

                    let sc = match.score - overLen * 1000 - wrongK*100 + leftInfo.score + rightInfo.score
                    if (sc < -4000) {
                        console.log('放弃，匹配分过低，可能不是一组', rowBigBox0.sid, '和', rowBigBox1.sid, sc)
                        return done()
                    }
                    
                    
                     
                    //console.log('getcenter', rowBigBox0.sid, '和', rowBigBox1.sid,   overLen, match.score + overLen * 1000 + leftInfo.score + rightInfo.score)
                    rowInfo = {
                        rowBigBox0,
                        rowBigBox1,
                        match,
                        k,
                        posLeft,
                        posRight,
                        score: sc / 3 + 500   , //700 + match.score*0.7 + (leftInfo.score + rightInfo.score)*0.3 ,
                        reversed: info2.reversed,
                    }
                } else {
                    if (rowBigBox0.boxes.length == 1 && rowBigBox1.boxes.length == 1) { 
                        rowInfo = getMatchScore(rowBigBox0.boxes[0], rowBigBox1.boxes[0] /* , { 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 == "pano2-row-6,4&pano4-row-3"){
                            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
                    }
                } 
                
                function done(rowInfo){ 
                    rowInfo && rowInfos.push(rowInfo)
                    rowInfos[rowBigBox0.sid + '&' + rowBigBox1.sid] = rowInfo
                }
                done(rowInfo)
                
                return rowInfo
            }

            let matchGroups = []
            let allRelations = []

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

            let ignoreCountMatch = groups.filter(e => e.length > 1).length == 1

            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 : -1000) //只考虑组成功的分数
                            }, 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.2 })
                    //addLabel(right, 'Right' + index, { bgcolor: '#F00', a: 0.2 })
                    let center = new THREE.Vector3().addVectors(left, right).multiplyScalar(0.5)
                    //addLabel(center, 'center' + index, { bgcolor: '#F00', a: 0.3 })
                    ;(info.left = left), (info.right = right), (info.center = center)
                    info.pointsLen = pointsLen
                }

                if (bigBoxes.length > 0) {
                    let getAve = bigBoxes => {
                        let center1 = new THREE.Vector3(),
                            size = new THREE.Vector3()
                        bigBoxes.forEach(box => {
                            let center0 = getBoxPos(box)
                            center1.add(center0)
                            size.add(box.size)
                        })

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

                        return { center1, size }
                    }
                    let { 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.4).areaMix

                        if (areaMixExpand / area0 < 0.7 && areaMixExpand / area1 < 0.7) continue   //包含的可以通过
                        
                        let areaMix = getBoxMixArea(0, 0).areaMix //实际重合面积

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

                        group0.contains.push({ group: group1, selfPercent: areaMix / area0, percent2: areaMix / area1, areaMix })
                        group1.contains.push({ group: group0, selfPercent: areaMix / area1, percent2: areaMix / area0, areaMix })

                         

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

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

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

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

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

                    let k  
                    {
                        //const k = infos.reduce((w, c) => (w += c.k), 0) / infos.length
                        let ks = infos.map(e=>e.k)                    
                        ks.sort((a,b)=>a-b)
                        let min = ks[0], max = ks[ks.length-1]
                        if(min<1 && max>1){//比较最小和最大，选取更极端的那个
                            let min_ = 1/min
                            if(min_ < max) k = max
                            else k = min
                        }else k = (min + max) / 2
                    }
                    
                    
                    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)
                                    
                                    if(topPos.y - groundY<0){
                                        console.log('?')
                                    }
                                    
                                    topPoss.push(topPos)
                                }
                                if ((k < 1 && topPoss[0].z > topPoss[count - 1].z) || (k > 1 && topPoss[0].x > topPoss[count - 1].x)) {
                                    heights1.reverse()
                                }
                                return heights1
                            })
                        }else{
                            let bigBoxes = []
                            infos.forEach(e => {
                                bigBoxes.push(...e.group.filter(e=>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) 
            }
             
            
            for (let id in this.datas) { 
                //对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)
                                if(version == 'vision'){                               
                                    i = this.datasMixed[id].shapes.findIndex(e=>e.sid == box.sid)
                                    this.datasMixed[id].shapes.splice(i, 1)
                                }
                            })
                            console.log('因融合而删除', bigBox.boxes) 
                            datas[id].push(bigBox)
                            if(version == 'vision'){
                                this.datasMixed[id].shapes.push(bigBox)
                            }
                            bigBox.index = datas[id].length>1 ? datas[id][datas[id].length-2].index+1 : 0 
                            {
                                let a = bigBox.sid.split('mix-')
                                bigBox.sid = a[0]+bigBox.index+'(mix'+a[1]+')'    //"pano20-mix-1,2"
                            } 
                            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
            }



            {
                //重新根据距离排序，挑选离所有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]
            }











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


            //零散匹配。

            

            
            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)){
                        if(box.sid == 'pano4-1'){
                            console.log(3)
                        }
                        
                        //如果和现有的box的距离都很远，很可能是漏掉的
                        let near = boxes.find(solidBox =>{ 
                            if(solidBox.name == "air-pano16-mix-5,4&pano18-0"){
                                console.log(3)
                            }
                        
                            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 dis = solidBox.bound.distanceToPoint(p2)
                            
                            let r0 = solidBox.boxType == 'air' ? 1.5 : solidBox.boxType == 'battery' ? 1.1 : 1 //空调最不容易扎堆放置，所以范围设置广一些 
                            let r1 = math.linearClamp( box.pano.position.distanceTo(p2), 3, 6, 1, 1.5); //距离远的话识别、计算都会更不准确，给一定的容错
                           
                            let ra = (solidBox.boxType ==  box.type ? 1 : 0.5 ) * r0 * r1    //数字越小限制越大
                            //let rb = (solidBox.boxType ==  box.type ? 0.5 : 0.2 ) * r0 * r1 
                            
                            let a = maxWidth * maxWidth * ra - p1_.distanceToSquared(p2_)
                            let b = - dis * 0.5
                             
                            
                            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 = [], boxes = []
                        for (let i = 0, len = goodList2.length; i < len; i++) {
                            //向后选择队友
                            let match0 = goodList2[i]
                            if (subGroups.some(e => e.includes(match0))) continue //被挑选了的没有选择权

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

                        
                    }
                })
                
                //改为之后 findRest, 因为两者都single的可能性低
                
                /* let judge = box => {
                    if (!used(box)) {
                        matched.push(box)
                        createSinglePano(box)
                    }
                }
                tooLows.forEach(e => {
                    judge(e.box0)
                    judge(e.box1)
                }) */
            }
        }

        function mixMatchBox(list, log) {
            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 prefix = log == 'findRest' ? 'rest:' : 'low:'
            let object = {
                name: prefix + list.map(e => e.name),
                boxType: list[0].boxType,
                center,
                size,
                list,
                xProp: list.find(e=>e.xProp) && list.find(e=>e.xProp).xProp,
                yProp: list.find(e=>e.yProp) && list.find(e=>e.xProp).yProp,
            }
            let o = restrictSize(size.x, size.z, object)
            size.x = o.x
            size.z = o.y
                                
                                
            let box = new Box(object)
            console.log('mixMatchBox',box)
            return box
        }



        function combineBoxes(boxes){ 
            const group = []
            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.4 : 1.1       //如果是没有交集，限制更大些
                        let maxDiff = 0.3
                        if ((size.x < maxX * r || size.x-maxX<maxDiff) && (size.z < maxZ * r || size.z-maxZ<maxDiff) ) {
                            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 info = {
                            name: 'mix:' + pair.map(e => e.name + ','),
                            mixedFrom: pair,
                            boxType,
                            center,
                            size,
                            xProp: pair.find(e=>e.xProp) && pair.find(e=>e.xProp).xProp,
                            yProp: pair.find(e=>e.yProp) && pair.find(e=>e.xProp).yProp,
                        }
                        let o = restrictSize(size.x, size.z, info)
                        size.x = o.x
                        size.z = o.y
                        
                        let box = new Box(info)
                        console.error('混合', boxType,   pair, box)
                    })
                }
            }
         
        }


        function combines(type) {
            //合并boxSolids .  battery经常嵌套
            if (type == 'battery') {   
                /* 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 => { 
                    combineBoxes(boxes)
                })
            }
        }  


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

            let center = getBoxPos(box)
            
             
            let info = {
                name: box.sid,
                box0: box,
                center, 
                topPos: box.topPos,
                btmPos: box.btmPos,
            }
             
            preDealBox(info) 
            
            let a = getPoseScore(info.boxposes,true)
            let failed = a < -8
        
            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)
        }



        this.expandModelBound() 

        if(version == 'vision')this.datasMixed = common.CloneObject(this.datas,null, [player.model.panos.list[0].constructor])

         
        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,
                        category: shape.category,   //提前 便于调试
                        pano: player.model.panos.index[panoId],
                        index: i,
                    },
                    shape
                )
            })   
        } 
        
         
        player.model.chunks.forEach(e=>{
            modelBound.union(e.geometry.boundingBox) //注：不用model.boundingBox是 因为union了pano的position的 
        }) 
        //针对部分模型错误，只有底面的，union一下pano.position 
        player.model.panos.list.forEach(e=>{
            modelBound.expandByPoint(e.position)
        })
        
        groundY = modelBound.min.y//部分模型底部高度错误，不管了
        
        groundPlane.setFromNormalAndCoplanarPoint(new THREE.Vector3(0, 1, 0), new THREE.Vector3(0, groundY, 0))

        /* const w = 0  //这一版的模型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()
    }
}



expandModelBound(){
    const maxDis0 = 1, maxDis1 = 3  //不可扩展太宽，否则不准确的框会飘很远，甚至多画多个box，如R7xZsmm9FsG
    let newBound = modelBound.clone()
     
    let list = []
    for(let panoId in this.datas ){
        this.datas[panoId].shapes.forEach(box=>{
            getBoxBase(box) 
            if(box.btmPosPredict){
                let far = box.pano.position.distanceToSquared(box.btmPosPredict)
                if(far > 12)return //太远不准
                let dis = modelBound.distanceToPoint(box.btmPosPredict)
                if(dis>0 && dis<maxDis1){//maxDis1用来防air-hanging和一些错误的框 
                    list.push({box, dis})
                }  
            }
        }) 
    }
    
    list.sort((a,b)=>a.dis-b.dis)
    //let mid = list[Math.floor(list.length/2)]
    let mid = list.length//  /2
    for(let i=0;i<mid;i++){
        let box = list[i].box
        let marginBound = new THREE.Box3;
        let pos = box.btmPosPredict
        if(list[i].dis > maxDis0){
            let p1 = pos.clone().clamp(modelBound.min, modelBound.max)
            let vec = new THREE.Vector3().subVectors(pos,p1).normalize().multiplyScalar(maxDis0)
            pos = new THREE.Vector3().addVectors(p1, vec)
        }
        marginBound.expandByPoint(pos);
        //console.log(box.btmPosPredict, box)
        marginBound.expandByVector(new THREE.Vector3(0.2,0,0.2)); 
        newBound.union(marginBound);   
    }
    
    
    console.log(newBound)
    
    skyBoxTight = new BoundingMesh(newBound, undefined, 0)
    skyBoxTight.material.side = 2
    skyBoxTight.material.wireframe = true
    skyBoxTight.material.opacity = 0.05
    skyBoxTight.material.transparent = true
    //skyBoxTight.visible = false  
    skyBoxTight.updateMatrixWorld()//不update的话raycaster是错的
    meshGroup.add(skyBoxTight)
    
    this.skyBoxTight = skyBoxTight
    this.safeBound = safeBound = newBound
    boundConfirmed = true
    
    
    
    
    
}

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

    player.on(PlayerEvents.FlyingEnded, () => {
        // 点位跳转后加载线框
        if (player.mode != Viewmode.PANORAMA) return // 只有PANORAMA模式下需要加载
        this.load(player.currentPano.id)
    })
    
    window.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.datasMixed[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 || this.currentId == panoId) return // 防止连续跳转点位时，clear后才load好上一点位的数据，导致出现之前的标记

    this.currentId = panoId
    


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

    shapes.forEach((shape ) => {
        // 填充色和线框色
        // let { fill_color, line_color } = shape

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

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

        if (!fill_color) fill_color = [255, 255, 255, 0]
        if (!line_color) line_color = [255, 0, 0, 255]

        this.showSignalFrom2d(
            shape.category + '-' + shape.sid,
            shape.bbox2,
            imageWidth,
            imageHeight,
            {
                fill: {
                    color: new THREE.Color().setRGB(fill_color[0] / 255, fill_color[1] / 255, fill_color[2] / 255),
                    opacity: fill_color[3] / 255,
                },
                line: {
                    color: new THREE.Color().setRGB(line_color[0] / 255, line_color[1] / 255, line_color[2] / 255),
                    opacity: 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 = [
        new THREE.Vector2(rect[0], rect[1]),
        new THREE.Vector2(rect[2], rect[1]),
        new THREE.Vector2(rect[2], rect[3]),
        new THREE.Vector2(rect[0], rect[3]),
    ]

    // 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(uv => {
        let dir = getDirByUV(uv, player.currentPano)
        // points.push(dir.sub(centerVec))  // 计算其他点相对于中点的坐标，方便旋转平移等
        points.push(dir)
    })

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

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

    // 名称
    const textMesh = new TextSprite({
        text: name,
        backgroundColor: { r: options.line.color.r * 255, g: options.line.color.g * 255, b: options.line.color.b * 255, a: 0.8 },
        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)
}
}