diff --git a/LuaLibs/WProcessCut.lua b/LuaLibs/WProcessCut.lua index 215047a..02cf974 100644 --- a/LuaLibs/WProcessCut.lua +++ b/LuaLibs/WProcessCut.lua @@ -30,10 +30,40 @@ function WPC.Classify( Proc, b3Raw) if Proc.Fct ~= 1 then return false end -- controllo la normale local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT) - if vtN:getZ() < -0.5 then return false end + if vtN:getZ() < - 0.5 then return false end return true end +---------------------------------------------------------------------- +-- Classificazione del flip della feature per nesting +-- return nFlip0, nFlip1 +function WPC.FlipClassify( Proc) + -- verifico abbia una sola faccia + if Proc.Fct ~= 1 then return 0, 0 end + -- controllo la normale + local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT) + local vtNZ = vtN:getZ() + if vtNZ > - GEO.EPS_SMALL then + nFlip0 = 100 + elseif vtNZ < -0.5 then + nFlip0 = 0 + else + nFlip0 = 25 + end + + if - vtNZ > - GEO.EPS_SMALL then + nFlip1 = 100 + elseif - vtNZ < -0.5 then + nFlip1 = 0 + else + nFlip1 = 25 + end + + --nFlip0 = EgtIf( vtN:getZ() < -0.5, 0, 100) + --nFlip1 = EgtIf( - vtN:getZ() < -0.5, 0, 100) + return nFlip0, nFlip1 +end + --------------------------------------------------------------------- -- Applicazione della lavorazione function WPC.Make( Proc, nRawId, b3Raw) diff --git a/LuaLibs/WProcessDoubleCut.lua b/LuaLibs/WProcessDoubleCut.lua index 0a36eed..74a0bc4 100644 --- a/LuaLibs/WProcessDoubleCut.lua +++ b/LuaLibs/WProcessDoubleCut.lua @@ -38,6 +38,20 @@ function WPDC.Classify( Proc, b3Raw) return ( vtN[1]:getZ() >= - 0.01 or vtN[2]:getZ() >= - 0.01) end +---------------------------------------------------------------------- +-- Classificazione del flip della feature per nesting +-- return nFlip0, nFlip1 +function WPDC.FlipClassify( Proc) + + -- se una faccia, uso la classificazione dei tagli singoli + if Proc.Fct == 1 then return Cut.FlipClassify( Proc) end + -- se due facce, uso la classificazione del lap joint a due facce + if Proc.Fct == 2 then return LapJoint.FlipClassify( Proc) end + -- se più di due facce non si fa + if Proc.Fct > 2 then return 0, 0 end + +end + --------------------------------------------------------------------- -- Applicazione della lavorazione function WPDC.Make( Proc, nRawId, b3Raw) diff --git a/LuaLibs/WProcessDrill.lua b/LuaLibs/WProcessDrill.lua index 225c460..4bc441c 100644 --- a/LuaLibs/WProcessDrill.lua +++ b/LuaLibs/WProcessDrill.lua @@ -42,7 +42,8 @@ end --------------------------------------------------------------------- -- Classificazione della feature -function WPD.Classify( Proc, b3Raw) +function WPD.Classify( Proc, b3Raw) + -- recupero e verifico l'entità foro local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i') or 0 if AuxId then AuxId = AuxId + Proc.Id end @@ -68,6 +69,98 @@ function WPD.Classify( Proc, b3Raw) end end +-- Classificazione del flip della feature per nesting +-- return nFlip0, nFlip1 +function WPD.FlipClassify( Proc, b3Part) + local nFlip0 = 0 + local nFlip1 = 0 + -- recupero e verifico l'entità foro + local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i') or 0 + if AuxId then AuxId = AuxId + Proc.Id end + if not AuxId or EgtGetType( AuxId) ~= GDB_TY.CRV_ARC then + return false + end + -- recupero i dati del foro + local dDiam = 2 * EgtArcRadius( AuxId) + local dLen = abs( EgtCurveThickness( AuxId)) + local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB) + local ptCen = EgtCP( AuxId, GDB_RT.GLOB) + + -- identifico su quali facce si trova il foro + local ptPrcMin = Proc.Box:getMin() + local ptPrcMax = Proc.Box:getMax() + local ptPartMin = b3Part:getMin() + local ptPartMax = b3Part:getMax() + + if not ( abs( ptPrcMin:getX() - ptPartMin:getX()) < GEO.EPS_SMALL or abs( ptPrcMax:getX() - ptPartMax:getX()) < GEO.EPS_SMALL) then -- corrispondente delle facce 5/6 nel caso ruotato + if abs( vtExtr:getX()) > WD.DRILL_VX_MAX then return 0, 0 end + end + + -- se foro cieco + if Proc.Fcs == 0 or Proc.Fce == 0 then + -- se normale positiva + local dVtExtrZ = vtExtr:getZ() + -- verifico se è lavorabile da sopra + nFlip0 = EgtIf( dVtExtrZ >= WD.DRILL_VZ_MIN, 100, 0) + -- verifico se e' lavorabile da fliped: cambio segno al versore + nFlip1 = EgtIf( -dVtExtrZ >= WD.DRILL_VZ_MIN, 100, 0) + return nFlip0, nFlip1 +-- -- altrimenti foro pasante +-- else +-- -- verifico orientamento della normale rispetto ad angolo massimo +-- if abs( vtExtr:getX()) <= WD.DRILL_VX_MAX then +-- nFlip0 = 100 +-- nFlip1 = 100 +-- else +-- nFlip0 = 0 +-- nFlip1 = 0 +-- end + end +end + +-- Classificazione della rotazione della feature per nesting +-- return nRot0, nRot90, nRot180, nRot270 +function WPD.RotateClassify( Proc, ValidRotations) + local nRot0 = -1 + local nRot90 = -1 + local nRot180 = -1 + local nRot270 = -1 + -- recupero e verifico l'entità foro + local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i') or 0 + if AuxId then AuxId = AuxId + Proc.Id end + if not AuxId or EgtGetType( AuxId) ~= GDB_TY.CRV_ARC then + return false + end + -- recupero i dati del foro + local dDiam = 2 * EgtArcRadius( AuxId) + local dLen = abs( EgtCurveThickness( AuxId)) + local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB) + local ptCen = EgtCP( AuxId, GDB_RT.GLOB) + -- se foro da 35 orizzontale + local HorizDrillDiam = 35 + local HorizDrillTol = 4 + if dDiam <= HorizDrillDiam + HorizDrillTol and dDiam >= HorizDrillDiam - HorizDrillTol and vtExtr:getZ() > -0.1 and vtExtr:getZ() < 0.1 then + -- se orientato perpendicolare ad X + if AreSameOrOppositeVectorApprox( vtExtr, X_AX()) then + nRot0 = 0 + nRot90 = EgtIf (ValidRotations.bRot90, 100, 0) + nRot180 = 0 + nRot270 = EgtIf (ValidRotations.bRot90, 100, 0) + return nRot0, nRot90, nRot180, nRot270 + elseif AreSameOrOppositeVectorApprox( vtExtr, Y_AX()) then + nRot0 = EgtIf (ValidRotations.bRot0, 100, 0) + nRot90 = 0 + nRot180 = EgtIf (ValidRotations.bRot0, 100, 0) + nRot270 = 0 + return nRot0, nRot90, nRot180, nRot270 + end + end + +-- local b3Drill = EgtGetBBoxGlob( Proc.Id, GDB_BB.STANDARD) +-- -- se ci sono fori sul profilo (box attaccato al profilo e / calcolo intersezione tra foro e box, se box del profilo foro ha Z, e' sul profilo) + +end + --------------------------------------------------------------------- -- Applicazione della lavorazione function WPD.Make( Proc, nRawId, b3Raw) diff --git a/LuaLibs/WProcessDtMortise.lua b/LuaLibs/WProcessDtMortise.lua index fe82a56..69968cb 100644 --- a/LuaLibs/WProcessDtMortise.lua +++ b/LuaLibs/WProcessDtMortise.lua @@ -36,6 +36,24 @@ function WPDM.Classify( Proc, b3Raw) return ( vtExtr:getZ() > WD.NZ_MINA) end + +---------------------------------------------------------------------- +-- Classificazione del flip della feature per nesting +-- return nFlip0, nFlip1 +function WPDM.FlipClassify( Proc) + -- recupero i dati della curva di contorno della faccia di fondo + local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i') + if not AuxId then return false end + AuxId = AuxId + Proc.Id + local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB) + -- verifico se la mortasa è lavorabile + nFlip0 = EgtIf( vtExtr:getZ() > WD.NZ_MINA, 100, 0) + nFlip1 = EgtIf( - vtExtr:getZ() > WD.NZ_MINA, 100, 0) + + return nFlip0, nFlip1 + +end + --------------------------------------------------------------------- -- Applicazione della lavorazione function WPDM.Make( Proc, nRawId, b3Raw) diff --git a/LuaLibs/WProcessFreeContour.lua b/LuaLibs/WProcessFreeContour.lua index f1598e3..93c3710 100644 --- a/LuaLibs/WProcessFreeContour.lua +++ b/LuaLibs/WProcessFreeContour.lua @@ -1,4 +1,4 @@ --- ProcessFreeContour.lua by Egaltech s.r.l. 2021/11/02 +-- ProcessFreeContour.lua by Egaltech s.r.l. 2021/11/04 -- Gestione calcolo profilo libero per Pareti -- Tabella per definizione modulo @@ -58,6 +58,56 @@ function WPF.Classify( Proc, b3Raw) end end +---------------------------------------------------------------------- +-- Classificazione del flip della feature per nesting +-- return nFlip0, nFlip1 +function WPF.FlipClassify( Proc, b3Raw) + local nFlip0 = 0 + local nFlip1 = 0 + + -- verifico se di tipo pocket + local bPocket = ( EgtGetInfo( Proc.Id, 'PCKT', 'i') == 1) + -- recupero la curva associata se esiste + local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i') + if not AuxId then return false end + AuxId = AuxId + Proc.Id + local vtN = EgtCurveExtrusion( AuxId, GDB_RT.GLOB) + local dVtNZ = vtN:getZ() + -- se tasca + if bPocket then + -- verifico se è lavorabile da sopra + nFlip0 = EgtIf( dVtNZ < -0.5, 0, 100) + -- verifico se e' lavorabile da fliped: cambio segno al versore + nFlip1 = EgtIf( -dVtNZ < -0.5, 100, 0) + + -- se altrimenti profilo orizzontale + elseif abs( dVtNZ) < WD.NZ_MINA then + return 0, 0 + -- se altrimenti profilo verticale che non interessa tutta la sezione + elseif Proc.Box:getMax():getZ() < b3Raw:getMax():getZ() - 2 then + return 0 , 0 + -- altrimenti è profilo verticale che interessa tutta la sezione + else + local dVtNZMedia = 0 + for i = 1, Proc.Fct do + local vtN = EgtSurfTmFacetNormVersor( Proc.Id, i - 1, GDB_ID.ROOT) + dVtNZMedia = dVtNZMedia + vtN:getZ() + end + dVtNZMedia = dVtNZMedia / Proc.Fct + if abs( dVtNZMedia) <= GEO.EPS_SMALL then + nFlip0 = 100 + nFlip1 = 100 + elseif dVtNZMedia >= 0 + GEO.EPS_SMALL then + nFlip0 = 75 + nFlip1 = 25 + else + nFlip0 = 25 + nFlip1 = 75 + end + end + return nFlip0, nFlip1 +end + --------------------------------------------------------------------- local function TestElleShape3( nIdGeom, nNumFacet) -- valida solo nel caso di tre facce @@ -1852,6 +1902,68 @@ local function MakeByMill( Proc, nRawId, b3Raw) return true end +--------------------------------------------------------------------- +local function MakeByMark( Proc, nRawId, b3Raw) + -- ingombro del pezzo + local Ls = EgtGetFirstNameInGroup( Proc.PartId, 'Box') + local b3Solid = EgtGetBBoxGlob( Ls or GDB_ID.NULL, GDB_BB.STANDARD) + if not b3Solid then + local sErr = 'Error : part box not found' + EgtOutLog( sErr) + return false, sErr + end + -- recupero e verifico l'entità curva + local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i') or 0 + if AuxId then AuxId = AuxId + Proc.Id end + if not AuxId or ( EgtGetType( AuxId) & GDB_FY.GEO_CURVE) == 0 then + local sErr = 'Error : missing profile geometry' + EgtOutLog( sErr) + return false, sErr + end + -- recupero i dati della curva e del profilo + local dDepth = abs( EgtCurveThickness( AuxId)) + local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB) + local b3Aux = EgtGetBBoxGlob( AuxId, GDB_BB.STANDARD) + local bToolInv = ( vtExtr:getZ() < -0.1) + local nTool_ID = EgtGetInfo( Proc.Id, 'CNT_DATA', 'i') + -- recupero la lavorazione + local sMilling = WM.FindMilling( 'Text', nil, nil, nTool_ID) + if not sMilling then + local sErr = 'Error : milling not found in library' + if nTool_ID then sErr = sErr .. ' (Tool_ID=' .. tostring( nTool_ID) .. ')' end + EgtOutLog( sErr) + return false, sErr + end + -- inserisco la lavorazione + local sName = 'FreeMark_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) + local nMchId = EgtAddMachining( sName, sMilling) + if not nMchId then + local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling + EgtOutLog( sErr) + return false, sErr + end + EgtSetInfo( nMchId, 'Part', Proc.PartId) + -- aggiungo geometria + EgtSetMachiningGeometry( {{ AuxId, -1}}) + -- se estrusione da sotto, inverto direzione fresa + if bToolInv then + EgtSetMachiningParam( MCH_MP.TOOLINVERT, true) + end + -- posizione braccio porta testa + local nSCC = MCH_SCC.ADIR_ZP + if AreSameOrOppositeVectorApprox( vtExtr, Z_AX()) then + nSCC = EgtIf( Proc.Box:getDimX() >= Proc.Box:getDimY(), MCH_SCC.ADIR_YP, MCH_SCC.ADIR_XP) + end + EgtSetMachiningParam( MCH_MP.SCC, nSCC) + -- eseguo + if not EgtApplyMachining( true, false) then + local _, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nMchId, false) + return false, sErr + end + return true +end + --------------------------------------------------------------------- local function MakeByNail( Proc, nRawId, b3Raw) -- ingombro del pezzo @@ -2119,6 +2231,9 @@ function WPF.Make( Proc, nRawId, b3Raw) -- se fresatura if nCntType == 2 then return MakeByMill( Proc, nRawId, b3Raw) + -- se marcatura + elseif nCntType == 10 then + return MakeByMark( Proc, nRawId, b3Raw) -- se chiodatura elseif nCntType == 20 then return MakeByNail( Proc, nRawId, b3Raw) diff --git a/LuaLibs/WProcessLapJoint.lua b/LuaLibs/WProcessLapJoint.lua index 891cc34..070c41e 100644 --- a/LuaLibs/WProcessLapJoint.lua +++ b/LuaLibs/WProcessLapJoint.lua @@ -175,6 +175,150 @@ function WPL.Classify( Proc, b3Raw) end end +-- funzione che verifica se faccia lavorabile da sopra +local function VerifyVtN( ProcId, nFct) + local nFlip0 = 0 + local nFlip1 = 0 + -- dati della faccia + local vtN = EgtSurfTmFacetNormVersor( ProcId, nFct, GDB_ID.ROOT) + local dVtNZ = vtN:getZ() + -- verifico se è lavorabile da sopra + nFlip0 = EgtIf( dVtNZ >= WD.NZ_MINA, 100, 0) + -- verifico se e' lavorabile da fliped: cambio segno al versore + nFlip1 = EgtIf( -dVtNZ >= WD.NZ_MINA, 100, 0) + return nFlip0, nFlip1 +end + +-- funzione che fa la media dei versori per assegnare punteggi flip +local function VerifyVtNMedia(ProcId, nFct1, nFct2) + local nFlip0 = 0 + local nFlip1 = 0 + -- dati delle facce + local vtN = {} + vtN[1] = EgtSurfTmFacetNormVersor( ProcId, nFct1, GDB_ID.ROOT) + vtN[2] = EgtSurfTmFacetNormVersor( ProcId, nFct2, GDB_ID.ROOT) + local dVtN1Z = vtN[1]:getZ() + local dVtN2Z = vtN[2]:getZ() + -- se entrambi i versori positivi + if (dVtN1Z >= - 0.01 and dVtN2Z >= - 0.01) then + -- posso lavorarlo da sopra + nFlip0 = 100 + -- se almeno un versore positivo + elseif (dVtN1Z >= - 0.01 or dVtN2Z >= - 0.01) then + -- calcolo media dei versori: se positiva tende verso alto + local dVtNMedia = ( dVtN1Z + dVtN2Z) / 2 + if dVtNMedia >= 0 - GEO.EPS_SMALL and dVtNMedia <= 0 + GEO.EPS_SMALL then + nFlip0 = 100 + elseif dVtNMedia >= 0 + GEO.EPS_SMALL then + nFlip0 = 75 + else + nFlip0 = 25 + end + -- se entrambi i versori negativi, impossibile da fare + else + nFlip0 = 0 + end + -- verifico se e' lavorabile da fliped: cambio segno ai versori + dVtN1Z = -dVtN1Z + dVtN2Z = -dVtN2Z + -- se entrambi i versori positivi + if (dVtN1Z >= - 0.01 and dVtN2Z >= - 0.01) then + -- posso lavorarlo da sopra + nFlip1 = 100 + -- se almeno un versore positivo + elseif (dVtN1Z >= - 0.01 or dVtN2Z >= - 0.01) then + -- calcolo media dei versori: se positiva tende verso alto + local dVtNMedia = ( dVtN1Z + dVtN2Z) / 2 + if dVtNMedia >= 0 - GEO.EPS_SMALL and dVtNMedia <= 0 + GEO.EPS_SMALL then + nFlip1 = 100 + elseif dVtNMedia >= 0 + GEO.EPS_SMALL then + nFlip1 = 75 + else + nFlip1 = 25 + end + -- se entrambi i versori negativi, impossibile da fare + else + nFlip0 = 0 + end + return nFlip0, nFlip1 +end + +-- Classificazione del flip della feature per nesting +-- return nFlip0, nFlip1 +function WPL.FlipClassify( Proc) + local nFlip0 = -1 + local nFlip1 = -1 + -- se 1 faccia + if Proc.Fct == 1 then + -- verifico che la normale permetta la lavorazione da sopra ed assegno punteggio di conseguenza + nFlip0, nFlip1 = VerifyVtN( Proc.Id, 0) + -- se 2 facce + elseif Proc.Fct == 2 then + -- calcolo la media delle normali delle facce ed assegno punteggio maggiore se positiva + nFlip0, nFlip1 = VerifyVtNMedia(Proc.Id, 0, 1) + -- se più di 2 facce + else + local nFacInd, dElev, nFacInd2, dElev2 = WL.GetFaceWithMostAdj( Proc.Id, Proc.PartId) + if nFacInd == -2 then return 0, 0 end + -- se 3 facce + if Proc.Fct == 3 then + -- se forma ad U + if not nFacInd2 or nFacInd2 == 0 then + -- verifico che la normale del fondo permetta la lavorazione da sopra ed assegno punteggio di conseguenza + nFlip0, nFlip1 = VerifyVtN( Proc.Id, nFacInd) + -- se non ad U + else + -- calcolo la media delle normali delle facce di fondo ed assegno punteggio maggiore se positiva + nFlip0, nFlip1 = VerifyVtNMedia(Proc.Id, nFacInd, nFacInd2) + end + -- se 4 facce + elseif Proc.Fct == 4 then + -- se senza fondo (tunnel) + if not nFacInd or nFacInd == -1 then + -- dati delle facce + local vtN = {} + vtN[1] = EgtSurfTmFacetNormVersor( Proc.Id, 0, GDB_ID.ROOT) + vtN[2] = EgtSurfTmFacetNormVersor( Proc.Id, 1, GDB_ID.ROOT) + vtN[3] = EgtSurfTmFacetNormVersor( Proc.Id, 2, GDB_ID.ROOT) + vtN[4] = EgtSurfTmFacetNormVersor( Proc.Id, 3, GDB_ID.ROOT) + -- verifico se è lavorabile da sopra + local vtAxN = vtN[1] ^ vtN[2] + if vtAxN:isSmall() then + vtAxN = vtN[1] ^ vtN[3] + end + if ( abs( vtAxN:getZ()) >= WD.NZ_MINA) then + -- calcolo la media dei versori delle facce + local dVtNMedia = ( vtN[1]:getZ() + vtN[2]:getZ() + vtN[3]:getZ() + vtN[4]:getZ()) / 4 + if dVtNMedia >= 0 - GEO.EPS_SMALL and dVtNMedia <= 0 + GEO.EPS_SMALL then + nFlip0 = 100 + nFlip1 = 100 + elseif dVtNMedia >= 0 + GEO.EPS_SMALL then + nFlip0 = 75 + nFlip1 = 25 + else + nFlip0 = 25 + nFlip1 = 75 + end + end + -- se con fondo + else + -- calcolo la media delle normali delle facce di fondo ed assegno punteggio maggiore se positiva + local vtN = {} + vtN[1] = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT) + vtN[2] = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd2, GDB_ID.ROOT) + if vtN[1]:getZ() == -1 or vtN[2]:getZ() == -1 then return 0, 100 end + if vtN[1]:getZ() == 1 or vtN[2]:getZ() == 1 then return 100, 0 end + nFlip0, nFlip1 = VerifyVtNMedia(Proc.Id, nFacInd, nFacInd2) + end + -- se 5 facce + elseif Proc.Fct == 5 then + -- verifico che la normale del fondo permetta la lavorazione da sopra ed assegno punteggio di conseguenza + nFlip0, nFlip1 = VerifyVtN( Proc.Id, nFacInd) + end + end + return nFlip0, nFlip1 +end + --------------------------------------------------------------------- local function TestElleShape3( nIdGeom, nNumFacet) -- valida solo nel caso di tre facce @@ -1268,7 +1412,7 @@ local function MakeSideGrooveByMill( Proc, nFacet, nRawId, b3Raw, sCustomMach, d EgtOutLog( sErr) return false, sErr end - -- verificoo che la lavorazione sia passante dal grezzo + -- verifico che la lavorazione sia passante dal grezzo local dLongGorge = max( dH, dV) local dExtraLongExtPlus = 0 local dExtraLongExtNeg = 0 diff --git a/LuaLibs/WProcessMark.lua b/LuaLibs/WProcessMark.lua index 4bee670..71af91f 100644 --- a/LuaLibs/WProcessMark.lua +++ b/LuaLibs/WProcessMark.lua @@ -37,6 +37,29 @@ function WPMK.Classify( Proc, b3Raw) return ( vtN:getZ() > WD.NZ_MINA) end +---------------------------------------------------------------------- +-- Classificazione del flip della feature per nesting +-- return nFlip0, nFlip1 +function WPMK.FlipClassify( Proc) + local nFlip0, nFlip1 + local vtN + if EgtGetType( Proc.Id) ~= GDB_TY.EXT_TEXT then + vtN = EgtCurveExtrusion( Proc.Id, GDB_ID.ROOT) + else + vtN = EgtTextNormVersor( Proc.Id, GDB_ID.ROOT) + end + -- verifico sia una curva/testo + if not vtN then + return false + end + -- verifico se la marcatura è lavorabile (solo da sopra) + nFlip0 = EgtIf( vtN:getZ() > WD.NZ_MINA, 100, 0) + nFlip1 = EgtIf( - vtN:getZ() > WD.NZ_MINA, 100, 0) + return nFlip0, nFlip1 + +end + + --------------------------------------------------------------------- -- Applicazione della lavorazione function WPMK.Make( Proc, nRawId, b3Raw) diff --git a/LuaLibs/WProcessMortise.lua b/LuaLibs/WProcessMortise.lua index edde5ee..b10098a 100644 --- a/LuaLibs/WProcessMortise.lua +++ b/LuaLibs/WProcessMortise.lua @@ -50,6 +50,39 @@ function WPM.Classify( Proc, b3Raw) end end +---------------------------------------------------------------------- +-- Classificazione del flip della feature per nesting +-- return nFlip0, nFlip1 +function WPM.FlipClassify( Proc) + -- recupero e verifico il percorso supplementare + local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i') + if AuxId then AuxId = AuxId + Proc.Id end + -- recupero versore estrusione della curva supplementare e non più della superficie + -- perché quest'ultima potrebbe non avere il fondo e dare quindi un risultato non corretto + local vtExtr = EgtCurveExtrusion( AuxId or GDB_ID.NULL, GDB_ID.ROOT) + -- recupero i dati della faccia di fondo + local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT) + -- verifico sia una superficie + if not vtExtr then + return false + end + if not vtN then + return false + end + -- Confronto le direzioni Z dei 2 versori : se diverse la faccia 0 non è il fondo => mortasa passante + if abs( vtExtr:getZ() - vtN:getZ()) > 10 * GEO.EPS_SMALL then + return 100, 100 + -- altrimenti è chiusa + else + -- verifico se la mortasa è lavorabile da sopra + nFlip0 = EgtIf( vtN:getZ() > WD.NZ_MINA, 100, 0) + nFlip1 = EgtIf( - vtN:getZ() > WD.NZ_MINA, 100, 0) + end + + return nFlip0, nFlip1 + +end + --------------------------------------------------------------------- -- Applicazione della lavorazione function WPM.Make( Proc, nRawId, b3Raw) diff --git a/LuaLibs/WProcessSawCut.lua b/LuaLibs/WProcessSawCut.lua index 70391b0..5a9ede2 100644 --- a/LuaLibs/WProcessSawCut.lua +++ b/LuaLibs/WProcessSawCut.lua @@ -32,6 +32,22 @@ function WPSC.Classify( Proc, b3Raw) return ( vtDir:getZ() > 0.5) end +---------------------------------------------------------------------- +-- Classificazione del flip della feature per nesting +-- return nFlip0, nFlip1 +function WPSC.FlipClassify( Proc) + -- recupero i dati del versore direzione di accesso della lavorazione + local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i') + if not AuxId then return false end + AuxId = AuxId + Proc.Id + local vtDir = EgtSV( AuxId, GDB_ID.ROOT) + local vtDirZ = vtDir:getZ() + nFlip0 = EgtIf( vtDirZ > 0.5, 100, 0) + nFlip1 = EgtIf( - vtDirZ > 0.5, 100, 0) + + return nFlip0, nFlip1 +end + --------------------------------------------------------------------- -- Applicazione della lavorazione function WPSC.Make( Proc, nRawId, b3Raw) diff --git a/LuaLibs/WProcessText.lua b/LuaLibs/WProcessText.lua index e66329f..a67651e 100644 --- a/LuaLibs/WProcessText.lua +++ b/LuaLibs/WProcessText.lua @@ -32,6 +32,25 @@ function WPT.Classify( Proc, b3Raw) return ( vtN:getZ() > WD.NZ_MINA) end +---------------------------------------------------------------------- +-- Classificazione del flip della feature per nesting +-- return nFlip0, nFlip1 +function WPT.FlipClassify( Proc) + local nFlip0, nFlip1 + -- recupero i dati del testo + local vtN = EgtTextNormVersor( Proc.Id, GDB_ID.ROOT) + -- verifico sia un testo + if not vtN then + return false + end + -- verifico se il testo è lavorabile (solo da sopra) + nFlip0 = EgtIf( vtN:getZ() > WD.NZ_MINA, 100, 0) + nFlip1 = EgtIf( - vtN:getZ() > WD.NZ_MINA, 100, 0) + return nFlip0, nFlip1 + +end + + --------------------------------------------------------------------- -- Applicazione della lavorazione function WPT.Make( Proc, nRawId, b3Raw) diff --git a/NestProcess.lua b/NestProcess.lua index 4d7dc14..f0c979b 100644 --- a/NestProcess.lua +++ b/NestProcess.lua @@ -19,6 +19,57 @@ EgtOutLog( sLog) local sLogFile = EgtChangePathExtension( NEST.FILE, '.txt') EgtEraseFile( sLogFile) +-- Imposto direttorio libreria specializzata per Travi +local sBaseDir = EgtGetSourceDir() +EgtAddToPackagePath( sBaseDir .. 'LuaLibs\\?.lua') + +-- Verifico che la macchina corrente sia abilitata per la lavorazione delle Pareti +local sMachDir = EgtGetCurrMachineDir() +if not EgtExistsFile( sMachDir .. '\\Wall\\WallData.lua') then + WALL.ERR = 12 + WALL.MSG = 'Error not configured for walls machine : ' .. sMachine + WriteErrToLogFile( WALL.ERR, WALL.MSG) + PostErrView( WALL.ERR, WALL.MSG) + return +end + +-- Elimino direttori altre macchine e imposto direttorio macchina corrente per ricerca librerie +EgtRemoveBaseMachineDirFromPackagePath() +EgtAddToPackagePath( sMachDir .. '\\Wall\\?.lua') + +-- Carico le librerie +_G.package.loaded.WallExec = nil +local WE = require( 'WallExec') +_G.package.loaded.WallLib = nil +local WL = require( 'WallLib') +_G.package.loaded.WProcessLapJoint = nil +local LapJoint = require( 'WProcessLapJoint') +_G.package.loaded.WProcessDrill = nil +local Drill = require( 'WProcessDrill') +_G.package.loaded.WProcessCut = nil +local Cut = require( 'WProcessCut') +_G.package.loaded.WProcessDoubleCut = nil +local DoubleCut = require( 'WProcessDoubleCut') +_G.package.loaded.WProcessSawCut = nil +local SawCut = require( 'WProcessSawCut') +_G.package.loaded.WProcessFreeContour = nil +local FreeContour = require( 'WProcessFreeContour') +_G.package.loaded.WProcessMortise = nil +local Mortise = require( 'WProcessMortise') +_G.package.loaded.WProcessDtMortise = nil +local DtMortise = require( 'WProcessDtMortise') +_G.package.loaded.WProcessMark = nil +local Mark = require( 'WProcessMark') +_G.package.loaded.WProcessText = nil +local Text = require( 'WProcessText') + + +-- Carico i dati globali +local WD = require( 'WallData') + +-- lista dei pezzi con flip o rotazione +local PartStates = {} + -- Funzioni per scrittura su file di log specifico local function WriteErrToLogFile( nErr, sMsg, nRot, nCutId, nTaskId) local hFile = io.open( sLogFile, 'a') @@ -83,37 +134,594 @@ local function NewMachGroupName() return nMaxMachGroup + 1 end --- Imposto direttorio libreria specializzata per Travi -local sBaseDir = EgtGetSourceDir() -EgtAddToPackagePath( sBaseDir .. 'LuaLibs\\?.lua') - --- Verifico che la macchina corrente sia abilitata per la lavorazione delle Pareti -local sMachDir = EgtGetCurrMachineDir() -if not EgtExistsFile( sMachDir .. '\\Wall\\WallData.lua') then - WALL.ERR = 12 - WALL.MSG = 'Error not configured for walls machine : ' .. sMachine - WriteErrToLogFile( WALL.ERR, WALL.MSG) - PostErrView( WALL.ERR, WALL.MSG) - return +-- Funzione che crea +local function CreateToolRectangle( ptP1, ptP2, vtFace, nOutlineGrp) + -- da inserire in WallData + local MILL_DIAM = 350 + + local vtX = ptP2 - ptP1 + vtX:normalize() + -- creo il rettangolo della lavorazione + ptP1 = ptP1 - vtX * 9000 + ptP2 = ptP2 + vtX * ( MILL_DIAM / 2 + 100 * GEO.EPS_SMALL) + ptP2 = ptP2 + vtFace * ( MILL_DIAM + 100 * GEO.EPS_SMALL) + local nId = EgtRectangle2P( nOutlineGrp, Point3d(ptP2:getX(), ptP2:getY(), 0), Point3d( ptP1:getX(), ptP1:getY(), 0)) + + return nId + end --- Elimino direttori altre macchine e imposto direttorio macchina corrente per ricerca librerie -EgtRemoveBaseMachineDirFromPackagePath() -EgtAddToPackagePath( sMachDir .. '\\Wall\\?.lua') --- Carico le librerie -_G.package.loaded.WallExec = nil -local WE = require( 'WallExec') -_G.package.loaded.WallLib = nil -local WL = require( 'WallLib') -_G.package.loaded.WProcessLapJoint = nil -local LapJoint = require( 'WProcessLapJoint') --- Carico i dati globali -local WD = require( 'WallData') + +-- Funzione che crea le regioni occupate dalle lavorazioni +local function ComputeToolOutlines( nPartId) + + local ToolOutlineId = {} + + -- recupero il gruppo con gli outlines degli utensili + local nOutlineGrp = EgtGetFirstNameInGroup(GDB_ID.ROOT, "ToolOutlines") + if not nOutlineGrp or nOutlineGrp == GDB_ID.NULL then + nOutlineGrp = EgtGroup( GDB_ID.ROOT) + EgtSetName( nOutlineGrp, "ToolOutlines") + EgtSetStatus( nOutlineGrp, GDB_ST.OFF) + end + + -- recupero i lap joint che sono fatti dal basso + local vPartProc = WE.CollectFeatures( nPartId, b3Raw) + for nInd = 1, #vPartProc do + Proc = vPartProc[nInd] + if LapJoint.Identify( vPartProc[nInd]) then + + if Proc.Fct == 2 then + local vtN = {} + vtN[1] = EgtSurfTmFacetNormVersor( Proc.Id, 0, GDB_ID.ROOT) + vtN[2] = EgtSurfTmFacetNormVersor( Proc.Id, 1, GDB_ID.ROOT) + if ( vtN[1]:getZ() <= - 0.95 or vtN[2]:getZ() <= - 0.95) then + local vtFace = EgtIf( vtN[1]:getZ() <= -0.95, vtN[2], vtN[1]) + local bAdj, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, 0, 1, GDB_ID.ROOT) + -- creo il rettangolo della lavorazione + local nId = CreateToolRectangle( ptP1, ptP2, vtFace, nOutlineGrp) + if nId ~= GDB_ID.NULL then table.insert(ToolOutlineId, nId) end + end + end + + if Proc.Fct == 3 then + local nFacInd, dElev = WL.GetFaceWithMostAdj( Proc.Id, Proc.PartId) + if nFacInd ~= -2 then + local vtN = EgtSurfTmFacetNormVersor( Proc.Id, nFacInd, GDB_ID.ROOT) + if not AreSameOrOppositeVectorApprox( vtN, Z_AX()) then + local nOtherFace = EgtIf( nFacInd == 0, 1, 0) + local bAdj, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, nFacInd, nOtherFace, GDB_ID.ROOT) + if abs( ptP1:getZ() - ptP2:getZ()) < GEO.EPS_SMALL then + local nId = CreateToolRectangle( ptP1, ptP2, vtN, nOutlineGrp) + if nId ~= GDB_ID.NULL then table.insert(ToolOutlineId, nId) end + end + end + end + end + + end + end + + return ToolOutlineId +end + + +-- Funzione che sposta e aggiunge pezzi per nesting +local function AddRawParts(RawParts) + -- creo tabella dei grezzi + for nIndex, nLen in pairs( LEN) do + table.insert(RawParts, {Len = nLen}) + end + for nIndex, nWidth in pairs( WIDTH) do + RawParts[tonumber(nIndex)].Width = nWidth + end + for nIndex, nQty in pairs( QTY) do + RawParts[tonumber(nIndex)].Qty = nQty + end + for nIndex, nMaterial in pairs( MATERIAL) do + RawParts[tonumber(nIndex)].Material = nMaterial + end + + local OUTLINE = "Outline" + for nIndex = 1, #RawParts do + -- creo pannello del materiale + local SheetPartId = EgtGroup(GDB_ID.ROOT) + RawParts[nIndex].PartId = SheetPartId + EgtSetName(SheetPartId, "Sheet") + local SheetLayerId = EgtGroup(SheetPartId) + EgtSetName(SheetLayerId, OUTLINE) + local SheetOutlineId = EgtRectangle2P(SheetLayerId, Point3d(0,0,0), Point3d(RawParts[nIndex].Len, RawParts[nIndex].Width, 0), GDB_RT.GLOB) + -- EgtModifyCurveThickness(SheetOutlineId, -Material.T_mm) + EgtSetName(SheetOutlineId, OUTLINE) + + -- creo foglio per nesting + EgtAutoNestAddSheet( SheetPartId, SheetOutlineId, NEST.KERF, 0, RawParts[nIndex].Qty) -- EgtAutoNestAddSheet( SheetId, OutlineId, dKerf, nPriority, nCount) + end +end + +local function AddParts(RawParts) + local nTotParts = 0 + for _ in pairs( PART) do nTotParts = nTotParts + 1 end + local nPartIndex = 0 + -- ciclo su pezzi per aggiungerli al nesting + for nPartId, nCount in pairs( PART) do + nPartIndex = nPartIndex + 1 + -- calcolo bbox pezzo per rotazioni + local b3Part = EgtGetBBoxGlob( nPartId, GDB_BB.STANDARD) + local vPartProc = WE.CollectFeatures( nPartId, b3Raw) + -- verifico se possibile flip parete + -- recupero stati di flip delle feature di lavorazione della parete + local bFlip = false + local FlipFeatureStates = {} + for nInd = 1, #vPartProc do + if LapJoint.Identify( vPartProc[nInd]) then + local nFlip0, nFlip1 = LapJoint.FlipClassify(vPartProc[nInd]) + if nFlip0 and nFlip1 and nFlip0 ~= nFlip1 then + table.insert( FlipFeatureStates, { Flip0 = nFlip0, Flip1 = nFlip1}) + end + elseif Drill.Identify( vPartProc[nInd]) then + local nFlip0, nFlip1 = Drill.FlipClassify(vPartProc[nInd], b3Part) + if nFlip0 and nFlip1 and nFlip0 ~= nFlip1 then + table.insert( FlipFeatureStates, { Flip0 = nFlip0, Flip1 = nFlip1}) + end + elseif Cut.Identify( vPartProc[nInd]) then + local nFlip0, nFlip1 = Cut.FlipClassify(vPartProc[nInd], b3Part) + if nFlip0 and nFlip1 and nFlip0 ~= nFlip1 then + table.insert( FlipFeatureStates, { Flip0 = nFlip0, Flip1 = nFlip1}) + end + elseif DoubleCut.Identify( vPartProc[nInd]) then + local nFlip0, nFlip1 = DoubleCut.FlipClassify(vPartProc[nInd], b3Part) + if nFlip0 and nFlip1 and nFlip0 ~= nFlip1 then + table.insert( FlipFeatureStates, { Flip0 = nFlip0, Flip1 = nFlip1}) + end + elseif SawCut.Identify( vPartProc[nInd]) then + local nFlip0, nFlip1 = SawCut.FlipClassify(vPartProc[nInd], b3Part) + if nFlip0 and nFlip1 and nFlip0 ~= nFlip1 then + table.insert( FlipFeatureStates, { Flip0 = nFlip0, Flip1 = nFlip1}) + end + elseif FreeContour.Identify( vPartProc[nInd]) then + local nFlip0, nFlip1 = FreeContour.FlipClassify(vPartProc[nInd], b3Part) + if nFlip0 and nFlip1 and nFlip0 ~= nFlip1 then + table.insert( FlipFeatureStates, { Flip0 = nFlip0, Flip1 = nFlip1}) + end + elseif Mortise.Identify( vPartProc[nInd]) then + local nFlip0, nFlip1 = Mortise.FlipClassify(vPartProc[nInd], b3Part) + if nFlip0 and nFlip1 and nFlip0 ~= nFlip1 then + table.insert( FlipFeatureStates, { Flip0 = nFlip0, Flip1 = nFlip1}) + end + elseif DtMortise.Identify( vPartProc[nInd]) then + local nFlip0, nFlip1 = DtMortise.FlipClassify(vPartProc[nInd], b3Part) + if nFlip0 and nFlip1 and nFlip0 ~= nFlip1 then + table.insert( FlipFeatureStates, { Flip0 = nFlip0, Flip1 = nFlip1}) + end + elseif Mark.Identify( vPartProc[nInd]) then + local nFlip0, nFlip1 = Mark.FlipClassify(vPartProc[nInd], b3Part) + if nFlip0 and nFlip1 and nFlip0 ~= nFlip1 then + table.insert( FlipFeatureStates, { Flip0 = nFlip0, Flip1 = nFlip1}) + end + elseif Text.Identify( vPartProc[nInd]) then + local nFlip0, nFlip1 = Text.FlipClassify(vPartProc[nInd], b3Part) + if nFlip0 and nFlip1 and nFlip0 ~= nFlip1 then + table.insert( FlipFeatureStates, { Flip0 = nFlip0, Flip1 = nFlip1}) + end + end + end + -- analizzo stati flip delle feature + local nFlip0Min = 100 + local nFlip0Cnt = 0 + local nFlip1Min = 100 + local nFlip1Cnt = 0 + -- calcolo punteggio minimo e sua molteplicita' per entrambi i lati + for nInd = 1, #FlipFeatureStates do + if FlipFeatureStates[nInd].Flip0 < nFlip0Min then + nFlip0Min = FlipFeatureStates[nInd].Flip0 + nFlip0Cnt = 1 + elseif FlipFeatureStates[nInd].Flip0 == nFlip0Min then + nFlip0Cnt = nFlip0Cnt + 1 + end + if FlipFeatureStates[nInd].Flip1 < nFlip1Min then + nFlip1Min = FlipFeatureStates[nInd].Flip1 + nFlip1Cnt = 1 + elseif FlipFeatureStates[nInd].Flip1 == nFlip1Min then + nFlip1Cnt = nFlip1Cnt + 1 + end + end + -- calcolo lato con punteggio minore o molteplicita' piu' alta + if nFlip0Min == nFlip1Min then + if nFlip0Cnt > nFlip1Cnt then + bFlip = true + end + elseif nFlip0Min < nFlip1Min then + bFlip = true + end + -- eseguo flip se necessario + if bFlip then + EgtRotate( nPartId, b3Part:getCenter(), X_AX(), 180, GDB_RT.GLOB) + end + + -- verifico quali sono le rotazioni ammesse + local ValidRotations = { bRot0 = true, bRot90 = true} + local dPartL = b3Part:getDimX() + local dPartW = b3Part:getDimY() + + local nOut0 = 0 -- numero di grezzi che non conterrebbero il pezzo ruotato di 0°/180° + local nOut90 = 0 -- numero di grezzi che non conterrebbero il pezzo ruotato di 90°/270° + for nInd = 1, #RawParts do + if ( dPartL > RawParts[nInd]["Len"] or dPartW > RawParts[nInd]["Width"]) then nOut0 = nOut0 + 1 end + if ( dPartW > RawParts[nInd]["Len"] or dPartL > RawParts[nInd]["Width"]) then nOut90 = nOut90 + 1 end + end + + -- se il pezzo ruotato è fuori da tutti i grezzi, blocco quelle rotazioni + if nOut0 == #RawParts then ValidRotations.bRot0 = false end + if nOut90 == #RawParts then ValidRotations.bRot90 = false end + + + local nRotate = 0 + local RotateFeatureStates = {} + for nInd = 1, #vPartProc do + if Drill.Identify( vPartProc[nInd]) then + local nRot0, nRot90, nRot180, nRot270 = Drill.RotateClassify(vPartProc[nInd], ValidRotations) + if nRot0 and nRot0 >= 0 then + table.insert( RotateFeatureStates, { Rot0 = nRot0, Rot90 = nRot90, Rot180 = nRot180, Rot270 = nRot270}) + end + end + end + -- analizzo stati rotazione delle feature + local nRot0Min = 100 + local nRot0Cnt = 0 + local nRot90Min = 100 + local nRot90Cnt = 0 + local nRot180Min = 100 + local nRot180Cnt = 0 + local nRot270Min = 100 + local nRot270Cnt = 0 + -- calcolo punteggio minimo e sua molteplicita' per tutte le rotazioni + for nInd = 1, #RotateFeatureStates do + if RotateFeatureStates[nInd].Rot0 < nRot0Min then + nRot0Min = RotateFeatureStates[nInd].Rot0 + nRot0Cnt = 1 + elseif RotateFeatureStates[nInd].Rot0 == nRot0Min then + nRot0Cnt = nRot0Cnt + 1 + end + if RotateFeatureStates[nInd].Rot90 < nRot90Min then + nRot90Min = RotateFeatureStates[nInd].Rot90 + nRot90Cnt = 1 + elseif RotateFeatureStates[nInd].Rot90 == nRot90Min then + nRot90Cnt = nRot90Cnt + 1 + end + if RotateFeatureStates[nInd].Rot180 < nRot180Min then + nRot180Min = RotateFeatureStates[nInd].Rot180 + nRot180Cnt = 1 + elseif RotateFeatureStates[nInd].Rot180 == nRot180Min then + nRot180Cnt = nRot180Cnt + 1 + end + if RotateFeatureStates[nInd].Rot270 < nRot270Min then + nRot270Min = RotateFeatureStates[nInd].Rot270 + nRot270Cnt = 1 + elseif RotateFeatureStates[nInd].Rot270 == nRot270Min then + nRot270Cnt = nRot270Cnt + 1 + end + end + + -- se c'e' qualche stato di rotazione + local MinList = { { Rot = 0, Score = nRot0Min, ScoreCnt = nRot0Cnt}, + { Rot = 90, Score = nRot90Min, ScoreCnt = nRot90Cnt}, + { Rot = 180, Score = nRot180Min, ScoreCnt = nRot180Cnt}, + { Rot = 270, Score = nRot270Min, ScoreCnt = nRot270Cnt}} + if #RotateFeatureStates > 0 then + -- calcolo lato con punteggio minore o molteplicita' piu' alta + local nRotMax = 0 + local nScoreMax = 0 + local nScoreCnt = 0 + for nInd = 1, #MinList do + if MinList[nInd].Score > nScoreMax then + nRotMax = MinList[nInd].Rot + nScoreMax = MinList[nInd].Score + nScoreCnt = MinList[nInd].ScoreCnt + elseif MinList[nInd].Score == nScoreMax then + if MinList[nInd].ScoreCnt < nScoreCnt then + nRotMax = MinList[nInd].Rot + nScoreMax = MinList[nInd].Score + nScoreCnt = MinList[nInd].ScoreCnt + end + end + end + nRotate = nRotMax + else + nRotate = 0 + end + + -- eseguo rotazione se necessario + if nRotate > 0 then + EgtRotate( nPartId, b3Part:getCenter(), Z_AX(), nRotate, GDB_RT.GLOB) + end +-- -- calcolo rotazioni permesse a nesting +-- local AdmittedRotation = {} +-- for nInd = 1, #MinList do +-- if MinList[nInd].Score >= 50 then +-- table.insert( AdmittedRotation, MinList[nInd].Rot) +-- end +-- end + local bRotNest = false + local nStepRotNest = 0 + -- se calcolate limitazioni su rotazioni + if MinList and #MinList > 0 then + -- verifico condizioni da permettere al nesting + if MinList[1].Score >= 50 and MinList[2].Score >= 50 and MinList[3].Score >= 50 and MinList[4].Score >= 50 then + bRotNest = true + nStepRotNest = 90 + elseif (nRotate == 0 and MinList[3].Score >= 50) or ( nRotate == 90 and MinList[4].Score >= 50) then + bRotNest = true + nStepRotNest = 180 + end + else + -- altrimenti permetto tutto + bRotNest = true + nStepRotNest = 90 + end + + -- aggiungo stato a lista stati del pezzo per ripristinare alla fine + table.insert( PartStates, { PartId = tonumber(nPartId), Flip = bFlip, Rotate = nRotate}) + + +-- local bFtDown = false +-- local vPartProc = WE.CollectFeatures( nPartId, b3Raw) +-- for nInd = 1, #vPartProc do +-- if LapJoint.Identify( vPartProc[nInd]) then +-- local nFacOpt, dMinElev, nFacOpt2, dMinElev2 = WL.GetFaceWithMostAdj( vPartProc[nInd].Id, vPartProc[nInd].PartId) +-- if nFacOpt >= 0 then +-- local vtN = EgtSurfTmFacetNormVersor( vPartProc[nInd].Id, nFacOpt, GDB_ID.ROOT) +-- if vtN:getZ() < -0.09 then +-- bFtDown = true +-- break +-- end +-- end +-- end +-- LapJoint.FlipClassify(vPartProc[nInd]) +-- end +-- -- ruoto se necessario +-- if bFtDown then +-- local b3Solid = EgtGetBBoxGlob(nPartId, GDB_BB.IGNORE_TEXT) +-- local ptRotCen = b3Solid:getCenter() +-- EgtRotate( nPartId, ptRotCen, X_AX(), 180, GDB_RT.GLOB) +-- end + +-- -- recupero le feature di lavorazione della parete +-- local bFtDown = false +-- local vPartProc = WE.CollectFeatures( nPartId, b3Raw) +-- for nInd = 1, #vPartProc do +-- if LapJoint.Identify( vPartProc[nInd]) then +-- local nFacOpt, dMinElev, nFacOpt2, dMinElev2 = WL.GetFaceWithMostAdj( vPartProc[nInd].Id, vPartProc[nInd].PartId) +-- if nFacOpt >= 0 then +-- local vtN = EgtSurfTmFacetNormVersor( vPartProc[nInd].Id, nFacOpt, GDB_ID.ROOT) +-- if vtN:getZ() < -0.09 then +-- bFtDown = true +-- break +-- end +-- end +-- end +-- end +-- -- ruoto se necessario +-- if bFtDown then +-- local b3Solid = EgtGetBBoxGlob(nPartId, GDB_BB.IGNORE_TEXT) +-- local ptRotCen = b3Solid:getCenter() +-- EgtRotate( nPartId, ptRotCen, X_AX(), 180, GDB_RT.GLOB) +-- end + + -- recupero contorno + local nOutlineLayer = EgtGetFirstNameInGroup(nPartId, "Outline") + -- elimino vecchio contorno se gia' presente + local nOldOutline = EgtGetFirstNameInGroup(nOutlineLayer, 'ON_TMP') + EgtErase(nOldOutline or GDB_ID.NULL) + + -- Recupero o ricalcolo il solido + local SolidId = EgtBeamGetSolid( nPartId) + if not SolidId or not EgtGetInfo( SolidId, 'VALID') then + EgtBeamCalcSolid( nPartId, true) + SolidId = EgtBeamGetSolid( nPartId) + end + local nOutline, nCnt = EgtGetSurfTmSilhouette( SolidId, Z_AX(), 10, nOutlineLayer, GDB_RT.GLOB) + EgtBeamShowSolid( nPartId, false) + --EgtSaveFile("c:\\Temp\\ProvaNesting.nge") + + local nCurrOutline = nOutline + if nCnt > 0 then + local frSum + EgtScale( nOutline, GLOB_FRM(), 1, 1, 0, GDB_RT.GLOB) + EgtModifyCurveExtrusion( nOutline, Z_AX(), GDB_RT.GLOB) + + -- verifico che la prima curva sia l'unico loop esterno + local vCrvRef = EgtCurveArea( nOutline) + for nInd = 1, nCnt - 1 do + local vCrv = EgtCurveArea( nOutline + nInd) + -- se trovo più loop esterni uso come contorno quello del box (quindi forzo nCurrOutline a nil) + if abs( vCrv * vCrvRef - 1) < GEO.EPS_SMALL then + nCurrOutline = nil + break + end + end + + --local frSum = EgtSurfFlatRegion(nOutlineLayer, nOutline) + --EgtSaveFile("c:\\Temp\\ProvaNesting.nge") + -- -- per ogni contorno creo flat region e le sommo + -- for nIndex = 0, nCnt - 1 do + -- EgtScale( nOutline + nIndex, GLOB_FRM(), 1, 1, 0, GDB_RT.GLOB) + -- EgtModifyCurveExtrusion( nOutline + nIndex, Z_AX(), GDB_RT.GLOB) + -- local frCurr = EgtSurfFlatRegion(nOutlineLayer, nOutline + nIndex) + -- if frCurr then + -- if frSum then + -- EgtSurfFrAdd(frSum, frCurr) + -- else + -- frSum = frCurr + -- end + -- end + -- EgtErase(frCurr) + -- end + -- --EgtSaveFile("c:/Temp/ProvaNesting.nge") + -- -- calcolo contorno della flat region somma + -- nCurrOutline = EgtExtractSurfFrChunkLoops(frSum, 0, nOutlineLayer) + -- EgtErase(frSum) + -- -- cancello contorni + -- for nIndex = 0, nCnt do + -- EgtErase(nOutline + nIndex) + -- end + end + + if nCurrOutline and nCurrOutline ~= GDB_ID.NULL then + nOutline = nCurrOutline + else + -- se non ho trovato contorno, lo recupero dal Box + local nBoxLayer = EgtGetFirstNameInGroup(nPartId, "Box") + local nBox = EgtGetFirstNameInGroup(nBoxLayer, "Box") + local BBox = EgtGetBBoxGlob(nBox, GDB_BB.STANDARD) + nOutline = EgtRectangle2P(nOutlineLayer, Point3d( BBox:getMin():getX(), BBox:getMin():getY(), 0), Point3d( BBox:getMax():getX(), BBox:getMax():getY(), 0), GDB_RT.GLOB) + EgtOutLog("Impossible creating silhouette for part " .. tostring(nPartId)) + end + --if nCnt == 0 then + -- -- se non ho trovato contorno, lo recupero dal Box + -- local nBoxLayer = EgtGetFirstNameInGroup(nPartId, "Box") + -- local nBox = EgtGetFirstNameInGroup(nBoxLayer, "Box") + -- local BBox = EgtGetBBoxGlob(nBox, GDB_BB.STANDARD) + -- nOutline = EgtRectangle2P(nOutlineLayer, Point3d( BBox:getMin():getX(), BBox:getMin():getY(), 0), Point3d( BBox:getMax():getX(), BBox:getMax():getY(), 0), GDB_RT.GLOB) + -- EgtOutLog("Impossible creating silhouette for part " .. tostring(nPartId)) + --else + -- --EgtScale( nOutline, GLOB_FRM(), 1, 1, 0, GDB_RT.GLOB) + -- --EgtModifyCurveExtrusion( nOutline, Z_AX(), GDB_RT.GLOB) + -- --EgtSaveFile("c:/Temp/ProvaNesting.nge") + -- EgtScale( nOutline, GLOB_FRM(), 1, 1, 0, GDB_RT.GLOB) + -- EgtModifyCurveExtrusion( nOutline, Z_AX(), GDB_RT.GLOB) + -- local frSum = EgtSurfFlatRegion(nOutlineLayer, nOutline) + -- EgtSaveFile("c:\\Temp\\ProvaNesting.nge") + -- -- per ogni contorno creo flat region e le sommo + -- for nIndex = 1, nCnt - 1 do + -- EgtScale( nOutline + nIndex, GLOB_FRM(), 1, 1, 0, GDB_RT.GLOB) + -- EgtModifyCurveExtrusion( nOutline + nIndex, Z_AX(), GDB_RT.GLOB) + -- local frCurr = EgtSurfFlatRegion(nOutlineLayer, nOutline + nIndex) + -- if frCurr then + -- EgtSurfFrAdd(frSum, frCurr) + -- end + -- end + -- -- calcolo contorno della flat region somma + -- nOutline = EgtExtractSurfFrChunkLoops(frSum, 0, nOutlineLayer) + -- -- cancello contorni successivi + -- for nIndex = 1, nCnt do + -- EgtErase(nOutline + nIndex) + -- end + --end + + EgtSetName( nOutline, 'ON_TMP') + + --[[ local nOutline + local nTrimesh + local bFirst = true + local bSecond = false + local bUseBox = false + nTrimesh = EgtGetFirstNameInGroup( nOutlineLayer, "1-Out") + if not nTrimesh then + nTrimesh = EgtGetFirstNameInGroup( nOutlineLayer, "2-Out") + end + if not nTrimesh then + nTrimesh = EgtGetFirstNameInGroup( nOutlineLayer, "3-Out") + end + if not nTrimesh then + nTrimesh = EgtGetFirstNameInGroup( nOutlineLayer, "4-Out") + end + -- se trovato contorno + if nTrimesh then + -- recupero la curva associata + local nAuxId = EgtGetInfo(nTrimesh, "AUXID", 'i') + nOutline = nTrimesh + nAuxId + -- verifico che il contorno sia verticale + local nFacetCount = EgtSurfTmFacetCount(nTrimesh) + for nIndex = 0, nFacetCount - 1 do + local vtNorm = EgtSurfTmFacetNormVersor(nTrimesh, nIndex, GDB_ID.ROOT) + if abs( vtNorm:getZ()) > 10 * GEO.EPS_SMALL then + bUseBox = true + break + end + end + -- se due compo o una e lati inclinati + if bUseBox then + -- calcolo box della trimesh + local b3Outline = EgtGetBBoxGlob(nTrimesh, GDB_BB.IGNORE_TEXT) + local ptP1 = Point3d( b3Outline:getMin():getX(), b3Outline:getMin():getY(), 0) + local ptP2 = Point3d( b3Outline:getMax():getX(), b3Outline:getMax():getY(), 0) + -- creo outline del box + nOutline = EgtRectangle2P(nOutlineLayer, ptP1, ptP2, GDB_RT.GLOB) + EgtSetStatus(nOutline, GDB_ST.OFF) + end + -- altrimenti cerco la regione sopra + else + -- cancello precedenti contorni calcolati + local nOldONId = EgtGetFirstNameInGroup( nOutlineLayer, 'ON_TMP') + if nOldONId then + EgtErase( nOldONId) + end + -- cerco la regione sopra + local nReg + for i = 1, 4 do + local sRegName = string.format( '%d-Top', i) + nReg = EgtGetFirstNameInGroup( nOutlineLayer, sRegName) + if nReg then + local vtNorm = EgtSurfFrNormVersor( nReg, GDB_ID.ROOT) + if vtNorm:getZ() > 0.99 then break end + end + end + if not nReg then + EgtOutLog("Errore: regione superiore non trovata") + end + -- recupero contorno della regione + local OutId, nCnt = EgtExtractSurfFrChunkLoops( nReg, 0, nOutlineLayer) + if OutId and nCnt > 1 then + for i = 2, nCnt do + EgtErase( OutId + i - 1) + end + end + if OutId then + EgtSetName( OutId, 'ON_TMP') + nOutline = OutId + end + end + ]]-- + + + + + + if nOutline then + -- aggiungo pezzo al nesting + EgtAutoNestAddPart( nPartId, nOutline, false, bRotNest, nStepRotNest, 0, nCount) + -- EgtAutoNestAddPart( PartId, OutlineId, bCanFlip, bCanRotate, dRotStep, nPriority, nCount) + end + + -- aggiungo aree di lavorazione del pezzo + local nToolOutlineIds = ComputeToolOutlines( nPartId) + for nInd = 1, #nToolOutlineIds do + EgtAutoNestAddToolOutlineToPart( nPartId, nToolOutlineIds[nInd]) + end + + + -- verifico se anullato nesting + if EgtProcessEvents( 100 + ( nPartIndex / nTotParts * 100), 0) == 1 then + return false + end + -- se necessario ripristino flip e rotazioni del pezzo + if bFlip then + EgtRotate( nPartId, b3Part:getCenter(), X_AX(), -180, GDB_RT.GLOB) + end + if nRotate and nRotate > 0 then + EgtRotate( nPartId, b3Part:getCenter(), Z_AX(), -nRotate, GDB_RT.GLOB) + end + end + return true +end -- Inizializzo contatori errori e avvisi local nErrCnt = 0 local nWarnCnt = 0 +local bOk = true +NEST.ERR = 0 -- resetto gruppo di lavorazione corrente EgtResetCurrMachGroup() @@ -121,250 +729,45 @@ EgtResetCurrMachGroup() -- inizio nesting automatico EgtAutoNestStart() --- creo tabella dei grezzi +-- lista dei grezzi local RawParts = {} -for nIndex, nLen in pairs( LEN) do - table.insert(RawParts, {Len = nLen}) -end -for nIndex, nWidth in pairs( WIDTH) do - RawParts[tonumber(nIndex)].Width = nWidth -end -for nIndex, nQty in pairs( QTY) do - RawParts[tonumber(nIndex)].Qty = nQty -end -for nIndex, nMaterial in pairs( MATERIAL) do - RawParts[tonumber(nIndex)].Material = nMaterial + +-- creo grezzi e li aggiungo al nesting +AddRawParts(RawParts) + +if not bOk then + EgtOutLog("Interruzione nesting") + NEST.ERR = 1 end -local SheetPartIdList = {} - -local OUTLINE = "Outline" -for nIndex = 1, #RawParts do - -- creo pannello del materiale - local SheetPartId = EgtGroup(GDB_ID.ROOT) - table.insert(SheetPartIdList, SheetPartId) - EgtSetName(SheetPartId, "Sheet") - local SheetLayerId = EgtGroup(SheetPartId) - EgtSetName(SheetLayerId, OUTLINE) - local SheetOutlineId = EgtRectangle2P(SheetLayerId, Point3d(0,0,0), Point3d(RawParts[nIndex].Len, RawParts[nIndex].Width, 0), GDB_RT.GLOB) - -- EgtModifyCurveThickness(SheetOutlineId, -Material.T_mm) - EgtSetName(SheetOutlineId, OUTLINE) - - -- creo foglio per nesting - EgtAutoNestAddSheet( SheetPartId, SheetOutlineId, NEST.KERF, 0, RawParts[nIndex].Qty) -- EgtAutoNestAddSheet( SheetId, OutlineId, dKerf, nPriority, nCount) -end --- ciclo su pezzi per aggiungerli al nesting -for nPartId, nCount in pairs( PART) do - -- verifico se ruotare pareti - -- recupero le feature di lavorazione della parete - local bFtDown = false - local vPartProc = WE.CollectFeatures( nPartId, b3Raw) - for nInd = 1, #vPartProc do - if LapJoint.Identify( vPartProc[nInd]) then - local nFacOpt, dMinElev, nFacOpt2, dMinElev2 = WL.GetFaceWithMostAdj( vPartProc[nInd].Id, vPartProc[nInd].PartId) - if nFacOpt >= 0 then - local vtN = EgtSurfTmFacetNormVersor( vPartProc[nInd].Id, nFacOpt, GDB_ID.ROOT) - if vtN:getZ() < -0.09 then - bFtDown = true - break - end - end - end - end - -- ruoto se necessario - if bFtDown then - local b3Solid = EgtGetBBoxGlob(nPartId, GDB_BB.IGNORE_TEXT) - local ptRotCen = b3Solid:getCenter() - EgtRotate( nPartId, ptRotCen, X_AX(), 180, GDB_RT.GLOB) - end - - -- recupero contorno - local nOutlineLayer = EgtGetFirstNameInGroup(nPartId, "Outline") - -- elimino vecchio contorno se gia' presente - local nOldOutline = EgtGetFirstNameInGroup(nOutlineLayer, 'ON_TMP') - EgtErase(nOldOutline or GDB_ID.NULL) - - -- Recupero o ricalcolo il solido - local SolidId = EgtBeamGetSolid( nPartId) - if not SolidId or not EgtGetInfo( SolidId, 'VALID') then - EgtBeamCalcSolid( nPartId, true) - SolidId = EgtBeamGetSolid( nPartId) - end - local nOutline, nCnt = EgtGetSurfTmSilhouette( SolidId, Z_AX(), 10, nOutlineLayer, GDB_RT.GLOB) - EgtBeamShowSolid( nPartId, false) - EgtSaveFile("c:\\Temp\\ProvaNesting.nge") - - local nCurrOutline = nOutline - if nCnt > 0 then - local frSum - EgtScale( nOutline, GLOB_FRM(), 1, 1, 0, GDB_RT.GLOB) - EgtModifyCurveExtrusion( nOutline, Z_AX(), GDB_RT.GLOB) - --local frSum = EgtSurfFlatRegion(nOutlineLayer, nOutline) - --EgtSaveFile("c:\\Temp\\ProvaNesting.nge") --- -- per ogni contorno creo flat region e le sommo --- for nIndex = 0, nCnt - 1 do --- EgtScale( nOutline + nIndex, GLOB_FRM(), 1, 1, 0, GDB_RT.GLOB) --- EgtModifyCurveExtrusion( nOutline + nIndex, Z_AX(), GDB_RT.GLOB) --- local frCurr = EgtSurfFlatRegion(nOutlineLayer, nOutline + nIndex) --- if frCurr then --- if frSum then --- EgtSurfFrAdd(frSum, frCurr) --- else --- frSum = frCurr --- end --- end --- EgtErase(frCurr) --- end --- --EgtSaveFile("c:/Temp/ProvaNesting.nge") --- -- calcolo contorno della flat region somma --- nCurrOutline = EgtExtractSurfFrChunkLoops(frSum, 0, nOutlineLayer) --- EgtErase(frSum) --- -- cancello contorni --- for nIndex = 0, nCnt do --- EgtErase(nOutline + nIndex) --- end - end - - if nCurrOutline and nCurrOutline ~= GDB_ID.NULL then - nOutline = nCurrOutline - else - -- se non ho trovato contorno, lo recupero dal Box - local nBoxLayer = EgtGetFirstNameInGroup(nPartId, "Box") - local nBox = EgtGetFirstNameInGroup(nBoxLayer, "Box") - local BBox = EgtGetBBoxGlob(nBox, GDB_BB.STANDARD) - nOutline = EgtRectangle2P(nOutlineLayer, Point3d( BBox:getMin():getX(), BBox:getMin():getY(), 0), Point3d( BBox:getMax():getX(), BBox:getMax():getY(), 0), GDB_RT.GLOB) - EgtOutLog("Impossible creating silhouette for part " .. tostring(nPartId)) - end - --if nCnt == 0 then - -- -- se non ho trovato contorno, lo recupero dal Box - -- local nBoxLayer = EgtGetFirstNameInGroup(nPartId, "Box") - -- local nBox = EgtGetFirstNameInGroup(nBoxLayer, "Box") - -- local BBox = EgtGetBBoxGlob(nBox, GDB_BB.STANDARD) - -- nOutline = EgtRectangle2P(nOutlineLayer, Point3d( BBox:getMin():getX(), BBox:getMin():getY(), 0), Point3d( BBox:getMax():getX(), BBox:getMax():getY(), 0), GDB_RT.GLOB) - -- EgtOutLog("Impossible creating silhouette for part " .. tostring(nPartId)) - --else - -- --EgtScale( nOutline, GLOB_FRM(), 1, 1, 0, GDB_RT.GLOB) - -- --EgtModifyCurveExtrusion( nOutline, Z_AX(), GDB_RT.GLOB) - -- --EgtSaveFile("c:/Temp/ProvaNesting.nge") - -- EgtScale( nOutline, GLOB_FRM(), 1, 1, 0, GDB_RT.GLOB) - -- EgtModifyCurveExtrusion( nOutline, Z_AX(), GDB_RT.GLOB) - -- local frSum = EgtSurfFlatRegion(nOutlineLayer, nOutline) - -- EgtSaveFile("c:\\Temp\\ProvaNesting.nge") - -- -- per ogni contorno creo flat region e le sommo - -- for nIndex = 1, nCnt - 1 do - -- EgtScale( nOutline + nIndex, GLOB_FRM(), 1, 1, 0, GDB_RT.GLOB) - -- EgtModifyCurveExtrusion( nOutline + nIndex, Z_AX(), GDB_RT.GLOB) - -- local frCurr = EgtSurfFlatRegion(nOutlineLayer, nOutline + nIndex) - -- if frCurr then - -- EgtSurfFrAdd(frSum, frCurr) - -- end - -- end - -- -- calcolo contorno della flat region somma - -- nOutline = EgtExtractSurfFrChunkLoops(frSum, 0, nOutlineLayer) - -- -- cancello contorni successivi - -- for nIndex = 1, nCnt do - -- EgtErase(nOutline + nIndex) - -- end - --end - - EgtSetName( nOutline, 'ON_TMP') - ---[[ local nOutline - local nTrimesh - local bFirst = true - local bSecond = false - local bUseBox = false - nTrimesh = EgtGetFirstNameInGroup( nOutlineLayer, "1-Out") - if not nTrimesh then - nTrimesh = EgtGetFirstNameInGroup( nOutlineLayer, "2-Out") - end - if not nTrimesh then - nTrimesh = EgtGetFirstNameInGroup( nOutlineLayer, "3-Out") - end - if not nTrimesh then - nTrimesh = EgtGetFirstNameInGroup( nOutlineLayer, "4-Out") - end - -- se trovato contorno - if nTrimesh then - -- recupero la curva associata - local nAuxId = EgtGetInfo(nTrimesh, "AUXID", 'i') - nOutline = nTrimesh + nAuxId - -- verifico che il contorno sia verticale - local nFacetCount = EgtSurfTmFacetCount(nTrimesh) - for nIndex = 0, nFacetCount - 1 do - local vtNorm = EgtSurfTmFacetNormVersor(nTrimesh, nIndex, GDB_ID.ROOT) - if abs( vtNorm:getZ()) > 10 * GEO.EPS_SMALL then - bUseBox = true - break - end - end - -- se due compo o una e lati inclinati - if bUseBox then - -- calcolo box della trimesh - local b3Outline = EgtGetBBoxGlob(nTrimesh, GDB_BB.IGNORE_TEXT) - local ptP1 = Point3d( b3Outline:getMin():getX(), b3Outline:getMin():getY(), 0) - local ptP2 = Point3d( b3Outline:getMax():getX(), b3Outline:getMax():getY(), 0) - -- creo outline del box - nOutline = EgtRectangle2P(nOutlineLayer, ptP1, ptP2, GDB_RT.GLOB) - EgtSetStatus(nOutline, GDB_ST.OFF) - end - -- altrimenti cerco la regione sopra - else - -- cancello precedenti contorni calcolati - local nOldONId = EgtGetFirstNameInGroup( nOutlineLayer, 'ON_TMP') - if nOldONId then - EgtErase( nOldONId) - end - -- cerco la regione sopra - local nReg - for i = 1, 4 do - local sRegName = string.format( '%d-Top', i) - nReg = EgtGetFirstNameInGroup( nOutlineLayer, sRegName) - if nReg then - local vtNorm = EgtSurfFrNormVersor( nReg, GDB_ID.ROOT) - if vtNorm:getZ() > 0.99 then break end - end - end - if not nReg then - EgtOutLog("Errore: regione superiore non trovata") - end - -- recupero contorno della regione - local OutId, nCnt = EgtExtractSurfFrChunkLoops( nReg, 0, nOutlineLayer) - if OutId and nCnt > 1 then - for i = 2, nCnt do - EgtErase( OutId + i - 1) - end - end - if OutId then - EgtSetName( OutId, 'ON_TMP') - nOutline = OutId - end - end -]]-- - if nOutline then - -- aggiungo pezzo al nesting - EgtAutoNestAddPart( nPartId, nOutline, false, true, 90, 0, nCount) - -- EgtAutoNestAddPart( PartId, OutlineId, bCanFlip, bCanRotate, dRotStep, nPriority, nCount) - end +-- calcolo rotazioni e flip ed aggiungo pezzi al nesting +if bOk then + bOk = AddParts(RawParts) end --- aggiungo offset tra pezzi -EgtAutoNestSetInterpartGap(NEST.OFFSET) +if not bOk then + EgtOutLog("Interruzione nesting") + NEST.ERR = 1 +end --- Impostazione corner di inizio del nesting (NST_CORNER.BL, TL, BR, TR) -EgtAutoNestSetStartCorner( NST_CORNER.BR) +if bOk then + -- aggiungo offset tra pezzi + EgtAutoNestSetInterpartGap(NEST.OFFSET) -local nMaxTime = 5 --- imposto tempo di nesting e lo avvio -EgtAutoNestCompute(true, NEST.TIME) + -- Impostazione corner di inizio del nesting (NST_CORNER.BL, TL, BR, TR) + EgtAutoNestSetStartCorner( NST_CORNER.BR) + + -- imposto tempo di nesting e lo avvio + EgtAutoNestCompute(true, NEST.TIME) +end -- Variabili di calcolo local nNestedParts, nParts, nSheets, nNestings, dTotFillRatio +local bNestingOk = bOk -- Attesa fine calcolo -local bOk = true local nTime = 0 -while bOk do - bOk, nStat = EgtAutoNestGetComputationStatus() +while bNestingOk do + bNestingOk, nStat = EgtAutoNestGetComputationStatus() if nStat == 2 or nStat == 3 then nNestedParts, nParts, nSheets, nNestings, dTotFillRatio = EgtAutoNestGetResults() --EgtOutText( string.format( 'Parts : %d/%d Filling : %.2f%%', nNestedParts, nParts, 100 * dTotFillRatio)) @@ -372,13 +775,16 @@ while bOk do if nStat == 3 then break end nTime = nTime + 1 if EgtProcessEvents( nTime / NEST.TIME * 100, 995) == 1 then - bOk = EgtAutoNestCancelComputation() + bNestingOk = EgtAutoNestCancelComputation() + bOk = false + EgtOutLog("Interruzione nesting") + NEST.ERR = 1 break end end -- se nesting andato bene -if bOk then +if bNestingOk then -- disposizione sheet e parts local SheetId = GDB_ID.NULL @@ -395,33 +801,53 @@ if bOk then -- creo gruppo di lavorazione local MachGroupName = NewMachGroupName() nMachGroup = EgtAddMachGroup(MachGroupName, sCurrMachName) - EgtSetInfo(nMachGroup, "PANELLEN", RawParts[nType].Len) - EgtSetInfo(nMachGroup, "PANELWIDTH", RawParts[nType].Width) - EgtSetInfo(nMachGroup, "MATERIAL", RawParts[nType].Material) - EgtSetInfo(nMachGroup, "AUTONEST", 1) + for nIndex = 1, #RawParts do + if RawParts[nIndex].PartId == nId then + EgtSetInfo(nMachGroup, "PANELLEN", RawParts[nIndex].Len) + EgtSetInfo(nMachGroup, "PANELWIDTH", RawParts[nIndex].Width) + EgtSetInfo(nMachGroup, "MATERIAL", RawParts[nIndex].Material) + EgtSetInfo(nMachGroup, "AUTONEST", 1) + end + end nPartCount = 0 -- altrimenti pezzo else - local PartId = nId nPartCount = nPartCount + 1 -- se c'e' un grezzo valido if nMachGroup and nMachGroup ~= GDB_ID.NULL then -- creo pezzo copia local nPartDuploId = EgtDuploNew( nId) + -- applico flip e rotazioni fatte durante verifica posizionamento pezzo + local b3Part = EgtGetBBoxGlob( nPartDuploId, GDB_BB.STANDARD) + local nPartInd + for nInd = 1, #PartStates do + if PartStates[nInd].PartId == nId then + if PartStates[nInd].Flip then + EgtRotate( nPartDuploId, b3Part:getCenter(), X_AX(), 180, GDB_RT.GLOB) + end + if PartStates[nInd].Rotate and PartStates[nInd].Rotate > 0 then + EgtRotate( nPartDuploId, b3Part:getCenter(), Z_AX(), PartStates[nInd].Rotate, GDB_RT.GLOB) + end + nPartInd = nInd + end + end + -- applico rotazione e traslazione pezzo da nesting EgtRotate( nPartDuploId, ORIG(), Z_AX(), dAngRot, GDB_RT.GLOB) EgtMove( nPartDuploId, Vector3d( dX, dY, 0), GDB_RT.GLOB) local PartBBox = EgtGetBBoxGlob( nPartDuploId, GDB_BB.STANDARD) local ptPos = Point3d( PartBBox:getMin():getX(), PartBBox:getMin():getY(), 0) - EgtSetInfo( nMachGroup, "PART" .. nPartCount, nPartDuploId .. "," .. EgtNumToString( ptPos:getX(), 3) .. "," .. EgtNumToString( ptPos:getY(), 3) .. "," .. 0 .. "," .. 0) + EgtSetInfo( nMachGroup, "PART" .. nPartCount, nPartDuploId .. "," .. EgtNumToString( ptPos:getX(), 3) .. "," .. EgtNumToString( ptPos:getY(), 3) .. "," .. 0 .."," .. 0) EgtSetInfo( nPartDuploId, "POSX", ptPos:getX()) EgtSetInfo( nPartDuploId, "POSY", ptPos:getY()) - EgtSetInfo( nPartDuploId, "ROT", dAngRot) - EgtSetInfo( nPartDuploId, "FLIP", 0) + EgtSetInfo( nPartDuploId, "ROT", dAngRot + PartStates[nPartInd].Rotate) + EgtSetInfo( nPartDuploId, "FLIP", PartStates[nPartInd].Flip) end end end - -- creo grezzi per ogni gruppo di lavorazione + -- creo grezzi per ogni gruppo di lavorazione + local MachGroupToTCnt = EgtGetMachGroupCount() + local MachGroupIndex = 0 _G.WALL = {} WALL.FILE = NEST.FILE WALL.MACHINE = NEST.MACHINE @@ -430,21 +856,30 @@ if bOk then while nMachGroup do EgtSetCurrMachGroup(nMachGroup) if EgtGetInfo(nMachGroup, "AUTONEST",'i') == 1 then + MachGroupIndex = MachGroupIndex + 1 EgtRemoveInfo(nMachGroup, "AUTONEST") EgtSetInfo(nMachGroup, "UPDATEUI", 1) dofile(EgtGetSourceDir() .. "BatchProcessNew.lua") + -- aggiorno interfaccia + EgtProcessEvents( 200 + ( MachGroupIndex / MachGroupToTCnt * 100), 0) end nMachGroup = EgtGetNextMachGroup(nMachGroup) end else EgtOutLog("Errore: nesting fallito") + NEST.ERR = 2 end EgtResetCurrMachGroup() --- nascondo rettangolo del materiale per nesting -for SheetPartId = 1, #SheetPartIdList do - EgtErase(SheetPartIdList[SheetPartId]) -end + + +-- cancello rettangolo del materiale per nesting + for RawPartId = 1, #RawParts do + EgtErase(RawParts[RawPartId].PartId) + end + +local nOutlineGrp = EgtGetFirstNameInGroup(GDB_ID.ROOT, "ToolOutlines") +if nOutlineGrp and nOutlineGrp ~= GDB_ID.NULL then EgtErase( nOutlineGrp) end -- EgtSaveFile("c:\\Temp\\Prova1.nge") EgtOutLog( ' +++ NestProcess completed')