1747 lines
51 KiB
TypeScript
1747 lines
51 KiB
TypeScript
import type { Big_bang, Con, Inv, xbang } from './bang'
|
||
import { LineType } from './bang'
|
||
|
||
export class RectOptimizeMachine {
|
||
private _Stop = false
|
||
|
||
public CallBack: (best: Inv, yl: Big_bang[], fit: number, info: any) => void | Promise<void>
|
||
|
||
Stop(d?:any) {
|
||
console.log('优化 stop=》RectOptimizeMachine',d)
|
||
this._Stop = true
|
||
}
|
||
|
||
/**
|
||
* @param xbangs 小板
|
||
* @param bigBang 大板(N个元素，前N-1个元素表示余料板且余料板须为矩形，第N个元素表示大板)
|
||
* @param bigBangSL 余料板数量(bigBang中前N-1个元素对应的数量，如果bigBang中只有一个元素即只有大板没有余料板，则为空数组)
|
||
* @param xyhcs 新优化次数
|
||
* @param isdtwosided 双面加工的小板是否优先排入
|
||
* @param gap 排版缝隙 = 开料刀直径 + 缝隙
|
||
* @param hssf 规则排版
|
||
* @param YuLiaoBoardDo2FaceBlock 余料板是否排入双面加工的小板
|
||
*/
|
||
async Start(xbangs: xbang[], bigBang: Big_bang[], bigBangSL: number[], xyhcs: number, isdtwosided: boolean, gap: number, hssf: boolean, YuLiaoBoardDo2FaceBlock: boolean) {
|
||
this._Stop = false
|
||
|
||
// let bestFit = Infinity; //最佳的利用率 35*10 + 最后一张板
|
||
let bestFit = Number.POSITIVE_INFINITY // 最佳的利用率 35*10 + 最后一张板
|
||
let bestInv: Inv
|
||
|
||
let i = 0
|
||
let inv; let re_ylb; let fit: any = null
|
||
|
||
while (!this._Stop) {
|
||
|
||
const qfsh = hssf ? false : i % 2 === 0 // 电子锯算法, 永远不合并空间
|
||
|
||
let tempArr = SnameYH(xbangs.slice(), bigBang, bigBangSL, xyhcs, qfsh, isdtwosided, gap, YuLiaoBoardDo2FaceBlock)
|
||
|
||
inv = tempArr[0]
|
||
re_ylb = tempArr[1]
|
||
if (xbangs.length > 1000) {
|
||
// debugger
|
||
}
|
||
fit = GetInvFit(inv)
|
||
let info = {
|
||
times: i,
|
||
type: 'loop'
|
||
}
|
||
if (fit < bestFit) {
|
||
bestFit = fit
|
||
bestInv = inv
|
||
this.CallBack(inv, re_ylb, fit, info)
|
||
}
|
||
/** 优化次数限制 逻辑 */
|
||
// if (xyhcs == i) {
|
||
// await this.Stop(info);
|
||
// info.type = 'stop'
|
||
// this.CallBack(inv, re_ylb, fit, info)
|
||
// }
|
||
await Sleep(Math.max(5, 20 - Math.floor(xbangs.length / 10000)))
|
||
i++
|
||
}
|
||
}
|
||
}
|
||
|
||
// 优化所有余料
|
||
function YLYH_all(xbangs: xbang[], yuliao_bang: Big_bang[], ylzs: number[], xyhcs: number, qfsh: boolean, isdtwosided: boolean, gap: number, YuLiaoBoardDo2FaceBlock: boolean): [Inv, xbang[], Big_bang[]] // 余料优化
|
||
{
|
||
let get_regelt: Inv = []
|
||
let temp_yan_bang: Big_bang[] = []
|
||
let re_Bigbang: Big_bang[] = []
|
||
temp_yan_bang = []
|
||
// console.log('余料总数:', ylzs)
|
||
for (let i = 0; i < ylzs.length; i++) {
|
||
if (xbangs.length == 0) {
|
||
break
|
||
}
|
||
else {
|
||
temp_yan_bang = []
|
||
for (let sl = 0; sl < ylzs[i]; sl++) {
|
||
temp_yan_bang.push(yuliao_bang[i])
|
||
}
|
||
let temp:any = []
|
||
temp = ylyh(xbangs, temp_yan_bang, xyhcs, qfsh, isdtwosided, gap, YuLiaoBoardDo2FaceBlock)
|
||
for (let yhsl = 0; yhsl < temp[0].length; yhsl++) {
|
||
get_regelt.push(temp[0][yhsl])
|
||
}
|
||
for (let ylsl = 0; ylsl < temp[2].length; ylsl++) {
|
||
re_Bigbang.push(temp[2][ylsl])
|
||
}
|
||
xbangs = temp[1].slice()
|
||
// re_Bigbang.push(temp[2].slice());
|
||
}
|
||
}
|
||
return [get_regelt, xbangs, re_Bigbang]
|
||
}
|
||
|
||
// 优化余料中的一个尺寸的小板
|
||
function ylyh(xbangs: xbang[], yuliao_bang: Big_bang[], xyhcs: number, qfsh: boolean, isdtwosided: boolean, gap: number, YuLiaoBoardDo2FaceBlock: boolean): [Inv, xbang[], Big_bang[]] // 余料优化
|
||
{
|
||
let finbang: xbang[]
|
||
let yh_result: Inv = []
|
||
let l: number
|
||
let w: number
|
||
let ylzs: number// 余料张数
|
||
let temp_yan_bang: Big_bang[] = []
|
||
let re_yan_bang: Big_bang[] = []
|
||
let temp_max_YH: Inv = []
|
||
temp_yan_bang = []
|
||
temp_yan_bang.push(yuliao_bang[0])
|
||
l = yuliao_bang[0].l
|
||
w = yuliao_bang[0].w
|
||
|
||
if (YuLiaoBoardDo2FaceBlock) // 余料板允许加入双面小板
|
||
{
|
||
finbang = find_bang_k_g(l, w, xbangs, false).slice()
|
||
}
|
||
else {
|
||
finbang = find_bang_k_g(l, w, xbangs, true).slice()
|
||
}
|
||
|
||
if (finbang.length > 0) {
|
||
if (YuLiaoBoardDo2FaceBlock) // 余料板允许加入双面小板
|
||
{
|
||
temp_max_YH = YHJS(finbang, temp_yan_bang, xyhcs, qfsh, isdtwosided, gap) // 余料板 不优先 双面加工板
|
||
}
|
||
else {
|
||
temp_max_YH = YHJS(finbang, temp_yan_bang, xyhcs, qfsh, false, gap)
|
||
}
|
||
|
||
if (yuliao_bang.length > temp_max_YH.length) {
|
||
ylzs = temp_max_YH.length
|
||
}
|
||
else {
|
||
ylzs = yuliao_bang.length
|
||
}
|
||
for (let i = 0; i < ylzs; i++) {
|
||
yh_result.push(temp_max_YH[i])
|
||
re_yan_bang.push(yuliao_bang[0])
|
||
for (let n = 0; n < temp_max_YH[i].length; n++) {
|
||
for (let bsl = xbangs.length - 1; bsl >= 0; bsl--)
|
||
if (temp_max_YH[i][n].bangid == xbangs[bsl].id) {
|
||
xbangs.splice(bsl, 1)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return [yh_result, xbangs, re_yan_bang]
|
||
}
|
||
// 相同板材优化
|
||
function SnameYH(xbangs: xbang[], B_bang: Big_bang[], ylsl: number[], xyhcs: number, qfsh: boolean, isdtwosided: boolean, gap: number, YuLiaoBoardDo2FaceBlock: boolean): [Inv, Big_bang[]] {
|
||
let same_yh_bang: Inv = []
|
||
let temp_max_YH: Inv = []
|
||
let ylbang_max_yh: Big_bang[] = []
|
||
let temp_same_yh: [Inv, xbang[]]
|
||
let isend: boolean = false
|
||
let Bigbang: Big_bang[] = []
|
||
Bigbang.push(B_bang[B_bang.length - 1])
|
||
|
||
let ylbang: Big_bang[] = B_bang.slice()
|
||
ylbang.pop()
|
||
|
||
let tempresult = []
|
||
|
||
tempresult = YLYH_all(xbangs, ylbang, ylsl, xyhcs, qfsh, isdtwosided, gap, YuLiaoBoardDo2FaceBlock) // 余料优化
|
||
|
||
for (let i = 0; i < tempresult[0].length; i++) {
|
||
same_yh_bang.push(tempresult[0][i])
|
||
}
|
||
xbangs = tempresult[1].slice()
|
||
ylbang_max_yh = tempresult[2].slice()
|
||
|
||
while (isend === false) {
|
||
if (xbangs.length == 0) { break }
|
||
temp_max_YH = YHJS(xbangs, Bigbang, xyhcs, qfsh, isdtwosided, gap)
|
||
temp_same_yh = Get_bs_bang(temp_max_YH, xbangs, isdtwosided)
|
||
for (let i = 0; i < temp_same_yh[0].length; i++) {
|
||
same_yh_bang.push(temp_same_yh[0][i])
|
||
xbangs = temp_same_yh[1].slice()
|
||
}
|
||
}
|
||
|
||
return [same_yh_bang, ylbang_max_yh]
|
||
}
|
||
|
||
// 优化计算.
|
||
function YHJS(xbangs: xbang[], B_bang: Big_bang[], cs: number, qfsh: boolean, isdtwosided: boolean, gap: number): Inv {
|
||
let xbangs_bak = xbangs.slice()
|
||
let bestFit = Number.POSITIVE_INFINITY
|
||
// let bestFit = Infinity;
|
||
let bestInv: Inv
|
||
for (let i = 0; i < cs; i++) {
|
||
xbangs = xbangs_bak.slice()
|
||
|
||
let result_yh: Inv
|
||
if (qfsh)
|
||
result_yh = CBJS(xbangs, B_bang, gap, isdtwosided)
|
||
else
|
||
result_yh = CBJS1(xbangs, B_bang, gap, isdtwosided)
|
||
|
||
let fit = GetInvFit(result_yh)
|
||
if (fit < bestFit) {
|
||
bestFit = fit
|
||
bestInv = result_yh
|
||
}
|
||
}
|
||
return bestInv
|
||
}
|
||
|
||
// 得到利用率最高板材，及返回倍数板及剩下的小板
|
||
function Get_bs_bang(inv: Inv, listbang: xbang[], isdtwosided: boolean): [Inv, xbang[]] {
|
||
let [bestCon] = arrayMax(inv, GetConFit)// 最优大板
|
||
|
||
let temp_yh_bang: Con = []
|
||
let temp_list_yh_bang: Inv = []
|
||
let isfindend: boolean = false
|
||
|
||
while (isfindend == false) {
|
||
if (listbang.length == 0) { break }
|
||
|
||
let unPlacelist = listbang.slice()
|
||
for (let br of bestCon) {
|
||
let temp_result = find_same_bang(br.pbg, br.pbk, unPlacelist, isdtwosided)
|
||
if (temp_result.findid > -1) // 找到合适的板
|
||
{
|
||
temp_yh_bang.push(
|
||
{
|
||
bangid: temp_result.id,
|
||
line: temp_result.line,
|
||
x: br.x,
|
||
y: br.y,
|
||
pbg: temp_result.pbg,
|
||
pbk: temp_result.pbk,
|
||
},
|
||
)
|
||
unPlacelist.splice(temp_result.findid, 1)// 这里不会错误的原因是 必然会有一次成功 并且下面会备份这个数组
|
||
}
|
||
else // 没找到 合适的板 退出
|
||
{
|
||
isfindend = true
|
||
break
|
||
}
|
||
}
|
||
if (isfindend == false) // 找到合适的
|
||
{
|
||
temp_list_yh_bang.push(temp_yh_bang)
|
||
temp_yh_bang = []
|
||
listbang = unPlacelist.slice()// 备份数组
|
||
}
|
||
}
|
||
return [temp_list_yh_bang, listbang]
|
||
}
|
||
|
||
function GetInvFit(inv: Inv) {
|
||
let fit = (inv.length - 1) * 10
|
||
fit += GetConFit(arrayLast(inv))
|
||
return fit
|
||
}
|
||
|
||
function GetConFit(con: Con) {
|
||
let fit = 0
|
||
for (let p of con)
|
||
fit += p.pbg * p.pbk * 1e-6
|
||
return fit
|
||
}
|
||
|
||
// 初步优化计算 横竖算法，无空间合并
|
||
function CBJS1(Listbang: xbang[], yanbang: Big_bang[], dt: number, isdtwosided: boolean): Inv // [(YHB_LST)[], (Big_bang[])[], (Big_bang[])[]]
|
||
{
|
||
let yanbang_bk: Big_bang[] = yanbang.slice()
|
||
// let zfkj: Big_bang[] = [];
|
||
// let list_zfkj: (Big_bang[])[] = [];
|
||
let list_yh_bng: Inv = []
|
||
// let list_yang_bang: (Big_bang[])[] = [];
|
||
let result_yh: Con = []
|
||
|
||
while (Listbang.length > 0) {
|
||
// zfkj = [];
|
||
yanbang = yanbang_bk.slice()
|
||
result_yh = []
|
||
while (yanbang.length > 0) {
|
||
let lx: number = Math.floor(Math.random() * 3) // lx:0 面积最大 1 最高 2 最宽
|
||
let fs: boolean // fs:留板方式，0:左右 1：上下
|
||
if (Math.floor(Math.random() * 2) == 0) { fs = false } else { fs = true }
|
||
let get_result = []
|
||
get_result = jsyb(yanbang[0], lx, fs, dt, Listbang, isdtwosided) // lx:0面积最大 1最高 2最宽 fs:取板方式，false:左右(取同宽) true：上下(取同高) dt:刀头间隙
|
||
yanbang.shift()
|
||
if (get_result[0] > 0) {
|
||
for (let i = 0; i < get_result[0]; i++)
|
||
yanbang.push(get_result[2][i])
|
||
}
|
||
if (get_result[1] > 0) {
|
||
for (let i = 0; i < get_result[1]; i++)
|
||
result_yh.push(get_result[3][i])
|
||
}
|
||
Listbang = get_result[4].slice()
|
||
if (Listbang.length == 0) { break }
|
||
}
|
||
// list_zfkj.push(zfkj);
|
||
list_yh_bng.push(result_yh)
|
||
// list_yang_bang.push(yanbang);
|
||
// list_zfkj.push(zfkj);
|
||
// Draw_Yan_bang(yanbang, 3, 0);
|
||
// Draw_Yan_bang(zfkj, 5, 0);
|
||
}
|
||
|
||
// return [list_yh_bng, list_zfkj, list_yang_bang];
|
||
return list_yh_bng
|
||
}
|
||
|
||
// 初步优化计算 交叉算法，有空间合并
|
||
function CBJS(Listbang: xbang[], yanbang: Big_bang[], dt: number, isdtwosided: boolean): Inv // [(YHB_LST)[], (Big_bang[])[], (Big_bang[])[]]
|
||
{
|
||
let yanbang_bk: Big_bang[] = yanbang.slice()
|
||
// let zfkj: Big_bang[] = [];
|
||
// let list_zfkj: (Big_bang[])[] = [];
|
||
let list_yh_bng: Inv = []
|
||
// let list_yang_bang: (Big_bang[])[] = [];
|
||
let result_yh: Con = []
|
||
|
||
// let temp: number = 0;
|
||
while (Listbang.length > 0)// while (temp < 2)//
|
||
{
|
||
// temp++;
|
||
// zfkj = [];
|
||
yanbang = yanbang_bk.slice()
|
||
result_yh = []
|
||
while (yanbang.length > 0) {
|
||
let lx: number = Math.floor(Math.random() * 3) // lx:0 面积最大 1 最高 2 最宽
|
||
let fs: boolean // fs:留板方式，0:左右 1：上下
|
||
if (Math.floor(Math.random() * 2) == 0) { fs = false } else { fs = true }
|
||
let get_result = []
|
||
let temp_yanbang = []
|
||
temp_yanbang = HBKJ(yanbang, Listbang, dt)
|
||
yanbang = temp_yanbang[0]
|
||
get_result = jsyb1(yanbang[temp_yanbang[1]], lx, fs, dt, Listbang, isdtwosided) // lx:0面积最大 1最高 2最宽 fs:取板方式，false:取同宽) true：取同高) dt:刀头间隙
|
||
yanbang.splice(temp_yanbang[1], 1)
|
||
if (get_result[0] > 0) {
|
||
for (let i = 0; i < get_result[0]; i++)
|
||
yanbang.push(get_result[2][i])
|
||
}
|
||
if (get_result[1] > 0) {
|
||
for (let i = 0; i < get_result[1]; i++)
|
||
result_yh.push(get_result[3][i])
|
||
}
|
||
Listbang = get_result[4].slice()
|
||
if (Listbang.length == 0) { break }
|
||
}
|
||
// list_zfkj.push(zfkj);
|
||
list_yh_bng.push(result_yh)
|
||
// list_yang_bang.push(yanbang);
|
||
// list_zfkj.push(zfkj);
|
||
// Draw_Yan_bang(yanbang, 3, 0);
|
||
// Draw_Yan_bang(zfkj, 5, 0);
|
||
}
|
||
|
||
// return [list_yh_bng, list_zfkj, list_yang_bang];
|
||
return list_yh_bng
|
||
}
|
||
|
||
// 空间合并(相加)
|
||
function hb(yanbang: Big_bang[], dt: number): Big_bang[] {
|
||
let i: number = -1
|
||
yanbang.sort((a1, a2) => a1.x - a2.x)
|
||
while (true) {
|
||
i++
|
||
|
||
if (yanbang.length < 2 || i === yanbang.length - 1)
|
||
break
|
||
|
||
if (yanbang[i].y === yanbang[i + 1].y
|
||
&& yanbang[i].x + yanbang[i].w + dt === yanbang[i + 1].x
|
||
&& yanbang[i].l === yanbang[i + 1].l) {
|
||
yanbang[i].w = yanbang[i].w + yanbang[i + 1].w + dt
|
||
yanbang.splice(i + 1, 1)
|
||
i = -1
|
||
}
|
||
}
|
||
return yanbang
|
||
}
|
||
|
||
// 整理空间
|
||
function zlkj(yanbang: Big_bang[], listbang: xbang[], dt: number): [Big_bang[], boolean] // false 继续合并 ture 不在合并
|
||
{
|
||
let k: number
|
||
let g: number
|
||
let isjshb: boolean = true// false 继续合并 ture 不在合并
|
||
let minY: number = 100000
|
||
let yanindex: number
|
||
if (listbang.length == 0)
|
||
return [yanbang, true]
|
||
|
||
for (let i = 0; i < yanbang.length; i++) {
|
||
if (yanbang[i].y < minY) {
|
||
minY = yanbang[i].y
|
||
yanindex = i
|
||
}
|
||
}
|
||
k = yanbang[yanindex].w
|
||
g = yanbang[yanindex].l
|
||
if (yanindex == 0 && yanbang.length > 1) {
|
||
if (yanbang[yanindex].x + yanbang[yanindex].w + dt == yanbang[yanindex + 1].x)// && yanbang[i].y + yanbang[i].l == yanbang[i + 1].y + yanbang[i + 1].l)
|
||
{
|
||
if (find_max_mz(g, k, listbang, false).findid == -1) {
|
||
yanbang[yanindex].y = yanbang[yanindex + 1].y
|
||
yanbang[yanindex].l = yanbang[yanindex + 1].l
|
||
isjshb = false
|
||
}
|
||
}
|
||
}
|
||
else if (yanindex == yanbang.length - 1 && yanbang.length > 1) {
|
||
if (yanbang[yanindex - 1].x + yanbang[yanindex - 1].w + dt == yanbang[yanindex].x && yanbang.length > 1)// && yanbang[i].y + yanbang[i].l == yanbang[i - 1].y + yanbang[i - 1].l && (yanbang[i - 1].x + yanbang[i - 1].w + dt == yanbang[i].x))
|
||
{
|
||
if (find_max_mz(g, k, listbang, false).findid == -1) {
|
||
yanbang[yanindex].y = yanbang[yanindex - 1].y
|
||
yanbang[yanindex].l = yanbang[yanindex - 1].l
|
||
isjshb = false
|
||
}
|
||
}
|
||
}
|
||
else if (yanbang.length > 1) {
|
||
if (yanbang[yanindex - 1].y > yanbang[yanindex + 1].y) {
|
||
if (yanbang[yanindex].x + yanbang[yanindex].w + dt == yanbang[yanindex + 1].x)// && yanbang[i].y + yanbang[i].l == yanbang[i + 1].y + yanbang[i + 1].l)
|
||
{
|
||
if (find_max_mz(g, k, listbang, false).findid == -1) {
|
||
yanbang[yanindex].y = yanbang[yanindex + 1].y
|
||
yanbang[yanindex].l = yanbang[yanindex + 1].l
|
||
isjshb = false
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
if (yanbang[yanindex - 1].x + yanbang[yanindex - 1].w + dt == yanbang[yanindex].x)// && yanbang.length > 1 && yanbang[i].y + yanbang[i].l == yanbang[i - 1].y + yanbang[i - 1].l && (yanbang[i - 1].x + yanbang[i - 1].w + dt == yanbang[i].x))
|
||
{
|
||
if (find_max_mz(g, k, listbang, false).findid == -1) {
|
||
yanbang[yanindex].y = yanbang[yanindex - 1].y
|
||
yanbang[yanindex].l = yanbang[yanindex - 1].l
|
||
isjshb = false
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// console.log("zlkj");
|
||
// console.log(g, k);
|
||
// console.log(yanbang);
|
||
// console.log(listbang);
|
||
|
||
// Sleep(0);
|
||
return [yanbang, isjshb]
|
||
}
|
||
|
||
// 合并空间
|
||
function HBKJ(yanbang: Big_bang[], listbang: xbang[], dt: number): [Big_bang[], number] {
|
||
let get_result: Big_bang[]
|
||
let minY: number = 10000
|
||
let yanindex: number
|
||
|
||
get_result = hb(yanbang, dt)
|
||
yanbang = get_result
|
||
|
||
let isend: boolean = false
|
||
while (isend == false) {
|
||
if (yanbang.length == 1) { break }
|
||
for (let i = 0; i < yanbang.length; i++) {
|
||
let temp_result = []
|
||
temp_result = zlkj(yanbang, listbang, dt)
|
||
if (temp_result[1] == false) {
|
||
yanbang = temp_result[0]
|
||
get_result = hb(yanbang, dt)
|
||
yanbang = get_result
|
||
}
|
||
else
|
||
isend = true
|
||
}
|
||
}
|
||
for (let i = 0; i < yanbang.length; i++) {
|
||
if (yanbang[i].y < minY) {
|
||
minY = yanbang[i].y
|
||
yanindex = i
|
||
}
|
||
}
|
||
return [yanbang, yanindex]
|
||
}
|
||
|
||
// 寻找符合面积的板
|
||
function find_bang_k_g(g: number, k: number, Listbang: xbang[], oneFaceBlock: boolean): xbang[] // g 高 k 宽 listbang:小板列表 lx:0 面积最大 1 最高 2 最宽 isdtwosided: boolean true 翻板提前
|
||
{
|
||
let finbang: xbang[] = []
|
||
if (oneFaceBlock == true) {
|
||
for (let i = 0; i < Listbang.length; i++) {
|
||
if (Listbang[i].line == 0) {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && Listbang[i].isdtwosided == false) {
|
||
finbang.push(Listbang[i])
|
||
}
|
||
}
|
||
else if (Listbang[i].line == 1) {
|
||
if (Listbang[i].l <= k && Listbang[i].w <= g && Listbang[i].isdtwosided == false) {
|
||
finbang.push(Listbang[i])
|
||
}
|
||
}
|
||
else {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && Listbang[i].isdtwosided == false) {
|
||
finbang.push(Listbang[i])
|
||
}
|
||
else if (Listbang[i].l <= k && Listbang[i].w <= g && Listbang[i].isdtwosided == false) {
|
||
finbang.push(Listbang[i])
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
for (let i = 0; i < Listbang.length; i++) {
|
||
if (Listbang[i].line == 0) {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k) {
|
||
finbang.push(Listbang[i])
|
||
}
|
||
}
|
||
else if (Listbang[i].line == 1) {
|
||
if (Listbang[i].l <= k && Listbang[i].w <= g) {
|
||
finbang.push(Listbang[i])
|
||
}
|
||
}
|
||
else {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k) {
|
||
finbang.push(Listbang[i])
|
||
}
|
||
else if (Listbang[i].l <= k && Listbang[i].w <= g) {
|
||
finbang.push(Listbang[i])
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return finbang
|
||
} // 寻找面积最的板
|
||
|
||
// 寻找面积最大的板
|
||
function find_max_mz(g: number, k: number, Listbang: xbang[], isdtwosided: boolean): findbang // g 高 k 宽 listbang:小板列表 lx:0 面积最大 1 最高 2 最宽 isdtwosided: boolean true 翻板提前
|
||
{
|
||
let max: number = 0
|
||
let bangindex: number = -1
|
||
let line: LineType = LineType.Positive
|
||
let pbg: number = 0
|
||
let pbk: number = 0
|
||
let bangid: number = 0
|
||
let temp_max: number
|
||
|
||
if (isdtwosided == true) {
|
||
for (let i = 0; i < Listbang.length; i++) {
|
||
temp_max = Listbang[i].l * Listbang[i].w / 1000000
|
||
if (Listbang[i].line == 0) {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max < temp_max && Listbang[i].isdtwosided == true) {
|
||
max = temp_max
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
else if (Listbang[i].line == 1) {
|
||
if (Listbang[i].l <= k && Listbang[i].w <= g && max < temp_max && Listbang[i].isdtwosided == true) {
|
||
max = temp_max
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
else {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max < temp_max && Listbang[i].isdtwosided == true) {
|
||
max = temp_max
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
}
|
||
else if (Listbang[i].l <= k && Listbang[i].w <= g && max < temp_max && Listbang[i].isdtwosided == true) {
|
||
max = temp_max
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
}
|
||
if (bangindex == -1) {
|
||
for (let i = 0; i < Listbang.length; i++) {
|
||
temp_max = Listbang[i].l * Listbang[i].w / 1000000
|
||
if (Listbang[i].line == 0) {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max < temp_max) {
|
||
max = temp_max
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
else if (Listbang[i].line == 1) {
|
||
if (Listbang[i].l <= k && Listbang[i].w <= g && max < temp_max) {
|
||
max = temp_max
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
else {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max < temp_max) {
|
||
max = temp_max
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
}
|
||
else if (Listbang[i].l <= k && Listbang[i].w <= g && max < temp_max) {
|
||
max = temp_max
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
for (let i = 0; i < Listbang.length; i++) {
|
||
temp_max = Listbang[i].l * Listbang[i].w / 1000000
|
||
if (Listbang[i].line == 0) {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max < temp_max) {
|
||
max = temp_max
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
else if (Listbang[i].line == 1) {
|
||
if (Listbang[i].l <= k && Listbang[i].w <= g && max < temp_max) {
|
||
max = temp_max
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
else {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max < temp_max) {
|
||
max = temp_max
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
}
|
||
else if (Listbang[i].l <= k && Listbang[i].w <= g && max < temp_max) {
|
||
max = temp_max
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return {
|
||
findid: bangindex,
|
||
line,
|
||
pbg,
|
||
pbk,
|
||
id: bangid,
|
||
}
|
||
} // 寻找面积最的板
|
||
|
||
// 寻找最高的板
|
||
function find_max_g(g: number, k: number, Listbang: xbang[], isdtwosided: boolean): findbang // g 高 k 宽 listbang:小板列表 lx:0 面积最大 1 最高 2 最宽
|
||
{
|
||
let max: number = 0
|
||
let bangindex: number = -1
|
||
let line: LineType = LineType.Positive
|
||
let pbg: number = 0
|
||
let pbk: number = 0
|
||
let bangid: number = 0
|
||
if (isdtwosided == true) {
|
||
for (let i = 0; i < Listbang.length; i++) {
|
||
if (Listbang[i].line == 0) {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max < Listbang[i].l && Listbang[i].isdtwosided == true) {
|
||
max = Listbang[i].l
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
else if (Listbang[i].line == 1) {
|
||
if (Listbang[i].l <= k && Listbang[i].w <= g && max < Listbang[i].w && Listbang[i].isdtwosided == true) {
|
||
max = Listbang[i].w
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
else {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max < Listbang[i].l && Listbang[i].isdtwosided == true) {
|
||
max = Listbang[i].l
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
}
|
||
else if (Listbang[i].l <= k && Listbang[i].w <= g && max < Listbang[i].w && Listbang[i].isdtwosided == true) {
|
||
max = Listbang[i].w
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
}
|
||
if (bangindex == -1) {
|
||
for (let i = 0; i < Listbang.length; i++) {
|
||
if (Listbang[i].line == 0) {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max < Listbang[i].l) {
|
||
max = Listbang[i].l
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
else if (Listbang[i].line == 1) {
|
||
if (Listbang[i].l <= k && Listbang[i].w <= g && max < Listbang[i].w) {
|
||
max = Listbang[i].w
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
else {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max < Listbang[i].l) {
|
||
max = Listbang[i].l
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
}
|
||
else if (Listbang[i].l <= k && Listbang[i].w <= g && max < Listbang[i].w) {
|
||
max = Listbang[i].w
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
for (let i = 0; i < Listbang.length; i++) {
|
||
if (Listbang[i].line == 0) {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max < Listbang[i].l) {
|
||
max = Listbang[i].l
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
else if (Listbang[i].line == 1) {
|
||
if (Listbang[i].l <= k && Listbang[i].w <= g && max < Listbang[i].w) {
|
||
max = Listbang[i].w
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
else {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max < Listbang[i].l) {
|
||
max = Listbang[i].l
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
}
|
||
else if (Listbang[i].l <= k && Listbang[i].w <= g && max < Listbang[i].w) {
|
||
max = Listbang[i].w
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return {
|
||
findid: bangindex,
|
||
line,
|
||
pbg,
|
||
pbk,
|
||
id: bangid,
|
||
}
|
||
}
|
||
|
||
// 寻找同高的板
|
||
function find_same_g(g: number, k: number, Listbang: xbang[], isdtwosided: boolean): findbang // g 高 k 宽 listbang:小板列表 lx:0 面积最大 1 最高 2 最宽
|
||
{
|
||
let max: number = g
|
||
let bangindex: number = -1
|
||
let line: LineType = LineType.Positive
|
||
let pbg: number = 0
|
||
let pbk: number = 0
|
||
let bangid: number = 0
|
||
if (isdtwosided == true) {
|
||
for (let i = 0; i < Listbang.length; i++) {
|
||
if (Listbang[i].line == 0) {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max == Listbang[i].l && Listbang[i].isdtwosided == true) {
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
else if (Listbang[i].line == 1) {
|
||
if (Listbang[i].l <= k && Listbang[i].w <= g && max == Listbang[i].w && Listbang[i].isdtwosided == true) {
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
else {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max == Listbang[i].l && Listbang[i].isdtwosided == true) {
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
else if (Listbang[i].l <= k && Listbang[i].w <= g && max == Listbang[i].w && Listbang[i].isdtwosided == true) {
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
}
|
||
if (bangindex == -1) {
|
||
for (let i = 0; i < Listbang.length; i++) {
|
||
if (Listbang[i].line == 0) {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max == Listbang[i].l) {
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
else if (Listbang[i].line == 1) {
|
||
if (Listbang[i].l <= k && Listbang[i].w <= g && max == Listbang[i].w) {
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
else {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max == Listbang[i].l) {
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
else if (Listbang[i].l <= k && Listbang[i].w <= g && max == Listbang[i].w) {
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
for (let i = 0; i < Listbang.length; i++) {
|
||
if (Listbang[i].line == 0) {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max == Listbang[i].l) {
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
else if (Listbang[i].line == 1) {
|
||
if (Listbang[i].l <= k && Listbang[i].w <= g && max == Listbang[i].w) {
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
else {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max == Listbang[i].l) {
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
else if (Listbang[i].l <= k && Listbang[i].w <= g && max == Listbang[i].w) {
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return {
|
||
findid: bangindex,
|
||
line,
|
||
pbg,
|
||
pbk,
|
||
id: bangid,
|
||
}
|
||
}// 寻找同高的板
|
||
|
||
// 寻找最宽的板
|
||
function find_max_k(g: number, k: number, Listbang: xbang[], isdtwosided: boolean): findbang // g 高 k 宽 listbang:小板列表 lx:0 面积最大 1 最高 2 最宽
|
||
{
|
||
let max: number = 0
|
||
let bangindex: number = -1
|
||
let line: LineType = LineType.Positive
|
||
let pbg: number = 0
|
||
let pbk: number = 0
|
||
let bangid: number = 0
|
||
if (isdtwosided == true) {
|
||
for (let i = 0; i < Listbang.length; i++) {
|
||
if (Listbang[i].line == 0) {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max < Listbang[i].w && Listbang[i].isdtwosided == true) {
|
||
max = Listbang[i].w
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
else if (Listbang[i].line == 1) {
|
||
if (Listbang[i].l <= k && Listbang[i].w <= g && max < Listbang[i].l && Listbang[i].isdtwosided == true) {
|
||
max = Listbang[i].l
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
else {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max < Listbang[i].w && Listbang[i].isdtwosided == true) {
|
||
max = Listbang[i].w
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
}
|
||
else if (Listbang[i].l <= k && Listbang[i].w <= g && max < Listbang[i].l && Listbang[i].isdtwosided == true) {
|
||
max = Listbang[i].l
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
}
|
||
if (bangindex == -1) {
|
||
for (let i = 0; i < Listbang.length; i++) {
|
||
if (Listbang[i].line == 0) {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max < Listbang[i].w) {
|
||
max = Listbang[i].w
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
else if (Listbang[i].line == 1) {
|
||
if (Listbang[i].l <= k && Listbang[i].w <= g && max < Listbang[i].l) {
|
||
max = Listbang[i].l
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
else {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max < Listbang[i].w) {
|
||
max = Listbang[i].w
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
}
|
||
else if (Listbang[i].l <= k && Listbang[i].w <= g && max < Listbang[i].l) {
|
||
max = Listbang[i].l
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
for (let i = 0; i < Listbang.length; i++) {
|
||
if (Listbang[i].line == 0) {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max < Listbang[i].w) {
|
||
max = Listbang[i].w
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
else if (Listbang[i].line == 1) {
|
||
if (Listbang[i].l <= k && Listbang[i].w <= g && max < Listbang[i].l) {
|
||
max = Listbang[i].l
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
else {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max < Listbang[i].w) {
|
||
max = Listbang[i].w
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
}
|
||
else if (Listbang[i].l <= k && Listbang[i].w <= g && max < Listbang[i].l) {
|
||
max = Listbang[i].l
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return {
|
||
findid: bangindex,
|
||
line,
|
||
pbg,
|
||
pbk,
|
||
id: bangid,
|
||
}
|
||
} // 寻找最高的板
|
||
|
||
// 寻同宽的板
|
||
function find_same_k(g: number, k: number, Listbang: xbang[], isdtwosided: boolean): findbang // g 高 k 宽 listbang:小板列表 lx:0 面积最大 1 最高 2 最宽
|
||
{
|
||
let max: number = k
|
||
let bangindex: number = -1
|
||
let line: LineType = LineType.Positive
|
||
let pbg: number = 0
|
||
let pbk: number = 0
|
||
let bangid: number = 0
|
||
if (isdtwosided == true) {
|
||
for (let i = 0; i < Listbang.length; i++) {
|
||
if (Listbang[i].line == 0) {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max == Listbang[i].w && Listbang[i].isdtwosided == true) {
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
else if (Listbang[i].line == 1) {
|
||
if (Listbang[i].l <= k && Listbang[i].w <= g && max == Listbang[i].l && Listbang[i].isdtwosided == true) {
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
else {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max == Listbang[i].w && Listbang[i].isdtwosided == true) {
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
else if (Listbang[i].l <= k && Listbang[i].w <= g && max == Listbang[i].l && Listbang[i].isdtwosided == true) {
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
}
|
||
if (bangindex == -1) {
|
||
for (let i = 0; i < Listbang.length; i++) {
|
||
if (Listbang[i].line == 0) {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max == Listbang[i].w) {
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
else if (Listbang[i].line == 1) {
|
||
if (Listbang[i].l <= k && Listbang[i].w <= g && max == Listbang[i].l) {
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
else {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max == Listbang[i].w) {
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
else if (Listbang[i].l <= k && Listbang[i].w <= g && max == Listbang[i].l) {
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
for (let i = 0; i < Listbang.length; i++) {
|
||
if (Listbang[i].line == 0) {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max == Listbang[i].w) {
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
else if (Listbang[i].line == 1) {
|
||
if (Listbang[i].l <= k && Listbang[i].w <= g && max == Listbang[i].l) {
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
else {
|
||
if (Listbang[i].l <= g && Listbang[i].w <= k && max == Listbang[i].w) {
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
else if (Listbang[i].l <= k && Listbang[i].w <= g && max == Listbang[i].l) {
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return {
|
||
findid: bangindex,
|
||
line,
|
||
pbg,
|
||
pbk,
|
||
id: bangid,
|
||
}
|
||
} // 寻同宽的板
|
||
|
||
// 找到同样大小尺寸的板材 && Listbang[i].isdtwosided == true)
|
||
function find_same_bang(g: number, k: number, Listbang: xbang[], isdtwosided: boolean): findbang // g 高 k 宽 listbang:小板列表 1 同高 2 同宽
|
||
{
|
||
let bangindex: number = -1
|
||
let line: LineType = LineType.Positive
|
||
let pbg: number = 0
|
||
let pbk: number = 0
|
||
let bangid: number = 0
|
||
if (isdtwosided == true) {
|
||
for (let i = 0; i < Listbang.length; i++) {
|
||
if (Listbang[i].line == 0) {
|
||
if (Listbang[i].l == g && Listbang[i].w == k && Listbang[i].isdtwosided == true) {
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
else if (Listbang[i].line == 1) {
|
||
if (Listbang[i].l == k && Listbang[i].w == g && Listbang[i].isdtwosided == true) {
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
else {
|
||
if (Listbang[i].l == g && Listbang[i].w == k && Listbang[i].isdtwosided == true) {
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
else if (Listbang[i].l == k && Listbang[i].w == g && Listbang[i].isdtwosided == true) {
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
}
|
||
if (bangindex == -1) {
|
||
for (let i = 0; i < Listbang.length; i++) {
|
||
if (Listbang[i].line == 0) {
|
||
if (Listbang[i].l == g && Listbang[i].w == k) {
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
else if (Listbang[i].line == 1) {
|
||
if (Listbang[i].l == k && Listbang[i].w == g) {
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
else {
|
||
if (Listbang[i].l == g && Listbang[i].w == k) {
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
else if (Listbang[i].l == k && Listbang[i].w == g) {
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
for (let i = 0; i < Listbang.length; i++) {
|
||
if (Listbang[i].line == 0) {
|
||
if (Listbang[i].l == g && Listbang[i].w == k) {
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
else if (Listbang[i].line == 1) {
|
||
if (Listbang[i].l == k && Listbang[i].w == g) {
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
else {
|
||
if (Listbang[i].l == g && Listbang[i].w == k) {
|
||
bangindex = i
|
||
line = 0
|
||
pbg = Listbang[i].l
|
||
pbk = Listbang[i].w
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
else if (Listbang[i].l == k && Listbang[i].w == g) {
|
||
bangindex = i
|
||
line = 1
|
||
pbg = Listbang[i].w
|
||
pbk = Listbang[i].l
|
||
bangid = Listbang[i].id
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return {
|
||
findid: bangindex,
|
||
line,
|
||
pbg,
|
||
pbk,
|
||
id: bangid,
|
||
}
|
||
} // 寻找同高或同宽的板
|
||
|
||
// 计算生成的余板 返回 余板数组，连带的板 小板数组
|
||
// lx:0面积最大 1最高 2最宽 fs:取板方式，false:左右(取同宽) true：上下(取同高) dt:刀头间隙
|
||
function jsyb(bigbang: Big_bang, lx: number, fs: boolean, dt: number, listbang: xbang[], isdtwosided: boolean): [number, number, Big_bang[], Con, xbang[], number, Big_bang[]] {
|
||
let x: number = bigbang.x
|
||
let y: number = bigbang.y
|
||
let k: number = bigbang.w
|
||
let g: number = bigbang.l
|
||
let isend: boolean = false
|
||
let ybg: number = g
|
||
let ybk: number = k
|
||
let x1: number = x
|
||
let y1: number = y
|
||
let yb: Big_bang[] = [] // #余板 坐标跟高宽;
|
||
let yhxbang: Con = [] // #连带小板的Id，及坐标
|
||
let zfkj: Big_bang[] = [] // 作废的空间
|
||
let l: number
|
||
let w: number
|
||
|
||
let get_result: findbang
|
||
let temp_get: findbang
|
||
if (lx === 0) {
|
||
// get_result = find_max_mz(g, k, listbang);
|
||
get_result = find_max_mz(g, k, listbang, isdtwosided)
|
||
}
|
||
else if (lx == 1) {
|
||
// get_result = find_max_g(g, k, listbang);
|
||
get_result = find_max_g(g, k, listbang, isdtwosided)
|
||
}
|
||
else {
|
||
// get_result = find_max_k(g, k, listbang);
|
||
get_result = find_max_k(g, k, listbang, isdtwosided)
|
||
}
|
||
|
||
if (get_result.findid > -1) {
|
||
yhxbang.push({
|
||
bangid: get_result.id,
|
||
line: get_result.line,
|
||
x,
|
||
y,
|
||
pbg: get_result.pbg,
|
||
pbk: get_result.pbk,
|
||
})
|
||
listbang.splice(get_result.findid, 1)
|
||
l = get_result.pbg
|
||
w = get_result.pbk
|
||
if (fs == false) // false:左右(取同宽) true：上下(取同高)
|
||
{
|
||
ybg = g - l - dt
|
||
y1 = y + l + dt
|
||
while (isend == false) {
|
||
// temp_get = find_same_k(ybg, w, listbang);
|
||
temp_get = find_same_k(ybg, w, listbang, isdtwosided)
|
||
if (temp_get.findid > -1) {
|
||
yhxbang.push({
|
||
bangid: temp_get.id,
|
||
line: temp_get.line,
|
||
x,
|
||
y: y1,
|
||
pbg: temp_get.pbg,
|
||
pbk: temp_get.pbk,
|
||
})
|
||
y1 = y1 + temp_get.pbg + dt
|
||
ybg = ybg - temp_get.pbg - dt
|
||
listbang.splice(temp_get.findid, 1)
|
||
}
|
||
else {
|
||
if (ybg > 0) {
|
||
yb.push({
|
||
l: ybg,
|
||
w,
|
||
x,
|
||
y: y1,
|
||
})
|
||
}
|
||
if (k - w - dt > 0) {
|
||
yb.push({
|
||
l: g,
|
||
w: k - w - dt,
|
||
x: x + w + dt,
|
||
y,
|
||
})
|
||
}
|
||
break
|
||
}
|
||
}
|
||
}
|
||
else // true：上下(取同高)
|
||
{
|
||
ybk = k - w - dt
|
||
x1 = x + w + dt
|
||
while (isend == false) {
|
||
temp_get = find_same_g(l, ybk, listbang, isdtwosided)
|
||
if (temp_get.findid > -1) {
|
||
yhxbang.push({
|
||
bangid: temp_get.id,
|
||
line: temp_get.line,
|
||
x: x1,
|
||
y,
|
||
pbg: temp_get.pbg,
|
||
pbk: temp_get.pbk,
|
||
})
|
||
x1 = x1 + temp_get.pbk + dt
|
||
ybk = ybk - temp_get.pbk - dt
|
||
listbang.splice(temp_get.findid, 1)
|
||
}
|
||
else {
|
||
if (ybk > 0) {
|
||
yb.push({
|
||
l,
|
||
w: ybk,
|
||
x: x1,
|
||
y,
|
||
})
|
||
}
|
||
if (g - l - dt > 0) {
|
||
yb.push({
|
||
l: g - l - dt,
|
||
w: k,
|
||
x,
|
||
y: y + l + dt,
|
||
})
|
||
}
|
||
break
|
||
}
|
||
}
|
||
} // false:左右(取同宽) true：上下(取同高)
|
||
let ybsl: number = 0
|
||
let yhsl: number = 0
|
||
if (yb.length > 0) { ybsl = yb.length }
|
||
if (yhxbang.length > 0) { yhsl = yhxbang.length }
|
||
return [ybsl, yhsl, yb, yhxbang, listbang, 0, zfkj]
|
||
}
|
||
else {
|
||
zfkj.push({
|
||
l: g,
|
||
w: k,
|
||
x,
|
||
y,
|
||
})
|
||
let ybsl: number = 0
|
||
let yhsl: number = 0
|
||
if (yb.length > 0) { ybsl = yb.length }
|
||
if (yhxbang.length > 0) { yhsl = yhxbang.length }
|
||
return [ybsl, yhsl, yb, yhxbang, listbang, 1, zfkj]
|
||
}
|
||
}
|
||
|
||
// 计算生成的余板 返回 余板数组，连带的板 小板数组 都是左右分隔空间，后面再来空间合并
|
||
// lx:0面积最大 1最高 2最宽 fs:取板方式，false:取同宽 true：取同高 dt:刀头间隙
|
||
function jsyb1(bigbang: Big_bang, lx: number, fs: boolean, dt: number, listbang: xbang[], isdtwosided: boolean): [number, number, Big_bang[], Con, xbang[], number, Big_bang[]] {
|
||
let x: number = bigbang.x
|
||
let y: number = bigbang.y
|
||
let k: number = bigbang.w
|
||
let g: number = bigbang.l
|
||
let isend: boolean = false
|
||
let ybg: number = g
|
||
let ybk: number = k
|
||
let x1: number = x
|
||
let y1: number = y
|
||
let yb: Big_bang[] = [] // #余板 坐标跟高宽;
|
||
let yhxbang: Con = []// #连带小板的Id，及坐标
|
||
let zfkj: Big_bang[] = [] // 作废的空间
|
||
let l: number
|
||
let w: number
|
||
|
||
let get_result: findbang
|
||
let temp_get: findbang
|
||
if (lx == 0) {
|
||
// get_result = find_max_mz(g, k, listbang);
|
||
get_result = find_max_mz(g, k, listbang, isdtwosided)
|
||
}
|
||
else if (lx == 1) {
|
||
// get_result = find_max_g(g, k, listbang);
|
||
get_result = find_max_g(g, k, listbang, isdtwosided)
|
||
}
|
||
else {
|
||
// get_result = find_max_k(g, k, listbang);
|
||
get_result = find_max_k(g, k, listbang, isdtwosided)
|
||
}
|
||
|
||
if (get_result.findid > -1) {
|
||
yhxbang.push({
|
||
bangid: get_result.id,
|
||
line: get_result.line,
|
||
x,
|
||
y,
|
||
pbg: get_result.pbg,
|
||
pbk: get_result.pbk,
|
||
})
|
||
listbang.splice(get_result.findid, 1)
|
||
//////////////
|
||
l = get_result.pbg
|
||
w = get_result.pbk
|
||
if (fs == false) // false:左右(取同宽) true：上下(取同高)
|
||
{
|
||
ybg = g - l - dt
|
||
y1 = y + l + dt
|
||
while (isend == false) {
|
||
temp_get = find_same_k(ybg, w, listbang, isdtwosided)
|
||
if (temp_get.findid > -1) {
|
||
yhxbang.push({
|
||
bangid: temp_get.id,
|
||
line: temp_get.line,
|
||
x,
|
||
y: y1,
|
||
pbg: temp_get.pbg,
|
||
pbk: temp_get.pbk,
|
||
})
|
||
y1 = y1 + temp_get.pbg + dt
|
||
ybg = ybg - temp_get.pbg - dt
|
||
listbang.splice(temp_get.findid, 1)
|
||
}
|
||
else {
|
||
if (ybg > 0) {
|
||
yb.push({
|
||
l: ybg,
|
||
w,
|
||
x,
|
||
y: y1,
|
||
})
|
||
}
|
||
if (k - w - dt > 0) {
|
||
yb.push({
|
||
l: g,
|
||
w: k - w - dt,
|
||
x: x + w + dt,
|
||
y,
|
||
})
|
||
}
|
||
break
|
||
}
|
||
}
|
||
}
|
||
else // true：上下(取同高)
|
||
{
|
||
ybk = k - w - dt
|
||
x1 = x + w + dt
|
||
while (isend == false) {
|
||
temp_get = find_same_g(l, ybk, listbang, isdtwosided)
|
||
if (temp_get.findid > -1) {
|
||
yhxbang.push({
|
||
bangid: temp_get.id,
|
||
line: temp_get.line,
|
||
x: x1,
|
||
y,
|
||
pbg: temp_get.pbg,
|
||
pbk: temp_get.pbk,
|
||
})
|
||
x1 = x1 + temp_get.pbk + dt
|
||
ybk = ybk - temp_get.pbk - dt
|
||
listbang.splice(temp_get.findid, 1)
|
||
}
|
||
else {
|
||
if (ybk > 0) {
|
||
yb.push({
|
||
l: g,
|
||
w: ybk,
|
||
x: x1,
|
||
y,
|
||
})
|
||
}
|
||
if (g - l - dt > 0) {
|
||
yb.push({
|
||
l: g - l - dt,
|
||
w: k - ybk - dt,
|
||
x,
|
||
y: y + l + dt,
|
||
})
|
||
}
|
||
break
|
||
}
|
||
}
|
||
} // false:左右(取同宽) true：上下(取同高)
|
||
|
||
////////////////////////////////////////////////////////////////////////////
|
||
|
||
let ybsl: number = 0
|
||
let yhsl: number = 0
|
||
if (yb.length > 0) { ybsl = yb.length }
|
||
if (yhxbang.length > 0) { yhsl = yhxbang.length }
|
||
return [ybsl, yhsl, yb, yhxbang, listbang, 0, zfkj]
|
||
}
|
||
else {
|
||
zfkj.push({
|
||
l: g,
|
||
w: k,
|
||
x,
|
||
y,
|
||
})
|
||
let ybsl: number = 0
|
||
let yhsl: number = 0
|
||
if (yb.length > 0) { ybsl = yb.length }
|
||
if (yhxbang.length > 0) { yhsl = yhxbang.length }
|
||
return [ybsl, yhsl, yb, yhxbang, listbang, 1, zfkj]
|
||
}
|
||
}
|
||
|
||
interface findbang {
|
||
findid: number
|
||
line: LineType
|
||
pbg: number
|
||
pbk: number
|
||
id: number
|
||
}
|
||
|
||
interface Lyr {
|
||
pfs: number// 平方数
|
||
lry: number// 利用率
|
||
ys: number// 页数
|
||
}
|
||
|
||
/** 获取数组最后一个元素 */
|
||
function arrayLast<T>(arr: { [key: number]: T; length: number }): T
|
||
{
|
||
return arr[arr.length - 1]
|
||
}
|
||
|
||
/** 查找数组中最大的元素 */
|
||
function arrayMax<T>(arr: T[], f: (item: T) => number = a => (a as unknown as number)): [T, number]
|
||
{
|
||
let max = Number.NEGATIVE_INFINITY
|
||
let maxIndex = -1
|
||
for (let i = 0; i < arr.length; i++)
|
||
{
|
||
let item = arr[i]
|
||
let v = f(item)
|
||
if (v > max)
|
||
{
|
||
maxIndex = i
|
||
max = v
|
||
}
|
||
}
|
||
return [arr[maxIndex], maxIndex]
|
||
}
|
||
async function Sleep(time: number)
|
||
{
|
||
return new Promise((res) =>
|
||
{
|
||
setTimeout(res, time)
|
||
})
|
||
}
|