diff --git a/LuaLibs/AddManData.lua b/LuaLibs/AddManData.lua index 60ecab2..578d885 100644 --- a/LuaLibs/AddManData.lua +++ b/LuaLibs/AddManData.lua @@ -68,6 +68,8 @@ KEY_COASTING_FEED = "CoastingFeed" KEY_WIPE_LEN = "WipeLen" KEY_WIPE_FEEDPU = "WipeFeedPu" KEY_TOOL_DIAM = "ToolDiam" + +-- Ribs KEY_RIBS_OVERLAP = "RibsOverlap" KEY_RIBS_SHELLS_NBR = "RibsStrandCount" KEY_RIBS_LINK = "RibsLink" @@ -82,6 +84,7 @@ KEY_RIBS_LEAD_OUT_WIPE = "RibsLeadOutWipe" KEY_RIBS_LEAD_OUT_WIPE_DIR = "RibsLeadOutWipeDir" KEY_RIBS_INTERS = "RibsHaveIntersections" KEY_SPLIT_RIB = "SplitRib" +KEY_RIBS_TWO_STRANDS = "RibsHaveAll2Strands" -- Parametri di macchina SEC_3DPRINTING = "3dPrinting" diff --git a/LuaLibs/CalcPaths.lua b/LuaLibs/CalcPaths.lua index 0d873c0..e86d3a5 100644 --- a/LuaLibs/CalcPaths.lua +++ b/LuaLibs/CalcPaths.lua @@ -24,8 +24,6 @@ local function GetLayerParamsForPathCalc() LayerParams.nFloorNbr = EgtGetInfo( s_nPartId, KEY_FLOOR_NBR, 'i') LayerParams.vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v') -- parametri costolature - LayerParams.dRibsOverlap = EgtGetInfo( s_nPartId, KEY_RIBS_OVERLAP, 'd') - LayerParams.nRibsShellsNbr = EgtGetInfo( s_nPartId, KEY_RIBS_SHELLS_NBR, 'i') LayerParams.bRibsInvertOrder = EgtGetInfo( s_nPartId, KEY_RIBS_INVERT_ORDER, 'b') return LayerParams end @@ -67,6 +65,21 @@ local function GetLayerStartPoint( nLayId, vtSlicing) return vPtStart end +---------------------------------------------------------------------- +local function ComputeSurfOffset( nSrf, nGrpId, dOffs) + + local nCopySrf = EgtCopy( nSrf, nGrpId) + local bOk = EgtSurfFrOffset( nCopySrf, dOffs) + local bExists = EgtSurfFrChunkCount( nCopySrf) > 0 + if not bOk or not bExists then + EgtErase( nCopySrf) + nCopySrf = EgtCopyGlob( nSrf, nGrpId) + bOk = EgtSurfFrOffset( nCopySrf, dOffs + 0.05) + bExists = EgtSurfFrChunkCount( nCopySrf) > 0 + end + return bOk, bExists, nCopySrf +end + --------------------------------------------------------------------- local function GetPathsFromSurf( nSrfId, sName, nType, nGrpId, vPtStart) @@ -141,7 +154,7 @@ local function TrimRibsOffset( nCrv, nOffs1, nOffs2, nOffsGrp, bIn) local ptInt2 = EgtIP( nCrv, nOffs2, ORIG()) local dPar1, dPar2 if ptInt1 then dPar1 = EgtCurveParamAtPoint( nCrv, ptInt1) end - if ptInt2 then dPar2 = EgtCurveParamAtPoint( nCrv, ptInt2) end + if ptInt2 then dPar2 = EgtCurveParamAtPoint( nCrv, ptInt2) end if dPar1 and dPar2 then -- la curva viene spezzata in tre parti @@ -167,9 +180,13 @@ end local function AdjustRibsOffsetForIntersection( nCrv1, nCrv2, LayerParams, nOffsGrp, bIn) -- calcolo gli offset della curva principale ( nCrv1) da usare per trim - local dOffs = ( LayerParams.nRibsShellsNbr - 1) * LayerParams.dStrand / 2 - local nOffsM = EgtOffsetCurveAdv( nCrv1, - dOffs - ( 1 - LayerParams.dRibsOverlap / 100) * LayerParams.dStrand) - local nOffsP = EgtOffsetCurveAdv( nCrv1, dOffs + ( 1 - LayerParams.dRibsOverlap / 100) * LayerParams.dStrand) + local nShells = EgtGetInfo( nCrv1, KEY_RIBS_SHELLS_NBR, 'i') + local nOverlap1 = EgtGetInfo( nCrv1, KEY_RIBS_OVERLAP, 'i') + local nOverlap2 = EgtGetInfo( nCrv2, KEY_RIBS_OVERLAP, 'i') + local nOverlap = min( nOverlap1, nOverlap2) + local dOffs = ( nShells - 1) * LayerParams.dStrand / 2 + local nOffsM = EgtOffsetCurveAdv( nCrv1, - dOffs - ( 1 - nOverlap / 100) * LayerParams.dStrand) + local nOffsP = EgtOffsetCurveAdv( nCrv1, dOffs + ( 1 - nOverlap / 100) * LayerParams.dStrand) local vSplit = {} -- recupero gli offset della curva secondaria ( nCrv2) @@ -186,7 +203,7 @@ end -------------------------------------------------------------------- -- Funzione che sistema le intersezioni fra costolature nel caso di 2 passate local function AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nOffsGrp, bIn) - + -- recupero gli offset delle due curve local vOffs1 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv1)) local vOffs2 = EgtGetNameInGroup( nOffsGrp, EgtGetName( nCrv2)) @@ -215,7 +232,7 @@ local function AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams local _, dParE = EgtCurveDomain( nCrv1) bInCrv1 = abs( dParInt - dParE) < 100 * GEO.EPS_SMALL end - TrimRibsOffset( vOffs1[i], vOffs2[vIds[1]], vOffs2[vIds[2]], nOffsGrp, bInCrv1) + TrimRibsOffset( vOffs1[i], vOffs2[vIds[1]], vOffs2[vIds[2]], nOffsGrp, bInCrv1) end end @@ -230,17 +247,16 @@ local function AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams if #vIds > 0 then if #vIds == 1 then table.insert( vIds, EgtIf( vIds[1] == 1, 2, 1)) end TrimRibsOffset( vOffs2[i], vCopy1[vIds[1]], vCopy1[vIds[2]], nOffsGrp, bIn) - end + end end for i = 1, #vCopy1 do EgtErase( vCopy1[i]) end - end -------------------------------------------------------------------- -local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp) +local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, bAllTwoStrands) local nCrvGrp = EgtGetParent( nRibsPathGrp) local nSrf = EgtGetFirstInGroup( nCrvGrp) @@ -261,7 +277,7 @@ local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPa end end - local bInters = false + local bInters = false local vSplit = {} for i = 1, #vRibsIds do -- verifico se interseca uno dei setti successivi @@ -282,7 +298,7 @@ local function HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPa nCrv1, nCrv2 = nCrv2, nCrv1 end - if LayerParams.nRibsShellsNbr == 2 then + if bAllTwoStrands then -- nel caso di 2 passate gestione speciale AdjustRibsOffsetForIntersection2Shells( nCrv1, nCrv2, LayerParams, nRibsPathGrp, bIn) else @@ -325,27 +341,30 @@ end -------------------------------------------------------------------- -- Funzione che riordina le costolature nel caso generico -local function ReorderRibs( nGrp, bInvertOrder, nShells) +local function ReorderRibs( nGrp, bInvertOrder) EgtSpInit() local vIds = EgtGetNameInGroup( nGrp, RIBS_CRV .. '*') local vSplitRibs = {} + local vSPRibs = {} for i = 1, #vIds do local nInfo = EgtGetInfo( vIds[i], KEY_SPLIT_RIB, 'i') + local nShells = EgtGetInfo( vIds[i], KEY_RIBS_SHELLS_NBR, 'i') -- se è ottenuto dalla divisione di una costolatura non va considerato per il TSP ( viene aggiunto in seguito) if nInfo and nShells == 1 then table.insert( vSplitRibs, vIds[i]) else local pt = EgtMP( vIds[i], GDB_RT.GLOB) EgtSpAddPoint( pt:getX(), pt:getY(), pt:getZ(), 0, 0, pt:getX(), pt:getY(), pt:getZ(), 0, 0) + table.insert( vSPRibs, vIds[i]) end end local vOrd, dLen = EgtSpCalculate( SHP_TY.OPEN) EgtSpTerminate() - EgtRelocateGlob( vIds[vOrd[1]], nGrp, EgtIf( bInvertOrder, GDB_IN.LAST, GDB_IN.FIRST)) + EgtRelocateGlob( vSPRibs[vOrd[1]], nGrp, EgtIf( bInvertOrder, GDB_IN.LAST, GDB_IN.FIRST)) for i = 2, #vOrd do - EgtRelocateGlob( vIds[vOrd[i]], vIds[vOrd[i-1]], EgtIf( bInvertOrder, GDB_IN.BEFORE, GDB_IN.AFTER)) + EgtRelocateGlob( vSPRibs[vOrd[i]], vSPRibs[vOrd[i-1]], EgtIf( bInvertOrder, GDB_IN.BEFORE, GDB_IN.AFTER)) end -- aggiusto tutte le costolature divise @@ -357,13 +376,70 @@ local function ReorderRibs( nGrp, bInvertOrder, nShells) end +-------------------------------------------------------------------------------------------- +local function CopyInfo( nSouId, nDestId, sInfo, sType) + local info = EgtGetInfo( nSouId, sInfo, sType) + EgtSetInfo( nDestId, sInfo, info) +end + +-------------------------------------------------------------------------------------------- +local function ReassignInfo( nCrv, nCnt, vOrig) + + for nId = nCrv, nCrv + nCnt - 1 do + local ptS = EgtSP( nId) + local ptE = EgtEP( nId) + + -- info overlap + local nOverlap = EgtGetInfo( s_nPartId, KEY_RIBS_OVERLAP, 'i') + EgtSetInfo( nId, KEY_RIBS_OVERLAP, nOverlap) + + local bStart = false + local bEnd = false + while not bStart and not bEnd do + -- scorro le curve originarie per capire da quali deriva + for i = 1, #vOrig do + local ptSOrig = EgtSP( vOrig[i]) + local ptEOrig = EgtEP( vOrig[i]) + + -- verifico se corrisponde al suo start + if AreSamePointApprox( ptS, ptSOrig) or AreSamePointApprox( ptS, ptEOrig) then + CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_IN_INVERT, 'b') + CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_IN_LEN, 'd') + bStart = true + end + -- verifico se corrisponde al suo end + if AreSamePointApprox( ptE, ptSOrig) or AreSamePointApprox( ptE, ptEOrig) then + CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_OUT_INVERT, 'b') + CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_OUT_LEN, 'd') + CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_OUT_COASTING, 'd') + CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_OUT_WIPE, 'd') + CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_OUT_WIPE_DIR, 'd') + bEnd = true + end + end + end + end + + -- dopo aver salvato le info è inutile conservare le curve originali + for i = 1, #vOrig do + EgtErase( vOrig[i]) + end +end + --------------------------------------------------------------------------------------------- -- Funzione che riordina le costolature nel caso di intersezioni e 2 passate local function ReorderRibsInters2Shells( nOffsGrp, dStrand) local vOffs = EgtGetNameInGroup( nOffsGrp, RIBS_CRV .. '*') + -- copio le curve originali ( per recuperarne le info) + local vCopy = {} + for i = 1, #vOffs do + local nNewId = EgtCopy( vOffs[i], nOffsGrp) + table.insert( vCopy, nNewId) + end + -- concateno le curve - local nCrv, nCnt = EgtCurveCompoByChain( nOffsGrp, vOffs, ORIG()) + local nCrv, nCnt = EgtCurveCompoByChain( nOffsGrp, vOffs, ORIG()) local vIds = {} for i = nCrv, nCrv + nCnt - 1 do @@ -417,73 +493,127 @@ local function ReorderRibsInters2Shells( nOffsGrp, dStrand) else nCurrCrv = nil end - end + end end end + + -- Recupero le info dalle curve originali + ReassignInfo( nCrv, nCnt, vCopy) end -------------------------------------------------------------------- -local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, nStmId) +local function CalcRibsPaths( nSliceGrp, nRibsGrp, LayerParams, nStmId, nIdx) - -- calcolo gli offset - local dOffs = ( LayerParams.nRibsShellsNbr - 1) * LayerParams.dStrand / 2 - local nOffsGrp = EgtGroup( nRibsGrp) local vRibs = EgtGetNameInGroup( nRibsGrp, RIBS_CRV .. '*') + -- verifico se tutte le costolature vengono fatte con 2 passate + local bAllTwoStrands = true for i = 1, #vRibs do - for k = 0, LayerParams.nRibsShellsNbr - 1 do + local nStrand = EgtGetInfo( vRibs[i], KEY_RIBS_SHELLS_NBR, 'i') + if nStrand ~= 2 then + bAllTwoStrands = false + break + end + end + + -- calcolo gli offset + local nOffsGrp = EgtGroup( nRibsGrp) + for i = 1, #vRibs do + local nShellsNbr = EgtGetInfo( vRibs[i], KEY_RIBS_SHELLS_NBR, 'i') + local dOffs = ( nShellsNbr - 1) * LayerParams.dStrand / 2 + for k = 0, nShellsNbr - 1 do local nNewId = EgtOffsetCurveAdv( vRibs[i], - dOffs + k * LayerParams.dStrand) EgtSetName( nNewId, EgtGetName( vRibs[i])) EgtSetInfo( nNewId, KEY_TYPE, TYPE.RIB) EgtRelocateGlob( nNewId, nOffsGrp) end end - + -- scorro i gruppi di curve + local dOffs = 0.5 * LayerParams.dStrand - LayerParams.dOffs + ( LayerParams.nShellsNbr - 1) * LayerParams.dStrand local nCrvGrp = EgtGetFirstNameInGroup( nSliceGrp, CONTOUR_GRP .. '*') while nCrvGrp do + + -- creo o svuoto il gruppo local nRibsPathGrp = EgtGetFirstNameInGroup( nCrvGrp, RIBS_GRP) - local nSrf = EgtGetFirstNameInGroup( nRibsPathGrp, LAYER_SRF) - if nSrf then + if not nRibsPathGrp then + nRibsPathGrp = EgtGroup( nCrvGrp) + EgtSetName( nRibsPathGrp, RIBS_GRP) + EgtSetStatus( nRibsPathGrp, GDB_ST.OFF) + else + EgtEmptyGroup( nRibsPathGrp) + end + + -- creo le superfici con cui fare i trim + local nSrf = EgtGetFirstNameInGroup( nCrvGrp, LAYER_SRF) + local bOk, bExists, nSrfBase = ComputeSurfOffset( nSrf, nRibsPathGrp, - dOffs) + if not bOk then + EgtOutLog( 'Error on Offset for Ribs (layer '..tostring( nIdx)..') - CalcPaths') + elseif not bExists then + EgtOutLog( 'Warning: Ribs not possibile (layer '..tostring( nIdx)..') - CalcPaths') + else + local vSurfOffs = {} + for i = 1, #vRibs do + local nOverlap = EgtGetInfo( vRibs[i], KEY_RIBS_OVERLAP, 'i') + if not vSurfOffs[nOverlap] then + local dNewOffs = ( 1 - nOverlap / 100) * LayerParams.dStrand + local bOk, bExists, nSrfOffs = ComputeSurfOffset( nSrfBase, nRibsPathGrp, - dNewOffs) + if bOk and bExists then + vSurfOffs[ nOverlap] = nSrfOffs + end + end + end + -- gestisco eventuali intersezioni fra costolature - local bInters = HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp) + local bInters = HandleRibsIntersections( nRibsGrp, LayerParams, nOffsGrp, nRibsPathGrp, bAllTwoStrands) EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_INTERS, bInters) + EgtSetInfo( nRibsPathGrp or GDB_ID.NULL, KEY_RIBS_TWO_STRANDS, bAllTwoStrands) -- riordino le costolature - if LayerParams.nRibsShellsNbr == 2 and bInters then + if bAllTwoStrands and bInters then -- gestione caso speciale di intersezione e 2 passate ReorderRibsInters2Shells( nRibsPathGrp, LayerParams.dStrand) else - ReorderRibs( nRibsPathGrp, LayerParams.bRibsInvertOrder, LayerParams.nRibsShellsNbr) + ReorderRibs( nRibsPathGrp, LayerParams.bRibsInvertOrder) end - + -- eseguo il trim delle costole con la regione offsettata local vErased = {} local vOrderedRibs = EgtGetNameInGroup( nRibsPathGrp, RIBS_CRV .. '*') - for i = 1, #vOrderedRibs do - local nCrv, nCnt = EgtTrimCurveWithRegion( vOrderedRibs[i], nSrf, true, false) - if nCnt == 0 then - -- lo aggiungo nella tabella delle costolature eliminate + for i = 1, #vOrderedRibs do + -- trim con superficie opportuna + local nOverlap = EgtGetInfo( vOrderedRibs[i], KEY_RIBS_OVERLAP, 'i') + if not vSurfOffs[ nOverlap] then + -- la costolatura non è fattibile + EgtOutLog( 'Warning: Ribs not possibile (layer '..tostring( nIdx)..') - CalcPaths') + EgtErase( vOrderedRibs[i]) vErased[vOrderedRibs[i]] = 1 - end - -- elimino tratti troppo corti - for nId = nCrv, nCrv + nCnt - 1 do - local dLen = EgtCurveLength( nId) - if dLen < 10 * MIN_LEN then - EgtErase( nId) + else + local nCrv, nCnt = EgtTrimCurveWithRegion( vOrderedRibs[i], vSurfOffs[nOverlap], true, false) + if nCnt == 0 then -- lo aggiungo nella tabella delle costolature eliminate - vErased[vOrderedRibs[i]] = 1 - else - local nInfo = EgtGetInfo( nId, KEY_SPLIT_RIB, 'i') - -- se la costolatura da cui deriva è stata eliminata, tolgo l'info che le associava - if nInfo and vErased[nInfo] then - EgtRemoveInfo( nId, KEY_SPLIT_RIB) + vErased[vOrderedRibs[i]] = 1 + end + -- elimino tratti troppo corti + for nId = nCrv, nCrv + nCnt - 1 do + local dLen = EgtCurveLength( nId) + if dLen < 10 * MIN_LEN then + EgtErase( nId) + -- lo aggiungo nella tabella delle costolature eliminate + vErased[vOrderedRibs[i]] = 1 + else + local nInfo = EgtGetInfo( nId, KEY_SPLIT_RIB, 'i') + -- se la costolatura da cui deriva è stata eliminata, tolgo l'info che le associava + if nInfo and vErased[nInfo] then + EgtRemoveInfo( nId, KEY_SPLIT_RIB) + end end end end end end - - if not EgtGetFirstNameInGroup( nRibsPathGrp, RIBS_CRV .. '*') then + + EgtErase( nSrfBase) + if not EgtGetFirstNameInGroup( nRibsPathGrp, RIBS_CRV .. '*') then EgtErase( nRibsPathGrp) end nCrvGrp = EgtGetNextName( nCrvGrp, CONTOUR_GRP .. '*') @@ -532,86 +662,35 @@ function CalcPaths.Exec( nPartId, nStmId) -- recupero la superficie ottenuta dallo slicing local nSrf = EgtGetFirstNameInGroup( nCrvGrpId, LAYER_SRF) if nSrf then - -- esterno - local nSrfId = EgtCopyGlob( nSrf, nCrvGrpId) + + -- parete esterna local dOffs = 0.5 * LayerParams.dStrand - LayerParams.dOffs - local bOk = EgtSurfFrOffset( nSrfId, -dOffs) - local bExists = EgtSurfFrChunkCount( nSrfId) > 0 - if not bOk then - EgtErase( nSrfId) - nSrfId = EgtCopyGlob( nSrf, nCrvGrpId) - local dNewOffs = dOffs - 0.05 - bOk = EgtSurfFrOffset( nSrfId, -dNewOffs) - bExists = EgtSurfFrChunkCount( nSrfId) > 0 - end - -- se offset riuscito, estraggo i contorni (pareti esterne) + local bOk, bExists, nSrfId = ComputeSurfOffset( nSrf, nCrvGrpId, - dOffs) if not bOk then EgtOutLog( 'Error on ExtOffset (layer '..tostring( nIdx)..') - CalcPaths') elseif not bExists then EgtOutLog( 'Warning : ExtOffset not possible (layer '..tostring( nIdx)..') - CalcPaths') else + -- se offset riuscito, estraggo i contorni (pareti esterne) GetPathsFromSurf( nSrfId, SHELL_CRV..'0', TYPE.OUTER_SHELL, nGrpId, vPtStart) end EgtErase( nSrfId) - -- calcolo pareti interne + -- pareti interne for nInd2 = 1, LayerParams.nShellsNbr - 1 do -- offset della superficie originale - local nSrfId = EgtCopy( nSrf, nGrpId) - local bOk = EgtSurfFrOffset( nSrfId, - dOffs - nInd2 * LayerParams.dStrand) - local bExists = EgtSurfFrChunkCount( nSrfId) > 0 - if not bOk then - EgtErase( nSrfId) - nSrfId = EgtCopyGlob( nSrf, nCrvGrpId) - bOk = EgtSurfFrOffset( nSrfId, -dOffs + 0.05 - nInd2 * LayerParams.dStrand) - bExists = EgtSurfFrChunkCount( nSrfId) > 0 - end - -- se offset riuscito, estraggo i contorni ( pareti interne) + local bOk, bExists, nSrfId = ComputeSurfOffset( nSrf, nCrvGrpId, - dOffs - nInd2 * LayerParams.dStrand) if not bOk then EgtOutLog( 'Error on IntOffset (layer '..tostring( nIdx)..') - CalcPaths') elseif not bExists then EgtOutLog( 'Warning : IntOffset not possible (layer '..tostring( nIdx)..') - CalcPaths') else + -- se offset riuscito, estraggo i contorni ( pareti interne) GetPathsFromSurf( nSrfId, SHELL_CRV..tostring( nInd2), TYPE.INNER_SHELL, nGrpId, vPtStart) end EgtErase( nSrfId) end - -- costolature - if nRibsGrp then - - -- creo o svuoto il gruppo per le costolature - local nRibsPathGrp = EgtGetFirstNameInGroup( nCrvGrpId, RIBS_GRP) - if not nRibsPathGrp then - nRibsPathGrp = EgtGroup( nCrvGrpId) - EgtSetName( nRibsPathGrp, RIBS_GRP) - EgtSetStatus( nRibsPathGrp, GDB_ST.OFF) - else - EgtEmptyGroup( nRibsPathGrp) - end - - -- calcolo superficie di offset da usare per le costolature - local nSrfId = EgtCopy( nSrf, nRibsPathGrp) - local dOffs = 0.5 * LayerParams.dStrand - LayerParams.dOffs + ( LayerParams.nShellsNbr - 1) * LayerParams.dStrand + ( 1 - LayerParams.dRibsOverlap / 100) * LayerParams.dStrand - local bOk = EgtSurfFrOffset( nSrfId, - dOffs) - local bExists = ( bOk and EgtSurfFrChunkCount( nSrfId) > 0) - if not bOk then - EgtErase( nSrfId) - nSrfId = EgtCopyGlob( nSrf, nRibsPathGrp) - bOk = EgtSurfFrOffset( nSrfId, - dOffs + 0.05) - bExists = ( bOk and EgtSurfFrChunkCount( nSrfId) > 0) - end - -- se non ho una superficie errore ed elimino il gruppo delle costolature - if not bOk then - EgtErase( nRibsPathGrp) - EgtOutLog( 'Error on Offset (Ribs) (layer '..tostring( nIdx)..') - CalcPaths') - elseif not bExists then - EgtErase( nRibsPathGrp) - EgtOutLog( 'Warning : Ribs not possible (layer '..tostring( nIdx)..') - CalcPaths') - end - - end - -- gestione eventuale floor if nIdx <= LayerParams.nFloorNbr then AddFloor( nSrf, nGrpId, LayerParams, nIdx) @@ -624,7 +703,7 @@ function CalcPaths.Exec( nPartId, nStmId) -- sistemo eventuali costolature if nRibsGrp then - CalcRibsPaths( vLayIds[nIdx], nRibsGrp, LayerParams, nStmId) + CalcRibsPaths( vLayIds[nIdx], nRibsGrp, LayerParams, nStmId, nIdx) end if EgtProcessEvents( nIdx / #vLayIds * 100, 0) == 1 then diff --git a/LuaLibs/CalcSlices.lua b/LuaLibs/CalcSlices.lua index 211fd09..2aa72cf 100644 --- a/LuaLibs/CalcSlices.lua +++ b/LuaLibs/CalcSlices.lua @@ -53,15 +53,48 @@ local function ComputeMaxH( nStmId, frSlicing, HMax) return GEO.INFINITO end +-------------------------------------------------------------------- +local function ReadParam( nId, sKey, sType, table) + local info = EgtGetInfo( nId, sKey, sType) or EgtGetInfo( s_nPartId, sKey, sType) + table[sKey] = info +end + +-------------------------------------------------------------------- +local function GetRibParams( nId) + + local RibParam = {} + ReadParam( nId, KEY_RIBS_SHELLS_NBR, 'i', RibParam) + ReadParam( nId, KEY_RIBS_INVERT_DIR, 'b', RibParam) + ReadParam( nId, KEY_RIBS_LEAD_IN_INVERT, 'b', RibParam) + ReadParam( nId, KEY_RIBS_LEAD_IN_LEN, 'd', RibParam) + ReadParam( nId, KEY_RIBS_LEAD_OUT_INVERT, 'b', RibParam) + ReadParam( nId, KEY_RIBS_LEAD_OUT_LEN, 'd', RibParam) + ReadParam( nId, KEY_RIBS_LEAD_OUT_COASTING, 'd', RibParam) + ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE, 'd', RibParam) + ReadParam( nId, KEY_RIBS_LEAD_OUT_WIPE_DIR, 'd', RibParam) + + -- overlap può essere diverso tra le varie costolature solo se non sono collegate + local bLink = EgtGetInfo( s_nPartId, KEY_RIBS_LINK, 'b') or false + if bLink then + RibParam[ KEY_RIBS_OVERLAP] = EgtGetInfo( s_nPartId, KEY_RIBS_OVERLAP, 'i') -- parametro generico + else + ReadParam( nId, KEY_RIBS_OVERLAP, 'i', RibParam) -- parametro specifico della costolatura + end + + return RibParam +end + -------------------------------------------------------------------- local function SlicingRibs( vtSlicing) local nRibsShells = EgtGetInfo( s_nPartId, KEY_RIBS_SHELLS_NBR, 'i') or 0 if nRibsShells == 0 then return end + -- recupero le superfici che definiscono le nervature local nRibsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_RIBS) local vRibsIds = EgtGetAllInGroup( nRibsLay or GDB_ID.NULL) if not vRibsIds or #vRibsIds == 0 then return end + -- sistemo la direzione normale dei piani for i = 1, #vRibsIds do if EgtGetType( vRibsIds[i]) == GDB_TY.SRF_MESH then @@ -72,6 +105,13 @@ local function SlicingRibs( vtSlicing) end end end + + -- recupero i parametri di ogni costolatura + local tabParams = {} + for i = 1, #vRibsIds do + local vRibParams = GetRibParams( vRibsIds[i]) + table.insert( tabParams, vRibParams) + end local nLayId = EgtGetFirstNameInGroup( s_nPartId, SLICE_LAYER .. '*') while nLayId do @@ -92,10 +132,13 @@ local function SlicingRibs( vtSlicing) for nId = nNewId, nNewId + nPntCnt -1 do EgtErase( nId) end - -- rinomino le curve e correggo di DeltaZ + -- rinomino le curve, correggo di DeltaZ e assegno parametri for nId = nNewId + nPntCnt, nNewId + nPntCnt + nCrvCnt - 1 do EgtSetName( nId, RIBS_CRV .. tostring( i)) EgtMove( nId, - dDeltaZ * vtSlicing) + for sKey, sVal in pairs( tabParams[i]) do + EgtSetInfo( nId, sKey, sVal) + end end -- rimuovo superfici for nId = nNewId + nPntCnt + nCrvCnt, nNewId + nPntCnt + nCrvCnt + nSrfCnt -1 do diff --git a/LuaLibs/CalcToolPath.lua b/LuaLibs/CalcToolPath.lua index 9493984..7ed6870 100644 --- a/LuaLibs/CalcToolPath.lua +++ b/LuaLibs/CalcToolPath.lua @@ -38,17 +38,8 @@ local function GetLayerParamsForToolPathCalc() LayerParams.vtSlicing = EgtGetInfo( s_nPartId, KEY_SLICING_DIR, 'v') LayerParams.dTDiam = EgtGetInfo( s_nPartId, KEY_TOOL_DIAM, 'd') -- Parametri costolature - LayerParams.nRibsShellsNbr = EgtGetInfo( s_nPartId, KEY_RIBS_SHELLS_NBR, 'i') LayerParams.bRibsLink = EgtGetInfo( s_nPartId, KEY_RIBS_LINK, 'b') - LayerParams.bRibsInvert = EgtGetInfo( s_nPartId, KEY_RIBS_INVERT_DIR, 'b') - LayerParams.bRibsLIInvert = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_IN_INVERT, 'b') - LayerParams.dRibsLILen = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_IN_LEN, 'd') - LayerParams.bRibsLOInvert = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_OUT_INVERT, 'b') - LayerParams.dRibsLOLen = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_OUT_LEN, 'd') - LayerParams.dRibsLOCoasting = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_OUT_COASTING, 'd') - LayerParams.dRibsLOWipe = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_OUT_WIPE, 'd') - LayerParams.dRibsLOWipeAng = EgtGetInfo( s_nPartId, KEY_RIBS_LEAD_OUT_WIPE_DIR, 'd') - + return LayerParams end @@ -153,7 +144,7 @@ local function AddRetraction( nCrvId, dCoastingLen, dWipeLen) if dWipeLen > GEO.EPS_SMALL then local nWipeId = EgtCopyGlob( nCopyId, nCoastingId or nCrvId, GDB_IN.AFTER) - EgtTrimCurveEndAtLen( nWipeId, dWipeLen) + EgtTrimCurveEndAtLen( nWipeId, dWipeLen) EgtSetName( nWipeId, WIPE_CRV) EgtSetInfo( nWipeId, KEY_TYPE, TYPE.WIPE) EgtSetColor( nWipeId, EgtStdColor('TEAL')) @@ -276,9 +267,12 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink) end -------------------------------------------------------------------- -local function AddRibsLeadIn( nCrv, nLoopsGrp, LayerParams) +local function AddRibsLeadIn( nCrv, nLoopsGrp) - if LayerParams.dRibsLILen < GEO.EPS_SMALL then return end + local dLILen = EgtGetInfo( nCrv, KEY_RIBS_LEAD_IN_LEN, 'd') + local bLIInvert = EgtGetInfo( nCrv, KEY_RIBS_LEAD_IN_INVERT, 'b') + + if dLILen < GEO.EPS_SMALL then return end -- recupero la curva di offset su cui calcolare leadin local ptS = EgtSP( nCrv) @@ -304,10 +298,10 @@ local function AddRibsLeadIn( nCrv, nLoopsGrp, LayerParams) local dLen1 = EgtCurveLength( nCrvId) local dLen2 = EgtCurveLength( nNewId) - local bKeepFirst = LayerParams.bRibsLIInvert - if dLen1 > LayerParams.dRibsLILen - GEO.EPS_SMALL and dLen2 < LayerParams.dRibsLILen - GEO.EPS_SMALL then + local bKeepFirst = bLIInvert + if dLen1 > dLILen - GEO.EPS_SMALL and dLen2 < dLILen - GEO.EPS_SMALL then bKeepFirst = true - elseif dLen1 < LayerParams.dRibsLILen - GEO.EPS_SMALL and dLen2 > LayerParams.dRibsLILen - GEO.EPS_SMALL then + elseif dLen1 < dLILen - GEO.EPS_SMALL and dLen2 > dLILen - GEO.EPS_SMALL then bKeepFirst = false end @@ -320,7 +314,7 @@ local function AddRibsLeadIn( nCrv, nLoopsGrp, LayerParams) end end - EgtTrimCurveEndAtLen( nCrvId, LayerParams.dRibsLILen) + EgtTrimCurveEndAtLen( nCrvId, dLILen) EgtInvertCurve( nCrvId) EgtSetInfo( nCrvId, KEY_TYPE, TYPE.RIB) EgtSetName( nCrvId, LEAD_IN_CRV) @@ -332,11 +326,17 @@ local function AddRibsLeadIn( nCrv, nLoopsGrp, LayerParams) end -------------------------------------------------------------------- -local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams) +local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, vtSlicing) - if abs( LayerParams.dRibsLOLen) < GEO.EPS_SMALL and - abs( LayerParams.dRibsLOCoasting) < GEO.EPS_SMALL and - abs( LayerParams.dRibsLOWipe) < GEO.EPS_SMALL then return end + 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') + + if abs( dRibsLOLen) < GEO.EPS_SMALL and + abs( dRibsLOCoasting) < GEO.EPS_SMALL and + abs( dRibsLOWipe) < GEO.EPS_SMALL then return end local ptE = EgtEP( nCrv) -- recupero la curva di offset su cui calcolare lead out @@ -368,10 +368,10 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams) local nNewId = EgtSplitCurveAtParam( nCrvRef, dParE) or EgtCopyGlob( nCrvRef, nCrv, GDB_IN.AFTER) local dLen1 = EgtCurveLength( nCrvRef) local dLen2 = EgtCurveLength( nNewId) - bInvert = LayerParams.bRibsLOInvert - if dLen1 > LayerParams.dRibsLOLen + LayerParams.dRibsLOCoasting - GEO.EPS_SMALL and dLen2 < LayerParams.dRibsLOLen + LayerParams.dRibsLOCoasting - GEO.EPS_SMALL then + bInvert = bRibsLOInvert + if dLen1 > dRibsLOLen + dRibsLOCoasting - GEO.EPS_SMALL and dLen2 < dRibsLOLen + dRibsLOCoasting - GEO.EPS_SMALL then bInvert = true - elseif dLen1 < LayerParams.dRibsLOLen + LayerParams.dRibsLOCoasting - GEO.EPS_SMALL and dLen2 > LayerParams.dRibsLOLen + LayerParams.dRibsLOCoasting - GEO.EPS_SMALL then + elseif dLen1 < dRibsLOLen + dRibsLOCoasting - GEO.EPS_SMALL and dLen2 > dRibsLOLen + dRibsLOCoasting - GEO.EPS_SMALL then bInvert = false end @@ -386,13 +386,13 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams) -- verifico se la curva ha lunghezza sufficiente local dLen = EgtCurveLength( nCrvRef) - local bSkip = ( dLen - LayerParams.dRibsLOLen - LayerParams.dRibsLOCoasting < - GEO.EPS_SMALL) + local bSkip = ( dLen - dRibsLOLen - dRibsLOCoasting < - GEO.EPS_SMALL) local vtE = EgtSV( nCrvRef) -- primo tratto ( segue offset con flusso aperto) - if LayerParams.dRibsLOLen > GEO.EPS_SMALL and not bSkip then + if dRibsLOLen > GEO.EPS_SMALL and not bSkip then nCrvLO = EgtCopyGlob( nCrvRef, nCrv, GDB_IN.AFTER) - EgtTrimCurveEndAtLen( nCrvLO, LayerParams.dRibsLOLen) + EgtTrimCurveEndAtLen( nCrvLO, dRibsLOLen) EgtSetInfo( nCrvLO, KEY_TYPE, TYPE.RIB) EgtSetName( nCrvLO, LEAD_OUT_CRV) -- aggiorno ptE e vtE @@ -401,10 +401,10 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams) end -- secondo tratto ( segue offset con flusso chiuso) - if LayerParams.dRibsLOCoasting > GEO.EPS_SMALL and not bSkip then + if dRibsLOCoasting > GEO.EPS_SMALL and not bSkip then nCoasting = EgtCopyGlob( nCrvRef, nCrvLO or nCrv, GDB_IN.AFTER) - EgtTrimCurveStartAtLen( nCoasting, LayerParams.dRibsLOLen) - EgtTrimCurveEndAtLen( nCoasting, LayerParams.dRibsLOCoasting) + EgtTrimCurveStartAtLen( nCoasting, dRibsLOLen) + EgtTrimCurveEndAtLen( nCoasting, dRibsLOCoasting) EgtSetName( nCoasting, COASTING_CRV) EgtSetInfo( nCoasting, KEY_TYPE, TYPE.COASTING) @@ -417,10 +417,10 @@ local function AddRibsLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams) EgtErase( nCrvRef) -- terzo tratto ( diretto verso esterno con ugello chiuso) - if LayerParams.dRibsLOWipe > GEO.EPS_SMALL then - local dAng = EgtIf( bInvert, 90, - 90) + LayerParams.dRibsLOWipeAng - vtE:rotate( LayerParams.vtSlicing, dAng) - local ptFinal = ptE + vtE * LayerParams.dRibsLOWipe + if dRibsLOWipe > GEO.EPS_SMALL then + local dAng = EgtIf( bInvert, 90, - 90) + dRibsLOWipeAng + vtE:rotate( vtSlicing, dAng) + local ptFinal = ptE + vtE * dRibsLOWipe nWipe = EgtCurveCompoFromPoints( nTPathGrp, { ptE, ptFinal}) EgtRelocateGlob( nWipe, nCoasting or nCrvLO or nCrv, GDB_IN.AFTER) EgtSetName( nWipe, WIPE_CRV) @@ -453,19 +453,22 @@ local function CalcRibsToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ) EgtSetColor( nNewEntId, EgtStdColor('GRAY')) end - -- estraggo i contorni della superficie di offset + -- estraggo i contorni di tutte le superfici di offset local nLoopGrp = EgtGroup( nRibsGrp) local nSrfId = EgtGetFirstNameInGroup( nRibsGrp, LAYER_SRF) - local nChunksNbr = EgtSurfFrChunkCount( nSrfId) - for i = 0, nChunksNbr do - local nRes, nCnt = EgtExtractSurfFrChunkLoops( nSrfId, i, nLoopGrp) - if nRes then - for j = nRes, nRes + nCnt - 1 do - EgtMove( j, dCorrZ * Z_AX(), GDB_RT.GLOB) - -- mi sposto dell'altezza layer - EgtMove( j, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) + while nSrfId do + local nChunksNbr = EgtSurfFrChunkCount( nSrfId) + for i = 0, nChunksNbr do + local nRes, nCnt = EgtExtractSurfFrChunkLoops( nSrfId, i, nLoopGrp) + if nRes then + for j = nRes, nRes + nCnt - 1 do + EgtMove( j, dCorrZ * Z_AX(), GDB_RT.GLOB) + -- mi sposto dell'altezza layer + EgtMove( j, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) + end end end + nSrfId = EgtGetNextName( nSrfId, LAYER_SRF) end -- recupero i gruppi delle costolature @@ -479,21 +482,28 @@ local function CalcRibsToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ) end local bInters = EgtGetInfo( nRibsGrp, KEY_RIBS_INTERS, 'b') or false - local bSpecialCase = bInters and LayerParams.nRibsShellsNbr == 2 + local bAllTwoStrands = EgtGetInfo( nRibsGrp, KEY_RIBS_TWO_STRANDS, 'b') or false + local bSpecialCase = bInters and bAllTwoStrands local bSwap = false - -- orientamento delle curve - local bInvert = LayerParams.bRibsInvert + -- orientamento del primo gruppo di curve + local bInvert = EgtGetInfo( tabRibs[1][1], KEY_RIBS_INVERT_DIR, 'b') if not bSpecialCase then - for i = 1, #tabRibs do + for i = 1, #tabRibs do local nInfo = EgtGetInfo( tabRibs[i][1], KEY_SPLIT_RIB, 'i') + local nShellsNbr = EgtGetInfo( tabRibs[i][1], KEY_RIBS_SHELLS_NBR, 'i') -- aggiorno bInvert per il gruppo di costolature analizzato - if i > 1 and not nInfo then - if LayerParams.bRibsLink and LayerParams.nRibsShellsNbr % 2 == 1 then - bInvert = not bInvert + if not LayerParams.bRibsLink then + bInvert = EgtGetInfo( tabRibs[i][1], KEY_RIBS_INVERT_DIR, 'b') + else + if i > 1 and not nInfo then + local nPrevShellsNbr = EgtGetInfo( tabRibs[i-1][1], KEY_RIBS_SHELLS_NBR, 'i') + if nPrevShellsNbr % 2 == 1 then + bInvert = not bInvert + end end end - if LayerParams.nRibsShellsNbr == 1 and nInfo and bInvert then + if nShellsNbr == 1 and nInfo and bInvert then -- se inverto direzione di costolature divise allora devo invertirne anche l'ordine di realizzazione bSwap = true EgtRelocateGlob( tabRibs[i][1], tabRibs[i-1][1], GDB_IN.BEFORE) @@ -550,12 +560,12 @@ local function CalcRibsToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ) -- verifico se necessario lead in local nPrev = EgtGetPrev( nCrvRib) if not nPrev or EgtGetName( nPrev) then - AddRibsLeadIn( nCrvRib, nLoopGrp, LayerParams) + AddRibsLeadIn( nCrvRib, nLoopGrp) end -- verifico se necessario lead out local nNext = EgtGetNext( nCrvRib) if not nNext or EgtGetName( nNext) then - AddRibsLeadOut( nCrvRib, nTpathGrpId, nLoopGrp, LayerParams) + AddRibsLeadOut( nCrvRib, nTpathGrpId, nLoopGrp, LayerParams.vtSlicing) end nCrvRib = EgtGetNextName( nCrvRib, RIBS_CRV .. '*') end