export type Con = YH_bang[];//单块1220*2440的板结果 Container
export type Inv = Con[];    //个体:优化结果 包含多个大板 Individual

/**纹路类型 Positive=0正纹 Reverse=1反纹 CanReversal=2可翻转 */
export enum LineType
{
    /**正纹 */
    Positive = 0,
    /**反纹 */
    Reverse = 1,
    /**可翻转 */
    CanReversal = 2,
}

/**优化的大板 */
export interface YH_bang
{
    /**板ID */
    bangid: number;
    /**纹路 */
    line: LineType;
    x: number;
    y: number;
    /**排版高 */
    pbg: number;
    /**排版宽 */
    pbk: number;

    ishb?: boolean;//是否参与合并的板
    hb?: number[];  //合在并的板
    isgr?: boolean; //是否关连
    gr?: number[];//关联的板的集合
    grid?: number; //跟别的板关联的ID
    isbig?: boolean;//是否为合并的大板
    isqg?: boolean;//是否被切掉的板
}

/**版面类型: Positive=0正面 Reverse=1反面 Arbitrary=2任意面 */
export enum ComposingType
{
    /**正面 */
    Positive = 0,
    /**反面 */
    Reverse = 1,
    /**任意面 */
    Arbitrary = 2
}

/**孔类型 None=0无 Positive=1正面 Reverse=2反面 Two=3正反 */
export enum HoleType
{
    /**无 */
    None = 0,
    /**正面 */
    Positive = 1,
    /**反面 */
    Reverse = 2,
    /**正反 */
    Two = 3
}

/** 小板 */
export interface xbang
{
    /**长 */
    l: number;
    /**宽 */
    w: number;
    /**纹路 */
    line: LineType;
    /**排版面 */
    face: ComposingType;
    /**小板ID */
    id: number;
    /**小板编号 */
    bno: string;
    /**孔面: 0无孔 1正面有孔 2反面有孔 3正反面都有孔 */
    holeFaceCount: HoleType;
    /**是矩形 */
    isRect?: boolean;
    /**有孔 */
    hasHole?: boolean;
    /**false单面  true双面 */
    isdtwosided?: boolean;
}

/** 大板 */
export class Big_bang   //待优化的板
{
    l: number;              //长
    w: number;              //宽
    x: number;              //x
    y: number;              //y
}


export enum BlockRegion
  {
  /** 左下 = 0 */
  LEFT_BOTTOM = 0,
  /** 右下 = 1 */
  RIGHT_BOTTOM = 1,
  /** 右上 = 2 */
  RIGHT_TOP = 2,
  /** 左上 = 3 */
  LEFT_TOP = 3,
}

export class WorkerItemType {
    w?: Worker
    goodsId?: string | number
    pm?: any
    status?: 'start' | 'stop'
}

//开料生产
export class KLSC
{
    xbang: YH_bang[];       //小板集合
    Bakbang: YH_bang[];     //备份小板集合
    HB_bang: number[] = []; //合并的板
    HB: number[][] = [];    //合并板的数组
    B_k: number;            //大板宽
    B_g: number;            //大板高
    dt: number;             //刀头大小（含修边）
    wzx: number;            //临时用于打印
    wzy: number;            //临时用于打印
    jl_mz: number;          //用于测试距离或者面积优选

    SCid: number[] = [];    //用于存化顺序的板的bangid
    //f = () => 5;
    constructor(xbang: YH_bang[], Bang_k: number, Bang_g: number, dt: number, wzx: number, wzy: number, JL_MZ: number) //false JL  ture MZ
    {
        this.xbang = JSON.parse(JSON.stringify(xbang));
        //this.xbang = [...xbang];
        this.Bakbang = JSON.parse(JSON.stringify(xbang));
        this.B_g = Bang_g;
        this.B_k = Bang_k;
        this.dt = dt;
        this.wzx = wzx;
        this.wzy = wzy;
        this.jl_mz = JL_MZ;
        this.XDscjs();
    };

    //查找距离中心最近，且跟最大的板相差不大于容差面积 rcmz 的板 返加YH_bang[].bangid
    MaxMZ = (rcmz: number): number =>
    {
        let tmepckb: number;
        let tmepckb1: number;
        let tempxbang: YH_bang[] = [];
        this.xbang.sort((b, a) => a.pbg * a.pbk - b.pbg * b.pbk);
        let maxmz = this.xbang[0].pbg * this.xbang[0].pbk / 1000000;
        let maxbangid = this.xbang[0].bangid;
        for (let i = 0; i < this.xbang.length; i++)
        {
            if (this.xbang[i].pbg > this.xbang[i].pbk)
            {
                tmepckb = this.xbang[i].pbg / this.xbang[i].pbk;
            }
            else
            {
                tmepckb = this.xbang[i].pbk / this.xbang[i].pbg;
            }
            if (this.xbang[0].pbg > this.xbang[0].pbk)
            {
                tmepckb1 = this.xbang[0].pbg / this.xbang[0].pbk;
            }
            else
            {
                tmepckb1 = this.xbang[0].pbk / this.xbang[0].pbg;
            }

            if (equaln(this.xbang[i].pbg * this.xbang[i].pbk / 1000000, maxmz, rcmz) && equaln(tmepckb, tmepckb1, 2))
            {
                tempxbang.push(this.xbang[i]);
            }
        }
        if (tempxbang.length > 0)
        {
            return this.minJL(tempxbang);
        }
        else
        {
            return maxbangid;
        }

    };

    //查找指定Bangid的板  返回在数组中的位置ID     f = () => 5;
    getID = (bangid: number): number => this.xbang.findIndex((n) => n.bangid == bangid);

    //查找备份板Bangid的板  返回在数组中的位置ID     f = () => 5;
    getID_Bkb = (bangid: number): number => this.Bakbang.findIndex((n) => n.bangid == bangid);


    //查找距离最近的板 返加YH_bang[].bangid
    minJL = (xbang: YH_bang[]): number => { xbang.sort((b, a) => Math.hypot(this.B_k / 2 - b.x - b.pbk / 2, this.B_g / 2 - b.y - b.pbg / 2) - Math.hypot(this.B_k / 2 - a.x - a.pbk / 2, this.B_g / 2 - a.y - a.pbg / 2)); return xbang[0].bangid; };

    //查找左边且Y位置一样的板，， 返加YH_bang[].bangid
    F_Left = (bangid: number): number =>
    {
        let a = this.xbang.find((n) => equaln(n.x + n.pbk + this.dt, this.xbang[this.getID(bangid)].x, 0.001)
            && equaln(n.y, this.xbang[this.getID(bangid)].y, 0.001) && n.ishb == false);
        if (a == undefined) { return; } return a.bangid;
    };
    //查找左边关连的板，并写入
    F_GL_LR = () =>
    {
        let temp: number;
        let bangIndex: number;
        let maxkd: number = 0;
        let maxid: number;  //bangid
        if (this.xbang.length > 1)
        {
            for (let i = 0; i < this.xbang.length; i++)
            {
                bangIndex = i;
                while (1)  //左边
                {
                    if (this.xbang[bangIndex].pbg > this.xbang[bangIndex].pbk && this.xbang[bangIndex].pbk < 200 && this.xbang[bangIndex].ishb == false)
                    {
                        temp = this.xbang.findIndex(n => n.x + n.pbk < this.xbang[bangIndex].x && n.y <= this.xbang[bangIndex].y && this.XJcd(n.bangid, this.xbang[bangIndex].bangid)[1] > this.xbang[bangIndex].pbk);
                        if (temp != -1)
                        {
                            if (this.xbang[temp].pbk > maxkd)
                            {
                                maxkd = this.xbang[temp].pbk;
                                maxid = this.xbang[temp].bangid;
                            }
                            if (this.xbang[temp].pbk > 200)
                            {
                                this.xbang[temp].isgr = true;
                                this.xbang[temp].gr.push(this.xbang[bangIndex].bangid);
                                this.xbang[bangIndex].grid = this.xbang[temp].bangid;
                                break;
                            }
                            else
                            {
                                bangIndex = temp;
                            }

                        }
                        else
                        {
                            break;
                        }
                    }
                    else
                    {
                        break;
                    }

                }
                bangIndex = i;
                while (1) //右边
                {
                    if (this.xbang[bangIndex].pbg > this.xbang[bangIndex].pbk && this.xbang[bangIndex].pbk < 200 && this.xbang[bangIndex].ishb == false)
                    {
                        temp = this.xbang.findIndex(n => n.x > this.xbang[bangIndex].x + this.xbang[bangIndex].pbk
                            && this.LR_is(this.xbang[bangIndex].bangid, n.bangid) == false
                            && n.pbg > 300
                            && this.XJcd(n.bangid, this.xbang[bangIndex].bangid)[1] > this.xbang[bangIndex].pbk);
                        if (temp != -1)
                        {
                            if (this.xbang[temp].pbk > maxkd)
                            {
                                maxkd = this.xbang[temp].pbk;
                                maxid = this.xbang[temp].bangid;
                            }
                            if (this.xbang[temp].pbk > 200)
                            {
                                this.xbang[temp].isgr = true;
                                this.xbang[temp].gr.push(this.xbang[bangIndex].bangid);
                                this.xbang[bangIndex].grid = this.xbang[temp].bangid;
                                break;
                            }
                            else
                            {
                                bangIndex = temp;
                            }

                        }
                        else
                        {
                            break;
                        }
                    }
                    else
                    {
                        break;
                    }

                }


            }
        };
    };

    //查找上下边关连的板，并写入
    F_GL_TD = () =>
    {
        let temp: number;
        let bangIndex: number;
        let maxkd: number = 0;
        let maxid: number;  //bangid
        if (this.xbang.length > 1)
        {
            for (let i = 0; i < this.xbang.length; i++)
            {
                bangIndex = i;
                while (1)  //上面
                {
                    if (this.xbang[bangIndex].pbg < this.xbang[bangIndex].pbk && this.xbang[bangIndex].pbg < 200 && this.xbang[bangIndex].ishb == false)
                    {
                        temp = this.xbang.findIndex(n => n.y > this.xbang[bangIndex].y + this.xbang[bangIndex].pbg && n.x + 0.01 <= this.xbang[bangIndex].x
                            && this.XJcd(n.bangid, this.xbang[bangIndex].bangid)[0] > this.xbang[bangIndex].pbg);
                        if (temp != -1)
                        {
                            if (this.xbang[temp].pbg > maxkd)
                            {
                                maxkd = this.xbang[temp].pbg;
                                maxid = this.xbang[temp].bangid;
                            }
                            if (this.xbang[temp].pbg > 200)
                            {
                                this.xbang[temp].isgr = true;
                                this.xbang[temp].gr.push(this.xbang[bangIndex].bangid);
                                this.xbang[bangIndex].grid = this.xbang[temp].bangid;
                                break;
                            }
                            else
                            {
                                bangIndex = temp;
                            }

                        }
                        else
                        {
                            break;
                        }
                    }
                    else
                    {
                        break;
                    }

                }
                bangIndex = i;
                while (1)  //下面
                {

                    if (this.xbang[bangIndex].pbg < this.xbang[bangIndex].pbk && this.xbang[bangIndex].pbg < 200 && this.xbang[bangIndex].ishb == false)
                    {

                        temp = this.xbang.findIndex(n => n.y + n.pbg < this.xbang[bangIndex].y + this.xbang[bangIndex].pbg && n.x - 0.01 <= this.xbang[bangIndex].x
                            && this.XJcd(n.bangid, this.xbang[bangIndex].bangid)[0] > this.xbang[bangIndex].pbg);
                        if (temp != -1)
                        {
                            if (this.xbang[temp].pbg > maxkd)
                            {
                                maxkd = this.xbang[temp].pbg;
                                maxid = this.xbang[temp].bangid;
                            }
                            if (this.xbang[temp].pbg > 200)
                            {
                                this.xbang[temp].isgr = true;
                                this.xbang[temp].gr.push(this.xbang[bangIndex].bangid);
                                this.xbang[bangIndex].grid = this.xbang[temp].bangid;
                                break;
                            }
                            else
                            {
                                bangIndex = temp;
                            }

                        }
                        else
                        {
                            break;
                        }
                    }
                    else
                    {
                        break;
                    }

                }


            }
        };
    };

    //查找有异形交集关连的板，并写入
    F_GL_JJB = () =>
    {
        let temp: number;
        if (this.xbang.length > 1)
        {
            for (let i = 0; i < this.xbang.length; i++)
            {
                temp = this.xbang.findIndex(n => this.XJcd(n.bangid, this.xbang[i].bangid)[0] > 50
                    && this.XJcd(n.bangid, this.xbang[i].bangid)[1] > 50 && n.bangid != this.xbang[i].bangid);
                if (temp != -1)
                {
                    if (this.xbang[i].pbg * this.xbang[i].pbk > this.xbang[temp].pbg * this.xbang[temp].pbk)
                    {
                        this.xbang[i].isgr = true;
                        this.xbang[i].gr.push(this.xbang[temp].bangid);
                        this.xbang[temp].grid = this.xbang[i].bangid;
                    }
                    else if (equaln(this.xbang[i].pbg * this.xbang[i].pbk, this.xbang[temp].pbg * this.xbang[temp].pbk, 0.01))
                    {
                        if (this.xbang[temp].x > this.xbang[i].x)
                        {

                            this.xbang[i].isgr = true;
                            this.xbang[i].gr.push(this.xbang[temp].bangid);
                            this.xbang[temp].grid = this.xbang[i].bangid;
                        }
                        else
                        {
                            this.xbang[temp].isgr = true;
                            this.xbang[temp].gr.push(this.xbang[i].bangid);
                            this.xbang[i].grid = this.xbang[temp].bangid;
                        }
                    }
                    else
                    {
                        this.xbang[temp].isgr = true;
                        this.xbang[temp].gr.push(this.xbang[i].bangid);
                        this.xbang[i].grid = this.xbang[temp].bangid;
                    }

                }
            }
        };
        for (let k = 0; k < this.xbang.length; k++)
        {
            let newgr = [... new Set(this.xbang[k].gr)];
            this.xbang[k].gr = newgr;
        }
    };

    //判断有关联的板跟大板之间是否有交集，如果有取消这块板的关联
    Is_big_gr = () =>
    {
        for (let k = 0; k < this.xbang.length; k++)
        {
            let newgr = [... new Set(this.xbang[k].gr)];
            this.xbang[k].gr = newgr;
        }
        let tempx: number;
        let tempy: number;
        let bangIndex1 = this.xbang[this.getID(this.HB[0][0])];
        let bangIndex2: number;
        for (let i = 0; i < this.xbang.length; i++)
        {
            if (this.xbang[i].isgr == true)
            {
                tempx = 0;
                tempy = 0;
                for (let j = 0; j < this.xbang[i].gr.length; j++)
                {
                    bangIndex2 = this.getID(this.xbang[i].gr[j]);
                    if (this.xbang[i].bangid == 10)////////////////////用于调试
                    {
                        console.log(this.xbang[i].bangid);
                    }
                    if (this.xbang[bangIndex2].pbg > this.xbang[bangIndex2].pbk)
                    {
                        tempy = this.Jcxj(bangIndex1.y, bangIndex1.pbg, this.xbang[bangIndex2].y, this.xbang[bangIndex2].pbg);
                    }
                    else
                    {
                        tempx = this.Jcxj(bangIndex1.x, bangIndex1.pbk, this.xbang[bangIndex2].x, this.xbang[bangIndex2].pbk);
                    }
                }
                if (tempx > 50 || tempy > 50)
                {
                    this.xbang[i].isgr = false;
                }
            }
        }

    };


    //检测两块板之间的右上角是否有板  false 没有 true 有
    LR_is = (bangid1: number, bangid2: number): boolean =>
    {
        let tb: YH_bang[] = [];
        tb.push(this.xbang[this.getID(bangid1)]);
        tb.push(this.xbang[this.getID(bangid2)]);
        if (tb[0].pbg + tb[0].y > tb[1].pbg + tb[1].y)//右上空间 左边高
        {
            return this.JCQY_is_bang(tb[1].x, tb[1].y + tb[1].pbg + this.dt, tb[1].pbk, tb[0].pbg - tb[1].pbg - this.dt);
        }
        else
        {
            return false;
        }
    };

    //检测两块板之间的右上角是否有板  false 没有 true 有
    TD_is = (bangid1: number, bangid2: number): boolean =>
    {
        let tb: YH_bang[] = [];
        tb.push(this.xbang[this.getID(bangid1)]);
        tb.push(this.xbang[this.getID(bangid2)]);
        if (tb[0].pbk + tb[0].x > tb[1].pbk + tb[1].x)//右下空间 左边高
        {
            return this.JCQY_is_bang(tb[1].x, tb[1].y + tb[1].pbg + this.dt, tb[1].pbk, tb[0].pbg - tb[1].pbg - this.dt);
        }
        else
        {
            return false;
        }
    };

    //查找左边且Y位置一样的板，， 返加YH_bang[].bangid
    F_Left_Big = (bangid: number, gbcd: number): number =>
    {
        let tempjh: YH_bang[] = [];
        for (let i = 0; i < this.xbang.length; i++)
        {
            if (this.xbang[i].x + this.xbang[i].pbk < this.xbang[this.getID(bangid)].x && this.XJcd(this.xbang[i].bangid, this.xbang[this.getID(bangid)].bangid)[1] > gbcd)
            {
                tempjh.push(this.xbang[i]);
            }
        }
        if (tempjh.length > 0)
        {
            tempjh.sort((a, b) => a.x - b.x);
            return tempjh[0].bangid;
        }
        else
        {
            return -1;
        }
    };

    //找到左右靠边最长的高度  返回  [0]长度 [1] y位置   [2] 0左边 1 右边
    L_R_kbcd = (bangid: number): [number, number, number] =>
    {
        let l_b: YH_bang[] = [];
        let cd_l = 0; let cd_r: number = 0; let wzl: number; let wzr: number;
        let tb = [...this.xbang];
        let tempx: number = this.xbang[this.getID(bangid)].x;
        let tempy: number = this.xbang[this.getID(bangid)].y;
        let tempk: number = this.xbang[this.getID(bangid)].pbk;
        let tempid: number;
        let isend: boolean = true;
        for (let i = 0; i < 2; i++)
        {
            l_b = [];
            tb = [...this.xbang];
            isend = true;
            while (isend == true)
            {
                if (i == 0) { tempid = tb.findIndex((n) => equaln(n.x + n.pbk + this.dt, tempx, 0.001) && (n.y <= tempy)); }
                else { tempid = tb.findIndex((n) => equaln(n.x, tempx + tempk + this.dt, 0.001) && (n.y <= tempy)); }

                if (tempid != -1)
                {
                    l_b.push(tb[tempid]);
                    tb.splice(tempid, 1);
                }
                else
                {
                    isend = false;
                }
            }
            if (l_b.length > 0)
            {
                l_b.sort((a, b) => b.pbg - a.pbg);
                if (i == 0) { cd_l = l_b[0].pbg; wzl = l_b[0].y; } else { cd_r = l_b[0].pbg; wzr = l_b[0].y; }
            }
        }
        if (cd_l > cd_r || cd_l == cd_r && cd_l > 0)
        {
            return [cd_l, wzl, 0];
        }
        else if (cd_l < cd_r)
        {
            return [cd_r, wzr, 1];
        }
        else
        {
            return [0, 0, 0];
        }

    };

    //查找右边且Y位置一样的板，， 返加YH_bang[].bangid
    F_Right = (bangid: number): number =>
    {
        let a = this.xbang.find((n) => equaln(n.x, this.xbang[this.getID(bangid)].x + this.xbang[this.getID(bangid)].pbk + this.dt, 0.001)
            && equaln(n.y, this.xbang[this.getID(bangid)].y, 0.001) && n.ishb == false);
        if (a == undefined) { return; } return a.bangid;
    };

    //查找右边且Y位置一样的板，， 返加YH_bang[].bangid
    F_Right_Big = (bangid: number, gbcd: number): number =>
    {
        let tempjh: YH_bang[] = [];
        for (let i = 0; i < this.xbang.length; i++)
        {
            if (this.xbang[i].x > this.xbang[this.getID(bangid)].x + this.xbang[this.getID(bangid)].pbk && this.XJcd(this.xbang[i].bangid, this.xbang[this.getID(bangid)].bangid)[1] > gbcd)
            {
                tempjh.push(this.xbang[i]);
            }
        }
        if (tempjh.length > 0)
        {
            tempjh.sort((a, b) => a.x - b.x);
            return tempjh[0].bangid;
        }
        else
        {
            return -1;
        }
    };

    //查找下边且X位置一样的板，， 返加YH_bang[].bangid
    F_Down = (bangid: number): number =>
    {
        let a = this.xbang.find((n) => equaln(n.y + n.pbg + this.dt, this.xbang[this.getID(bangid)].y, 0.001)
            // && n.x > 10
            && equaln(n.x, this.xbang[this.getID(bangid)].x, 0.001) && n.ishb == false);
        if (a == undefined) { return; } return a.bangid;
    };

    //查找上边且X位置一样的板，， 返加YH_bang[].bangid
    F_TOP = (bangid: number): number =>
    {
        let a = this.xbang.find((n) => equaln(n.y, this.xbang[this.getID(bangid)].y + this.xbang[this.getID(bangid)].pbg + this.dt, 0.001)
            //&& n.x > 10
            && equaln(n.x, this.xbang[this.getID(bangid)].x, 0.001) && n.ishb == false);
        if (a == undefined) { return; } return a.bangid;
    };


    //查找上边且X位置一样的板，， 返加YH_bang[].bangid  hbcd为大于共边的长度
    F_Top_Big = (bangid: number, gbcd: number): number =>
    {
        let tempjh: YH_bang[] = [];
        for (let i = 0; i < this.xbang.length; i++)
        {
            if (this.xbang[i].y > this.xbang[this.getID(bangid)].y + this.xbang[this.getID(bangid)].pbg
                && this.xbang[i].x + this.xbang[i].pbk <= this.xbang[this.getID(bangid)].x + this.xbang[this.getID(bangid)].pbk + 0.1
                && this.XJcd(this.xbang[i].bangid, this.xbang[this.getID(bangid)].bangid)[0] > gbcd)
            {
                tempjh.push(this.xbang[i]);
            }
        }
        if (tempjh.length > 0)
        {
            tempjh.sort((a, b) => a.x - b.x);
            return tempjh[0].bangid;
        }
        else
        {
            return -1;
        }
    };


    //查找下边且X位置一样的板，， 返加YH_bang[].bangid
    F_Down_Big = (bangid: number, gbcd: number): number =>
    {
        let tempjh: YH_bang[] = [];
        for (let i = 0; i < this.xbang.length; i++)
        {
            for (let i = 0; i < this.xbang.length; i++)
            {
                if (this.xbang[i].y + this.xbang[i].pbg < this.xbang[this.getID(bangid)].y
                    && this.xbang[i].x >= this.xbang[this.getID(bangid)].x && this.xbang[i].pbg > 300
                    && this.XJcd(this.xbang[i].bangid, this.xbang[this.getID(bangid)].bangid)[0] > gbcd)
                {
                    tempjh.push(this.xbang[i]);
                }
            }
        }
        if (tempjh.length > 0)
        {
            tempjh.sort((a, b) => a.x - b.x);
            return tempjh[0].bangid;
        }
        else
        {
            return -1;
        }
    };


    //合并同高相邻的板  isbig: true 为第一回合并的大板  wz为方位  L 左 R右 T上 D下   返回是否有合并过 false 为没有合并过  true 有合并过
    HB_LR = (bangid: number, isbig: boolean): boolean =>
    {
        let isend: boolean = true;
        let tempbangid: number;
        let ishb: boolean = false;

        while (isend == true)
        {
            tempbangid = this.F_Left(bangid);
            if (tempbangid != undefined)
            {
                let temp = this.JC_is_bang(bangid, tempbangid);  //[f/t,1:x,2:y,3:k,4:g]
                if (temp[0] == false)
                {
                    this.addbang(bangid, tempbangid, temp[1], temp[2], temp[3], temp[4], isbig);
                    ishb = true;
                }
                else
                {
                    isend = false;
                }
            }
            else
            {
                isend = false;
            }
        }
        isend = true;
        while (isend == true)
        {
            tempbangid = this.F_Right(bangid);
            if (tempbangid != undefined)
            {
                let temp = this.JC_is_bang(bangid, tempbangid);  //[f/t,1:x,2:y,3:k,4:g]
                if (temp[0] == false)
                {
                    this.addbang(bangid, tempbangid, temp[1], temp[2], temp[3], temp[4], isbig);
                    ishb = true;
                }
                else
                {
                    isend = false;
                }
            }
            else
            {
                isend = false;
            }
        }
        return ishb;
    };

    //合并同宽相邻的板  isbig: true 为第一回合并的大板  wz为方位  L 左 R右 T上 D下 返回是否有合并过 false 为没有合并过  true 有合并过
    HB_TD = (bangid: number, isbig: boolean): boolean =>
    {
        let isend: boolean = true;
        let tempbangid: number;
        let ishb: boolean = false;
        while (isend == true)
        {
            tempbangid = this.F_Down(bangid);
            if (tempbangid != undefined)
            {
                let temp = this.JC_is_bang(bangid, tempbangid);  //[f/t,1:x,2:y,3:k,4:g]
                if (temp[0] == false)
                {
                    this.addbang(bangid, tempbangid, temp[1], temp[2], temp[3], temp[4], isbig);
                    ishb = true;
                }
                else
                {
                    isend = false;
                }

            }
            else
            {
                isend = false;
            }
        }
        isend = true;
        while (isend == true)
        {
            tempbangid = this.F_TOP(bangid);
            if (tempbangid != undefined)
            {
                let temp = this.JC_is_bang(bangid, tempbangid);  //[f/t,1:x,2:y,3:k,4:g]
                if (temp[0] == false)
                {
                    this.addbang(bangid, tempbangid, temp[1], temp[2], temp[3], temp[4], isbig);
                    ishb = true;
                }
                else
                {
                    isend = false;
                }
            }
            else
            {
                isend = false;
            }
        }
        return ishb;
    };

    addbang = (id1: number, id2: number, x: number, y: number, k: number, g: number, isbig: boolean) =>  //把合并的板写入，并改板的大小
    {
        let tempid1 = this.getID(id1);
        let tempid2 = this.getID(id2);
        if (this.xbang[tempid1].ishb == false)
        {
            this.HB_bang.push(id1);
        }
        this.HB_bang.push(id2);
        this.xbang[tempid1].x = x;
        this.xbang[tempid1].y = y;
        this.xbang[tempid1].pbk = k;
        this.xbang[tempid1].pbg = g;
        this.xbang[tempid1].ishb = true;
        this.xbang[tempid2].ishb = true;
        if (isbig == true) { this.xbang[tempid1].isbig = true; this.xbang[tempid2].isbig = true; }
    };

    //计算相邻两块板中有空位的地方是否有其它小板 返回 false 为没有其它板，true 有其它板  x,y,k,g
    JC_is_bang = (bangid1: number, bangid2: number): [boolean, number, number, number, number] =>
    {
        let tb: YH_bang[] = [];
        tb.push(this.xbang[this.getID(bangid1)]);
        tb.push(this.xbang[this.getID(bangid2)]);
        if (equaln(tb[0].y, tb[1].y, 0.01)) //左右相邻
        {
            tb.sort((a, b) => a.x - b.x);
            if (tb[0].pbg < tb[1].pbg)//左上空间 右边高
            {
                return [this.JCQY_is_bang(tb[0].x, tb[0].y + tb[0].pbg + this.dt, tb[0].pbk, tb[1].pbg - tb[0].pbg - this.dt),
                tb[0].x, tb[0].y, tb[0].pbk + tb[1].pbk + this.dt, tb[1].pbg];
            }
            else if (tb[0].pbg > tb[1].pbg)//右上空间 左边高
            {
                return [this.JCQY_is_bang(tb[1].x, tb[1].y + tb[1].pbg + this.dt, tb[1].pbk, tb[0].pbg - tb[1].pbg - this.dt),
                tb[0].x, tb[0].y, tb[0].pbk + tb[1].pbk + this.dt, tb[0].pbg];
            }
            else   //一样高
            {
                return [false, tb[0].x, tb[0].y, tb[0].pbk + tb[1].pbk + this.dt, tb[0].pbg];
            }
        }
        else   //上下空间
        {
            tb.sort((b, a) => a.y - b.y);
            if (tb[0].pbk < tb[1].pbk)//右上空间 上边短
            {
                return [this.JCQY_is_bang(tb[0].x + tb[0].pbk + this.dt, tb[0].y, tb[1].pbk - tb[0].pbk - this.dt, tb[0].pbg),
                tb[1].x, tb[1].y, tb[1].pbk, tb[0].pbg + tb[1].pbg + this.dt];
            }
            else if (tb[0].pbk > tb[1].pbk)//右下空间 下边短
            {
                return [this.JCQY_is_bang(tb[1].x + tb[1].pbk + this.dt, tb[1].y, tb[0].pbk - tb[1].pbk - this.dt, tb[1].pbg),
                tb[1].x, tb[1].y, tb[0].pbk, tb[0].pbg + tb[1].pbg + this.dt];
            }
            else   //一样高
            {
                return [false, tb[1].x, tb[1].y, tb[0].pbk, tb[0].pbg + tb[1].pbg + this.dt];
            }
        }
    };

    //检测两块板之间相交的长度且两块板之间没有其它板 ，返回长度，第一个为X相交长度  第二个为Y相交长度
    XJcd = (bangid1: number, bangid2: number): [number, number] =>
    {
        let tempbang: YH_bang[] = [];
        tempbang.push(this.xbang[this.getID(bangid1)]);
        tempbang.push(this.xbang[this.getID(bangid2)]);

        let tempx = this.Jcxj(tempbang[0].x, tempbang[0].pbk, tempbang[1].x, tempbang[1].pbk);
        let tempy = this.Jcxj(tempbang[0].y, tempbang[0].pbg, tempbang[1].y, tempbang[1].pbg);
        if (tempx > 0 && tempy > 0)
        {
            return [tempx, tempy];
        }
        else if (tempx > 0)
        {
            tempbang.sort((a, b) => a.x - b.x);
            if (tempbang[0].y > tempbang[1].y)
            {
                if (this.JCQY_is_bang(tempbang[1].x, tempbang[1].y + tempbang[1].pbg, tempx, tempbang[0].y - tempbang[1].y - tempbang[1].pbg) == false)
                {
                    return [tempx, 0];
                }
                else
                {
                    return [0, 0];
                }
            }
            else
            {
                if (this.JCQY_is_bang(tempbang[1].x, tempbang[0].y + tempbang[0].pbg, tempx, tempbang[1].y - tempbang[0].y - tempbang[0].pbg) == false)
                {
                    return [tempx, 0];
                }
                else
                {
                    return [0, 0];
                }
            }

        }
        else if (tempy > 0)
        {
            tempbang.sort((a, b) => a.x - b.x);
            if (tempbang[0].y > tempbang[1].y)
            {
                if (this.JCQY_is_bang(tempbang[0].x + tempbang[0].pbk, tempbang[0].y, tempbang[1].x - tempbang[0].x - tempbang[0].pbk, tempy) == false)
                {
                    return [0, tempy];
                }
                else
                {
                    return [0, 0];
                }
            }
            else
            {
                if (this.JCQY_is_bang(tempbang[0].x + tempbang[0].pbk, tempbang[1].y, tempbang[1].x - tempbang[0].x - tempbang[0].pbk, tempy) == false)
                {
                    return [0, tempy];
                }
                else
                {
                    return [0, 0];
                }
            }
        }
        else
        {
            return [0, 0];
        }
    };

    //检测指定区域内否有其它小板 返回 false 为没有其它板，true 有其它板
    JCQY_is_bang = (x: number, y: number, k: number, g: number): boolean =>
    {
        let result = this.xbang.findIndex((n) => (k + n.pbk - Math.abs(x - n.x) - Math.abs(x - n.x + k - n.pbk)) / 2 > 0.01 &&
            (g + n.pbg - Math.abs(y - n.y) - Math.abs(y - n.y + g - n.pbg)) / 2 > 0.01);
        if (result == -1) { return false; } else { return true; }
    };

    //计算两边相交长度/
    Jcxj = (wz1: number, l1: number, wz2: number, l2: number): number => { return (l1 + l2 - Math.abs(wz1 - wz2) - Math.abs(wz1 - wz2 + l1 - l2)) / 2; };

    Find_BS = (): number[] =>
    {
        let temp = this.Find_BS_gr();
        if (temp[0] > 2)
        {
            return this.Find_BS_wgr()[1];
        }
        else
        {
            if (temp[1][0] == 0)
            {
                return this.Find_BS_wgr()[1];
            }
            else
            {
                return temp[1];
            }


        }
    };
    //找到共边最少的板的集合  订算有关系的板
    Find_BS_gr = (): [number, number[]] =>
    {
        let bs: number = 6;
        let id: number[] = [];
        let tempsl: number[];
        if (this.xbang.length == 1)
        {
            return [0, [0]];
        }
        else
        {
            for (let i = 0; i < this.xbang.length; i++)
            {
                if (this.xbang[i].isgr == false && this.xbang[i].ishb == false && this.xbang[i].isqg == false)
                {
                    tempsl = this.JSgbsl(this.xbang[i].bangid);
                    if (bs == tempsl[0])
                    {
                        id.push(this.xbang[i].bangid);
                    }
                    else if (bs > tempsl[0])
                    {
                        bs = tempsl[0];
                        id = [];
                        id.push(this.xbang[i].bangid);
                    }

                }
            }
            if (id.length > 0)
            { return [bs, id]; }
            else
            {
                //console.log("没找到最少边");
                return [0, [0]];
            }

        }
    };

    //找到共边最少的板的集合  订算没有算关系的板
    Find_BS_wgr = (): [number, number[]] =>
    {
        let bs: number = 6;
        let id: number[] = [];
        let tempsl: number[];
        if (this.xbang.length == 1)
        {
            return [0, [0]];
        }
        else
        {
            for (let i = 0; i < this.xbang.length; i++)
            {
                if (this.xbang[i].ishb == false && this.xbang[i].isqg == false)
                {
                    tempsl = this.JSgbsl(this.xbang[i].bangid);
                    if (bs == tempsl[0])
                    {
                        id.push(this.xbang[i].bangid);
                    }
                    else if (bs > tempsl[0])
                    {
                        bs = tempsl[0];
                        id = [];
                        id.push(this.xbang[i].bangid);
                    }
                }
            }
            if (id.length > 0) { return [bs, id]; } else { return [0, [0]]; }

        }
    };


    //计算这块板的与其它板的相交的边数，及每条边数跟权重 0数量  1左 2右 3上 4下  5权重
    JSgbsl = (bangid: number): [number, number, number, number, number, number] =>
    {
        let left = 0, right = 0, top = 0, down = 0, qz = 0;
        let bangIndex = this.getID(bangid);
        for (let j = 0; j < this.xbang.length; j++)
        {
            if (bangIndex != j && this.xbang[j].isqg == false)
            {
                let jjy = this.Jcxj(this.xbang[bangIndex].y, this.xbang[bangIndex].pbg, this.xbang[j].y, this.xbang[j].pbg);
                let jjx = this.Jcxj(this.xbang[bangIndex].x, this.xbang[bangIndex].pbk, this.xbang[j].x, this.xbang[j].pbk);
                if (this.xbang[bangIndex].pbg > this.xbang[bangIndex].pbk)
                {
                    if (jjy < this.xbang[bangIndex].pbk && jjy < 50) { jjy = 0; }
                }
                if (this.xbang[bangIndex].pbk > this.xbang[bangIndex].pbg)
                {
                    if (jjx < this.xbang[bangIndex].pbg && jjx < 50) { jjx = 0; }
                }
                if (jjy > 0 && this.xbang[bangIndex].x > this.xbang[j].x + this.xbang[j].pbk) { left = 1; }
                if (jjy > 0 && this.xbang[j].x > this.xbang[bangIndex].x + this.xbang[bangIndex].pbk) { right = 1; }
                if (jjx > 0 && this.xbang[bangIndex].y > this.xbang[j].y + this.xbang[j].pbg) { down = 1; }
                if (jjx > 0 && this.xbang[j].y > this.xbang[bangIndex].y + this.xbang[bangIndex].pbg) { top = 1; }
                if ((left == 1 && right == 1) || (down == 1 && top == 1)) { qz = 1; }
            }
        }
        return [left + right + top + down + qz, left, right, top, down, qz];
    };
    Jcsb = (bangid1: number, bangid2: number): boolean =>  // 把bang1 要去掉， bang2 是否少边  返加True 有少边  False 没有少边
    {
        let xj = this.XJcd(bangid1, bangid2);
        let jjx = xj[0]; let jjy = xj[1];


        if (jjx > 0 && this.xbang[this.getID(bangid1)].pbg < this.xbang[this.getID(bangid2)].pbg)
        {
            return true;
        }
        else if (jjx > 0 && jjx > 0 && this.xbang[this.getID(bangid1)].pbk * this.xbang[this.getID(bangid1)].pbg < this.xbang[this.getID(bangid2)].pbk * this.xbang[this.getID(bangid2)].pbg)
        {
            return false;
        }
        else if (jjy > 0 && this.xbang[this.getID(bangid1)].pbg < this.xbang[this.getID(bangid2)].pbg)
        {
            return false;
        }
        else if (jjy > 0 && this.xbang[this.getID(bangid1)].pbg > this.xbang[this.getID(bangid2)].pbg)
        {
            return true;
        }
        // else if (jjy > 0 && this.xbang[this.getID(bangid2)].pbk > this.xbang[this.getID(bangid2)].pbg
        //     && this.xbang[this.getID(bangid2)].pbk * this.xbang[this.getID(bangid2)].pbg < this.xbang[this.getID(bangid1)].pbk * this.xbang[this.getID(bangid1)].pbg)
        // {
        //     return true;
        // }
        else
        {
            return false;
        }



        // if (bangid1 == 2 && bangid2 == 10)
        // {
        //     console.log(bangid1);
        // }
        // let bs1 = this.JSgbsl(bangid1)[0];
        // let bs2 = this.JSgbsl(bangid2)[0];
        // let sb2 = this.is_sb(bangid1, bangid2)[0];
        // let sb1 = this.is_sb(bangid2, bangid1)[0];

        // if (sb2 < bs1 && sb1 < bs2)
        // {
        //     return true;
        // }
        // else
        // {
        //     return false;
        // }

    };

    //检测所有会让其它板少条且最小的的板
    JS_sb_minmz = (): number =>
    {
        let Bangidzh = this.Find_BS();
        if (Bangidzh[0] != 0)
        {
            let tempbang: YH_bang[] = [];
            for (let m = 0; m < Bangidzh.length; m++)
            {
                tempbang.push(this.xbang[this.getID(Bangidzh[m])]);
            }
            if (tempbang.length > 0)
            {
                tempbang.sort((a, b) => a.pbg * a.pbk - b.pbg * b.pbk);
                return tempbang[0].bangid;
            }
            else if (tempbang.length == 1)
            {
                return tempbang[0].bangid;
            }
            else
            {
                return -1;
            }
        }
        else
        {
            return -1;
        }
    };
    //合并所有的板
    HB_b = () =>
    {
        let jshb_lr: boolean = true;
        let jshb_td: boolean = true;
        let jshb: boolean;
        for (let i = 0; i < this.xbang.length; i++)
        {
            if (this.xbang[i].ishb == false) { jshb = true; } else { jshb = false; }
            while (jshb == true)
            {
                if (this.xbang[i].pbg > this.xbang[i].pbk && this.xbang[i].pbk > 100) //左右
                {
                    jshb_lr = this.HB_LR(this.xbang[i].bangid, false);
                }
                else
                {
                    jshb_lr = false;
                }

                if ((this.xbang[i].pbg < this.xbang[i].pbk && this.xbang[i].pbg > 100)) //上下合并
                {
                    jshb_td = this.HB_TD(this.xbang[i].bangid, false);
                }
                else
                {
                    jshb_td = false;
                }
                if (jshb_lr == true || jshb_td == true)
                {
                    jshb = true;
                }
                else if (jshb_lr == false || jshb_td == false)
                {
                    if ((this.xbang[i].pbg > 100 && this.xbang[i].pbk > 100)) //上下合并
                    {
                        jshb_lr = this.HB_LR(this.xbang[i].bangid, false);
                        jshb_td = this.HB_TD(this.xbang[i].bangid, false);
                        if (jshb_lr == true || jshb_td == true) { jshb = true; } else { jshb = false; }
                    }
                    else
                    {
                        jshb = false;
                    }
                }
                else
                {
                    jshb = true;
                }
            }
            if (this.HB_bang.length > 0)
            {
                this.HB.push(this.HB_bang);
                this.HB_bang = [];
            }
        }
    };

    //合并指定的板 第一步
    HB_Max_bang = (Bangid: number) =>
    {
        if (Bangid > 0)
        {
            let jshb_lr: boolean = true;
            let jshb_td: boolean = true;
            let jshb: boolean;
            let bangid = this.getID(Bangid);
            if (this.xbang[bangid].ishb == false) { jshb = true; } else { jshb = false; }
            while (jshb == true)
            {
                if (this.xbang[bangid].pbg > this.xbang[bangid].pbk && this.xbang[bangid].pbk > 100) //左右
                {
                    jshb_lr = this.HB_LR(this.xbang[bangid].bangid, false);
                }
                else
                {
                    jshb_lr = false;
                }

                if ((this.xbang[bangid].pbg < this.xbang[bangid].pbk && this.xbang[bangid].pbg > 100)) //上下合并
                {
                    jshb_td = this.HB_TD(this.xbang[bangid].bangid, false);
                }
                else
                {
                    jshb_td = false;
                }
                if (jshb_lr == true || jshb_td == true)
                {
                    jshb = true;
                }
                else if (jshb_lr == false || jshb_td == false)
                {
                    if ((this.xbang[bangid].pbg > 100 && this.xbang[bangid].pbk > 100)) //上下合并
                    {
                        jshb_lr = this.HB_LR(this.xbang[bangid].bangid, false);
                        jshb_td = this.HB_TD(this.xbang[bangid].bangid, false);
                        if (jshb_lr == true || jshb_td == true) { jshb = true; } else { jshb = false; }
                    }
                    else
                    {
                        jshb = false;
                    }
                }
                else
                {
                    jshb = true;
                }
            }
            if (this.HB_bang.length > 0)
            {
                this.HB.push(this.HB_bang);
                this.HB_bang = [];
            }
            else
            {
                this.HB.push([Bangid]);
                this.xbang[bangid].ishb = true;
            }
        }
    };


    //合并上面的大板  cd为共边长度
    HB_top = (bangid: number, cd: number) =>
    {
        let hbbang: number[] = [];
        let fid: number = bangid;
        while (fid > -1)
        {
            fid = this.F_Top_Big(fid, cd);
            if (fid > -1)
            {
                this.xbang[this.getID(fid)].ishb = true;
                hbbang.push(fid);
                //this.printstr(fid, 1, "大合", -30, 80, 50);
            }
        }
        if (hbbang.length > 0) { this.HB.push(hbbang); }
    };
    //合并下面的大板  cd为共边长度
    HB_down = (bangid: number, cd: number) =>
    {
        let hbbang: number[] = [];
        let fid: number = bangid;
        while (fid > -1)
        {
            fid = this.F_Down_Big(fid, cd);
            if (fid > -1)
            {
                this.xbang[this.getID(fid)].ishb = true;
                hbbang.push(fid);
                // this.printstr(fid, 1, "大合", 10, 80, 50);
            }
        }
        if (hbbang.length > 0) { this.HB.push(hbbang); }
    };

    //寻找最后一块要切割的板
    F_last_mz = (jlID: number): number =>
    {
        let bangid: number;
        let temp: number[];
        let index: number = 1;
        let lastId: number;
        if (jlID == 0) { lastId = this.F_minMZ(); } else { lastId = jlID; }
        while (true)
        {
            if (lastId == -1) { break; }
            bangid = this.JS_sb_Bxl(lastId);  //检测所有会让其它板少条且有两块或者多块边相邻的板
            if (bangid > -1)
            { this.add_last(bangid, index); index++; lastId = bangid; }
            else
            {
                bangid = this.JS_sb_minmz(); //检测所有会让其它板少条且最小的的板
                if (bangid > -1)
                { this.add_last(bangid, index); index++; lastId = bangid; }
                else
                {
                    if (lastId == -1) { break; }
                    bangid = this.F_minJL(lastId);
                    if (bangid > -1) { this.add_last(bangid, index); index++; lastId = bangid; }
                    else
                    {
                        bangid = this.F_minMZ();  //找到面积最小的板
                        this.add_last(bangid, index);
                        index++;
                        lastId = bangid;
                    }
                }
            }
            // bangid = this.F_minJL(bangid);
            //if (bangid > -1) { this.add_last(bangid, index); index++; }

            temp = this.Find_BS();

            if (temp[0] == 0)
            {
                break;
            }
        }
        return index;

    };


    //寻找最后一块要切割的板
    F_last_jl = (jlID: number): number =>
    {
        let bangid: number;
        let temp: number[];
        let index: number = 1;
        let lastId: number;
        if (jlID == 0) { lastId = this.F_minMZ(); } else { lastId = jlID; }
        let tempend: boolean = false;
        while (true)
        {
            if (lastId == -1) { break; }
            bangid = this.JS_sb_Bxl(lastId);  //检测所有会让其它板少条且有两块或者多块边相邻的板
            if (bangid > -1)
            { this.add_last(bangid, index); index++; lastId = bangid; }
            else
            {
                if (lastId == -1) { break; }
                bangid = this.F_minJL(lastId);
                if (bangid > -1)
                { this.add_last(bangid, index); index++; lastId = bangid; }
                else
                {
                    //bangid = this.F_minMZ();  //找到面积最小的板
                    // if (lastId == -1) { break; }
                    // bangid = this.F_minJL(lastId);
                    bangid = this.JS_sb_minmz(); //检测所有会让其它板少条且最小的的板

                    if (bangid > -1) { this.add_last(bangid, index); index++; lastId = bangid; }
                    else
                    {
                        bangid = this.F_minMZ();  //找到面积最小的板
                        this.add_last(bangid, index);
                        index++;
                        lastId = bangid;
                    }
                }
            }
            // bangid = this.F_minJL(bangid);
            //if (bangid > -1) { this.add_last(bangid, index); index++; }

            temp = this.Find_BS();

            if (temp[0] == 0)
            {
                break;
            }

        }
        return index;

    };

    //打印并添加最后一块
    add_last = (bangid: number, index: number) =>
    {
        let tempx: number;
        //if (index > 9) { tempx = 27; } else { tempx = 10; } 这两行用于测试打印
        //this.printstr(bangid, 1, index.toString(), this.xbang[this.getID(bangid)].pbk / 2 - tempx, this.xbang[this.getID(bangid)].pbg / 2 - 20, 50);
        this.SCid.push(bangid);
        this.xbang[this.getID(bangid)].isqg = true;
        let tempid = this.xbang[this.getID(bangid)].grid;
        if (this.xbang[this.getID(bangid)].grid > -1)
        {
            let tempin = this.xbang[this.getID(tempid)].gr.findIndex((n) => n == bangid);
            if (tempin > -1)
            {
                this.xbang[this.getID(tempid)].gr.splice(tempin, 1);
                if (this.xbang[this.getID(tempid)].gr.length == 0) { this.xbang[this.getID(tempid)].isgr = false; }
            }
        }
    };

    //找到面积最小的板
    F_minMZ = (): number =>
    {
        let jhb = this.Find_BS();
        if (jhb[0] != 0)
        {
            let tempBang: YH_bang[] = [];
            if (jhb.length == 1)
            {
                return jhb[0];
            }
            else
            {
                for (let i = 0; i < jhb.length; i++)
                {
                    tempBang.push(this.xbang[this.getID(jhb[i])]);
                }
                tempBang = tempBang.sort((a, b) =>
                {
                    if (a.pbg * a.pbk == b.pbg * b.pbk)
                    {
                        return Math.hypot(this.B_k - a.x - a.pbk / 2, this.B_g - a.y - a.pbg / 2) - Math.hypot(this.B_k - b.x - b.pbk / 2, this.B_g - b.y - b.pbg / 2);
                    }
                    else
                    {
                        return a.pbg * a.pbk - b.pbg * b.pbk ? -1 : 1;
                    }
                });

                return tempBang[0].bangid;
            }
        }
        else
        {
            return -1;
        }
    };

    //按位置最近排序
    F_minJL = (bangid: number): number =>
    {
        let jhb = this.Find_BS();
        if (jhb.length[0] != 0)
        {
            let tempBang: YH_bang[] = [];
            if (jhb.length > 0)
            {
                for (let i = 0; i < jhb.length; i++)
                {
                    tempBang.push(this.xbang[this.getID(jhb[i])]);
                }
                let wzx = this.xbang[this.getID(bangid)].x + this.xbang[this.getID(bangid)].pbk / 2;
                let wzy = this.xbang[this.getID(bangid)].y + this.xbang[this.getID(bangid)].pbg / 2;
                tempBang.sort((a, b) => a.pbk * a.pbg - b.pbk * b.pbg);
                if (tempBang[tempBang.length - 1].pbg * tempBang[tempBang.length - 1].pbk / 1000000 - tempBang[0].pbg * tempBang[0].pbk / 1000000 > 0.2)
                {
                    return tempBang[0].bangid;
                }
                else
                {
                    tempBang.sort((a, b) => Math.hypot(wzx - a.x - a.pbk / 2, wzy - a.y - a.pbg / 2) - Math.hypot(wzx - b.x - b.pbk / 2, wzy - b.y - b.pbg / 2));
                    return tempBang[0].bangid;
                }
            }
            else if (jhb.length == 1)
            {
                return jhb[0];
            }
            else
            {
                return -1;
            }
        }
        else
        {
            return -1;
        }
    };
    //检测所有会让其它板少条且有两块或者多块边相邻的板
    JS_sb_Bxl = (bangid: number): number =>
    {
        let Bangidzh = this.Find_BS();
        if (Bangidzh[0] != 0)
        {
            let tempbang: YH_bang[] = [];
            let tempxj: YH_bang[] = [];
            let temp: YH_bang;
            for (let m = 0; m < Bangidzh.length; m++)
            {
                for (let n = 0; n < Bangidzh.length; n++)
                {
                    if (m != n)
                    {
                        if (this.Jcsb(Bangidzh[m], Bangidzh[n]) == true)
                        {
                            tempbang.push(this.xbang[this.getID(Bangidzh[m])]);
                        }
                    }
                }
            }
            if (tempbang.length == 1)
            {
                return tempbang[0].bangid;
            }
            else if (tempbang.length == 0)
            {
                return -1;
            }
            else //(tempbang.length > 1);
            {
                let wzx = this.xbang[this.getID(bangid)].x + this.xbang[this.getID(bangid)].pbk / 2;
                let wzy = this.xbang[this.getID(bangid)].y + this.xbang[this.getID(bangid)].pbg / 2;
                tempbang.sort((a, b) => Math.hypot(wzx - a.x - a.pbk / 2, wzy - a.y - a.pbg / 2) - Math.hypot(wzx - b.x - b.pbk / 2, wzy - b.y - b.pbg / 2));
                return tempbang[0].bangid;

            }
        }
        else
        {
            return -1;
        }

    };

    //用于计算下刀顺序
    XDscjs = () =>
    {
        let bangid = this.MaxMZ(0.05);
        this.HB_Max_bang(bangid);
        this.HB_top(bangid, 200);
        this.HB_down(bangid, 200);
        this.F_GL_LR();
        this.F_GL_TD();
        this.Is_big_gr();
        this.F_GL_JJB();

        let index: number;

        if (this.jl_mz == 1)
        {
            index = this.F_last_jl(0);
        } else
        {
            index = this.F_last_mz(0);
        }
        this.printHBCS(index);


    };
    printHBCS = (index: number) =>
    {
        for (let m = this.HB.length - 1; m >= 0; m--)
        {
            for (let n = this.HB[m].length - 1; n >= 0; n--)
            {
                //this.printstr(this.HB[m][n], 1, index.toString(), this.Bakbang[this.getID_Bkb(this.HB[m][n])].pbk / 2, this.Bakbang[this.getID_Bkb(this.HB[m][n])].pbg / 2, 50);
                this.SCid.push(this.HB[m][n]);
                index++;
            };
        }
    };
};

function equaln(v1: number, v2: number, fuzz = 1e-5)
{
    return Math.abs(v1 - v2) <= fuzz;
}