3dPrinting :

- nel caso spiral vase corretta la gestione dei punti iniziali delle curve.

.gitlab-ci.yml

@@ -16,14 +16,14 @@ variables:
     $FileList = Get-ChildItem("*.lua")
     ForEach ($File in $FileList) {
       $FileName = Split-Path $File -leaf
-      lua54 -o bin\$FileName $FileName
-      echo "lua54 -o bin\$FileName $FileName"
+      lua54 -o bin\$FileName -s $FileName
+      echo "lua54 -o bin\$FileName -s $FileName"
     }
     $FileList = Get-ChildItem("LuaLibs\*.lua")
     ForEach ($File in $FileList) {
       $FileName = Split-Path $File -leaf
-      lua54 -o bin\LuaLibs\$FileName LuaLibs\$FileName
-      echo "lua54 -o bin\LuaLibs\$FileName LuaLibs\$FileName"
+      lua54 -o bin\LuaLibs\$FileName -s LuaLibs\$FileName
+      echo "lua54 -o bin\LuaLibs\$FileName -s LuaLibs\$FileName"
     }
 
 # helper copia SORGENTI verso cartella di rete R:\ dei SORGENTI

Compile.bat

@@ -1,21 +1,21 @@
 
-REM Compilazione degli script 3dPrinting Egaltech                         2023.01.11
+REM Compilazione degli script 3dPrinting Egaltech                         2024.03.27
 REM Per togliere info di debug aggiungere flag -s prima del nome del file di input
 
 REM Compilazione 32 e 64 bit
 
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\AddManData.lua                    LuaLibs\AddManData.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcPaths.lua                     LuaLibs\CalcPaths.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcSlices.lua                    LuaLibs\CalcSlices.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcToolPath.lua                  LuaLibs\CalcToolPath.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunCalcSolids.lua                 LuaLibs\RunCalcSolids.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunGcodeGenerate.lua              LuaLibs\RunGcodeGenerate.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunMachParamFromSWCalc.lua        LuaLibs\RunMachParamFromSWCalc.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunPrepareExport.lua              LuaLibs\RunPrepareExport.lua
-\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunSlicing.lua                    LuaLibs\RunSlicing.lua
-\EgtProg\Dll32\luac54 -o bin\CalcMachParamFromSW.lua                   CalcMachParamFromSW.lua
-\EgtProg\Dll32\luac54 -o bin\CalcSolids.lua                            CalcSolids.lua
-\EgtProg\Dll32\luac54 -o bin\GcodeGenerate.lua                         GcodeGenerate.lua
-\EgtProg\Dll32\luac54 -o bin\PrepareExport.lua                         PrepareExport.lua
-\EgtProg\Dll32\luac54 -o bin\Slicing.lua                               Slicing.lua
-\EgtProg\Dll32\luac54 -o bin\Version.lua                               Version.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\AddManData.lua                  -s LuaLibs\AddManData.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcPaths.lua                   -s LuaLibs\CalcPaths.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcSlices.lua                  -s LuaLibs\CalcSlices.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\CalcToolPath.lua                -s LuaLibs\CalcToolPath.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunCalcSolids.lua               -s LuaLibs\RunCalcSolids.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunGcodeGenerate.lua            -s LuaLibs\RunGcodeGenerate.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunMachParamFromSWCalc.lua      -s LuaLibs\RunMachParamFromSWCalc.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunPrepareExport.lua            -s LuaLibs\RunPrepareExport.lua
+\EgtProg\Dll32\luac54 -o bin\LuaLibs\RunSlicing.lua                  -s LuaLibs\RunSlicing.lua
+\EgtProg\Dll32\luac54 -o bin\CalcMachParamFromSW.lua                 -s CalcMachParamFromSW.lua
+\EgtProg\Dll32\luac54 -o bin\CalcSolids.lua                          -s CalcSolids.lua
+\EgtProg\Dll32\luac54 -o bin\GcodeGenerate.lua                       -s GcodeGenerate.lua
+\EgtProg\Dll32\luac54 -o bin\PrepareExport.lua                       -s PrepareExport.lua
+\EgtProg\Dll32\luac54 -o bin\Slicing.lua                             -s Slicing.lua
+\EgtProg\Dll32\luac54 -o bin\Version.lua                             -s Version.lua

LuaLibs/AddManData.lua

@@ -140,6 +140,8 @@ KEY_RIBS_USER_LINK_TOT = "RibsUserLinkParts"
 KEY_RIBS_INVERT_STRAND_ORDER = "RibsInvertStrandOrder"
 KEY_RIBS_MERGE_WITH_SHELLS = "RibsMergeWithShell"
 KEY_INVERT_RIBS_MERGED_SHELL_LINK = "InvertRibsMergedShellMainLink"
+KEY_RIBS_LEAD_FILLET = "RibsLeadFillet"
+KEY_RIBS_LINK_FILLET = "RibsLinkFillet"
 
 -- Regioni con diverso numero di passate
 KEY_SHELL_NBR_DIFF = "ShellNbrDifference"
@@ -204,6 +206,7 @@ KEY_CRV_STRAND = "CurveStrand"
 KEY_LAYER_CNT = "LayerCnt"
 KEY_CRV_OFFSET = "CurveOffset"
 KEY_ORIG_REF = "Orig"
+KEY_WIPE_ON_CRV = "WipeOnCrv"
 
 SLICING_TYPE = {
    VERTICAL = 1,

LuaLibs/CalcPaths.lua

@@ -14,7 +14,7 @@ local AMD = require( 'AddManData')
 
 ---------------------------------------------------------------------
 local s_nPartId
-local s_dOffsCorr = 50 * GEO.EPS_SMALL
+local s_dOffsCorr = 20 * GEO.EPS_SMALL
 local s_vErr = {}
 local s_nCurrIdx
 local s_vtSlicing
@@ -85,30 +85,22 @@ end
 ----------------------------------------------------------------------
 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
+
+   local nOffsSrf = EgtSurfFrOffsetAdv( nSrf, dOffs)
+   if not nOffsSrf then
       -- ritento modificando leggermente l'offset
-      EgtErase( nOffsSrf)
-      nOffsSrf = EgtCopyGlob( nSrf, nGrpId) or GDB_ID.NULL
-      bOk = EgtSurfFrOffset( nOffsSrf, dOffs + 0.05)
+      nOffsSrf = EgtSurfFrOffsetAdv( nSrf, dOffs + 0.05)
    end
+   -- sposto nel gruppo desiderato
+   EgtRelocateGlob( nOffsSrf or GDB_ID.NULL, nGrpId)
    
-   if not bOk then
-      EgtErase( nOffsSrf)
-      return nil
-   elseif EgtSurfFrChunkCount( nOffsSrf) == 0 then
-      return GDB_ID.NULL
-   else
-      return nOffsSrf
-   end
+   return nOffsSrf
 end
 
 --------------------------------------------------------------------
 local function ComputeTrimSurf( nSrf, nGrpId, dStrand, dOverlap)
    
-   local nTrimSurf = ComputeSurfOffset( nSrf, nGrpId, - dStrand * ( 0.5 - dOverlap / 100) + s_dOffsCorr)
+   local nTrimSurf = ComputeSurfOffset( nSrf, nGrpId, - dStrand * ( 0.5 - dOverlap / 100) + 2 * s_dOffsCorr)
    local bNoOverlap = false
    if not nTrimSurf and dOverlap > GEO.EPS_SMALL then
       -- tento senza overlap
@@ -192,6 +184,7 @@ local function GetPathsFromSurf( nSrfId, sName, nType, nGrpId, vPtStart)
       for nInd = 0, nCrvCnt - 1 do
          EgtSetName( nCrvId + nInd, sName)
          EgtSetInfo( nCrvId + nInd, KEY_TYPE, nType)
+         EgtModifyCurveExtrusion( nCrvId + nInd, s_vtSlicing, GDB_ID.ROOT)
          
          -- se è loop interno lo inverto per averlo orientato in senso antiorario 
          if nInd > 0 then
@@ -204,15 +197,14 @@ local function GetPathsFromSurf( nSrfId, sName, nType, nGrpId, vPtStart)
          local _ , _ , dArea = EgtCurveArea( nCrvId + nInd)
          if dLen < MIN_LEN or dArea < MIN_AREA then
             EgtErase( nCrvId + nInd)
-            return
+         else         
+            table.insert( vIds, nCrvId + nInd)
+            ModifyStartPoint( nCrvId + nInd, vPtStart)
          end
-         
-         table.insert( vIds, nCrvId + nInd)
-         ModifyStartPoint( nCrvId + nInd, vPtStart)
       end
    end
    
-   return vIds
+   return vIds or {}
 end
 
 ----------------------------------------------------------------------
@@ -2153,6 +2145,8 @@ local function ReassignInfo( nCrv, nCnt, vOrig)
                CopyInfo( vOrig[i], nId, KEY_RIBS_OVERLAP, 'd')
                CopyInfo( vOrig[i], nId, KEY_RIBS_TYPE, 'i')
                CopyInfo( vOrig[i], nId, KEY_RIBS_LINK, 'b')
+               CopyInfo( vOrig[i], nId, KEY_RIBS_LINK_FILLET, 'd')
+               CopyInfo( vOrig[i], nId, KEY_RIBS_LEAD_FILLET, 'd')
                bStart = true
             end
             -- verifico se corrisponde al suo end
@@ -2535,6 +2529,89 @@ end
 
 --------------------------------------------------------------------
 --------------------- RIBS-MERGED SHELLS ---------------------------
+--------------------------------------------------------------------
+local function CalcFillet( nCrv1, nCrv2, dFillet, nGrpId, nGrpTmp)
+
+   if dFillet < GEO.EPS_SMALL then return end
+   
+   -- creo il fillet
+   local dParRef1 = EgtCurveParamAtLength( nCrv1, EgtCurveLength( nCrv1) - 100 * GEO.EPS_SMALL)
+   local dParRef2 = EgtCurveParamAtLength( nCrv2, 100 * GEO.EPS_SMALL)
+   local nFillet = EgtCurveFillet( nGrpTmp, nCrv1, EgtUP( nCrv1, dParRef1, nGrpTmp), nCrv2, EgtUP( nCrv2, dParRef2, nGrpTmp), dFillet, true, GDB_RT.LOC)
+   if not nFillet then
+      -- ritento con valore di fillet leggermente inferiore
+      nFillet = EgtCurveFillet( nGrpTmp, nCrv1, EgtUP( nCrv1, dParRef1, nGrpTmp), nCrv2, EgtUP( nCrv2, dParRef2, nGrpTmp), dFillet - 50 * GEO.EPS_SMALL, true, GDB_RT.LOC)
+   end
+
+   -- spezzo a metà il fillet per assegnarlo alle due curve
+   if nFillet then
+      local nNewFillet = EgtSplitCurve( nFillet, 2)
+      
+      -- aggiungo a nCrv1
+      if EgtExistsObj( nCrv1) then
+         EgtAddCurveCompoArcTg( nCrv1, EgtEP( nNewFillet, GDB_ID.ROOT), true, GDB_RT.GLOB)
+         EgtErase( nNewFillet)
+      else
+         -- nCrv1 viene sostituita completamente dal fillet
+         local nNewCrv = EgtCurveCompo( nGrpId, {nNewFillet})
+         EgtChangeId( nNewCrv, nCrv1)
+      end
+      
+      -- aggiungo a nCrv2
+      if EgtExistsObj( nCrv2) then
+         EgtAddCurveCompoArcTg( nCrv2, EgtSP( nNewFillet + 1, GDB_ID.ROOT), false, GDB_RT.GLOB)
+         EgtErase( nNewFillet + 1)
+      else
+         -- nCrv2 viene sostituita completamente dal fillet
+         local nNewCrv = EgtCurveCompo( nGrpId, {nNewFillet + 1})
+         EgtChangeId( nNewCrv, nCrv2)
+      end
+   else
+      EgtOutLog( 'Warning : ribs-merged shells fillet not possible (layer '..tostring( s_nCurrIdx)..') - CalcPath')
+   end
+   
+   EgtRelocateGlob( nFillet or GDB_ID.NULL, nGrpId)
+end
+
+--------------------------------------------------------------------
+local function AddFillet( nRib1, vLinks, nRib2, nGrpId)
+   
+   local dFillet1 = EgtGetInfo( nRib1, KEY_RIBS_LINK_FILLET, 'd')
+   local dFillet2 = EgtGetInfo( nRib2, KEY_RIBS_LINK_FILLET, 'd')
+   -- verifico se necessaria correzione per passate dello stesso setto
+   local nOrig1 = EgtGetInfo( nRib1, KEY_ORIGINAL_RIB, 'i')
+   local nOrig2 = EgtGetInfo( nRib2, KEY_ORIGINAL_RIB, 'i')
+   local nSplit1 = EgtGetInfo( nRib1, KEY_SPLIT_ID, 'i') or 0
+   local nSplit2 = EgtGetInfo( nRib2, KEY_SPLIT_ID, 'i') or 0
+   if nOrig1 == nOrig2 and nSplit1 == nSplit2 then
+      local dStrand = EgtGetInfo( nRib1, KEY_RIBS_STRAND, 'd')
+      dFillet1 = min( dFillet1, 0.5 * dStrand)
+      dFillet2 = dFillet1
+   end
+   
+   -- creo un gruppo con riferimento locale allo slicing per i conti del fillet
+   local nGrpTmp = EgtGroup( nGrpId, Frame3d( ORIG(), s_vtSlicing), GDB_RT.GLOB)
+   
+   -- calcolo il primo fillet
+   local ptRib1 = EgtEP( nRib1, GDB_ID.ROOT)
+   for i = 1, #vLinks do
+      if AreSamePointApprox( ptRib1, EgtSP( vLinks[i], GDB_ID.ROOT)) then
+         CalcFillet( nRib1, vLinks[i], dFillet1, nGrpId, nGrpTmp)
+         break
+      end
+   end
+   -- calcolo il secondo fillet
+   local ptRib2 = EgtSP( nRib2, GDB_ID.ROOT)
+   for i = 1, #vLinks do
+      if AreSamePointApprox( EgtEP( vLinks[i], GDB_ID.ROOT), ptRib2) then
+         CalcFillet( vLinks[i], nRib2, dFillet2, nGrpId, nGrpTmp)
+         break
+      end
+   end
+
+   EgtErase( nGrpTmp)
+end
+
 --------------------------------------------------------------------
 local function ComputeShortestLinkOnCurve( nCrv, dParS, dParE, nGrp)
    
@@ -2785,6 +2862,8 @@ local function HandleRibsIntersectionForRibsMergedShells( vOrigRibs, nRibsGrp, n
                      if nLinkId then
                         local nRes = EgtCurveWithRegionClassify( nLinkId, nShellSrf)
                         if nRes == GDB_CRC.IN then
+                           -- fillet
+                           AddFillet( nCrv, {nLinkId}, nCrv + 1, nRibsGrp)
                            EgtAddCurveCompoCurve( nCrv + 1, nLinkId, true, false)
                            EgtAddCurveCompoCurve( nCrv + 1, nCrv, true, false)
                         else
@@ -2890,6 +2969,7 @@ local function CreateRibsMergedShellLastLink( vShells, vRibs, nGrp, bInvert)
          if bInvert then
             -- conservo tratto dParS->dParE
             EgtTrimCurveStartEndAtParam( nLink, dParS, dParE)
+            EgtInvertCurve( nLink)
          else
             -- conservo tratto dParE->dParS
             EgtTrimCurveStartEndAtParam( nLink, dParE, dParS)
@@ -2932,6 +3012,8 @@ local function CreateRibsMergedShellLastLink( vShells, vRibs, nGrp, bInvert)
                            end
                         end
                         if nPartLink then
+                           -- fillet
+                           AddFillet( vRibs[i], {nPartLink}, nOtherPart, nGrp)
                            EgtAddCurveCompoCurve( vRibs[i], nPartLink)
                            EgtAddCurveCompoCurve( vRibs[i], nOtherPart)
                         end
@@ -3024,6 +3106,7 @@ local function AdjustRibsMergedExtraShellLink( nLinkId, vExtraShells, nGrp)
    
    local frLoc = Frame3d( ORIG(), s_vtSlicing)
    local nGrpLoc = EgtGroup( nGrp, frLoc)
+   local vLinks = {}
    
    -- devo conservare solo le intersezioni fra link ed extra shell
    for i = 1, #vExtraShells do
@@ -3031,6 +3114,8 @@ local function AdjustRibsMergedExtraShellLink( nLinkId, vExtraShells, nGrp)
       if nRes then
          for nId = nRes + nPntCnt, nRes + nPntCnt + nCrvCnt - 1 do
             EgtRelocateGlob( nId, nGrp)
+            EgtModifyCurveExtrusion( nId, s_vtSlicing, GDB_ID.ROOT)
+            table.insert( vLinks, nId)
          end
       end
    end
@@ -3038,6 +3123,7 @@ local function AdjustRibsMergedExtraShellLink( nLinkId, vExtraShells, nGrp)
    -- cancello il link originale
    EgtErase( nLinkId)
    EgtErase( nGrpLoc)
+   return vLinks
 end
 
 --------------------------------------------------------------------
@@ -3079,7 +3165,7 @@ local function CreateRibsMergedShellCurve( nGrp, nRibsGrp, vShells, vOrigShells,
       -- creo il link
       local nLinkId = CreateRibsMergedShellLink( nCurr, nNext, nGrp, EgtIf( bLinkOnShell, vLoopsShell, vLoopsTrim), nRibsGrp)
       if not nLinkId then
-         return false 
+         return false
       end
 
       -- se link fatto sulla shell verifico non si sovrapponga al last link 
@@ -3101,16 +3187,24 @@ local function CreateRibsMergedShellCurve( nGrp, nRibsGrp, vShells, vOrigShells,
       end
       
       -- verifico se necessari aggiustamenti per extra shell
+      local vLinks
       if bExtraShell and bLinkOnShell then
-         AdjustRibsMergedExtraShellLink( nLinkId, vOrigShells, nGrp)
+         vLinks = AdjustRibsMergedExtraShellLink( nLinkId, vOrigShells, nGrp)
       end
       
+      -- fillet
+      AddFillet( nCurr, vLinks or {nLinkId}, nNext, nGrp)
+      
    end
    
    -- eventuali aggiustamenti del last link per extra shell
+   local vLastLinks
    if bExtraShell then
-       AdjustRibsMergedExtraShellLink( nLastLink, vOrigShells, nGrp)
+      vLastLinks = AdjustRibsMergedExtraShellLink( nLastLink, vOrigShells, nGrp)
    end
+   
+   -- fillet sul last link
+   AddFillet( vRibs[#vRibs], vLastLinks or {nLastLink}, vRibs[1], nGrp)
 
    -- elimino le curve inutili e le superfici
    EgtErase( nRibsGrp)
@@ -3216,7 +3310,7 @@ local function UpdateTrimSurfWithRibsMergedShell( nPathGrp, sName, LayerParams)
       -- calcolo la regione occupata dalla nuova shell
       local nType = EgtGetInfo( vNewShells[i], KEY_TYPE, 'i')
       dStrand = EgtIf( nType == TYPE.OUTER_SHELL or nType == TYPE.EXTRA_OUTER_SHELL, LayerParams.dStrand, LayerParams.dInnerStrand)
-      local nSrfShell = EgtSurfFrFatCurve( nCrvGrp, vNewShells[i], dStrand * 0.5 + 0.5 * s_dOffsCorr, false, false, s_dOffsTol)
+      local nSrfShell = EgtSurfFrFatCurve( nCrvGrp, vNewShells[i], dStrand * 0.5 + s_dOffsCorr, false, false, s_dOffsTol)
       if nSrfShell then
          if not EgtSurfFrSubtract( nNewTrimSurf, nSrfShell) then
             EgtOutLog( 'Error : EgtSurfFrSubtract with ribs-merged shell for TotTrimSurfRegion failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
@@ -3528,7 +3622,7 @@ end
 --------------------------------------------------------------------
 local function UpdateTrimSurfWithExtraShell( nSrf, nCrv, dStrand, nGrpId)
    
-   local nSrfExtraShell = EgtSurfFrFatCurve( nGrpId, nCrv, dStrand * 0.5 + s_dOffsCorr * 0.5, true, false, s_dOffsTol)
+   local nSrfExtraShell = EgtSurfFrFatCurve( nGrpId, nCrv, dStrand * 0.5 + s_dOffsCorr, true, false, s_dOffsTol)
    if nSrfExtraShell then
       if not EgtSurfFrSubtract( nSrf, nSrfExtraShell) then
          EgtOutLog( 'Error : EgtSurfFrSubtract with ExtraShell for TotTrimSurfRegion failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
@@ -3841,8 +3935,8 @@ local function CalcExtraShellsPath( nMaxShellNbrDiff, nShellNbrGrp, nCrvGrpId, d
             local nOffs, nOffsCnt = EgtOffsetCurveAdv( nCrvT, - dOffs, GDB_OT.FILLET, s_dOffsTol)
             for nCrvOffs = nOffs, nOffs + nOffsCnt - 1 do
                
-               -- calcolo la regione con cui fare trim
-               local nTrimSurf, bNoOverlap = ComputeTrimSurf( nTotShellTrim, nGrpTmp, dCurrStrand, LayerParams.dStrandOverlap)
+               -- calcolo la regione con cui fare trim ( con correzione extra per evitare tratti on)
+               local nTrimSurf, bNoOverlap = ComputeTrimSurf( nTotShellTrim, nGrpTmp, dCurrStrand - 10 * s_dOffsCorr, LayerParams.dStrandOverlap)
                if not nTrimSurf then
                   -- errore nel calcolo della superficie di trim
                   EgtOutLog( 'Error : creation of ExtraShell failed (layer '.. EgtNumToString( s_nCurrIdx) ..') - CalcPaths')
@@ -4209,6 +4303,8 @@ end
 ---------------------------------------------------------------------
 function CalcPaths.Exec( nPartId)
    
+   EgtStartCounter()
+   
    s_nPartId = nPartId
 
    local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER.."*")
@@ -4384,6 +4480,9 @@ function CalcPaths.Exec( nPartId)
       end
    end
    
+   -- report tempo di calcolo in log
+   EgtOutLog( string.format( '  CalcPathTime = %.2f ms', EgtStopCounter()))
+   
    if #s_vErr > 0 then
       EgtOutBox( 'CalcPath Error on :\n' .. table.concat( s_vErr, '\n'), 'Calculating Paths')
    end

LuaLibs/CalcSlices.lua

@@ -121,7 +121,9 @@ local function GetRibParams( nId)
    ReadParam( nId, KEY_RIBS_TYPE, 'i', RIB_TYPE.INTERNAL, RibParam)
    ReadParam( nId, KEY_RIBS_INVERT_STRAND_ORDER, 'b', false, RibParam)
    ReadParam( nId, KEY_RIBS_MERGE_WITH_SHELLS, 'b', false, RibParam)
-  
+   ReadParam( nId, KEY_RIBS_LEAD_FILLET, 'd', 0, RibParam)
+   ReadParam( nId, KEY_RIBS_LINK_FILLET, 'd', 0, RibParam)
+   
    return RibParam
 end
 

LuaLibs/CalcToolPath.lua

@@ -16,6 +16,8 @@ local AMD = require( 'AddManData')
 local s_nPartId
 local s_nDefaultWipeAng = -90   -- angolo = 0° per wipe significa che esce ortogonalmente alla direzione del movimento
 local s_dApproxTol = 0.1
+local s_dHSafeWipe = 2
+local s_nCurrIdx
 
 ---------------------------------------------------------------------
 local function GetLayerParamsForToolPathCalc()
@@ -97,7 +99,7 @@ local function AddZCorrection( b3Box, LayerParams)
    
    -- correzione per i wipe
    -- altezza minima necessaria per i wipe
-   local dHMinWipe = LayerParams.dTDiam / 2 * dNxy + max( dHBox, 0)
+   local dHMinWipe = LayerParams.dTDiam / 2 * dNxy + max( dHBox, 0) + s_dHSafeWipe
    local vLayIds = EgtGetNameInGroup( s_nPartId, SLICE_LAYER.."*")
    for i = 1, #vLayIds do
       local vCrvGrps = EgtGetNameInGroup( vLayIds[i], CONTOUR_GRP.."*")
@@ -108,13 +110,23 @@ local function AddZCorrection( b3Box, LayerParams)
             for k = 1, #vIds do
                -- se wipe verifico se ha lunghezza sensata per non finire nella tavola
                if EgtGetInfo( vIds[k], KEY_TYPE, 'i') == TYPE.WIPE then
-                  local dLen = EgtCurveLength( vIds[k])
-                  local vtDir = EgtSV( vIds[k], GDB_ID.ROOT)
-                  local ptE = EgtEP( vIds[k], GDB_ID.ROOT)
-                  if ptE:getZ() < dHMinWipe then
-                     -- modifico la lunghezza per non finire nella tavola
-                     local dDiffLen = ( dHMinWipe - ptE:getZ()) / vtDir:getZ()
-                     EgtTrimCurveEndAtLen( vIds[k], dLen - abs( dDiffLen))
+                  -- da controllare solo se non segue l'andamento di una curva chiusa
+                  local bOnCurve = EgtGetInfo( vIds[k], KEY_WIPE_ON_CRV, 'b') or false
+                  if not bOnCurve then
+                     local dLen = EgtCurveLength( vIds[k])
+                     local vtDir = EgtSV( vIds[k], GDB_ID.ROOT)
+                     local ptE = EgtEP( vIds[k], GDB_ID.ROOT)
+                     if ptE:getZ() < dHMinWipe then
+                        -- modifico la lunghezza per non finire nella tavola
+                        local dDiffLen = abs( ( dHMinWipe - ptE:getZ()) / vtDir:getZ())
+                        if dDiffLen > dLen - GEO.EPS_SMALL then
+                           -- l'intero tratto di wipe va eliminato
+                           EgtErase( vIds[k])
+                           EgtOutLog( 'Warning : wipe was removed due to wrong direction (layer '..tostring( i)..') - CalcToolPath')
+                        else
+                           EgtTrimCurveEndAtLen( vIds[k], dLen - dDiffLen)
+                        end
+                     end
                   end
                end
             end
@@ -152,8 +164,13 @@ local function AddCurvesToToolPath( vEntIds, nTpathGrpId, nOrder, bInvert, vtSli
          end
       end
       
+      -- approssimo la curva e ne risetto il punto iniziale
+      local ptS = EgtSP( vIds[nIdx], GDB_ID.ROOT)
       EgtApproxCurve( vIds[nIdx], GDB_CA.ARCS, s_dApproxTol)
-            
+      if EgtCurveIsClosed( vIds[nIdx]) then
+         EgtChangeClosedCurveStartPoint( vIds[nIdx], ptS, GDB_RT.GLOB)
+      end
+
       EgtSetInfo( vEntIds[i], KEY_ASSOCIATED_TP_CRV, vIds[nIdx])
       EgtSetInfo( vIds[nIdx], KEY_ASSOCIATED_P_CRV, vEntIds[i])
 
@@ -373,19 +390,29 @@ local function AddRetraction( nCrvId, vtSlicing, dCoastingLen, dWipeLen, dWipeDi
    
    -- curva ausiliaria per generare correttamente wipe
    local nCopyId = EgtCopyGlob( nCrvId, nCrvId, GDB_IN.AFTER)
-   if not EgtCurveIsClosed( nCopyId) then
-      local ptNewStart = EgtEP( nCrvId)
-      local dPar = EgtCurveParamAtPoint( nCopyId, ptNewStart)
-      local _, dParE = EgtCurveDomain( nCopyId)
-      if abs( dPar - dParE) < GEO.EPS_SMALL then
-         EgtCloseCurveCompo( nCopyId)
-         EgtChangeClosedCurveStartPoint( nCopyId, ptNewStart)
-      else
+   if not EgtCurveIsClosed( nCopyId) and EgtCurveIsFlat( nCopyId) then
+      local ptNewStart = EgtEP( nCopyId, GDB_ID.ROOT)
+      -- mi posiziono in un frame locale per fare i conti
+      local nGrp = EgtGroup( EgtGetParent( nCrvId), Frame3d( ORIG(), vtSlicing), GDB_RT.GLOB)
+      EgtRelocateGlob( nCopyId, nGrp)
+      local nInters = EgtCurveSelfIntersCount( nCopyId)
+      local nCrvCnt
+      if nInters > 0 then
          -- caso con sovrapposizione
-         EgtTrimCurveStartAtParam( nCopyId, dPar)
+         nCopyId, nCrvCnt = EgtSplitCurveAtSelfInters( nCopyId)
+         for nIdx = 1, nCrvCnt - 2 do
+            EgtAddCurveCompoCurve( nCopyId, nCopyId + nIdx)
+         end
+         if nCrvCnt > 1 then 
+            EgtErase( nCopyId + nCrvCnt - 1)
+         end
       end
+      EgtCloseCurveCompo( nCopyId)
+      EgtChangeClosedCurveStartPoint( nCopyId, ptNewStart, GDB_RT.GLOB)
+      EgtRelocateGlob( nCopyId, nCrvId, GDB_IN.AFTER)
+      EgtErase( nGrp)
    end
-   
+
    local nCoastingId
    if dCoastingLen > GEO.EPS_SMALL then
       nCoastingId = EgtCopyGlob( nCrvId, nCrvId, GDB_IN.AFTER)
@@ -416,6 +443,7 @@ local function AddRetraction( nCrvId, vtSlicing, dCoastingLen, dWipeLen, dWipeDi
          nWipeId = nCopyId
          nCopyId = nil
          EgtTrimCurveEndAtLen( nWipeId, dWipeLen)
+         EgtSetInfo( nWipeId, KEY_WIPE_ON_CRV, true)
       else
          -- se extra shell, infill, spiral vase o rib che non termina sulla parete
          local ptS = EgtEP( nCoastingId or nCrvId, GDB_ID.ROOT)
@@ -513,7 +541,7 @@ local function CalcShellsToolPath( vEntIds, nTpathGrpId, LayerParams)
    -- aggiungo le curve nel toolpath
    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')
@@ -525,7 +553,7 @@ local function CalcShellsToolPath( vEntIds, nTpathGrpId, LayerParams)
          EgtSetInfo( vIds[i], KEY_CRV_STRAND, LayerParams.dInfillStrand)
       end
    end
-   
+
    -- aggiungo gli opportuni raccordi
    AddLink( vIds, nTpathGrpId, LayerParams.nLinkType, LayerParams.dLinkParam, LayerParams.dSPOffs, LayerParams.nOrder, LayerParams.vtSlicing)
    
@@ -1035,6 +1063,78 @@ end
 
 --------------------------------------------------------------------
 --------------------------- RIBS -----------------------------------
+--------------------------------------------------------------------
+local function AddFillet( nCrv1, nCrv2, dFillet, vtSlicing)
+   
+   if dFillet < GEO.EPS_SMALL then
+      return
+   end
+   
+   local nRefPosId = EgtGetPrev( nCrv1)
+   local nRefGrpId = EgtGetParent( nCrv1)
+   local vsInfo1 = EgtGetAllInfo( nCrv1)
+   local vsInfo2 = EgtGetAllInfo( nCrv2)
+   
+   -- creo un gruppo con riferimento locale allo slicing per i conti del fillet
+   local nGrpTmp = EgtGroup( EgtGetParent( nCrv1), Frame3d( ORIG(), vtSlicing), GDB_RT.GLOB)
+   
+   -- creo il fillet
+   local dParRef1 = EgtCurveParamAtLength( nCrv1, EgtCurveLength( nCrv1) - 100 * GEO.EPS_SMALL)
+   local dParRef2 = EgtCurveParamAtLength( nCrv2, 100 * GEO.EPS_SMALL)
+   local nFillet = EgtCurveFillet( nGrpTmp, nCrv1, EgtUP( nCrv1, dParRef1, nGrpTmp), nCrv2, EgtUP( nCrv2, dParRef2, nGrpTmp), dFillet, true, GDB_RT.LOC)
+   if not nFillet then
+      -- ritento con valore di fillet leggermente inferiore
+      nFillet = EgtCurveFillet( nGrpTmp, nCrv1, EgtUP( nCrv1, dParRef1, nGrpTmp), nCrv2, EgtUP( nCrv2, dParRef2, nGrpTmp), dFillet - 50 * GEO.EPS_SMALL, true, GDB_RT.LOC)
+   end
+
+   -- spezzo a metà il fillet per assegnarlo alle due curve
+   if nFillet then
+      
+      local nNewFillet = EgtSplitCurve( nFillet, 2)
+      
+      -- aggiungo a nCrv1
+      if EgtExistsObj( nCrv1) then
+         EgtAddCurveCompoArcTg( nCrv1, EgtEP( nNewFillet, GDB_ID.ROOT), true, GDB_RT.GLOB)
+         EgtErase( nNewFillet)
+      else
+         -- nCrv1 viene sostituita completamente dal fillet
+         local nNewCrv = EgtCurveCompo( nRefGrpId, {nNewFillet})
+         -- riposiziono dopo il precedente di nCrv1 ( se esiste) oppure in testa al gruppo
+         if nRefPosId ~= GDB_ID.NULL then
+            EgtRelocateGlob( nNewFillet, nRefPosId, GDB_IN.AFTER)
+         else
+            EgtRelocateGlob( nNewFillet, nRefGrpId, GDB_IN.FIRST_SON)
+         end
+         -- modifico l'id per conservare quello di nCrv1
+         EgtChangeId( nNewCrv, nCrv1)
+         -- riassegno le info
+         for i = 1, #vsInfo1 do
+            local vsInfo = EgtSplitString( vsInfo1[i], '=')
+            EgtSetInfo( nCrv1, vsInfo[1], vsInfo[2])
+         end
+      end
+      
+      -- aggiungo a nCrv2
+      if EgtExistsObj( nCrv2) then
+         EgtAddCurveCompoArcTg( nCrv2, EgtSP( nNewFillet + 1, GDB_ID.ROOT), false, GDB_RT.GLOB)
+         EgtErase( nNewFillet + 1)
+      else
+         -- nCrv2 viene sostituita completamente dal fillet
+         local nNewCrv = EgtCurveCompo( nRefGrpId, {nNewFillet + 1})
+         EgtRelocateGlob( nNewCrv, nCrv1, GDB_IN.AFTER)
+         EgtChangeId( nNewCrv, nCrv2)
+         for i = 1, #vsInfo2 do
+            local vsInfo = EgtSplitString( vsInfo2[i], '=')
+            EgtSetInfo( nCrv2, vsInfo[1], vsInfo[2])
+         end
+      end
+   else
+      EgtOutLog( 'Warning : ribs fillet not possible (layer '..tostring( s_nCurrIdx)..') - CalcToolPath')
+   end
+   
+   EgtErase( nGrpTmp)
+end
+
 --------------------------------------------------------------------
 local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand)
 
@@ -1069,7 +1169,7 @@ local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand)
       end
       
       -- se collegamento non ottimale verifico che abbia una parte esterna alla regione occupata dai setti abbsatanza lunga ( > 20% della lunghezza totale)
-      if dist( EgtEP( nCurr, GDB_ID.ROOT), EgtSP( nNext, GDB_ID.ROOT)) > dist( EgtEP( nCurr, GDB_ID.ROOT), EgtEP( nNext, GDB_ID.ROOT)) + GEO.EPS_SMALL then
+      if dist( EgtEP( nCurr, GDB_ID.ROOT), EgtSP( nNext, GDB_ID.ROOT)) > dist( EgtEP( nCurr, GDB_ID.ROOT), EgtEP( nNext, GDB_ID.ROOT)) + 1000 * GEO.EPS_SMALL then
          local nSrfRibs = EgtSurfFrFatCurve( nGrpTmp, nCurr, dStrand, false) or GDB_ID.NULL
          local nSrfRibs2 = EgtSurfFrFatCurve( nGrpTmp, nNext, dStrand, false) or GDB_ID.NULL
          EgtSurfFrAdd( nSrfRibs, nSrfRibs2)
@@ -1111,7 +1211,7 @@ local function VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand)
             dOffs = dCurrStrand * 0.5
          else
             -- altrimenti verifico che le regioni del link e del setto non si sovrappongono ( a meno dell'overlap fissato)
-            dOffs = dCurrStrand * 0.5 + ( 0.5 - dOverlap / 100) * dStrand - 10 * GEO.EPS_SMALL
+            dOffs = dCurrStrand * 0.5 + ( 0.5 - dOverlap / 100) * dStrand - 50 * GEO.EPS_SMALL
          end
          
          if dOffs > GEO.EPS_SMALL then
@@ -1237,6 +1337,8 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, vtSlicing, nGrp
    local dStrand1 = EgtGetInfo( nCurr, KEY_CRV_STRAND, 'd')
    local dStrand2 = EgtGetInfo( nNext, KEY_CRV_STRAND, 'd')
    local dStrand = max( dStrand1, dStrand2)
+   local dFillet1 = EgtGetInfo( nCurr, KEY_RIBS_LINK_FILLET, 'd')
+   local dFillet2 = EgtGetInfo( nNext, KEY_RIBS_LINK_FILLET, 'd')
    
    local vCrvIds = EgtGetAllInGroup( nLoopGrp)
    -- recupero le curve di bordo su cui poggiano i setti e i corrispondenti parametri
@@ -1268,6 +1370,14 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, vtSlicing, nGrp
          end
          
          if nLinkId then
+            -- fillet
+            if bForceLink then
+               dFillet1 = min( dFillet1, dStrand1 * 0.5)
+               dFillet2 = min( dFillet2, dStrand2 * 0.5)
+            end
+            AddFillet( nCurr, nLinkId, dFillet1, vtSlicing)
+            AddFillet( nLinkId, nNext, dFillet2, vtSlicing)
+            -- assegno le info
             EgtRelocateGlob( nLinkId, nCurr, GDB_IN.AFTER)
             EgtSetInfo( nLinkId, KEY_TYPE, TYPE.RIB)
             EgtSetName( nLinkId, LINK_CRV)
@@ -1281,6 +1391,7 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, vtSlicing, nGrp
    -- 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})
+      -- assegno le info
       EgtSetInfo( nLinkId, KEY_TYPE, TYPE.RIB)
       EgtSetName( nLinkId, LINK_CRV)
       EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB)
@@ -1288,6 +1399,11 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, vtSlicing, nGrp
       EgtSetInfo( nLinkId, KEY_CRV_STRAND, dStrand)
       local bValid = VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand)
       if bValid then
+         -- fillet
+         dFillet1 = min( dFillet1, dStrand1 * 0.5)
+         dFillet2 = min( dFillet2, dStrand2 * 0.5)
+         AddFillet( nCurr, nLinkId, dFillet1, vtSlicing)
+         AddFillet( nLinkId, nNext, dFillet2, vtSlicing)
          return nLinkId
       else
          EgtErase( nLinkId)
@@ -1299,12 +1415,13 @@ local function CalcRibsLink( nCurr, nNext, nLoopGrp, bForceLink, vtSlicing, nGrp
 end
 
 --------------------------------------------------------------------
-local function CalcLoopRibLink( nCurr, nNext, nLoopGrp, vtSlicing, nGrpTmp)
+local function CalcLoopRibLink( nCurr, nNext, nLoopGrp, vtSlicing, nGrpTmp, bForceLink)
    
    local ptS = EgtEP( nCurr)
    local ptE = EgtSP( nNext)
    if AreSamePointApprox( ptS, ptE) then return end
    local dStrand = EgtGetInfo( nCurr, KEY_CRV_STRAND, 'd')
+   local dFillet = EgtGetInfo( nCurr, KEY_RIBS_LINK_FILLET, 'd')
    
    local vCrvIds = EgtGetAllInGroup( nLoopGrp)
    -- scorro le curve di bordo e verifico se posso creare il link
@@ -1320,6 +1437,12 @@ local function CalcLoopRibLink( nCurr, nNext, nLoopGrp, vtSlicing, nGrpTmp)
             EgtModifyCurveExtrusion( nLinkId, vtSlicing, GDB_RT.GLOB)
             EgtSetInfo( nLinkId, KEY_CRV_STRAND, dStrand)
             if VerifyRibsLink( nLinkId, nCurr, nNext, nGrpTmp, dStrand) then
+               -- fillet
+               if bForceLink then
+                  dFillet = min( dFillet, dStrand * 0.5)
+               end
+               AddFillet( nCurr, nLinkId, dFillet, vtSlicing)
+               AddFillet( nLinkId, nNext, dFillet, vtSlicing)
                return nLinkId
             else
                EgtErase( nLinkId)
@@ -1397,7 +1520,7 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
    -- 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
+      local dCurrOffs = dCurrStrand * 0.5 + ( 0.5 - dOverlap / 100) * dStrand - 50 * GEO.EPS_SMALL
       if dCurrOffs > GEO.EPS_SMALL then
          local nSrfCurr = EgtSurfFrFatCurve( nGrpTmp, vCheckIds[i], dCurrOffs, false)
          if nSrfCurr then
@@ -1426,8 +1549,9 @@ local function VerifyRibsLead( nId, nRibId, bInVsOut, nGrpTmp)
       local vtE = EgtUV( nLeadLoc, dParCrv, -1)
       local dLenCrv = EgtCurveCompoLength( nLeadLoc, dParCrv - 1)
       if AreSameVectorApprox( vtS, vtE) and vtS * vtDir < - 1 + GEO.EPS_SMALL and dLenCrv > dStrand + GEO.EPS_SMALL then
-         local dDist = EgtPointCurveDist( EgtUP( nLeadLoc, dParCrv - 0.5), nRibLoc)
-         EgtCopyGlob( nLeadLoc, nGrpTmp)
+         local vtDist = EgtUP( nLeadLoc, dParCrv - 0.5) - EgtMP( nRibLoc)
+         local vtOrthoDist = vtDist - ( vtDist * vtDir) * vtDir
+         local dDist = vtOrthoDist:len()
          if dDist < dStrand + GEO.EPS_SMALL then
             return false
          end
@@ -1566,6 +1690,7 @@ local function AddRibsLeadIn( nCrv, nLoopsGrp, vtSlicing, nGrpTmp, bForceNoSolid
    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')
+   local dFillet = EgtGetInfo( nCrv, KEY_RIBS_LEAD_FILLET, 'd')
    
    if dLILen < GEO.EPS_SMALL then return end
    
@@ -1584,6 +1709,8 @@ local function AddRibsLeadIn( nCrv, nLoopsGrp, vtSlicing, nGrpTmp, bForceNoSolid
          local nLeadIn = FindCorrectRibLead( dParS, nCrv, vCrvOffs[i], bLIInvert, dLILen, true, nGrpTmp, bSpecialCase)
          -- se lead in possibile
          if nLeadIn then
+            AddFillet( nLeadIn, nCrv, dFillet, vtSlicing)
+            
             EgtModifyCurveExtrusion( nLeadIn, vtSlicing, GDB_RT.GLOB)
             EgtSetInfo( nLeadIn, KEY_TYPE, TYPE.RIB)
             EgtSetName( nLeadIn, LEAD_IN_CRV)
@@ -1603,6 +1730,7 @@ local function AddRibsLeadOut( nCrv, nLoopsGrp, vtSlicing, nGrpTmp, bForceNoSoli
    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')
+   local dFillet = EgtGetInfo( nCrv, KEY_RIBS_LEAD_FILLET, 'd')
    
    if abs( dRibsLOLen) < GEO.EPS_SMALL and
       abs( dRibsLOCoasting) < GEO.EPS_SMALL and
@@ -1636,7 +1764,12 @@ local function AddRibsLeadOut( nCrv, nLoopsGrp, vtSlicing, nGrpTmp, bForceNoSoli
          local nCrvRef, bInvert = FindCorrectRibLead( dParE, nCrv, vCrvOffs[i], bRibsLOInvert, dRibsLOLen + dRibsLOCoasting, false, nGrpTmp, bSpecialCase)
    
          if nCrvRef then
-   
+            
+            -- aggiungo il fillet ( potrebbe coinvolgere sia lead out sia coasting)
+            AddFillet( nCrv, nCrvRef, dFillet, vtSlicing)
+            -- calcolo la nuova lunghezza per il lead out per conservare la lunghezza del coasting dopo il fillet
+            dRibsLOLen = EgtCurveLength( nCrvRef) - dRibsLOCoasting
+            
             -- primo tratto ( segue offset con flusso aperto)
             if dRibsLOLen > GEO.EPS_SMALL then
                nCrvLO = EgtCopyGlob( nCrvRef, nCrv, GDB_IN.AFTER)
@@ -1706,13 +1839,20 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
    local nGrpTmp = EgtGroup( nRibsGrp, frLoc, GDB_RT.GLOB)
    
    -- aggiungo le costolature nel toolpath
-   local nNewFirstEnt
+   local nLastEnt = EgtGetLastInGroup( nTpathGrpId)
    for i = 1, #vEntIds do
       -- copio entità nel gruppo toolpath
       local nNewEntId = EgtCopyGlob( vEntIds[i], nTpathGrpId, GDB_IN.LAST_SON)
       -- mi sposto dell'altezza layer
       EgtMove( nNewEntId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
+      
+      -- approssimo la curva e ne risetto punto iniziale (se chiusa)
+      local ptS = EgtSP( nNewEntId, GDB_ID.ROOT)
       EgtApproxCurve( nNewEntId, GDB_CA.ARCS, s_dApproxTol)
+      if EgtCurveIsClosed( nNewEntId) then
+         EgtChangeClosedCurveStartPoint( nNewEntId, ptS, GDB_RT.GLOB)
+      end
+      
       EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB)
       EgtSetColor( nNewEntId, EgtStdColor('MAROON'))
       
@@ -1721,13 +1861,11 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
       
       EgtSetInfo( nNewEntId, KEY_ASSOCIATED_P_CRV, vEntIds[i])
       EgtSetInfo( vEntIds[i], KEY_ASSOCIATED_TP_CRV, nNewEntId)
-     
-      if i == 1 then nNewFirstEnt = nNewEntId end
    end
    
    -- recupero i gruppi delle costolature
    local tabRibs = {}
-   local nFirst = nNewFirstEnt
+   local nFirst = EgtGetNext( nLastEnt)
    while nFirst do
       local sName = EgtGetName( nFirst)
       local vIds = EgtGetNameInGroup( nTpathGrpId, sName)
@@ -1759,12 +1897,17 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
                if not bLoopRib then
                   CalcRibsLink( tabRibs[i][j], tabRibs[i][j + 1], nLoopGrp, bForceLink, LayerParams.vtSlicing, nGrpTmp)
                else
-                  local nLinkId = CalcLoopRibLink( tabRibs[i][j], tabRibs[i][j + 1], nLoopGrp, LayerParams.vtSlicing, nGrpTmp)
+                  local nLinkId = CalcLoopRibLink( tabRibs[i][j], tabRibs[i][j + 1], nLoopGrp, LayerParams.vtSlicing, nGrpTmp, bForceLink)
                   -- se collegamento congiungo i setti in unico percorso
                   if nLinkId then
-                     EgtAddCurveCompoCurve( tabRibs[i][j], nLinkId)
-                     EgtAddCurveCompoCurve( tabRibs[i][j], tabRibs[i][j + 1])
-                     tabRibs[i][j+1] = tabRibs[i][j] -- aggiorno id nel vettore dei setti per gestire correttamente la curva allo step successivo
+                     EgtAddCurveCompoCurve( tabRibs[i][j+1], nLinkId, true, false)
+                     EgtAddCurveCompoCurve( tabRibs[i][j+1], tabRibs[i][j], true, false)
+                     -- aggiorno id nel vettore dei setti per gestire correttamente le curve negli step successivi
+                     for k = 0, j do
+                        if tabRibs[i][k] == tabRibs[i][j] then
+                           tabRibs[i][k] = tabRibs[i][j+1]
+                        end
+                     end
                   end
                end
             end
@@ -1773,7 +1916,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 = CalcLoopRibLink( tabRibs[i][nTotCrv], tabRibs[i][1], nLoopGrp, LayerParams.vtSlicing, nGrpTmp)
+            local nLinkId = CalcLoopRibLink( tabRibs[i][nTotCrv], tabRibs[i][1], nLoopGrp, LayerParams.vtSlicing, nGrpTmp, false)
             if nLinkId then
                -- se curva unica
                if tabRibs[i][nTotCrv] == tabRibs[i][1] then
@@ -1818,7 +1961,7 @@ local function CalcRibsToolPath( vEntIds, nRibsGrp, nTpathGrpId, LayerParams)
    if nType == RIB_TYPE.UNBOUNDED then
       bForceNoSolidBorder = true
    end
-   local nCrvRib = nNewFirstEnt
+   local nCrvRib = EgtGetNext( nLastEnt)
    while nCrvRib do
       -- verifico se necessario lead in
       local nPrev = EgtGetPrev( nCrvRib)
@@ -1841,7 +1984,7 @@ end
 --------------------------------------------------------------------
 local function AddSpiralVaseLeadOut( nOldId, LayerParams)
    
-    if LayerParams.nLeadOutType ~= LEAD_TYPE.NONE then
+   if LayerParams.nLeadOutType ~= LEAD_TYPE.NONE then
       EgtTrimCurveEndAtLen( nOldId, EgtCurveLength( nOldId) - LayerParams.dOffsetLP)
       local nLeadOut = AddLeadOut( nOldId, LayerParams, EgtGetParent( nOldId))
       if nLeadOut then
@@ -1914,66 +2057,72 @@ local function SpiralVase( vLayIds, LayerParams)
             return false
          end
          
-         local nNewEntId = EgtCopyGlob( vEntIds[1], nTpathGrpId, GDB_IN.LAST_SON)
+         local nNewEntId = EgtCopyGlob( vEntIds[1] or GDB_ID.NULL, nTpathGrpId, GDB_IN.LAST_SON)
+         
+         if nNewEntId then
             
-         local vtMove = V_NULL()
-         -- eventuale spostamento dell'altezza layer
-         if nSlicingType == SLICING_TYPE.DEG45_X or nSlicingType == SLICING_TYPE.DEG45_Y then
-            vtMove = LayerParams.dLayHeight * LayerParams.vtSlicing
-            EgtMove( nNewEntId, vtMove, GDB_RT.GLOB)
-         end
-
-         EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB)
-         EgtSetInfo( nNewEntId, KEY_CRV_STRAND, LayerParams.dStrand)
-         
-         -- eventuale inversione
-         if LayerParams.bInvert then
-            EgtInvertCurve( nNewEntId)
-            EgtSetInfo( nNewEntId, KEY_INVERTED_CRV, 1)
-         end
-         EgtSetColor( nNewEntId, EgtStdColor('GRAY'))
-         
-         -- se primo layer
-         if bFirst and nNewEntId then
-            -- mi sposto dell'altezza layer
-            EgtMove( nNewEntId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
-            -- eventuale lead in
-            if LayerParams.nLeadInType ~= LEAD_TYPE.NONE then
-               EgtTrimCurveStartAtLen( nNewEntId, LayerParams.dOffsetLP)
-               AddLeadIn( nNewEntId, LayerParams, nTpathGrpId)
+            local vtMove = V_NULL()
+            -- eventuale spostamento dell'altezza layer
+            if nSlicingType == SLICING_TYPE.DEG45_X or nSlicingType == SLICING_TYPE.DEG45_Y then
+               vtMove = LayerParams.dLayHeight * LayerParams.vtSlicing
+               EgtMove( nNewEntId, vtMove, GDB_RT.GLOB)
             end
-            bFirst = false
-         else
-            local ptOld = EgtEP( nOldId, GDB_ID.ROOT)
-            local ptNew = EgtSP( nNewEntId, GDB_ID.ROOT)
-            if dist( ptNew, ptOld) < LayerParams.dStrand then
-               -- se i punti sono vicini ma non coincidenti modifico la curva per avere transizione più uniforme
+      
+            EgtModifyCurveExtrusion( nNewEntId, LayerParams.vtSlicing, GDB_RT.GLOB)
+            EgtSetInfo( nNewEntId, KEY_CRV_STRAND, LayerParams.dStrand)
+            
+            -- eventuale inversione
+            if LayerParams.bInvert then
+               EgtInvertCurve( nNewEntId)
+               EgtSetInfo( nNewEntId, KEY_INVERTED_CRV, 1)
+            end
+            EgtSetColor( nNewEntId, EgtStdColor('GRAY'))
+            
+            -- se primo layer
+            if bFirst then
+               -- mi sposto dell'altezza layer
+               EgtMove( nNewEntId, LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
+               -- eventuale lead in
+               if LayerParams.nLeadInType ~= LEAD_TYPE.NONE then
+                  EgtTrimCurveStartAtLen( nNewEntId, LayerParams.dOffsetLP)
+                  AddLeadIn( nNewEntId, LayerParams, nTpathGrpId)
+               end
+               bFirst = false
+            else
+               local ptOld = EgtEP( nOldId, GDB_ID.ROOT)
+               local ptNew = EgtSP( nNewEntId, GDB_ID.ROOT)
+               -- se i punti non coincidono modifico la curva per avere transizione più uniforme
                if not AreSamePointApprox( ptOld, ptNew) then
                   -- recupero la curva da usare come guida
                   local nGuideId = EgtCopyGlob( nOldPathId, nTpathGrpId)
                   -- la porto alla stessa quota del toolpath
                   EgtMove( nGuideId, vtMove + LayerParams.dLayHeight * LayerParams.vtSlicing, GDB_RT.GLOB)
+                  -- modifico i punti iniziali affinchè coincidano con il punto finale del percorso precedente
                   EgtChangeClosedCurveStartPoint( nGuideId, ptOld, GDB_RT.GLOB)
-                  
+                  EgtChangeClosedCurveStartPoint( nNewEntId, ptOld, GDB_RT.GLOB)
                   EgtSpiralizeCurveAlongGuide( nNewEntId, nGuideId)
                   EgtErase( nGuideId)
                end
-            else
-               EgtOutLog( 'Warning : in spiral vase mode no link betweeen toolpaths (layer '..tostring( nIdx)..') - CalcToolPath')
-               -- aggiungo uscita, coasting e wipe sulla curva precedente
-               AddSpiralVaseLeadOut( nOldId, LayerParams)
+               EgtSpiralizeCurveAlongExtrusion( nNewEntId, LayerParams.dLayHeight)
             end
-            EgtSpiralizeCurveAlongExtrusion( nNewEntId, LayerParams.dLayHeight)
-            EgtApproxCurve( nNewEntId, GDB_CA.ARCS, s_dApproxTol)
+            
+            -- approssimo la curva
+            if nNewEntId then
+               local ptS = EgtSP( nNewEntId, GDB_ID.ROOT)
+               EgtApproxCurve( nNewEntId, GDB_CA.ARCS, s_dApproxTol)
+               if EgtCurveIsClosed( nNewEntId) then
+                  EgtChangeClosedCurveStartPoint( nNewEntId, ptS, GDB_RT.GLOB)
+               end
+            end
+            
+            nOldPathId = vEntIds[1]
+            nOldId = nNewEntId
          end
-         
-         nOldPathId = vEntIds[1]
-         nOldId = nNewEntId
 
          -- aggiorno il box dei toolpath
          local b3Box = ComputeToolPathBox( nTpathGrpId)
          b3Tot:Add( b3Box)
-         
+
       end
       
       if EgtProcessEvents( EgtIf( PRINT, 300, 0) + nIdx / #vLayIds * 100, 0) == 1 then
@@ -2016,6 +2165,8 @@ function CalcToolPath.Exec( nPartId)
    -- Ciclo sui layer
    for nIdx = 1, #vLayIds do
       
+      s_nCurrIdx = nIdx
+      
       -- scorro tutti i gruppi di contorni
       local nCrvGrpId = EgtGetFirstNameInGroup( vLayIds[ nIdx], CONTOUR_GRP.."*")
       while nCrvGrpId do

LuaLibs/RunCalcSolids.lua

@@ -14,6 +14,7 @@ local AMD = require( 'AddManData')
 
 --------------------------------------------------------------------
 local s_dTol = 0.1
+local s_nSimplifiedSection = 0
 
 ---------------------------------------------------------------------
 local function GetLayerParamsForSolidCalc( nPartId)
@@ -27,46 +28,32 @@ end
 
 ---------------------------------------------------------------------
 local function CalcSectionParams( dStrand, dH)
-   local dL = dStrand
-   local dLm = dStrand / 10
-   local dHm = dH / 6
-   local dD1 = 0.5 * dL - dLm
-   local dD2 = 0.5 * dL - dD1 
-   local dD3 = dHm
-   local dD4 = dH - 2 * dD3
-   return dD1, dD2, dD3, dD4
+   local dBevelX = 0
+   local dBevelY = 0
+   if s_nSimplifiedSection == 0 then
+      -- sezione ottagonale
+      dBevelX = dStrand / 10
+      dBevelY = dH / 6
+   end
+   return dBevelX, dBevelY
 end
 
 ---------------------------------------------------------------------
 local function CreateSection( ptS, vtDir, dStrand, dH, vtSlicing, nSolidGrp)
 
-   local dD1, dD2, dD3, dD4 = CalcSectionParams( dStrand, dH)
-   local ptA = ptS - dH * vtSlicing + dD1 * vtDir
-   local ptB = ptA + dD2 * vtDir + dD3 *vtSlicing
-   local ptC = ptB + dD4 * vtSlicing
+   local dBevelX, dBevelY = CalcSectionParams( dStrand, dH)
+   local ptA = ptS - dH * vtSlicing  + ( 0.5 * dStrand - dBevelX) * vtDir
+   local ptB = ptA + dBevelY * vtSlicing + dBevelX * vtDir
+   local ptC = ptB + ( dH - 2 * dBevelY) * vtSlicing
    local ptD = ptA + dH * vtSlicing
-   local ptE = ptD - 2 * dD1 * vtDir 
-   local ptF = ptC - 2 * ( dD1 + dD2) * vtDir
-   local ptG = ptB - 2 * ( dD1 + dD2) * vtDir
-   local ptH = ptA - 2 * dD1 * vtDir 
+   local ptE = ptD - ( dStrand - 2 * dBevelX) * vtDir
+   local ptF = ptC - dStrand * vtDir
+   local ptG = ptB - dStrand * vtDir
+   local ptH = ptA - ( dStrand - 2 * dBevelX) * vtDir
    
    local nId = EgtCurveCompoFromPoints( nSolidGrp, {ptA, ptB, ptC, ptD, ptE, ptF, ptG, ptH, ptA}, GDB_RT.GLOB)
    EgtInvertCurve( nId)
    
-   return nId 
-end
-
----------------------------------------------------------------------
-local function CreateHalfSection( ptS, vtDir, dStrand, dH, vtSlicing, nSolidGrp)
-
-   local dD1, dD2, dD3, dD4 = CalcSectionParams( dStrand, dH)
-   local ptA = ptS - dH * vtSlicing + dD1 * vtDir
-   local ptB = ptA + dD2 * vtDir + dD3 * vtSlicing
-   local ptC = ptB + dD4 * vtSlicing
-   local ptD = ptA + dH * vtSlicing
- 
-   local nId = EgtCurveCompoFromPoints( nSolidGrp, { ptS - dH * vtSlicing, ptA, ptB, ptC, ptD, ptS}, GDB_RT.GLOB)
-   
    return nId
 end
 
@@ -74,30 +61,48 @@ end
 local function CreateSpiralVaseCap( nSectId, vtDir, nSolidGrp)
    
    local vPt = {}
-   for i = 0, 7 do
+   local nLast = EgtIf( s_nSimplifiedSection == 1, 3, 7)
+   for i = 0, nLast do
       vPt[i + 1] = EgtUP( nSectId, i, GDB_ID.ROOT)
    end
    
    local vCrvs = {}
-   vCrvs[1] = EgtArc2PV( nSolidGrp, vPt[1], vPt[2], vtDir, GDB_RT.GLOB)
-   vCrvs[2] = EgtArc2PV( nSolidGrp, vPt[8], vPt[3], vtDir, GDB_RT.GLOB)
-   vCrvs[3] = EgtArc2PV( nSolidGrp, vPt[7], vPt[4], vtDir, GDB_RT.GLOB)
-   vCrvs[4] = EgtArc2PV( nSolidGrp, vPt[6], vPt[5], vtDir, GDB_RT.GLOB)
-   vCrvs[5] = EgtCurveCompo( nSolidGrp, {vCrvs[1]}, false, GDB_RT.GLOB)
-   EgtCloseCurveCompo( vCrvs[5])
-   vCrvs[6] = EgtCurveCompo( nSolidGrp, {vCrvs[4]}, false, GDB_RT.GLOB)
-   EgtCloseCurveCompo( vCrvs[6])
-   local nSurf1 = EgtSurfTmRuled( nSolidGrp, vCrvs[1], vCrvs[2], GDB_RUL.ISOPAR, s_dTol)
-   local nSurf2 = EgtSurfTmRuled( nSolidGrp, vCrvs[2], vCrvs[3], GDB_RUL.ISOPAR, s_dTol)
-   local nSurf3 = EgtSurfTmRuled( nSolidGrp, vCrvs[3], vCrvs[4], GDB_RUL.ISOPAR, s_dTol)
-   local nSurf4 = EgtSurfTmByRegion( nSolidGrp, vCrvs[5], s_dTol)
-   local nSurf5 = EgtSurfTmByRegion( nSolidGrp, vCrvs[6], s_dTol)
-   local nCapSrf = EgtSurfTmBySewing( nSolidGrp, {nSurf1, nSurf2, nSurf3, nSurf4, nSurf5})
-
+   -- calcolo gli archi che definiscono la superficie laterale
+   if s_nSimplifiedSection == 1 then
+      -- sezione quadrata
+      vCrvs[1] = EgtArc2PV( nSolidGrp, vPt[1], vPt[2], vtDir, GDB_RT.GLOB)
+      vCrvs[2] = EgtArc2PV( nSolidGrp, vPt[4], vPt[3], vtDir, GDB_RT.GLOB)
+   else
+      -- sezione ottagonale
+      vCrvs[1] = EgtArc2PV( nSolidGrp, vPt[1], vPt[2], vtDir, GDB_RT.GLOB)
+      vCrvs[2] = EgtArc2PV( nSolidGrp, vPt[8], vPt[3], vtDir, GDB_RT.GLOB)
+      vCrvs[3] = EgtArc2PV( nSolidGrp, vPt[7], vPt[4], vtDir, GDB_RT.GLOB)
+      vCrvs[4] = EgtArc2PV( nSolidGrp, vPt[6], vPt[5], vtDir, GDB_RT.GLOB)
+   end
+   -- creo le rigate
+   local vSurfs = {}
+   for i = 1, #vCrvs - 1 do
+      vSurfs[i] = EgtSurfTmRuled( nSolidGrp, vCrvs[i], vCrvs[i+1], GDB_RUL.ISOPAR, s_dTol)
+   end
+   -- calcolo le superfici top e bottom del cap
+   local nCrvBottom = EgtCurveCompo( nSolidGrp, {vCrvs[1]}, false, GDB_RT.GLOB)
+   EgtCloseCurveCompo( nCrvBottom)
+   local nSurfBottom = EgtSurfTmByRegion( nSolidGrp, nCrvBottom, s_dTol)
+   local nCrvTop = EgtCurveCompo( nSolidGrp, {vCrvs[#vCrvs]}, false, GDB_RT.GLOB)
+   EgtCloseCurveCompo( nCrvTop)
+   local nSurfTop = EgtSurfTmByRegion( nSolidGrp, nCrvTop, s_dTol)
+   table.insert( vSurfs, nSurfTop)
+   table.insert( vSurfs, nSurfBottom)
+   
+   local nCapSrf = EgtSurfTmByTriangles( nSolidGrp, vSurfs)
+   
+   -- cancello curve di costruzione
    for i = 1, #vCrvs do
       EgtErase( vCrvs[i])
    end
-
+   EgtErase( nCrvTop)
+   EgtErase( nCrvBottom)
+   
    return nCapSrf
 end
 
@@ -105,16 +110,21 @@ end
 local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
    
    -- gruppo temporaneo per conti 
-   local nGrpTmp = EgtGroup( nSolidGrp)
+   local nGrpTmp = EgtGroup( nSolidGrp, Frame3d( ORIG(), LayerParams.vtSlicing, GDB_RT.GLOB))
+   
+   -- accorcio leggermente la curva per evitare problemi di inconsistent orientation nel solido
+   local dLen = EgtCurveLength( nCrvId)
+   EgtTrimCurveEndAtLen( nCrvId, dLen - 20 * GEO.EPS_SMALL)
    
    local ptS = EgtSP( nCrvId, GDB_ID.ROOT)
    local vtS = EgtSV( nCrvId, GDB_ID.ROOT)
    local ptE = EgtEP( nCrvId, GDB_ID.ROOT)
    local vtE = EgtEV( nCrvId, GDB_ID.ROOT)
+   local dDelta = ( ptE - ptS) * LayerParams.vtSlicing
    -- appiattisco la curva
    local nCrvCopy = EgtCopyGlob( nCrvId, nGrpTmp)
-   local dDelta = ( ptE - ptS) * LayerParams.vtSlicing
-   EgtSpiralizeCurveAlongExtrusion( nCrvCopy, - dDelta)
+   EgtModifyCurveExtrusion( nCrvCopy, LayerParams.vtSlicing, GDB_RT.GLOB)
+   EgtProjectCurveOnPlane( nCrvCopy, ptS, LayerParams.vtSlicing, GDB_RT.GLOB)
    EgtMergeCurvesInCurveCompo( nCrvCopy)
    EgtChangeClosedCurveStartPoint( nCrvCopy, ptS, GDB_RT.GLOB)
   
@@ -141,12 +151,19 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
       local dMove = ( ptRef - ptS) * LayerParams.vtSlicing
       EgtMove( vCrvs[i+1], LayerParams.vtSlicing * dMove, GDB_RT.GLOB)
       EgtSpiralizeCurveAlongExtrusion( vCrvs[i+1], dDelta)
-      
+
       -- modifico la curva per congiungerla ai caps
-      EgtAddCurveCompoLine( vCrvs[i+1], ptRef, false, GDB_RT.GLOB)
+      EgtApproxCurve( vCrvs[i+1], GDB_CA.LINES, s_dTol)
+      EgtModifyCurveStartPoint( vCrvs[i+1], ptRef, GDB_RT.GLOB)
       local ptRefEnd = EgtUP( nSectE, i, GDB_ID.ROOT)
-      EgtAddCurveCompoLine( vCrvs[i+1], ptRefEnd, true, GDB_RT.GLOB)
+      local _, _, dParMinDist = EgtPointCurveDist( ptRefEnd, vCrvs[i+1], GDB_ID.ROOT)
+      local _, dParE = EgtCurveDomain( vCrvs[i+1])
+      if abs( dParE - dParMinDist) > GEO.EPS_SMALL then
+         EgtTrimCurveEndAtParam( vCrvs[i+1], dParMinDist)
+      end
+      EgtModifyCurveEndPoint( vCrvs[i+1], ptRefEnd, GDB_RT.GLOB)
    end
+   
    local vSurfs = {}
    for i = 1, #vCrvs - 1 do
       vSurfs[i] = EgtSurfTmRuled( nGrpTmp, vCrvs[i], vCrvs[i+1], GDB_RUL.MINDIST, s_dTol)
@@ -156,10 +173,7 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
       end
    end
 
-   local nSrfId = EgtSurfTmBySewing( nSolidGrp, vSurfs)
-   if not nSrfId then
-     nSrfId = EgtSurfTmByTriangles( nSolidGrp, vSurfs)
-   end
+   local nSrfId = EgtSurfTmByTriangles( nSolidGrp, vSurfs)
   
    -- creazione del mezzo disco iniziale
    local nCap1 = CreateSpiralVaseCap( nSectId, - vtS, nSolidGrp)
@@ -170,14 +184,14 @@ local function CreateSpiralVaseSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
    -- cancello le curve usate per la costruzione
    EgtErase( nGrpTmp)
 
-   return EgtSurfTmBySewing( nSolidGrp, { nSrfId, nCap1, nCap2}) or EgtSurfTmByTriangles( nSolidGrp, { nSrfId, nCap1, nCap2})
+   return EgtSurfTmByTriangles( nSolidGrp, { nSrfId, nCap1, nCap2})
 end
 
 ----------------------------------------------------------------------
 local function CreateStandardSolid( nCrvId, nSolidGrp, LayerParams, dStrand)
 
-   local dD1, dD2, dD3, dD4 = CalcSectionParams( dStrand, LayerParams.dLayHeight)
-   local nSrfId = EgtSurfTmRectSwept( nSolidGrp, dStrand, LayerParams.dLayHeight, dD2, dD3, nCrvId, GDB_RSCT.BEVEL, s_dTol)
+   local dBevelX, dBevelY = CalcSectionParams( dStrand, LayerParams.dLayHeight)
+   local nSrfId = EgtSurfTmRectSwept( nSolidGrp, dStrand, LayerParams.dLayHeight, dBevelX, dBevelY, nCrvId, GDB_RSCT.BEVEL, s_dTol)
    return nSrfId
 end
 
@@ -220,6 +234,36 @@ local function CreateDirectionArrow( nCrvId, nSolidGrp, vtSlicing, dStrand, nLay
    
 end
 
+---------------------------------------------------------------------
+local function CreateRecursiveSolid( nCrvId, vSurfs, nSolidGrp, LayerParams, dStrand)
+
+   -- tento la creazione del solido
+   local nSurf = CreateSolid( nCrvId, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)
+   if nSurf then
+      EgtErase( nCrvId)
+      table.insert( vSurfs, nSurf)
+      return true
+   else
+      -- se curva singola esco perchè non è possibile spezzare ulteriormente
+      local _, dParE = EgtCurveDomain( nCrvId)
+      if abs( dParE - 1) < GEO.EPS_SMALL then
+         EgtErase( nCrvId)
+         return false
+      end
+      -- se non si tratta di curva singola, spezzo a metà e tento sulle due sottocurve
+      local dParSplit = floor( dParE / 2 + 0.5)
+      local nCrvSplit = EgtSplitCurveAtParam( nCrvId, dParSplit)
+      if not nCrvSplit then
+         -- errore nello split
+         EgtErase( nCrvId)
+         return false
+      end
+      local bOk = CreateRecursiveSolid( nCrvId, vSurfs, nSolidGrp, LayerParams, dStrand)
+      bOk = bOk and CreateRecursiveSolid( nCrvSplit, vSurfs, nSolidGrp, LayerParams, dStrand)
+      return bOk
+   end
+end
+
 ---------------------------------------------------------------------
 local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
   
@@ -272,44 +316,42 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
       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
-         if nInd < nParts - 1 then
-            local nCopyId = EgtCopy( nGuideId + 1, nGuideId, GDB_IN.AFTER)
-            if nCopyId then
-               local LEN_TRIM = 10
-               local bOk1 = EgtTrimCurveEndAtLen( nCopyId, LEN_TRIM)
-               local bOk2 = EgtAddCurveCompoCurve( nGuideId, nCopyId)
-               local bOk3 = EgtTrimCurveStartAtLen( nGuideId + 1, LEN_TRIM)
-               nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 5 * GEO.EPS_SMALL)
-               if not nSrfId then
-                  nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)
+         -- ritento con strand più piccolo
+         nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)         
+         
+         if not nSrfId then
+            EgtOutLog( 'Warning : CreateSolid_1 failed '.. '(layer '..tostring( nLayer)..', curve '..tostring( nCrvId)..')')
+            -- se non ultima, provo a spostare l'estremità finale
+            if nInd < nParts - 1 then
+               local nCopyId = EgtCopy( nGuideId + 1, nGuideId, GDB_IN.AFTER)
+               if nCopyId then
+                  local LEN_TRIM = 10
+                  local bOk1 = EgtTrimCurveEndAtLen( nCopyId, LEN_TRIM)
+                  local bOk2 = EgtAddCurveCompoCurve( nGuideId, nCopyId)
+                  local bOk3 = EgtTrimCurveStartAtLen( nGuideId + 1, LEN_TRIM)
+                  nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 5 * GEO.EPS_SMALL)
+                  if not nSrfId then
+                     nSrfId = CreateSolid( nGuideId, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)
+                  end
                end
             end
          end
-         -- ritento spezzando la curva
+         
+         -- ritento spezzando la curva in modo ricorsivo fino ad inidividuare delle sottocurve su cui è possibile calcolare il solido
          if not nSrfId then
             EgtOutLog( 'Warning : CreateSolid_2 failed')
             local nGrp = EgtGroup( nSolidGrp, Frame3d( ORIG(), LayerParams.vtSlicing), GDB_RT.GLOB)
             EgtRelocateGlob( nGuideId, nGrp)
             EgtApproxCurve( nGuideId, GDB_CA.LINES, 100 * GEO.EPS_SMALL)
             EgtRelocateGlob( nGuideId, nSolidGrp)
-            local nFirstCrv, nCrvNbr = EgtSplitCurveAtCorners( nGuideId, 30)
-            if nFirstCrv and nCrvNbr > 1 then
-               local nSrfIds = {}
-               for nInd2 = 0, nCrvNbr-1 do
-                  local nSrfId2 = CreateSolid( nFirstCrv + nInd2, nSolidGrp, LayerParams, dStrand - 50 * GEO.EPS_SMALL)
-                  EgtErase( nFirstCrv + nInd2)
-                  if nSrfId2 then
-                     table.insert( nSrfIds, nSrfId2)
-                  end
-               end
-               if #nSrfIds == nCrvNbr then
-                  nSrfId = EgtSurfTmBySewing( nSolidGrp, nSrfIds)
-               else
-                  EgtOutLog( 'Warning : CreateSolid_3 failed')
-               end
-            else
-               EgtErase( nFirstCrv)
+
+            local vSurfs = {}
+            local bOk = CreateRecursiveSolid( nGuideId, vSurfs, nSolidGrp, LayerParams, dStrand)
+            if #vSurfs > 0 then
+               nSrfId = EgtSurfTmByTriangles( nSolidGrp, vSurfs)
+            end
+            if not nSrfId or bOk == false then
+               EgtOutLog( 'Warning : CreateSolid_3 failed')
             end
             EgtErase( nGrp)
          end
@@ -319,7 +361,7 @@ local function CreateSolidFromCurve( nCrvId, nSolidGrp, LayerParams, nLayer)
          EgtSetColor( nSrfId, Color)
          EgtSetInfo( nSrfId, KEY_TYPE, nType)
          EgtSetInfo( nSrfId, KEY_SLICE_NBR, nLayer)
-      else 
+      else
          bOk = false
          EgtOutLog( 'Warning : CreateSolid_Sewing failed')
       end
@@ -334,6 +376,10 @@ function RunCalcSolids.Exec()
 
    -- per determinare il tempo di calcolo
    EgtStartCounter()
+   
+   -- verifico se richiesta sezione semplificata ( rettangolare)
+   local sIniFile = EgtGetIniFile()
+   s_nSimplifiedSection = EgtGetNumberFromIni( 'Solids', 'SimplifiedSection', 0, sIniFile)
 
    local nPartIndex = 1
    local nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. nPartIndex) or EgtGetFirstNameInGroup( GDB_ID.ROOT, PART)

LuaLibs/RunMachParamFromSWCalc.lua

@@ -1,4 +1,4 @@
--- RunMachParamFromSWCalc.lua by Egaltech s.r.l. 2022/12/28
+-- RunMachParamFromSWCalc.lua by Egaltech s.r.l. 2024/01/30
 -- Calcolo dei parametri di stampa
 
 -- Tabella per definizione modulo
@@ -126,44 +126,6 @@ function RunMachParamFromSWCalc.Exec()
             end
             nCrvId = EgtGetNextName( nCrvId, CONTOUR_GRP .. '*')
          end
-
-
-         -- -- rimuovo eventuale info precedente del tempo di attesa
-         -- EgtRemoveInfo( nLayerId, KEY_WAITING_TIME)
-         -- -- calcolo lunghezza totale del layer
-         -- local dTotLayerLength = 0
-         -- local dTotLayerLengthForMass = 0
-         -- local dTotLayerArea = 0
-         -- local nCrvId = EgtGetFirstNameInGroup( nLayerId, CONTOUR_GRP .. '*')
-         -- while nCrvId do
-         --    local nToolPathId = EgtGetFirstNameInGroup( nCrvId, TOOLPATH_GRP)
-         --    -- sommo lunghezze percorsi
-         --    local dTotCrvLength = 0
-         --    local dTotCrvLengthForMass = 0
-         --    local nShellId = EgtGetFirstInGroup( nToolPathId)
-         --    while nShellId do
-         --       dTotCrvLength = dTotCrvLength + EgtCurveLength( nShellId)
-         --       if EgtGetName( nShellId) ~= WIPE_CRV then
-         --          dTotCrvLengthForMass = dTotCrvLengthForMass + EgtCurveLength( nShellId)
-         --       end
-         --       nShellId = EgtGetNext( nShellId)
-         --    end
-         --    dTotLayerLength = dTotLayerLength + dTotCrvLength
-         --    dTotLayerLengthForMass = dTotLayerLengthForMass + dTotCrvLengthForMass
-         --    -- recupero area
-         --    local nOuterCrvId = EgtGetFirstNameInGroup( nCrvId, OUTER_CRV)
-         --    if nOuterCrvId and dStrandCount > 0.5 then
-         --       local _, _, dTotCrvArea = EgtCurveArea( nOuterCrvId)
-         --       local dOuterLength = EgtCurveLength( nOuterCrvId)
-         --       -- recupero offset del part per aggiungerlo all'area interna
-         --       local dOffset = EgtGetInfo( nPartId, KEY_OFFSET_SLICE, 'd')
-         --       dTotCrvArea = dTotCrvArea + ( dOffset * dOuterLength)
-         --       dTotLayerArea = dTotLayerArea + dTotCrvArea
-         --    end
-         --    nCrvId = EgtGetNextName( nCrvId, CONTOUR_GRP .. '*')
-         -- end
-
-
          -- recupero feed del layer
          local dLayerFeed = 0
          local dLayerWait = 0
@@ -192,12 +154,11 @@ function RunMachParamFromSWCalc.Exec()
          for nMeanIndex = 1, #LengthCrvList do
             dStrandMean = dStrandMean + LengthCrvList[nMeanIndex].Width * LengthCrvList[nMeanIndex].Length
          end
-         dStrandMean = dStrandMean / dTotLayerLength
+         dStrandMean = dStrandMean / EgtIf( dTotLayerLength > 0.1, dTotLayerLength, 1)
          -- calcolo costante MF
          local dMF = 1
          local dSC = 1
          if dTotLayerArea > 1 then
-            -- dMF = dTotLayerLength * dStrand / dTotLayerArea * 100
             dMF = dTotLayerLength * dStrandMean / dTotLayerArea * 100
             dSC = dStrandCount
          else
@@ -216,9 +177,9 @@ function RunMachParamFromSWCalc.Exec()
          local dTMin = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.AMin) / MATERIAL.BMin * pow( 0.25 * dStrandMean, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
          local dTTrg = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.ATrg) / MATERIAL.BTrg * pow( 0.25 * dStrandMean, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
          local dTMax = ( MATERIAL.K_LAYERTIME / 100.0) * ( dMF + MATERIAL.AMax) / MATERIAL.BMax * pow( 0.25 * dStrandMean, MATERIAL.KW) * pow( dSliceStep, MATERIAL.KZ) * pow( dSC, MATERIAL.KN)
-         local dFMin = dTotLayerLength / dTMax * 60
-         local dFTrg = dTotLayerLength / dTTrg * 60
-         local dFMax = dTotLayerLength / dTMin * 60
+         local dFMin = dTotLayerLength / EgtIf( dTMax > 0.1, dTMax, 1) * 60
+         local dFTrg = dTotLayerLength / EgtIf( dTTrg > 0.1, dTTrg, 1) * 60
+         local dFMax = dTotLayerLength / EgtIf( dTMin > 0.1, dTMin, 1) * 60
          local dLayerTime = dTTrg
          if dLayerFeed == 0 then
             dLayerFeed = dFTrg
@@ -241,8 +202,10 @@ function RunMachParamFromSWCalc.Exec()
             dSpeed = dSMax
          end
          if not bSpeedOk then
-            dLayerFeed = ( MATERIAL.C1 * pow( ( dSpeed / (( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0))), MATERIAL.C2)) * 1000 / ( ( dStrandMean - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2))
-            dLayerTime = dTotLayerLength / dLayerFeed * 60
+            if dTotLayerLength > 0.1 then
+               dLayerFeed = ( MATERIAL.C1 * pow( ( dSpeed / (( MATERIAL.K_EXTRUSION / 100.0) * ( MACHINING.K / 100.0))), MATERIAL.C2)) * 1000 / ( ( dStrandMean - dSliceStep) * dSliceStep + pi * pow( dSliceStep / 2, 2))
+               dLayerTime = dTotLayerLength / dLayerFeed * 60
+            end
             dLayerWait = floor( dTMin + 0.5) - floor( dLayerTime + 0.5)
          end
          -- calcolo massa dello strato
@@ -276,15 +239,11 @@ function RunMachParamFromSWCalc.Exec()
             EgtSetInfo( nLayerResultId, KEY_WAITING_TIME, dLayerWait)
          end
          -- scrivo valori in struttura dati
-         --local nLayerResultId = EgtGetFirstNameInGroup( nResultLayerId, nLayerIndex)
          EgtSetInfo( nLayerResultId, KEY_TMIN, dTMin)
          EgtSetInfo( nLayerResultId, KEY_TTRG, dTTrg)
          EgtSetInfo( nLayerResultId, KEY_TMAX, dTMax)
          EgtSetInfo( nLayerResultId, KEY_FTRG, dFTrg)
          EgtSetInfo( nLayerResultId, KEY_FMAX, dFeedMax)
-         -- EgtSetInfo( nLayerResultId, KEY_FMIN, dFMin)
-         -- EgtSetInfo( nLayerResultId, KEY_FTRG, dFTrg)
-         -- EgtSetInfo( nLayerResultId, KEY_FMAX, dFMax)
          EgtSetInfo( nLayerResultId, KEY_TCUR, dLayerTime)
          EgtSetInfo( nLayerResultId, KEY_FCUR, dLayerFeed)
          EgtSetInfo( nLayerResultId, KEY_LENGTH, dTotLayerLength)
@@ -296,11 +255,12 @@ function RunMachParamFromSWCalc.Exec()
             EgtEmptyGroup( nResultLayerId)
             return
          end
-         
+         -- passo al layer successivo
          nLayerIndex = nLayerIndex + 1
          nLayerId = EgtGetFirstNameInGroup( nPartId, SLICE_LAYER .. nLayerIndex) or EgtGetFirstNameInGroup( nPartId, "__" .. SLICE_LAYER .. nLayerIndex)
       end
       if nMaxIndex < nLayerIndex then nMaxIndex = nLayerIndex end
+      -- passo al pezzo successivo
       nPartId = EgtGetNextPart( nPartId)
       ::continue::
    end

LuaLibs/RunPrepareExport.lua

@@ -28,56 +28,57 @@ local function CalcCurves( nSliceId, nDestGrp, vtSlicing, dStrandBase)
             if nType ~= TYPE.WIPE then
                local dStrand = EgtGetInfo( nId, KEY_CRV_STRAND, 'd') or dStrandBase
                
-               -- TO DO : da sostituire con offset di Vroni che per curve aperte è la fat curve
+               -- calcolo fat region a partire da una copia della curva ( in questo modo nel DB geometrico non restano
+               -- salvati i diagrammi di Voronoi che non servono per conti futuri)
                local nCopy = EgtCopyGlob( nId, nDestGrp)
-               local nCopyInv = EgtCopyGlob( nId, nDestGrp)
-               EgtInvertCurve( nCopyInv)
-               EgtAddCurveCompoCurve( nCopy, nCopyInv)
-               local nCrv, nCnt = EgtOffsetCurveAdv( nCopy, 0.5 * dStrand)
+               local nSurf = EgtSurfFrFatCurve( nDestGrp, nCopy, 0.5 * dStrand, false)
                -- se fallisce ritento con valore leggermente diverso
-               if not nCrv or nCnt == 0 then
-                  nCrv, nCnt = EgtOffsetCurveAdv( nCopy, 0.5 * dStrand - 0.05)
+               if not nSurf or nSurf == GDB_ID.NULL then
+                  nSurf = EgtSurfFrFatCurve( nDestGrp, nCopy, 0.5 * dStrand - 0.05, false)
                end
-               
-               if nCrv and nCnt > 0 then
-                  -- se sono curve chiuse piccoli aggistamenti per creare un percorso unico
-                  if nCnt > 1 then
-                     for nLoopId = nCrv + 1, nCrv + nCnt - 1 do
-                        EgtInvertCurve( nLoopId)
-                        local dLen = EgtCurveLength( nLoopId)
-                        local dPar1 = EgtCurveParamAtLength( nLoopId, dLen * 0.5)
-                        local dPar2 = EgtCurveParamAtLength( nLoopId, dLen * 0.5 + 2 * GEO.EPS_SMALL)
-                        local ptM = EgtUP( nLoopId, dPar1)
-                        local ptM2 = EgtUP( nLoopId, dPar2)
-                        local _, _, dParRef1 = EgtPointCurveDist( ptM, nCrv)
-                        local _, _, dParRef2 = EgtPointCurveDist( ptM, nCrv)
-                        EgtTrimCurveStartEndAtParam( nCrv, dParRef2, dParRef1)
-                        EgtTrimCurveStartEndAtParam( nLoopId, dPar2, dPar1)
-                        EgtInvertCurve( nLoopId)
-                        EgtAddCurveCompoLine( nCrv, EgtSP( nLoopId))
-                        EgtAddCurveCompoCurve( nCrv, nLoopId)
-                        EgtCloseCurveCompo( nCrv)
+               EgtErase( nCopy)
+                 
+               if nSurf then
+                  local nChunks = EgtSurfFrChunkCount( nSurf)
+                  for k = 0, nChunks - 1 do
+                     -- estraggo i loop associati
+                     local nCrv, nCnt = EgtExtractSurfFrChunkLoops( nSurf, k, nDestGrp)
+                     -- eventuali aggiustamenti per creare un percorso unico
+                     if nCnt > 1 then
+                        for nLoopId = nCrv + 1, nCrv + nCnt - 1 do
+                           local dLen = EgtCurveLength( nLoopId)
+                           local dPar1 = EgtCurveParamAtLength( nLoopId, dLen * 0.5)
+                           local dPar2 = EgtCurveParamAtLength( nLoopId, dLen * 0.5 + 2 * GEO.EPS_SMALL)
+                           local ptM = EgtUP( nLoopId, dPar1)
+                           local ptM2 = EgtUP( nLoopId, dPar2)
+                           local _, _, dParRef1 = EgtPointCurveDist( ptM2, nCrv)
+                           local _, _, dParRef2 = EgtPointCurveDist( ptM, nCrv)
+                           EgtTrimCurveStartEndAtParam( nCrv, dParRef2, dParRef1)
+                           EgtTrimCurveStartEndAtParam( nLoopId, dPar2, dPar1)
+                           EgtAddCurveCompoLine( nCrv, EgtSP( nLoopId))
+                           EgtAddCurveCompoCurve( nCrv, nLoopId)
+                           EgtCloseCurveCompo( nCrv)
+                        end
+                     end
+                     
+                     if nType == TYPE.OUTER_SHELL or nType == TYPE.EXTRA_OUTER_SHELL then 
+                        EgtSetColor( nCrv, EgtStdColor( 'TEAL'))
+                     elseif nType == TYPE.INNER_SHELL or nType == TYPE.EXTRA_SHELL then
+                        EgtSetColor( nCrv, EgtStdColor( 'ORANGE'))
+                     elseif nType == TYPE.LINK then
+                        EgtSetColor( nCrv, EgtStdColor( 'GRAY'))
+                     elseif nType == TYPE.INFILL then
+                        EgtSetColor( nCrv, EgtStdColor( 'YELLOW'))
+                     elseif nType == TYPE.COASTING then
+                        EgtSetColor( nCrv, EgtStdColor( 'BLUE'))
+                     elseif nType == TYPE.RIB then
+                        EgtSetColor( nCrv, EgtStdColor( 'OLIVE'))
+                     elseif nType == TYPE.AUX_SOLID then
+                        EgtSetColor( nCrv, EgtStdColor( 'AQUA'))
                      end
                   end
-                  
-                  if nType == TYPE.OUTER_SHELL or nType == TYPE.EXTRA_OUTER_SHELL then 
-                     EgtSetColor( nCrv, EgtStdColor( 'TEAL'))
-                  elseif nType == TYPE.INNER_SHELL or nType == TYPE.EXTRA_SHELL then
-                     EgtSetColor( nCrv, EgtStdColor( 'ORANGE'))
-                  elseif nType == TYPE.LINK then
-                     EgtSetColor( nCrv, EgtStdColor( 'GRAY'))
-                  elseif nType == TYPE.INFILL then
-                     EgtSetColor( nCrv, EgtStdColor( 'YELLOW'))
-                  elseif nType == TYPE.COASTING then
-                     EgtSetColor( nCrv, EgtStdColor( 'BLUE'))
-                  elseif nType == TYPE.RIB then
-                     EgtSetColor( nCrv, EgtStdColor( 'OLIVE'))
-                  elseif nType == TYPE.AUX_SOLID then
-                     EgtSetColor( nCrv, EgtStdColor( 'AQUA'))
-                  end
+                  EgtErase( nSurf)
                end
-               
-               EgtErase( nCopy)
             end
             
             nId = EgtGetNext( nId)
@@ -117,7 +118,7 @@ end
 
 ------------------------------------------------------------------
 function RunPrepareExport.Exec()
-   
+
    local nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. '*')
    if not nPartId then 
       EgtOutBox( 'Error : no part', 'Export')
@@ -183,7 +184,7 @@ function RunPrepareExport.Exec()
    end
 
    for i = 1, #vSlices do
-      
+     
       -- creo il gruppo corrispondente
       local nDestGrp = EgtGroup( nGrp)
       EgtSetName( nDestGrp, EgtGetName( vSlices[i]))

Version.lua

@@ -1,4 +1,4 @@
--- Version.lua by Egaltech s.r.l. 2023/10/02
+-- Version.lua by Egaltech s.r.l. 2024/05/06
 -- Gestione della versione di 3dPrinting
 
-VERSION = '2.5l1'
+VERSION = '2.6g2'