diff --git a/LuaLibs/AddManData.lua b/LuaLibs/AddManData.lua index 74eef84..0d9df5a 100644 --- a/LuaLibs/AddManData.lua +++ b/LuaLibs/AddManData.lua @@ -21,6 +21,8 @@ SHELL_CRV = "Shell" INFILL_CRV = "Infill" COASTING_CRV = "Coasting" WIPE_CRV = "Wipe" +LEAD_IN_CRV = "LeadIn" +LEAD_OUT_CRV = "LeadOut" FRAME_PART = "FramePart" START_POINT = "StartPoint" @@ -68,7 +70,8 @@ KEY_TOOL_DIAM = "ToolDiam" KEY_SETTI_OVERLAP = "SettiOverlap" KEY_SETTI_SHELLS_NBR = "SettiStrandCount" KEY_SETTI_LINK = "SettiLink" -KEY_SETTI_INVERT = "SettiInvert" +KEY_SETTI_INVERT_DIR = "SettiInvertDirection" +KEY_SETTI_INVERT_ORDER = "SettiInvertOrder" KEY_SETTI_LEAD_IN_INVERT = "SettiLeadInInvert" KEY_SETTI_LEAD_IN_LEN = "SettiLeadInLen" KEY_SETTI_LEAD_OUT_INVERT = "SettiLeadOutInvert" diff --git a/LuaLibs/CalcPaths.lua b/LuaLibs/CalcPaths.lua index a9e953d..3bfa644 100644 --- a/LuaLibs/CalcPaths.lua +++ b/LuaLibs/CalcPaths.lua @@ -26,6 +26,7 @@ local function GetLayerParamsForPathCalc() -- parametri setti LayerParams.dSettiOverlap = EgtGetInfo( s_nPartId, KEY_SETTI_OVERLAP, 'd') LayerParams.nSettiShellsNbr = EgtGetInfo( s_nPartId, KEY_SETTI_SHELLS_NBR, 'i') + LayerParams.bSettiInvertOrder = EgtGetInfo( s_nPartId, KEY_SETTI_INVERT_ORDER, 'b') return LayerParams end @@ -97,66 +98,61 @@ local function AddFloor( nSrfId, nGrpId, LayerParams, nFloorNbr) -- end -- EgtErase( nSrfCopy) -- end - end -------------------------------------------------------------------- -local function ReorderSetti( nGrp, vtSlicing, nStmId) +local function ReorderSetti( nGrp, bInvertOrder) - -- box del pezzo - local nSlicePart = EgtGetParent( nGrp) - local frLoc = Frame3d( ORIG(), vtSlicing) - local b3Box = EgtGetBBoxRef( nSlicePart, GDB_BB.STANDARD, frLoc) - local ptMin = b3Box:getMin() - local ptMax = b3Box:getMax() - ptMin:toGlob( frLoc) - ptMax:toGlob( frLoc) - - EgtSpInit() + EgtSpInit() local vIds = EgtGetNameInGroup( nGrp, SETTI_CRV .. '*') for i = 1, #vIds do local pt = EgtMP( vIds[i], GDB_RT.GLOB) - EgtSpAddPoint( pt:getX(), pt:getY()) + EgtSpAddPoint( pt:getX(), pt:getY(), pt:getZ(), 0, 0, pt:getX(), pt:getY(), pt:getZ(), 0, 0) end - EgtSpSetOpenBound( true, SHP_OB.NEAR_PNT, min( ptMin:getX(), ptMax:getX()), min( ptMin:getY(), ptMax:getY())) local vOrd, dLen = EgtSpCalculate( SHP_TY.OPEN) EgtSpTerminate() local vOrderedSetti = {} - for i = 1, #vOrd do - table.insert( vOrderedSetti, vIds[vOrd[i]]) + if bInvertOrder then + for i = #vOrd, 1, -1 do + table.insert( vOrderedSetti, vIds[vOrd[i]]) + end + else + for i = 1, #vOrd do + table.insert( vOrderedSetti, vIds[vOrd[i]]) + end end - + return vOrderedSetti end -------------------------------------------------------------------- local function CalcSettiPaths( nSliceGrp, nSettiGrp, LayerParams, nStmId) - - -- riordino i setti - local vOrderedSetti = ReorderSetti( nSettiGrp, LayerParams.vtSlicing, nStmId) - -- calcolo gli offset + + -- calcolo gli offset local dOffs = ( LayerParams.nSettiShellsNbr - 1) * LayerParams.dStrand / 2 local nOffsGrp = EgtGroup( nSettiGrp) - for i = 1, #vOrderedSetti do + local vSetti = EgtGetNameInGroup( nSettiGrp, SETTI_CRV .. '*') + for i = 1, #vSetti do for k = 0, LayerParams.nSettiShellsNbr - 1 do - local nNewId = EgtOffsetCurveAdv( vOrderedSetti[i], - dOffs + k * LayerParams.dStrand) - EgtSetName( nNewId, EgtGetName( vOrderedSetti[i])) + local nNewId = EgtOffsetCurveAdv( vSetti[i], - dOffs + k * LayerParams.dStrand) + EgtSetName( nNewId, EgtGetName( vSetti[i])) EgtSetInfo( nNewId, KEY_TYPE, TYPE.SETTO) EgtRelocateGlob( nNewId, nOffsGrp) end - end - + end + + -- riordino setti + local vOrderedSetti = ReorderSetti( nOffsGrp, LayerParams.bSettiInvertOrder) -- scorro i gruppi di curve - local vSetti = EgtGetAllInGroup( nOffsGrp) local nCrvGrp = EgtGetFirstNameInGroup( nSliceGrp, CONTOUR_GRP .. '*') while nCrvGrp do local nSettiPathGrp = EgtGetFirstNameInGroup( nCrvGrp, SETTI_GRP) local nSrf = EgtGetFirstNameInGroup( nSettiPathGrp, LAYER_SRF) if nSrf then - for i = 1, #vSetti do - local nNewId = EgtCopyGlob( vSetti[i], nSettiPathGrp) + for i = 1, #vOrderedSetti do + local nNewId = EgtCopyGlob( vOrderedSetti[i], nSettiPathGrp) -- trim dei setti con la regione offsettata local nCrv, nCnt = EgtTrimCurveWithRegion( nNewId, nSrf, true, false) -- elimino tratti troppo corti @@ -165,7 +161,7 @@ local function CalcSettiPaths( nSliceGrp, nSettiGrp, LayerParams, nStmId) if dLen < MIN_LEN then EgtErase( nId) end - end + end end end diff --git a/LuaLibs/CalcSlices.lua b/LuaLibs/CalcSlices.lua index 376e502..0dc9611 100644 --- a/LuaLibs/CalcSlices.lua +++ b/LuaLibs/CalcSlices.lua @@ -56,6 +56,8 @@ end -------------------------------------------------------------------- local function SlicingSetti( vtSlicing, dZmin) + local nSettiShells = EgtGetInfo( s_nPartId, KEY_SETTI_SHELLS_NBR, 'i') or 0 + if nSettiShells == 0 then return end -- recupero le superfici che definiscono i setti local nWallsLay = EgtGetFirstNameInGroup( s_nPartId, LAY_WALLS) local vSettiIds = EgtGetAllInGroup( nWallsLay or GDB_ID.NULL) diff --git a/LuaLibs/CalcToolPath.lua b/LuaLibs/CalcToolPath.lua index 5d75d80..b932be4 100644 --- a/LuaLibs/CalcToolPath.lua +++ b/LuaLibs/CalcToolPath.lua @@ -40,7 +40,7 @@ local function GetLayerParamsForToolPathCalc() -- Parametri setti LayerParams.nSettiShellsNbr = EgtGetInfo( s_nPartId, KEY_SETTI_SHELLS_NBR, 'i') LayerParams.bSettiLink = EgtGetInfo( s_nPartId, KEY_SETTI_LINK, 'b') - LayerParams.bSettiInvert = EgtGetInfo( s_nPartId, KEY_SETTI_INVERT, 'b') + LayerParams.bSettiInvert = EgtGetInfo( s_nPartId, KEY_SETTI_INVERT_DIR, 'b') LayerParams.bSettiLIInvert = EgtGetInfo( s_nPartId, KEY_SETTI_LEAD_IN_INVERT, 'b') LayerParams.dSettiLILen = EgtGetInfo( s_nPartId, KEY_SETTI_LEAD_IN_LEN, 'd') LayerParams.bSettiLOInvert = EgtGetInfo( s_nPartId, KEY_SETTI_LEAD_OUT_INVERT, 'b') @@ -87,6 +87,7 @@ local function AddLeadIn( nCrvId, LayerParams, nGrpId) EgtRelocate( nLeadInCrv, nGrpId, GDB_IN.FIRST_SON) EgtModifyCurveExtrusion( nLeadInCrv, LayerParams.vtSlicing, GDB_RT.GLOB) EgtSetInfo( nLeadInCrv, KEY_TYPE, TYPE.LINK) + EgtSetName( nLeadInCrv, LEAD_IN_CRV) end -------------------------------------------------------------------- @@ -113,6 +114,7 @@ local function AddLeadOut( nCrvId, LayerParams, nGrpId) EgtRelocate( nLeadOutCrv, nGrpId, GDB_IN.LAST_SON) EgtModifyCurveExtrusion( nLeadOutCrv, LayerParams.vtSlicing, GDB_RT.GLOB) EgtSetInfo( nLeadOutCrv, KEY_TYPE, TYPE.LINK) + EgtSetName( nLeadOutCrv, LEAD_OUT_CRV) end -------------------------------------------------------------------- @@ -175,111 +177,195 @@ end local function CalcSettiLink( ptS, ptE, nCurr, nLoopGrp) local nCrvId = EgtGetFirstInGroup( nLoopGrp) - - local dParS = EgtCurveParamAtPoint( nCrvId, ptS) - local dParE = EgtCurveParamAtPoint( nCrvId, ptE) + -- recupero la curva di offset su cui calcolare link + while nCrvId do + local dParS = EgtCurveParamAtPoint( nCrvId, ptS) + local dParE = EgtCurveParamAtPoint( nCrvId, ptE) + if dParS and dParE then + local bInvert = false + local bClosed = EgtCurveIsClosed( nCrvId) + if bClosed then + -- se la curva è chiusa 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 dLen1 = EgtCurveLength( nCopyId1) + local dLen2 = EgtCurveLength( nCopyId2) + if dLen1 > dLen2 then + bInvert = true + dParS, dParE = dParE, dParS + end + EgtErase( nCopyId1) + EgtErase( nCopyId2) + end + + local nCopyId = EgtCopyGlob( nCrvId, nLoopGrp) + local nLinkId = EgtCopyGlob( nCrvId, nCurr, GDB_IN.AFTER) + + if dParS > dParE and not bInvert then + bInvert = true + dParS, dParE = dParE, dParS + end + + EgtTrimCurveStartEndAtParam( nLinkId, dParS, dParE) + EgtSetInfo( nLinkId, KEY_TYPE, TYPE.SETTO) + if bInvert then EgtInvertCurve( nLinkId) end + + if bClosed then + EgtTrimCurveStartEndAtParam( nCrvId, dParE, dParS) + EgtErase( nCopyId) + else + EgtTrimCurveEndAtParam( nCrvId, dParS) + EgtTrimCurveStartAtParam( nCopyId, dParE) + end - if dParS and dParE then - -- verifico i due percorsi ( 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 dLen1 = EgtCurveLength( nCopyId1) - local dLen2 = EgtCurveLength( nCopyId2) - if dLen1 < dLen2 then - EgtErase( nCopyId2) - EgtSetInfo( nCopyId1, KEY_TYPE, TYPE.SETTO) - else - EgtErase( nCopyId1) - EgtSetInfo( nCopyId2, KEY_TYPE, TYPE.SETTO) + return nLinkId end + + nCrvId = EgtGetNext( nCrvId) end - end -------------------------------------------------------------------- -local function AddSettiLeadIn( nCrv, nLoopsGrp, dLeadInLen, bInvert) +local function AddSettiLeadIn( nCrv, nLoopsGrp, LayerParams) - if dLeadInLen < GEO.EPS_SMALL then return end - -- recupero la curva di offset + if LayerParams.dSettiLILen < GEO.EPS_SMALL then return end + + -- recupero la curva di offset su cui calcolare leadin + local ptS = EgtSP( nCrv) local nCrvOffs = EgtGetFirstInGroup( nLoopsGrp) - - local ptS = EgtSP( nCrv) - local dParS = EgtCurveParamAtPoint( nCrvOffs, ptS) - if not dParS then return end - - local nCopyOffs = EgtCopyGlob( nCrvOffs, nCrv, GDB_IN.BEFORE) - EgtChangeClosedCurveStartPoint( nCopyOffs, ptS) - if bInvert then - EgtInvertCurve( nCopyOffs) - end - EgtTrimCurveEndAtLen( nCopyOffs, dLeadInLen) - EgtInvertCurve( nCopyOffs) - EgtSetInfo( nCopyOffs, KEY_TYPE, TYPE.SETTO) - + while nCrvOffs do + local dParS = EgtCurveParamAtPoint( nCrvOffs, ptS) + if dParS then + local nCrvId = EgtCopyGlob( nCrvOffs, nCrv, GDB_IN.BEFORE) + local bClosed = EgtCurveIsClosed( nCrvId) + if bClosed then + EgtChangeClosedCurveStart( nCrvId, dParS) + dParS = 0 + end + + -- scelgo il lato da cui fare ingresso + local _, dEndPar = EgtCurveDomain( nCrvId) + -- se ho solo un tratto possibile verifico se va invertito + if abs( dParS - dEndPar) < GEO.EPS_SMALL then + EgtInvertCurve( nCrvId) + elseif abs( dParS) > GEO.EPS_SMALL or bClosed then + -- se ho più tratti possibili scelgo in base al parametro SettiLIInvert + local nNewId = EgtSplitCurveAtParam( nCrvId, dParS) or EgtCopyGlob( nCrvId, nCrv, GDB_IN.BEFORE) + if LayerParams.bSettiLIInvert then + EgtInvertCurve( nCrvId) + EgtErase( nNewId) + else + EgtErase( nCrvId) + nCrvId = nNewId + end + end + + EgtTrimCurveEndAtLen( nCrvId, LayerParams.dSettiLILen) + EgtInvertCurve( nCrvId) + EgtSetInfo( nCrvId, KEY_TYPE, TYPE.SETTO) + EgtSetName( nCrvId, LEAD_IN_CRV) + return + end + + nCrvOffs = EgtGetNext( nCrvOffs) + end end -------------------------------------------------------------------- -local function AddSettiLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams, bInvert) +local function AddSettiLeadOut( nCrv, nTPathGrp, nLoopsGrp, LayerParams) + + if abs( LayerParams.dSettiLOLen) < GEO.EPS_SMALL and + abs( LayerParams.dSettiLOWipeTang) < GEO.EPS_SMALL and + abs( LayerParams.dSettiLOWipe) < GEO.EPS_SMALL then return end - -- recupero la curva di offset - local nCrvOffs = EgtGetFirstInGroup( nLoopsGrp) local ptE = EgtEP( nCrv) - local dParE = EgtCurveParamAtPoint( nCrvOffs, ptE) - if not dParE then return end - local vtE = EgtUV( nCrvOffs, dParE, 1) - if bInvert then vtE = - vtE end - local nCrvLO - local nWipe + -- recupero la curva di offset su cui calcolare lead out + local nCrvOffs = EgtGetFirstInGroup( nLoopsGrp) + while nCrvOffs do + local dParE = EgtCurveParamAtPoint( nCrvOffs, ptE) + if dParE then + + local nCrvLO + local nWipe + local bInvert = false + + local nCrvRef = EgtCopyGlob( nCrvOffs, nCrv, GDB_IN.AFTER) + local bClosed = EgtCurveIsClosed( nCrvRef) + if bClosed then + EgtChangeClosedCurveStart( nCrvRef, dParE) + dParE = 0 + end + + -- scelgo il lato da cui fare uscita + local _, dEndPar = EgtCurveDomain( nCrvRef) + -- se ho solo un tratto possibile verifico se va invertito + if abs( dParE - dEndPar) < GEO.EPS_SMALL then + EgtInvertCurve( nCrvRef) + bInvert = true + elseif abs( dParE) > GEO.EPS_SMALL or bClosed then + -- se ho più tratti possibili scelgo in base al parametro SettiLOInvert + bInvert = LayerParams.bSettiLOInvert + local nNewId = EgtSplitCurveAtParam( nCrvRef, dParE) or EgtCopyGlob( nCrvRef, nCrv, GDB_IN.AFTER) + if bInvert then + EgtInvertCurve( nCrvRef) + EgtErase( nNewId) + else + EgtErase( nCrvRef) + nCrvRef = nNewId + end + end + + local vtE = EgtSV( nCrvRef) - -- primo tratto ( segue offset con flusso aperto) - if LayerParams.dSettiLOLen > GEO.EPS_SMALL then - nCrvLO = EgtCopyGlob( nCrvOffs, nCrv, GDB_IN.AFTER) - EgtChangeClosedCurveStartPoint( nCrvLO, ptE) - if bInvert then - EgtInvertCurve( nCrvLO) + -- primo tratto ( segue offset con flusso aperto) + if LayerParams.dSettiLOLen > GEO.EPS_SMALL then + nCrvLO = EgtCopyGlob( nCrvRef, nCrv, GDB_IN.AFTER) + EgtTrimCurveEndAtLen( nCrvLO, LayerParams.dSettiLOLen) + EgtSetInfo( nCrvLO, KEY_TYPE, TYPE.SETTO) + EgtSetName( nCrvLO, LEAD_OUT_CRV) + -- aggiorno ptE e vtE + ptE = EgtEP( nCrvLO) + vtE = EgtEV( nCrvLO) + end + + -- secondo tratto ( segue offset con flusso chiuso) + if LayerParams.dSettiLOWipeTang > GEO.EPS_SMALL then + nWipe = EgtCopyGlob( nCrvRef, nCrvLO or nCrv, GDB_IN.AFTER) + EgtTrimCurveStartAtLen( nWipe, LayerParams.dSettiLOLen) + EgtTrimCurveEndAtLen( nWipe, LayerParams.dSettiLOWipeTang) + -- aggiorno ptE e vtE + ptE = EgtEP( nWipe) + vtE = EgtEV( nWipe) + end + EgtErase( nCrvRef) + + -- terzo tratto ( diretto verso esterno con ugello chiuso) + if LayerParams.dSettiLOWipe > GEO.EPS_SMALL then + local dAng = EgtIf( bInvert, 90, - 90) + LayerParams.dSettiLOWipeAng + vtE:rotate( LayerParams.vtSlicing, dAng) + local ptFinal = ptE + vtE * LayerParams.dSettiLOWipe + if nWipe then + -- unisco al secondo tratto così da averne uno solo per il wiping + EgtAddCurveCompoLine( nWipe, ptFinal) + else + nWipe = EgtCurveCompoFromPoints( nTPathGrp, { ptE, ptFinal}) + EgtRelocateGlob( nWipe, nCrvLO or nCrv, GDB_IN.AFTER) + end + end + + if nWipe then + EgtSetName( nWipe, WIPE_CRV) + EgtSetInfo( nWipe, KEY_TYPE, TYPE.WIPE) + EgtSetColor( nWipe, EgtStdColor('TEAL')) + end + return end - EgtTrimCurveEndAtLen( nCrvLO, LayerParams.dSettiLOLen) - EgtSetInfo( nCrvLO, KEY_TYPE, TYPE.SETTO) - -- aggiorno ptE e vtE - ptE = EgtEP( nCrvLO) - vtE = EgtEV( nCrvLO) - end - - -- secondo tratto ( segue offset con flusso chiuso) - if LayerParams.dSettiLOWipeTang > GEO.EPS_SMALL then - nWipe = EgtCopyGlob( nCrvOffs, nCrvLO or nCrv, GDB_IN.AFTER) - EgtChangeClosedCurveStartPoint( nWipe, ptE) - if bInvert then - EgtInvertCurve( nWipe) - end - EgtTrimCurveEndAtLen( nWipe, LayerParams.dSettiLOWipeTang) - -- aggiorno ptE e vtE - ptE = EgtEP( nWipe) - vtE = EgtEV( nWipe) - end - - -- terzo tratto ( diretto verso esterno con ugello chiuso) - if LayerParams.dSettiLOWipe > GEO.EPS_SMALL then - local dAng = EgtIf( bInvert, 90, - 90) + LayerParams.dSettiLOWipeAng - vtE:rotate( LayerParams.vtSlicing, dAng) - local ptFinal = ptE + vtE * LayerParams.dSettiLOWipe - if nWipe then - -- unisco al secondo tratto così da averne uno solo per il wiping - EgtAddCurveCompoLine( nWipe, ptFinal) - else - nWipe = EgtCurveCompoFromPoints( nTPathGrp, { ptE, ptFinal}) - EgtRelocateGlob( nWipe, nCrvLO or nCrv, GDB_IN.AFTER) - end - end - - if nWipe then - EgtSetName( nWipe, WIPE_CRV) - EgtSetInfo( nWipe, KEY_TYPE, TYPE.WIPE) - EgtSetColor( nWipe, EgtStdColor('TEAL')) + + nCrvOffs = EgtGetNext( nCrvOffs) end end @@ -298,89 +384,86 @@ local function CalcSettiToolPath( nCrvGrp, nTpathGrpId, LayerParams, dCorrZ) -- mi sposto dell'altezza layer EgtMove( nNewEntId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB) EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB) - EgtSetColor( nNewEntId, EgtStdColor('GRAY')) - end + EgtSetColor( nNewEntId, EgtStdColor('GRAY')) + end - -- estraggo i contorni delle superfici di offset + -- estraggo i contorni della superficie di offset local nLoopGrp = EgtGroup( nSettiGrp) local nSrfId = EgtGetFirstNameInGroup( nSettiGrp, LAYER_SRF) local nChunksNbr = EgtSurfFrChunkCount( nSrfId) for i = 0, nChunksNbr do local nRes, nCnt = EgtExtractSurfFrChunkLoops( nSrfId, i, nLoopGrp) - if nRes then + 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 - - -- orientamento delle curve - local nInd = EgtGetFirstNameInGroup( nTpathGrpId, SETTI_CRV .. '*') - local bInvert = LayerParams.bSettiInvert - while nInd do - local sName = EgtGetName( nInd) - -- considero tutte le passate relative al setto corrente - local vIds = EgtGetNameInGroup( nTpathGrpId, sName) - for i = 1, #vIds do - if ( bInvert and i % 2 == 1) or ( not bInvert and i % 2 == 0) then - EgtInvertCurve( vIds[i]) end end - -- passo al gruppo di setti successivo - nInd = EgtGetNextName( vIds[#vIds], SETTI_CRV .. '*') - -- aggiorno bInvert per il gruppo successivo + end + + -- recupero i gruppi di setti + local tabSetti = {} + local nFirst = EgtGetFirstNameInGroup( nTpathGrpId, SETTI_CRV .. '*') + while nFirst do + local sName = EgtGetName( nFirst) + local vIds = EgtGetNameInGroup( nTpathGrpId, sName) + table.insert( tabSetti, vIds) + nFirst = EgtGetNextName( vIds[#vIds], SETTI_CRV .. '*') + end + + -- orientamento delle curve + local bInvert = LayerParams.bSettiInvert + for i = 1, #tabSetti do + -- oriento tutte le passate relative ad uno stesso setto + for j = 1, #tabSetti[i] do + if ( bInvert and j % 2 == 1) or ( not bInvert and j % 2 == 0) then + EgtInvertCurve( tabSetti[i][j]) + end + end + -- aggiorno bInvert per il gruppo di setti successivo if LayerParams.bSettiLink and LayerParams.nSettiShellsNbr % 2 == 1 then bInvert = not bInvert end - end - - -- collegamenti - local vSettiIds = EgtGetNameInGroup( nTpathGrpId, SETTI_CRV .. '*') - for i = 1, #vSettiIds - 1 do - local sNameCurr = EgtGetName( vSettiIds[i]) - local sNameNext = EgtGetName( vSettiIds[i + 1]) - - local ptS = EgtEP( vSettiIds[i]) - local ptE = EgtSP( vSettiIds[i + 1]) - if LayerParams.bSettiLink then - CalcSettiLink( ptS, ptE, vSettiIds[i], nLoopGrp) - else - -- collego solo le passate dello stesso setto - if sNameCurr == sNameNext then - CalcSettiLink( ptS, ptE, vSettiIds[i], nLoopGrp) - end - end - end - - -- leadin/leadout - local bInvertLI = EgtIf( LayerParams.nSettiShellsNbr == 1, LayerParams.bSettiLIInvert, not LayerParams.bSettiInvert) - local bInvertLO = LayerParams.bSettiLOInvert - - if LayerParams.bSettiLink then - -- aggiungo ingresso e uscita solo sul primo e sull'ultimo setto - local nFirst = EgtGetFirstNameInGroup( nTpathGrpId, SETTI_CRV .. '*') - if nFirst then AddSettiLeadIn( nFirst, nLoopGrp, LayerParams.dSettiLILen, bInvertLI) end - local nLast = EgtGetLastNameInGroup( nTpathGrpId, SETTI_CRV .. '*') - if LayerParams.nSettiShellsNbr > 1 then - bInvertLO = EgtIf( #vEntIds % 2 == 0, not bInvertLI, bInvertLI) - end - if nLast then AddSettiLeadOut( nLast, nTpathGrpId, nLoopGrp, LayerParams, bInvertLO) end - else - local nFirst = EgtGetFirstNameInGroup( nTpathGrpId, SETTI_CRV .. '*') - while nFirst do - local sName = EgtGetName( nFirst) - local vEnt = EgtGetNameInGroup( nTpathGrpId, sName) - AddSettiLeadIn( nFirst, nLoopGrp, LayerParams.dSettiLILen, bInvertLI) - if LayerParams.nSettiShellsNbr > 1 then - bInvertLO = EgtIf( #vEnt % 2 == 0, not bInvertLI, bInvertLI) - end - AddSettiLeadOut( vEnt[#vEnt], nTpathGrpId, nLoopGrp, LayerParams, bInvertLO) - nFirst = EgtGetNextName( vEnt[#vEnt], SETTI_CRV .. '*') + end + + -- Link + -- collego le passate di uno stesso setto + for i = 1, #tabSetti do + for j = 1, #tabSetti[i] - 1 do + local ptS = EgtEP( tabSetti[i][j]) + local ptE = EgtSP( tabSetti[i][j + 1]) + CalcSettiLink( ptS, ptE, tabSetti[i][j], nLoopGrp) + -- creo link fittizio per eliminare tratto corrispondente sulla curva di offset + local nFakeLink = CalcSettiLink( EgtSP( tabSetti[i][j]), EgtEP(tabSetti[i][j + 1]), tabSetti[i][j], nLoopGrp) + EgtErase( nFakeLink) end end - + -- se necessario collego i diversi setti + if LayerParams.bSettiLink then + for i = 1, #tabSetti - 1 do + local nCnt = #tabSetti[i] + local ptS = EgtEP( tabSetti[i][nCnt]) + local ptE = EgtSP( tabSetti[i + 1][1]) + CalcSettiLink( ptS, ptE, tabSetti[i][nCnt], nLoopGrp) + end + end + + -- leadin/leadout + local nCrvSetto = EgtGetFirstNameInGroup( nTpathGrpId, SETTI_CRV .. '*') + while nCrvSetto do + -- verifico se necessario lead in + local nPrev = EgtGetPrev( nCrvSetto) + if not nPrev or EgtGetName( nPrev) then + AddSettiLeadIn( nCrvSetto, nLoopGrp, LayerParams) + end + -- verifico se necessario lead out + local nNext = EgtGetNext( nCrvSetto) + if not nNext or EgtGetName( nNext) then + AddSettiLeadOut( nCrvSetto, nTpathGrpId, nLoopGrp, LayerParams) + end + nCrvSetto = EgtGetNextName( nCrvSetto, SETTI_CRV .. '*') + end end --------------------------------------------------------------------- @@ -398,7 +481,7 @@ function CalcToolPath.Exec( nPartId) local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER.."*") if not vLayIds then EgtOutBox( 'Error missing slices', 'ToolPathCalc') - return + return end -- recupero i parametri per calcolo dei toolpath diff --git a/LuaLibs/RunSlicing.lua b/LuaLibs/RunSlicing.lua index f340acd..5da3d8a 100644 --- a/LuaLibs/RunSlicing.lua +++ b/LuaLibs/RunSlicing.lua @@ -116,8 +116,9 @@ local function LoadParams( sFile, nPartId) -- parametri per setti SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_OVERLAP, '0.0') SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_SHELLS_NBR, '0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_INVERT, '0') - SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_LINK, '0') + SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_INVERT_DIR, '0') + SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_INVERT_ORDER, '0') + SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_LINK, '0') SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_LEAD_IN_INVERT, '0') SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_LEAD_IN_LEN, '0.0') SetParamInfo( sFile, nPartId, SEC_DEFAULT, KEY_SETTI_LEAD_OUT_INVERT, '0')