diff --git a/LuaLibs/BeamExec.lua b/LuaLibs/BeamExec.lua index d9eeb9a..d003a51 100644 --- a/LuaLibs/BeamExec.lua +++ b/LuaLibs/BeamExec.lua @@ -35,8 +35,9 @@ -- 2022/08/01 Tolleranza su sezione portata a 0.1 mm (100 * GEO.EPS_SMALL). -- 2022/08/08 Modifica per macchine senza BD.MAX_WIDTH2 e BD.MAX_HEIGHT2. -- 2022/08/18 Aggiunta gestione macchine con testa da sotto con lama da sotto disabilitata. --- 2022/09/21 Nella funzione di ordinamento il foro del birdsmouth viene sempre fatto prima della lavorazione stessa -- 2022/09/28 I fori vengono sempre fatti prima delle tacche. +-- 2022/09/29 Aggiunta la ricerca di feature specchiate, al momento solo per DtMortise, con le relative funzioni. + -- Tabella per definizione modulo local BeamExec = {} @@ -1368,6 +1369,108 @@ local function MoveDrillsOnTenon( vProc) end end +------------------------------------------------------------------------------------------------------------- +-- Estrazione parametri P da lavorazioni di tipo DtMortise +local function GetPParametersDtMortise( Proc) + local vPParameters = { + { 'P01', 'd'}, + { 'P02', 'd'}, + { 'P03', 'd'}, + { 'P04', 'i'}, + { 'P05', 'i'}, + { 'P06', 'd'}, + { 'P07', 'd'}, + { 'P09', 'd'}, + { 'P10', 'd'}, + { 'P11', 'd'}, + { 'P12', 'd'}, + { 'P13', 'd'}, + { 'P14', 'd'}, + { 'P15', 'd'} + } + for i = 1, #vPParameters do + vPParameter = vPParameters[i] + vPParameter[3] = EgtGetInfo( Proc.Id, vPParameter[1], vPParameter[2]) + end + return vPParameters +end + +------------------------------------------------------------------------------------------------------------- +-- Controlla se la feature ProcMirror è la specchiata di Proc, per feature di tipo DtMortise +local function CheckMirrorDtMortise( Proc, ProcMirror, dHBeam) + local bIsMirror = true + local vPParametersProc = GetPParametersDtMortise( Proc) + local vPParametersMirror = GetPParametersDtMortise( ProcMirror) + local nP02, nP06 = 2, 6 + -- controllo che i parametri P delle due feature, tranne P02 e P06, siano uguali + for i = 1, #vPParametersProc do + local vPParameterProc = vPParametersProc[i] + local vPParameterMirror = vPParametersMirror[i] + if vPParameterProc[1] ~= 'P02' and vPParameterProc[1] ~= 'P06'then + bIsMirror = ( abs( vPParameterProc[3] - vPParameterMirror[3]) < 100 * GEO.EPS_SMALL) + if bIsMirror == false then break end + elseif vPParameterProc[1] == 'P02' then + nP02 = i + elseif vPParameterProc[1] == 'P06' then + nP06 = i + end + end + -- se gli altri parametri P sono uguali, verifico che P02 e P06 siano compatibili con feature specchiate + if bIsMirror == true then + bIsMirror = ( ( vPParametersProc[nP02][3] == 0 and abs( vPParametersMirror[nP02][3] - dHBeam) < 100 * GEO.EPS_SMALL) and + ( vPParametersProc[nP06][3] == 90 and vPParametersMirror[nP06][3] == -90)) or + ( ( vPParametersMirror[nP02][3] == 0 and abs( vPParametersProc[nP02][3] - dHBeam) < 100 * GEO.EPS_SMALL) and + ( vPParametersMirror[nP06][3] == 90 and vPParametersProc[nP06][3] == -90)) + end + return bIsMirror +end + +------------------------------------------------------------------------------------------------------------- +-- Cerca se esiste una feature specchiata di Proc e nel caso ne restituisce la posizione in vProc +local function FindMirrorFeature( vProc, Proc, sFeatureType, dHBeam) + local nProcMirror + -- se mortasa a coda di rondine + if sFeatureType == 'DtMortise' then + Proc.Side = EgtGetInfo( Proc.Id, 'SIDE', 'i') + for i = 1, #vProc do + local ProcMirror = vProc[i] + if DtMortise.SideIdentify(ProcMirror) then + ProcMirror.Side = EgtGetInfo( ProcMirror.Id, 'SIDE', 'i') + if ( Proc.Side == 1 and ProcMirror.Side == 3) or ( Proc.Side == 3 and ProcMirror.Side == 1) or + ( Proc.Side == 2 and ProcMirror.Side == 4) or ( Proc.Side == 4 and ProcMirror.Side == 2) then + local bIsMirror = CheckMirrorDtMortise( Proc, ProcMirror, dHBeam) + if bIsMirror then nProcMirror = i end + end + end + end + end + -- se foratura (da implementare) + return nProcMirror +end + +------------------------------------------------------------------------------------------------------------- +-- Cerca in vProc la presenza di feature specchiate. Se le trova scrive in Proc e nelle info l'Id della specchiata. +local function SetMirroredFeatures( vProc, dHBeam) + for i = 1, #vProc do + local Proc = vProc[i] + local sFeatureType + if DtMortise.SideIdentify(Proc) then + sFeatureType = 'DtMortise' + elseif Drill.Identify(Proc) then + sFeatureType = 'Drill' + end + if ( sFeatureType == 'DtMortise' or sFeatureType == 'Drill') and not Proc.MirrorId then + local nProcMirror = FindMirrorFeature( vProc, Proc, sFeatureType, dHBeam) + if nProcMirror then + Proc.MirrorId = vProc[nProcMirror].Id + vProc[nProcMirror].MirrorId = Proc.Id + EgtSetInfo( Proc.Id, 'MIRRORID', vProc[nProcMirror].Id) + EgtSetInfo( vProc[nProcMirror].Id, 'MIRRORID', Proc.Id) + end + end + end +end + ------------------------------------------------------------------------------------------------------------- -- verifica se ci sono forature da lavorare dopo tagli di testa o coda e nel caso le classifica come Head o Tail e gli assegna l'Id della rispettiva feature di taglio local function SetDrillingsToMachineAfterHeadOrTailCut( vProc, vMachineBeforeIntersectingDrillings) @@ -1462,6 +1565,11 @@ function BeamExec.ProcessFeatures() if BD.IMPROVE_HEAD_TAIL_DRILLINGS then SetDrillingsToMachineAfterHeadOrTailCut( vProc, vMachineBeforeIntersectingDrillings) end + -- verifica presenza di feature specchiate per eventuali lavorazioni simultanee + local bConcurrentDoubleHead = BD.DOUBLE_HEAD_MIRRORED_FEATURES and ( BD.TWO_EQUAL_HEADS or BD.TWO_UP_DOWN_HEADS) + if bConcurrentDoubleHead then + SetMirroredFeatures( vProc, EgtGetRawPartBBox( nRawId):getDimZ()) + end -- le ordino lungo X OrderFeatures( vProc, b3Raw) -- le classifico diff --git a/LuaLibs/MachiningLib.lua b/LuaLibs/MachiningLib.lua index 8d1bc16..b4faff5 100644 --- a/LuaLibs/MachiningLib.lua +++ b/LuaLibs/MachiningLib.lua @@ -3,6 +3,7 @@ -- 2022/05/07 ES Profonde modifiche per scelta ottimale lavorazioni in macchine con più teste. -- 2022/07/27 Aggiunta la gestione del tipo di foratura "AngleDrill" per fori molto inclinati -- 2022/11/02 Modificata scelta utensile ottimizzata. Ora se c'è un utensile più grande disponibile si dà preferenza a quello. +-- 2022/11/25 Per FindMilling implementata la possibilità di escludere la testa H3 dalla ricerca utensile. -- Tabella per definizione modulo local MachiningLib = {} @@ -108,8 +109,9 @@ local function SetCurrMachiningAndTool( sMachName) local sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD) local nHead = tonumber( sHead:sub( 2, #sHead)) local bH2 = ( nHead >= 21 and nHead <= 29) + local bH3 = ( nHead >= 31 and nHead <= 39) local bFixed = ( vFixedHeads[nHead]) - return bActive, sTool, bH2, bFixed + return bActive, sTool, bH2, bFixed, bH3 end --------------------------------------------------------------------- @@ -222,7 +224,7 @@ function ReturnParams( MachiningType, MachiningName, sType, ToolParams) end --------------------------------------------------------------------- -local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead) +local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead, bExcludeH3) if bTopHead == nil and bDownHead == nil then bTopHead = true bDownHead = false @@ -273,8 +275,8 @@ local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead) _, sMachiningType = EgtEndsWith( Machining.Type, '_H2') end -- recupero dati utensile - local bToolActive, sToolName, bH2, bFixed = SetCurrMachiningAndTool( Machining.Name) - if Machining.On and sMachiningType == sType and bToolActive then + local bToolActive, sToolName, bH2, bFixed, bH3 = SetCurrMachiningAndTool( Machining.Name) + if Machining.On and sMachiningType == sType and bToolActive and ( not bH3 or bH3 == not bExcludeH3) then local bOk, ToolParams = VerifyTool( MachiningType, sType, Params, bH2) if bOk then if MachineHeadUse == ONE_HEAD then @@ -384,8 +386,8 @@ function MachiningLib.FindAngleDrilling( dDiam, dDepth, bTopHead, bDownHead) end --------------------------------------------------------------------- -function MachiningLib.FindMilling( sType, dDepth, sTuuidMstr, dMaxDiam, dMaxTotLen, bTopHead, bDownHead) - return FindMachining( MCH_MY.MILLING, sType, { Depth = dDepth, TuuidMstr = sTuuidMstr, MaxDiam = dMaxDiam, MaxTotLen = dMaxTotLen}, bTopHead, bDownHead) +function MachiningLib.FindMilling( sType, dDepth, sTuuidMstr, dMaxDiam, dMaxTotLen, bTopHead, bDownHead, bExcludeH3) + return FindMachining( MCH_MY.MILLING, sType, { Depth = dDepth, TuuidMstr = sTuuidMstr, MaxDiam = dMaxDiam, MaxTotLen = dMaxTotLen}, bTopHead, bDownHead, bExcludeH3) end --------------------------------------------------------------------- diff --git a/LuaLibs/ProcessDrill.lua b/LuaLibs/ProcessDrill.lua index 6f318eb..2e3714c 100644 --- a/LuaLibs/ProcessDrill.lua +++ b/LuaLibs/ProcessDrill.lua @@ -14,6 +14,7 @@ -- 2022/07/27 Aggiunta la gestione del tipo di foratura "AngleDrill" per fori molto inclinati -- 2022/08/18 Aggiunta gestione macchine con testa da sotto e punta disabilitata. -- 2022/10/25 Nella funzione Split aggiunto il controllo che le facce di ingresso e uscita siano differenti (potrebbe succedere per fori molto corti). Modifica importatore in futuro. +-- 2022/11/23 Aggiunta la gestione dei fori con angolo < 30 gradi, per i quali si usa la testa della macchina per accorciare l'utile di lavoro. -- Tabella per definizione modulo local ProcessDrill = {} @@ -267,7 +268,7 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId) local nErrorCode = 0 -- abilitazione foratura da sotto local bDrillDown = ( bDownDrill and ( Proc.Down or vtExtr:getZ() < -0.1 or vtExtr:getZ() < 0.259)) - local bDrillUp = ( bDownDrill and vtExtr:getZ() > -0.5) + local bDrillUp = ( bDownDrill and vtExtr:getZ() > -0.421) -- primo gruppo di controlli con lunghezza utensile pari a metà foro se passante -- recupero la lavorazione local sDrilling, sType, dMaxDepth, dMaxToolLength, dToolDiam, dDiamTh, dToolFreeLen = ML.FindDrilling( dDiam, dCheckDepth, bDrillUp, bDrillDown) @@ -370,10 +371,14 @@ function ProcessDrill.Make( Proc, nPhase, nRawId, nPartId) -- Calcolo acciorciamento affondamento utile per evitare collisione portautensile con faccia local TgA = CosB / sqrt( 1 - CosB * CosB) local dSubL = ( dDiamTh / 2 + ( Proc.Diam - dToolDiam) / 2 + 2) * TgA + -- Per fori molto inclinati ( < 30 gradi) si usa la testa della macchina per l'accorciamento. Fast esclusa + if BD.C_SIMM and CosB > 0.866 then + dSubL = ( 190 / 2 + ( Proc.Diam - dToolDiam) / 2 + 2) * TgA - 96 + end local dMaxDepthOri = dMaxDepth - dMaxDepth = min( dMaxDepth, dToolFreeLen - dSubL) + dMaxDepth = min( dMaxDepth, max( dToolFreeLen - dSubL, 0)) -- Verifico inclinazione foro nei limiti - local bTryDrill = ( CosB < BD.DRILL_VX_MAX) + local bTryDrill = EgtIf( dMaxDepth > 0, ( CosB < BD.DRILL_VX_MAX), false) if ( CosB > 0.8 * BD.DRILL_VX_MAX and CosB < BD.DRILL_VX_MAX_ANGLEDRILL) then -- cerco le forature speciali AngleDrill local sDrilling3, sType3, dMaxDepth3 = ML.FindAngleDrilling( dDiam, dCheckDepth, bDrillUp, bDrillDown) diff --git a/LuaLibs/ProcessDtMortise.lua b/LuaLibs/ProcessDtMortise.lua index def01c1..e7ebb09 100644 --- a/LuaLibs/ProcessDtMortise.lua +++ b/LuaLibs/ProcessDtMortise.lua @@ -7,6 +7,7 @@ -- 2021/12/01 Se frontale aggiungo taglio con Grp e Proc di vero taglio (per aggiornare ingombro di testa /coda). -- 2022/06/01 Modifiche per evitare di entrare nel legno con mortase parziali. -- 2022/08/18 Migliorato calcolo dello step. +-- 2022/09/29 Aggiunto riconoscimento della sola feature laterale. -- Tabella per definizione modulo local ProcessDtMortise = {} @@ -39,6 +40,12 @@ function ProcessDtMortise.FrontIdentify( Proc) return (( Proc.Grp == 3 or Proc.Grp == 4) and Proc.Prc == 56) end +--------------------------------------------------------------------- +-- Riconoscimento della sola feature laterale +function ProcessDtMortise.SideIdentify( Proc) + return (( Proc.Grp == 3 or Proc.Grp == 4) and Proc.Prc == 55) +end + --------------------------------------------------------------------- -- Verifica se feature di coda function ProcessDtMortise.IsTailFeature( Proc, b3Raw) diff --git a/LuaLibs/ProcessFreeContour.lua b/LuaLibs/ProcessFreeContour.lua index b681f39..9352d5c 100644 --- a/LuaLibs/ProcessFreeContour.lua +++ b/LuaLibs/ProcessFreeContour.lua @@ -4,6 +4,8 @@ -- 2022/09/21 In MakeByMill aggiunto messaggio per elevazione non raggiunta. -- 2022/11/03 In MakeByMill migliorata gestione lavorazione con fresa su testa da sotto. -- 2022/11/09 Aggiunta la gestione della chiamata della FreeContour da parte della SimpleScarf. +-- 2022/11/24 In MakeByMill aggiunta la lavorazione sopra/sotto nel caso di testa sotto +-- In MakeByMill se BeamData forza lettura codolo da Q questo viene sempre fatto indipendentemente dalle dimensioni della feature -- Tabella per definizione modulo @@ -121,7 +123,7 @@ function ProcessFreeContour.Classify( Proc, b3Raw) end --------------------------------------------------------------------- -local function VerifyChamfer( Proc, AuxId, nRawId, bMakeVertCham) +local function VerifyChamfer( Proc, AuxId, nRawId, bMakeVertCham, bDownHead) local nChamfer = 0 -- ingombro del grezzo local b3Raw = EgtGetRawPartBBox( nRawId) @@ -161,7 +163,11 @@ local function VerifyChamfer( Proc, AuxId, nRawId, bMakeVertCham) -- recupero la lavorazione local sMilling if nChamfer > 0 then - sMilling = ML.FindMilling( 'Mark') + if bDownHead then + sMilling = ML.FindMilling( 'Mark_H2', nil, nil, nil, nil, false, true) + else + sMilling = ML.FindMilling( 'Mark') + end if not sMilling then local sErr = 'Error : Mark not found in library' EgtOutLog( sErr) @@ -302,15 +308,15 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) end local dOriDepth = dDepth local nDouble = 1 - local bCanDouble = ( abs( vtExtr:getY()) > abs( vtExtr:getZ()) and bCross) + local bCanDouble = ( abs( vtExtr:getY()) > abs( vtExtr:getZ()) and bCross) or ( BD.DOWN_HEAD and bCross) local dDimStrip = BD.DIM_STRIP if dDimStrip < 0 then dDimStrip = EgtGetInfo( Proc.Id, Q_DIM_STRIP, 'd') or 0 end local bStripOnSide = false if bCross then - -- se chiamata da SimpleScarf il codolo è sempre attivo - if dDimStrip > 10 * GEO.EPS_SMALL and ( nStep > 1 or ( bDown and b3Aux:getDimX() > 0.5 * b3Raw:getDimX()) or Proc.Prc == 70) then + -- se forzata da parametro Q il codolo è sempre attivo + if dDimStrip > 10 * GEO.EPS_SMALL and ( BD.DIM_STRIP < 0 or nStep > 1 or ( bDown and b3Aux:getDimX() > 0.5 * b3Raw:getDimX())) then -- devo lasciare un codolo local dExtraCham = EgtIf( nChamfer > 0, 2, 0) dDepth = EgtIf( Proc.Prc == 70, dDepth - dDimStrip - dDepthCham - dExtraCham, dDepth - dDimStrip) @@ -322,8 +328,9 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) end local bIsDepthReduced = false -- se parametro beamdata forza codolo in centro e lavorazione orizzontale e se larghezza trave è sufficientemente larga - -- se chiamata da SimpleScarf il codolo è sempre attivo - if BD.DIM_TO_CENTER_STRIP and BD.DIM_TO_CENTER_STRIP > 10 * GEO.EPS_SMALL and ( nStep > 1 or Proc.Prc == 70) and + -- se forzata da parametro Q il codolo è sempre attivo + local dDepthWork = dDepth + if BD.DIM_TO_CENTER_STRIP and BD.DIM_TO_CENTER_STRIP > 10 * GEO.EPS_SMALL and ( BD.DIM_STRIP < 0 or nStep > 1) and bCanDouble and b3Raw:getDimY() > BD.DIM_TO_CENTER_STRIP - 0.1 then nDouble = 2 dDepth = min( ( b3Raw:getDimY() - dDimStrip) * 0.5, dMaxDepth) @@ -332,8 +339,9 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) if dDepth > dMaxDepth then if bCanDouble then nDouble = 2 - dDepth = min( 0.5 * dDepth, dMaxDepth) - if dDepth < 0.5 * dDepth - 10 * GEO.EPS_SMALL then + dDepthWork = 0.5 * dDepth + dDepth = min( dDepthWork, dMaxDepth) + if dDepth < dDepthWork - 10 * GEO.EPS_SMALL then bIsDepthReduced = true end else @@ -345,7 +353,7 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) local sWarn = '' -- se ho ridotto l'altezza emetto warning if bIsDepthReduced then - sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' (Free Contour) : elevation bigger than max tool depth' + sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' (Free Contour) : depth (' .. EgtNumToString( dDepthWork, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')' EgtOutLog( sWarn) end -- se utensile orizzontale verso Y+, non in doppio e codolo da lasciare, devo invertire per lavorare sempre da Y- @@ -361,11 +369,34 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) if nChamfer > 0 and Proc.Grp ~= 0 and dOriDepth > dDepthCham and Proc.Prc ~= 70 then local bDoubleCham = false local dExtra = 2 + local sChamferDown, sChamferUp + if nDouble > 1 and bCanDouble then + if nSide == 0 then + if BD.DOWN_HEAD then + -- recupero la lavorazione + local nChamferDown + nChamferDown, _, sChamferDown = VerifyChamfer( Proc, AuxId, nRawId, true, true) + if nChamferDown < 0 then + sWarn = 'Warning : chamfer from bottom not found in library' + sChamferDown = nil + EgtOutLog( sWarn) + end + end + local nChamferUp + nChamferUp, _, sChamferUp = VerifyChamfer( Proc, AuxId, nRawId, true, false) + if nChamferUp < 0 then + sWarn = 'Warning : chamfer from bottom not found in library' + sChamferUp = nil + EgtOutLog( sWarn) + end + end + end -- eseguo for i = 1, nStep do -- inserisco la lavorazione local sNameCh = 'Cham_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) - local nMchId = EgtAddMachining( sNameCh, sChamfer) + local sChamferSide1 = EgtIf( bDownHead, sChamferDown, sChamfer) + local nMchId = EgtAddMachining( sNameCh, sChamferSide1) if not nMchId then local sErr = 'Error adding machining ' .. sNameCh .. '-' .. sChamfer EgtOutLog( sErr) @@ -374,9 +405,6 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) -- aggiungo geometria EgtSetMachiningGeometry( {{ AuxId, -1}}) -- se lavorazione da sopra o da sotto - if nSide ~= 0 then - bDoubleCham = true - end if Proc.Grp == 3 then if not bToolInv then EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT) @@ -406,6 +434,11 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) end end end + if nSide == 0 then + bDoubleCham = EgtIf( sChamferDown and BD.DOWN_HEAD, true, false) + else + bDoubleCham = true + end -- assegno affondamento e offset radiale EgtSetMachiningParam( MCH_MP.DEPTH, dDepthCham + dExtra) EgtSetMachiningParam( MCH_MP.OFFSR, dExtra) @@ -445,12 +478,19 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) EgtSetOperationMode( nMchId, false) return false, sErr end - -- se lavorazione da due parti, aggiungo la seconda if bDoubleCham then -- inserisco la lavorazione local sName = 'ChamB_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) - local nMchId = EgtAddMachining( sName, sChamfer) + local sChamferSide2 + if EgtEndsWith( sChamferSide1, 'H2') then + sChamferSide2 = sChamferUp + elseif nSide == 0 then + sChamferSide2 = sChamferDown + else + sChamferSide2 = sChamfer + end + nMchId = EgtAddMachining( sName, sChamferSide2) if not nMchId then local sErr = 'Error adding machining ' .. sName .. '-' .. sChamfer EgtOutLog( sErr) @@ -511,6 +551,31 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) end -- verifico se devo fare sgrossatura più finitura local dOffsetPar = EgtGetInfo( Proc.Id, Q_OVERMAT_FOR_FINISH, 'i') or 0 + -- nel caso di lavorazioni sopra/sotto cerco lavorazioni specifiche + local sMillingDown, sMillingUp + if nDouble > 1 and bCanDouble then + if nSide == 0 then + if BD.DOWN_HEAD then + -- recupero la lavorazione + sMillingDown = ML.FindMilling( 'FreeContour_H2', nil, nil, nil, nil, false, true) + if not sMillingDown then + nDouble = 1 + dDepth = min( dOriDepth, dMaxDepth) + sWarn = 'Warning in process ' .. tostring( Proc.Id) .. ' (Free Contour) : milling from bottom not found in library' .. '\n' .. + '; depth (' .. EgtNumToString( dOriDepth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth, 1) .. ')' + EgtOutLog( sWarn) + elseif sMillingDown and not bDownHead then + bToolInv = true + sMilling = sMillingDown + end + end + sMillingUp = ML.FindMilling( 'FreeContour', nil, nil, nil, nil, true, false) + if not sMillingUp then + sWarn = 'Warning : milling not found in library' + EgtOutLog( sWarn) + end + end + end -- eseguo for i = 1, nStep do for j = 1, nDouble do @@ -535,7 +600,13 @@ local function MakeByMill( Proc, nPhase, nRawId, nPartId, dOvmHead) else -- inserisco la lavorazione sName = 'Free_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) - nMchId = EgtAddMachining( sName, sMilling) + if EgtEndsWith( sMilling, '_H2') then + nMchId = EgtAddMachining( sName, EgtIf( j == 2 and nSide == 0, sMillingUp, sMilling)) + elseif sMillingDown then + nMchId = EgtAddMachining( sName, EgtIf( j == 2 and nSide == 0, sMillingDown, sMilling)) + else + nMchId = EgtAddMachining( sName, sMilling) + end if not nMchId then local sErr = 'Error adding machining ' .. sName .. '-' .. sMilling EgtOutLog( sErr) diff --git a/LuaLibs/ProcessHeadCut.lua b/LuaLibs/ProcessHeadCut.lua index 2abb99a..51f397b 100644 --- a/LuaLibs/ProcessHeadCut.lua +++ b/LuaLibs/ProcessHeadCut.lua @@ -5,6 +5,7 @@ -- 2022/08/18 Aggiunta gestione macchine con testa da sotto con lama da sotto disabilitata. -- 2022/09/08 Migliorato verso di lavorazione in caso di DoubleCut -- 2022/11/02 Corretti accorciamenti per DoubleCut +-- 2022/11/10 Corrette finiture lama per BigSection con trave alta -- Tabella per definizione modulo local ProcessHeadCut = {} @@ -168,11 +169,13 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut -- recupero i dati dell'utensile local dSawDiam = 400 local dMaxDepth = 50 + local dSawThick = 2 if EgtMdbSetCurrMachining( sCutting) then local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then dSawDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth + dSawThick = EgtTdbGetCurrToolParam(MCH_TP.THICK) or dSawThick end end local dMaxVertDepth = dMaxDepth - ( BD.DECR_VERT_CUT or 0) @@ -181,20 +184,22 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut -- recupero i dati della eventuale seconda lama local dSawDiam2 = 0 local dMaxDepth2 = 0 + local dSawThick2 = 0 if sCutting2 and EgtMdbSetCurrMachining( sCutting2) then local sTuuid2 = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid2) or '') then dSawDiam2 = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam2 dMaxDepth2 = EgtTdbGetCurrToolMaxDepth() or dMaxDepth2 + dSawThick2 = EgtTdbGetCurrToolParam(MCH_TP.THICK) or dSawThick2 end end -- caratteristiche taglio local dDimYRef = EgtIf( b3Raw:getDimZ() < BD.MIN_DIM_HBEAM + 10 * GEO.EPS_SMALL, dMaxDepth, abs( BD.MAX_DIM_HTCUT_HBEAM)) local bBigSectionCut = ( b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) and ( b3Raw:getDimZ() > EgtIf( BD.TURN, 2 * dMaxVertDepth, dMaxVertDepth + dMaxDepth2) - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) - local bHorizCut = ( not bBigSectionCut and ( b3Raw:getDimY() > b3Raw:getDimZ() + 10 * GEO.EPS_SMALL or BD.TURN) and b3Raw:getDimZ() < dMaxVertDepth - BD.CUT_EXTRA) - local bDoubleHorizCut = ( ( BD.DOWN_HEAD or BD.TURN) and not bBigSectionCut and not bHorizCut and b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) - local bDoubleCut = ( not bBigSectionCut and not bHorizCut and not bDoubleHorizCut and b3Raw:getDimY() > dDimYRef - BD.CUT_EXTRA + 10 * GEO.EPS_SMALL) + local bHorizCut = ( ( b3Raw:getDimY() > b3Raw:getDimZ() + 10 * GEO.EPS_SMALL or BD.TURN) and b3Raw:getDimZ() < dMaxVertDepth - BD.CUT_EXTRA) + local bDoubleHorizCut = ( ( BD.DOWN_HEAD or BD.TURN) and not bHorizCut and b3Raw:getDimY() > 2 * dDimYRef - BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL) + local bDoubleCut = ( not bHorizCut and not bDoubleHorizCut and b3Raw:getDimY() > dDimYRef - BD.CUT_EXTRA + 10 * GEO.EPS_SMALL) -- dati geometrici del taglio local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT) -- se non obbligatorio e coincide con inizio grezzo, non va fatto @@ -210,8 +215,21 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut local nQ05 = EgtGetInfo( nOriId or GDB_ID.NULL, 'Q05', 'i') or 0 -- se finitura con lama if nQ05 == 1 or nQ05 == 0 then - local bOk, sErr = Cut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, nil, false, true, nil, nil, dCurrOvmT) - if not bOk then return bOk, sErr end + local dSawThickCheck = dSawThick + if dSawThick2 > 0 and bDoubleHorizCut then + dSawThickCheck = min( dSawThick, dSawThick2) + end + local dMaxElev = 0 + if vtN:getX() > 0 then + dMaxElev = b3Raw:getMax():getX() - Proc.Box:getMin():getX() + else + dMaxElev = Proc.Box:getMax():getX() - b3Raw:getMin():getX() + end + -- controllo se è necessario un taglio con dicing o si deve proseguire ai casi standard + if dMaxElev > dSawThickCheck then + local bOk, sErr = Cut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, nil, false, true, nil, nil, dCurrOvmT) + return bOk, sErr + end -- se finitura con truciolatore elseif nQ05 == 2 then local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( nPartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD) @@ -227,11 +245,12 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut return false, sErr end local bOk, sErr = Pocket.Make( Proc, Proc.Id, 0, sPocketing, nPartId, b3Solid) - if not bOk then return bOk, sErr end + return bOk, sErr end end + end -- se tagli standard - elseif not bDoubleHorizCut then + if not bDoubleHorizCut then -- flag di lavorazione faccia local nOrthoOpposite = EgtIf( bHorizCut, MCH_MILL_FU.ORTHO_DOWN, MCH_MILL_FU.ORTHO_FRONT) -- calcolo extra taglio ed accorciamento @@ -277,7 +296,7 @@ function ProcessHeadCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, bNeedHCut -- verifico che le due lame riescano a lavorare la sezione local dDimZ = b3Raw:getDimZ() local dExtra = dMaxVertDepth + dMaxDepth2 - dDimZ - if dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0 then + if ( dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0) and not bBigSectionCut then local sErr = 'Error : section too big for head cut' EgtOutLog( sErr) return false, sErr diff --git a/LuaLibs/ProcessLongCut.lua b/LuaLibs/ProcessLongCut.lua index d47bc00..739320f 100644 --- a/LuaLibs/ProcessLongCut.lua +++ b/LuaLibs/ProcessLongCut.lua @@ -13,6 +13,7 @@ -- 2022/07/14 Aggiunta limitazione lavorazione a sinistra anche se il grezzo successivo non ha lavorazioni (finale barra) ma è abbastanza lungo da poter essere riutilizzato (BD.MinRaw). -- 2022/09/23 Modificato l'angolo per l'abilitazione della lama da sotto: ora interviene anche per facce verticali. -- 2022/11/04 Aggiunto passaggio parametro bDownHead (Testa da Sotto) nelle chiamate a MakeSideFace. +-- 2022/11/28 Correzioni varie per attacco, pulizia spigoli, utilizzo H3 -- Tabella per definizione modulo local ProcessLongCut = {} @@ -860,7 +861,8 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus -- recupero la lavorazione local bDownHead = ( nSide == - 1) sMchType = EgtIf( bDownHead, 'Long2Cut_H2', 'Long2Cut') - local sMilling = ML.FindMilling( sMchType, dElev, nil, nil, nil, not bDownHead, bDownHead) + local bExcludeH3 = bLarghAsFace and abs( nSide) ~= 1 + local sMilling = ML.FindMilling( sMchType, dElev, nil, nil, nil, not bDownHead, bDownHead, bExcludeH3) if not sMilling then local sErr = 'Error : milling '..sMchType..' not found in library' EgtOutLog( sErr) @@ -885,11 +887,22 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus if bLimXmin and bLimXmax and Proc.Box:getDimX() < 2 * dToolDiam then return MakeByPocketing( Proc, nPhase, nRawId, nPartId) end + -- determino l'utilizzo della faccia + local nFaceUse = EgtIf( abs( vtN:getY()) > 0.01, MCH_MILL_FU.ORTHO_DOWN, EgtIf( bFront, MCH_MILL_FU.ORTHO_FRONT, MCH_MILL_FU.ORTHO_BACK)) + -- determino il lato di attacco (0:xMin, 1:xMax) + local nStartSide = 0 + if nFaceUse == MCH_MILL_FU.ORTHO_DOWN and not bFront then + nStartSide = 1 + elseif nFaceUse ~= MCH_MILL_FU.ORTHO_DOWN then + if ( bFront and nSide == -1) or ( not bFront and nSide == 1) then + nStartSide = 1 + end + end -- determino gli estremi local dStartDist = 0 local dStartAccDist = BD.LONGCUT_ENDLEN local bStartFixed = true - if ( bLimXmin and bFront) or ( bLimXmax and not bFront) then + if ( bLimXmin and nStartSide == 0) or ( bLimXmax and nStartSide == 1) then dStartDist = dToolDiam / 2 dStartAccDist = BD.LONGCUT_MAXLEN bStartFixed = false @@ -897,7 +910,7 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus local dEndDist = 0 local dEndAccDist = BD.LONGCUT_ENDLEN local bEndFixed = true - if ( bLimXmin and not bFront) or ( bLimXmax and bFront) then + if ( bLimXmin and nStartSide == 1) or ( bLimXmax and nStartSide == 0) then dEndDist = dToolDiam / 2 dEndAccDist = BD.LONGCUT_MAXLEN bEndFixed = false @@ -962,8 +975,6 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus dEndAccDist = 0 end end - -- determino l'utilizzo della faccia - local nFaceUse = EgtIf( abs( vtN:getY()) > 0.01, MCH_MILL_FU.ORTHO_DOWN, EgtIf( bFront, MCH_MILL_FU.ORTHO_FRONT, MCH_MILL_FU.ORTHO_BACK)) -- si percorre il lato basso della faccia local nM = 0 local nCountMilHead = 0 @@ -994,6 +1005,22 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus EgtOutLog( sErr) return false, sErr end + -- correggo l'attacco se necessario + if i == 1 and not bStartFixed then + if nO == 1 or EgtGetMachiningParam( MCH_MP.LITANG) ~= 0 then + EgtSetMachiningParam( MCH_MP.LIELEV, 0) + EgtSetMachiningParam( MCH_MP.LITANG, 0) + EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_MILL_LI.LINEAR) + EgtSetMachiningParam( MCH_MP.LIPERP, dWidth + BD.CUT_EXTRA + BD.CUT_SIC or 20) + end + elseif i == nC and not bEndFixed then + if nO == 1 or EgtGetMachiningParam( MCH_MP.LOTANG) ~= 0 then + EgtSetMachiningParam( MCH_MP.LOELEV, 0) + EgtSetMachiningParam( MCH_MP.LOTANG, 0) + EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LI.LINEAR) + EgtSetMachiningParam( MCH_MP.LOPERP, dWidth + BD.CUT_EXTRA + BD.CUT_SIC or 20) + end + end -- aggiungo geometria EgtSetMachiningGeometry( {{ Proc.Id, 0}}) -- limito opportunamente la lavorazione @@ -1022,7 +1049,11 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus end -- eventuale lavorazione della faccia limitante l'inizio if i == 1 and not bStartFixed then - local vtIni = EgtIf( bFront, X_AX(), -X_AX()) + -- per il lato sotto il vettore è opposto + local vtIni = EgtIf( bFront, X_AX(), -X_AX()) + if nSide == -1 then + vtIni = -1 * vtIni + end for j = 1, Proc.Fct - 1 do local _, vtN = EgtSurfTmFacetCenter( Proc.Id, j, GDB_ID.ROOT) if vtIni * vtN > 0 and nCountMilHead < 2 then @@ -1039,7 +1070,11 @@ function ProcessLongCut.Make( Proc, nPhase, nRawId, nPartId, bCustUseBlade, nCus -- eventuale lavorazione della faccia limitante la fine if not bEndFixed then - local vtFin = EgtIf( bFront, -X_AX(), X_AX()) + -- per il lato sotto il vettore è opposto + local vtFin = EgtIf( bFront, -X_AX(), X_AX()) + if nSide == -1 then + vtFin = -1 * vtFin + end for j = 1, Proc.Fct - 1 do local _, vtN = EgtSurfTmFacetCenter( Proc.Id, j, GDB_ID.ROOT) if vtFin * vtN > 0 and nCountMilHead < 2 then diff --git a/LuaLibs/ProcessSimpleScarf.lua b/LuaLibs/ProcessSimpleScarf.lua index 29b42af..aba4e1c 100644 --- a/LuaLibs/ProcessSimpleScarf.lua +++ b/LuaLibs/ProcessSimpleScarf.lua @@ -198,119 +198,120 @@ function ProcessSimpleScarf.Make( Proc, nPhase, nRawId, nPartId, dOvmHead, dOvmT ( EgtGetInfo( Proc.Id, 'Q04', 'd') == 3 and abs( vtN[vFaceOrd[3]]:getY()) < 0.1 and vtN[vFaceOrd[3]]:getZ() < 0.1) if bForceSideMill then bOk, sErr = FreeContour.Make( Proc, nPhase, nRawId, nPartId, dOvmHead) - return bOk, sErr - end - -- recupero la lavorazione - local sCutting = ML.FindCutting( 'HeadSide') - if not sCutting then - local sErr = 'Error : cutting not found in library' - EgtOutLog( sErr) - return false, sErr - end - -- recupero i dati dell'utensile - local dSawDiam = 400 - if EgtMdbSetCurrMachining( sCutting) then - local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) - if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then - dSawDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam - end - end - -- taglio sulla faccia esterna - if vFaceOrd[1] ~= 0 then - -- in generale va fatto - local bCut = true - -- se di testa e coincide con inizio grezzo, non va fatto - if bHead and AreSameVectorApprox( vtN[vFaceOrd[1]], X_AX()) and abs( ptC[vFaceOrd[1]]:getX() - b3Raw:getMax():getX() + dOvmHead) < 10 * GEO.EPS_SMALL then - bCut = false - end - -- se di coda e coincide con taglio di separazione, non va fatto - if not bHead and AreSameVectorApprox( vtN[vFaceOrd[1]], - X_AX()) and abs( ptC[vFaceOrd[1]]:getX() - b3Raw:getMin():getX()) < dOvmTail + 10 * GEO.EPS_SMALL then - bCut = false - end - -- se va fatto, inserisco la lavorazione - if bCut then - local vtOrthoO = Vector3d( vtRef) - local bOk, sNameOrErr = Fbs.MakeOne( Proc.Id, vFaceOrd[1] - 1, sCutting, dSawDiam, vtOrthoO, nil, BD.CUT_EXTRA, BD.CUT_SIC, 0, 0, 0, nil, b3Raw) - if not bOk then return bOk, sNameOrErr end - end - end - -- recupero gruppo per geometria addizionale - local nAddGrpId = BL.GetAddGroup( nPartId) - if not nAddGrpId then - local sErr = 'Error : missing AddGroup' - EgtOutLog( sErr) - return false, sErr - end - -- se esistono faccia interna ed intermedia, verifico se richiedono taglio a cubetti - local vCuts = {} - if vFaceOrd[2] ~= 0 and vFaceOrd[3] ~= 0 then - vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC[vFaceOrd[3]], vtN[vFaceOrd[3]], false, ptC[vFaceOrd[2]], vtN[vFaceOrd[2]]) - elseif vFaceOrd[3] ~= 0 then - vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC[vFaceOrd[3]], vtN[vFaceOrd[3]], true) - end - if #vCuts > 0 then - -- sistemo posizione nel DB e nome - for i = 1, #vCuts do - for j = 1, #vCuts[i] do - EgtSetName( vCuts[i][j], 'AddCut_' .. tostring( Proc.Id)) - EgtSetInfo( vCuts[i][j], 'TASKID', Proc.TaskId) - end - end - -- calcolo secondo riferimento per testa o coda - local vtRef2 = EgtIf( bHead, X_AX(), -X_AX()) - -- eseguo - for i = 1, #vCuts do - local vtOrthoO - if i % 2 == 1 then - vtOrthoO = Vector3d( vtRef) - else - if #vCuts[i-1] > 0 then - vtOrthoO = Vector3d( EgtIf( vtRef2, vtRef2, vtRef)) - else - local vtO - for j = 1, #vCuts[i-1] do - _, vtO = EgtSurfTmFacetCenter( vCuts[i-1][j], 0, GDB_ID.ROOT) - break - end - if vtO then - vtOrthoO = Vector3d( vtO) - else - vtOrthoO = Y_AX() - end - end - end - -- lavoro la faccia - for j = 1, #vCuts[i] do - local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw) - if not bOk then - return bOk, sErr - end - end - end + if not bOk then return bOk, sErr end else - -- taglio sulla faccia interna - local bIntCut = false - if vFaceOrd[2] ~= 0 then - -- inserisco la lavorazione - local nOrthoOpposite = BL.GetNearestOrthoOpposite( vtRef) - local bOk, sNameOrErr = Fbs.MakeOne( Proc.Id, vFaceOrd[2] - 1, sCutting, dSawDiam, nOrthoOpposite, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw) - if not bOk then return bOk, sNameOrErr end - if #sNameOrErr > 0 then bIntCut = true end + -- recupero la lavorazione + local sCutting = ML.FindCutting( 'HeadSide') + if not sCutting then + local sErr = 'Error : cutting not found in library' + EgtOutLog( sErr) + return false, sErr end - -- taglio sulla faccia intermedia - if vFaceOrd[3] ~= 0 then - -- calcolo secondo testa o coda - local vtRef2 = EgtIf( bHead, X_AX(), -X_AX()) - -- se non ho il taglio sulla faccia interna - if not bIntCut then - local frHV, DimH, DimV = BL.GetFaceHvRefDim( Proc.Id, vFaceOrd[3] - 1) - if DimV > DimH then - vtRef2 = Vector3d( frHV:getVersX()) + -- recupero i dati dell'utensile + local dSawDiam = 400 + if EgtMdbSetCurrMachining( sCutting) then + local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) + if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then + dSawDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam + end + end + -- taglio sulla faccia esterna + if vFaceOrd[1] ~= 0 then + -- in generale va fatto + local bCut = true + -- se di testa e coincide con inizio grezzo, non va fatto + if bHead and AreSameVectorApprox( vtN[vFaceOrd[1]], X_AX()) and abs( ptC[vFaceOrd[1]]:getX() - b3Raw:getMax():getX() + dOvmHead) < 10 * GEO.EPS_SMALL then + bCut = false + end + -- se di coda e coincide con taglio di separazione, non va fatto + if not bHead and AreSameVectorApprox( vtN[vFaceOrd[1]], - X_AX()) and abs( ptC[vFaceOrd[1]]:getX() - b3Raw:getMin():getX()) < dOvmTail + 10 * GEO.EPS_SMALL then + bCut = false + end + -- se va fatto, inserisco la lavorazione + if bCut then + local vtOrthoO = Vector3d( vtRef) + local bOk, sNameOrErr = Fbs.MakeOne( Proc.Id, vFaceOrd[1] - 1, sCutting, dSawDiam, vtOrthoO, nil, BD.CUT_EXTRA, BD.CUT_SIC, 0, 0, 0, nil, b3Raw) + if not bOk then return bOk, sNameOrErr end + end + end + -- recupero gruppo per geometria addizionale + local nAddGrpId = BL.GetAddGroup( nPartId) + if not nAddGrpId then + local sErr = 'Error : missing AddGroup' + EgtOutLog( sErr) + return false, sErr + end + -- se esistono faccia interna ed intermedia, verifico se richiedono taglio a cubetti + local vCuts = {} + if vFaceOrd[2] ~= 0 and vFaceOrd[3] ~= 0 then + vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC[vFaceOrd[3]], vtN[vFaceOrd[3]], false, ptC[vFaceOrd[2]], vtN[vFaceOrd[2]]) + elseif vFaceOrd[3] ~= 0 then + vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC[vFaceOrd[3]], vtN[vFaceOrd[3]], true) + end + if #vCuts > 0 then + -- sistemo posizione nel DB e nome + for i = 1, #vCuts do + for j = 1, #vCuts[i] do + EgtSetName( vCuts[i][j], 'AddCut_' .. tostring( Proc.Id)) + EgtSetInfo( vCuts[i][j], 'TASKID', Proc.TaskId) end end - -- inserisco la lavorazione - local bOk, sErr = Fbs.MakeOne( Proc.Id, vFaceOrd[3] - 1, sCutting, dSawDiam, vtRef2, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw) - if not bOk then return bOk, sErr end + -- calcolo secondo riferimento per testa o coda + local vtRef2 = EgtIf( bHead, X_AX(), -X_AX()) + -- eseguo + for i = 1, #vCuts do + local vtOrthoO + if i % 2 == 1 then + vtOrthoO = Vector3d( vtRef) + else + if #vCuts[i-1] > 0 then + vtOrthoO = Vector3d( EgtIf( vtRef2, vtRef2, vtRef)) + else + local vtO + for j = 1, #vCuts[i-1] do + _, vtO = EgtSurfTmFacetCenter( vCuts[i-1][j], 0, GDB_ID.ROOT) + break + end + if vtO then + vtOrthoO = Vector3d( vtO) + else + vtOrthoO = Y_AX() + end + end + end + -- lavoro la faccia + for j = 1, #vCuts[i] do + local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrthoO, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw) + if not bOk then + return bOk, sErr + end + end + end + else + -- taglio sulla faccia interna + local bIntCut = false + if vFaceOrd[2] ~= 0 then + -- inserisco la lavorazione + local nOrthoOpposite = BL.GetNearestOrthoOpposite( vtRef) + local bOk, sNameOrErr = Fbs.MakeOne( Proc.Id, vFaceOrd[2] - 1, sCutting, dSawDiam, nOrthoOpposite, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw) + if not bOk then return bOk, sNameOrErr end + if #sNameOrErr > 0 then bIntCut = true end + end + -- taglio sulla faccia intermedia + if vFaceOrd[3] ~= 0 then + -- calcolo secondo testa o coda + local vtRef2 = EgtIf( bHead, X_AX(), -X_AX()) + -- se non ho il taglio sulla faccia interna + if not bIntCut then + local frHV, DimH, DimV = BL.GetFaceHvRefDim( Proc.Id, vFaceOrd[3] - 1) + if DimV > DimH then + vtRef2 = Vector3d( frHV:getVersX()) + end + end + -- inserisco la lavorazione + local bOk, sErr = Fbs.MakeOne( Proc.Id, vFaceOrd[3] - 1, sCutting, dSawDiam, vtRef2, nil, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw) + if not bOk then return bOk, sErr end + end end end -- aggiornamento ingombro di testa o coda diff --git a/LuaLibs/ProcessSplit.lua b/LuaLibs/ProcessSplit.lua index 92c8340..f617d5f 100644 --- a/LuaLibs/ProcessSplit.lua +++ b/LuaLibs/ProcessSplit.lua @@ -6,6 +6,7 @@ -- 2022/09/08 Migliorato verso di lavorazione in caso di DoubleCut -- 2022/11/02 Corretti accorciamenti per DoubleCut -- 2022/11/10 Corrette finiture lama per BigSection con trave alta +-- 2022/11/16 Correzioni per travi larghe -- Tabella per definizione modulo local ProcessSplit = {} @@ -346,6 +347,12 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt -- altrimenti tagli dai due fianchi (dietro e davanti) else local cutDepth = 0.5 * b3Raw:getDimY() + BD.CUT_EXTRA_MIN + -- se la sega a catena non può completare lo split esco + if cutDepth >= min( dMaxMat, dTLen - BD.C_SIMM_ENC) + 10 * GEO.EPS_SMALL then + sErr = 'Error : section too big for splitting' + EgtOutLog( sErr) + return false, sErr, -1 + end local sNotesSplit = 'Presplit;' local bOk, sErr = MakeSplitByChainSaw( Proc.Id, MCH_MILL_FU.PARAL_BACK, cutDepth, sNotesSplit, dOffs) if not bOk then return bOk, sErr, nNewPhase end @@ -482,7 +489,7 @@ function ProcessSplit.Make( Proc, nPhase, nRawId, nPartId, nOrd, sDownOrSideOrSt -- verifico che le due lame riescano a lavorare la sezione local dDimZ = b3Raw:getDimZ() local dExtra = dMaxVertDepth + dMaxDepth2 - dDimZ - if dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0 then + if ( dExtra - 2 * BD.CUT_EXTRA_MIN + 10 * GEO.EPS_SMALL < 0) and not bBigSectionCut then local sErr = 'Error : section too big for tail cut' EgtOutLog( sErr) return false, sErr