diff --git a/LuaLibs/AddManData.lua b/LuaLibs/AddManData.lua index c29aab0..605a380 100644 --- a/LuaLibs/AddManData.lua +++ b/LuaLibs/AddManData.lua @@ -46,6 +46,7 @@ KEY_SLICING_DIR = "SlicingDir" KEY_SLICE_STEP = "StrandH" KEY_SHELLS_NBR = "StrandCount" KEY_STRAND = "StrandW" +KEY_INNER_STRAND = "InnerStrandW" KEY_STRAND_OVERLAP = "StrandOverlap" KEY_OFFSET_SLICE = "Offset" KEY_SP_OFFSET_ON_SLICE = "StartPointOffsetOnSlice" @@ -88,6 +89,7 @@ KEY_CEIL_TYPE = "CeilType" KEY_FILL_TYPE = "FillType" -- Infill +KEY_INFILL_STRAND = "InfillStrandW" KEY_INFILL_TYPE = "InfillType" KEY_INFILL_DENSITY = "InfillDensity" KEY_INFILL_OVERLAP = "InfillOverlap" @@ -100,6 +102,7 @@ KEY_INFILL_WIPE = "InfillWipe" KEY_INFILL_WIPE_DIR = "InfillWipeDir" -- Ribs +KEY_RIBS_STRAND = "RibsStrandW" KEY_RIBS_TYPE = "RibsType" KEY_LIMIT_UNBDD_RIBS = "LimitUnboundedRibsWithSolid" KEY_RIBS_OVERLAP = "RibsOverlap" @@ -141,6 +144,7 @@ KEY_EXTRA_SHELL_WIPE = "ExtraShellWipe" KEY_EXTRA_SHELL_WIPE_DIR = "ExtraShellWipeDir" -- Solidi ausiliari +KEY_AUX_SOLIDS_STRAND = "AuxSolidsStrandW" KEY_AUX_SOLIDS_OVERLAP = "AuxSolidsOverlap" KEY_AUX_SOLIDS_INFILL = "AuxSolidsInfill" KEY_AUX_SOLIDS_PRINT_ORDER = "AuxSolidsStrandOrder" @@ -186,6 +190,7 @@ KEY_ASSOCIATED_P_CRV = "AssociatedPathCrv" KEY_INTERNAL_SRF_LOOP = "InternalSrfLoop" KEY_PREV_CRV = "PrevCrv" KEY_NEXT_CRVS = "NextCrvs" +KEY_CRV_STRAND = "CurveStrand" SLICING_TYPE = { VERTICAL = 1, @@ -231,7 +236,7 @@ PRINT_DIRECTION = { LINK_TYPE = { NONE = 1, LINEAR = 2, - BIARC = 3, + BIARC = 3, } LEAD_TYPE = { diff --git a/LuaLibs/CalcPaths.lua b/LuaLibs/CalcPaths.lua index ca6c62c..7830595 100644 --- a/LuaLibs/CalcPaths.lua +++ b/LuaLibs/CalcPaths.lua @@ -24,8 +24,9 @@ local function GetLayerParamsForPathCalc() LayerParams.bSpiralVase = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE, 'b') or false LayerParams.nShellsNbr = EgtGetInfo( s_nPartId, KEY_SHELLS_NBR, 'i') LayerParams.dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd') + LayerParams.dInnerStrand = EgtGetInfo( s_nPartId, KEY_INNER_STRAND, 'd') or LayerParams.dStrand LayerParams.dLayHeight = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd') - LayerParams.nStrandOverlap = EgtGetInfo( s_nPartId, KEY_STRAND_OVERLAP, 'i') or 0 + LayerParams.dStrandOverlap = EgtGetInfo( s_nPartId, KEY_STRAND_OVERLAP, 'd') or 0 LayerParams.dOffs = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd') LayerParams.vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v') LayerParams.bPrintInvert = ( EgtGetInfo( s_nPartId, KEY_PRINT_DIRECTION, 'i') == PRINT_DIRECTION.CW) @@ -42,7 +43,8 @@ local function GetLayerParamsForPathCalc() LayerParams.nCeilNbr = EgtGetInfo( s_nPartId, KEY_CEIL_NBR, 'i') or 0 LayerParams.nCeilType = EgtGetInfo( s_nPartId, KEY_CEIL_TYPE, 'i') or FILL_TYPE.OFFSET -- parametri infill - LayerParams.nInfillOverlap = EgtGetInfo( s_nPartId, KEY_INFILL_OVERLAP, 'i') or 0 + LayerParams.dInfillStrand = EgtGetInfo( s_nPartId, KEY_INFILL_STRAND, 'd') or LayerParams.dStrand + LayerParams.dInfillOverlap = EgtGetInfo( s_nPartId, KEY_INFILL_OVERLAP, 'd') or 0 LayerParams.nInfillType = EgtGetInfo( s_nPartId, KEY_INFILL_TYPE, 'i') or FILL_TYPE.NONE -- eventuale modifica dei parametri per gestire correttamente il caso spiral vase @@ -76,27 +78,43 @@ local function UpdateInvertInfo( nId) end ---------------------------------------------------------------------- -local function ComputeSurfOffset( nSrf, nGrpId, dOffs, vtSlicing, nOffsType) - -- tipologia di offset - if not nOffsType then nOffsType = GDB_OT.FILLET end - -- gruppo temporaneo locale - local nGrpTmp = EgtGroup( nGrpId, Frame3d( ORIG(), vtSlicing), GDB_RT.GLOB) - local nCopySrf = EgtCopyGlob( nSrf, nGrpTmp) or GDB_ID.NULL - local bOk = EgtSurfFrOffset( nCopySrf, dOffs, nOffsType) - local bExists = EgtSurfFrChunkCount( nCopySrf) > 0 - if not bOk or not bExists then - EgtErase( nCopySrf) - nCopySrf = EgtCopyGlob( nSrf, nGrpTmp) or GDB_ID.NULL - bOk = EgtSurfFrOffset( nCopySrf, dOffs + 0.05) - bExists = EgtSurfFrChunkCount( nCopySrf) > 0 +local function ComputeSurfOffset( nSrf, nGrpId, dOffs) + -- restituisce id della superficie offsettata in caso di successo, nil in caso di errore, GDB_ID.NULL se la superficie offsettata scompare + + local nOffsSrf = EgtCopyGlob( nSrf, nGrpId) or GDB_ID.NULL + local bOk = EgtSurfFrOffset( nOffsSrf, dOffs) + if not bOk then + -- ritento modificando leggermente l'offset + EgtErase( nOffsSrf) + nOffsSrf = EgtCopyGlob( nSrf, nGrpId) or GDB_ID.NULL + bOk = EgtSurfFrOffset( nOffsSrf, dOffs + 0.05) end - EgtRelocateGlob( nCopySrf, nGrpId) - EgtErase( nGrpTmp) - if not bExists then - nCopySrf = GDB_ID.NULL + if not bOk then + EgtErase( nOffsSrf) + return nil + elseif EgtSurfFrChunkCount( nOffsSrf) == 0 then + return GDB_ID.NULL + else + return nOffsSrf end - return bOk, bExists, nCopySrf +end + +-------------------------------------------------------------------- +local function ComputeTrimSurf( nSrf, nGrpId, dStrand, dOverlap) + + local nTrimSurf = ComputeSurfOffset( nSrf, nGrpId, - dStrand * ( 0.5 - dOverlap / 100) + s_dOffsCorr) + local bNoOverlap = false + if not nTrimSurf and dOverlap > GEO.EPS_SMALL then + -- tento senza overlap + nTrimSurf = ComputeSurfOffset( nSrf, nGrpId, - dStrand * 0.5) + if not nTrimSurf then + return + end + bNoOverlap = true + end + + return nTrimSurf, bNoOverlap end --------------------------------------------------------------------- @@ -163,8 +181,8 @@ local function GetPathsFromSurf( nSrfId, sName, nType, nGrpId, vPtStart) local vIds = {} local nChunks = EgtSurfFrChunkCount( nSrfId) - for nC = 0, nChunks - 1 do - -- estraggo i contorni + for nC = 0, nChunks - 1 do + -- estraggo i contorni local nCrvId, nCrvCnt = EgtExtractSurfFrChunkLoops( nSrfId, nC, nGrpId) for nInd = 0, nCrvCnt - 1 do EgtSetName( nCrvId + nInd, sName) @@ -205,7 +223,7 @@ local function VerifyPath( nCrvId, dStrand, vtSlicing, nGrp) if not nRes then nRes, nCnt = EgtOffsetCurveAdv( nCrvId, - dStrand / 2 + 0.05) if not nRes then return false end - end + end for j = nRes, nRes + nCnt - 1 do EgtErase( j) end @@ -284,39 +302,46 @@ local function CalcInfillPaths( nLayId, nInfillGrp, LayerParams) EgtSetStatus( nInfillPathGrp, GDB_ST.OFF) EgtSetInfo( nInfillPathGrp, KEY_FILL_TYPE, LayerParams.nInfillType) - -- recupero la superficie con cui fare trim - local nSrf = EgtGetFirstNameInGroup( vCrvGrps[i], TOT_SHELL_TRIM_SURF) - if not nSrf then + -- recupero la superficie occupata dalle shell + local nSrfBase = EgtGetFirstNameInGroup( vCrvGrps[i], TOT_SHELL_TRIM_SURF) + if not nSrfBase then -- se non esiste non c'è spazio per infill - EgtOutLog( 'Warning: Infill not possibile (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + EgtOutLog( 'Warning : Infill not possibile (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') else - local bOk, bExists, nTrimSrf = ComputeSurfOffset( nSrf, nInfillPathGrp, LayerParams.nInfillOverlap / 100 * LayerParams.dStrand, LayerParams.vtSlicing, GDB_OT.EXTEND) - if not bOk then - -- eseguo trim senza overlap - EgtOutLog( 'Warning: Infill without correct overlap (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - nTrimSrf = EgtCopyGlob( nSrf, nInfillPathGrp) - end - - for i = 1, #vIds do - local nNewId = EgtCopyGlob( vIds[i], nInfillPathGrp) - -- faccio trim con la superficie - local nRes, nCnt = EgtTrimCurveWithRegion( nNewId, nTrimSrf, true, true) - for nId = nRes, nRes + nCnt - 1 do - -- verifico se lunghezza minima - local dLen = EgtCurveLength( nId) - if dLen < MIN_INFILL_LEN then - EgtErase( nId) - else - EgtSetName( nId, INFILL_CRV) - EgtSetInfo( nId, KEY_TYPE, TYPE.INFILL) - EgtSetInfo( nId, KEY_ASSOCIATED_SURF, nTrimSrf) - EgtModifyCurveExtrusion( nId, LayerParams.vtSlicing) + -- calcolo la superficie per trim + local nTrimSrf, bNoOverlap = ComputeTrimSurf( nSrfBase, nInfillPathGrp, LayerParams.dInfillStrand, LayerParams.dInfillOverlap) + if not nTrimSrf then + -- errore + EgtOutLog( 'Error : creation of Infill region failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of Infill region failed') + elseif nTrimSrf == GDB_ID.NULL then + EgtOutLog( 'Warning : Infill not possibile (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + else + if bNoOverlap then + EgtOutLog( 'Warning : Infill without correct overlap (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + end + + for i = 1, #vIds do + local nNewId = EgtCopyGlob( vIds[i], nInfillPathGrp) + -- faccio trim con la superficie + local nRes, nCnt = EgtTrimCurveWithRegion( nNewId, nTrimSrf, true, true) + for nId = nRes, nRes + nCnt - 1 do + -- verifico se lunghezza minima + local dLen = EgtCurveLength( nId) + if dLen < MIN_INFILL_LEN then + EgtErase( nId) + else + EgtSetName( nId, INFILL_CRV) + EgtSetInfo( nId, KEY_TYPE, TYPE.INFILL) + EgtSetInfo( nId, KEY_ASSOCIATED_SURF, nTrimSrf) + EgtModifyCurveExtrusion( nId, LayerParams.vtSlicing) + end end end + + -- avendo riempito la regione con gli infill, la TotShellTrimSurf non deve esistere + EgtErase( nSrfBase) end - - -- avendo riempito la regione con gli infill, la TotShellTrimSurf non deve esistere - EgtErase( nSrf) end -- se gruppo vuoto lo cancello @@ -415,10 +440,8 @@ local function ComputeOffsetSolidFill( nSrf, dStrand, vtSlicing, sName, nType, n -- nSrf è già la prima superficie da cui estrarre i bordi, quindi il primo offset non va fatto local dOffs = 0 local nSrfOffs = EgtCopyGlob( nSrf, nGrp) - local bOk = true - local bExists = ( EgtSurfFrChunkCount( nSrf) > 0) - while bOk and bExists do + while nSrfOffs and nSrfOffs ~= GDB_ID.NULL do -- estraggo i contorni local vNewIds = GetPathsFromSurf( nSrfOffs, sName, nType, nGrp, vPtStart) if vNewIds then @@ -441,7 +464,7 @@ local function ComputeOffsetSolidFill( nSrf, dStrand, vtSlicing, sName, nType, n -- offset successivo EgtErase( nSrfOffs) dOffs = dOffs - dStrand - bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrf, nGrp, dOffs, vtSlicing) + nSrfOffs = ComputeSurfOffset( nSrf, nGrp, dOffs) end end @@ -529,7 +552,7 @@ local function ComputeZigZagSolidFill( nSrf, dStrand, vtSlicing, sName, nType, n local nCopySrf = EgtCopyGlob( nSrf, nGrp) local frLoc = Frame3d( ORIG(), vtSlicing) - -- analizzo tutti i chunk della superifice da riempire + -- analizzo tutti i chunk della superficie da riempire local nFirst, nSrfCnt = EgtExplodeSurf( nCopySrf) local vIds = {} for nSrfId = nFirst, nFirst + nSrfCnt - 1 do @@ -567,34 +590,41 @@ local function CalcSolidFillPath( nLayId, LayerParams, vPtStart, nFillType) EgtSetStatus( nInfillPathGrp, GDB_ST.OFF) EgtSetInfo( nInfillPathGrp, KEY_FILL_TYPE, nFillType) - -- recupero la superficie da riempire - local nSrf = EgtGetFirstNameInGroup( vCrvGrps[i], TOT_SHELL_TRIM_SURF) - if not nSrf then + -- recupero la superficie occupata dalle shell + local nSrfBase = EgtGetFirstNameInGroup( vCrvGrps[i], TOT_SHELL_TRIM_SURF) + if not nSrfBase then -- se non esiste non c'è spazio per solid fill - EgtOutLog( 'Warning: SolidFill not possibile (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + EgtOutLog( 'Warning : SolidFill not possibile (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') else - local bOk, bExists, nSrfToFill = ComputeSurfOffset( nSrf, nInfillPathGrp, LayerParams.nInfillOverlap / 100 * LayerParams.dStrand, LayerParams.vtSlicing) - if not bOk then - -- eseguo trim senza overlap - EgtOutLog( 'Warning: SolidFill without correct overlap (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - nSrfToFill = EgtCopyGlob( nSrf, nInfillPathGrp) + -- calcolo la superficie da riempire + local nSrfToFill, bNoOverlap = ComputeTrimSurf( nSrfBase, nInfillPathGrp, LayerParams.dInfillStrand, LayerParams.dInfillOverlap) + if not nSrfToFill then + -- errore + EgtOutLog( 'Error : creation of SolidFill region failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of SolidFill region failed') + elseif nSrfToFill == GDB_ID.NULL then + EgtOutLog( 'Warning : SolidFill not possibile (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + else + if bNoOverlap then + EgtOutLog( 'Warning : SolidFill without correct overlap (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + end + + -- distanza tra passate tenendo conto dell'overlap indicato + local dDist = ( 1 - LayerParams.dStrandOverlap / 100) * LayerParams.dInfillStrand + -- inserisco il riempimento + if nFillType == FILL_TYPE.OFFSET then + -- recupero le shell precedenti dal PathGrp + local nPathGrp = EgtGetFirstNameInGroup( vCrvGrps[i], PATH_GRP) + local nLast = EgtGetLastNameInGroup( nPathGrp, SHELL_CRV .. '*') or EgtGetLastNameInGroup( nPathGrp, EXTRA_SHELL_CRV .. '*') + local vOldIds = EgtGetNameInGroup( nPathGrp, EgtGetName( nLast)) + ComputeOffsetSolidFill( nSrfToFill, dDist, LayerParams.vtSlicing, INFILL_CRV, TYPE.INFILL, nInfillPathGrp, vPtStart, vOldIds) + elseif nFillType == FILL_TYPE.ZIGZAG then + ComputeZigZagSolidFill( nSrfToFill, dDist, LayerParams.vtSlicing, INFILL_CRV, TYPE.INFILL, nInfillPathGrp) + end + + -- avendo riempito la regione, la TotShellTrimSurf non deve esistere + EgtErase( nSrfBase) end - - -- distanza tra passate tenendo conto dell'overlap indicato - local dDist = ( 1 - LayerParams.nStrandOverlap / 100) * LayerParams.dStrand - -- inserisco il riempimento - if nFillType == FILL_TYPE.OFFSET then - -- recupero le shell precedenti dal PathGrp - local nPathGrp = EgtGetFirstNameInGroup( vCrvGrps[i], PATH_GRP) - local nLast = EgtGetLastNameInGroup( nPathGrp, SHELL_CRV .. '*') or EgtGetLastNameInGroup( nPathGrp, EXTRA_SHELL_CRV .. '*') - local vOldIds = EgtGetNameInGroup( nPathGrp, EgtGetName( nLast)) - ComputeOffsetSolidFill( nSrfToFill, dDist, LayerParams.vtSlicing, INFILL_CRV, TYPE.INFILL, nInfillPathGrp, vPtStart, vOldIds) - elseif nFillType == FILL_TYPE.ZIGZAG then - ComputeZigZagSolidFill( nSrfToFill, dDist, LayerParams.vtSlicing, INFILL_CRV, TYPE.INFILL, nInfillPathGrp) - end - - -- avendo riempito la regione, la TotShellTrimSurf non deve esistere - EgtErase( nSrf) end -- se gruppo vuoto lo cancello @@ -607,7 +637,7 @@ end -------------------------------------------------------------------- --------------------------- RIBS ----------------------------------- -------------------------------------------------------------------- -local function VerifyRibsHoles( vIds, dStrand) +local function VerifyRibsHoles( vIds) local sPrevName = EgtGetName( vIds[1]) local i = 2 @@ -617,6 +647,7 @@ local function VerifyRibsHoles( vIds, dStrand) local sCurrName = EgtGetName( vIds[i]) -- se derivano dallo stesso setto verifico se possono essere uniti if sCurrName == sPrevName then + local dStrand = EgtGetInfo( vIds[i], KEY_RIBS_STRAND, 'd') local ptS1 = EgtSP( vIds[i-1]) local ptE1 = EgtEP( vIds[i-1]) local ptS2 = EgtSP( vIds[i]) @@ -1056,26 +1087,8 @@ local function AdjustHoledRibs( nTrimmedRibsGrp) end ------------------------------------------------------------------- -local function TrimRibs( vRibs, nRibsGrp, nSrf, dSrfOffs, vtSlicing) - - -- costruisco le superfici con cui fare il trim grossolano dei setti - local nSrfInt = GDB_ID.NULL - local nSrfExt = GDB_ID.NULL - if nSrf ~= GDB_ID.NULL then - local bOk - bOk, _, nSrfInt = ComputeSurfOffset( nSrf, nRibsGrp, dSrfOffs, vtSlicing) - if not bOk then - EgtOutLog( 'Warning: coarse trim for internal ribs may be innacurate (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - nSrfInt = EgtCopyGlob( nSrf, nRibsGrp) - end - - bOk, _, nSrfExt = ComputeSurfOffset( nSrf, nRibsGrp, - dSrfOffs, vtSlicing) - if not bOk then - EgtOutLog( 'Warning: coarse trim for external ribs may be innacurate (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - nSrfExt = EgtCopyGlob( nSrf, nRibsGrp) - end - end - +local function TrimRibs( vRibs, nRibsGrp, nSrfTrimInt, nSrfTrimExt, vtSlicing) + -- trim dei setti local nTrimmedRibsGrp = EgtGroup( nRibsGrp) local tUserLink = {} -- tratti appartenenti a UserLink @@ -1086,29 +1099,23 @@ local function TrimRibs( vRibs, nRibsGrp, nSrf, dSrfOffs, vtSlicing) local nCopyRib = EgtCopyGlob( vRibs[i], nTrimmedRibsGrp) local nCrv, nCnt + -- setto interno if nType == RIB_TYPE.INTERNAL or nType == RIB_TYPE.SUPPORT then - if EgtSurfFrChunkCount( nSrfInt) == 0 then - -- se la superficie non esiste, il setto deve essere cancellato + if nSrfTrimInt == GDB_ID.NULL then + -- se la superficie non esiste, il setto deve essere cancellato perchè non c'è spazio nCrv = nCopyRib nCnt = 0 - else - nCrv, nCnt = EgtTrimCurveWithRegion( nCopyRib, nSrfInt, true, true) + elseif nSrfTrimInt then + nCrv, nCnt = EgtTrimCurveWithRegion( nCopyRib, nSrfTrimInt, true, true) end + -- setto esterno elseif nType == RIB_TYPE.EXTERNAL then - if EgtSurfFrChunkCount( nSrfExt) == 0 then - -- se la superficie non esiste il setto è valido - nCrv = nCopyRib - nCnt = 1 - else - nCrv, nCnt = EgtTrimCurveWithRegion( nCopyRib, nSrfExt, false, true) + if nSrfTrimExt ~= GDB_ID.NULL then + nCrv, nCnt = EgtTrimCurveWithRegion( nCopyRib, nSrfTrimExt, false, true) end - else - -- setto unbounded non va tagliato - nCrv = nCopyRib - nCnt = 1 end - -- se errore nel calcolare trim ( nCrv = nil) riprendo il setto originario + -- se nCrv non definito ( per errore nel trim o perchè il setto va conservato) riprendo il setto originario if not nCrv then nCrv = nCopyRib nCnt = 1 @@ -1142,9 +1149,9 @@ local function TrimRibs( vRibs, nRibsGrp, nSrf, dSrfOffs, vtSlicing) EgtSetInfo( vRibs[i], KEY_ASSOCIATED_CRVS, tUserLink[vRibs[i]]) end end - + -- verifico e sistemo UserLink - AdjustUserLinkRibs( tUserLink, vSingleRibs, vtSlicing, nSrfInt, nSrfExt, nRibsGrp) + AdjustUserLinkRibs( tUserLink, vSingleRibs, vtSlicing, nSrfTrimInt, nSrfTrimExt, nRibsGrp) -- verifico se necessari aggiustamenti per holes AdjustHoledRibs( nTrimmedRibsGrp) @@ -1153,7 +1160,7 @@ local function TrimRibs( vRibs, nRibsGrp, nSrf, dSrfOffs, vtSlicing) end -------------------------------------------------------------------- -local function ComputeRibsOrientedOffset( nRibsGrp, dStrand) +local function ComputeRibsOrientedOffset( nRibsGrp) local nOffsGrp = EgtGroup( EgtGetParent( nRibsGrp)) @@ -1168,16 +1175,17 @@ local function ComputeRibsOrientedOffset( nRibsGrp, dStrand) local bInvert = EgtGetInfo( nCurrRib, KEY_RIBS_INVERT_DIR, 'b') or false local bInvertOrder = EgtGetInfo( nCurrRib, KEY_RIBS_INVERT_STRAND_ORDER, 'b') or false local nShellsNbr = EgtGetInfo( nCurrRib, KEY_RIBS_SHELLS_NBR, 'i') - local dOffs = ( nShellsNbr - 1) * dStrand / 2 -- offset di ogni tratto del setto local vOffs = {} local bPlusToMinus = false for i = 1, #vIds do - + local bUserLinked = EgtGetInfo( vIds[i], KEY_RIBS_USER_LINK, 'b') or false local bCCW = EgtGetInfo( vIds[i], KEY_RIBS_USER_LINK_CCW, 'b') or false local nLinkOrder = EgtGetInfo( vIds[i], KEY_RIBS_USER_LINK_ORDER, 'i') or 0 + local dStrand = EgtGetInfo( vIds[i], KEY_RIBS_STRAND, 'd') + local dOffs = ( nShellsNbr - 1) * dStrand / 2 -- ordine di realizzazione degli offset if not bUserLinked then @@ -1263,152 +1271,261 @@ local function ComputeRibsOrientedOffset( nRibsGrp, dStrand) end -------------------------------------------------------------------- -local function ComputeTrimSurfWithOverlapsForRibs( vIds, nSrfBase, nSrfExt, dOffs, dStrand, nGrp, vtSlicing) +local function FindRibWithSameTrimSurf( tOffs, dOffs, nType) - -- per ogni tipologia e overlap creo le superfici con cui fare i trim - local tSurfOffs = {{}, {}, {}, {}} - for i = 1, #vIds do - local nOverlap = EgtGetInfo( vIds[i], KEY_RIBS_OVERLAP, 'i') - local nType = EgtGetInfo( vIds[i], KEY_RIBS_TYPE, 'i') - if not tSurfOffs[nType][nOverlap] then - if nType == RIB_TYPE.INTERNAL or nType == RIB_TYPE.SUPPORT then - if nSrfBase ~= GDB_ID.NULL then - local dNewOffs = nOverlap / 100 * dStrand - local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrfBase, nGrp, dNewOffs, vtSlicing) - if not bOk then - -- considero la superficie senza overlap corretto - EgtOutLog( 'Warning: rib without correct overlap (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - nSrfOffs = EgtCopyGlob( nSrfBase, nGrp) - end - tSurfOffs[RIB_TYPE.INTERNAL][nOverlap] = nSrfOffs - tSurfOffs[RIB_TYPE.SUPPORT][nOverlap] = nSrfOffs - end - elseif nType == RIB_TYPE.EXTERNAL then - if nSrfExt ~= GDB_ID.NULL then - local dNewOffs = dOffs + ( 0.5 - nOverlap / 100) * dStrand - local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrfExt, nGrp, dNewOffs, vtSlicing) - if not bOk then - -- considero la superficie senza overlap corretto - EgtOutLog( 'Warning: rib without correct overlap (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - nSrfOffs = EgtCopyGlob( nSrfExt, nGrp) - end - tSurfOffs[nType][nOverlap] = nSrfOffs - EgtSetName( nSrfOffs, TOT_SHELL_TRIM_SURF) + for nId, dCurrOffs in pairs( tOffs) do + local nCurrType = EgtGetInfo( nId, KEY_RIBS_TYPE, 'i') + if nCurrType == nType and abs( dOffs - dCurrOffs) < GEO.EPS_SMALL then + return nId + end + end + return +end +-------------------------------------------------------------------- +local function ComputeTrimSurfWithOverlapsForRibs( vIds, nGrp, nSrfInt, nSrfExt, nLoopGrp) + -- ad ogni setto ottenuto dallo slicing associo la superficie con cui fare trim : nSurfId se setto da trimmare, nil se setto da cancellare, GDB_ID.NULL se setto da non trimmare + + local tOffs = {} + local tSurfOffs = {} + for i = 1, #vIds do + local dStrand = EgtGetInfo( vIds[i], KEY_RIBS_STRAND, 'd') + local dOverlap = EgtGetInfo( vIds[i], KEY_RIBS_OVERLAP, 'd') + local nType = EgtGetInfo( vIds[i], KEY_RIBS_TYPE, 'i') + local dOffs = dStrand * ( 0.5 - dOverlap / 100) + + -- verifico se la superficie è già stata calcolata + local nRefId = FindRibWithSameTrimSurf( tOffs, dOffs, nType) + if nRefId then + tSurfOffs[vIds[i]] = tSurfOffs[nRefId] + else + + if nType == RIB_TYPE.INTERNAL or nType == RIB_TYPE.SUPPORT then + if nSrfInt == GDB_ID.NULL then + -- se la superficie non esiste non c'è spazio per il setto che va cancellato + EgtOutLog( 'Warning : rib not possibile (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') else - -- se la superficie non esiste, il setto è sicuramente esterno ( è analogo ad unbounded) - tSurfOffs[nType][nOverlap] = GDB_ID.NULL + local nTrimSurf, bNoOverlap = ComputeTrimSurf( nSrfInt, nGrp, dStrand, dOverlap) + if not nTrimSurf then + EgtOutLog( 'Error : creation of trim region for internal rib failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of trim region for rib failed') + elseif nTrimSurf == GDB_ID.NULL then + EgtOutLog( 'Warning : rib not possibile (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + else + if bNoOverlap then + EgtOutLog( 'Warning : internal rib without correct overlap (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + end + EgtSetName( nTrimSurf, TOT_SHELL_TRIM_SURF) + tSurfOffs[vIds[i]] = nTrimSurf + end end + + elseif nType == RIB_TYPE.EXTERNAL then + if not nSrfExt then + -- errore nella creazione della superficie, il setto va cancellato + EgtOutLog( 'Error : creation of trim region for external rib failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of trim region for external rib failed') + elseif nSrfExt == GDB_ID.NULL then + -- se la superficie non esiste il setto va conservato + tSurfOffs[vIds[i]] = GDB_ID.NULL + else + local nTrimSurf, bNoOverlap = ComputeTrimSurf( nSrfExt, nGrp, - dStrand, dOverlap) + if not nTrimSurf then + EgtOutLog( 'Error : creation of trim region for external rib failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of trim region for external rib failed') + else + if bNoOverlap then + EgtOutLog( 'Warning : external rib without correct overlap (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + end + EgtSetName( nTrimSurf, TOT_SHELL_TRIM_SURF) + tSurfOffs[vIds[i]] = nTrimSurf + end + end + else - tSurfOffs[nType][nOverlap] = GDB_ID.NULL + -- se unbounded non va mai trimmato + tSurfOffs[vIds[i]] = GDB_ID.NULL + end + + tOffs[vIds[i]] = dOffs + end + end + + -- estraggo i contorni + local vSurfIds = EgtGetNameInGroup( nGrp, TOT_SHELL_TRIM_SURF) or {} + for i = 1, #vSurfIds do + local nChunksNbr = EgtSurfFrChunkCount( vSurfIds[i]) + for j = 0, nChunksNbr - 1 do + local nRes, nCnt = EgtExtractSurfFrChunkLoops( vSurfIds[i], j, nLoopGrp) + for k = nRes, nRes + nCnt - 1 do + EgtSetName( k, TRIM_SURF_LOOP) end end end + return tSurfOffs end -------------------------------------------------------------------- -local function VerifyRibsIntersection( nRib1, nRib2, nType1, nType2, nSrf1, nSrf2, dStrand, nGrp, nOffsGrp) +local function VerifyRibsIntersectionValidity( nIntersId, nSrfInt, nSrfExt, nType1, nType2) + + if nType1 == RIB_TYPE.UNBOUNDED and nType2 == RIB_TYPE.UNBOUNDED then + -- l'intersezione è sempre valida + return true + elseif nType1 == RIB_TYPE.EXTERNAL or nType2 == RIB_TYPE.EXTERNAL then + if not nSrfExt or nSrfExt == GDB_ID.NULL then + -- se la surf non esiste l'intersezione è sicuramente esterna + return true + else + -- l'intersezione deve essere esterna + return EgtSurfFrTestExternal( nSrfExt, nIntersId) + end + else + if nSrfInt == GDB_ID.NULL then + -- se la superficie non esiste, l'intersezione è sicuramente esterna + return false + else + -- l'intersezione deve essere interna + return not EgtSurfFrTestExternal( nSrfInt, nIntersId) + end + end + + return false +end + +-------------------------------------------------------------------- +local function VerifyRibsIntersection( nRib1, nRib2, nType1, nType2, nSrfInt, nSrfExt, nGrp, nOffsGrp) + -- restituisce se intersezione ( bInters) e se taglio va forzato sulla curva1 ( bForceCrv1Cut) -- setti interni/supporto ed esterni non si possono intersecare per definizione if ( ( nType1 == RIB_TYPE.INTERNAL or nType1 == RIB_TYPE.SUPPORT) and nType2 == RIB_TYPE.EXTERNAL) or ( nType1 == RIB_TYPE.EXTERNAL and ( nType2 == RIB_TYPE.INTERNAL or nType2 == RIB_TYPE.SUPPORT)) then - return false + return false, false end -- se hanno lo stesso nome derivano dalla stessa costolatura quindi non ha senso controllare intersezione -- ( non vengono gestiti setti che si autointersecano) if EgtGetName( nRib1) == EgtGetName( nRib2) then - return false + return false, false end - local bInters = false - local bForceCrv1Cut = false - -- porto le curve nel gruppo locale local nCrv1 = EgtCopyGlob( nRib1, nGrp) local nCrv2 = EgtCopyGlob( nRib2, nGrp) - -- verifico se si intersecano nel piano XY definito dal gruppo locale - local nId, nPntCnt, nCrvCnt = EgtCurveCurveInters( nCrv1, nCrv2, nGrp) - -- se si intersecano verifico se ho intersezioni valide - if nId then + -- verifico se si intersecano nel piano XY definito dal gruppo locale in modo valido + local bForceCrv1Cut = false + local nOrigInt, nPntCnt, nCrvCnt = EgtCurveCurveInters( nCrv1, nCrv2, nGrp) + if nOrigInt then + local bInters = false -- scorro tutti i punti di intersezione trovati - for i = 0, nPntCnt - 1 do - local nPtId = nId + i - -- verifico se valida - if nType1 == RIB_TYPE.UNBOUNDED and nType2 == RIB_TYPE.UNBOUNDED then - -- nel caso unbounded l'intersezione può essere ovunque - bInters = true - elseif nType1 == RIB_TYPE.EXTERNAL or nType2 == RIB_TYPE.EXTERNAL then - if nSrf2 then - -- l'intersezione deve essere esterna - if EgtSurfFrTestExternal( nSrf2, nPtId) then bInters = true end - else - -- se la surf non esiste l'intersezione è sicuramente esterna - bInters = true - end - else - -- se uno dei due è interno o supporto l'intersezione deve essere interna - if nSrf1 and not EgtSurfFrTestExternal( nSrf1, nPtId) then bInters = true end - end + for nPtId = nOrigInt, nOrigInt + nPntCnt - 1 do - -- se valida verifico se forza il taglio sulla curva 1 - if bInters then - local ptInt = EgtSP( nPtId, GDB_ID.ROOT) - local dPar1 = EgtCurveParamAtPoint( nCrv1, ptInt, GEO.EPS_SMALL, GDB_RT.GLOB) - local dPar2 = EgtCurveParamAtPoint( nCrv2, ptInt, GEO.EPS_SMALL, GDB_RT.GLOB) - local _, dParE1 = EgtCurveDomain( nCrv1) - local _, dParE2 = EgtCurveDomain( nCrv2) - - local bCrv1OnExtr = ( dPar1 < 10 * GEO.EPS_SMALL or abs( dPar1 - dParE1) < 10 * GEO.EPS_SMALL) - local bCrv2OnExtr = ( dPar2 < 10 * GEO.EPS_SMALL or abs( dPar2 - dParE2) < 10 * GEO.EPS_SMALL) - bForceCrv1Cut = ( bCrv1OnExtr and not bCrv2OnExtr) - + -- verifico se forza il taglio sulla curva 1 ( indipendentemente dalla validità) + if not bForceCrv1Cut then + local ptInt = EgtSP( nPtId, GDB_ID.ROOT) + local dPar1 = EgtCurveParamAtPoint( nCrv1, ptInt, GEO.EPS_SMALL, GDB_RT.GLOB) + local dPar2 = EgtCurveParamAtPoint( nCrv2, ptInt, GEO.EPS_SMALL, GDB_RT.GLOB) + local _, dParE1 = EgtCurveDomain( nCrv1) + local _, dParE2 = EgtCurveDomain( nCrv2) + + local bCrv1OnExtr = ( dPar1 < 10 * GEO.EPS_SMALL or abs( dPar1 - dParE1) < 10 * GEO.EPS_SMALL) + local bCrv2OnExtr = ( dPar2 < 10 * GEO.EPS_SMALL or abs( dPar2 - dParE2) < 10 * GEO.EPS_SMALL) + bForceCrv1Cut = bCrv1OnExtr and not bCrv2OnExtr + end + + if VerifyRibsIntersectionValidity( nPtId, nSrfInt, nSrfExt, nType1, nType2) then + bInters = true if bForceCrv1Cut then - return bInters, bForceCrv1Cut -- true, true + return true, true -- intersezione, forza taglio sulla crv1 end end end - return bInters, bForceCrv1Cut -- true/false, false - - else - -- se non si intersecano, verifico se si intersecano i loro offset - local vOffs1 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv1)) or {} - local vOffs2 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv2)) or {} - for i = 1, #vOffs1 do - local nSrfOffs1 = EgtSurfFrFatCurve( nGrp, vOffs1[i], 0.5 * dStrand, false) - if nSrfOffs1 then - for j = 1, #vOffs2 do - -- verifico se intersezione - local nRes = EgtCurveWithRegionClassify( vOffs2[j], nSrfOffs1) - if nRes == GDB_CRC.IN or nRes == GDB_CRC.INTERS then + if bInters then + return true, false -- intersezione, non forza taglio su crv1 + end + end + + -- se le curve non si intersecano in modo valido, verifico se lo fanno i loro offset + local vOffs1 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv1)) or {} + local vOffs2 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv2)) or {} + local nOffs1Inters = 0 -- numero di offset di nCrv1 coinvolti nelle intersezioni + for i = 1, #vOffs1 do + local nOffs1 = EgtCopyGlob( vOffs1[i], nGrp) + local bInters = false + for j = 1, #vOffs2 do + if bInters then break end -- se già trovato intersezione non ho bisogno di analizzare gli altri offset + local nOffs2 = EgtCopyGlob( vOffs2[j], nGrp) + local nId, nPntCnt, nCrvCnt = EgtCurveCurveInters( nOffs1, nOffs2, nGrp) + if nId then + for nPtId = nId, nId + nPntCnt - 1 do + if VerifyRibsIntersectionValidity( nPtId, nSrfInt, nSrfExt, nType1, nType2) then + -- intersezione valida bInters = true + nOffs1Inters = nOffs1Inters + 1 break end end - if bInters then break end end end - - return bInters, bForceCrv1Cut -- true, false end + if nOffs1Inters > 0 then + if nOrigInt then + -- se i setti originiari si intersecavano il forzare il taglio sulla curva1 dipende dalla loro intersezione anche se non valida + return true, bForceCrv1Cut + else + return true, nOffs1Inters == #vOffs1 + end + end + + -- se le curve di offset non si intersecano verifico se lo fanno le loro SurfFatCurve + local dStrand1 = EgtGetInfo( nCrv1, KEY_RIBS_STRAND, 'd') + local dStrand2 = EgtGetInfo( nCrv2, KEY_RIBS_STRAND, 'd') + local dOverlap2 = EgtGetInfo( nCrv2, KEY_RIBS_OVERLAP, 'd') + for i = 1, #vOffs1 do + for j = 1, #vOffs2 do + local nSrfOffs = EgtSurfFrFatCurve( nGrp, vOffs1[i], 0.5 * dStrand1 + dStrand2 * ( 0.5 - dOverlap2 / 100), false) + if nSrfOffs then + local nRes = EgtCurveWithRegionClassify( vOffs2[j], nSrfOffs) + if nRes ~= GDB_CRC.OUT then + return true, false + end + end + end + end + + return false, false end --------------------------------------------------------------------------------- -- Funzione che sistema le intersezioni fra costolature nel caso generico -local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nOffsGrp, nLoopGrp, tSurfOffs, nType2) - - -- calcolo la superficie della curva principale ( nCrv1) da usare per trim - local nShells = EgtGetInfo( nCrv1, KEY_RIBS_SHELLS_NBR, 'i') - local nOverlap = EgtGetInfo( nCrv2, KEY_RIBS_OVERLAP, 'i') - local dOffs = ( nShells - 1) * LayerParams.dStrand / 2 - local nSrf = EgtSurfFrFatCurve( nOffsGrp, nCrv1, dOffs + ( 1 - nOverlap / 100) * LayerParams.dStrand, false) - if not nSrf then return end - - -- trim degli offset della curva secondaria ( nCrv2) +local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, nOffsGrp, nLoopGrp, nSrfTrim, nType2) + + -- recupero gli offset della curva secondaria ( nCrv2) local vOffs2 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv2)) or {} + + local nShells = EgtGetInfo( nCrv1, KEY_RIBS_SHELLS_NBR, 'i') + local dStrand1 = EgtGetInfo( nCrv1, KEY_RIBS_STRAND, 'd') + local dOverlap = EgtGetInfo( nCrv2, KEY_RIBS_OVERLAP, 'i') + local dStrand2 = EgtGetInfo( nCrv2, KEY_RIBS_STRAND, 'd') + + if dOverlap / 100 * dStrand2 > nShells * dStrand1 * 0.5 - GEO.EPS_SMALL then + -- non ha senso spezzare la curva, aggiorno solo split order dei suoi offset + for i = 1, #vOffs2 do + CopyInfo( nCrv2, vOffs2[i], KEY_SPLIT_ORDER, 'i') + end + return + end + + -- calcolo la superficie della curva principale ( nCrv1) da usare per trim + local dOffs = nShells * dStrand1 * 0.5 + dStrand2 * ( 0.5 - dOverlap / 100) + local nSrf = EgtSurfFrFatCurve( nOffsGrp, nCrv1, dOffs, false) + if not nSrf then + EgtOutLog( 'Error : ribs intersection failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing ribs intersection') + return + end for i = 1, #vOffs2 do local nId, nCnt = EgtTrimCurveWithRegion( vOffs2[i], nSrf, false, true) @@ -1431,10 +1548,9 @@ local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nOffs -- salvo i loop da usare nel toolpath per ingressi e uscite local nSrfRef -- recupero la superficie di bordo con lo stesso overlap - local nSrfTrim = tSurfOffs[nType2][nOverlap] if nSrfTrim and nSrfTrim ~= GDB_ID.NULL then nSrfRef = EgtCopyGlob( nSrfTrim, nLoopGrp) - if nType2 == RIB_TYPE.INTERNAL then + if nType2 == RIB_TYPE.INTERNAL or nType2 == RIB_TYPE.SUPPORT then EgtSurfFrSubtract( nSrfRef, nSrf) elseif nType2 == RIB_TYPE.EXTERNAL then EgtSurfFrAdd( nSrfRef, nSrf) @@ -1458,30 +1574,23 @@ end -------------------------------------------------------------------- -- Funzione che sistema le intersezioni fra costolature nel caso di 2 passate -local function AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nOffsGrp) +local function AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, nOffsGrp) -- costruisco le superfici da usare per trim - local nSrf1 = EgtSurfFrFatCurve( nOffsGrp, nCrv1, LayerParams.dStrand / 2, false) - local vtN1 = EgtSurfFrNormVersor( nSrf1, GDB_ID.ROOT) - if LayerParams.vtSlicing * vtN1 < 0 then - EgtInvertSurf( nSrf1) - end - - local nSrf2 = EgtSurfFrFatCurve( nOffsGrp, nCrv2, LayerParams.dStrand / 2, false) - local vtN2 = EgtSurfFrNormVersor( nSrf2, GDB_ID.ROOT) - if LayerParams.vtSlicing * vtN2 < 0 then - EgtInvertSurf( nSrf2) - end + local dStrand1 = EgtGetInfo( nCrv1, KEY_RIBS_STRAND, 'd') + local nSrf1 = EgtSurfFrFatCurve( nOffsGrp, nCrv1, dStrand1 * 0.5, false) + local dStrand2 = EgtGetInfo( nCrv2, KEY_RIBS_STRAND, 'd') + local nSrf2 = EgtSurfFrFatCurve( nOffsGrp, nCrv2, dStrand2 * 0.5, false) -- trim degli offset di nCrv1 local vOffs1 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv1)) or {} for i = 1, #vOffs1 do local nId, nCnt = EgtTrimCurveWithRegion( vOffs1[i], nSrf2, false, true) - end + end -- trim degli offset di nCrv2 local vOffs2 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv2)) or {} - for i = 1, #vOffs2 do + for i = 1, #vOffs2 do local nId, nCnt = EgtTrimCurveWithRegion( vOffs2[i], nSrf1, false, true) end @@ -1514,42 +1623,24 @@ local function UpdateSplitOrder( nCrv, tInters, nOffsGrp) end end ---------------------------------------------------------------------------------- -local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, nLoopGrp, bAllTwoStrands, vTypeSequence, tSurfOffs) - +------------------------------------------------------------------ +local function HandleRibsIntersections( nRibsGrp, nOffsGrp, nRibsPathGrp, vtSlicing, nSrfInt, nSrfExt, bAllTwoStrands, vTypeSequence, nLoopGrp, tSurfOffs) + local bSpecialCase = false - local vRibsIds = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') - -- copio gli offset delle costolature nel RibsPathGrp - local nCrvGrp = EgtGetParent( nRibsPathGrp) - local vOffsRib = EgtGetAllInGroup( nOffsGrp) - for i = 1, #vOffsRib do - EgtCopyGlob( vOffsRib[i], nRibsPathGrp) + local vOffsIds = EgtGetNameInGroup( nRibsPathGrp, RIBS_CRV .. '*') -- passate dei setti + local vAllRibsIds = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') -- setti originali + local vRibsIds = {} + -- ignoro setti che non hanno passate corrispondenti + for i = 1, #vAllRibsIds do + local vOffs = EgtGetNameInGroup( nRibsPathGrp, EgtGetName( vAllRibsIds[i])) + if vOffs then table.insert( vRibsIds, vAllRibsIds[i]) end end -- creo un gruppo con frame locale per calcolare le intersezioni ( è il piano XY locale dove calcolare intersezioni) - local frLoc = Frame3d( ORIG(), LayerParams.vtSlicing) + local frLoc = Frame3d( ORIG(), vtSlicing) local nGrpTmp = EgtGroup( nRibsGrp, frLoc, GDB_RT.GLOB) - - -- calcolo le regioni nella quali ha senso considerare l'intersezione - local nSrfOffs1, nSrfOffs2 - local bOk, bExists - local nSrf1 = EgtGetFirstNameInGroup( nCrvGrp, TOT_SHELL_TRIM_SURF) or GDB_ID.NULL - if nSrf1 ~= GDB_ID.NULL then - bOk, bExists, nSrfOffs1 = ComputeSurfOffset( nSrf1, nCrvGrp, 2 * LayerParams.dStrand, LayerParams.vtSlicing) - if not bOk or not bExists then - nSrfOffs1 = EgtCopyGlob( nSrf1, nCrvGrp) - end - end - local nSrf2 = EgtGetFirstNameInGroup( nCrvGrp, LAYER_SRF) or GDB_ID.NULL - if nSrf2 ~= GDB_ID.NULL then - bOk, bExists, nSrfOffs2 = ComputeSurfOffset( nSrf2, nCrvGrp, - 2 * LayerParams.dStrand, LayerParams.vtSlicing) - if not bOk or not bExists then - nSrfOffs2 = EgtCopyGlob( nSrf2, nCrvGrp) - end - end - + local bInters = false - local vSplit = {} local tInters = {} -- tabella che tiene traccia delle intersezioni trovate for i = 1, #vRibsIds do local nType1 = EgtGetInfo( vRibsIds[i], KEY_RIBS_TYPE, 'i') @@ -1557,8 +1648,8 @@ local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPa -- verifico se interseca uno dei setti successivi for j = i + 1, #vRibsIds do local nType2 = EgtGetInfo( vRibsIds[j], KEY_RIBS_TYPE, 'i') + local bRibInters, bForceCrv1Cut = VerifyRibsIntersection( vRibsIds[i], vRibsIds[j], nType1, nType2, nSrfInt, nSrfExt, nGrpTmp, nOffsGrp) - local bRibInters, bForceCrv1Cut = VerifyRibsIntersection( vRibsIds[i], vRibsIds[j], nType1, nType2, nSrfOffs1, nSrfOffs2, LayerParams.dStrand, nGrpTmp, nOffsGrp) if bRibInters then bInters = true @@ -1594,24 +1685,21 @@ local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPa if bAllTwoStrands and ( nType1 == nType2) then -- nel caso di 2 passate e stessa tipologia gestione speciale per creare unico percorso - AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nRibsPathGrp) + AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, nRibsPathGrp) bSpecialCase = true else - AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nRibsPathGrp, nLoopGrp, tSurfOffs, nType2) + AdjustRibsOffsetForIntersection( nCrv1, nCrv2, nRibsPathGrp, nLoopGrp, tSurfOffs[nCrv2], nType2) end end end end - EgtErase( nSrfOffs1) - EgtErase( nSrfOffs2) EgtErase( nGrpTmp) - return bInters, bSpecialCase end --------------------------------------------------------------------- -local function ReorderSplitRibs( vIds, dStrand, bParamInvertOrder) +local function ReorderSplitRibs( vIds, bParamInvertOrder) -- individuo i setti che derivano da uno stesso pezzo di costolatura local tabRibs = {} @@ -1638,6 +1726,7 @@ local function ReorderSplitRibs( vIds, dStrand, bParamInvertOrder) if nSplitOrder > 0 or bSplitAfterTrim then -- caso di setti splittati local nShells = EgtGetInfo( tabVal[1], KEY_RIBS_SHELLS_NBR, 'i') + local dStrand = EgtGetInfo( tabVal[1], KEY_RIBS_STRAND, 'd') if nShells == 1 then -- non è necessario il riordino, associo splitId diversi ad ogni tratto per gestire correttamente il link nel CalcToolPath for i = 1, #tabVal do @@ -1654,7 +1743,7 @@ local function ReorderSplitRibs( vIds, dStrand, bParamInvertOrder) local bCurrSplitAfterTrim = EgtGetInfo( nCurrId, KEY_SPLIT_AFTER_TRIM, 'b') or false while nCurrId do local ptCurr = EgtMP( nCurrId) - bFound = false + local bFound = false for j = 1, #tabVal do local dDist1 = EgtPointCurveDist( ptCurr, tabVal[j]) local dDist2 = EgtPointCurveDist( EgtMP( tabVal[j]), nCurrId) @@ -1821,13 +1910,13 @@ local function ShortestPathForRibs( vRibs, nGrp, bInvertOrder) end -------------------------------------------------------------------- -local function ReorderRibs( nGrp, bInvertOrder, dStrand) +local function ReorderRibs( nGrp, bInvertOrder) local vIds = EgtGetNameInGroup( nGrp, RIBS_CRV .. '*') if not vIds or #vIds == 0 then return end -- riordino setti splittati - ReorderSplitRibs( vIds, dStrand, bInvertOrder) + ReorderSplitRibs( vIds, bInvertOrder) -- aggiorno gli id con il nuovo ordinamento vIds = EgtGetNameInGroup( nGrp, RIBS_CRV .. '*') @@ -1887,10 +1976,11 @@ local function ReassignInfo( nCrv, nCnt, vOrig) -- verifico se corrisponde al suo start if AreSamePointApprox( ptS, ptSOrig) or AreSamePointApprox( ptS, ptEOrig) then + CopyInfo( vOrig[i], nId, KEY_RIBS_STRAND, 'd') CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_IN_INVERT, 'b') CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_IN_LEN, 'd') CopyInfo( vOrig[i], nId, KEY_ASSOCIATED_SURF, 'i') - CopyInfo( vOrig[i], nId, KEY_RIBS_OVERLAP, 'i') + CopyInfo( vOrig[i], nId, KEY_RIBS_OVERLAP, 'd') CopyInfo( vOrig[i], nId, KEY_RIBS_TYPE, 'i') CopyInfo( vOrig[i], nId, KEY_RIBS_LINK, 'b') bStart = true @@ -1916,7 +2006,7 @@ end --------------------------------------------------------------------------------------------- -- Funzione che riordina le costolature nel caso di intersezioni e 2 passate -local function ReorderRibsInters2Shells( nOffsGrp, dStrand, bInvertOrder) +local function ReorderRibsInters2Shells( nOffsGrp, bInvertOrder) local vOffs = {} local vClosed = {} @@ -1955,6 +2045,7 @@ local function ReorderRibsInters2Shells( nOffsGrp, dStrand, bInvertOrder) local nNewId = EgtCopy( vOffs[i], nOffsGrp) table.insert( vCopy, nNewId) end + local dStrand = EgtGetInfo( vCopy[1], KEY_RIBS_STRAND, 'd') -- concateno le curve local nCrv, nCnt = EgtCurveCompoByChain( nOffsGrp, vOffs, ORIG()) @@ -1968,7 +2059,7 @@ local function ReorderRibsInters2Shells( nOffsGrp, dStrand, bInvertOrder) while #vIds > 0 do k = k + 1 -- prendo la prima tra le curve a disposizione - nCurrCrv = vIds[1] + local nCurrCrv = vIds[1] table.remove( vIds, 1) EgtSetName( nCurrCrv, RIBS_CRV .. tostring(k)) local pt = EgtEP( nCurrCrv) @@ -2067,7 +2158,6 @@ local function ReorderRibsInters2Shells( nOffsGrp, dStrand, bInvertOrder) EgtRelocateGlob( vRibs[j], nOffsGrp, GDB_IN.LAST_SON) end end - end ------------------------------------------------------------------- @@ -2088,18 +2178,21 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart) end local vOrigRibs = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') - -- verifico se tutte le costolature vengono fatte con 2 passate + + -- verifico se tutte le costolature vengono fatte con 2 passate e con lo stesso strand local bAllTwoStrands = true + local dStrandRef = EgtGetInfo( vOrigRibs[1], KEY_RIBS_STRAND, 'd') for i = 1, #vOrigRibs do - local nStrand = EgtGetInfo( vOrigRibs[i], KEY_RIBS_SHELLS_NBR, 'i') - if nStrand ~= 2 then + local nShells = EgtGetInfo( vOrigRibs[i], KEY_RIBS_SHELLS_NBR, 'i') + local dStrand = EgtGetInfo( vOrigRibs[i], KEY_RIBS_STRAND, 'd') + if nShells ~= 2 or abs( dStrand - dStrandRef) > GEO.EPS_SMALL then bAllTwoStrands = false break end end -- verifico se posso ignorare eventuali buchi nei setti - VerifyRibsHoles( vOrigRibs, LayerParams.dStrand) + VerifyRibsHoles( vOrigRibs) -- scorro i gruppi di curve local nCrvGrp = EgtGetFirstNameInGroup( nSliceGrp, CONTOUR_GRP .. '*') @@ -2115,68 +2208,65 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart) EgtEmptyGroup( nRibsPathGrp) end - -- recupero le superfici - local nSrfBase = EgtGetFirstNameInGroup( nCrvGrp, TOT_SHELL_TRIM_SURF) or GDB_ID.NULL - local nSrfExt = EgtGetFirstNameInGroup( nCrvGrp, LAYER_SRF) or GDB_ID.NULL - + -- recupero le superfici occupate dalle shell + local nSrfInt = EgtGetFirstNameInGroup( nCrvGrp, TOT_SHELL_TRIM_SURF) or GDB_ID.NULL + local nSrfExt = GDB_ID.NULL + local nSrfLay = EgtGetFirstNameInGroup( nCrvGrp, LAYER_SRF) + if nSrfLay then + nSrfExt = ComputeSurfOffset( nSrfLay, nCrvGrp, LayerParams.dOffs) + if not nSrfExt then + EgtOutLog( 'Error : creation of trim region for external ribs failed. Errors may occur also with internal user-linked ribs (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing trim region for external ribs') + end + end + -- trim grossolano dei setti - local nTrimGrp = TrimRibs( vOrigRibs, nRibsGrp, nSrfExt, LayerParams.dOffs - LayerParams.dStrand / 2, LayerParams.vtSlicing) + local nTrimGrp = TrimRibs( vOrigRibs, nRibsGrp, nSrfExt, nSrfInt, LayerParams.vtSlicing) -- calcolo offset orientati - local nOffsGrp = ComputeRibsOrientedOffset( nTrimGrp, LayerParams.dStrand) - - -- creo le superfici con cui fare i trim corretti - local tSurfOffs = ComputeTrimSurfWithOverlapsForRibs( vOrigRibs, nSrfBase, nSrfExt, LayerParams.dOffs, LayerParams.dStrand, nRibsPathGrp, LayerParams.vtSlicing) + local nOffsGrp = ComputeRibsOrientedOffset( nTrimGrp) -- preparo il gruppo con i contorni delle superfici di offset ( necessario per CalcToolPath) local nLoopGrp = EgtGroup( nRibsPathGrp) - local nSrfId = EgtGetFirstNameInGroup( nRibsPathGrp, TOT_SHELL_TRIM_SURF) - while nSrfId do - local nChunksNbr = EgtSurfFrChunkCount( nSrfId) - for i = 0, nChunksNbr - 1 do - local nRes, nCnt = EgtExtractSurfFrChunkLoops( nSrfId, i, nLoopGrp) - for j = nRes, nRes + nCnt - 1 do - EgtSetName( j, TRIM_SURF_LOOP) - end - end - nSrfId = EgtGetNextName( nSrfId, TOT_SHELL_TRIM_SURF) + + -- creo le superfici con cui fare i trim corretti e ne estraggo contorni + local tSurfOffs = ComputeTrimSurfWithOverlapsForRibs( vOrigRibs, nRibsPathGrp, nSrfInt, nSrfExt, nLoopGrp) + + -- copio gli offset delle costolature nel PathGrp + local vOffsRib = EgtGetAllInGroup( nOffsGrp) + for i = 1, #vOffsRib do + EgtCopyGlob( vOffsRib[i], nRibsPathGrp) end - - -- gestisco eventuali intersezioni fra costolature - local bInters, bSpecialCase = HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, nLoopGrp, bAllTwoStrands, vTypeSequence, tSurfOffs) - EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_INTERS, bInters) - EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_SPECIAL_CASE, bSpecialCase) -- trim dei setti con le regioni offsettate secondo opportuno overlap local vRibs = EgtGetNameInGroup( nRibsPathGrp, RIBS_CRV ..'*') or {} for i = 1, #vRibs do local nCrvId = vRibs[i] -- trim con superficie opportuna - local nOverlap = EgtGetInfo( nCrvId, KEY_RIBS_OVERLAP, 'i') local nType = EgtGetInfo( nCrvId, KEY_RIBS_TYPE, 'i') - if not tSurfOffs[nType][nOverlap] then + local nStartRib = EgtGetInfo( nCrvId, KEY_START_RIB, 'i') + if not tSurfOffs[nStartRib] then -- la costolatura non è fattibile - EgtOutLog( 'Warning: Rib not possibile (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - EgtErase( vRibs[i]) + EgtErase( nCrvId) else local nCrv, nCnt - if tSurfOffs[nType][nOverlap] == GDB_ID.NULL then - -- caso unbounded o esterno in assenza di solido + if tSurfOffs[nStartRib] == GDB_ID.NULL then + -- il setto non va trimmato ( caso di rib unbounded o rib esterno senza solido) nCrv = nCrvId nCnt = 1 else - nCrv, nCnt = EgtTrimCurveWithRegion( nCrvId, tSurfOffs[nType][nOverlap], EgtIf( nType == RIB_TYPE.INTERNAL or nType == RIB_TYPE.SUPPORT, true, false), false) + nCrv, nCnt = EgtTrimCurveWithRegion( nCrvId, tSurfOffs[nStartRib], EgtIf( nType == RIB_TYPE.INTERNAL or nType == RIB_TYPE.SUPPORT, true, false), false) end for nInd = 0, nCnt - 1 do - -- verifico vicolo sulla lunghezza + -- verifico vincolo sulla lunghezza local dLen = EgtCurveLength( nCrv + nInd) if dLen < MIN_RIBS_LEN then EgtErase( nCrv + nInd) else -- salvo info della superficie di trim associata - EgtSetInfo( nCrv + nInd, KEY_ASSOCIATED_SURF, tSurfOffs[nType][nOverlap]) + EgtSetInfo( nCrv + nInd, KEY_ASSOCIATED_SURF, tSurfOffs[nStartRib]) -- setti chiusi if EgtCurveIsClosed( nCrv + nInd) then @@ -2207,28 +2297,32 @@ local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, vPtStart) end end + -- gestisco eventuali intersezioni fra costolature + local bInters, bSpecialCase = HandleRibsIntersections( nRibsGrp, nOffsGrp, nRibsPathGrp, LayerParams.vtSlicing, nSrfInt, nSrfExt, bAllTwoStrands, vTypeSequence, nLoopGrp, tSurfOffs) + EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_INTERS, bInters) + EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_SPECIAL_CASE, bSpecialCase) + -- riordino le costolature if bSpecialCase then -- gestione caso speciale di intersezione e 2 passate - ReorderRibsInters2Shells( nRibsPathGrp, LayerParams.dStrand, LayerParams.bRibsInvertOrder) + ReorderRibsInters2Shells( nRibsPathGrp, LayerParams.bRibsInvertOrder) else - ReorderRibs( nRibsPathGrp, LayerParams.bRibsInvertOrder, LayerParams.dStrand) + ReorderRibs( nRibsPathGrp, LayerParams.bRibsInvertOrder) end + -- sistemo le quote dei loop per CalcToolPath + local vLoopIds = EgtGetAllInGroup( nLoopGrp) or {} + for i = 1, #vLoopIds do + EgtMove( vLoopIds[i], LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) + end + + -- elimino superficie per check + EgtErase( nSrfExt) + if not EgtGetFirstNameInGroup( nRibsPathGrp, RIBS_CRV .. '*') then EgtErase( nRibsPathGrp) end - -- sistemo le quote delle superfici e dei loop per CalcToolPath - local vLoopIds = EgtGetAllInGroup( nLoopGrp) or {} - for i = 1, #vLoopIds do - EgtMove( vLoopIds[i], LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) - end - local vSrfIds = EgtGetNameInGroup( nRibsPathGrp, TOT_SHELL_TRIM_SURF) or {} - for i = 1, #vSrfIds do - EgtMove( vSrfIds[i], LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) - end - nCrvGrp = EgtGetNextName( nCrvGrp, CONTOUR_GRP .. '*') end end @@ -2259,10 +2353,10 @@ local function CreateShellNbrSurfaces( nGrp, nShellsNbr) table.insert( tDiffCrvs[nShellNbrDiff], nCrvId) end else - EgtOutLog( 'Warning: ReducedShellNumber is too small (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + EgtOutLog( 'Warning : ReducedShellNumber is too small (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') end else - EgtOutLog( 'Error: ReducedShellNumber is not closed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + EgtOutLog( 'Error : ReducedShellNumber is not closed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : ReducedShellNumber is not closed') end @@ -2300,7 +2394,7 @@ local function CreateShellNbrSurfaces( nGrp, nShellsNbr) end end if not bOk then - EgtOutLog( 'Error: ReducedShellNumber is not considered (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + EgtOutLog( 'Error : ReducedShellNumber is not considered (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : ReducedShellNumber is not considered') end end @@ -2377,8 +2471,10 @@ local function TrimOuterCurveForExtraShellCalc( nOuterCrv, nSrfDiff, nGrpId, vPt nCnt = nCnt - 1 end - -- assegno le info in base alla curva che li delimita for nId = nCrv, nCrv + nCnt - 1 do + -- assegno estrusione + EgtModifyCurveExtrusion( nCrv, LayerParams.vtSlicing, GDB_RT.GLOB) + -- assegno le info per leadout local ptS = EgtSP( nId) local dCoastingS, dWipeS, dWipeDirS = FindExtraShellRetractionParams( ptS, vShellNbrCrvs, LayerParams) local ptE = EgtEP( nId) @@ -2394,30 +2490,79 @@ local function TrimOuterCurveForExtraShellCalc( nOuterCrv, nSrfDiff, nGrpId, vPt end -------------------------------------------------------------------- -local function UpdateTotalShellSurf( nSrf, nCrv, dStrand, nGrpId) - - local nSrfExtraShell = EgtSurfFrFatCurve( nGrpId, nCrv, dStrand - s_dOffsCorr, false) +local function UpdateTrimSurfWithExtraShell( nSrf, nCrv, dStrand, nGrpId) + + local nSrfExtraShell = EgtSurfFrFatCurve( nGrpId, nCrv, dStrand * 0.5 + s_dOffsCorr * 0.5, true) if nSrfExtraShell then - local vtSrfN = EgtSurfFrNormVersor( nSrf, GDB_ID.ROOT) - local vtSrfExShN = EgtSurfFrNormVersor( nSrfExtraShell, GDB_ID.ROOT) - if vtSrfExShN * vtSrfN < 0 then - EgtInvertSurf( nSrfExtraShell) + if not EgtSurfFrSubtract( nSrf, nSrfExtraShell) then + EgtOutLog( 'Error : EgtSurfFrSubtract with ExtraShell for TotTrimSurfRegion failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements') + else + EgtErase( nSrfExtraShell) end - EgtSurfFrSubtract( nSrf, nSrfExtraShell) - EgtErase( nSrfExtraShell) + else + EgtOutLog( 'Error : creation of ExtraShell region for TotTrimSurfRegion failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements') + end +end + +--------------------------------------------------------------------- +local function AdjustTrimSurfWithExtraShells( nTrimSurf, dOffs, dStrand, nGrpTmp) + + -- calcolo la superficie occupata dalle shell se non ci fossero ReducedShellNumber + local nLaySurf = EgtGetFirstNameInGroup( EgtGetParent( nTrimSurf), LAYER_SRF) + dOffs = dOffs + dStrand * 0.5 + 50 * GEO.EPS_SMALL + local nBaseSurf = ComputeSurfOffset( nLaySurf, nGrpTmp, - dOffs) + if not nBaseSurf then + EgtOutLog( 'Warning : AdjustTrimSurfWithExtraShell base surf computation failed. TrimSurf may be inaccurate (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + return + elseif nBaseSurf == GDB_ID.NULL then + EgtOutLog( 'Warning : AdjustTrimSurfWithExtraShell base surf does not exist. TrimSurf may be inaccurate (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + return + end + local nChunks = EgtSurfFrChunkCount( nBaseSurf) + + -- individuo i chunk della TrimSurf da conservare + local vValidChunks = {} + local nFirstId, nCnt = EgtExplodeSurf( nTrimSurf) + for nId = nFirstId, nFirstId + nCnt - 1 do + -- verifico se è esterno a tutti i chunks di nBaseSurf ( quindi è porzione non riempita tra le shell da eliminare) + local bIsOut = true + for i = 0, nChunks - 1 do + local nRes = EgtSurfFrChunkSimpleClassify( nId, 0, nBaseSurf, i) + if nRes ~= GDB_RC.OUT then + bIsOut = false + break + end + end + + if bIsOut then + EgtErase( nId) + else + -- se compreso nella superficie base va conservato + table.insert( vValidChunks, nId) + end + end + + -- unisco tutti i chunk validi in un'unica superficie + for i = 2, #vValidChunks do + EgtSurfFrAdd( vValidChunks[1], vValidChunks[i]) + EgtErase( vValidChunks[i]) end end --------------------------------------------------------------------- -local function ReorderExtraShells( nPathGrp, dStrand, vPtStart, bPrintInvert) +local function ReorderExtraShells( nPathGrp, vPtStart, LayerParams) - -- verifico se posso unire due tratti consecutivi della stessa shell + -- verifico se posso unire due tratti consecutivi della stessa shell local nFirst = EgtGetFirstNameInGroup( nPathGrp, EXTRA_SHELL_CRV .. '*') while nFirst do -- recupero tratti appartenenti alla stessa shell local sName = EgtGetName( nFirst) local vShells = EgtGetNameInGroup( nPathGrp, sName) + local nType = EgtGetInfo( nFirst, KEY_TYPE, 'i') + local dStrand = EgtIf( nType == TYPE.EXTRA_OUTER_SHELL, LayerParams.dStrand, LayerParams.dInnerStrand) local nCurr = vShells[1] for i = 2, #vShells do if dist( EgtEP( nCurr), EgtSP( vShells[i])) < dStrand + GEO.EPS_SMALL then @@ -2452,7 +2597,7 @@ local function ReorderExtraShells( nPathGrp, dStrand, vPtStart, bPrintInvert) if not vIds then return end -- eventuale inversione di tutte le curve - if bPrintInvert then + if LayerParams.bPrintInvert then for i = 1, #vIds do EgtInvertCurve( vIds[i]) UpdateInvertInfo( vIds[i]) @@ -2464,12 +2609,10 @@ local function ReorderExtraShells( nPathGrp, dStrand, vPtStart, bPrintInvert) while #vIds > 0 do k = k + 1 -- prendo la prima tra le curve a disposizione - nCurrCrv = vIds[1] + local nCurrCrv = vIds[1] table.remove( vIds, 1) EgtSetName( nCurrCrv, EXTRA_SHELL_CRV .. tostring(k)) - - local ptSCurr = EgtSP( nCurrCrv) - local ptECurr = EgtEP( nCurrCrv) + local nCnt = 0 -- se curva è chiusa if EgtCurveIsClosed( nCurrCrv) then @@ -2480,24 +2623,34 @@ local function ReorderExtraShells( nPathGrp, dStrand, vPtStart, bPrintInvert) -- scorro alla ricerca di una curva che posso collegare alla corrente while nCurrCrv do + local ptSCurr = EgtSP( nCurrCrv) + local ptECurr = EgtEP( nCurrCrv) local bFound = false + local nCurrType = EgtGetInfo( nCurrCrv, KEY_TYPE, 'i') + local dCurrStrand = EgtIf( nCurrType == TYPE.EXTRA_OUTER_SHELL, LayerParams.dStrand, LayerParams.dInnerStrand) for j = 1, #vIds do if not EgtCurveIsClosed( vIds[j]) then local ptS = EgtSP( vIds[j]) local ptE = EgtEP( vIds[j]) - - local bLink = dist( ptS, ptECurr) < 1.5 * dStrand - - if dist( ptE, ptECurr) < 1.5 * dStrand then + + local nTypeJ = EgtGetInfo( vIds[j], KEY_TYPE, 'i') + local dStrandJ = EgtIf( nTypeJ == TYPE.EXTRA_OUTER_SHELL, LayerParams.dStrand, LayerParams.dInnerStrand) + local dVal = 1.5 * max( dCurrStrand, dStrandJ) + + local bLink = false + if dist( ptECurr, ptE) < dVal then -- congiungo end-end EgtInvertCurve( vIds[j]) - EgtSetInfo( vIds[j], KEY_INVERTED_CRV, EgtIf( bPrintInvert, 0, 1)) + UpdateInvertInfo( vIds[j]) bLink = true - elseif nCnt == 0 and dist( ptS, ptSCurr) < 1.5 * dStrand then + elseif dist( ptECurr, ptS) < dVal then + -- congiungo start-end + bLink = true + elseif nCnt == 0 and dist( ptSCurr, ptS) < dVal then -- congiungo start-start EgtInvertCurve( nCurrCrv) - EgtSetInfo( nCurrCrv, KEY_INVERTED_CRV, EgtIf( bPrintInvert, 0, 1)) + UpdateInvertInfo( nCurrCrv) bLink = true end @@ -2509,8 +2662,6 @@ local function ReorderExtraShells( nPathGrp, dStrand, vPtStart, bPrintInvert) -- aggiorno per collegamento successivo bFound = true nCurrCrv = vIds[j] - ptSCurr = EgtSP( vIds[j]) - ptECurr = EgtEP( vIds[j]) table.remove( vIds, j) break end @@ -2524,127 +2675,142 @@ local function ReorderExtraShells( nPathGrp, dStrand, vPtStart, bPrintInvert) end end +-------------------------------------------------------------------- +local function FinalizeExtraShellPath( nPathGrp, vPtStart, nTotShellTrim, dOffs, dStrand, LayerParams, nGrpTmp) + + -- riordino shell per creare link + ReorderExtraShells( nPathGrp, vPtStart, LayerParams) + -- aggiorno la trim surf eliminando piccole zone non riempite tra le shell + AdjustTrimSurfWithExtraShells( nTotShellTrim, dOffs, dStrand, nGrpTmp) + -- elimino il gruppo temporaneo usato per i conti + EgtErase( nGrpTmp) + +end + -------------------------------------------------------------------- local function CalcExtraShellsPath( nMaxShellNbrDiff, nShellNbrGrp, nCrvGrpId, dOffs, LayerParams, vPtStart) local nGrpId = EgtGetFirstNameInGroup( nCrvGrpId, PATH_GRP) + local nGrpTmp = EgtGroup( nGrpId) -- gruppo temporaneo per conti - -- recupero la superficie occupata dalle shell per trim - local nSrfTrim = EgtGetFirstNameInGroup( nCrvGrpId, TOT_SHELL_TRIM_SURF) - if not nSrfTrim then + -- recupero la superficie occupata dalle shell + local nTotShellTrim = EgtGetFirstNameInGroup( nCrvGrpId, TOT_SHELL_TRIM_SURF) + if not nTotShellTrim then EgtOutLog( 'Warning : ExtraInnerShells not possible (layer '..tostring( s_nCurrIdx)..') - CalcPaths') return end - + + local dCurrStrand = 0 for nInd = nMaxShellNbrDiff, 1, -1 do - dOffs = dOffs + LayerParams.dStrand * ( 1 - EgtIf( nInd == LayerParams.nShellsNbr, 0, LayerParams.nStrandOverlap / 100)) - + + if nInd == LayerParams.nShellsNbr then + -- devo realizzare la shell esterna + dOffs = dOffs + 0.5 * LayerParams.dStrand + elseif nInd == LayerParams.nShellsNbr - 1 then + -- devo realizzare la prima shell interna + dOffs = dOffs + 0.5 * LayerParams.dStrand + LayerParams.dInnerStrand * ( 0.5 - LayerParams.dStrandOverlap / 100) + else + -- devo realizzare shell interne + dOffs = dOffs + LayerParams.dInnerStrand * ( 1 - LayerParams.dStrandOverlap / 100) + end + dCurrStrand = EgtIf( nInd == LayerParams.nShellsNbr, LayerParams.dStrand, LayerParams.dInnerStrand) + local nSrfDiff = EgtGetFirstNameInGroup( nShellNbrGrp, SHELL_NBR_SURF .. tostring( nInd)) local nOuterCrv = EgtGetFirstNameInGroup( nCrvGrpId, OUTER_CRV) + while nOuterCrv do - -- trim della curva con la superficie - local nTrimCrv, nTrimCnt = TrimOuterCurveForExtraShellCalc( nOuterCrv, nSrfDiff, nGrpId, vPtStart, LayerParams) - + -- trim della outer curve con la superficie + local nTrimCrv, nTrimCnt = TrimOuterCurveForExtraShellCalc( nOuterCrv, nSrfDiff, nGrpTmp, vPtStart, LayerParams) for nCrvT = nTrimCrv, nTrimCrv + nTrimCnt - 1 do - -- calcolo offset della curva ( è il percorso della shell) - EgtModifyCurveExtrusion( nCrvT, LayerParams.vtSlicing, GDB_RT.GLOB) + + -- calcolo offset della curva ( è il percorso della shell) local nOffs, nOffsCnt = EgtOffsetCurveAdv( nCrvT, - dOffs) - EgtErase( nCrvT) for nCrvOffs = nOffs, nOffs + nOffsCnt - 1 do - -- trim con la regione già occupata dal altre shell - local nCrv, nCnt = EgtTrimCurveWithRegion( nCrvOffs, nSrfTrim, true, true) - if nCrv and nCnt ~= 0 then - for nId = nCrv, nCrv + nCnt - 1 do - local dLen = EgtCurveLength( nId) - local bValid = true - if EgtCurveIsClosed( nId) then - bValid = VerifyPath( nId, LayerParams.dStrand, LayerParams.vtSlicing, nGrpId) - end - -- verifico se soddisfa vincolo sulla lunghezza - if dLen > MIN_LEN and bValid then - EgtSetStatus( nId, GDB_ST.ON) - EgtModifyCurveExtrusion( nId, LayerParams.vtSlicing, GDB_RT.GLOB) - EgtSetName( nId, EXTRA_SHELL_CRV .. tostring( nMaxShellNbrDiff - nInd + 1)) - if nInd == LayerParams.nShellsNbr then - EgtSetInfo( nId, KEY_TYPE, TYPE.EXTRA_OUTER_SHELL) + + -- calcolo la regione con cui fare trim + local nTrimSurf, bNoOverlap = ComputeTrimSurf( nTotShellTrim, nGrpTmp, dCurrStrand, LayerParams.dStrandOverlap) + if not nTrimSurf then + -- errore nel calcolo della superficie di trim + EgtOutLog( 'Error : creation of ExtraShell failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing extra shell') + -- aggiustamenti finali alle extra shell calcolate in precedenza + FinalizeExtraShellPath( nGrpId, vPtStart, nTotShellTrim, dOffs, dCurrStrand, LayerParams, nGrpTmp) + return + elseif nTrimSurf == GDB_ID.NULL then + -- non c'è più spazio per realizzare le extra shell + EgtOutLog( 'Warning : ExtraInnerShells not possible (layer '..tostring( s_nCurrIdx)..') - CalcPaths') + -- aggiustamenti finali alle extra shell calcolate in precedenza + FinalizeExtraShellPath( nGrpId, vPtStart, nTotShellTrim, dOffs, dCurrStrand, LayerParams, nGrpTmp) + return + else + if bNoOverlap then + EgtOutLog( 'Warning : ExtraShell without correct overlap (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + end + + local nCrv, nCnt = EgtTrimCurveWithRegion( nCrvOffs, nTrimSurf, true, true) + if nCrv and nCnt ~= 0 then + for nId = nCrv, nCrv + nCnt - 1 do + local dLen = EgtCurveLength( nId) + local bValid = true + if EgtCurveIsClosed( nId) then + bValid = VerifyPath( nId, LayerParams.dStrand, LayerParams.vtSlicing, nGrpId) + end + -- verifico se soddisfa vincolo sulla lunghezza + if dLen > MIN_LEN and bValid then + -- sposto nel path + EgtRelocateGlob( nId, nGrpId) + EgtSetStatus( nId, GDB_ST.ON) + EgtModifyCurveExtrusion( nId, LayerParams.vtSlicing, GDB_RT.GLOB) + EgtSetName( nId, EXTRA_SHELL_CRV .. tostring( nMaxShellNbrDiff - nInd + 1)) + if nInd == LayerParams.nShellsNbr then + EgtSetInfo( nId, KEY_TYPE, TYPE.EXTRA_OUTER_SHELL) + else + EgtSetInfo( nId, KEY_TYPE, TYPE.EXTRA_SHELL) + end + + -- verifico se può essere chiusa + if not EgtCurveIsClosed( nId) then + if dist( EgtSP( nId), EgtEP( nId)) < dCurrStrand + GEO.EPS_SMALL then + EgtCloseCurveCompo( nId) + end + end + + -- aggiorno la superficie occupata dalle shell con quella appena calcolata + UpdateTrimSurfWithExtraShell( nTotShellTrim, nId, dCurrStrand, nGrpId) else - EgtSetInfo( nId, KEY_TYPE, TYPE.EXTRA_SHELL) + EgtErase( nId) end - - -- aggiorno la superficie occupata dalle shell con quella appena calcolata (tenendo conto dell'overlap) - UpdateTotalShellSurf( nSrfTrim, nId, ( 1 - LayerParams.nStrandOverlap / 100) * LayerParams.dStrand, nGrpId) - -- se la superficie si annulla non è possibile realizzare altro, quindi cancello tutte le curve rimaste - if EgtSurfFrChunkCount( nSrfTrim) == 0 then - for j = nId + 1, nCrv + nCnt - 1 do - EgtErase( j) - end - for j = nCrvT + 1, nTrimCrv + nTrimCnt - 1 do - EgtErase( j) - end - -- aggiorno superficie - EgtSurfFrOffset( nSrfTrim, - LayerParams.nStrandOverlap / 100 * LayerParams.dStrand) - -- riordino le curve appena create e se possibile creo percorsi chiusi - ReorderExtraShells( nGrpId, LayerParams.dStrand, vPtStart, LayerParams.bPrintInvert) - return - end - else - EgtErase( nId) end end end end end - nOuterCrv = EgtGetNextName( nOuterCrv, OUTER_CRV) end end - -- aggiorno superificie - EgtSurfFrOffset( nSrfTrim, - LayerParams.nStrandOverlap / 100 * LayerParams.dStrand) - -- riordino le curve appena create e se possibile creo percorsi chiusi - ReorderExtraShells( nGrpId, LayerParams.dStrand, vPtStart, LayerParams.bPrintInvert) + -- ultimi aggiustamenti alle extra shell + FinalizeExtraShellPath( nGrpId, vPtStart, nTotShellTrim, dOffs, dCurrStrand, LayerParams, nGrpTmp) end -------------------------------------------------------------------- ------------------ AUX SOLIDS ------------------------------------- -------------------------------------------------------------------- -local function ComputeTrimSurfWithOverlapsForAuxSolids( vIds, nSrfBase, dStrand, nGrp, vtSlicing) - - -- per ogni valore di overlap creo le superfici con cui fare i trim - local vSurfOffs = {} - for i = 1, #vIds do - local nOverlap = EgtGetInfo( vIds[i][1], KEY_AUX_SOLIDS_OVERLAP, 'i') - if not vSurfOffs[nOverlap] then - local dNewOffs = nOverlap / 100 * dStrand - local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrfBase, nGrp, dNewOffs, vtSlicing) - if bOk then - vSurfOffs[nOverlap] = nSrfOffs - else - EgtOutLog( 'Warning: AuxSolid without correct overlap (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - vSurfOffs[nOverlap] = nSrfBase - end - end - end - return vSurfOffs -end +local function UpdateTrimSurfWithAuxSolidsOffset( nSrfSolid, nSrfBase, dStrand, nCrvGrp) ------------------------------------------------------------------------ -local function UpdateTrimSurfWithAuxSolidsOffset( nSrfSolid, nSrfBase, dStrand, nCrvGrp, vtSlicing) - - -- offset della superifice del solido - local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrfSolid, nCrvGrp, dStrand, vtSlicing) - if not bOk then + -- offset della superfice del solido + local nSrfOffs = ComputeSurfOffset( nSrfSolid, nCrvGrp, dStrand * 0.5) + if not nSrfOffs then EgtOutLog( 'Error : creation of AuxSolid region for TotTrimSurfRegion failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements') - elseif nSrfOffs then + else if not EgtSurfFrSubtract( nSrfBase, nSrfOffs) then EgtOutLog( 'Error : EgtSurfFrSubtract with AuxSolid for TotTrimSurfRegion failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements') end EgtErase( nSrfOffs) end - end -------------------------------------------------------------------- @@ -2658,11 +2824,8 @@ local function UpdateTrimSurfWithAuxSolidsZigZag( nAuxSolidsGrp, sName, nSrfBase local vtDir = EgtSV( vCrvs[i]) -- costruisco percorso associato - local nCopyCrv = EgtCopyGlob( vCrvs[i], nGrpTmp) - local nCopy2 = EgtCopyGlob( vCrvs[i], nGrpTmp) - EgtInvertCurve( nCopy2) - EgtAddCurveCompoCurve( nCopyCrv, nCopy2) - local nOffsP = EgtOffsetCurveAdv( nCopyCrv, dStrand, GDB_OT.FILLET) + local nSrfFatCrv = EgtSurfFrFatCurve( nGrpTmp, vCrvs[i], dStrand * 0.5 + 10 * GEO.EPS_SMALL, false) + local nOffsP = EgtExtractSurfFrChunkLoops( nSrfFatCrv, 0, nGrpTmp) local nFirst, nCnt = EgtExplodeCurveCompo( nOffsP, nGrpTmp) -- cerco tratti lineari orientati ortogonalmente alla direzione di svuotatura @@ -2754,19 +2917,27 @@ local function AddExtraZigZag( nSrf, sName, dStrand, vtSlicing, nGrp, nSrfTrim) end ------------------------------------------------------------------- -local function ComputeAuxSolidsGenericInfill( nSrf, dStrand, vtSlicing, sName, nPathGrp, vPtStart, nOrigSurf, nOverlap, nAuxSolidsGrp) +local function ComputeAuxSolidsGenericInfill( nSrf, dStrand, vtSlicing, sName, nPathGrp, vPtStart, nOrigSurf, dOverlap, nAuxSolidsGrp) -- estraggo i contorni della superficie ( perimetro) GetPathsFromSurf( nSrf, sName, TYPE.AUX_SOLID, nPathGrp, vPtStart) -- preparo la superficie con cui fare trim degli infill - local dOffs = dStrand * ( nOverlap / 100 - 0.5) - local bOk, bExists, nSrfTrim = ComputeSurfOffset( nSrf, nPathGrp, dOffs, vtSlicing) - if not bOk then - EgtOutLog( 'Warning: AuxSolid Infill without correct overlap (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') - nSrfTrim = EgtCopyGlob( nSrf, nPathGrp) - elseif not bExists then - EgtOutLog( 'Warning: AuxSolid Infill not possibile (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + local dOffs = dStrand * ( 1 - dOverlap / 100) + local nSrfTrim = ComputeSurfOffset( nSrf, nPathGrp, - dOffs) + if not nSrfTrim then + -- tento senza overlap + nSrfTrim = ComputeSurfOffset( nSrf, nPathGrp, - dStrand) + if not nSrfTrim then + -- errore + EgtOutLog( 'Error : creation of AuxSolid Infill region failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of AuxSolid infill region failed') + return + else + EgtOutLog( 'Warning : AuxSolid Infill without correct overlap (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + end + elseif nSrfTrim == GDB_ID.NULL then + EgtOutLog( 'Warning : AuxSolid Infill not possibile (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') return end @@ -2825,47 +2996,60 @@ local function CalcAuxSolidsPaths( nSliceGrp, nSolidGrp, LayerParams, vPtStart) if not nSrfBase then EgtOutLog( 'Warning : AuxSolids not possible (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') else - local vSurfOffs = ComputeTrimSurfWithOverlapsForAuxSolids( vSolidIds, nSrfBase, LayerParams.dStrand, nSolidPathGrp, LayerParams.vtSlicing) - + for i = 1, #vSolidIds do -- creo la flat region corrispondente al solido ausiliario local sName = EgtGetName( vSolidIds[i][1]) - local nOverlap = EgtGetInfo( vSolidIds[i][1], KEY_AUX_SOLIDS_OVERLAP, 'i') + local dStrand = EgtGetInfo( vSolidIds[i][1], KEY_AUX_SOLIDS_STRAND, 'd') + local dOverlap = EgtGetInfo( vSolidIds[i][1], KEY_AUX_SOLIDS_OVERLAP, 'd') local nOrigSurf = EgtGetInfo( vSolidIds[i][1], KEY_ORIGINAL_SURF, 'i') local nSrfId = EgtSurfFlatRegion( nSolidPathGrp, vSolidIds[i]) if nSrfId then EgtSetName( nSrfId, AUX_SOLIDS_SRF) - -- trim con la superficie di offset - EgtSurfFrIntersect( nSrfId, vSurfOffs[nOverlap]) + -- calcolo superficie con cui fare trim + local nTrimSurf, bNoOverlap = ComputeTrimSurf( nSrfBase, nSolidPathGrp, dStrand, dOverlap) + if not nTrimSurf then + EgtOutLog( 'Error : creation of AuxSolid region failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of AuxSolid region failed') + elseif nTrimSurf == GDB_ID.NULL then + EgtOutLog( 'Warning : AuxSolids not possible (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + else + if bNoOverlap then + EgtOutLog( 'Warning : AuxSolids without correct overlap (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + end - local nFirst, nCnt = EgtExplodeSurf( nSrfId) - for j = 0, nCnt - 1 do - local sNewName = sName .. EgtIf( j == 0, '', '_' .. tostring( j)) - local nInfillType = EgtGetInfo( vSolidIds[i][1], KEY_AUX_SOLIDS_INFILL, 'i') + -- trim con la superficie di offset + EgtSurfFrIntersect( nSrfId, nTrimSurf) - if nInfillType == FILL_TYPE.NONE then - -- estraggo i contorni della superficie ( serve solo perimetro) - GetPathsFromSurf( nFirst + j, sNewName, TYPE.AUX_SOLID, nSolidPathGrp, vPtStart) - -- aggiorno la trim surf - UpdateTrimSurfWithAuxSolidsOffset( nFirst + j, nSrfBase, LayerParams.dStrand, nSolidPathGrp, LayerParams.vtSlicing) + local nFirst, nCnt = EgtExplodeSurf( nSrfId) + for j = 0, nCnt - 1 do + local sNewName = sName .. EgtIf( j == 0, '', '_' .. tostring( j)) + local nInfillType = EgtGetInfo( vSolidIds[i][1], KEY_AUX_SOLIDS_INFILL, 'i') - elseif nInfillType == FILL_TYPE.OFFSET then - ComputeOffsetSolidFill( nFirst + j, LayerParams.dStrand, LayerParams.vtSlicing, sNewName, TYPE.AUX_SOLID, nSolidPathGrp, vPtStart) - -- aggiorno la trim surf - UpdateTrimSurfWithAuxSolidsOffset( nFirst + j, nSrfBase, LayerParams.dStrand, nSolidPathGrp, LayerParams.vtSlicing) - - elseif nInfillType == FILL_TYPE.ZIGZAG then - ComputeZigZagSolidFill( nFirst + j, LayerParams.dStrand, LayerParams.vtSlicing, sNewName, TYPE.AUX_SOLID, nSolidPathGrp, vSurfOffs[nOverlap]) - -- aggiungo eventuale passata extra - AddExtraZigZag( nFirst + j, sNewName, LayerParams.dStrand, LayerParams.vtSlicing, nSolidPathGrp, vSurfOffs[nOverlap]) - -- aggiorno la trim surf - UpdateTrimSurfWithAuxSolidsZigZag( nSolidPathGrp, sNewName, nSrfBase, LayerParams.dStrand, nFirst + j) - - else - ComputeAuxSolidsGenericInfill( nFirst + j, LayerParams.dStrand, LayerParams.vtSlicing, sNewName, nSolidPathGrp, vPtStart, nOrigSurf, nOverlap, nSolidGrp) - -- aggiorno la trim surf - UpdateTrimSurfWithAuxSolidsOffset( nFirst + j, nSrfBase, LayerParams.dStrand, nSolidPathGrp, LayerParams.vtSlicing) + if nInfillType == FILL_TYPE.NONE then + -- estraggo i contorni della superficie ( serve solo perimetro) + GetPathsFromSurf( nFirst + j, sNewName, TYPE.AUX_SOLID, nSolidPathGrp, vPtStart) + -- aggiorno la trim surf + UpdateTrimSurfWithAuxSolidsOffset( nFirst + j, nSrfBase, dStrand, nSolidPathGrp) + + elseif nInfillType == FILL_TYPE.OFFSET then + ComputeOffsetSolidFill( nFirst + j, dStrand, LayerParams.vtSlicing, sNewName, TYPE.AUX_SOLID, nSolidPathGrp, vPtStart) + -- aggiorno la trim surf + UpdateTrimSurfWithAuxSolidsOffset( nFirst + j, nSrfBase, dStrand, nSolidPathGrp) + + elseif nInfillType == FILL_TYPE.ZIGZAG then + ComputeZigZagSolidFill( nFirst + j, dStrand, LayerParams.vtSlicing, sNewName, TYPE.AUX_SOLID, nSolidPathGrp, nTrimSurf) + -- aggiungo eventuale passata extra + AddExtraZigZag( nFirst + j, sNewName, dStrand, LayerParams.vtSlicing, nSolidPathGrp, nTrimSurf) + -- aggiorno la trim surf + UpdateTrimSurfWithAuxSolidsZigZag( nSolidPathGrp, sNewName, nSrfBase, dStrand, nFirst + j) + + else + ComputeAuxSolidsGenericInfill( nFirst + j, dStrand, LayerParams.vtSlicing, sNewName, nSolidPathGrp, vPtStart, nOrigSurf, dOverlap, nSolidGrp) + -- aggiorno la trim surf + UpdateTrimSurfWithAuxSolidsOffset( nFirst + j, nSrfBase, dStrand, nSolidPathGrp) + end end end else @@ -2903,7 +3087,7 @@ function CalcPaths.Exec( nPartId) -- scorro tutti i suoi layer for nIdx = 1, #vLayIds do - + s_nCurrIdx = nIdx local nRibsGrp = EgtGetFirstNameInGroup( vLayIds[nIdx], RIBS_GRP) @@ -2943,20 +3127,22 @@ function CalcPaths.Exec( nPartId) -- parete esterna local vOldIds local bPrevExists = true - local dOffs = - LayerParams.dOffs - 0.5 * LayerParams.dStrand + local dLastStrand = 0 + local dOffs = - LayerParams.dOffs if nMaxShellNbrDiff < LayerParams.nShellsNbr then - dOffs = dOffs + LayerParams.dStrand - local bOk, bExists, nSrfId = ComputeSurfOffset( nSrf, nCrvGrpId, - dOffs, LayerParams.vtSlicing) - if not bOk then - EgtOutLog( 'Error : ExtOffset failed (layer '.. EgtNumToString( nIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( nIdx) .. ' : creation of OuterShell failed') - elseif not bExists then - EgtOutLog( 'Warning : ExtOffset not possible (layer '.. EgtNumToString( nIdx) ..') - CalcPaths') + dOffs = dOffs + 0.5 * LayerParams.dStrand + dLastStrand = LayerParams.dStrand + local nSrfId = ComputeSurfOffset( nSrf, nCrvGrpId, - dOffs) + if not nSrfId then + EgtOutLog( 'Error : ExtOffset failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of OuterShell failed') + elseif nSrfId == GDB_ID.NULL then + EgtOutLog( 'Warning : ExtOffset not possible (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') else -- se offset riuscito, estraggo i contorni (pareti esterne) vOldIds = GetPathsFromSurf( nSrfId, SHELL_CRV ..'0', TYPE.OUTER_SHELL, nGrpId, vPtStart) end - bPrevExists = bExists + bPrevExists = ( nSrfId ~= GDB_ID.NULL) EgtErase( nSrfId) end @@ -2969,14 +3155,19 @@ function CalcPaths.Exec( nPartId) -- pareti interne complete for nInd = 1, LayerParams.nShellsNbr - 1 - nMaxShellNbrDiff do + dLastStrand = LayerParams.dInnerStrand -- offset della superficie originale - dOffs = dOffs + LayerParams.dStrand * ( 1 - LayerParams.nStrandOverlap / 100) - local bOk, bExists, nSrfId = ComputeSurfOffset( nSrf, nCrvGrpId, - dOffs, LayerParams.vtSlicing) - if not bOk then - EgtOutLog( 'Error : IntOffset failed (layer '.. EgtNumToString( nIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( nIdx) .. ' : creation of InnerShell failed') - elseif not bExists then - EgtOutLog( 'Warning : IntOffset ' .. EgtNumToString( nInd) .. ' not possible (layer '.. EgtNumToString( nIdx) ..') - CalcPaths') + if nInd == 1 then + dOffs = dOffs + 0.5 * LayerParams.dStrand + LayerParams.dInnerStrand * ( 0.5 - LayerParams.dStrandOverlap / 100) + else + dOffs = dOffs + LayerParams.dInnerStrand * ( 1 - LayerParams.dStrandOverlap / 100) + end + local nSrfId = ComputeSurfOffset( nSrf, nCrvGrpId, - dOffs) + if not nSrfId then + EgtOutLog( 'Error : IntOffset failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of InnerShell failed') + elseif nSrfId == GDB_ID.NULL then + EgtOutLog( 'Warning : IntOffset ' .. EgtNumToString( nInd) .. ' not possible (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') else -- se offset riuscito, estraggo i contorni ( pareti interne) local vNewIds = GetPathsFromSurf( nSrfId, SHELL_CRV..tostring( nInd), TYPE.INNER_SHELL, nGrpId, vPtInnerStart) @@ -2986,33 +3177,29 @@ function CalcPaths.Exec( nPartId) -- se questo offset esiste ma il precedente no, allora il precedente è un errore da segnalare if not bPrevExists then local sElement = EgtIf( nInd > 1, 'IntOffset ' .. EgtNumToString( nInd - 1), 'ExtOffset') - EgtOutLog( 'Error :' .. sElement .. ' failed (layer '.. EgtNumToString( nIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( nIdx) .. ' : creation of ' .. EgtIf( nInd > 1, 'InnerShell', 'OuterShell') .. ' failed') + EgtOutLog( 'Error :' .. sElement .. ' failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of ' .. EgtIf( nInd > 1, 'InnerShell', 'OuterShell') .. ' failed') end end - bPrevExists = bExists + bPrevExists = ( nSrfId ~= GDB_ID.NULL) EgtErase( nSrfId) end -- preparo superficie occupata dalle shell da usare per trim - local dSurfTrimOffs = dOffs + LayerParams.dStrand - if nMaxShellNbrDiff > 0 then - -- se hai extra shell tieni conto anche dell'overlap ammesso - dSurfTrimOffs = dOffs + ( 1 - LayerParams.nStrandOverlap / 100) * LayerParams.dStrand - s_dOffsCorr - end - local bOkTrim, bExistsTrim, nSrfTrim = ComputeSurfOffset( nSrf, nCrvGrpId, - dSurfTrimOffs, LayerParams.vtSlicing) - if not bOkTrim then - EgtOutLog( 'Error : IntOffset for TotTrimSurfRegion failed (layer '.. EgtNumToString( nIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( nIdx) .. ' : error in computing region for internal elements') - elseif bExistsTrim then + local dSurfTrimOffs = dOffs + 0.5 * dLastStrand + local nSrfTrim = ComputeSurfOffset( nSrf, nCrvGrpId, - dSurfTrimOffs) + if not nSrfTrim then + EgtOutLog( 'Error : offset for TotTrimSurfRegion failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : error in computing region for internal elements') + elseif nSrfTrim ~= GDB_ID.NULL then EgtSetName( nSrfTrim, TOT_SHELL_TRIM_SURF) EgtSetStatus( nSrfTrim, GDB_ST.OFF) -- se questo offset esiste ma il precedente no, allora il precedente è un errore da segnalare if not bPrevExists then - EgtOutLog( 'Error : IntOffset' .. EgtNumToString( LayerParams.nShellsNbr - 1 - nMaxShellNbrDiff) .. ' failed (layer '.. EgtNumToString( nIdx) ..') - CalcPaths') - table.insert( s_vErr, 'layer ' .. EgtNumToString( nIdx) .. ' : creation of InnerShell failed') + EgtOutLog( 'Error : IntOffset' .. EgtNumToString( LayerParams.nShellsNbr - 1 - nMaxShellNbrDiff) .. ' failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths') + table.insert( s_vErr, 'layer ' .. EgtNumToString( s_nCurrIdx) .. ' : creation of InnerShell failed') end end diff --git a/LuaLibs/CalcSlices.lua b/LuaLibs/CalcSlices.lua index 9159dd0..6e04abf 100644 --- a/LuaLibs/CalcSlices.lua +++ b/LuaLibs/CalcSlices.lua @@ -15,6 +15,7 @@ local AMD = require( 'AddManData') --------------------------------------------------------------------- local s_nPartId local s_vErr = {} +local s_dStrand -- costanti local TOLER = 0.05 @@ -97,6 +98,7 @@ end local function GetRibParams( nId) local RibParam = {} + ReadParam( nId, KEY_RIBS_STRAND, 'd', s_dStrand, RibParam) ReadParam( nId, KEY_RIBS_SHELLS_NBR, 'i', 0, RibParam) ReadParam( nId, KEY_RIBS_INVERT_DIR, 'b', false, RibParam) ReadParam( nId, KEY_RIBS_LEAD_IN_INVERT, 'b', false, RibParam) @@ -106,7 +108,7 @@ local function GetRibParams( nId) ReadParam( nId, KEY_RIBS_LEAD_OUT_COASTING, 'd', 0, RibParam) ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE, 'd', 0, RibParam) ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE_DIR, 'd', 0, RibParam) - ReadParam( nId, KEY_RIBS_OVERLAP, 'i', 0, RibParam) + ReadParam( nId, KEY_RIBS_OVERLAP, 'd', 0, RibParam) ReadParam( nId, KEY_RIBS_LINK, 'b', false, RibParam) ReadParam( nId, KEY_RIBS_TYPE, 'i', RIB_TYPE.INTERNAL, RibParam) ReadParam( nId, KEY_RIBS_INVERT_STRAND_ORDER, 'b', false, RibParam) @@ -130,7 +132,8 @@ end local function GetAuxSolidsParams( nId) local AuxSolidsParam = {} - ReadParam( nId, KEY_AUX_SOLIDS_OVERLAP, 'i', 0, AuxSolidsParam) + ReadParam( nId, KEY_AUX_SOLIDS_STRAND, 'd', s_dStrand, AuxSolidsParam) + ReadParam( nId, KEY_AUX_SOLIDS_OVERLAP, 'd', 0, AuxSolidsParam) ReadParam( nId, KEY_AUX_SOLIDS_INFILL, 'i', FILL_TYPE.NONE, AuxSolidsParam) ReadParam( nId, KEY_AUX_SOLIDS_PRINT_ORDER, 'i', PRINT_ORDER.EXT_INT, AuxSolidsParam) ReadParam( nId, KEY_AUX_SOLIDS_LINK_TYPE, 'i', LINK_TYPE.NONE, AuxSolidsParam) @@ -141,7 +144,7 @@ local function GetAuxSolidsParams( nId) ReadParam( nId, KEY_AUX_SOLIDS_DIR, 'd', 0, AuxSolidsParam) ReadParam( nId, KEY_AUX_SOLIDS_OFFSET_X, 'd', 0, AuxSolidsParam) ReadParam( nId, KEY_AUX_SOLIDS_OFFSET_Y, 'd', 0, AuxSolidsParam) - ReadParam( nId, KEY_AUX_SOLIDS_GRID_OVERLAP, 'i', 0, AuxSolidsParam) + ReadParam( nId, KEY_AUX_SOLIDS_GRID_OVERLAP, 'd', 0, AuxSolidsParam) ReadParam( nId, KEY_AUX_SOLIDS_COASTING_LEN, 'd', 0, AuxSolidsParam) ReadParam( nId, KEY_AUX_SOLIDS_WIPE_LEN, 'd', 0, AuxSolidsParam) ReadParam( nId, KEY_AUX_SOLIDS_WIPE_DIR, 'd', 0, AuxSolidsParam) @@ -511,7 +514,7 @@ local function CalcGridFromPattern( nInfillGrp, nStmId, dOffsStm, frRef, vtOffs, local pt2 = pt1 + dDim2 * Y_AX() local nCrvBase = EgtCurveCompoFromPoints( nMainGrp, {pt1, pt2}) if not nCrvBase then - -- caso zigzag con nOverlapGrid = 100 ( dDim2 = 0) + -- caso zigzag con dOverlapGrid = 100 ( dDim2 = 0) local vtDir1 = VectorFromPolar( 1, dAng) local vtDir2 = VectorFromPolar( 1, 180 - dAng) pt2 = pt1 + vtDir1 * dDim1 @@ -556,7 +559,7 @@ local function CalcGridFromPattern( nInfillGrp, nStmId, dOffsStm, frRef, vtOffs, end -------------------------------------------------------------------- -local function CalcInfill( nInfillGrp, nType, dDensity, dDir, dOffsX, dOffsY, nGridOverlap, nStmId, dOffsStm, dStrand, vtSlicing) +local function CalcInfill( nInfillGrp, nType, dDensity, dDir, dOffsX, dOffsY, dGridOverlap, nStmId, dOffsStm, dStrand, vtSlicing) -- frame locale alla direzione dell'infill local frLoc = Frame3d( ORIG(), vtSlicing) @@ -569,10 +572,10 @@ local function CalcInfill( nInfillGrp, nType, dDensity, dDir, dOffsX, dOffsY, nG local vtOffs = Vector3d( dOffsX, dOffsY, 0) vtOffs:toLoc( frLoc) - -- eventuale correzione di nGridOverlap + -- eventuale correzione di dGridOverlap if nType ~= FILL_TYPE.LINES and nType ~= FILL_TYPE.GRID and dDensity > 85 then EgtOutLog( 'Warning: InfillGridOverlap is ignored due to high infill density - CalcSlices') - nGridOverlap = 0 + dGridOverlap = 0 end -- creo le curve di infill @@ -583,7 +586,7 @@ local function CalcInfill( nInfillGrp, nType, dDensity, dDir, dOffsX, dOffsY, nG CalcSimpleGridInfill( nInfillGrp, nStmId, dOffsStm, frLoc, vtOffs, dDist) elseif nType == FILL_TYPE.ZIG_ZAG_GRID then - local dRealStrand = ( 1 - nGridOverlap / 100) * dStrand + local dRealStrand = ( 1 - dGridOverlap / 100) * dStrand local dAng = 45 local dDim1 = ( dDist - dStrand) * sqrt(2) local dDim2 = dRealStrand @@ -591,7 +594,7 @@ local function CalcInfill( nInfillGrp, nType, dDensity, dDir, dOffsX, dOffsY, nG CalcGridFromPattern( nInfillGrp, nStmId, dOffsStm, frLoc, vtOffs, dDim1, dDim2, dAng, vSlicesAng, dRealStrand, vtSlicing) elseif nType == FILL_TYPE.HONEYCOMB or nType == FILL_TYPE.HONEYCOMB_GRID then - local dRealStrand = ( 1 - nGridOverlap / 100) * dStrand + local dRealStrand = ( 1 - dGridOverlap / 100) * dStrand local dAng = 30 local dDim1 = ( dDist - dStrand) / cos(30) local dDim2 = dDim1 + sqrt(3) * dRealStrand @@ -610,14 +613,15 @@ local function PrepareInfill( nStmId, vtSlicing) if nType == FILL_TYPE.NONE then return end local dDensity = EgtGetInfo( s_nPartId, KEY_INFILL_DENSITY, 'd') or 0 if dDensity < GEO.EPS_SMALL then return end + dDensity = EgtClamp( dDensity, 0, 90) -- recupero i parametri per infill local dDir = EgtGetInfo( s_nPartId, KEY_INFILL_DIR, 'd') or 0 local dOffsX = EgtGetInfo( s_nPartId, KEY_INFILL_OFFSET_X, 'd') or 0 local dOffsY = EgtGetInfo( s_nPartId, KEY_INFILL_OFFSET_Y, 'd') or 0 - local nGridOverlap = EgtGetInfo( s_nPartId, KEY_INFILL_GRID_OVERLAP, 'i') or 0 + local dGridOverlap = EgtGetInfo( s_nPartId, KEY_INFILL_GRID_OVERLAP, 'd') or 0 local dOffsStm = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd') - local dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd') + local dStrand = EgtGetInfo( s_nPartId, KEY_INFILL_STRAND, 'd') or s_dStrand -- creo gruppo per infill local nInfillGrp = EgtGroup( s_nPartId) @@ -625,7 +629,7 @@ local function PrepareInfill( nStmId, vtSlicing) EgtSetStatus( nInfillGrp, GDB_ST.OFF) -- calcolo infill - CalcInfill( nInfillGrp, nType, dDensity, dDir, dOffsX, dOffsY, nGridOverlap, nStmId, dOffsStm, dStrand, vtSlicing) + CalcInfill( nInfillGrp, nType, dDensity, dDir, dOffsX, dOffsY, dGridOverlap, nStmId, dOffsStm, dStrand, vtSlicing) -- aggiungo allo slicing SlicingInfill( nInfillGrp, vtSlicing, INFILL_CRV, INFILL_GRP) @@ -643,13 +647,14 @@ local function PrepareAuxSolidsInfill( nSolidsLay, vtSlicing) if nType & FILL_CATEGORY.INFILL ~= 0 then local dDensity = ReadParam( vIds[i], KEY_AUX_SOLIDS_DENSITY, 'd', 0) if dDensity > GEO.EPS_SMALL then + dDensity = EgtClamp( dDensity, 0, 90) -- recupero i parametri per infill local dDir = ReadParam( vIds[i], KEY_AUX_SOLIDS_DIR, 'd', 0) local dOffsX = ReadParam( vIds[i], KEY_AUX_SOLIDS_OFFSET_X, 'd', 0) local dOffsY = ReadParam( vIds[i], KEY_AUX_SOLIDS_OFFSET_Y, 'd', 0) - local nGridOverlap = ReadParam( vIds[i], KEY_AUX_SOLIDS_GRID_OVERLAP, 'i', 0) - local dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd') + local dGridOverlap = ReadParam( vIds[i], KEY_AUX_SOLIDS_GRID_OVERLAP, 'd', 0) + local dStrand = ReadParam( vIds[i], KEY_AUX_SOLIDS_STRAND, 'd', s_dStrand) -- creo gruppo associato local nInfillGrp = EgtGroup( s_nPartId) @@ -657,7 +662,7 @@ local function PrepareAuxSolidsInfill( nSolidsLay, vtSlicing) EgtSetStatus( nInfillGrp, GDB_ST.OFF) -- calcolo infill - CalcInfill( nInfillGrp, nType, dDensity, dDir, dOffsX, dOffsY, nGridOverlap, vIds[i], 0, dStrand, vtSlicing) + CalcInfill( nInfillGrp, nType, dDensity, dDir, dOffsX, dOffsY, dGridOverlap, vIds[i], 0, dStrand, vtSlicing) -- aggiungo allo slicing local sName = AUX_SOLIDS_INFILL_CRV .. tostring( vIds[i]) .. '_' @@ -1104,6 +1109,7 @@ function CalcSlices.Exec( nPartId, nStmId, HMax) EgtOutLog( 'Warning : SliceStep is 0') return end + s_dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd') local dZmin = b3Box:getMin():getZ() local dZmax = b3Box:getMax():getZ() diff --git a/LuaLibs/CalcToolPath.lua b/LuaLibs/CalcToolPath.lua index 595ba28..333c742 100644 --- a/LuaLibs/CalcToolPath.lua +++ b/LuaLibs/CalcToolPath.lua @@ -22,6 +22,7 @@ local function GetLayerParamsForToolPathCalc() local LayerParams = {} LayerParams.bSpiralVase = EgtGetInfo( s_nPartId, KEY_SPIRAL_VASE, 'b') or false LayerParams.dStrand = EgtGetInfo( s_nPartId, KEY_STRAND, 'd') + LayerParams.dInnerStrand = EgtGetInfo( s_nPartId, KEY_INNER_STRAND, 'd') or LayerParams.dStrand LayerParams.dLayHeight = EgtGetInfo( s_nPartId, KEY_SLICE_STEP, 'd') LayerParams.dOffs = EgtGetInfo( s_nPartId, KEY_OFFSET_SLICE, 'd') LayerParams.bInvert = ( EgtGetInfo( s_nPartId, KEY_PRINT_DIRECTION, 'i') == PRINT_DIRECTION.CW) @@ -43,6 +44,7 @@ local function GetLayerParamsForToolPathCalc() LayerParams.vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v') LayerParams.dTDiam = EgtGetInfo( s_nPartId, KEY_TOOL_DIAM, 'd') -- parametri infill + LayerParams.dInfillStrand = EgtGetInfo( s_nPartId, KEY_INFILL_STRAND, 'd') or LayerParams.dStrand LayerParams.dInfillCoasting = EgtGetInfo( s_nPartId, KEY_INFILL_COASTING, 'd') or 0 LayerParams.dInfillWipe = EgtGetInfo( s_nPartId, KEY_INFILL_WIPE, 'd') or 0 LayerParams.dInfillWipeDir = EgtGetInfo( s_nPartId, KEY_INFILL_WIPE_DIR, 'd') or 0 @@ -149,18 +151,21 @@ local function AddCurvesToToolPath( vEntIds, nTpathGrpId, nOrder, bInvert, vtSli end ------------------------------------------------------------------------- -local function AddStartPointOffsetOnLayer( nCrv, nCrvPrev, dSPOffs, nOrder, dStrand, vtSlicing, dLayH) +local function AddStartPointOffsetOnLayer( nCrv, nCrvPrev, dSPOffs, nOrder, vtSlicing, dLayH) if not EgtCurveIsClosed( nCrv) then return end + local dStrand = EgtGetInfo( nCrv, KEY_CRV_STRAND, 'd') -- individuo eventuale curva di toolpath precendente da cui prendere il punto di partenza local nPrev local vPrevPath = EgtGetInfo( nCrv, EgtIf( nOrder == PRINT_ORDER.EXT_INT, KEY_PREV_CRV, KEY_NEXT_CRVS), 'vi') if vPrevPath then local nAssociatedPathCrv = EgtGetInfo( nCrv, KEY_ASSOCIATED_P_CRV, 'i') + local nPrevFirst = EgtGetInfo( vPrevPath[1], KEY_ASSOCIATED_TP_CRV, 'i') + local dOtherStrand = EgtGetInfo( nPrevFirst, KEY_CRV_STRAND, 'd') for j = 1, #vPrevPath do -- verifico se gli start point delle path curve sono sufficientemente vicini - if dist( EgtSP( vPrevPath[j], GDB_ID.ROOT), EgtSP( nAssociatedPathCrv, GDB_ID.ROOT)) < dStrand + 100 * GEO.EPS_SMALL then + if dist( EgtSP( vPrevPath[j], GDB_ID.ROOT), EgtSP( nAssociatedPathCrv, GDB_ID.ROOT)) < ( dStrand + dOtherStrand) * 0.5 + 100 * GEO.EPS_SMALL then nPrev = EgtGetInfo( vPrevPath[j], KEY_ASSOCIATED_TP_CRV, 'i') break end @@ -185,26 +190,28 @@ local function AddStartPointOffsetOnLayer( nCrv, nCrvPrev, dSPOffs, nOrder, dStr end ------------------------------------------------------------------- -local function AddLink( vCrv, nTpathGrpId, nLinkType, dLinkParam, dSPOffs, dStrand, nOrder, vtSlicing) +local function AddLink( vCrv, nTpathGrpId, nLinkType, dLinkParam, dSPOffs, nOrder, vtSlicing) if not vCrv or #vCrv == 0 then return end if nLinkType == LINK_TYPE.NONE and abs( dSPOffs) > GEO.EPS_SMALL then -- se nessun raccordo modifico solo lo start point delle curve for i = 1, #vCrv do - AddStartPointOffsetOnLayer( vCrv[i], vCrv[i-1], dSPOffs, nOrder, dStrand) + AddStartPointOffsetOnLayer( vCrv[i], vCrv[i-1], dSPOffs, nOrder) end elseif nLinkType ~= LINK_TYPE.NONE then -- modifico lo start point della prima curva - AddStartPointOffsetOnLayer( vCrv[1], nil, dSPOffs, nOrder, dStrand) + AddStartPointOffsetOnLayer( vCrv[1], nil, dSPOffs, nOrder) + local dPrevStrand = EgtGetInfo( vCrv[1], KEY_CRV_STRAND, 'd') -- creo i raccordi for i = 2, #vCrv do -- il link ha senso solo su curva chiusa if EgtCurveIsClosed( vCrv[i]) then -- verifico se ha senso creare raccordo - local dDist = EgtPointCurveDist( EgtEP( vCrv[i-1]), vCrv[i]) - if dDist < dStrand + 10 * GEO.EPS_SMALL then + local dDist = EgtPointCurveDist( EgtEP( vCrv[i-1]), vCrv[i]) + local dCurrStrand = EgtGetInfo( vCrv[i], KEY_CRV_STRAND, 'd') + if dDist < ( dCurrStrand + dPrevStrand) * 0.5 + 10 * GEO.EPS_SMALL then local nLinkId -- modifico lo start point local dLen = EgtCurveLength( vCrv[i-1]) - EgtIf( i > 2, abs( dSPOffs), 0) @@ -231,10 +238,13 @@ local function AddLink( vCrv, nTpathGrpId, nLinkType, dLinkParam, dSPOffs, dStra EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB) EgtSetInfo( nLinkId, KEY_TYPE, TYPE.LINK) EgtSetName( nLinkId, LINK_CRV) + EgtSetInfo( nLinkId, KEY_CRV_STRAND, max( dCurrStrand, dPrevStrand)) end + + dPrevStrand = dCurrStrand else -- se raccordo non sensato perchè curve troppo distanti modifico lo start point - AddStartPointOffsetOnLayer( vCrv[i], vCrv[i-1], dSPOffs, nOrder, dStrand) + AddStartPointOffsetOnLayer( vCrv[i], vCrv[i-1], dSPOffs, nOrder) end end end @@ -295,11 +305,13 @@ local function AddLeadIn( nCrvId, LayerParams, nGrpId) EgtInvertCurve( nLeadInCrv) end - if nLeadInCrv then + if nLeadInCrv then EgtRelocate( nLeadInCrv, nCrvId, GDB_IN.BEFORE) EgtModifyCurveExtrusion( nLeadInCrv, LayerParams.vtSlicing, GDB_RT.GLOB) EgtSetInfo( nLeadInCrv, KEY_TYPE, TYPE.LINK) EgtSetName( nLeadInCrv, LEAD_IN_CRV) + local dStrand = EgtGetInfo( nCrvId, KEY_CRV_STRAND, 'd') + EgtSetInfo( nLeadInCrv, KEY_CRV_STRAND, dStrand) end end @@ -330,6 +342,8 @@ local function AddLeadOut( nCrvId, LayerParams, nGrpId) EgtModifyCurveExtrusion( nLeadOutCrv, LayerParams.vtSlicing, GDB_RT.GLOB) EgtSetInfo( nLeadOutCrv, KEY_TYPE, TYPE.LINK) EgtSetName( nLeadOutCrv, LEAD_OUT_CRV) + local dStrand = EgtGetInfo( nCrvId, KEY_CRV_STRAND, 'd') + EgtSetInfo( nLeadOutCrv, KEY_CRV_STRAND, dStrand) end return nLeadOutCrv end @@ -440,9 +454,12 @@ local function AddRetraction( nCrvId, vtSlicing, dCoastingLen, dWipeLen, dWipeDi EgtRelocateGlob( nWipeId, nCoastingId or nCrvId, GDB_IN.AFTER) end - EgtSetName( nWipeId, WIPE_CRV) - EgtSetInfo( nWipeId, KEY_TYPE, TYPE.WIPE) - EgtSetColor( nWipeId, EgtStdColor('AQUA')) + if nWipeId then + EgtSetName( nWipeId, WIPE_CRV) + EgtSetInfo( nWipeId, KEY_TYPE, TYPE.WIPE) + EgtSetInfo( nWipeId, KEY_CRV_STRAND, 0) + EgtSetColor( nWipeId, EgtStdColor('AQUA')) + end end if nCopyId then EgtErase( nCopyId) end @@ -482,8 +499,20 @@ local function CalcShellsToolPath( vEntIds, nTpathGrpId, LayerParams) local vIds = AddCurvesToToolPath( vEntIds, nTpathGrpId, LayerParams.nOrder, LayerParams.bInvert, LayerParams.vtSlicing, LayerParams.dLayHeight) local nFirstCopy = EgtCopyGlob( vIds[1], nTpathGrpId) -- necessaria per corretto offset lead point sulla shell esterna + -- assegno lo strand + for i = 1, #vIds do + local nType = EgtGetInfo( vIds[i], KEY_TYPE, 'i') + if nType == TYPE.OUTER_SHELL then + EgtSetInfo( vIds[i], KEY_CRV_STRAND, LayerParams.dStrand) + elseif nType == TYPE.INNER_SHELL then + EgtSetInfo( vIds[i], KEY_CRV_STRAND, LayerParams.dInnerStrand) + else -- infill + EgtSetInfo( vIds[i], KEY_CRV_STRAND, LayerParams.dInfillStrand) + end + end + -- aggiungo gli opportuni raccordi - AddLink( vIds, nTpathGrpId, LayerParams.nLinkType, LayerParams.dLinkParam, LayerParams.dSPOffs, LayerParams.dStrand, LayerParams.nOrder, LayerParams.vtSlicing) + AddLink( vIds, nTpathGrpId, LayerParams.nLinkType, LayerParams.dLinkParam, LayerParams.dSPOffs, LayerParams.nOrder, LayerParams.vtSlicing) -- offset lead point AddOffsetLeadPoint( vIds, nFirstCopy, LayerParams.dOffsetLP, LayerParams.nLinkType) @@ -516,6 +545,16 @@ local function CalcExtraShellToolPath( vEntIds, nTpathGrpId, LayerParams) -- aggiungo le curve nel toolpath local vIds = AddCurvesToToolPath( vEntIds, nTpathGrpId, PRINT_ORDER.EXT_INT, false, LayerParams.vtSlicing, LayerParams.dLayHeight) + -- assegno strand + for i = 1, #vIds do + local nType = EgtGetInfo( vIds[i], KEY_TYPE, 'i') + if nType == TYPE.EXTRA_OUTER_SHELL then + EgtSetInfo( vIds[i], KEY_CRV_STRAND, LayerParams.dStrand) + else + EgtSetInfo( vIds[i], KEY_CRV_STRAND, LayerParams.dInnerStrand) + end + end + -- aggiungo gli opportuni raccordi local sPrevName = EgtGetName( vIds[1]) for i = 2, #vIds do @@ -530,6 +569,14 @@ local function CalcExtraShellToolPath( vEntIds, nTpathGrpId, LayerParams) EgtModifyCurveExtrusion( nLinkId, LayerParams.vtSlicing, GDB_RT.GLOB) EgtSetInfo( nLinkId, KEY_TYPE, TYPE.LINK) EgtSetName( nLinkId, LINK_CRV) + local dStrand1 = EgtGetInfo( vIds[i], KEY_CRV_STRAND, 'd') + local dStrand2 = EgtGetInfo( vIds[i-1], KEY_CRV_STRAND, 'd') + EgtSetInfo( nLinkId, KEY_CRV_STRAND, max( dStrand1, dStrand2)) + end + else + -- se nome diverso ma chiuse applico lo start point + if EgtCurveIsClosed( vIds[i]) and EgtCurveIsClosed( vIds[i-1]) then + AddStartPointOffsetOnLayer( vIds[i], vIds[i-1], LayerParams.dSPOffs, PRINT_ORDER.EXT_INT, LayerParams.vtSlicing, LayerParams.dLayHeight) end end sPrevName = sCurrName @@ -581,12 +628,17 @@ local function CalcSolidFillToolPath( nInfillGrp, nTpathGrpId, LayerParams) -- aggiungo le curve nel toolpath local vIds = AddCurvesToToolPath( vEntIds, nTpathGrpId, nOrder, bInvert, LayerParams.vtSlicing, LayerParams.dLayHeight) + + -- assegno strand + for i = 1, #vIds do + EgtSetInfo( vIds[i], KEY_CRV_STRAND, LayerParams.dInfillStrand) + end -- se riempimento ad offset sistemo come nel caso delle shell if nSolidFillType == FILL_TYPE.OFFSET then local nFirstCopy = EgtCopyGlob( vIds[1], nTpathGrpId) -- aggiungo gli opportuni raccordi - AddLink( vIds, nTpathGrpId, LayerParams.nLinkType, LayerParams.dLinkParam, LayerParams.dSPOffs, LayerParams.dStrand, LayerParams.nOrder, LayerParams.vtSlicing) + AddLink( vIds, nTpathGrpId, LayerParams.nLinkType, LayerParams.dLinkParam, LayerParams.dSPOffs, LayerParams.nOrder, LayerParams.vtSlicing) -- offset lead point AddOffsetLeadPoint( vIds, nFirstCopy, LayerParams.dOffsetLP, LayerParams.nLinkType) end @@ -608,7 +660,12 @@ local function CalcInfillToolPath( nInfillGrp, nTpathGrpId, LayerParams) -- aggiungo le curve nel toolpath local vIds = AddCurvesToToolPath( vEntIds, nTpathGrpId, PRINT_ORDER.EXT_INT, false, LayerParams.vtSlicing, LayerParams.dLayHeight) - + + -- assegno strand + for i = 1, #vIds do + EgtSetInfo( vIds[i], KEY_CRV_STRAND, LayerParams.dInfillStrand) + end + -- aggiungo coasting e wipe for i = 1, #vIds do AddRetraction( vIds[i], LayerParams.vtSlicing, LayerParams.dInfillCoasting, LayerParams.dInfillWipe, LayerParams.dInfillWipeDir) @@ -676,10 +733,11 @@ local function CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGr -- recupero tutti i percorsi relativi a quel solido local sName = EgtGetName( nSolidId) local vEntIds = EgtGetNameInGroup( nAuxSolidsPathGrp, sName .. '*') - if vEntIds then + if vEntIds then -- recupero i parametri relativi al solido dalla curva di slicing local nFillType = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_INFILL, 'i') + local dStrand = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_STRAND, 'd') local nOrder = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_PRINT_ORDER, 'i') local dCoastingLen = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_COASTING_LEN, 'd') local dWipeLen = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_WIPE_LEN, 'd') @@ -687,7 +745,12 @@ local function CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGr -- copio i percorsi nel gruppo toolpath local vIds = AddCurvesToToolPath( vEntIds, nTpathGrpId, EgtIf( nFillType == FILL_TYPE.OFFSET, nOrder, PRINT_ORDER.EXT_INT), LayerParams.bInvert, LayerParams.vtSlicing, LayerParams.dLayHeight) - + + -- assegno strand + for i = 1, #vIds do + EgtSetInfo( vIds[i], KEY_CRV_STRAND, dStrand) + end + -- aggiungo link e offset lead point if nFillType == FILL_TYPE.OFFSET or nFillType == FILL_TYPE.NONE then local nLinkType = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_LINK_TYPE, 'i') @@ -696,7 +759,7 @@ local function CalcAuxSolidsToolPath( nAuxSolidsGrp, nAuxSolidsPathGrp, nTpathGr local dLPOffset = EgtGetInfo( nSolidId, KEY_AUX_SOLIDS_LP_OFFSET, 'd') local nFirstCopy = EgtCopyGlob( vIds[1], nTpathGrpId) -- necessaria per avere il corretto offset lead point sulla shell esterna nel caso di link - AddLink( vIds, nTpathGrpId, nLinkType, dLinkParam, dSPOffset, LayerParams.dStrand, nOrder, LayerParams.vtSlicing) + AddLink( vIds, nTpathGrpId, nLinkType, dLinkParam, dSPOffset, nOrder, LayerParams.vtSlicing) AddOffsetLeadPoint( vIds, nFirstCopy, dLPOffset, nLinkType) end @@ -718,29 +781,55 @@ end ------------------------------------------------------------------- --------------------------- RIBS ----------------------------------- -------------------------------------------------------------------- -local function VerifyRibsLink( nLinkId, nCurr, nNext, dStrand, nGrpTmp, bCheckLinked) +local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, bCheckLinked) + local dStrand = EgtGetInfo( nLinkId, KEY_CRV_STRAND, 'd') + local dOverlap1 = EgtGetInfo( nCurr, KEY_RIBS_OVERLAP, 'd') + local dOverlap2 = EgtGetInfo( nNext, KEY_RIBS_OVERLAP, 'd') + local dOverlap = max( dOverlap1, dOverlap2) local dLen = EgtCurveLength( nLinkId) - if dLen < dStrand + GEO.EPS_SMALL then - return true - end - -- regione occupata dal link + -- porto il link nel gruppo locale local nLinkLoc = EgtCopyGlob( nLinkId, nGrpTmp) - local nOverlap = EgtGetInfo( nCurr, KEY_RIBS_OVERLAP, 'i') - local nSrfLink = EgtSurfFrFatCurve( nGrpTmp, nLinkId, dStrand * ( 1 - nOverlap / 100) - 100 * GEO.EPS_SMALL, false) - if not nSrfLink then - return false + + -- verifico se interseca altri setti ( considerando anche le tipologie del PathGrp non ancora realizzate) + local nOrigCurr = EgtGetInfo( nCurr, KEY_ORIGINAL_RIB, 'i') + local nOrigNext = EgtGetInfo( nNext, KEY_ORIGINAL_RIB, 'i') + local vRibsIds = EgtGetNameInGroup( EgtGetParent( nCurr), RIBS_CRV .. '*') + local nCrvGrp = EgtGetParent( EgtGetParent( nCurr)) + local nRibsPathGrp = EgtGetFirstNameInGroup( nCrvGrp, RIBS_GRP) + local vRibsPaths = EgtGetNameInGroup( nRibsPathGrp, RIBS_CRV .. '*') + for i = 1, #vRibsPaths do + local nTPath = EgtGetInfo( vRibsPaths[i], KEY_ASSOCIATED_TP_CRV, 'i') + if not nTPath then + table.insert( vRibsIds, vRibsPaths[i]) + end end - -- verifico se interseca altri setti - local vRibsIds = EgtGetNameInGroup( EgtGetParent( nCurr), RIBS_CRV .. '*') for i = 1, #vRibsIds do if vRibsIds[i] ~= nCurr and vRibsIds[i] ~= nNext then - local nRibsLoc = EgtCopyGlob( vRibsIds[i], nGrpTmp) - local nRes = EgtCurveWithRegionClassify( vRibsIds[i], nSrfLink) - if nRes ~= GDB_CRC.OUT then - return false + local dCurrStrand = EgtGetInfo( vRibsIds[i], KEY_RIBS_STRAND, 'd') + local nOrigId = EgtGetInfo( vRibsIds[i], KEY_ORIGINAL_RIB, 'i') + if nOrigId == nOrigCurr or nOrigId == nOrigNext then + -- se passate relative ad un setto coinvolto verifico se sovrapposizione con la curva + local ptS = EgtSP( vRibsIds[i], GDB_ID.ROOT) + local dParS = EgtCurveParamAtPoint( nLinkLoc, ptS, dCurrStrand * 0.5, GDB_RT.GLOB) + if dParS then return false end + local ptE = EgtEP( vRibsIds[i], GDB_ID.ROOT) + local dParE = EgtCurveParamAtPoint( nLinkLoc, ptE, dCurrStrand * 0.5, GDB_RT.GLOB) + if dParE then return false end + else + -- verifico se sovrapposizione con la passata + local dOffs = dCurrStrand * 0.5 + ( 0.5 - dOverlap / 100) * dStrand - 10 * GEO.EPS_SMALL + if dOffs > GEO.EPS_SMALL then + local nSrfCurr = EgtSurfFrFatCurve( nGrpTmp, vRibsIds[i], dOffs, false) + if nSrfCurr then + local nRes = EgtCurveWithRegionClassify( nLinkLoc, nSrfCurr) + if nRes ~= GDB_CRC.OUT then + return false + end + end + end end end end @@ -767,68 +856,135 @@ local function VerifyRibsLink( nLinkId, nCurr, nNext, dStrand, nGrpTmp, bCheckLi end end - -- verifico se si trova nella regione ammissibile ( per caso ForcedLink) - local nSurfId = EgtGetInfo( nCurr, KEY_ASSOCIATED_SURF, 'i') - if nSurfId then - local nSrfLoc = EgtCopyGlob( nSurfId, nGrpTmp) - local nRes = EgtCurveWithRegionClassify( nLinkId, nSurfId) - local nType = EgtGetInfo( nCurr, KEY_RIBS_TYPE, 'i') - if nRes == GDB_CRC.INTERS or ( ( nType == RIB_TYPE.INTERNAL or nType == RIB_TYPE.SUPPORT) and nRes == GDB_CRC.OUT) or ( nType == RIB_TYPE.EXTERNAL and nRes == GDB_CRC.IN) then - return false + -- verifico se si trova almeno in una regione ammissibile ( per caso ForcedLink) + local nType = EgtGetInfo( nCurr, KEY_RIBS_TYPE, 'i') + local nOut = 0 + for i = 1, 2 do + local nSurfId = EgtGetInfo( EgtIf( i == 1, nCurr, nNext), KEY_ASSOCIATED_SURF, 'i') + if nSurfId and nSurfId ~= -1 then + local nSrfLoc = EgtCopyGlob( nSurfId, nGrpTmp) + local nRes = EgtCurveWithRegionClassify( nLinkId, nSrfLoc) + if ( ( nType == RIB_TYPE.INTERNAL or nType == RIB_TYPE.SUPPORT) and ( nRes == GDB_CRC.OUT or nRes == GDB_CRC.INTERS)) or + ( nType == RIB_TYPE.EXTERNAL and ( nRes == GDB_CRC.IN or nRes == GDB_CRC.INTERS)) then + nOut = nOut + 1 + end end end + local nType1 = EgtGetInfo( nCurr, KEY_RIBS_TYPE, 'i') + local nType2 = EgtGetInfo( nNext, KEY_RIBS_TYPE, 'i') + if nType1 == RIB_TYPE.UNBOUNDED or nType2 == RIB_TYPE.UNBOUNDED then + -- deve essere nella regione ammissibile dell'altro setto + if nOut == 1 then return false end + else + -- deve essere nella regione ammissibile di uno dei due + if nOut == 2 then return false end + end return true end -------------------------------------------------------------------- -local function CalcRibsLink( nCurr, nNext, nLoopGrp, dStrand, bForceLink, bCheckLinked, vtSlicing, nGrpTmp) +local function ComputeShortestCrv( nCrvId, dParS, dParE) + + local nParentId = EgtGetParent( nCrvId) + + -- verifico i due percorsi possibili dParS->dParE e dParE->dParS + local nCopyId1 = EgtCopyGlob( nCrvId, nParentId, GDB_IN.AFTER) + local nCopyId2 = EgtCopyGlob( nCrvId, nParentId, GDB_IN.AFTER) + EgtTrimCurveStartEndAtParam( nCopyId1, dParS, dParE) + EgtTrimCurveStartEndAtParam( nCopyId2, dParE, dParS) + EgtInvertCurve( nCopyId2) + + local dLen1 = EgtCurveLength( nCopyId1) + local dLen2 = EgtCurveLength( nCopyId2) + if dLen1 > dLen2 then + EgtErase( nCopyId1) + return nCopyId2 + else + EgtErase( nCopyId2) + return nCopyId1 + end +end + +-------------------------------------------------------------------- +local function ComputeRibsLinkOnDiffCrvs( nCrvS, nCrvE, dParS, dParE) + + -- recupero il tratto interessato sulla curva1 + local _, _, dParFinal = EgtPointCurveDist( EgtUP( nCrvE, dParE, GDB_ID.ROOT), nCrvS, GDB_ID.ROOT) + local nCrv1 = ComputeShortestCrv( nCrvS, dParS, dParFinal) + + -- recupero il tratto interessato sulla cruva2 + local _, _, dParStart = EgtPointCurveDist( EgtUP( nCrvS, dParS, GDB_ID.ROOT), nCrvE, GDB_ID.ROOT) + local nCrv2 = ComputeShortestCrv( nCrvE, dParStart, dParE) + + -- modifico nCrv2 per avere una transizione uniforme da nCrv1 + if EgtSpiralizeCurveAlongGuide( nCrv2, nCrv1) then + EgtErase( nCrv1) + return nCrv2 + else + EgtErase( nCrv1) + EgtErase( nCrv2) + return nil + end +end + +-------------------------------------------------------------------- +local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, bCheckLinked, vtSlicing, nGrpTmp) local ptS = EgtEP( nCurr) local ptE = EgtSP( nNext) if AreSamePointApprox( ptS, ptE) then return end - local nCrvId = EgtGetFirstInGroup( nLoopGrp) - -- recupero la curva di offset su cui calcolare link - while nCrvId do - local dParS = EgtCurveParamAtPoint( nCrvId, ptS, 10 * GEO.EPS_SMALL) - local dParE = EgtCurveParamAtPoint( nCrvId, ptE, 10 * GEO.EPS_SMALL) - if dParS and dParE then - - -- verifico i due percorsi possibili dParS->dParE e dParE->dParS - local nCopyId1 = EgtCopyGlob( nCrvId, nCurr, GDB_IN.AFTER) - local nCopyId2 = EgtCopyGlob( nCrvId, nCurr, GDB_IN.AFTER) - EgtTrimCurveStartEndAtParam( nCopyId1, dParS, dParE) - EgtTrimCurveStartEndAtParam( nCopyId2, dParE, dParS) - EgtInvertCurve( nCopyId2) - - local nLinkId - local dLen1 = EgtCurveLength( nCopyId1) - local dLen2 = EgtCurveLength( nCopyId2) - if dLen1 > dLen2 then - nLinkId = nCopyId2 - EgtErase( nCopyId1) - else - nLinkId = nCopyId1 - EgtErase( nCopyId2) - end - - EgtSetInfo( nLinkId, KEY_TYPE, TYPE.RIB) - EgtSetName( nLinkId, LINK_CRV) - EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB) - - -- verifico se è valido - local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, dStrand, nGrpTmp, bCheckLinked) - if bValid then - return nLinkId - else - EgtErase( nLinkId) - end + local dStrand1 = EgtGetInfo( nCurr, KEY_CRV_STRAND, 'd') + local dStrand2 = EgtGetInfo( nNext, KEY_CRV_STRAND, 'd') + local dStrand = max( dStrand1, dStrand2) + + local vCrvIds = EgtGetAllInGroup( nLoopGrp) + -- recupero le curve di bordo su cui poggiano i setti e i corrispondenti parametri + local vIdsS, vIdsE = {}, {} + local vParS, vParE = {}, {} + for i = 1, #vCrvIds do + local dParS = EgtCurveParamAtPoint( vCrvIds[i], ptS, 10 * GEO.EPS_SMALL) + if dParS then + table.insert( vIdsS, i) + table.insert( vParS, dParS) + end + local dParE = EgtCurveParamAtPoint( vCrvIds[i], ptE, 10 * GEO.EPS_SMALL) + if dParE then + table.insert( vIdsE, i) + table.insert( vParE, dParE) end - - nCrvId = EgtGetNext( nCrvId) end + -- verifico se possibile creare link basandosi sulle curve di bordo + for i = 1, #vIdsS do + for j = 1, #vIdsE do + local nLinkId + if vIdsS[i] == vIdsE[j] then + -- link su una sola curva + nLinkId = ComputeShortestCrv( vCrvIds[vIdsS[i]], vParS[i], vParE[j]) + else + -- link tra due curve distinte + nLinkId = ComputeRibsLinkOnDiffCrvs( vCrvIds[vIdsS[i]], vCrvIds[vIdsE[j]], vParS[i], vParE[j]) + end + + if nLinkId then + EgtRelocateGlob( nLinkId, nCurr, GDB_IN.AFTER) + EgtSetInfo( nLinkId, KEY_TYPE, TYPE.RIB) + EgtSetName( nLinkId, LINK_CRV) + EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB) + EgtSetInfo( nLinkId, KEY_CRV_STRAND, dStrand) + -- verifico se valido + local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, bCheckLinked) + if bValid then + return nLinkId + else + EgtErase( nLinkId) + end + end + end + end + -- se non ho trovato un collegamento lungo bordi ma link deve esserci creo una linea tra ptS e ptE if bForceLink then local nLinkId = EgtCurveCompoFromPoints( EgtGetParent( nCurr), {ptS, ptE}) @@ -836,7 +992,8 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, dStrand, bForceLink, bCheck EgtSetName( nLinkId, LINK_CRV) EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB) EgtRelocateGlob( nLinkId, nCurr, GDB_IN.AFTER) - local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, dStrand, nGrpTmp, bCheckLinked) + EgtSetInfo( nLinkId, KEY_CRV_STRAND, dStrand) + local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, bCheckLinked) if bValid then return nLinkId else @@ -849,34 +1006,35 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, dStrand, bForceLink, bCheck end -------------------------------------------------------------------- -local function VerifyRibsLead( nId, nRibId, dStrand, bInVsOut, nGrpTmp) +local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp) + local dStrand = EgtGetInfo( nRibId, KEY_CRV_STRAND, 'd') + local dOverlap = EgtGetInfo( nRibId, KEY_RIBS_OVERLAP, 'd') local dLen = EgtCurveLength( nId) - if dLen < dStrand + GEO.EPS_SMALL then - return true - end - -- regione occupata dal lead + -- porto il lead nel gruppo locale local nLeadLoc = EgtCopyGlob( nId, nGrpTmp) - local nOverlap = EgtGetInfo( nRibId, KEY_RIBS_OVERLAP, 'i') - local nSrfLead = EgtSurfFrFatCurve( nGrpTmp, nId, dStrand * ( 1 - nOverlap / 100) - 100 * GEO.EPS_SMALL, false) - if not nSrfLead then - return false - end - -- individuo eventuale lead in o link relativo al setto corrente + -- individuo eventuale lead in o link relativo al setto corrente ( solo se collega due passate dello stesso setto) local nCurrLI local nCurrLink if not bInVsOut then local nPrev = EgtGetPrev( nRibId) - if nPrev and EgtGetName( nPrev) == LEAD_IN_CRV then + if nPrev and EgtGetName( nPrev) == LEAD_IN_CRV then nCurrLI = nPrev elseif nPrev and EgtGetName( nPrev) == LINK_CRV then - nCurrLink = nPrev + local nPrevRib = EgtGetPrev( nPrev) + local nOrigRib = EgtGetInfo( nRibId, KEY_ORIGINAL_RIB, 'i') or -1 + local nOrigRibPrev = EgtGetInfo( nPrevRib, KEY_ORIGINAL_RIB, 'i') or -1 + if nOrigRib == nOrigRibPrev then + nCurrLink = nPrev + end end end -- verifico se interseca altri setti, lead in, lead out o collegamenti + -- recupero gli id degli elementi da controllare + local vCheckIds = {} local nCurrId = EgtGetFirstNameInGroup( EgtGetParent( nRibId), RIBS_CRV .. '*') -- verifico se il primo setto ha lead in da controllare local nPrevId = EgtGetPrev( nCurrId) @@ -884,15 +1042,35 @@ local function VerifyRibsLead( nId, nRibId, dStrand, bInVsOut, nGrpTmp) while nCurrId do -- salto i i wipe ( non sono materiale depositato) e i tratti relativi al setto corrente if not EgtStartsWith( EgtGetName( nCurrId), WIPE_CRV) and nCurrId ~= nCurrLI and nCurrId ~= nRibId and nCurrId ~= nId and nCurrId ~= nCurrLink then - local nRibLoc = EgtCopyGlob( nCurrId, nGrpTmp) - local nRes = EgtCurveWithRegionClassify( nRibLoc, nSrfLead) - if nRes ~= GDB_CRC.OUT then - return false - end + table.insert( vCheckIds, nCurrId) end nCurrId = EgtGetNext( nCurrId) end - + -- tra gli id da controllare devo aggiungere anche altri setti non ancora presenti nel toolpath ( tipologie di setti realizzate in seguito) + local nCrvGrp = EgtGetParent( EgtGetParent( nRibId)) + local nRibsPathGrp = EgtGetFirstNameInGroup( nCrvGrp, RIBS_GRP) + local vRibsPaths = EgtGetNameInGroup( nRibsPathGrp, RIBS_CRV .. '*') + for i = 1, #vRibsPaths do + local nTPath = EgtGetInfo( vRibsPaths[i], KEY_ASSOCIATED_TP_CRV, 'i') + if not nTPath then + table.insert( vCheckIds, vRibsPaths[i]) + end + end + -- controllo se intersezione + for i = 1, #vCheckIds do + local dCurrStrand = EgtGetInfo( vCheckIds[i], KEY_CRV_STRAND, 'd') or EgtGetInfo( vCheckIds[i], KEY_RIBS_STRAND, 'd') + local dCurrOffs = dCurrStrand * 0.5 + ( 0.5 - dOverlap / 100) * dStrand - 10 * GEO.EPS_SMALL + if dCurrOffs > GEO.EPS_SMALL then + local nSrfCurr = EgtSurfFrFatCurve( nGrpTmp, vCheckIds[i], dCurrOffs, false) + if nSrfCurr then + local nRes = EgtCurveWithRegionClassify( nLeadLoc, nSrfCurr) + if nRes ~= GDB_CRC.OUT then + return false + end + end + end + end + -- verifiche con il setto corrente -- verifico non passi da altro estremo local dParTest = EgtCurveParamAtPoint( nLeadLoc, EgtIf( bInVsOut, EgtEP( nRibId, GDB_ID.ROOT), EgtSP( nRibId, GDB_ID.ROOT)), 100 * GEO.EPS_SMALL, GDB_RT.GLOB) @@ -904,14 +1082,13 @@ local function VerifyRibsLead( nId, nRibId, dStrand, bInVsOut, nGrpTmp) local nRibLoc = EgtCopyGlob( nRibId, nGrpTmp) local vtDir = EgtMV( nRibLoc) local dParCrv = 1 - local dTol = 10 * GEO.EPS_SMALL + local dTol = 10 * GEO.EPS_SMALL for dParCrv = 1, dParE do local vtS = EgtUV( nLeadLoc, dParCrv - 1, 1) local vtE = EgtUV( nLeadLoc, dParCrv, -1) local dTol = 10 * GEO.EPS_SMALL - if AreSameVectorApprox( vtS, vtE) and ( (vtS - vtDir):sqlen() < dTol * dTol or ( vtS + vtDir):sqlen() < dTol * dTol) then + if AreSameVectorApprox( vtS, vtE) and vtS * vtDir < - 1 + GEO.EPS_SMALL then local dDist = EgtPointCurveDist( EgtUP( nLeadLoc, dParCrv - 0.5), nRibLoc) - EgtPoint( nGrpTmp, EgtUP( nLeadLoc, dParCrv - 0.5)) EgtCopyGlob( nLeadLoc, nGrpTmp) if dDist < dStrand + GEO.EPS_SMALL then return false @@ -929,14 +1106,17 @@ local function VerifyRibsLead( nId, nRibId, dStrand, bInVsOut, nGrpTmp) end local dLeadInLen = EgtCurveLength( nLeadInLoc) if dLeadInLen > dStrand + GEO.EPS_SMALL then - -- verifico di avere un solo tratto esterno di lunghezza sufficiente - local nRes, nCnt = EgtTrimCurveWithRegion( nLeadInLoc, nSrfLead, false, false) - if nCnt ~= 1 then - return false - else - local dLen = EgtCurveLength( nRes) - if dLen < dStrand / 2 + GEO.EPS_SMALL then + local nSrfLeadIn = EgtSurfFrFatCurve( nGrpTmp, nId, dStrand * ( 1 - dOverlap / 100), false) + if nSrfLeadIn then + -- verifico di avere un solo tratto esterno di lunghezza sufficiente + local nRes, nCnt = EgtTrimCurveWithRegion( nLeadInLoc, nSrfLeadIn, false, false) + if nCnt ~= 1 then return false + else + local dLen = EgtCurveLength( nRes) + if dLen < dStrand / 2 + GEO.EPS_SMALL then + return false + end end end end @@ -964,7 +1144,7 @@ local function PrepareRibLead( nCrvOffs, nRib, bInvert, bInVsOut, dPar, dLeadLen end --------------------------------------------------------------------------------- -local function FindCorrectRibLead( dPar, nRib, nCrvOffs, bLeadInvert, dLeadLen, dStrand, bInVsOut, nGrpTmp, bSpecialCase) +local function FindCorrectRibLead( dPar, nRib, nCrvOffs, bLeadInvert, dLeadLen, bInVsOut, nGrpTmp, bSpecialCase) local nLeadId local bInvert = bLeadInvert -- valore di default è quello dei parametri @@ -1015,7 +1195,7 @@ local function FindCorrectRibLead( dPar, nRib, nCrvOffs, bLeadInvert, dLeadLen, nLeadId = PrepareRibLead( nCrvOffs, nRib, bInvert, bInVsOut, dPar, dLeadLen) -- verifico se lead sensato - if not VerifyRibsLead( nLeadId, nRib, dStrand, bInVsOut, nGrpTmp) then + if not VerifyRibsLead( nLeadId, nRib, bInVsOut, nGrpTmp) then EgtErase( nLeadId) return end @@ -1024,12 +1204,12 @@ local function FindCorrectRibLead( dPar, nRib, nCrvOffs, bLeadInvert, dLeadLen, else -- primo tentativo nella direzione individuata dal parametro bInvert nLeadId = PrepareRibLead( nCrvOffs, nRib, bInvert, bInVsOut, dPar, dLeadLen) - if not VerifyRibsLead( nLeadId, nRib, dStrand, bInVsOut, nGrpTmp) then + if not VerifyRibsLead( nLeadId, nRib, bInVsOut, nGrpTmp) then -- secondo tentativo nell'altra direzione EgtErase( nLeadId) bInvert = not bInvert nLeadId = PrepareRibLead( nCrvOffs, nRib, bInvert, bInVsOut, dPar, dLeadLen) - if not VerifyRibsLead( nLeadId, nRib, dStrand, bInVsOut, nGrpTmp) then + if not VerifyRibsLead( nLeadId, nRib, bInVsOut, nGrpTmp) then EgtErase( nLeadId) return end @@ -1040,10 +1220,11 @@ local function FindCorrectRibLead( dPar, nRib, nCrvOffs, bLeadInvert, dLeadLen, end -------------------------------------------------------------------- -local function AddRibsLeadIn( nCrv, nLoopsGrp, dStrand, vtSlicing, nGrpTmp, bForceNoSolidBorder, bSpecialCase) +local function AddRibsLeadIn( nCrv, nLoopsGrp, vtSlicing, nGrpTmp, bForceNoSolidBorder, bSpecialCase) local dLILen = EgtGetInfo( nCrv, KEY_RIBS_LEAD_IN_LEN, 'd') local bLIInvert = EgtGetInfo( nCrv, KEY_RIBS_LEAD_IN_INVERT, 'b') + local dStrand = EgtGetInfo( nCrv, KEY_CRV_STRAND, 'd') if dLILen < GEO.EPS_SMALL then return end @@ -1059,12 +1240,13 @@ local function AddRibsLeadIn( nCrv, nLoopsGrp, dStrand, vtSlicing, nGrpTmp, bFor for i = 1, #vCrvOffs do local dParS = EgtCurveParamAtPoint( vCrvOffs[i], ptS) if dParS then - local nLeadIn = FindCorrectRibLead( dParS, nCrv, vCrvOffs[i], bLIInvert, dLILen, dStrand, true, nGrpTmp, bSpecialCase) + local nLeadIn = FindCorrectRibLead( dParS, nCrv, vCrvOffs[i], bLIInvert, dLILen, true, nGrpTmp, bSpecialCase) -- se lead in possibile if nLeadIn then EgtModifyCurveExtrusion( nLeadIn, vtSlicing, GDB_RT.GLOB) EgtSetInfo( nLeadIn, KEY_TYPE, TYPE.RIB) EgtSetName( nLeadIn, LEAD_IN_CRV) + EgtSetInfo( nLeadIn, KEY_CRV_STRAND, dStrand) return end end @@ -1072,13 +1254,14 @@ local function AddRibsLeadIn( nCrv, nLoopsGrp, dStrand, vtSlicing, nGrpTmp, bFor end -------------------------------------------------------------------- -local function AddRibsLeadOut( nCrv, nLoopsGrp, dStrand, vtSlicing, nGrpTmp, bForceNoSolidBorder, bSpecialCase) +local function AddRibsLeadOut( nCrv, nLoopsGrp, vtSlicing, nGrpTmp, bForceNoSolidBorder, bSpecialCase) local dRibsLOLen = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_LEN, 'd') local dRibsLOCoasting = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_COASTING, 'd') local dRibsLOWipe = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_WIPE, 'd') local dRibsLOWipeAng = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_WIPE_DIR, 'd') local bRibsLOInvert = EgtGetInfo( nCrv, KEY_RIBS_LEAD_OUT_INVERT, 'b') + local dStrand = EgtGetInfo( nCrv, KEY_CRV_STRAND, 'd') if abs( dRibsLOLen) < GEO.EPS_SMALL and abs( dRibsLOCoasting) < GEO.EPS_SMALL and @@ -1109,7 +1292,7 @@ local function AddRibsLeadOut( nCrv, nLoopsGrp, dStrand, vtSlicing, nGrpTmp, bFo local nWipe -- trovo curva opportuna per lead out - local nCrvRef, bInvert = FindCorrectRibLead( dParE, nCrv, vCrvOffs[i], bRibsLOInvert, dRibsLOLen + dRibsLOCoasting, dStrand, false, nGrpTmp, bSpecialCase) + local nCrvRef, bInvert = FindCorrectRibLead( dParE, nCrv, vCrvOffs[i], bRibsLOInvert, dRibsLOLen + dRibsLOCoasting, false, nGrpTmp, bSpecialCase) if nCrvRef then @@ -1120,6 +1303,8 @@ local function AddRibsLeadOut( nCrv, nLoopsGrp, dStrand, vtSlicing, nGrpTmp, bFo EgtModifyCurveExtrusion( nCrvLO, vtSlicing, GDB_RT.GLOB) EgtSetInfo( nCrvLO, KEY_TYPE, TYPE.RIB) EgtSetName( nCrvLO, LEAD_OUT_CRV) + EgtSetInfo( nCrvLO, KEY_CRV_STRAND, dStrand) + -- aggiorno ptE e vtE ptE = EgtEP( nCrvLO, GDB_ID.ROOT) vtE = EgtEV( nCrvLO, GDB_ID.ROOT) @@ -1131,10 +1316,10 @@ local function AddRibsLeadOut( nCrv, nLoopsGrp, dStrand, vtSlicing, nGrpTmp, bFo EgtTrimCurveStartAtLen( nCoasting, dRibsLOLen) EgtTrimCurveEndAtLen( nCoasting, dRibsLOCoasting) EgtModifyCurveExtrusion( nCoasting, vtSlicing, GDB_RT.GLOB) - EgtSetName( nCoasting, COASTING_CRV) EgtSetInfo( nCoasting, KEY_TYPE, TYPE.COASTING) EgtSetColor( nCoasting, EgtStdColor('ORANGE')) + EgtSetInfo( nCoasting, KEY_CRV_STRAND, dStrand) -- aggiorno ptE e vtE ptE = EgtEP( nCoasting, GDB_ID.ROOT) @@ -1150,11 +1335,14 @@ local function AddRibsLeadOut( nCrv, nLoopsGrp, dStrand, vtSlicing, nGrpTmp, bFo vtE:rotate( vtSlicing, EgtIf( bInvert, - dAng, dAng)) local ptFinal = FindWipeEndPoint( ptE, vtE, dRibsLOWipe, vtSlicing) nWipe = EgtCurveCompoFromPoints( EgtGetParent( nCrv), { ptE, ptFinal}, GDB_RT.GLOB) - EgtModifyCurveExtrusion( nWipe, vtSlicing, GDB_RT.GLOB) - EgtRelocateGlob( nWipe, nCoasting or nCrvLO or nCrv, GDB_IN.AFTER) - EgtSetName( nWipe, WIPE_CRV) - EgtSetInfo( nWipe, KEY_TYPE, TYPE.WIPE) - EgtSetColor( nWipe, EgtStdColor('AQUA')) + if nWipe then + EgtModifyCurveExtrusion( nWipe, vtSlicing, GDB_RT.GLOB) + EgtRelocateGlob( nWipe, nCoasting or nCrvLO or nCrv, GDB_IN.AFTER) + EgtSetName( nWipe, WIPE_CRV) + EgtSetInfo( nWipe, KEY_TYPE, TYPE.WIPE) + EgtSetInfo( nWipe, KEY_CRV_STRAND, 0) + EgtSetColor( nWipe, EgtStdColor('AQUA')) + end end return @@ -1185,6 +1373,13 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams) EgtMove( nNewEntId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB) EgtSetColor( nNewEntId, EgtStdColor('MAROON')) + + local dStrand = EgtGetInfo( vEntIds[i], KEY_RIBS_STRAND, 'd') + EgtSetInfo( nNewEntId, KEY_CRV_STRAND, dStrand) + + EgtSetInfo( nNewEntId, KEY_ASSOCIATED_P_CRV, vEntIds[i]) + EgtSetInfo( vEntIds[i], KEY_ASSOCIATED_TP_CRV, nNewEntId) + if i == 1 then nNewFirstEnt = nNewEntId end end @@ -1205,7 +1400,7 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams) -- collego le passate di una stessa costolatura for i = 1, #tabRibs do if EgtCurveIsClosed( tabRibs[i][1]) then - AddLink( tabRibs[i], nTpathGrpId, LINK_TYPE.NONE, LayerParams.dLinkParam, LayerParams.dSPOffs, LayerParams.dStrand, LayerParams.vtSlicing) + AddLink( tabRibs[i], nTpathGrpId, LINK_TYPE.NONE, LayerParams.dLinkParam, LayerParams.dSPOffs, LayerParams.vtSlicing) else local bLoopRib = EgtGetInfo( tabRibs[i][1], KEY_LOOP_RIB, 'b') or false for j = 1, #tabRibs[i] - 1 do @@ -1218,7 +1413,7 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams) local bCheckLinkedRibs = not bForceLink and not bUserLink if ( nOrig1 ~= nOrig2 and bUserLink) or ( nSplitId1 == nSplitId2 and nOrig1 == nOrig2) then - local nLinkId = CalcRibsLink( tabRibs[i][j], tabRibs[i][j + 1], nLoopGrp, LayerParams.dStrand, bForceLink, bCheckLinkedRibs, LayerParams.vtSlicing, nGrpTmp) + local nLinkId = CalcRibsLink( tabRibs[i][j], tabRibs[i][j + 1], nLoopGrp, bForceLink, bCheckLinkedRibs, LayerParams.vtSlicing, nGrpTmp) -- se LoopRib congiungo i setti in unico percorso if bLoopRib and nLinkId then @@ -1232,7 +1427,7 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams) -- se LoopRib aggiungo collegamento tra primo e ultimo setto del gruppo if bLoopRib then local nTotCrv = #tabRibs[i] - local nLinkId = CalcRibsLink( tabRibs[i][nTotCrv], tabRibs[i][1], nLoopGrp, LayerParams.dStrand, false, false, LayerParams.vtSlicing, nGrpTmp) + local nLinkId = CalcRibsLink( tabRibs[i][nTotCrv], tabRibs[i][1], nLoopGrp, false, false, LayerParams.vtSlicing, nGrpTmp) if nLinkId then -- se curva unica if tabRibs[i][nTotCrv] == tabRibs[i][1] then @@ -1265,7 +1460,7 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams) local bLink2 = EgtGetInfo( tabRibs[i + 1][1], KEY_RIBS_LINK, 'b') if bLink1 and bLink2 then local nCnt = #tabRibs[i] - CalcRibsLink( tabRibs[i][nCnt], tabRibs[i + 1][1], nLoopGrp, LayerParams.dStrand, false, true, LayerParams.vtSlicing, nGrpTmp) + CalcRibsLink( tabRibs[i][nCnt], tabRibs[i + 1][1], nLoopGrp, false, true, LayerParams.vtSlicing, nGrpTmp) end end @@ -1280,12 +1475,12 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams) -- verifico se necessario lead in local nPrev = EgtGetPrev( nCrvRib) if not nPrev or EgtGetName( nPrev) ~= LINK_CRV then - AddRibsLeadIn( nCrvRib, nLoopGrp, LayerParams.dStrand, LayerParams.vtSlicing, nGrpTmp, bForceNoSolidBorder, bSpecialCase) + AddRibsLeadIn( nCrvRib, nLoopGrp, LayerParams.vtSlicing, nGrpTmp, bForceNoSolidBorder, bSpecialCase) end -- verifico se necessario lead out local nNext = EgtGetNext( nCrvRib) if not nNext or EgtGetName( nNext) ~= LINK_CRV then - AddRibsLeadOut( nCrvRib, nLoopGrp, LayerParams.dStrand, LayerParams.vtSlicing, nGrpTmp, bForceNoSolidBorder, bSpecialCase) + AddRibsLeadOut( nCrvRib, nLoopGrp, LayerParams.vtSlicing, nGrpTmp, bForceNoSolidBorder, bSpecialCase) end nCrvRib = EgtGetNextName( nCrvRib, RIBS_CRV .. '*') end @@ -1376,6 +1571,8 @@ local function SpiralVase( vLayIds, LayerParams) end EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB) + EgtSetInfo( nNewEntId, KEY_CRV_STRAND, LayerParams.dStrand) + -- eventuale inversione if LayerParams.bInvert then EgtInvertCurve( nNewEntId) @@ -1383,7 +1580,7 @@ local function SpiralVase( vLayIds, LayerParams) end EgtSetColor( nNewEntId, EgtStdColor('GRAY')) - -- se primo layer + -- se primo layer if bFirst and nNewEntId then -- mi sposto dell'altezza layer EgtMove( nNewEntId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) @@ -1471,7 +1668,7 @@ function CalcToolPath.Exec( nPartId) -- Ciclo sui layer for nIdx = 1, #vLayIds do - + -- scorro tutti i gruppi di contorni local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*") while nCrvGrpId do diff --git a/LuaLibs/RunCalcSolids.lua b/LuaLibs/RunCalcSolids.lua index 59ab7e6..26e9f3f 100644 --- a/LuaLibs/RunCalcSolids.lua +++ b/LuaLibs/RunCalcSolids.lua @@ -20,7 +20,6 @@ local function GetLayerParamsForSolidCalc( nPartId) local LayerParams = {} LayerParams.bSpiralVase = EgtGetInfo( nPartId, KEY_SPIRAL_VASE, 'b') or false LayerParams.dLayHeight = EgtGetInfo( nPartId, KEY_SLICE_STEP, 'd') - LayerParams.dStrand = EgtGetInfo( nPartId, KEY_STRAND, 'd') LayerParams.vtSlicing = EgtGetInfo( nPartId, KEY_SLICING_DIR, 'v') return LayerParams end @@ -192,7 +191,7 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer) local nType = EgtGetInfo( nCrvId, KEY_TYPE, 'i') if nType == TYPE.WIPE then return true end -- scelta del colore - local Color = EgtStdColor( 'GRAY') + local Color = EgtStdColor( 'GRAY') if nType == TYPE.OUTER_SHELL or nType == TYPE.EXTRA_OUTER_SHELL then Color = EgtStdColor( 'TEAL') elseif nType == TYPE.INNER_SHELL or nType == TYPE.EXTRA_SHELL then @@ -203,14 +202,13 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer) Color = EgtStdColor( 'YELLOW') elseif nType == TYPE.COASTING then Color = EgtStdColor( 'BLUE') - elseif nType == TYPE.WIPE then - Color = EgtStdColor( 'LIME') elseif nType == TYPE.RIB then Color = EgtStdColor( 'OLIVE') elseif nType == TYPE.AUX_SOLID then Color = EgtStdColor( 'AQUA') end - + local dStrand = EgtGetInfo( nCrvId, KEY_CRV_STRAND, 'd') + local nCopyId = EgtCopyGlob( nCrvId, nSolidGrp) local nId = GDB_ID.NULL local nParts = 1 @@ -230,7 +228,7 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer) local bOk = true for nInd = 0, nParts - 1 do local nGuideId = nId + nInd - local nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, LayerParams.dStrand - 5 * GEO.EPS_SMALL) + local nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 5 * GEO.EPS_SMALL) if not nSrfId then EgtOutLog( 'Warning : CreateSolid failed '.. '(layer '..tostring( nLayer)..', curve '..tostring( nCrvId)..')') -- se non ultima, provo a spostare l'estremità finale @@ -241,9 +239,9 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer) local bOk1 = EgtTrimCurveEndAtLen( nCopyId, LEN_TRIM) local bOk2 = EgtAddCurveCompoCurve( nGuideId, nCopyId) local bOk3 = EgtTrimCurveStartAtLen( nGuideId + 1, LEN_TRIM) - nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, LayerParams.dStrand - 5 * GEO.EPS_SMALL) + nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 5 * GEO.EPS_SMALL) if not nSrfId then - nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, LayerParams.dStrand - 50 * GEO.EPS_SMALL) + nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL) end end end @@ -258,7 +256,7 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer) if nFirstCrv and nCrvNbr > 1 then local nSrfIds = {} for nInd2 = 0, nCrvNbr-1 do - local nSrfId2 = CreateSolid( nFirstCrv + nInd2, nSolidGrp, LayerParams, LayerParams.dStrand - 50 * GEO.EPS_SMALL) + local nSrfId2 = CreateSolid( nFirstCrv + nInd2, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL) EgtErase( nFirstCrv + nInd2) if nSrfId2 then table.insert( nSrfIds, nSrfId2) @@ -279,6 +277,7 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer) if nSrfId then EgtSetColor( nSrfId, Color) EgtSetInfo( nSrfId, KEY_TYPE, nType) + EgtSetInfo( nSrfId, KEY_SLICE_NBR, nLayer) else bOk = false EgtOutLog( 'Warning : CreateSolid_Sewing failed') @@ -330,7 +329,7 @@ function RunCalcSolids.Exec() local nTPathGrpId = EgtGetFirstNameInGroup( nCrvGrpId, TOOLPATH_GRP) or GDB_ID.NULL if nTPathGrpId == GDB_ID.NULL then EgtOutBox( 'Error no tool paths', 'SolidCalc') - return + return end -- recupero il gruppo dei solidi diff --git a/Version.lua b/Version.lua index 5363e05..f000a69 100644 --- a/Version.lua +++ b/Version.lua @@ -1,4 +1,4 @@ -- Version.lua by Egaltech s.r.l. 2023/02/28 -- Gestione della versione di 3dPrinting -VERSION = '2.5f1' \ No newline at end of file +VERSION = '2.5f2' \ No newline at end of file